From 34a86ecb3a6f9d06a4e1711f8c40bfcae915f4ad Mon Sep 17 00:00:00 2001 From: Oleg Pipikin Date: Tue, 10 Oct 2023 11:25:57 +0200 Subject: [PATCH] Refactor BinaryConvolutionLayerTest and BucketizeLayerTest (#19654) * Refactor BinaryConvolutionLayerTest * Refactor BucketizeLayerTest --- .../single_layer_tests/binary_convolution.cpp | 31 ++++---- .../single_layer_tests/bucketize.cpp | 57 +++++++------ .../single_layer_tests/binary_convolution.hpp | 1 - .../single_op_tests/binary_convolution.hpp | 15 ++++ .../include/single_op_tests/bucketize.hpp | 15 ++++ .../single_op/binary_convolution.hpp | 42 ++++++++++ .../single_op/bucketize.hpp | 33 ++++++++ .../src/single_layer/bucketize.cpp | 1 - .../src/single_op/binary_convolution.cpp | 79 +++++++++++++++++++ .../src/single_op/bucketize.cpp | 61 ++++++++++++++ 10 files changed, 287 insertions(+), 48 deletions(-) create mode 100644 src/tests/functional/plugin/shared/include/single_op_tests/binary_convolution.hpp create mode 100644 src/tests/functional/plugin/shared/include/single_op_tests/bucketize.hpp create mode 100644 src/tests/functional/shared_test_classes/include/shared_test_classes/single_op/binary_convolution.hpp create mode 100644 src/tests/functional/shared_test_classes/include/shared_test_classes/single_op/bucketize.hpp create mode 100644 src/tests/functional/shared_test_classes/src/single_op/binary_convolution.cpp create mode 100644 src/tests/functional/shared_test_classes/src/single_op/bucketize.cpp diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/binary_convolution.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/binary_convolution.cpp index 53a249873e2..da2df80eb7d 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/binary_convolution.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/binary_convolution.cpp @@ -4,16 +4,17 @@ #include -#include "single_layer_tests/binary_convolution.hpp" +#include "single_op_tests/binary_convolution.hpp" #include "common_test_utils/test_constants.hpp" -using namespace LayerTestsDefinitions; +using ov::test::BinaryConvolutionLayerTest; namespace { -const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, InferenceEngine::Precision::FP16, - InferenceEngine::Precision::I32}; +const std::vector model_types = { + ov::element::f32, + ov::element::f16, + ov::element::i32}; /* ============= 2D Binary Convolution ============= */ const std::vector> kernels = {{3, 3}, {3, 5}}; @@ -24,6 +25,10 @@ const std::vector> dilations = {{1, 1}, {3, 1}}; const std::vector numOutChannels = {1, 5}; const std::vector padValues = {0, 1}; +const std::vector> input_shapes_static = { + {{ 1, 3, 30, 30}}, +}; + const auto binConv2DParams_ExplicitPadding = ::testing::Combine( ::testing::ValuesIn(kernels), ::testing::ValuesIn(strides), @@ -48,12 +53,8 @@ INSTANTIATE_TEST_SUITE_P( smoke_BinaryConvolution2D_ExplicitPadding, BinaryConvolutionLayerTest, ::testing::Combine( binConv2DParams_ExplicitPadding, - ::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({1, 3, 30, 30})), + ::testing::ValuesIn(model_types), + ::testing::ValuesIn(ov::test::static_shapes_to_test_representation(input_shapes_static)), ::testing::Values(ov::test::utils::DEVICE_CPU)), BinaryConvolutionLayerTest::getTestCaseName); @@ -61,12 +62,8 @@ INSTANTIATE_TEST_SUITE_P( smoke_BinaryConvolution2D_AutoPadValid, BinaryConvolutionLayerTest, ::testing::Combine( binConv2DParams_ValidPadding, - ::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({1, 3, 30, 30})), + ::testing::ValuesIn(model_types), + ::testing::ValuesIn(ov::test::static_shapes_to_test_representation(input_shapes_static)), ::testing::Values(ov::test::utils::DEVICE_CPU)), BinaryConvolutionLayerTest::getTestCaseName); diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/bucketize.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/bucketize.cpp index 4ac333bb09c..f1c08370ebf 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/bucketize.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/bucketize.cpp @@ -4,53 +4,52 @@ #include -#include "single_layer_tests/bucketize.hpp" +#include "single_op_tests/bucketize.hpp" #include "common_test_utils/test_constants.hpp" -using namespace LayerTestsDefinitions; +using ov::test::BucketizeLayerTest; -const std::vector> dataShapes = { - {1, 20, 20}, - {2, 3, 50, 50} +namespace { +const std::vector> input_shapes_static = { + //data_shape, bucket_shape + {{ 1, 20, 20 }, {5}}, + {{ 1, 20, 20 }, {20}}, + {{ 1, 20, 20 }, {100}}, + {{ 2, 3, 50, 50 }, {5}}, + {{ 2, 3, 50, 50 }, {20}}, + {{ 2, 3, 50, 50 }, {100}} }; -const std::vector> bucketsShapes = { - {5}, - {20}, - {100} +const std::vector in_types = { + ov::element::f32, + ov::element::f16, + ov::element::i64, + ov::element::i32 }; -const std::vector inPrc = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16, - InferenceEngine::Precision::I64, - InferenceEngine::Precision::I32 -}; - -const std::vector netPrc = { - InferenceEngine::Precision::I64, - InferenceEngine::Precision::I32 +const std::vector model_types = { + ov::element::i64, + ov::element::i32 }; const auto test_Bucketize_right_edge = ::testing::Combine( - ::testing::ValuesIn(dataShapes), - ::testing::ValuesIn(bucketsShapes), + ::testing::ValuesIn(ov::test::static_shapes_to_test_representation(input_shapes_static)), ::testing::Values(true), - ::testing::ValuesIn(inPrc), - ::testing::ValuesIn(inPrc), - ::testing::ValuesIn(netPrc), + ::testing::ValuesIn(in_types), + ::testing::ValuesIn(in_types), + ::testing::ValuesIn(model_types), ::testing::Values(ov::test::utils::DEVICE_CPU) ); const auto test_Bucketize_left_edge = ::testing::Combine( - ::testing::ValuesIn(dataShapes), - ::testing::ValuesIn(bucketsShapes), + ::testing::ValuesIn(ov::test::static_shapes_to_test_representation(input_shapes_static)), ::testing::Values(false), - ::testing::ValuesIn(inPrc), - ::testing::ValuesIn(inPrc), - ::testing::ValuesIn(netPrc), + ::testing::ValuesIn(in_types), + ::testing::ValuesIn(in_types), + ::testing::ValuesIn(model_types), ::testing::Values(ov::test::utils::DEVICE_CPU) ); INSTANTIATE_TEST_SUITE_P(smoke_TestsBucketize_right, BucketizeLayerTest, test_Bucketize_right_edge, BucketizeLayerTest::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_TestsBucketize_left, BucketizeLayerTest, test_Bucketize_left_edge, BucketizeLayerTest::getTestCaseName); +} // namespace diff --git a/src/tests/functional/plugin/shared/include/single_layer_tests/binary_convolution.hpp b/src/tests/functional/plugin/shared/include/single_layer_tests/binary_convolution.hpp index f6f2fbdbbc9..6d76bf71a3e 100644 --- a/src/tests/functional/plugin/shared/include/single_layer_tests/binary_convolution.hpp +++ b/src/tests/functional/plugin/shared/include/single_layer_tests/binary_convolution.hpp @@ -7,7 +7,6 @@ #include "shared_test_classes/single_layer/binary_convolution.hpp" namespace LayerTestsDefinitions { - TEST_P(BinaryConvolutionLayerTest, CompareWithRefs) { Run(); } diff --git a/src/tests/functional/plugin/shared/include/single_op_tests/binary_convolution.hpp b/src/tests/functional/plugin/shared/include/single_op_tests/binary_convolution.hpp new file mode 100644 index 00000000000..4f1e93f4155 --- /dev/null +++ b/src/tests/functional/plugin/shared/include/single_op_tests/binary_convolution.hpp @@ -0,0 +1,15 @@ +// Copyright (C) 2018-2023 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include "shared_test_classes/single_op/binary_convolution.hpp" + +namespace ov { +namespace test { +TEST_P(BinaryConvolutionLayerTest, Inference) { + run(); +} +} // namespace test +} // namespace ov diff --git a/src/tests/functional/plugin/shared/include/single_op_tests/bucketize.hpp b/src/tests/functional/plugin/shared/include/single_op_tests/bucketize.hpp new file mode 100644 index 00000000000..3056be6c48d --- /dev/null +++ b/src/tests/functional/plugin/shared/include/single_op_tests/bucketize.hpp @@ -0,0 +1,15 @@ +// Copyright (C) 2018-2023 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include "shared_test_classes/single_op/bucketize.hpp" + +namespace ov { +namespace test { +TEST_P(BucketizeLayerTest, Inference) { + run(); +} +} // namespace test +} // namespace ov diff --git a/src/tests/functional/shared_test_classes/include/shared_test_classes/single_op/binary_convolution.hpp b/src/tests/functional/shared_test_classes/include/shared_test_classes/single_op/binary_convolution.hpp new file mode 100644 index 00000000000..14d388a8883 --- /dev/null +++ b/src/tests/functional/shared_test_classes/include/shared_test_classes/single_op/binary_convolution.hpp @@ -0,0 +1,42 @@ +// Copyright (C) 2018-2023 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include +#include +#include +#include + +#include "shared_test_classes/base/ov_subgraph.hpp" + +namespace ov { +namespace test { + +using binConvSpecificParams = std::tuple< + std::vector, // Kernel size + std::vector, // Strides + std::vector, // Pads begin + std::vector, // Pads end + std::vector, // Dilations + size_t, // Num Output channels + ov::op::PadType, // Padding type + float>; // Padding value + +using binaryConvolutionTestParamsSet = std::tuple< + binConvSpecificParams, // + ov::element::Type, // Model Type + std::vector, // Input shape + std::string>; // Device name + +class BinaryConvolutionLayerTest : public testing::WithParamInterface, + virtual public ov::test::SubgraphBaseTest { +public: + static std::string getTestCaseName(const testing::TestParamInfo& obj); +protected: + void SetUp() override; +}; + +} // namespace test +} // namespace ov diff --git a/src/tests/functional/shared_test_classes/include/shared_test_classes/single_op/bucketize.hpp b/src/tests/functional/shared_test_classes/include/shared_test_classes/single_op/bucketize.hpp new file mode 100644 index 00000000000..509a1405379 --- /dev/null +++ b/src/tests/functional/shared_test_classes/include/shared_test_classes/single_op/bucketize.hpp @@ -0,0 +1,33 @@ +// Copyright (C) 2018-2023 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include +#include + +#include "shared_test_classes/base/ov_subgraph.hpp" + +namespace ov { +namespace test { + +using bucketizeParamsTuple = std::tuple< + std::vector, // data shape, bucket shape + bool, // Right edge of interval + ov::element::Type, // Data input precision + ov::element::Type, // Buckets input precision + ov::element::Type, // Output precision + std::string>; // Device name + +class BucketizeLayerTest : public testing::WithParamInterface, + virtual public ov::test::SubgraphBaseTest { +public: + static std::string getTestCaseName(const testing::TestParamInfo& obj); +protected: + void SetUp() override; +}; + + +} // namespace test +} // namespace ov \ No newline at end of file diff --git a/src/tests/functional/shared_test_classes/src/single_layer/bucketize.cpp b/src/tests/functional/shared_test_classes/src/single_layer/bucketize.cpp index 30f162feeb2..381a2c9f55f 100644 --- a/src/tests/functional/shared_test_classes/src/single_layer/bucketize.cpp +++ b/src/tests/functional/shared_test_classes/src/single_layer/bucketize.cpp @@ -5,7 +5,6 @@ #include "shared_test_classes/single_layer/bucketize.hpp" namespace LayerTestsDefinitions { - std::string BucketizeLayerTest::getTestCaseName(const testing::TestParamInfo& obj) { InferenceEngine::SizeVector dataShape; InferenceEngine::SizeVector bucketsShape; diff --git a/src/tests/functional/shared_test_classes/src/single_op/binary_convolution.cpp b/src/tests/functional/shared_test_classes/src/single_op/binary_convolution.cpp new file mode 100644 index 00000000000..b2f056457a8 --- /dev/null +++ b/src/tests/functional/shared_test_classes/src/single_op/binary_convolution.cpp @@ -0,0 +1,79 @@ +// Copyright (C) 2018-2023 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "shared_test_classes/single_op/binary_convolution.hpp" + +#include "ov_models/builders.hpp" +#include "common_test_utils/ov_tensor_utils.hpp" + +namespace ov { +namespace test { +std::string BinaryConvolutionLayerTest::getTestCaseName(const testing::TestParamInfo& obj) { + binConvSpecificParams bin_conv_params; + ov::element::Type model_type; + std::vector shapes; + std::string target_device; + + std::tie(bin_conv_params, model_type, shapes, target_device) = obj.param; + + ov::op::PadType pad_type; + std::vector kernel, stride, dilation; + std::vector pad_begin, padEnd; + size_t conv_out_channels; + float pad_value; + std::tie(kernel, stride, pad_begin, padEnd, dilation, conv_out_channels, pad_type, pad_value) = bin_conv_params; + + std::ostringstream result; + result << "IS=("; + for (size_t i = 0lu; i < shapes.size(); i++) { + result << ov::test::utils::partialShape2str({shapes[i].first}) << (i < shapes.size() - 1lu ? "_" : ""); + } + result << ")_TS="; + for (size_t i = 0lu; i < shapes.front().second.size(); i++) { + result << "{"; + for (size_t j = 0lu; j < shapes.size(); j++) { + result << ov::test::utils::vec2str(shapes[j].second[i]) << (j < shapes.size() - 1lu ? "_" : ""); + } + result << "}_"; + } + result << "KS=" << ov::test::utils::vec2str(kernel) << "_"; + result << "S=" << ov::test::utils::vec2str(stride) << "_"; + result << "PB=" << ov::test::utils::vec2str(pad_begin) << "_"; + result << "PE=" << ov::test::utils::vec2str(padEnd) << "_"; + result << "D=" << ov::test::utils::vec2str(dilation) << "_"; + result << "O=" << conv_out_channels << "_"; + result << "AP=" << pad_type << "_"; + result << "PV=" << pad_value << "_"; + result << "netPRC=" << model_type.get_type_name() << "_"; + result << "trgDev=" << target_device; + return result.str(); +} + +void BinaryConvolutionLayerTest::SetUp() { + binConvSpecificParams bin_conv_params; + ov::element::Type model_type; + std::vector shapes; + + std::tie(bin_conv_params, model_type, shapes, targetDevice) = this->GetParam(); + init_input_shapes(shapes); + + ov::op::PadType pad_type; + std::vector kernel_size, strides, dilations; + std::vector pads_begin, pads_end; + size_t num_out_channels; + float pad_value; + std::tie(kernel_size, strides, pads_begin, pads_end, dilations, num_out_channels, pad_type, pad_value) = bin_conv_params; + + ov::ParameterVector params{std::make_shared(model_type, inputDynamicShapes.front())}; + params[0]->set_friendly_name("a_data_batch"); + + // TODO: refactor build BinaryConvolution op to accept filters input as Parameter + auto bin_conv = + ngraph::builder::makeBinaryConvolution(params[0], kernel_size, strides, pads_begin, pads_end, dilations, pad_type, num_out_channels, pad_value); + auto result = std::make_shared(bin_conv); + function = std::make_shared(ov::OutputVector{result}, params, "BinaryConvolution"); +} + +} // namespace test +} // namespace ov diff --git a/src/tests/functional/shared_test_classes/src/single_op/bucketize.cpp b/src/tests/functional/shared_test_classes/src/single_op/bucketize.cpp new file mode 100644 index 00000000000..bea6eaf18bf --- /dev/null +++ b/src/tests/functional/shared_test_classes/src/single_op/bucketize.cpp @@ -0,0 +1,61 @@ +// Copyright (C) 2018-2023 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "shared_test_classes/single_op/bucketize.hpp" + +#include "common_test_utils/ov_tensor_utils.hpp" + +namespace ov { +namespace test { + +std::string BucketizeLayerTest::getTestCaseName(const testing::TestParamInfo& obj) { + std::vector shapes; + bool with_right_bound; + ov::element::Type in_data_type, in_buckets_type, model_type; + std::string target_device; + + std::tie(shapes, with_right_bound, in_data_type, in_buckets_type, model_type, target_device) = obj.param; + + std::ostringstream result; + result << "IS=("; + for (size_t i = 0lu; i < shapes.size(); i++) { + result << ov::test::utils::partialShape2str({shapes[i].first}) << (i < shapes.size() - 1lu ? "_" : ""); + } + result << ")_TS="; + for (size_t i = 0lu; i < shapes.front().second.size(); i++) { + result << "{"; + for (size_t j = 0lu; j < shapes.size(); j++) { + result << ov::test::utils::vec2str(shapes[j].second[i]) << (j < shapes.size() - 1lu ? "_" : ""); + } + result << "}_"; + } + if (with_right_bound) + result << "rightIntervalEdge_"; + else + result << "leftIntervalEdge_"; + result << "in_data_type=" << in_data_type.get_type_name() << "_"; + result << "in_buckets_type=" << in_buckets_type.get_type_name() << "_"; + result << "model_type=" << model_type.get_type_name() << "_"; + result << "target_device=" << target_device; + return result.str(); +} + +void BucketizeLayerTest::SetUp() { + std::vector shapes; + bool with_right_bound; + ov::element::Type in_data_type, in_buckets_type, model_type; + + std::tie(shapes, with_right_bound, in_data_type, in_buckets_type, model_type, targetDevice) = this->GetParam(); + init_input_shapes(shapes); + + auto data = std::make_shared(in_data_type, inputDynamicShapes[0]); + data->set_friendly_name("a_data"); + auto buckets = std::make_shared(in_buckets_type, inputDynamicShapes[1]); + buckets->set_friendly_name("b_buckets"); + auto bucketize = std::make_shared(data, buckets, model_type, with_right_bound); + auto result = std::make_shared(bucketize); + function = std::make_shared(result, ov::ParameterVector{data, buckets}, "Bucketize"); +} +} // namespace test +} // namespace ov