diff --git a/src/plugins/intel_gpu/src/plugin/ops/result.cpp b/src/plugins/intel_gpu/src/plugin/ops/result.cpp index 47deb50b893..da7d7156eb3 100644 --- a/src/plugins/intel_gpu/src/plugin/ops/result.cpp +++ b/src/plugins/intel_gpu/src/plugin/ops/result.cpp @@ -63,7 +63,10 @@ static void CreateResultOp(Program& p, const std::shared_ptrgetPrecision(); std::string outputID = inputs[0]; - if (p.use_new_shape_infer()) { + if (p.use_new_shape_infer() + // Note:: Currently Split/Variadic Split are divided to multiple crops + && !ngraph::is_type(prev) + && !ngraph::is_type(prev)) { auto reorder_primitive = cldnn::reorder(outLayerName, outputID, FormatFromLayout(outputlayout), diff --git a/src/plugins/intel_gpu/src/plugin/program.cpp b/src/plugins/intel_gpu/src/plugin/program.cpp index c4cea81215e..3b7abbf8975 100644 --- a/src/plugins/intel_gpu/src/plugin/program.cpp +++ b/src/plugins/intel_gpu/src/plugin/program.cpp @@ -419,7 +419,11 @@ std::vector Program::GetInputPrimitiveIDs(const std::shared for (size_t i = 0; i < op->get_input_size(); i++) { auto prevOp = op->get_input_node_ptr(i); std::string prevName = layer_type_name_ID(prevOp); - if (prevOp->get_output_size() > 1 && !allow_new_shape_infer) { + if (prevOp->get_output_size() > 1 && + (!allow_new_shape_infer + // Note:: Currently Split/Variadic Split are divided to multiple crops + || ngraph::is_type(prevOp) + || ngraph::is_type(prevOp))) { prevName += ".out" + std::to_string(op->get_input_source_output(i).get_index()); } diff --git a/src/tests/functional/plugin/gpu/single_layer_tests/dynamic/split.cpp b/src/tests/functional/plugin/gpu/single_layer_tests/dynamic/split.cpp new file mode 100644 index 00000000000..f27d9691ba9 --- /dev/null +++ b/src/tests/functional/plugin/gpu/single_layer_tests/dynamic/split.cpp @@ -0,0 +1,214 @@ +// Copyright (C) 2022 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "shared_test_classes/single_layer/select.hpp" +#include "shared_test_classes/base/ov_subgraph.hpp" +#include "ie_precision.hpp" +#include "ngraph_functions/builders.hpp" +#include + +using namespace ngraph; +using namespace InferenceEngine; +using namespace ov::test; + +namespace GPULayerTestsDefinitions { + +typedef std::tuple< + size_t, // Num splits + size_t, // Axis + ElementType, // Net precision + InputShape, // Input shapes + std::vector // Used outputs indices +> splitDynamicGPUTestParams; + +class SplitLayerGPUDynamicTest : public testing::WithParamInterface, + virtual public SubgraphBaseTest { +public: + static std::string getTestCaseName(testing::TestParamInfo obj) { + std::ostringstream result; + size_t numSplits; + int64_t axis; + ElementType netPrecision; + InputShape inputShape; + std::vector outIndices; + std::tie(numSplits, axis, netPrecision, inputShape, outIndices) = obj.param; + + result << "IS="; + result << CommonTestUtils::partialShape2str({inputShape.first}) << "_"; + result << "TS="; + for (const auto& shape : inputShape.second) { + result << CommonTestUtils::vec2str(shape) << "_"; + } + result << "numSplits=" << numSplits << "_"; + result << "axis=" << axis << "_"; + if (!outIndices.empty()) { + result << "outIndices" << CommonTestUtils::vec2str(outIndices) << "_"; + } + result << "netPRC=" << netPrecision << "_"; + return result.str(); + } + +protected: + void SetUp() override { + targetDevice = CommonTestUtils::DEVICE_GPU; + size_t axis, numSplits; + InputShape inputShape; + std::vector outIndices; + ElementType netPrecision; + std::tie(numSplits, axis, netPrecision, inputShape, outIndices) = this->GetParam(); + if (outIndices.empty()) { + for (int i = 0; i < numSplits; ++i) { + outIndices.push_back(i); + } + } + init_input_shapes({inputShape}); + auto dyn_params = ngraph::builder::makeDynamicParams(netPrecision, {inputDynamicShapes[0]}); + auto paramOuts = + ngraph::helpers::convert2OutputVector(helpers::castOps2Nodes(dyn_params)); + auto split = std::dynamic_pointer_cast( + ngraph::builder::makeSplit(paramOuts[0], netPrecision, numSplits, axis)); + ngraph::ResultVector results; + for (int i = 0; i < outIndices.size(); i++) { + results.push_back(std::make_shared(split->output(outIndices[i]))); + } + function = std::make_shared(results, dyn_params, "split"); + } +}; + +TEST_P(SplitLayerGPUDynamicTest, CompareWithRefs) { + SKIP_IF_CURRENT_TEST_IS_DISABLED() + run(); +} + +const std::vector inputShapes4d = { + { + {-1, -1, -1, -1}, {{1, 4, 5, 7}, {3, 8, 5, 9}, {5, 16, 1, 8}} + } +}; + +const std::vector inputShapes5d = { + { + {-1, -1, -1, -1, -1}, {{10, 20, 30, 40, 10}, {5, 18, 3, 10, 10}, {3, 10, 6, 2, 4}} + } +}; + +const std::vector inputShapes6d = { + { + {-1, -1, -1, -1, -1, -1}, {{10, 32, 3, 4, 12, 24}, {5, 2, 3, 1, 32, 12}, {3, 1, 6, 2, 4, 18}} + } +}; + +INSTANTIATE_TEST_SUITE_P(smoke_SplitsCheck4Dr, SplitLayerGPUDynamicTest, + ::testing::Combine( + ::testing::Values(2), // nSplits + ::testing::Values(1), // axes + ::testing::Values(ElementType::f16), // netPrec + ::testing::ValuesIn(inputShapes4d), // inShapes + ::testing::Values(std::vector({}))), // outIndices + SplitLayerGPUDynamicTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_SplitsCheck5D, SplitLayerGPUDynamicTest, + ::testing::Combine( + ::testing::Values(3), // nSplits + ::testing::Values(2), // axes + ::testing::Values(ElementType::f32), // netPrec + ::testing::ValuesIn(inputShapes5d), // inShapes + ::testing::Values(std::vector({}))), // outIndices + SplitLayerGPUDynamicTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_SplitsCheck6D, SplitLayerGPUDynamicTest, + ::testing::Combine( + ::testing::Values(4), // nSplits + ::testing::Values(4), // axes + ::testing::Values(ElementType::i8), // netPrec + ::testing::ValuesIn(inputShapes6d), // inShapes + ::testing::Values(std::vector({}))), // outIndices + SplitLayerGPUDynamicTest::getTestCaseName); + +typedef std::tuple< + size_t, // Axis + std::vector, // SplitLength + ElementType, // Net precision + InputShape // Input shapes +> varSplitDynamicGPUTestParams; + +class VariadicSplitLayerGPUDynamicTest : public testing::WithParamInterface, + virtual public SubgraphBaseTest { +public: + static std::string getTestCaseName(testing::TestParamInfo obj) { + std::ostringstream result; + size_t axis; + std::vector splitLength; + ElementType netPrecision; + InputShape inputShape; + std::tie(axis, splitLength, netPrecision, inputShape) = obj.param; + + result << "IS="; + result << CommonTestUtils::partialShape2str({inputShape.first}) << "_"; + result << "TS="; + for (const auto& shape : inputShape.second) { + result << CommonTestUtils::vec2str(shape) << "_"; + } + result << "SplitLen=" << CommonTestUtils::vec2str(splitLength) << "_"; + result << "axis=" << axis << "_"; + result << "netPRC=" << netPrecision << "_"; + return result.str(); + } + +protected: + void SetUp() override { + targetDevice = CommonTestUtils::DEVICE_GPU; + size_t axis; + InputShape inputShape; + std::vector splitLength; + ElementType netPrecision; + std::tie(axis, splitLength, netPrecision, inputShape) = this->GetParam(); + init_input_shapes({inputShape}); + auto dyn_params = ngraph::builder::makeDynamicParams(netPrecision, {inputDynamicShapes[0]}); + auto paramOuts = + ngraph::helpers::convert2OutputVector(helpers::castOps2Nodes(dyn_params)); + + auto splitAxisOp = std::make_shared(ngraph::element::i64, ngraph::Shape{}, std::vector{static_cast(axis)}); + auto splitLengthOp = std::make_shared(ngraph::element::i32, ngraph::Shape{splitLength.size()}, splitLength); + + auto varSplit = std::make_shared(paramOuts[0], splitAxisOp, splitLengthOp); + ngraph::ResultVector results; + for (int i = 0; i < splitLength.size(); i++) { + results.push_back(std::make_shared(varSplit->output(i))); + } + function = std::make_shared(results, dyn_params, "varSplit"); + } +}; + +TEST_P(VariadicSplitLayerGPUDynamicTest, CompareWithRefs) { + SKIP_IF_CURRENT_TEST_IS_DISABLED() + run(); +} + +INSTANTIATE_TEST_SUITE_P(smoke_VariadicSplitsCheck4D, VariadicSplitLayerGPUDynamicTest, + ::testing::Combine( + ::testing::Values(1), // axes + ::testing::Values(std::vector{2, 1, -1}), // splitLength + ::testing::Values(ElementType::f16), // netPrec + ::testing::ValuesIn(inputShapes4d)), // inShapes + VariadicSplitLayerGPUDynamicTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_VariadicSplitsCheck5D, VariadicSplitLayerGPUDynamicTest, + ::testing::Combine( + ::testing::Values(2), // axes + ::testing::Values(std::vector{2, -1}), // splitLength + ::testing::Values(ElementType::f32), // netPrec + ::testing::ValuesIn(inputShapes5d)), // inShapes + VariadicSplitLayerGPUDynamicTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_VariadicSplitsCheck6D, VariadicSplitLayerGPUDynamicTest, + ::testing::Combine( + ::testing::Values(5), // nSplits + ::testing::Values(std::vector{2, 3, 2, -1}), // splitLength + ::testing::Values(ElementType::i8), // netPrec + ::testing::ValuesIn(inputShapes6d)), // inShapes + VariadicSplitLayerGPUDynamicTest::getTestCaseName); + +} // namespace GPULayerTestsDefinitions +