Added subgraph tests (opencv#100)

l-bat · web-flow · commit 2fbbd7afe3f8 · 2021-03-25T13:02:33.000+03:00
diff --git a/modules/arm_plugin/src/transformations/decompose_variadic_split.cpp b/modules/arm_plugin/src/transformations/decompose_variadic_split.cpp
@@ -42,14 +42,27 @@ ArmPlugin::pass::DecomposeVariadicSplit::DecomposeVariadicSplit() {
         ngraph::OutputVector slices;
         ngraph::NodeVector slice_nodes;
         std::string output_name = split->get_friendly_name();
+
+        int count_useless_outs = 0;
+        for (auto out : split->outputs()) {
+            auto inputs = out.get_target_inputs();
+            if (inputs.empty()) {
+                ++count_useless_outs;
+            }
+        }
+
         for (size_t i = 0; i < splits.size(); i++) {
             begin_vec[axis] = end_vec[axis];
             end_vec[axis]  += splits[i];
 
             auto begin  = opset::Constant::create<int64_t>(ngraph::element::i64, ngraph::Shape{size}, begin_vec);
             auto end    = opset::Constant::create<int64_t>(ngraph::element::i64, ngraph::Shape{size}, end_vec);
             auto slice  = std::make_shared<opset::StridedSlice>(input, begin, end, stride, std::vector<int64_t>{}, std::vector<int64_t>{});
-            slice->set_friendly_name(output_name  + '.' + std::to_string(i));
+            std::string name = output_name;
+            if (splits.size() - count_useless_outs > 1) {
+                name += '.' + std::to_string(i);
+            }
+            slice->set_friendly_name(name);
             slice_nodes.push_back(slice);
             slices.push_back(slice->output(0));
         }
diff --git a/modules/arm_plugin/tests/functional/shared_tests_instances/subgraph_tests/conv_eltwise_fusion.cpp b/modules/arm_plugin/tests/functional/shared_tests_instances/subgraph_tests/conv_eltwise_fusion.cpp
@@ -25,7 +25,7 @@ const std::vector<ngraph::element::Type> types{
         {1, 1, 1, 1},
     };
 
-    INSTANTIATE_TEST_CASE_P(smoke_Convolution_2D, ConvEltwiseFusion,
+    INSTANTIATE_TEST_CASE_P(smoke_Check_Convolution_2D, ConvEltwiseFusion,
                             ::testing::Combine(
                                     ::testing::Values(ngraph::opset4::Convolution::type_info),
                                     ::testing::ValuesIn(IN({MUL(4), ADD(5)})),
@@ -36,7 +36,7 @@ const std::vector<ngraph::element::Type> types{
                                     ::testing::Values(CommonTestUtils::DEVICE_CPU)),
                             ConvEltwiseFusion::getTestCaseName);
 
-    INSTANTIATE_TEST_CASE_P(smoke_Convolution_2D_4ops, ConvEltwiseFusion,
+    INSTANTIATE_TEST_CASE_P(smoke_Check_Convolution_2D_4ops, ConvEltwiseFusion,
                             ::testing::Combine(
                                     ::testing::Values(ngraph::opset4::Convolution::type_info),
                                     ::testing::ValuesIn(IN({MUL(6), ADD(6)})),
@@ -47,7 +47,7 @@ const std::vector<ngraph::element::Type> types{
                                     ::testing::Values(CommonTestUtils::DEVICE_CPU)),
                             ConvEltwiseFusion::getTestCaseName);
 
-    INSTANTIATE_TEST_CASE_P(smoke_GroupConvolution_2D, ConvEltwiseFusion,
+    INSTANTIATE_TEST_CASE_P(smoke_Check_GroupConvolution_2D, ConvEltwiseFusion,
                             ::testing::Combine(
                                     ::testing::Values(ngraph::opset4::GroupConvolution::type_info),
                                     ::testing::ValuesIn(IN({MUL(4), ADD(5)})),
@@ -58,7 +58,7 @@ const std::vector<ngraph::element::Type> types{
                                     ::testing::Values(CommonTestUtils::DEVICE_CPU)),
                             ConvEltwiseFusion::getTestCaseName);
 
-    INSTANTIATE_TEST_CASE_P(smoke_DepthwiseConvolution_2D, ConvEltwiseFusion,
+    INSTANTIATE_TEST_CASE_P(smoke_Check_DepthwiseConvolution_2D, ConvEltwiseFusion,
                             ::testing::Combine(
                                     ::testing::Values(ngraph::opset4::GroupConvolution::type_info),
                                     ::testing::ValuesIn(IN({MUL(4), ADD(5)})),
@@ -80,7 +80,7 @@ const std::vector<ngraph::element::Type> types{
         {1, 3, 1}, // fused
     };
 
-    INSTANTIATE_TEST_CASE_P(smoke_Convolution_2D_Negative, ConvEltwiseFusion,
+    INSTANTIATE_TEST_CASE_P(smoke_Check_Convolution_2D_Negative, ConvEltwiseFusion,
                             ::testing::Combine(
                                     ::testing::Values(ngraph::opset4::Convolution::type_info),
                                     ::testing::ValuesIn(IN({MUL(6), ADD(6)})),
@@ -96,7 +96,7 @@ const std::vector<ngraph::element::Type> types{
         {1, 3, 1, 1}, // fused
     };
 
-    INSTANTIATE_TEST_CASE_P(smoke_Convolution_2D_Negative_5ops, ConvEltwiseFusion,
+    INSTANTIATE_TEST_CASE_P(smoke_Check_Convolution_2D_Negative_5ops, ConvEltwiseFusion,
                             ::testing::Combine(
                                     ::testing::Values(ngraph::opset4::Convolution::type_info),
                                     ::testing::ValuesIn(IN({ADD(5)})),
@@ -107,7 +107,7 @@ const std::vector<ngraph::element::Type> types{
                                     ::testing::Values(CommonTestUtils::DEVICE_CPU)),
                             ConvEltwiseFusion::getTestCaseName);
 
-    INSTANTIATE_TEST_CASE_P(smoke_GroupConvolution_2D_Negative, ConvEltwiseFusion,
+    INSTANTIATE_TEST_CASE_P(smoke_Check_GroupConvolution_2D_Negative, ConvEltwiseFusion,
                             ::testing::Combine(
                                     ::testing::Values(ngraph::opset4::GroupConvolution::type_info),
                                     ::testing::ValuesIn(IN({MUL(6), ADD(6)})),
@@ -118,7 +118,7 @@ const std::vector<ngraph::element::Type> types{
                                     ::testing::Values(CommonTestUtils::DEVICE_CPU)),
                             ConvEltwiseFusion::getTestCaseName);
 
-    INSTANTIATE_TEST_CASE_P(smoke_DepthwiseConvolution_2D_Negative, ConvEltwiseFusion,
+    INSTANTIATE_TEST_CASE_P(smoke_Check_DepthwiseConvolution_2D_Negative, ConvEltwiseFusion,
                             ::testing::Combine(
                                     ::testing::Values(ngraph::opset4::GroupConvolution::type_info),
                                     ::testing::ValuesIn(IN({MUL(6), ADD(6)})),
diff --git a/modules/arm_plugin/tests/functional/shared_tests_instances/subgraph_tests/get_output_before_activation.cpp b/modules/arm_plugin/tests/functional/shared_tests_instances/subgraph_tests/get_output_before_activation.cpp
@@ -0,0 +1,38 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+#include <subgraph_tests/get_output_before_activation.hpp>
+#include "common_test_utils/test_constants.hpp"
+
+namespace SubgraphTestsDefinitions {
+namespace {
+    std::vector<size_t> input_sizes = {
+        80,
+        32,
+        64,
+        100
+    };
+
+    std::vector<midOutputType> midLayerTypes {
+        midOutputType::Mul,
+        midOutputType::Sub,
+        midOutputType::Sum
+    };
+
+    std::map<std::string, std::string> additional_config = {};
+} // namespace
+
+const std::vector<InferenceEngine::Precision> netPrecisions = {
+        InferenceEngine::Precision::FP32,
+        InferenceEngine::Precision::FP16
+};
+
+
+INSTANTIATE_TEST_CASE_P(smoke_Check, OutputBeforeActivation,
+    ::testing::Combine(
+        ::testing::Values(CommonTestUtils::DEVICE_CPU),
+        ::testing::ValuesIn(netPrecisions),
+        ::testing::ValuesIn(input_sizes),
+        ::testing::ValuesIn(midLayerTypes),
+        ::testing::Values(additional_config)),
+    OutputBeforeActivation::getTestCaseName);
+} // namespace SubgraphTestsDefinitions
diff --git a/modules/arm_plugin/tests/functional/shared_tests_instances/subgraph_tests/matmul_squeeze_add.cpp b/modules/arm_plugin/tests/functional/shared_tests_instances/subgraph_tests/matmul_squeeze_add.cpp
@@ -0,0 +1,47 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <vector>
+
+#include "common_test_utils/test_constants.hpp"
+#include "subgraph_tests/matmul_squeeze_add.hpp"
+
+using namespace SubgraphTestsDefinitions;
+
+namespace {
+const std::vector<InferenceEngine::Precision> netPrecisions = {
+        InferenceEngine::Precision::FP32,
+        InferenceEngine::Precision::FP16
+};
+
+const std::vector<std::map<std::string, std::string>> configs = {
+    { }
+};
+
+std::vector<std::vector<size_t>> input_shapes = {
+    {1, 8},
+    {1, 42},
+    {1, 100},
+    {1, 128},
+    {1, 512}
+};
+
+std::vector<size_t> output_sizes = {
+    1000,
+    512,
+    128,
+    42,
+    16,
+    8
+};
+
+INSTANTIATE_TEST_CASE_P(smoke_Check, MatmulSqueezeAddTest,
+                        ::testing::Combine(
+                            ::testing::ValuesIn(netPrecisions),
+                            ::testing::Values(CommonTestUtils::DEVICE_CPU),
+                            ::testing::ValuesIn(configs),
+                            ::testing::ValuesIn(input_shapes),
+                            ::testing::ValuesIn(output_sizes)),
+                        MatmulSqueezeAddTest::getTestCaseName);
+}  // namespace
diff --git a/modules/arm_plugin/tests/functional/shared_tests_instances/subgraph_tests/multiply_add.cpp b/modules/arm_plugin/tests/functional/shared_tests_instances/subgraph_tests/multiply_add.cpp
@@ -0,0 +1,32 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <vector>
+
+#include "subgraph_tests/multiply_add.hpp"
+
+using namespace SubgraphTestsDefinitions;
+
+namespace {
+
+const std::vector<InferenceEngine::Precision> netPrecisions = {
+        InferenceEngine::Precision::FP32,
+        InferenceEngine::Precision::FP16
+};
+
+const std::vector<std::vector<size_t>> inputShapes = {
+        {2, 3},
+        {2, 3, 4},
+        {1, 3, 2, 2},
+        {1, 3, 2, 2, 6},
+};
+
+INSTANTIATE_TEST_CASE_P(smoke_Check, MultiplyAddLayerTest,
+                        ::testing::Combine(
+                                ::testing::ValuesIn(inputShapes),
+                                ::testing::ValuesIn(netPrecisions),
+                                ::testing::Values(CommonTestUtils::DEVICE_CPU)),
+                        MultiplyAddLayerTest::getTestCaseName);
+
+}  // namespace
diff --git a/modules/arm_plugin/tests/functional/shared_tests_instances/subgraph_tests/perm_conv_perm_concat.cpp b/modules/arm_plugin/tests/functional/shared_tests_instances/subgraph_tests/perm_conv_perm_concat.cpp
@@ -0,0 +1,40 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+#include <vector>
+#include "subgraph_tests/perm_conv_perm_concat.hpp"
+#include "common_test_utils/test_constants.hpp"
+namespace {
+std::vector<std::array<size_t, 4>> input_shapes {
+    {1, 1, 7, 32},
+    {1, 1, 8, 16},
+};
+
+std::vector<std::array<size_t, 2>> kernel_shapes {
+    {1, 3},
+    {1, 5},
+};
+
+std::vector<size_t> output_channels {
+    32,
+    64,
+};
+
+std::vector<InferenceEngine::Precision> netPrecisions = {
+    InferenceEngine::Precision::FP32,
+    InferenceEngine::Precision::FP16,
+};
+
+std::map<std::string, std::string> additional_config = {};
+} // namespace
+
+namespace SubgraphTestsDefinitions {
+INSTANTIATE_TEST_CASE_P(smoke_Check, PermConvPermConcat,
+    ::testing::Combine(
+        ::testing::ValuesIn(netPrecisions),
+        ::testing::Values(CommonTestUtils::DEVICE_CPU),
+        ::testing::ValuesIn(input_shapes),
+        ::testing::ValuesIn(kernel_shapes),
+        ::testing::ValuesIn(output_channels),
+        ::testing::Values(additional_config)),
+    PermConvPermConcat::getTestCaseName);
+} // namespace SubgraphTestsDefinitions
diff --git a/modules/arm_plugin/tests/functional/shared_tests_instances/subgraph_tests/relu_shape_of.cpp b/modules/arm_plugin/tests/functional/shared_tests_instances/subgraph_tests/relu_shape_of.cpp
@@ -0,0 +1,23 @@
+// Copyright (C) 2019 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <vector>
+
+#include "subgraph_tests/relu_shape_of.hpp"
+#include "common_test_utils/test_constants.hpp"
+
+using namespace SubgraphTestsDefinitions;
+
+namespace {
+    const std::vector<InferenceEngine::Precision> netPrecisions = {
+            InferenceEngine::Precision::I32
+    };
+
+    INSTANTIATE_TEST_CASE_P(smoke_Check, ReluShapeOfSubgraphTest,
+                            ::testing::Combine(
+                                    ::testing::ValuesIn(netPrecisions),
+                                    ::testing::Values(std::vector<size_t>({20, 10, 10, 10})),
+                                    ::testing::Values(CommonTestUtils::DEVICE_CPU)),
+                            ReluShapeOfSubgraphTest::getTestCaseName);
+}  // namespace
diff --git a/modules/arm_plugin/tests/functional/shared_tests_instances/subgraph_tests/reshape_squeeze_reshape_relu.cpp b/modules/arm_plugin/tests/functional/shared_tests_instances/subgraph_tests/reshape_squeeze_reshape_relu.cpp
@@ -0,0 +1,46 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+#include <vector>
+#include "subgraph_tests/reshape_squeeze_reshape_relu.hpp"
+#include "common_test_utils/test_constants.hpp"
+
+using namespace SubgraphTestsDefinitions;
+
+namespace {
+    std::vector<ShapeAxesTuple> inputs{
+            {{1, 1, 3}, {0, 1}},
+            {{1, 1, 3}, {0}},
+            {{1, 1, 3}, {1}},
+            {{1, 3, 1}, {0, 2}},
+            {{1, 3, 1}, {0}},
+            {{1, 3, 1}, {2}},
+            {{3, 1, 1}, {1, 2}},
+            {{3, 1, 1}, {1}},
+            {{3, 1, 1}, {2}},
+            {{4, 1, 3, 1}, {1, 3}},
+            {{4, 1, 1, 3}, {1, 2}},
+            {{1, 4, 1, 3}, {0, 2}},
+            {{1, 3, 5, 2, 1}, {0, 4}},
+            {{3, 1, 2, 4, 4, 3}, {1}},
+            {{1, 1, 1, 1, 1, 3}, {0, 1, 2, 3, 4}},
+            {{1, 1, 1, 1, 1, 3}, {1, 3}},
+            {{1}, {0}},
+    };
+
+    std::vector<InferenceEngine::Precision> netPrecisions = {InferenceEngine::Precision::FP32,
+                                                             InferenceEngine::Precision::FP16,
+    };
+
+    const std::vector<ngraph::helpers::SqueezeOpType> opTypes = {
+            ngraph::helpers::SqueezeOpType::SQUEEZE,
+            ngraph::helpers::SqueezeOpType::UNSQUEEZE
+    };
+
+    INSTANTIATE_TEST_CASE_P(smoke_Check, ReshapeSqueezeReshapeRelu,
+                            ::testing::Combine(
+                                    ::testing::ValuesIn(inputs),
+                                    ::testing::ValuesIn(netPrecisions),
+                                    ::testing::Values(CommonTestUtils::DEVICE_CPU),
+                                    ::testing::ValuesIn(opTypes)),
+                            ReshapeSqueezeReshapeRelu::getTestCaseName);
+}  // namespace
diff --git a/modules/arm_plugin/tests/functional/shared_tests_instances/subgraph_tests/split_conv_concat.cpp b/modules/arm_plugin/tests/functional/shared_tests_instances/subgraph_tests/split_conv_concat.cpp
@@ -0,0 +1,29 @@
+// Copyright (C) 2019 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <vector>
+
+#include "subgraph_tests/split_conv_concat.hpp"
+#include "common_test_utils/test_constants.hpp"
+
+using namespace SubgraphTestsDefinitions;
+
+namespace {
+
+const std::vector<InferenceEngine::Precision> netPrecisions = {
+        InferenceEngine::Precision::FP32,
+        InferenceEngine::Precision::FP16
+};
+
+INSTANTIATE_TEST_CASE_P(smoke_Check, SplitConvConcat,
+                        ::testing::Combine(
+                                ::testing::ValuesIn(netPrecisions),
+                                ::testing::Values(InferenceEngine::SizeVector({1, 6, 40, 40})),
+                                ::testing::Values(CommonTestUtils::DEVICE_CPU)),
+                        SplitConvConcat::getTestCaseName);
+}  // namespace
+
+
+
+
diff --git a/modules/arm_plugin/tests/functional/shared_tests_instances/subgraph_tests/tensor_names.cpp b/modules/arm_plugin/tests/functional/shared_tests_instances/subgraph_tests/tensor_names.cpp
@@ -0,0 +1,16 @@
+// Copyright (C) 2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <vector>
+
+#include "subgraph_tests/tensor_names.hpp"
+#include "common_test_utils/test_constants.hpp"
+
+using namespace SubgraphTestsDefinitions;
+
+namespace {
+    INSTANTIATE_TEST_CASE_P(smoke_Check, TensorNamesTest,
+                            ::testing::Values(CommonTestUtils::DEVICE_CPU),
+                            TensorNamesTest::getTestCaseName);
+}  // namespace
diff --git a/modules/arm_plugin/tests/functional/shared_tests_instances/subgraph_tests/variadic_split_pad.cpp b/modules/arm_plugin/tests/functional/shared_tests_instances/subgraph_tests/variadic_split_pad.cpp
