[CORE] Clamp pre post processing (#29446)

### Details:
- add clamp operator for pre post processing

### Tickets:
 - [*161080*](https://jira.devtools.intel.com/browse/CVS-161080)

---------

Co-authored-by: Diya910 <[email protected]>
Co-authored-by: Diya910 <[email protected]>
Co-authored-by: Pawel Raasz <[email protected]>
Co-authored-by: Michal Lukaszewski <[email protected]>

Author: 4 people

src/core/include/openvino/core/preprocess/postprocess_steps.hpp

@@ -33,6 +33,13 @@ class OPENVINO_API PostProcessSteps final {
     /// \brief Default destructor
     ~PostProcessSteps();
 
+    /// \brief Add clamp postprocess operation. Clamp each element of input to the specified range [min_value,max_value]
+    /// \param min_value Minimum value to clamp to.
+    /// \param max_value Maximum value to clamp to.
+    ///
+    /// \return Reference to 'this' to allow chaining with other calls in a builder-like manner
+    PostProcessSteps& clamp(double min_value, double max_value);
+
     /// \brief Add convert element type post-process operation
     ///
     /// \param type Desired type of output. If not specified, type will be obtained from 'tensor' output information

src/core/include/openvino/core/preprocess/preprocess_steps.hpp

@@ -36,6 +36,14 @@ class OPENVINO_API PreProcessSteps final {
     /// \brief Default destructor
     ~PreProcessSteps();
 
+    /// \brief Add clamp preprocess operation. Clamp each element of input to the specified range [min_value, max_value]
+    ///
+    /// \param min_value Minimum value to clamp to.
+    /// \param max_value Maximum value to clamp to.
+    ///
+    /// \return Reference to 'this' to allow chaining with other calls in a builder-like manner
+    PreProcessSteps& clamp(double min_value, double max_value);
+
     /// \brief Add convert element type preprocess operation
     ///
     /// \param type Desired type of input.

src/core/src/preprocess/pre_post_process.cpp

@@ -379,6 +379,11 @@ InputTensorInfo& InputTensorInfo::set_from(const ov::Tensor& runtime_tensor) {
 PreProcessSteps::PreProcessSteps() : m_impl(std::unique_ptr<PreProcessStepsImpl>(new PreProcessStepsImpl())) {}
 PreProcessSteps::~PreProcessSteps() = default;
 
+PreProcessSteps& PreProcessSteps::clamp(double min_value, double max_value) {
+    m_impl->add_clamp(min_value, max_value);
+    return *this;
+}
+
 PreProcessSteps& PreProcessSteps::scale(float value) {
     m_impl->add_scale_impl(std::vector<float>{value});
     return *this;
@@ -508,6 +513,11 @@ OutputModelInfo& OutputModelInfo::set_color_format(const ov::preprocess::ColorFo
 PostProcessSteps::PostProcessSteps() : m_impl(std::unique_ptr<PostProcessStepsImpl>(new PostProcessStepsImpl())) {}
 PostProcessSteps::~PostProcessSteps() = default;
 
+PostProcessSteps& PostProcessSteps::clamp(double min_value, double max_value) {
+    m_impl->add_clamp(min_value, max_value);
+    return *this;
+}
+
 PostProcessSteps& PostProcessSteps::convert_element_type(const element::Type& type) {
     m_impl->add_convert_impl(type);
     return *this;

src/core/src/preprocess/preprocess_steps_impl.cpp

@@ -99,6 +99,25 @@ void PreStepsList::add_scale_impl(const std::vector<float>& values) {
         "scale " + vector_to_string(values));
 }
 
+void PreStepsList::add_clamp(double min_value, double max_value) {
+    std::stringstream name_builder;
+    name_builder << "clamp(min " << min_value << ", max " << max_value << ")";
+
+    m_actions.emplace_back(
+        [min_value, max_value](const std::vector<Output<Node>>& nodes,
+                               const std::shared_ptr<Model>& function,
+                               PreprocessingContext& ctxt) {
+            OPENVINO_ASSERT(nodes.size() == 1,
+                            "Can't apply clamp to multi-plane input. Suggesting to convert current image to "
+                            "RGB/BGR color format using 'PreProcessSteps::convert_color'");
+
+            const auto& node = nodes.front();
+            auto clamp_op = std::make_shared<ov::op::v0::Clamp>(node, min_value, max_value);
+            return std::make_tuple(std::vector<Output<Node>>{clamp_op}, true);
+        },
+        name_builder.str());
+}
+
 void PreStepsList::add_mean_impl(const std::vector<float>& values) {
     m_actions.emplace_back(
         [values](const std::vector<Output<Node>>& nodes,
@@ -688,6 +707,18 @@ std::tuple<std::vector<Output<Node>>, bool> PreStepsList::cut_last_channel(const
 }
 
 //------------- Post processing ------
+void PostStepsList::add_clamp(double min_value, double max_value) {
+    std::stringstream name_builder;
+    name_builder << "clamp(min " << min_value << ", max " << max_value << ")";
+
+    m_actions.emplace_back(
+        [min_value, max_value](const Output<Node>& node, PostprocessingContext& ctxt) {
+            auto clamp_op = std::make_shared<ov::op::v0::Clamp>(node, min_value, max_value);
+            return std::make_tuple(Output<Node>{clamp_op}, true);
+        },
+        name_builder.str());
+}
+
 void PostStepsList::add_convert_impl(const element::Type& type) {
     m_actions.emplace_back(
         [type](const Output<Node>& node, PostprocessingContext& ctxt) {

src/core/src/preprocess/preprocess_steps_impl.hpp

@@ -157,6 +157,7 @@ struct InternalPreprocessAction {
 class PreStepsList {
 public:
     void add_scale_impl(const std::vector<float>& values);
+    void add_clamp(double min_value, double max_value);
     void add_mean_impl(const std::vector<float>& values);
     void add_pad_impl(const std::vector<int>& pads_begin,
                       const std::vector<int>& pads_end,
@@ -220,6 +221,7 @@ struct InternalPostprocessAction {
 /// \brief PostProcessStepsImpl - internal data structure
 class PostStepsList {
 public:
+    void add_clamp(double min_value, double max_value);
     void add_convert_impl(const element::Type& type);
     void add_convert_layout_impl(const Layout& layout);
     void add_convert_layout_impl(const std::vector<uint64_t>& dims);

src/core/tests/preprocess.cpp

@@ -60,11 +60,10 @@ static std::shared_ptr<Model> create_conv(element::Type in_type, const PartialSh
     return std::make_shared<Model>(ResultVector{res}, ParameterVector{data1});
 }
 
-template <int N>
-static std::shared_ptr<Model> create_n_inputs(element::Type type, const PartialShape& shape) {
+static std::shared_ptr<Model> create_n_inputs(int N, element::Type type, const PartialShape& shape) {
     ResultVector res;
     ParameterVector params;
-    for (size_t i = 0; i < N; i++) {
+    for (int i = 0; i < N; i++) {
         auto index_str = std::to_string(i);
         auto data1 = std::make_shared<op::v0::Parameter>(type, shape);
         data1->set_friendly_name("input" + index_str);
@@ -80,6 +79,21 @@ static std::shared_ptr<Model> create_n_inputs(element::Type type, const PartialS
     return std::make_shared<Model>(res, params);
 }
 
+static std::shared_ptr<Model> create_no_inputs(element::Type type) {
+    ResultVector res;
+    ParameterVector params;
+    auto index_str = std::to_string(0);
+    auto data1 = std::make_shared<op::v0::Constant>(type, Shape{}, 1);
+    data1->set_friendly_name("input" + index_str);
+    data1->get_output_tensor(0).set_names({"tensor_input" + index_str});
+    auto res1 = std::make_shared<op::v0::Result>(data1);
+    res1->set_friendly_name("Result" + index_str);
+    res1->get_output_tensor(0).set_names({"tensor_output" + index_str});
+    res.push_back(res1);
+
+    return std::make_shared<Model>(res, params);
+}
+
 namespace {
 void set_model_as_v10(ov::Model& model) {
     model.get_rt_info()["version"] = static_cast<int64_t>(10);
@@ -110,6 +124,70 @@ TEST(pre_post_process, simple_mean_scale_getters_f64) {
     EXPECT_EQ(f->get_output_element_type(0), element::f64);
 }
 
+TEST(pre_post_process, clamp_operation_on_input_preprocess) {
+    auto model = create_simple_function(element::f32, Shape{1, 3, 2, 2});
+
+    {
+        auto input_node = model->get_parameters().front();
+        auto connected_node = input_node->output(0).get_target_inputs().begin()->get_node();
+        EXPECT_STREQ(connected_node->get_type_name(), "Relu");
+    }
+    auto p = PrePostProcessor(model);
+    p.input().preprocess().clamp(0.0, 1.0);
+    model = p.build();
+    {
+        auto input_node = model->get_parameters().front();
+        auto connected_node = input_node->output(0).get_target_inputs().begin()->get_node();
+        EXPECT_STREQ(connected_node->get_type_name(), "Clamp");
+    }
+}
+
+TEST(pre_post_process, clamp_operation_on_input_preprocess_throw_no_input) {
+    auto model = create_no_inputs(element::f32);
+
+    {
+        auto input_node = model->get_ordered_ops().front();
+        auto connected_node = input_node->output(0).get_target_inputs().begin()->get_node();
+        EXPECT_STREQ(connected_node->get_type_name(), "Result");
+    }
+
+    auto p = PrePostProcessor(model);
+
+    EXPECT_ANY_THROW(p.input().preprocess().clamp(0.0, 1.0); model = p.build());
+}
+
+TEST(pre_post_process, clamp_operation_on_input_preprocess_throw_more_than_one_input) {
+    auto model = create_n_inputs(2, element::f32, Shape{1, 3, 2, 2});
+
+    {
+        auto input_node = model->get_parameters().front();
+        auto connected_node = input_node->output(0).get_target_inputs().begin()->get_node();
+        EXPECT_STREQ(connected_node->get_type_name(), "Relu");
+    }
+
+    auto p = PrePostProcessor(model);
+
+    EXPECT_ANY_THROW(p.input().preprocess().clamp(0.0, 1.0); model = p.build());
+}
+
+TEST(pre_post_process, clamp_operation_on_output_postprocess) {
+    auto model = create_simple_function(element::f32, Shape{1, 3, 2, 2});
+
+    {
+        auto result_node = model->get_results().front();
+        auto connected_node = result_node->input_value(0).get_node_shared_ptr();
+        EXPECT_STREQ(connected_node->get_type_name(), "Relu");
+    }
+    auto p = PrePostProcessor(model);
+    p.output().postprocess().clamp(0.0, 1.0);
+    model = p.build();
+    {
+        auto result_node = model->get_results().front();
+        auto connected_node = result_node->input_value(0).get_node_shared_ptr();
+        EXPECT_STREQ(connected_node->get_type_name(), "Clamp");
+    }
+}
+
 TEST(pre_post_process, convert_element_type_and_scale) {
     auto f = create_simple_function(element::i8, Shape{1, 3, 2, 2});
     auto p = PrePostProcessor(f);
@@ -198,7 +276,7 @@ TEST(pre_post_process, empty_preprocess) {
 }
 
 TEST(pre_post_process, preprocess_assert_input_without_index) {
-    auto f = create_n_inputs<2>(element::f32, Shape{1, 3, 2, 2});
+    auto f = create_n_inputs(2, element::f32, Shape{1, 3, 2, 2});
     auto p = PrePostProcessor(f);
     EXPECT_ANY_THROW(p.input().preprocess().mean(0.f); f = p.build());
     EXPECT_ANY_THROW(p.input("some_non_existing_name").preprocess().mean(0.f); f = p.build());
@@ -612,7 +690,7 @@ TEST(pre_post_process, convert_color_incorrect_subnames) {
 }
 
 TEST(pre_post_process, convert_color_duplicate_subnames) {
-    auto f = create_n_inputs<2>(element::f32, PartialShape{1, 2, 2, 3});
+    auto f = create_n_inputs(2, element::f32, PartialShape{1, 2, 2, 3});
     f->get_parameters()[0]->get_output_tensor(0).set_names({"tensor_input1"});
     f->get_parameters()[1]->get_output_tensor(0).set_names({"tensor_input1/CustomUV"});
     auto p = PrePostProcessor(f);
@@ -670,7 +748,7 @@ TEST(pre_post_process, convert_layout_implicit_several_time) {
 }
 
 TEST(pre_post_process, tensor_set_layout) {
-    auto f = create_n_inputs<6>(element::f32, Shape{1, 3, 480, 640});
+    auto f = create_n_inputs(6, element::f32, Shape{1, 3, 480, 640});
     PrePostProcessor preprocessor(f);
     preprocessor.input(0).tensor().set_layout("NCHW");
     preprocessor.input(0).preprocess().mean({1.0, 2.0, 3.0});
@@ -709,7 +787,7 @@ TEST(pre_post_process, tensor_set_layout) {
 }
 
 TEST(pre_post_process, postprocess_set_model_layout) {
-    auto f = create_n_inputs<2>(element::f32, Shape{1, 3, 224, 224});
+    auto f = create_n_inputs(2, element::f32, Shape{1, 3, 224, 224});
     PrePostProcessor p(f);
     p.output(0).model().set_layout("NCHW");
     p.output(0).postprocess().convert_layout("NHWC");
@@ -790,7 +868,7 @@ TEST(pre_post_process, custom_preprocessing) {
 }
 
 TEST(pre_post_process, test_2_inputs_basic) {
-    auto f = create_n_inputs<2>(element::f32, Shape{1, 3, 1, 1});
+    auto f = create_n_inputs(2, element::f32, Shape{1, 3, 1, 1});
     auto p = PrePostProcessor(f);
     p.input(1).preprocess().mean(1.f).scale(2.0f);
     f = p.build();
@@ -1196,7 +1274,7 @@ TEST(pre_post_process, preprocess_convert_layout_invalid_dims_dyn_shape) {
 }
 
 TEST(pre_post_process, preprocess_convert_layout_partially_defined) {
-    auto f = create_n_inputs<8>(element::f32, Shape{1, 2, 3, 4, 5});
+    auto f = create_n_inputs(8, element::f32, Shape{1, 2, 3, 4, 5});
 
     auto p = PrePostProcessor(f);
     p.input(0).tensor().set_layout("nc???");
@@ -1235,7 +1313,7 @@ TEST(pre_post_process, preprocess_convert_layout_partially_defined) {
 }
 
 TEST(pre_post_process, preprocess_convert_layout_partially_defined_trivial) {
-    auto f = create_n_inputs<4>(element::f32, Shape{1, 2, 3, 4, 5});
+    auto f = create_n_inputs(4, element::f32, Shape{1, 2, 3, 4, 5});
     auto ops_num = f->get_ordered_ops().size();
 
     auto p = PrePostProcessor(f);
@@ -1261,7 +1339,7 @@ TEST(pre_post_process, preprocess_convert_layout_partially_defined_trivial) {
 }
 
 TEST(pre_post_process, preprocess_convert_layout_squeeze) {
-    auto f = create_n_inputs<3>(element::f32, Shape{1, 3, 1, 480, 640});
+    auto f = create_n_inputs(3, element::f32, Shape{1, 3, 1, 480, 640});
     auto p = PrePostProcessor(f);
 
     p.input(0).tensor().set_layout("HWC");
@@ -1283,7 +1361,7 @@ TEST(pre_post_process, preprocess_convert_layout_squeeze) {
 }
 
 TEST(pre_post_process, preprocess_convert_layout_squeeze_dynamic) {
-    auto f = create_n_inputs<2>(element::f32, PartialShape{Dimension::dynamic(), 3, 1, 480, 640});
+    auto f = create_n_inputs(2, element::f32, PartialShape{Dimension::dynamic(), 3, 1, 480, 640});
     auto p = PrePostProcessor(f);
 
     p.input(0).tensor().set_layout("HWC");
@@ -1300,7 +1378,7 @@ TEST(pre_post_process, preprocess_convert_layout_squeeze_dynamic) {
 }
 
 TEST(pre_post_process, preprocess_convert_layout_squeeze_unsupported) {
-    auto f = create_n_inputs<1>(element::f32, PartialShape{Dimension::dynamic(), 3, 1, 480, 640});
+    auto f = create_n_inputs(1, element::f32, PartialShape{Dimension::dynamic(), 3, 1, 480, 640});
     EXPECT_THROW(
         {
             auto p = PrePostProcessor(f);
@@ -1490,7 +1568,7 @@ TEST(pre_post_process, preprocess_from) {
 }
 
 TEST(pre_post_process, preprocess_crop) {
-    auto model = create_n_inputs<1>(element::f32, PartialShape::dynamic());
+    auto model = create_n_inputs(1, element::f32, PartialShape::dynamic());
     auto p = PrePostProcessor(model);
 
     p.input().tensor().set_shape(Shape{1, 3, 200, 400});
@@ -1513,7 +1591,7 @@ TEST(pre_post_process, preprocess_crop) {
 }
 
 TEST(pre_post_process, preprocess_crop_wrong_dims) {
-    auto model = create_n_inputs<1>(element::f32, PartialShape::dynamic());
+    auto model = create_n_inputs(1, element::f32, PartialShape::dynamic());
     auto p = PrePostProcessor(model);
 
     p.input().tensor().set_shape(Shape{1, 3, 200, 400});
@@ -1533,7 +1611,7 @@ TEST(pre_post_process, preprocess_crop_wrong_dims) {
 }
 
 TEST(pre_post_process, preprocess_crop_wrong_dims_not_aligned) {
-    auto model = create_n_inputs<1>(element::f32, PartialShape{1, 3, 100, 200});
+    auto model = create_n_inputs(1, element::f32, PartialShape{1, 3, 100, 200});
     auto p = PrePostProcessor(model);
 
     p.input().tensor().set_shape(Shape{1, 3, 200});
@@ -1611,7 +1689,7 @@ TEST(pre_post_process, trivial_model_convert_element_type_explicit) {
 }
 
 TEST(pre_post_process, postprocess_convert_element_type_default) {
-    auto f = create_n_inputs<2>(element::f32, Shape{1, 3, 2, 2});
+    auto f = create_n_inputs(2, element::f32, Shape{1, 3, 2, 2});
     auto name = f->output(1).get_node_shared_ptr()->get_friendly_name();
     auto name_last_op = f->get_results().front()->get_input_source_output(0).get_node_shared_ptr()->get_friendly_name();
     auto tensor_names = f->output(1).get_tensor().get_names();
@@ -1657,7 +1735,7 @@ TEST(pre_post_process, postprocess_convert_element_type_implicit) {
 }
 
 TEST(pre_post_process, preprocess_keep_params_order) {
-    auto f = create_n_inputs<3>(element::f32, Shape{1, 2, 2, 3});
+    auto f = create_n_inputs(3, element::f32, Shape{1, 2, 2, 3});
     auto p = PrePostProcessor(f);
 
     p.input(1).tensor().set_color_format(ColorFormat::NV12_TWO_PLANES, {"Y", "UV"});
@@ -1726,7 +1804,7 @@ TEST(pre_post_process, postprocess_set_model_layout_when_already_exists) {
 }
 
 TEST(pre_post_process, postprocess_convert_layout_explicit_no_target) {
-    auto f = create_n_inputs<2>(element::f32, Shape{1, 3, 2, 2});
+    auto f = create_n_inputs(2, element::f32, Shape{1, 3, 2, 2});
     auto p = PrePostProcessor(f);
 
     p.output(1).model().set_layout("NCHW");
@@ -2033,14 +2111,14 @@ TEST(pre_post_process, postprocess_implicit_convert_element_type_and_layout) {
 }
 
 TEST(pre_post_process, postprocess_assert_output_without_index) {
-    auto f = create_n_inputs<2>(element::f32, Shape{1, 3, 2, 2});
+    auto f = create_n_inputs(2, element::f32, Shape{1, 3, 2, 2});
     auto p = PrePostProcessor(f);
     EXPECT_ANY_THROW(p.output().tensor().set_element_type(element::f32); p.build());
     EXPECT_ANY_THROW(p.output("some_non_existing_name").tensor().set_element_type(element::f32); p.build());
 }
 
 TEST(pre_post_process, postprocess_keep_results_order) {
-    auto f = create_n_inputs<3>(element::f32, Shape{1, 3, 2, 2});
+    auto f = create_n_inputs(3, element::f32, Shape{1, 3, 2, 2});
     auto names0 = f->output(0).get_tensor().get_names();
     auto names1 = f->output(1).get_tensor().get_names();
     auto names2 = f->output(2).get_tensor().get_names();
@@ -2244,7 +2322,7 @@ TEST(pre_post_process, postprocess_nothing_applied) {
 }
 
 TEST(pre_post_process, exception_safety) {
-    auto f = create_n_inputs<2>(element::f32, Shape{1, 3, 224, 224});
+    auto f = create_n_inputs(2, element::f32, Shape{1, 3, 224, 224});
     auto name0 = f->input(0).get_node_shared_ptr()->get_friendly_name();
     auto tensor_names0 = f->input(0).get_tensor().get_names();
     auto name1 = f->input(1).get_node_shared_ptr()->get_friendly_name();