[IE TESTS] Add VariadicSplit in SingleLayerTest (#1468)

* [IE TESTS] add variadic split

* [IE TESTS] update  variadic split

* [IE TESTS] update instance variadic split

* [IE TESTS] update variadic_split.cpp

diff --git a/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/single_layer_tests/variadic_split.cpp b/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/single_layer_tests/variadic_split.cpp
new file mode 100644 (file)
index 0000000..204909e
--- /dev/null
+++ b/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/single_layer_tests/variadic_split.cpp
@@ -0,0 +1,36 @@
+// Copyright (C) 2019 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <vector>
+
+#include "single_layer_tests/variadic_split.hpp"
+#include "common_test_utils/test_constants.hpp"
+
+using namespace LayerTestsDefinitions;
+
+namespace {
+
+    const std::vector<InferenceEngine::Precision> netPrecisions = {
+            InferenceEngine::Precision::FP32,
+            InferenceEngine::Precision::FP16
+    };
+
+    // Sum of elements numSplits = inputShapes[Axis]
+    const std::vector<std::vector<size_t>> numSplits = {
+            {1, 16, 5, 8},
+            {2, 19, 5, 4},
+            {7, 13, 2, 8},
+            {5, 8, 12, 5},
+            {4, 11, 6, 9}
+    };
+
+    INSTANTIATE_TEST_CASE_P(NumSplitsCheck, VariadicSplitLayerTest,
+            ::testing::Combine(
+            ::testing::ValuesIn(numSplits),
+            ::testing::Values(0, 1, 2, 3),
+            ::testing::ValuesIn(netPrecisions),
+            ::testing::Values(std::vector<size_t>({30, 30, 30, 30})),
+            ::testing::Values(CommonTestUtils::DEVICE_CPU)),
+            VariadicSplitLayerTest::getTestCaseName);
+}  // namespace

diff --git a/inference-engine/tests/functional/plugin/shared/include/single_layer_tests/variadic_split.hpp b/inference-engine/tests/functional/plugin/shared/include/single_layer_tests/variadic_split.hpp
new file mode 100644 (file)
index 0000000..26dc0d6
--- /dev/null
+++ b/inference-engine/tests/functional/plugin/shared/include/single_layer_tests/variadic_split.hpp
@@ -0,0 +1,34 @@
+// Copyright (C) 2019 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <tuple>
+#include <string>
+#include <vector>
+#include <memory>
+
+#include "functional_test_utils/layer_test_utils.hpp"
+#include "ngraph_functions/builders.hpp"
+
+namespace LayerTestsDefinitions {
+
+    typedef std::tuple<
+            std::vector<size_t>,            // Num splits
+            size_t,                         // Axis
+            InferenceEngine::Precision,     // Net precision
+            std::vector<size_t>,            // Input shapes
+            std::string                     // Target device name
+    > VariadicSplitParams;
+
+class VariadicSplitLayerTest : public testing::WithParamInterface<VariadicSplitParams>,
+                           public LayerTestsUtils::LayerTestsCommon {
+public:
+    static std::string getTestCaseName(testing::TestParamInfo<VariadicSplitParams> obj);
+
+protected:
+    void SetUp() override;
+};
+
+}  // namespace LayerTestsDefinitions
\ No newline at end of file

diff --git a/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/variadic_split.cpp b/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/variadic_split.cpp
new file mode 100644 (file)
index 0000000..ff73d0d
--- /dev/null
+++ b/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/variadic_split.cpp
@@ -0,0 +1,64 @@
+// Copyright (C) 2019 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <tuple>
+#include <string>
+#include <vector>
+#include <memory>
+#include <functional>
+#include <functional_test_utils/skip_tests_config.hpp>
+
+#include "ie_core.hpp"
+#include "ngraph_functions/utils/ngraph_helpers.hpp"
+
+#include "common_test_utils/common_utils.hpp"
+#include "functional_test_utils/blob_utils.hpp"
+#include "functional_test_utils/plugin_cache.hpp"
+#include "functional_test_utils/layer_test_utils.hpp"
+
+#include "single_layer_tests/variadic_split.hpp"
+
+namespace LayerTestsDefinitions {
+
+    std::string VariadicSplitLayerTest::getTestCaseName(testing::TestParamInfo<VariadicSplitParams> obj) {
+        size_t axis;
+        std::vector<size_t> numSplits;
+        InferenceEngine::Precision netPrecision;
+        InferenceEngine::SizeVector inputShapes;
+        std::string targetDevice;
+        std::tie(numSplits, axis, netPrecision, inputShapes, targetDevice) = obj.param;
+        std::ostringstream result;
+        result << "IS=" << CommonTestUtils::vec2str(inputShapes) << "_";
+        result << "numSplits=" << CommonTestUtils::vec2str(numSplits) << "_";
+        result << "axis=" << axis << "_";
+        result << "IS";
+        result << "netPRC=" << netPrecision.name() << "_";
+        result << "targetDevice=" << targetDevice;
+        return result.str();
+    }
+
+    void VariadicSplitLayerTest::SetUp() {
+        SetRefMode(LayerTestsUtils::RefMode::CONSTANT_FOLDING);
+        size_t axis;
+        std::vector<size_t> inputShape, numSplits;
+        InferenceEngine::Precision netPrecision;
+        std::tie(numSplits, axis, netPrecision, inputShape, targetDevice) = this->GetParam();
+        auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
+        auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
+        auto paramOuts = ngraph::helpers::convert2OutputVector(
+                ngraph::helpers::castOps2Nodes<ngraph::opset3::Parameter>(params));
+        auto VariadicSplit = std::dynamic_pointer_cast<ngraph::opset3::VariadicSplit>(ngraph::builder::makeVariadicSplit(params[0],
+                                              ngPrc, numSplits, axis));
+        ngraph::ResultVector results;
+        for (int i = 0; i < numSplits.size(); i++) {
+            results.push_back(std::make_shared<ngraph::opset3::Result>(VariadicSplit->output(i)));
+        }
+        function = std::make_shared<ngraph::Function>(results, params, "VariadicSplit");
+    }
+
+    TEST_P(VariadicSplitLayerTest, CompareWithRefs) {
+        Run();
+    }
+
+}  // namespace LayerTestsDefinitions
\ No newline at end of file

diff --git a/inference-engine/tests/ngraph_functions/include/ngraph_functions/builders.hpp b/inference-engine/tests/ngraph_functions/include/ngraph_functions/builders.hpp
index 684d984..8839c94 100644 (file)
--- a/inference-engine/tests/ngraph_functions/include/ngraph_functions/builders.hpp
+++ b/inference-engine/tests/ngraph_functions/include/ngraph_functions/builders.hpp
@@ -130,6 +130,11 @@ std::shared_ptr<ngraph::Node> makeSplit(const ngraph::Output<Node> &in,
                                         size_t numSplits,
                                         size_t axis);
 
+std::shared_ptr<ngraph::Node> makeVariadicSplit(const ngraph::Output<Node> &in,
+                                                const element::Type &type,
+                                                const std::vector<size_t> numSplits,
+                                                size_t axis);
+
 std::shared_ptr<ngraph::Node> makeActivation(const ngraph::Output<Node> &in,
                                              const element::Type &type,
                                              ngraph::helpers::ActivationTypes activationType,

diff --git a/inference-engine/tests/ngraph_functions/src/variadic_split.cpp b/inference-engine/tests/ngraph_functions/src/variadic_split.cpp
new file mode 100644 (file)
index 0000000..0d22936
--- /dev/null
+++ b/inference-engine/tests/ngraph_functions/src/variadic_split.cpp
@@ -0,0 +1,24 @@
+// Copyright (C) 2019 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <vector>
+#include <memory>
+
+#include "ngraph_functions/builders.hpp"
+
+namespace ngraph {
+namespace builder {
+        std::shared_ptr<ngraph::Node> makeVariadicSplit(const ngraph::Output<Node> &in,
+                                                        const element::Type &type,
+                                                        const std::vector<size_t> numSplits,
+                                                        size_t axis) {
+            auto splitAxisOp = std::make_shared<ngraph::opset3::Constant>(type, ngraph::Shape{},
+                                                                          std::vector<size_t>{axis});
+            auto numSplit = std::make_shared<ngraph::opset3::Constant>(type, ngraph::Shape{numSplits.size()},
+                                                                       numSplits);
+            auto VariadicSplitNode = std::make_shared<ngraph::opset3::VariadicSplit>(in, splitAxisOp, numSplit);
+            return VariadicSplitNode;
+        }
+}  // namespace builder
+}  // namespace ngraph