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

[CPU Tests] migrate FuseTransposeAndReorderTest to API 2.0 (#21297)

Browse Source
This commit is contained in:
River Li 2023-11-27 18:18:23 +08:00 committed by GitHub
parent 598da6e5c0
commit 45d6aa2171
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 139 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp
View File

@ -178,8 +178,6 @@ std::vector<std::string> disabledTestPatterns() {
R"(.*InferRequestIOBBlobTest.*canProcessDeallocatedOutputBlobAfterGetAndSetBlob.*)", R"(.*InferRequestIOBBlobTest.*canProcessDeallocatedOutputBlobAfterGetAndSetBlob.*)",
// Plugin version was changed to ov::Version // Plugin version was changed to ov::Version
R"(.*VersionTest.*pluginCurrentVersionIsCorrect.*)", R"(.*VersionTest.*pluginCurrentVersionIsCorrect.*)",
// Issue: 120286
R"(.*smoke_Basic/FuseTransposeAndReorderTest.CompareWithRefs.*)",
// Issue: 113703, 114763 // Issue: 113703, 114763
R"(.*smoke_If/SimpleIfTest.*Cond=0.*)", R"(.*smoke_If/SimpleIfTest.*Cond=0.*)",
// Issue: 114765 // Issue: 114765

34
src/plugins/intel_cpu/tests/functional/subgraph_tests/include/fuse_transpose_reorder.hpp
View File

@ -9,51 +9,51 @@
#include <string> #include <string>
#include "test_utils/cpu_test_utils.hpp" #include "test_utils/cpu_test_utils.hpp"
#include "shared_test_classes/base/layer_test_utils.hpp"
#include "ov_models/utils/ov_helpers.hpp" #include "ov_models/utils/ov_helpers.hpp"
#include "ov_models/builders.hpp" #include "ov_models/builders.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
using namespace CPUTestUtils; using namespace CPUTestUtils;
namespace SubgraphTestsDefinitions { namespace ov {
namespace test {
using FuseTransposeAndReorderParams = std::tuple< using FuseTransposeAndReorderParams = std::tuple<ov::Shape, // Input shape
InferenceEngine::SizeVector, // Input shape ov::element::Type // Input precision
InferenceEngine::Precision // Input precision >;
>;
class FuseTransposeAndReorderTest : public testing::WithParamInterface<FuseTransposeAndReorderParams>, public CPUTestsBase, class FuseTransposeAndReorderTest : public testing::WithParamInterface<FuseTransposeAndReorderParams>, public CPUTestsBase,
virtual public LayerTestsUtils::LayerTestsCommon { virtual public ov::test::SubgraphBaseStaticTest {
public: public:
static std::string getTestCaseName(testing::TestParamInfo<FuseTransposeAndReorderParams> obj); static std::string getTestCaseName(testing::TestParamInfo<FuseTransposeAndReorderParams> obj);
protected: protected:
void SetUp() override; void SetUp() override;
virtual void CreateGraph(); virtual void create_model();
void CheckTransposeCount(size_t expectedTransposeCount); void check_transpose_count(size_t expectedTransposeCount);
InferenceEngine::SizeVector inputShape; ov::Shape input_shape;
InferenceEngine::Precision inPrec; ov::element::Type in_prec;
}; };
class FuseTransposeAndReorderTest1 : public FuseTransposeAndReorderTest { class FuseTransposeAndReorderTest1 : public FuseTransposeAndReorderTest {
protected: protected:
void CreateGraph() override; void create_model() override;
}; };
class FuseTransposeAndReorderTest2 : public FuseTransposeAndReorderTest { class FuseTransposeAndReorderTest2 : public FuseTransposeAndReorderTest {
protected: protected:
void CreateGraph() override; void create_model() override;
}; };
class FuseTransposeAndReorderTest3 : public FuseTransposeAndReorderTest { class FuseTransposeAndReorderTest3 : public FuseTransposeAndReorderTest {
protected: protected:
void CreateGraph() override; void create_model() override;
}; };
class FuseTransposeAndReorderTest4 : public FuseTransposeAndReorderTest { class FuseTransposeAndReorderTest4 : public FuseTransposeAndReorderTest {
protected: protected:
void CreateGraph() override; void create_model() override;
}; };
} // namespace test
} // namespace SubgraphTestsDefinitions } // namespace ov

230
src/plugins/intel_cpu/tests/functional/subgraph_tests/src/fuse_transpose_reorder.cpp
View File

@ -3,59 +3,60 @@
// //
#include "subgraph_tests/include/fuse_transpose_reorder.hpp" #include "subgraph_tests/include/fuse_transpose_reorder.hpp"
#include <ov_models/preprocess/preprocess_builders.hpp> #include "common_test_utils/node_builders/convolution.hpp"
#include <openvino/openvino.hpp> #include "ov_models/builders.hpp"
#include "ov_models/preprocess/preprocess_builders.hpp"
#include "openvino/openvino.hpp"
using namespace InferenceEngine;
using namespace CPUTestUtils; using namespace CPUTestUtils;
namespace SubgraphTestsDefinitions { namespace ov {
namespace test {
std::string FuseTransposeAndReorderTest::getTestCaseName(testing::TestParamInfo<FuseTransposeAndReorderParams> obj) { std::string FuseTransposeAndReorderTest::getTestCaseName(testing::TestParamInfo<FuseTransposeAndReorderParams> obj) {
std::ostringstream result; std::ostringstream result;
SizeVector inputShape; ov::Shape input_shape;
Precision inPrec; ov::element::Type in_prec;
std::tie(inputShape, inPrec) = obj.param; std::tie(input_shape, in_prec) = obj.param;
result << "IS=" << ov::test::utils::vec2str(inputShape) << "_"; result << "IS=" << ov::test::utils::vec2str(input_shape) << "_";
result << "Precision=" << inPrec.name(); result << "Precision=" << in_prec.to_string();
return result.str(); return result.str();
} }
void FuseTransposeAndReorderTest::CheckTransposeCount(size_t expectedTransposeCount) { void FuseTransposeAndReorderTest::check_transpose_count(size_t expectedTransposeCount) {
InferenceEngine::CNNNetwork execGraphInfo = executableNetwork.GetExecGraphInfo(); auto runtime_model = compiledModel.get_runtime_model();
auto function = execGraphInfo.getFunction(); ASSERT_NE(nullptr, runtime_model);
ASSERT_NE(nullptr, function); size_t actual_transpose_count = 0;
size_t actualTransposeCount = 0; for (const auto &node : runtime_model->get_ops()) {
for (const auto &node : function->get_ops()) {
const auto & rtInfo = node->get_rt_info(); const auto & rtInfo = node->get_rt_info();
auto getExecValue = [&rtInfo](const std::string & paramName) -> std::string { auto getExecValue = [&rtInfo](const std::string & paramName) -> std::string {
auto it = rtInfo.find(paramName); auto it = rtInfo.find(paramName);
OPENVINO_ASSERT(rtInfo.end() != it); OPENVINO_ASSERT(rtInfo.end() != it);
return it->second.as<std::string>(); return it->second.as<std::string>();
}; };
if (getExecValue(ExecGraphInfoSerialization::LAYER_TYPE) == "Transpose") { if (getExecValue(ov::exec_model_info::LAYER_TYPE) == "Transpose") {
actualTransposeCount++; actual_transpose_count++;
} }
} }
ASSERT_EQ(expectedTransposeCount, actualTransposeCount); ASSERT_EQ(expectedTransposeCount, actual_transpose_count);
} }
void FuseTransposeAndReorderTest::SetUp() { void FuseTransposeAndReorderTest::SetUp() {
targetDevice = ov::test::utils::DEVICE_CPU; targetDevice = ov::test::utils::DEVICE_CPU;
SKIP_IF_CURRENT_TEST_IS_DISABLED(); SKIP_IF_CURRENT_TEST_IS_DISABLED();
std::tie(inputShape, inPrec) = this->GetParam(); std::tie(input_shape, in_prec) = this->GetParam();
CreateGraph(); create_model();
} }
const auto fuseTransposeAndReorderCommonParams = ::testing::Combine( const auto fuseTransposeAndReorderCommonParams = ::testing::Combine(
::testing::Values(SizeVector{1, 2, 3, 4}, SizeVector{1, 2, 3, 4, 5}), ::testing::Values(ov::Shape{1, 2, 3, 4}, ov::Shape{1, 2, 3, 4, 5}),
::testing::Values(Precision::I8, Precision::U8) ::testing::Values(ov::element::i8, ov::element::u8)
); );
/* FuseTransposeAndReorderTest graph /* FuseTransposeAndReorderTest model
--------- ---------
|Input | |Input |
--------- ---------
@ -75,30 +76,29 @@ const auto fuseTransposeAndReorderCommonParams = ::testing::Combine(
--------- ---------
*/ */
void FuseTransposeAndReorderTest::CreateGraph() { void FuseTransposeAndReorderTest::create_model() {
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inPrec); ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(in_prec, ov::Shape(input_shape))};
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))};
auto order = inputShape.size() == 5 ? std::vector<int64_t>{0, 2, 3, 4, 1} : std::vector<int64_t>{0, 2, 3, 1}; auto order = input_shape.size() == 5 ? std::vector<int64_t>{0, 2, 3, 4, 1} : std::vector<int64_t>{0, 2, 3, 1};
auto memFmt = inputShape.size() == 5 ? ndhwc : nhwc; auto memFmt = input_shape.size() == 5 ? ndhwc : nhwc;
auto constOrder = ngraph::builder::makeConstant(ngraph::element::i64, {inputShape.size()}, order); auto constOrder = ngraph::builder::makeConstant(ov::element::i64, {input_shape.size()}, order);
auto transpose = std::make_shared<ngraph::opset5::Transpose>(params[0], constOrder); auto transpose = std::make_shared<ov::op::v1::Transpose>(params[0], constOrder);
transpose->get_rt_info() = makeCPUInfo({memFmt}, {memFmt}, {}); transpose->get_rt_info() = makeCPUInfo({memFmt}, {memFmt}, {});
ngraph::ResultVector results{std::make_shared<ngraph::opset5::Result>(transpose)}; ov::ResultVector results{std::make_shared<ov::op::v0::Result>(transpose)};
function = std::make_shared<ngraph::Function>(results, params, "TransposeReorder"); function = std::make_shared<ov::Model>(results, params, "TransposeReorder");
} }
TEST_P(FuseTransposeAndReorderTest, CompareWithRefs) { TEST_P(FuseTransposeAndReorderTest, CompareWithRefs) {
Run(); run();
CheckTransposeCount(0); check_transpose_count(0);
} }
INSTANTIATE_TEST_SUITE_P(smoke_Basic, FuseTransposeAndReorderTest, fuseTransposeAndReorderCommonParams, FuseTransposeAndReorderTest::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Basic, FuseTransposeAndReorderTest, fuseTransposeAndReorderCommonParams, FuseTransposeAndReorderTest::getTestCaseName);
/* FuseTransposeAndReorderTest1 graph /* FuseTransposeAndReorderTest1 model
--------- ---------
|Input | |Input |
--------- ---------
@ -134,40 +134,38 @@ INSTANTIATE_TEST_SUITE_P(smoke_Basic, FuseTransposeAndReorderTest, fuseTranspose
--------- ---------
*/ */
void FuseTransposeAndReorderTest1::CreateGraph() { void FuseTransposeAndReorderTest1::create_model() {
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inPrec); ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(in_prec, ov::Shape(input_shape))};
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))}; auto order = input_shape.size() == 5 ? std::vector<int64_t>{0, 2, 3, 4, 1} : std::vector<int64_t>{0, 2, 3, 1};
auto order = inputShape.size() == 5 ? std::vector<int64_t>{0, 2, 3, 4, 1} : std::vector<int64_t>{0, 2, 3, 1}; auto constOrder1 = ngraph::builder::makeConstant(ov::element::i64, {input_shape.size()}, order);
auto transpose1 = std::make_shared<ov::op::v1::Transpose>(params[0], constOrder1);
auto constOrder1 = ngraph::builder::makeConstant(ngraph::element::i64, {inputShape.size()}, order); auto memFmt1 = input_shape.size() == 5 ? ndhwc : nhwc;
auto transpose1 = std::make_shared<ngraph::opset5::Transpose>(params[0], constOrder1);
auto memFmt1 = inputShape.size() == 5 ? ndhwc : nhwc;
transpose1->get_rt_info() = makeCPUInfo({memFmt1}, {memFmt1}, {}); transpose1->get_rt_info() = makeCPUInfo({memFmt1}, {memFmt1}, {});
auto constOrder2 = ngraph::builder::makeConstant(ngraph::element::i64, {inputShape.size()}, order); auto constOrder2 = ngraph::builder::makeConstant(ov::element::i64, {input_shape.size()}, order);
auto transpose2 = std::make_shared<ngraph::opset5::Transpose>(transpose1, constOrder2); auto transpose2 = std::make_shared<ov::op::v1::Transpose>(transpose1, constOrder2);
auto memFmt2 = inputShape.size() == 5 ? ndhwc : nhwc; auto memFmt2 = input_shape.size() == 5 ? ndhwc : nhwc;
transpose2->get_rt_info() = makeCPUInfo({memFmt2}, {memFmt2}, {}); transpose2->get_rt_info() = makeCPUInfo({memFmt2}, {memFmt2}, {});
auto constOrder3 = ngraph::builder::makeConstant(ngraph::element::i64, {inputShape.size()}, order); auto constOrder3 = ngraph::builder::makeConstant(ov::element::i64, {input_shape.size()}, order);
auto transpose3 = std::make_shared<ngraph::opset5::Transpose>(transpose2, constOrder3); auto transpose3 = std::make_shared<ov::op::v1::Transpose>(transpose2, constOrder3);
auto memFmt3 = inputShape.size() == 5 ? ncdhw : nchw; auto memFmt3 = input_shape.size() == 5 ? ncdhw : nchw;
transpose3->get_rt_info() = makeCPUInfo({memFmt3}, {memFmt3}, {}); transpose3->get_rt_info() = makeCPUInfo({memFmt3}, {memFmt3}, {});
auto shape = ngraph::builder::makeConstant(ngraph::element::i64, {inputShape.size()}, transpose3->get_output_shape(0)); auto shape = ngraph::builder::makeConstant(ov::element::i64, {input_shape.size()}, transpose3->get_output_shape(0));
auto reshape = std::make_shared<ngraph::opset5::Reshape>(transpose1, shape, false); auto reshape = std::make_shared<ov::op::v1::Reshape>(transpose1, shape, false);
auto concat = std::make_shared<ov::op::v0::Concat>(ov::NodeVector{transpose3, reshape}, 1); auto concat = std::make_shared<ov::op::v0::Concat>(ov::NodeVector{transpose3, reshape}, 1);
ngraph::ResultVector results{std::make_shared<ngraph::opset5::Result>(concat)}; ov::ResultVector results{std::make_shared<ov::op::v0::Result>(concat)};
function = std::make_shared<ngraph::Function>(results, params, "Transpose_TransposeReorderTranspose_Reshape_Concat"); function = std::make_shared<ov::Model>(results, params, "Transpose_TransposeReorderTranspose_Reshape_Concat");
} }
// Test disabled temporarily, it conflicts with TransposeFuse transformation in common optimizations step // Test disabled temporarily, it conflicts with TransposeFuse transformation in common optimizations step
TEST_P(FuseTransposeAndReorderTest1, DISABLED_CompareWithRefs) { TEST_P(FuseTransposeAndReorderTest1, DISABLED_CompareWithRefs) {
Run(); run();
CheckTransposeCount(2); check_transpose_count(2);
} }
INSTANTIATE_TEST_SUITE_P(smoke_Basic, FuseTransposeAndReorderTest1, fuseTransposeAndReorderCommonParams, FuseTransposeAndReorderTest::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Basic, FuseTransposeAndReorderTest1, fuseTransposeAndReorderCommonParams, FuseTransposeAndReorderTest::getTestCaseName);
@ -199,35 +197,33 @@ INSTANTIATE_TEST_SUITE_P(smoke_Basic, FuseTransposeAndReorderTest1, fuseTranspos
--------- ---------
*/ */
void FuseTransposeAndReorderTest2::CreateGraph() { void FuseTransposeAndReorderTest2::create_model() {
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inPrec); auto input_shape2(input_shape);
input_shape2[input_shape2.size() - 1] *= 2;
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(in_prec, ov::Shape(input_shape)),
std::make_shared<ov::op::v0::Parameter>(in_prec, ov::Shape(input_shape2))};
auto order = input_shape.size() == 5 ? std::vector<int64_t>{0, 4, 1, 2, 3} : std::vector<int64_t>{0, 3, 1, 2};
auto inputShape2(inputShape); auto constOrder1 = ngraph::builder::makeConstant(ov::element::i64, {input_shape.size()}, order);
inputShape2[inputShape2.size() - 1] *= 2; auto transpose1 = std::make_shared<ov::op::v1::Transpose>(params[0], constOrder1);
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape)), auto memFmt1 = input_shape.size() == 5 ? ndhwc : nhwc;
std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape2))};
auto order = inputShape.size() == 5 ? std::vector<int64_t>{0, 4, 1, 2, 3} : std::vector<int64_t>{0, 3, 1, 2};
auto constOrder1 = ngraph::builder::makeConstant(ngraph::element::i64, {inputShape.size()}, order);
auto transpose1 = std::make_shared<ngraph::opset5::Transpose>(params[0], constOrder1);
auto memFmt1 = inputShape.size() == 5 ? ndhwc : nhwc;
transpose1->get_rt_info() = makeCPUInfo({memFmt1}, {memFmt1}, {}); transpose1->get_rt_info() = makeCPUInfo({memFmt1}, {memFmt1}, {});
auto constOrder2 = ngraph::builder::makeConstant(ngraph::element::i64, {inputShape.size()}, order); auto constOrder2 = ngraph::builder::makeConstant(ov::element::i64, {input_shape.size()}, order);
auto transpose2 = std::make_shared<ngraph::opset5::Transpose>(params[1], constOrder2); auto transpose2 = std::make_shared<ov::op::v1::Transpose>(params[1], constOrder2);
auto memFmt2 = inputShape.size() == 5 ? ncdhw : nchw; auto memFmt2 = input_shape.size() == 5 ? ncdhw : nchw;
transpose2->get_rt_info() = makeCPUInfo({memFmt2}, {memFmt2}, {}); transpose2->get_rt_info() = makeCPUInfo({memFmt2}, {memFmt2}, {});
auto concat = std::make_shared<ov::op::v0::Concat>(ov::NodeVector{transpose1, transpose2}, 1); auto concat = std::make_shared<ov::op::v0::Concat>(ov::NodeVector{transpose1, transpose2}, 1);
concat->get_rt_info() = makeCPUInfo({memFmt1, memFmt1}, {memFmt1}, {}); concat->get_rt_info() = makeCPUInfo({memFmt1, memFmt1}, {memFmt1}, {});
ngraph::ResultVector results{std::make_shared<ngraph::opset5::Result>(concat)}; ov::ResultVector results{std::make_shared<ov::op::v0::Result>(concat)};
function = std::make_shared<ngraph::Function>(results, params, "Transpose_Transpose_Concat"); function = std::make_shared<ov::Model>(results, params, "Transpose_Transpose_Concat");
} }
TEST_P(FuseTransposeAndReorderTest2, CompareWithRefs) { TEST_P(FuseTransposeAndReorderTest2, CompareWithRefs) {
Run(); run();
CheckTransposeCount(1); check_transpose_count(1);
} }
INSTANTIATE_TEST_SUITE_P(smoke_Basic, FuseTransposeAndReorderTest2, fuseTransposeAndReorderCommonParams, FuseTransposeAndReorderTest::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Basic, FuseTransposeAndReorderTest2, fuseTransposeAndReorderCommonParams, FuseTransposeAndReorderTest::getTestCaseName);
@ -247,44 +243,48 @@ INSTANTIATE_TEST_SUITE_P(smoke_Basic, FuseTransposeAndReorderTest2, fuseTranspos
Result Result
*/ */
void FuseTransposeAndReorderTest3::CreateGraph() { void FuseTransposeAndReorderTest3::create_model() {
OPENVINO_ASSERT(inputShape.size() == 4); OPENVINO_ASSERT(input_shape.size() == 4);
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inPrec);
auto memFmt = nhwc; auto memFmt = nhwc;
ngraph::op::PadType padType = ngraph::op::PadType::SAME_UPPER; ov::op::PadType padType = ov::op::PadType::SAME_UPPER;
InferenceEngine::SizeVector kernel{3, 3}, stride{1, 1}, dilation{1, 1}; ov::Shape kernel{3, 3}, stride{1, 1}, dilation{1, 1};
std::vector<ptrdiff_t> padBegin{0, 0}, padEnd{0, 0}; std::vector<ptrdiff_t> padBegin{0, 0}, padEnd{0, 0};
size_t convOutChannels = 32; size_t convOutChannels = 32;
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))}; ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(in_prec, ov::Shape(input_shape))};
OPENVINO_ASSERT(inputShape[1] >= 8 && (inputShape[1] % 8 == 0)); OPENVINO_ASSERT(input_shape[1] >= 8 && (input_shape[1] % 8 == 0));
auto convolutionNode = ov::test::utils::make_convolution(params.front(),
auto convolutionNode = ngraph::builder::makeConvolution(params.front(), ngPrc, kernel, stride, padBegin, in_prec,
padEnd, dilation, padType, convOutChannels); kernel,
stride,
padBegin,
padEnd,
dilation,
padType,
convOutChannels);
convolutionNode->get_rt_info() = makeCPUInfo({memFmt}, {memFmt}, {}); convolutionNode->get_rt_info() = makeCPUInfo({memFmt}, {memFmt}, {});
auto sndAddIn = std::make_shared<ngraph::opset1::Parameter>(ngPrc, convolutionNode->get_output_shape(0)); auto sndAddIn = std::make_shared<ov::op::v0::Parameter>(in_prec, convolutionNode->get_output_shape(0));
params.push_back(sndAddIn); params.push_back(sndAddIn);
auto add = std::make_shared<ngraph::opset1::Add>(convolutionNode->output(0), sndAddIn); auto add = std::make_shared<ov::op::v1::Add>(convolutionNode->output(0), sndAddIn);
auto order = std::vector<int64_t>{0, 2, 3, 1}; auto order = std::vector<int64_t>{0, 2, 3, 1};
auto constOrder = ngraph::builder::makeConstant(ngraph::element::i64, {order.size()}, order); auto constOrder = ngraph::builder::makeConstant(ov::element::i64, {order.size()}, order);
auto transpose = std::make_shared<ngraph::opset5::Transpose>(add, constOrder); auto transpose = std::make_shared<ov::op::v1::Transpose>(add, constOrder);
transpose->get_rt_info() = makeCPUInfo({memFmt}, {memFmt}, {}); transpose->get_rt_info() = makeCPUInfo({memFmt}, {memFmt}, {});
ngraph::ResultVector results{std::make_shared<ngraph::opset5::Result>(transpose)}; ov::ResultVector results{std::make_shared<ov::op::v0::Result>(transpose)};
function = std::make_shared<ngraph::Function>(results, params, "TransposeReorder"); function = std::make_shared<ov::Model>(results, params, "TransposeReorder");
} }
TEST_P(FuseTransposeAndReorderTest3, CompareWithRefs) { TEST_P(FuseTransposeAndReorderTest3, CompareWithRefs) {
Run(); run();
CheckTransposeCount(1); check_transpose_count(1);
} }
const auto convSumTranposeParams = ::testing::Combine(::testing::Values(SizeVector{1, 16, 32, 35}), const auto convSumTranposeParams = ::testing::Combine(::testing::Values(ov::Shape{1, 16, 32, 35}),
::testing::Values(Precision::FP32) ::testing::Values(ov::element::f32)
); );
INSTANTIATE_TEST_SUITE_P(smoke_Basic, FuseTransposeAndReorderTest3, convSumTranposeParams, FuseTransposeAndReorderTest::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Basic, FuseTransposeAndReorderTest3, convSumTranposeParams, FuseTransposeAndReorderTest::getTestCaseName);
@ -306,27 +306,40 @@ INSTANTIATE_TEST_SUITE_P(smoke_Basic, FuseTransposeAndReorderTest3, convSumTranp
| |
result result
*/ */
void FuseTransposeAndReorderTest4::CreateGraph() { void FuseTransposeAndReorderTest4::create_model() {
OPENVINO_ASSERT(inputShape.size() == 4); OPENVINO_ASSERT(input_shape.size() == 4);
const InferenceEngine::SizeVector kernel = {1, 1}; const ov::Shape kernel = {1, 1};
const InferenceEngine::SizeVector stride = {1, 1}; const ov::Shape stride = {1, 1};
const InferenceEngine::SizeVector dilation = {1, 1}; const ov::Shape dilation = {1, 1};
const std::vector<ptrdiff_t> padBegin = {0, 0}; const std::vector<ptrdiff_t> padBegin = {0, 0};
const std::vector<ptrdiff_t> padEnd = {0, 0}; const std::vector<ptrdiff_t> padEnd = {0, 0};
const size_t convOutChannels = 4; const size_t convOutChannels = 4;
auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inPrec);
auto memFmt = nhwc; auto memFmt = nhwc;
ov::ParameterVector inputParams {std::make_shared<ov::op::v0::Parameter>(ngPrc, ov::Shape(inputShape))}; ov::ParameterVector inputParams{std::make_shared<ov::op::v0::Parameter>(in_prec, ov::Shape(input_shape))};
const auto relu = std::make_shared<ov::op::v0::Relu>(inputParams[0]); const auto relu = std::make_shared<ov::op::v0::Relu>(inputParams[0]);
const auto transposeOrder = ov::op::v0::Constant::create(ov::element::i32, {4}, {0, 3, 1, 2}); const auto transposeOrder = ov::op::v0::Constant::create(ov::element::i32, {4}, {0, 3, 1, 2});
const auto transpose1 = std::make_shared<ov::op::v1::Transpose>(relu, transposeOrder); const auto transpose1 = std::make_shared<ov::op::v1::Transpose>(relu, transposeOrder);
const auto conv1 = ngraph::builder::makeConvolution(transpose1, ngPrc, kernel, stride, padBegin, const auto conv1 = ov::test::utils::make_convolution(transpose1,
padEnd, dilation, ngraph::op::PadType::AUTO, convOutChannels); in_prec,
kernel,
stride,
padBegin,
padEnd,
dilation,
ov::op::PadType::AUTO,
convOutChannels);
conv1->get_rt_info() = makeCPUInfo({memFmt}, {memFmt}, {}); conv1->get_rt_info() = makeCPUInfo({memFmt}, {memFmt}, {});
const auto transpose2 = std::make_shared<ov::op::v1::Transpose>(relu, transposeOrder); const auto transpose2 = std::make_shared<ov::op::v1::Transpose>(relu, transposeOrder);
const auto conv2 = ngraph::builder::makeConvolution(transpose2, ngPrc, kernel, stride, padBegin, const auto conv2 = ov::test::utils::make_convolution(transpose2,
padEnd, dilation, ngraph::op::PadType::AUTO, convOutChannels); in_prec,
kernel,
stride,
padBegin,
padEnd,
dilation,
ov::op::PadType::AUTO,
convOutChannels);
conv2->get_rt_info() = makeCPUInfo({memFmt}, {memFmt}, {}); conv2->get_rt_info() = makeCPUInfo({memFmt}, {memFmt}, {});
const auto add = std::make_shared<ov::op::v1::Add>(conv1, conv2); const auto add = std::make_shared<ov::op::v1::Add>(conv1, conv2);
@ -335,8 +348,8 @@ void FuseTransposeAndReorderTest4::CreateGraph() {
} }
TEST_P(FuseTransposeAndReorderTest4, CompareWithRefs) { TEST_P(FuseTransposeAndReorderTest4, CompareWithRefs) {
Run(); run();
CheckTransposeCount(0); check_transpose_count(0);
} }
INSTANTIATE_TEST_SUITE_P(smoke_Basic, FuseTransposeAndReorderTest4, convSumTranposeParams, FuseTransposeAndReorderTest::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Basic, FuseTransposeAndReorderTest4, convSumTranposeParams, FuseTransposeAndReorderTest::getTestCaseName);
@ -353,4 +366,5 @@ TEST(smoke_Basic, FuseDynamicTransposeAndReorderTest) {
ASSERT_NO_THROW(core.compile_model(model, "CPU")); ASSERT_NO_THROW(core.compile_model(model, "CPU"));
} }
} // namespace SubgraphTestsDefinitions } // namespace test
} // namespace ov