Subgraph tests

Author: v-Golubev

src/plugins/intel_cpu/tests/functional/subgraph_tests/src/merge_transpose_reorder.cpp

@@ -0,0 +1,137 @@
+// Copyright (C) 2018-2023 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <memory>
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include "common_test_utils/common_utils.hpp"
+#include "openvino/opsets/opset10.hpp"
+#include "ov_models/builders.hpp"
+#include "shared_test_classes/base/ov_subgraph.hpp"
+#include "test_utils/cpu_test_utils.hpp"
+#include "transformations/utils/utils.hpp"
+
+using namespace CPUTestUtils;
+using namespace ov::test;
+using namespace ngraph::helpers;
+
+namespace CPUSubgraphTestsDefinitions {
+template <typename NodeType, typename... Args>
+static std::shared_ptr<ov::Node> make_layer_with_bias(Args&&... args) {
+    const auto node = std::make_shared<NodeType>(std::forward<Args>(args)...);
+    const auto& precision = node->get_output_element_type(0);
+    const auto bias_const = ngraph::builder::makeConstant(precision, ov::Shape{}, std::vector<float>{}, true);
+    const auto bias = std::make_shared<ov::opset10::Add>(node, bias_const);
+    return bias;
+}
+
+static std::shared_ptr<ov::Model> initSubgraph(const ov::PartialShape& input_shape, const ov::element::Type& precision) {
+    const auto shapeof_subgraph_prc = ov::element::i32;
+    OPENVINO_ASSERT(input_shape.rank().is_static() && input_shape.size() == 4, "initSubgraph: only 4D shapes are supported");
+    OPENVINO_ASSERT(input_shape[1].is_static(), "initSubgraph: only static channels dim is supported");
+
+    const auto param = std::make_shared<ov::opset10::Parameter>(precision, input_shape);
+    const auto reshape_const_1 = ov::opset10::Constant::create(shapeof_subgraph_prc, {3}, {0, 0, -1});
+    const auto reshape_1 = std::make_shared<ov::opset10::Reshape>(param, reshape_const_1, true);
+
+    const auto transpose_const_1 = ov::opset10::Constant::create(shapeof_subgraph_prc, {3}, {0, 2, 1});
+    const auto transpose_1 = std::make_shared<ov::opset10::Transpose>(reshape_1, transpose_const_1);
+
+    const size_t channels = input_shape[1].get_length();
+    const size_t fc_out_channels = 512;
+    const auto fc_weights_1 = ngraph::builder::makeConstant(precision, ov::Shape{fc_out_channels, channels}, std::vector<float>{}, true);
+    const auto fc_1 = make_layer_with_bias<ov::opset10::MatMul>(transpose_1, fc_weights_1, false, true);
+
+    const auto transpose_const_2 = ov::opset10::Constant::create(shapeof_subgraph_prc, {3}, {0, 2, 1});
+    const auto transpose_2 = std::make_shared<ov::opset10::Transpose>(fc_1, transpose_const_2);
+    const auto spatial_dims = ov::op::util::node_to_get_shape_value_of_indices_from_shape_source(param, {2, 3}, {}, shapeof_subgraph_prc);
+    const auto unchangable_dims = ov::opset10::Constant::create(shapeof_subgraph_prc, {2}, {0, 0});
+    const auto reshape_const_2 = ov::op::util::make_try_fold<ov::opset10::Concat>(ov::OutputVector{unchangable_dims, spatial_dims}, 0);
+    const auto reshape_2 = std::make_shared<ov::opset10::Reshape>(transpose_2, reshape_const_2, true);
+
+    const auto conv_weights = ngraph::builder::makeConstant(precision, ov::Shape{fc_out_channels, 1, 1, 3, 3}, std::vector<float>{}, true);
+    const auto conv = make_layer_with_bias<ov::opset10::GroupConvolution>(reshape_2,
+                                                                          conv_weights,
+                                                                          ov::Strides{1, 1},
+                                                                          ov::CoordinateDiff{1, 1},
+                                                                          ov::CoordinateDiff{1, 1},
+                                                                          ov::Strides{1, 1});
+
+    const auto dim_h = ov::op::util::node_to_get_shape_value_of_indices_from_shape_source(param, {2}, {}, shapeof_subgraph_prc);
+    const auto dim_w = ov::op::util::node_to_get_shape_value_of_indices_from_shape_source(param, {3}, {}, shapeof_subgraph_prc);
+    const auto fused_spatial_dims = ov::op::util::make_try_fold<ov::opset10::Multiply>(dim_h, dim_w);
+    const auto reshape_const_3 = ov::op::util::make_try_fold<ov::opset10::Concat>(ov::OutputVector{unchangable_dims, fused_spatial_dims}, 0);
+    const auto reshape_3 = std::make_shared<ov::opset10::Reshape>(conv, reshape_const_3, true);
+    const auto transpose_const_3 = ov::opset10::Constant::create(shapeof_subgraph_prc, {3}, {0, 2, 1});
+    const auto transpose_3 = std::make_shared<ov::opset10::Transpose>(reshape_3, transpose_const_3);
+
+    const auto fc_weights_2 = ngraph::builder::makeConstant(precision, ov::Shape{channels, fc_out_channels}, std::vector<float>{}, true);
+    const auto fc_2 = make_layer_with_bias<ov::opset10::MatMul>(transpose_3, fc_weights_2, false, true);
+    return std::make_shared<ov::Model>(fc_2, ov::ParameterVector{param}, "MergeTransposeReorderModel");
+}
+
+using MergeTransposeReorderTestParams = std::tuple<InputShape, ElementType>;
+class MergeTransposeReorderCPUTest : public testing::WithParamInterface<MergeTransposeReorderTestParams>, virtual public SubgraphBaseTest, public CPUTestsBase {
+public:
+    static std::string getTestCaseName(const testing::TestParamInfo<MergeTransposeReorderTestParams> &obj) {
+        InputShape input_shape;
+        ElementType precision;
+        std::tie(input_shape, precision) = obj.param;
+
+        std::ostringstream results;
+        results << "IS=(" << ov::test::utils::partialShape2str({input_shape.first}) << "_";
+        results << ")_TS=(";
+        for (const auto& static_shape : input_shape.second) {
+            results << ov::test::utils::vec2str(static_shape) << "_";
+        }
+        results << ")_precision=" << precision;
+        return results.str();
+    }
+
+protected:
+    void SetUp() override {
+        targetDevice = ov::test::utils::DEVICE_CPU;
+        InputShape input_shape;
+        ElementType precision;
+        std::tie(input_shape, precision) = this->GetParam();
+        init_input_shapes({input_shape});
+        function = initSubgraph(inputDynamicShapes[0], precision);
+    }
+
+    void validate_exec_graph() {
+        CheckNumberOfNodesWithType(compiledModel, "Transpose", 1);
+        CheckNumberOfNodesWithType(compiledModel, "Reshape", 1);
+        size_t fake_reorder_count = 0;
+        for (const auto& node : compiledModel.get_runtime_model()->get_ops()) {
+            const auto& rtInfo = node->get_rt_info();
+            auto it = rtInfo.find(ExecGraphInfoSerialization::LAYER_TYPE);
+            IE_ASSERT(rtInfo.end() != it);
+            if (it->second.as<std::string>() == "Reorder") {
+                fake_reorder_count++;
+                ASSERT_TRUE(node->get_friendly_name().find("_fake") != std::string::npos) << "Non fake reorder found.";
+            }
+        }
+        ASSERT_EQ(fake_reorder_count, 2);
+    }
+};
+
+TEST_P(MergeTransposeReorderCPUTest, CompareWithRefs) {
+    run();
+    validate_exec_graph();
+}
+
+namespace {
+
+std::vector<InputShape> inputShapes = {
+    InputShape{{}, {{1, 32, 16, 16}}},
+};
+
+INSTANTIATE_TEST_SUITE_P(smoke_MergeTransposeReorder, MergeTransposeReorderCPUTest,
+                        ::testing::Combine(::testing::ValuesIn(inputShapes),
+                                           ::testing::Values(ElementType::f32)),
+                        MergeTransposeReorderCPUTest::getTestCaseName);
+} // namespace
+} // namespace CPUSubgraphTestsDefinitions