const DataVector& outputs) {
std::vector<DimValues> offsets;
offsets.reserve(outputs.size());
-
DimValues curOffset({{axis, 0}});
- for (const auto& output : outputs) {
- offsets.emplace_back(curOffset);
- curOffset.set(axis, curOffset[axis] + output->desc().dim(axis));
+
+ const auto haveUnusedOutput = [](const DataVector& outputs) {
+ return std::any_of(outputs.begin(), outputs.end(), [](const vpu::Data& out) {
+ return out == nullptr;
+ });
+ };
+
+ std::vector<size_t> outAxisSizes;
+ if (haveUnusedOutput(outputs)) {
+ VPU_THROW_UNLESS(layer != nullptr,
+ "Can't build split stage whith name {} with unused outputs when layer == nullptr", name);
+ const auto outDimsSize = layer->outData[0]->getDims().size();
+ const int idx = dimToIeInd(axis, outDimsSize);
+ outAxisSizes.reserve(outDimsSize);
+ for (const auto& out : layer->outData) {
+ VPU_THROW_UNLESS(idx <= out->getDims().size(),
+ "Split stage with name {} and type {} can't have idx = {} when out dimensions size = {}",
+ layer->name, layer->type, idx, out->getDims().size());
+ outAxisSizes.push_back(out->getDims()[idx]);
+ }
+ } else {
+ outAxisSizes.reserve(outputs.size());
+ for (const auto& output : outputs) {
+ outAxisSizes.push_back(output->desc().dim(axis));
+ }
+ }
+
+ vpu::DataVector usedOutputs;
+ for (int i = 0; i < outputs.size(); ++i) {
+ if (outputs[i] != nullptr) {
+ offsets.emplace_back(curOffset);
+ usedOutputs.push_back(outputs[i]);
+ }
+ curOffset.set(axis, curOffset[axis] + outAxisSizes[i]);
}
- auto stage = addSplitStage(model, name, layer, std::move(offsets), input, outputs);
+ auto stage = addSplitStage(model, name, layer, std::move(offsets), input, usedOutputs);
stage->attrs().set("axis", axis);
::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::Values(InferenceEngine::Layout::ANY),
- ::testing::Values(std::vector<size_t >({30, 30, 30, 30})),
+ ::testing::Values(std::vector<size_t>({30, 30, 30, 30})),
::testing::Values(CommonTestUtils::DEVICE_MYRIAD)),
SplitLayerTest::getTestCaseName);
+INSTANTIATE_TEST_CASE_P(smoke_splitWithUnusedOutputsTest, splitWithUnusedOutputsTest,
+ ::testing::Combine(
+ ::testing::Values(5),
+ // TODO: 0-axis excluded
+ // Check (status == ie::StatusCode::OK) failed: Failed to reshape Network:
+ // Failed to infer shapes for Split layer (Split_2) with error:
+ // The sum of the dimensions on the axis(0) is not equal out_sizes: [30]
+ ::testing::Values(1, 2, 3),
+ ::testing::ValuesIn(netPrecisions),
+ ::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
+ ::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
+ ::testing::Values(InferenceEngine::Layout::ANY),
+ ::testing::Values(InferenceEngine::Layout::ANY),
+ ::testing::Values(std::vector<size_t>({30, 30, 30, 30})),
+ ::testing::Values(std::vector<size_t>({0, 2}),
+ std::vector<size_t>({0, 4}),
+ std::vector<size_t>({2, 3})),
+ ::testing::Values(CommonTestUtils::DEVICE_MYRIAD)),
+ splitWithUnusedOutputsTest::getTestCaseName);
} // namespace
void SetUp() override;
};
-} // namespace LayerTestsDefinitions
\ No newline at end of file
+typedef std::tuple<
+ size_t, // Num splits
+ size_t, // Axis
+ InferenceEngine::Precision, // Net precision
+ InferenceEngine::Precision, // Input precision
+ InferenceEngine::Precision, // Output precision
+ InferenceEngine::Layout, // Input layout
+ InferenceEngine::Layout, // Output layout
+ std::vector<size_t>, // Input shapes
+ std::vector<size_t>, // Used outputs indices
+ std::string // Target device name
+> splitWithUnusedOutputsParams;
+
+class splitWithUnusedOutputsTest : public testing::WithParamInterface<splitWithUnusedOutputsParams>,
+ virtual public LayerTestsUtils::LayerTestsCommon {
+public:
+ static std::string getTestCaseName(testing::TestParamInfo<splitWithUnusedOutputsParams> obj);
+
+protected:
+ void SetUp() override;
+};
+
+} // namespace LayerTestsDefinitions
Run();
};
-} // namespace LayerTestsDefinitions
\ No newline at end of file
+std::string splitWithUnusedOutputsTest::getTestCaseName(testing::TestParamInfo<splitWithUnusedOutputsParams> obj) {
+ size_t numSplits, axis;
+ InferenceEngine::Precision netPrecision;
+ InferenceEngine::Precision inPrc, outPrc;
+ InferenceEngine::Layout inLayout, outLayout;
+ InferenceEngine::SizeVector inputShapes;
+ std::vector<size_t> outIndices;
+ std::string targetDevice;
+ std::tie(numSplits, axis, netPrecision, inPrc, outPrc, inLayout, outLayout, inputShapes, outIndices, targetDevice) = obj.param;
+ std::ostringstream result;
+ result << "IS=" << CommonTestUtils::vec2str(inputShapes) << "_";
+ result << "numSplits=" << numSplits << "_";
+ result << "axis=" << axis << "_";
+ result << "outIndices" << CommonTestUtils::vec2str(outIndices) << "_";
+ result << "IS";
+ result << "netPRC=" << netPrecision.name() << "_";
+ result << "inPRC=" << inPrc.name() << "_";
+ result << "outPRC=" << outPrc.name() << "_";
+ result << "inL=" << inLayout << "_";
+ result << "outL=" << outLayout << "_";
+ result << "trgDev=" << targetDevice;
+ return result.str();
+}
+
+void splitWithUnusedOutputsTest::SetUp() {
+ SetRefMode(LayerTestsUtils::RefMode::CONSTANT_FOLDING);
+ size_t axis, numSplits;
+ std::vector<size_t> inputShape;
+ InferenceEngine::Precision netPrecision;
+ std::vector<size_t> outIndices;
+ std::tie(numSplits, axis, netPrecision, inPrc, outPrc, inLayout, outLayout, inputShape, outIndices, 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::op::Parameter>(params));
+ auto split = std::dynamic_pointer_cast<ngraph::opset5::Split>(ngraph::builder::makeSplit(paramOuts[0],
+ ngPrc, numSplits, axis));
+ ngraph::ResultVector results;
+ for (int i = 0; i < outIndices.size(); i++) {
+ results.push_back(std::make_shared<ngraph::opset5::Result>(split->output(outIndices[i])));
+ }
+ function = std::make_shared<ngraph::Function>(results, params, "split");
+}
+
+TEST_P(splitWithUnusedOutputsTest, CompareWithRefs) {
+ Run();
+};
+
+} // namespace LayerTestsDefinitions