[TF FE] Fix centernet and correct FloorDiv translator for signed integer type

src/common/transformations/include/transformations/rt_info/disable_fp16_compression.hpp

@@ -39,7 +39,7 @@ class TRANSFORMATIONS_API DisableFP16Compression : public RuntimeAttribute {
     }
 
     bool is_copyable() const override {
-        return false;
+        return true;
     }
 };
 

src/common/transformations/src/transformations/fp16_compression/mark_subgraphs_to_keep_in_mixed_precision.cpp

@@ -13,6 +13,7 @@
 #include "openvino/op/divide.hpp"
 #include "openvino/op/exp.hpp"
 #include "openvino/op/fake_quantize.hpp"
+#include "openvino/op/floor.hpp"
 #include "openvino/op/interpolate.hpp"
 #include "openvino/op/max_pool.hpp"
 #include "openvino/op/maximum.hpp"
@@ -423,6 +424,35 @@ class PropagateDownDisableSensitivityForQuantized : public pass::MatcherPass {
     }
 };
 
+/* FloorDiv should be kept in fp32 precision for better accuracy
+   when it accepts large values (> fp16_max).
+*/
+class MarkFloorDiv : public pass::MatcherPass {
+public:
+    OPENVINO_RTTI("MarkFloorDiv", "0");
+    MarkFloorDiv() {
+        MATCHER_SCOPE(MarkFloorDiv);
+        // FloorDiv is repesented either as:
+        // Floor(Div(input_1, input_2))
+        // Floor(Mul(input_1, inversed_const_input_2)), if input_2 is constant
+        auto div_mul_pattern = pattern::wrap_type<ov::op::v1::Divide, ov::op::v1::Multiply>();
+        auto floor_pattern = pattern::wrap_type<ov::op::v0::Floor>({div_mul_pattern});
+
+        matcher_pass_callback callback = [=](pattern::Matcher& m) {
+            const auto& node = m.get_match_root();
+            if (!node)
+                return false;
+            disable_fp16_compression(node);
+            disable_fp16_compression(node->input_value(0).get_node_shared_ptr());
+
+            return true;
+        };
+
+        auto m = make_shared<pattern::Matcher>(floor_pattern, matcher_name);
+        register_matcher(m, callback);
+    }
+};
+
 bool MarkSugraphsToKeepInMixedPrecision::run_on_model(const shared_ptr<ov::Model>& m) {
     RUN_ON_MODEL_SCOPE(MarkSugraphsToKeepInMixedPrecision);
 
@@ -432,6 +462,8 @@ bool MarkSugraphsToKeepInMixedPrecision::run_on_model(const shared_ptr<ov::Model
     REGISTER_PASS(manager, MarkExpInReduceOpPath)
     REGISTER_PASS(manager, PropagateDownDisableSensitivityForQuantized)
 
+    REGISTER_PASS(manager, MarkFloorDiv)
+
     // both Up and Down propagations are needed.
     // Why both of them are needed is explained in comments in passes declarations.
     REGISTER_PASS(manager, PropagateDownMarkToKeepInMixedPrecision)

src/common/transformations/tests/common_optimizations/mark_subgraph_to_keep_in_mixed_precision_test.cpp

@@ -1269,3 +1269,82 @@ TEST(TransformationTests, MarkDivWithEpsToKeepInMixedPrecision_disable_for_quant
     result = fc(model, model_ref);
     ASSERT_TRUE(result.valid) << result.message;
 }
+
+TEST(TransformationTests, keep_floor_div_1) {
+    shared_ptr<Model> model, model_ref;
+    pass::Manager manager;
+    {
+        auto input_1 = make_shared<Parameter>(element::f32, Shape{1, 1000});
+        auto input_2 = make_shared<Parameter>(element::f32, Shape{1000});
+
+        auto div_1 = make_shared<Divide>(input_1, input_2);
+        auto floor_1 = make_shared<Floor>(div_1);
+
+        model = make_shared<Model>(NodeVector{floor_1}, ParameterVector{input_1, input_2});
+
+        manager.register_pass<pass::MarkSugraphsToKeepInMixedPrecision>();
+        manager.run_passes(model);
+    }
+
+    {
+        auto input_1 = make_shared<Parameter>(element::f32, Shape{1, 1000});
+        auto input_2 = make_shared<Parameter>(element::f32, Shape{1000});
+
+        auto div_1 = make_shared<Divide>(input_1, input_2);
+        auto floor_1 = make_shared<Floor>(div_1);
+
+        // marking nodes to be kept in fp32 for mixed precision
+        disable_fp16_compression(div_1);
+        disable_fp16_compression(floor_1);
+
+        model_ref = make_shared<Model>(NodeVector{floor_1}, ParameterVector{input_1, input_2});
+    }
+
+    const FunctionsComparator func_comparator =
+        FunctionsComparator::with_default().enable(FunctionsComparator::RUNTIME_KEYS);
+    // need to compare twice to ensure that no extra nodes are marked
+    FunctionsComparator::Result result = func_comparator(model_ref, model);
+    ASSERT_TRUE(result.valid) << result.message;
+    result = func_comparator(model, model_ref);
+    ASSERT_TRUE(result.valid) << result.message;
+}
+
+TEST(TransformationTests, keep_floor_div_2) {
+    shared_ptr<Model> model, model_ref;
+    pass::Manager manager;
+    {
+        auto input_1 = make_shared<Parameter>(element::f32, Shape{1, 100});
+        auto const_input_2 = Constant::create(element::f32, Shape{100}, {100000});
+
+        auto mul_1 = make_shared<Multiply>(input_1, const_input_2);
+        auto floor_1 = make_shared<Floor>(mul_1);
+
+        model = make_shared<Model>(NodeVector{floor_1}, ParameterVector{input_1});
+
+        manager.register_pass<pass::MarkSugraphsToKeepInMixedPrecision>();
+        manager.run_passes(model);
+    }
+
+    {
+        auto input_1 = make_shared<Parameter>(element::f32, Shape{1, 100});
+        auto const_input_2 = Constant::create(element::f32, Shape{100}, {100000});
+
+        auto mul_1 = make_shared<Multiply>(input_1, const_input_2);
+        auto floor_1 = make_shared<Floor>(mul_1);
+
+        // marking nodes to be kept in fp32 for mixed precision
+        disable_fp16_compression(mul_1);
+        disable_fp16_compression(floor_1);
+        disable_fp16_compression(const_input_2);
+
+        model_ref = make_shared<Model>(NodeVector{floor_1}, ParameterVector{input_1});
+    }
+
+    const FunctionsComparator func_comparator =
+        FunctionsComparator::with_default().enable(FunctionsComparator::RUNTIME_KEYS);
+    // need to compare twice to ensure that no extra nodes are marked
+    FunctionsComparator::Result result = func_comparator(model_ref, model);
+    ASSERT_TRUE(result.valid) << result.message;
+    result = func_comparator(model, model_ref);
+    ASSERT_TRUE(result.valid) << result.message;
+}

src/core/src/graph_util.cpp

@@ -20,6 +20,7 @@
 #include "transformations/common_optimizations/compress_float_constants.hpp"
 #include "transformations/common_optimizations/fused_names_cleanup.hpp"
 #include "transformations/common_optimizations/mark_precision_sensitive_shapeof_subgraphs.hpp"
+#include "transformations/fp16_compression/mark_subgraphs_to_keep_in_mixed_precision.hpp"
 
 namespace {
 
@@ -331,6 +332,7 @@ void serialize(const std::shared_ptr<const ov::Model>& m,
 void save_model(const std::shared_ptr<const ov::Model>& m, const std::string& output_model, bool compress_to_fp16) {
     ov::pass::Manager manager;
     if (compress_to_fp16) {
+        manager.register_pass<ov::pass::MarkSugraphsToKeepInMixedPrecision>();
         manager.register_pass<ov::pass::MarkPrecisionSensitiveConstants>();
         manager.register_pass<ov::pass::CompressFloatConstants>(/*postponed=*/true);
     }

tests/layer_tests/tensorflow_tests/test_tf_FloorDiv.py

@@ -5,7 +5,6 @@
 import pytest
 
 from common.tf_layer_test_class import CommonTFLayerTest
-from common.utils.tf_utils import permute_nchw_to_nhwc
 
 
 class TestFloorDiv(CommonTFLayerTest):
@@ -17,9 +16,8 @@ def create_add_placeholder_const_net(self, x_shape, dtype, ir_version, use_new_f
         # Create the graph and model
         with tf.compat.v1.Session() as sess:
             x = tf.compat.v1.placeholder(dtype, x_shape, 'Input')
-            constant_value = np.array(-10).astype(dtype)
+            constant_value = np.array(-256).astype(dtype)
             y = tf.constant(constant_value)
-            x = tf.raw_ops.Abs(x=x)
             res = tf.raw_ops.FloorDiv(x=x, y=y)
 
             tf.compat.v1.global_variables_initializer()
@@ -28,13 +26,19 @@ def create_add_placeholder_const_net(self, x_shape, dtype, ir_version, use_new_f
         ref_net = None
 
         return tf_net, ref_net
-
+
+    def _prepare_input(self, inputs_dict):
+        for input in inputs_dict.keys():
+            inputs_dict[input] = np.random.randint(-100000, 100000, inputs_dict[input]).astype(np.float32)
+        return inputs_dict
+
     # TODO: implement tests for 2 Consts + Add
 
     test_data_1D = [
         dict(x_shape=[], dtype=np.int32),
         dict(x_shape=[2], dtype=np.int64),
         dict(x_shape=[2, 4, 5], dtype=np.int32),
+        dict(x_shape=[2, 1000], dtype=np.int32),
         dict(x_shape=[], dtype=np.float32),
         dict(x_shape=[2], dtype=np.float64),
         dict(x_shape=[2, 4, 5], dtype=np.float32),