fix TS for Interpolate + codestyle

src/common/transformations/src/transformations/common_optimizations/transpose_sinking_binary.cpp

@@ -2,6 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "transformations/common_optimizations/transpose_sinking_binary.hpp"
+
 #include <openvino/opsets/opset10.hpp>
 #include <openvino/pass/pattern/op/or.hpp>
 
@@ -9,7 +11,6 @@
 #include "openvino/op/util/op_types.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "transformations/common_optimizations/transpose_sinking_utils.hpp"
-#include "transformations/common_optimizations/transpose_sinking_binary.hpp"
 #include "transformations/rt_info/transpose_sinking_attr.hpp"
 
 using namespace ov::pass::pattern;

src/common/transformations/src/transformations/common_optimizations/transpose_sinking_data_movement.cpp

@@ -23,7 +23,8 @@ ov::pass::TransposeSinkingDataMovementForward::TransposeSinkingDataMovementForwa
     MATCHER_SCOPE(TransposeSinkingDataMovementForward);
     auto const_label = wrap_type<Constant>();
     auto transpose_label = wrap_type<Transpose>({any_input(), const_label});
-    auto main_node_label = wrap_type<Pad, BatchToSpace, SpaceToBatch>({transpose_label, any_input(), any_input(), any_input()});
+    auto main_node_label =
+        wrap_type<Pad, BatchToSpace, SpaceToBatch>({transpose_label, any_input(), any_input(), any_input()});
 
     matcher_pass_callback matcher_pass_callback = [=](Matcher& m) {
         const auto& pattern_to_node = m.get_pattern_map();

src/common/transformations/src/transformations/common_optimizations/transpose_sinking_fuse.cpp

@@ -8,9 +8,9 @@
 #include <vector>
 
 #include "itt.hpp"
+#include "openvino/core/validation_util.hpp"
 #include "openvino/opsets/opset10.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
-#include "openvino/core/validation_util.hpp"
 #include "transformations/common_optimizations/transpose_sinking_utils.hpp"
 #include "transformations/utils/utils.hpp"
 
@@ -19,13 +19,11 @@ using namespace opset10;
 
 ov::pass::TransposeFuse::TransposeFuse() {
     MATCHER_SCOPE(TransposeFuse);
-    auto transpose_label =
+    auto transpose_label = pattern::wrap_type<Transpose>({pattern::any_input(), pattern::wrap_type<Constant>()});
-            pattern::wrap_type<Transpose>({pattern::any_input(), pattern::wrap_type<Constant>()});
     ov::matcher_pass_callback matcher_pass_callback = [=](pattern::Matcher& m) {
         const auto& pattern_to_output = m.get_pattern_map();
         auto transpose_1 = pattern_to_output.at(transpose_label);
-        auto order_const_1 =
+        auto order_const_1 = std::dynamic_pointer_cast<Constant>(transpose_1->input_value(1).get_node_shared_ptr());
-                std::dynamic_pointer_cast<Constant>(transpose_1->input_value(1).get_node_shared_ptr());
         auto consumers = transpose_1->get_output_target_inputs(0);
 
         std::vector<int64_t> saved_order_values;

src/common/transformations/src/transformations/common_optimizations/transpose_sinking_general.cpp

@@ -14,6 +14,7 @@
 #include "transformations/common_optimizations/transpose_sinking_binary.hpp"
 #include "transformations/common_optimizations/transpose_sinking_concat.hpp"
 #include "transformations/common_optimizations/transpose_sinking_data_movement.hpp"
+#include "transformations/common_optimizations/transpose_sinking_interpolate.hpp"
 #include "transformations/common_optimizations/transpose_sinking_split.hpp"
 #include "transformations/common_optimizations/transpose_sinking_unary.hpp"
 #include "transformations/utils/utils.hpp"
@@ -26,6 +27,7 @@ ov::pass::TransposeSinkingGeneralForward::TransposeSinkingGeneralForward() {
     add_matcher<ov::pass::TransposeSinkingSplitForward>();
     add_matcher<ov::pass::TransposeSinkingDataMovementForward>();
     add_matcher<ov::pass::TransposeSinkingReductionForward>();
+    add_matcher<ov::pass::TransposeSinkingInterpolateForward>();
     add_matcher<ov::pass::TransposeFuse>();
 }
 
@@ -37,6 +39,7 @@ ov::pass::TransposeSinkingGeneralBackward::TransposeSinkingGeneralBackward() {
     add_matcher<ov::pass::TransposeSinkingSplitBackward>();
     add_matcher<ov::pass::TransposeSinkingDataMovementBackward>();
     add_matcher<ov::pass::TransposeSinkingReductionBackward>();
+    add_matcher<ov::pass::TransposeSinkingInterpolateBackward>();
     add_matcher<ov::pass::TransposeFuse>();
 }
 

src/common/transformations/src/transformations/common_optimizations/transpose_sinking_interpolate.cpp

@@ -44,12 +44,11 @@ ov::pass::TransposeSinkingInterpolateForward::TransposeSinkingInterpolateForward
         main_node->input(0).replace_source_output(transpose_parent);
 
         const auto transpose_axis_order = transpose_const->get_axis_vector_val();
-        const auto reversed_transpose_order = ReverseTransposeOrder(transpose_axis_order);
         auto axis = std::make_shared<Constant>(element::i32, Shape{}, std::vector<int32_t>{0});
 
         const auto& interpolate = std::dynamic_pointer_cast<Interpolate>(main_node);
 
-        auto data = std::make_shared<Constant>(element::i32, Shape{reversed_transpose_order.size()}, reversed_transpose_order);
+        auto data = std::make_shared<Constant>(element::i32, Shape{transpose_axis_order.size()}, transpose_axis_order);
         const auto& indices = main_node->input_value(3);
         auto new_axis = std::make_shared<Gather>(data, indices, axis);
 
@@ -57,13 +56,13 @@ ov::pass::TransposeSinkingInterpolateForward::TransposeSinkingInterpolateForward
         if (interpolate) {
             op::v4::Interpolate::InterpolateAttrs attrs = interpolate->get_attrs();
             if (!attrs.pads_begin.empty() || !attrs.pads_end.empty()) {
-                const auto &order_size = reversed_transpose_order.size();
+                const auto& order_size = transpose_axis_order.size();
                 attrs.pads_begin.resize(order_size);
                 attrs.pads_end.resize(order_size);
                 std::vector<size_t> new_pads_begin(order_size), new_pads_end(order_size);
                 for (size_t i = 0; i < order_size; ++i) {
-                    new_pads_begin[i] = attrs.pads_begin[reversed_transpose_order[i]];
+                    new_pads_begin[i] = attrs.pads_begin[transpose_axis_order[i]];
-                    new_pads_end[i] = attrs.pads_end[reversed_transpose_order[i]];
+                    new_pads_end[i] = attrs.pads_end[transpose_axis_order[i]];
                 }
                 std::swap(attrs.pads_begin, new_pads_begin);
                 std::swap(attrs.pads_end, new_pads_end);
@@ -71,7 +70,6 @@ ov::pass::TransposeSinkingInterpolateForward::TransposeSinkingInterpolateForward
             }
         }
 
-
         main_node->validate_and_infer_types();
         TransposeInputsInfo transpose_input_info = {transpose, transpose_const, 0};
         for (auto& new_node : sink_forward::InsertOutputTransposes(main_node, transpose_input_info)) {
@@ -115,21 +113,23 @@ ov::pass::TransposeSinkingInterpolateBackward::TransposeSinkingInterpolateBackwa
         RemoveSingleOutputConsumers(main_node);
 
         const auto transpose_axis_order = transpose_const->get_axis_vector_val();
+        const auto reversed_transpose_order = ReverseTransposeOrder(transpose_axis_order);
         auto axis = std::make_shared<Constant>(element::i32, Shape{}, std::vector<int32_t>{0});
-        auto data = std::make_shared<Constant>(element::i32, Shape{transpose_axis_order.size()}, transpose_axis_order);
+        auto data =
+            std::make_shared<Constant>(element::i32, Shape{reversed_transpose_order.size()}, reversed_transpose_order);
         const auto& indices = main_node->input_value(3);
         auto new_axis = std::make_shared<Gather>(data, indices, axis);
         const auto& interpolate = std::dynamic_pointer_cast<Interpolate>(main_node);
         if (interpolate) {
             op::v4::Interpolate::InterpolateAttrs attrs = interpolate->get_attrs();
             if (!attrs.pads_begin.empty() || !attrs.pads_end.empty()) {
-                const auto &order_size = transpose_axis_order.size();
+                const auto& order_size = reversed_transpose_order.size();
                 attrs.pads_begin.resize(order_size);
                 attrs.pads_end.resize(order_size);
                 std::vector<size_t> new_pads_begin(order_size), new_pads_end(order_size);
                 for (size_t i = 0; i < order_size; ++i) {
-                    new_pads_begin[i] = attrs.pads_begin[transpose_axis_order[i]];
+                    new_pads_begin[i] = attrs.pads_begin[reversed_transpose_order[i]];
-                    new_pads_end[i] = attrs.pads_end[transpose_axis_order[i]];
+                    new_pads_end[i] = attrs.pads_end[reversed_transpose_order[i]];
                 }
                 std::swap(attrs.pads_begin, new_pads_begin);
                 std::swap(attrs.pads_end, new_pads_end);

src/common/transformations/src/transformations/common_optimizations/transpose_sinking_reduction.cpp

@@ -8,9 +8,9 @@
 #include <vector>
 
 #include "itt.hpp"
+#include "openvino/core/validation_util.hpp"
 #include "openvino/opsets/opset10.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
-#include "openvino/core/validation_util.hpp"
 #include "transformations/common_optimizations/transpose_sinking_utils.hpp"
 #include "transformations/utils/utils.hpp"
 
@@ -77,19 +77,16 @@ bool get_keep_dims(const std::shared_ptr<Node>& reduction) {
         keep_dims = arithmetic_reduce->get_keep_dims();
     return keep_dims;
 }
-}
+}  // namespace
 
 ov::pass::TransposeSinkingReductionForward::TransposeSinkingReductionForward() {
     MATCHER_SCOPE(TransposeSinkingReductionForward);
 
-    auto transpose_label =
+    auto transpose_label = pattern::wrap_type<Transpose>({pattern::any_input(), pattern::wrap_type<Constant>()},
-            pattern::wrap_type<Transpose>({pattern::any_input(), pattern::wrap_type<Constant>()},
                                                          pattern::consumers_count(1));
-    auto reduce_or_squeeze_label =
+    auto reduce_or_squeeze_label = pattern::
-            pattern::wrap_type<op::util::ArithmeticReductionKeepDims,
+        wrap_type<op::util::ArithmeticReductionKeepDims, op::util::LogicalReductionKeepDims, Squeeze, Unsqueeze>(
-                    op::util::LogicalReductionKeepDims,
+            {transpose_label, pattern::wrap_type<Constant>()});
-                    Squeeze,
-                    Unsqueeze>({transpose_label, pattern::wrap_type<Constant>()});
 
     ov::matcher_pass_callback matcher_pass_callback = [=](pattern::Matcher& m) {
         const auto& pattern_to_output = m.get_pattern_value_map();
@@ -141,9 +138,8 @@ ov::pass::TransposeSinkingReductionForward::TransposeSinkingReductionForward() {
 
         std::shared_ptr<Node> new_reduction;
         if (!unsqueeze) {
-            auto new_const = std::make_shared<Constant>(reduction_axes->get_element_type(),
+            auto new_const =
-                                                                reduction_axes->get_shape(),
+                std::make_shared<Constant>(reduction_axes->get_element_type(), reduction_axes->get_shape(), new_values);
-                                                                new_values);
             new_reduction = reduction->clone_with_new_inputs({transpose->input_value(0), new_const});
         } else {
             new_reduction = reduction->clone_with_new_inputs({transpose->input_value(0), reduction->input_value(1)});
@@ -165,14 +161,11 @@ ov::pass::TransposeSinkingReductionForward::TransposeSinkingReductionForward() {
 ov::pass::TransposeSinkingReductionBackward::TransposeSinkingReductionBackward() {
     MATCHER_SCOPE(TransposeSinkingReductionBackward);
 
-    auto reduce_or_squeeze_label =
+    auto reduce_or_squeeze_label = pattern::
-            pattern::wrap_type<op::util::ArithmeticReductionKeepDims,
+        wrap_type<op::util::ArithmeticReductionKeepDims, op::util::LogicalReductionKeepDims, Squeeze, Unsqueeze>(
-                    op::util::LogicalReductionKeepDims,
+            {pattern::any_input(), pattern::wrap_type<Constant>()},
-                    Squeeze,
-                    Unsqueeze>({pattern::any_input(), pattern::wrap_type<Constant>()},
             transpose_sinking::HasSameOutputTransposeNodes);
-    auto transpose_label =
+    auto transpose_label = pattern::wrap_type<Transpose>({reduce_or_squeeze_label, pattern::wrap_type<Constant>()});
-            pattern::wrap_type<Transpose>({reduce_or_squeeze_label, pattern::wrap_type<Constant>()});
     ov::matcher_pass_callback matcher_pass_callback = [=](pattern::Matcher& m) {
         const auto& pattern_to_output = m.get_pattern_value_map();
 
@@ -249,9 +242,8 @@ ov::pass::TransposeSinkingReductionBackward::TransposeSinkingReductionBackward()
             copy_runtime_info({transpose, reduction}, {new_transpose, new_reduction});
             register_new_node(new_transpose);
         } else {
-            auto new_const = std::make_shared<Constant>(reduction_axes->get_element_type(),
+            auto new_const =
-                                                        reduction_axes->get_shape(),
+                std::make_shared<Constant>(reduction_axes->get_element_type(), reduction_axes->get_shape(), new_values);
-                                                        new_values);
             auto new_transpose = transpose->clone_with_new_inputs({reduction->input_value(0), new_transpose_order});
             auto new_reduction = reduction->clone_with_new_inputs({new_transpose, new_const});
             replace_node(transpose, new_reduction);

src/common/transformations/src/transformations/common_optimizations/transpose_sinking_unary.cpp

@@ -55,7 +55,9 @@ ov::pass::TransposeSinkingUnaryForward::TransposeSinkingUnaryForward() {
     MATCHER_SCOPE(TransposeSinkingUnaryForward);
 
     auto transpose_label = wrap_type<Transpose>({any_input(), any_input()});
-    auto unary_label = wrap_type<UnaryElementwiseArithmetic, Clamp, Elu, SoftPlus, LogicalNot, Convert, IsInf, IsNaN, IsFinite>({transpose_label});
+    auto unary_label =
+        wrap_type<UnaryElementwiseArithmetic, Clamp, Elu, SoftPlus, LogicalNot, Convert, IsInf, IsNaN, IsFinite>(
+            {transpose_label});
 
     ov::matcher_pass_callback matcher_pass_callback = [=](Matcher& m) {
         const auto& pattern_to_output = m.get_pattern_value_map();
@@ -90,7 +92,8 @@ ov::pass::TransposeSinkingUnaryBackward::TransposeSinkingUnaryBackward() {
 
     auto unary_label =
         wrap_type<UnaryElementwiseArithmetic, Clamp, Elu, SoftPlus, LogicalNot, Convert, IsInf, IsNaN, IsFinite>(
-                {any_input()}, unary_restrictions);
+            {any_input()},
+            unary_restrictions);
 
     auto transpose_const_label = wrap_type<Constant>();
 

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

@@ -292,7 +292,8 @@ INSTANTIATE_TEST_SUITE_P(TransposeSinkingPadForwardSingleConsumerTestSuite,
                                             ::testing::Values(element::f32)),
                          TransposeSinkingPadTestFixture::get_test_name);
 
-INSTANTIATE_TEST_SUITE_P(TransposeSinkingPadBackwardSingleConsumerTestSuite,
+INSTANTIATE_TEST_SUITE_P(
+    TransposeSinkingPadBackwardSingleConsumerTestSuite,
     TransposeSinkingPadTestFixture,
     ::testing::Combine(::testing::Values(CREATE_PASS_FACTORY(TransposeSinkingDataMovementBackward)),
                        ::testing::ValuesIn(pad_operations_numbers),