IntenseWebs/openvino
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[GNA] added split_to_concat_multi_inputs test (#7775)

Browse Source 
* added split_to_concat_multi_inputs test

* [GNA] fixes according to comments
  *Deleted commented str
  *Updated opset for MatMul
  *Added gna_sw_exact mode

* [GNA] Added input with n * 512 size

* [GNA] Changed input gen params

* rebase commit
This commit is contained in:
Andrey Noskov 2021-11-25 15:22:42 +03:00 committed by GitHub
parent f92ae6511b
commit 1f4aa79a01
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 164 additions and 201 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
inference-engine/tests/functional/plugin/gna/shared_tests_instances/subgraph_tests/split_concat_multi_inputs.cpp Normal file
View File

@ -0,0 +1,46 @@
// Copyright (C) 2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include <vector>
#include "subgraph_tests/split_concat_multi_inputs.hpp"
#include "common_test_utils/test_constants.hpp"
#include "gna/gna_config.hpp"
using namespace SubgraphTestsDefinitions;
namespace {
std::vector<InferenceEngine::Precision> precisions = {InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16};
std::vector<std::map<std::string, std::string>> additionalConfig = {
{
{"GNA_DEVICE_MODE", "GNA_SW_FP32"}
},
{
{"GNA_DEVICE_MODE", "GNA_SW_EXACT"}
}
};
std::vector<std::vector<size_t>> inputShapes = {
{1, 10},
{1, 50},
{1, 32},
{1, 512}
};
std::vector<size_t> splitsNum = {2, 3, 4, 10};
std::vector<bool> isFc = {false, true};
INSTANTIATE_TEST_SUITE_P(smoke_splitConcatMultiInputs, SplitConcatMultiInputsTest,
::testing::Combine(
::testing::ValuesIn(precisions),
::testing::Values(CommonTestUtils::DEVICE_GNA),
::testing::ValuesIn(additionalConfig),
::testing::ValuesIn(inputShapes),
::testing::ValuesIn(splitsNum),
::testing::ValuesIn(isFc)),
SplitConcatMultiInputsTest::getTestCaseName);
} // namespace

14
inference-engine/tests/functional/plugin/shared/include/subgraph_tests/split_concat_multi_inputs.hpp Normal file
View File

@ -0,0 +1,14 @@
// Copyright (C) 2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#pragma once
#include "shared_test_classes/subgraph/split_concat_multi_inputs.hpp"
namespace SubgraphTestsDefinitions {
TEST_P(SplitConcatMultiInputsTest, CompareWithRefs) {
Run();
};
} // namespace SubgraphTestsDefinitions

42
inference-engine/tests/functional/shared_test_classes/include/shared_test_classes/subgraph/split_concat_multi_inputs.hpp Normal file
View File

@ -0,0 +1,42 @@
// Copyright (C) 2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#pragma once
#include <tuple>
#include <vector>
#include <string>
#include <memory>
#include "shared_test_classes/base/layer_test_utils.hpp"
#include "ngraph_functions/utils/ngraph_helpers.hpp"
#include "ngraph_functions/builders.hpp"
namespace SubgraphTestsDefinitions {
typedef std::tuple<
InferenceEngine::Precision, // Network Precision
std::string, // Target Device
std::map<std::string, std::string>, // Configuration
std::vector<size_t>, // Input Shapes
size_t, // Num of Split outputs (concat inputs)
bool // with FC or not
> SplitConcatMultiInputsParams;
class SplitConcatMultiInputsTest : public testing::WithParamInterface<SplitConcatMultiInputsParams>,
public LayerTestsUtils::LayerTestsCommon {
public:
static std::string getTestCaseName(testing::TestParamInfo<SplitConcatMultiInputsParams> obj);
protected:
void SetUp() override;
InferenceEngine::Blob::Ptr GenerateInput(const InferenceEngine::InputInfo &info) const override;
float inputDataMin = 0.0;
float inputDataMax = 0.2;
float inputDataResolution = 1;
int32_t seed = 1;
};
} // namespace SubgraphTestsDefinitions

62
inference-engine/tests/functional/shared_test_classes/src/subgraph/split_concat_multi_inputs.cpp Normal file
View File

@ -0,0 +1,62 @@
// Copyright (C) 2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "shared_test_classes/subgraph/split_concat_multi_inputs.hpp"
#include "ngraph_functions/builders.hpp"
namespace SubgraphTestsDefinitions {
std::string SplitConcatMultiInputsTest::getTestCaseName(testing::TestParamInfo<SplitConcatMultiInputsParams> obj) {
std::vector<size_t> inputShape;
size_t splitsNum;
std::map<std::string, std::string> config;
InferenceEngine::Precision netPrecision;
std::string targetName;
bool withFC;
std::tie(netPrecision, targetName, config, inputShape, splitsNum, withFC) = obj.param;
std::ostringstream result;
result << "IS=" << CommonTestUtils::vec2str(inputShape) << "_";
result << "SplitsN=" << splitsNum << "_";
result << "netPRC=" << netPrecision.name() << "_";
result << "trgDev=" << targetName << "_";
result << "FC=" << withFC;
for (auto const& configItem : config) {
result << "_configItem=" << configItem.first << "_" << configItem.second;
}
return result.str();
}
void SplitConcatMultiInputsTest::SetUp() {
std::vector<size_t> inputShape;
size_t splitsNum;
std::map<std::string, std::string> tempConfig;
InferenceEngine::Precision netPrecision;
bool withFC;
std::tie(netPrecision, targetDevice, tempConfig, inputShape, splitsNum, withFC) = this->GetParam();
configuration.insert(tempConfig.begin(), tempConfig.end());
inputShape[1] *= splitsNum;
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision);
auto params = ngraph::builder::makeParams(ngPrc, {inputShape});
auto split = ngraph::builder::makeSplit(params[0], ngPrc, splitsNum, 1);
ngraph::OutputVector concatInputs = split->outputs();
auto concat = std::make_shared<ngraph::opset7::Concat>(concatInputs, 1);
if (withFC) {
auto mul_const = ngraph::builder::makeConstant<float>(ngPrc, { 10, inputShape[1] },
CommonTestUtils::generate_float_numbers(10 * inputShape[1], -0.2f, 0.2f), false);
auto matmul = std::make_shared<ngraph::op::MatMul>(concat, mul_const, false, true);
function = std::make_shared<ngraph::Function>(matmul, params, "SplitConcatMultiInputs");
} else {
function = std::make_shared<ngraph::Function>(concat, params, "SplitConcatMultiInputs");
}
}
InferenceEngine::Blob::Ptr SplitConcatMultiInputsTest::GenerateInput(const InferenceEngine::InputInfo &info) const {
return FuncTestUtils::createAndFillBlob(info.getTensorDesc(), inputDataMax - inputDataMin, inputDataMin, 1 / inputDataResolution,
seed);
}
} // namespace SubgraphTestsDefinitions

201
inference-engine/tests_deprecated/unit/engines/gna/fp32_non_quantized_tests.cpp
View File

@ -378,113 +378,6 @@ TEST_F(FP32NonQuantizedTest, TwoOutputsDiffPrecisionPropagateForward) {
.called_with().input("input_1", input_data).result().equals_to(result1).And().equals_to(result2);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith2InputsNotAlignedNoFC) {
std::vector<float> input_data(20);
std::iota(input_data.begin(), input_data.end(), 1.0f);
assert_that().onInferModel(SplitToConcatWith2InputsNotAlignedNoFC())
.inNotCompactMode().gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(input_data);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith2By50InputsNotAlignedNoFC) {
std::vector<float> input_data(100);
std::iota(input_data.begin(), input_data.end(), 1.0f);
assert_that().onInferModel(SplitToConcatWith2By50InputsNotAlignedNoFC())
.inNotCompactMode().gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(input_data);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith2By50InputsNotAlignedNoFCWithInCopyWithOutCopy) {
std::vector<float> input_data(100);
std::iota(input_data.begin(), input_data.end(), 1.0f);
assert_that().onInferModel(SplitToConcatWith2By50InputsNotAlignedNoFCWithInCopyWithOutCopy())
.inNotCompactMode().gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(input_data);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith3InputsNotAlignedNoFC) {
std::vector<float> input_data(30);
std::iota(input_data.begin(), input_data.end(), 1.0f);
assert_that().onInferModel(SplitToConcatWith3InputsNotAlignedNoFC())
.inNotCompactMode().gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(input_data);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith4InputsNotAlignedNoFC) {
std::vector<float> input_data(40);
std::iota(input_data.begin(), input_data.end(), 1.0f);
assert_that().onInferModel(SplitToConcatWith4InputsNotAlignedNoFC())
.inNotCompactMode().gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(input_data);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith4InputsNotAlignedNoFCWithOutCopy) {
std::vector<float> input_data(40);
std::iota(input_data.begin(), input_data.end(), 1.0f);
assert_that().onInferModel(SplitToConcatWith4InputsNotAlignedNoFCWithOutCopy())
.inNotCompactMode().gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(input_data);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith10InputsNotAlignedNoFC) {
std::vector<float> input_data(100);
std::iota(input_data.begin(), input_data.end(), 1.0f);
assert_that().onInferModel(SplitToConcatWith10InputsNotAlignedNoFC())
.inNotCompactMode().gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(input_data);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith10InputsNotAlignedNoFCWithOutCopy) {
std::vector<float> input_data(100);
std::iota(input_data.begin(), input_data.end(), 1.0f);
assert_that().onInferModel(SplitToConcatWith10InputsNotAlignedNoFCWithOutCopy())
.inNotCompactMode().gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(input_data);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith10By1InputsNotAlignedNoFCWithOutCopy) {
std::vector<float> input_data(10);
std::iota(input_data.begin(), input_data.end(), 1.0f);
assert_that().onInferModel(SplitToConcatWith10By1InputsNotAlignedNoFCWithOutCopy())
.inNotCompactMode().gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(input_data);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith2InputsNotAlignedWithFC) {
std::vector<float> input_data(20);
std::iota(input_data.begin(), input_data.end(), 1.0f);
std::vector<float> expected_result(10, 211.0f);
assert_that().onInferModel(SplitToConcatWith2InputsNotAlignedWithFC())
.inNotCompactMode().withWeigthsPattern({1}).gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(expected_result);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith3InputsNotAlignedWithFC) {
std::vector<float> input_data(30);
std::iota(input_data.begin(), input_data.end(), 1.0f);
std::vector<float> expected_result(10, 466.0f);
assert_that().onInferModel(SplitToConcatWith3InputsNotAlignedWithFC())
.inNotCompactMode().withWeigthsPattern({1}).gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(expected_result);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith3By512InputsWithOutCopy) {
std::vector<float> input_data(1536);
std::iota(input_data.begin(), input_data.end(), 1.0f);
assert_that().onInferModel(SplitToConcatWith3By512InputsWithOutCopy())
.inNotCompactMode().gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(input_data);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith10InputsNotAlignedWithFC) {
std::vector<float> input_data(100);
std::iota(input_data.begin(), input_data.end(), 1.0f);
std::vector<float> expected_result(10, 5051.0f);
assert_that().onInferModel(SplitToConcatWith10InputsNotAlignedWithFC())
.inNotCompactMode().withWeigthsPattern({1}).gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(expected_result);
}
TEST_F(FP32NonQuantizedTest, DISABLED_SplitToConcatWith2InputsAlignedNoFC) {
std::vector<float> input_data(64);
std::iota(input_data.begin(), input_data.end(), 1.0f);
@ -501,30 +394,6 @@ TEST_F(FP32NonQuantizedTest, DISABLED_SplitToConcatWith2By64InputsAlignedNoFC) {
.called_with_input(input_data).equals_to(input_data);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith2Inputs1360NotAlignedNoFC) {
std::vector<float> input_data(1360);
std::iota(input_data.begin(), input_data.end(), 1.0f);
assert_that().onInferModel(SplitToConcatWith2Inputs1360NotAlignedNoFC())
.inNotCompactMode().gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(input_data);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith2By64InputsAlignedNoFCWithOutCopy) {
std::vector<float> input_data(128);
std::iota(input_data.begin(), input_data.end(), 1.0f);
assert_that().onInferModel(SplitToConcatWith2By64InputsAlignedNoFCWithOutCopy())
.inNotCompactMode().gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(input_data);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith2InputsAlignedNoFCWithInCopyWithOutCopy) {
std::vector<float> input_data(64);
std::iota(input_data.begin(), input_data.end(), 1.0f);
assert_that().onInferModel(SplitToConcatWith2InputsAlignedNoFCWithInCopyWithOutCopy())
.inNotCompactMode().gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(input_data);
}
TEST_F(FP32NonQuantizedTest, DISABLED_SplitToConcatWith3InputsAlignedNoFC) {
std::vector<float> input_data(96);
std::iota(input_data.begin(), input_data.end(), 1.0f);
@ -533,14 +402,6 @@ TEST_F(FP32NonQuantizedTest, DISABLED_SplitToConcatWith3InputsAlignedNoFC) {
.called_with_input(input_data).equals_to(input_data);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith3InputsAlignedNoFCWithInCopyWithOutCopy) {
std::vector<float> input_data(96);
std::iota(input_data.begin(), input_data.end(), 1.0f);
assert_that().onInferModel(SplitToConcatWith3InputsAlignedNoFCWithInCopyWithOutCopy())
.inNotCompactMode().gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(input_data);
}
TEST_F(FP32NonQuantizedTest, DISABLED_SplitToConcatWith10InputsAlignedNoFC) {
std::vector<float> input_data(320);
std::iota(input_data.begin(), input_data.end(), 1.0f);
@ -549,68 +410,6 @@ TEST_F(FP32NonQuantizedTest, DISABLED_SplitToConcatWith10InputsAlignedNoFC) {
.called_with_input(input_data).equals_to(input_data);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith10InputsAlignedNoFCWithInCopyWithOutCopy) {
std::vector<float> input_data(320);
std::iota(input_data.begin(), input_data.end(), 1.0f);
assert_that().onInferModel(SplitToConcatWith10InputsAlignedNoFCWithInCopyWithOutCopy())
.inNotCompactMode().gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(input_data);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith2InputsAlignedWithFC) {
std::vector<float> input_data(64);
std::iota(input_data.begin(), input_data.end(), 1.0f);
std::vector<float> expected_result(32, 2081.0f);
assert_that().onInferModel(SplitToConcatWith2InputsAlignedWithFC())
.inNotCompactMode().withWeigthsPattern({1}).gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(expected_result);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith2InputsAlignedWithFCWithInCopy) {
std::vector<float> input_data(64);
std::iota(input_data.begin(), input_data.end(), 1.0f);
std::vector<float> expected_result(32, 2081.0f);
assert_that().onInferModel(SplitToConcatWith2InputsAlignedWithFCWithInCopy())
.inNotCompactMode().withWeigthsPattern({1}).gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(expected_result);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith3InputsAlignedWithFC) {
std::vector<float> input_data(96);
std::iota(input_data.begin(), input_data.end(), 1.0f);
std::vector<float> expected_result(32, 4657.0f);
assert_that().onInferModel(SplitToConcatWith3InputsAlignedWithFC())
.inNotCompactMode().withWeigthsPattern({1}).gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(expected_result);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith3InputsAlignedWithFCWithInCopy) {
std::vector<float> input_data(96);
std::iota(input_data.begin(), input_data.end(), 1.0f);
std::vector<float> expected_result(32, 4657.0f);
assert_that().onInferModel(SplitToConcatWith3InputsAlignedWithFCWithInCopy())
.inNotCompactMode().withWeigthsPattern({1}).gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(expected_result);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith10InputsAlignedWithFC) {
std::vector<float> input_data(320);
std::iota(input_data.begin(), input_data.end(), 1.0f);
std::vector<float> expected_result(32, 51361.0f);
assert_that().onInferModel(SplitToConcatWith10InputsAlignedWithFC())
.inNotCompactMode().withWeigthsPattern({1}).gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(expected_result);
}
TEST_F(FP32NonQuantizedTest, SplitToConcatWith10InputsAlignedWithFCWithInCopy) {
std::vector<float> input_data(320);
std::iota(input_data.begin(), input_data.end(), 1.0f);
std::vector<float> expected_result(32, 51361.0f);
assert_that().onInferModel(SplitToConcatWith10InputsAlignedWithFCWithInCopy())
.inNotCompactMode().withWeigthsPattern({1}).gna().propagate_forward().onCPU()
.called_with_input(input_data).equals_to(expected_result);
}
TEST_F(FP32NonQuantizedTest, ReshapeConvolutionLessThan48Filters) {
std::vector<float> input_data(800, 1.f);
std::vector<float> expected_result(1600, 8.f);