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

[GPU] Refactor CumSum, DeformableConvolution, DeformablePSROIPooling, DepthToSpaceBS (#20499)

Browse Source 
* CumSum

* deformable_convolution

* DeformablePSROIPooling

* DepthToSpaceBS

* smoke_DetectionOutput3In, smoke_DetectionOutput5In

* tmp

* refactor 3 embedding

* extract_image_patches and fake_quantize

* gather_nd and gather_tree

* gather_elements

* Gather

* dft

* CumSum

* deformable_convolution

* DeformablePSROIPooling

* DepthToSpaceBS

* smoke_DetectionOutput3In, smoke_DetectionOutput5In

* tmp

* refactor 3 embedding

* extract_image_patches and fake_quantize

* gather_nd and gather_tree

* gather_elements

* Gather

* dft

* restore dft

* fix after review

---------

Co-authored-by: Sergeys Shlyapnikov <sergey.shlyapnikov@intel.com>
This commit is contained in:
Andrei Gorbachev 2023-10-26 17:00:51 +01:00 committed by GitHub
parent 1e4f3f18fe
commit 66dca04b45
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 683 additions and 889 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/cum_sum.cpp
View File

@ -4,31 +4,30 @@
#include <vector>
#include "single_layer_tests/cum_sum.hpp"
#include "single_op_tests/cum_sum.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
namespace {
using ov::test::CumSumLayerTest;
std::vector<std::vector<size_t>> inShapes = {
{10, 10},
{10, 10, 10},
{10, 10, 10, 10},
{10, 10, 10, 10, 10},
{10, 10, 10, 10, 10, 10},
std::vector<std::vector<ov::Shape>> inShapes = {
{{10, 10}},
{{10, 10, 10}},
{{10, 10, 10, 10}},
{{10, 10, 10, 10, 10}},
{{10, 10, 10, 10, 10, 10}},
};
std::vector<int64_t> axes = {-1, 0, 1};
std::vector<bool> exclusive = {false, true};
std::vector<bool> reverse = {false, true};
std::vector<InferenceEngine::Precision> precisions = {InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16};
std::vector<ov::element::Type> precisions = {ov::element::f32,
ov::element::f16};
std::vector<std::vector<size_t>> shape1d = {{10}};
std::vector<std::vector<ov::Shape>> shape1d = {{{10}}};
std::vector<int64_t> axis1d = {0};
INSTANTIATE_TEST_SUITE_P(smoke_CumSum1D, CumSumLayerTest,
::testing::Combine(
::testing::ValuesIn(shape1d),
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(shape1d)),
::testing::ValuesIn(precisions),
::testing::ValuesIn(axis1d),
::testing::ValuesIn(exclusive),
@ -38,7 +37,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_CumSum1D, CumSumLayerTest,
INSTANTIATE_TEST_SUITE_P(smoke_CumSum, CumSumLayerTest,
::testing::Combine(
::testing::ValuesIn(inShapes),
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(inShapes)),
::testing::ValuesIn(precisions),
::testing::ValuesIn(axes),
::testing::ValuesIn(exclusive),

487
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/deformable_convolution.cpp
View File

@ -3,13 +3,14 @@
//
#include <vector>
#include "common_test_utils/test_constants.hpp"
#include "single_layer_tests/deformable_convolution.hpp"
using namespace LayerTestsDefinitions;
#include "single_op_tests/deformable_convolution.hpp"
namespace {
const std::vector<InferenceEngine::Precision> netPrecisions = {
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16,
InferenceEngine::Precision::I16
using ov::test::DeformableConvolutionLayerTest;
const std::vector<ov::element::Type> netPrecisions = {
ov::element::f32,
ov::element::f16,
ov::element::i16
};
/* ============= 2D DeformableConvolution ============= */
@ -30,57 +31,55 @@ const std::vector<bool> with_bilinear_interpolation_pad = { false, true };
const std::vector<bool> with_modulated_scalar = { false, true };
const auto deformableConv2DParams_ExplicitPadding = ::testing::Combine(
::testing::ValuesIn(deformable_values_0),
::testing::ValuesIn(kernel_shapes_0), ::testing::ValuesIn(stride_values),
::testing::ValuesIn(pad_begin_values), ::testing::ValuesIn(pad_end_values),
::testing::ValuesIn(dilation_values), ::testing::ValuesIn(num_groups),
::testing::ValuesIn(num_deformable_groups_0), ::testing::ValuesIn(num_out_channels),
::testing::Values(ngraph::op::PadType::EXPLICIT), ::testing::ValuesIn(with_bilinear_interpolation_pad),
::testing::ValuesIn(with_modulated_scalar));
::testing::ValuesIn(stride_values),
::testing::ValuesIn(pad_begin_values),
::testing::ValuesIn(pad_end_values),
::testing::ValuesIn(dilation_values),
::testing::ValuesIn(num_groups),
::testing::ValuesIn(num_deformable_groups_0),
::testing::ValuesIn(num_out_channels),
::testing::Values(ov::op::PadType::EXPLICIT),
::testing::ValuesIn(with_bilinear_interpolation_pad));
const auto deformableConv2DParams_AutoPadValid = ::testing::Combine(
::testing::ValuesIn(deformable_values_0),
::testing::ValuesIn(kernel_shapes_0), ::testing::ValuesIn(stride_values),
::testing::ValuesIn(stride_values),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::ValuesIn(dilation_values), ::testing::ValuesIn(num_groups),
::testing::ValuesIn(num_deformable_groups_0), ::testing::ValuesIn(num_out_channels),
::testing::Values(ngraph::op::PadType::VALID),
::testing::ValuesIn(with_bilinear_interpolation_pad),
::testing::ValuesIn(with_modulated_scalar));
::testing::ValuesIn(dilation_values),
::testing::ValuesIn(num_groups),
::testing::ValuesIn(num_deformable_groups_0),
::testing::ValuesIn(num_out_channels),
::testing::Values(ov::op::PadType::VALID),
::testing::ValuesIn(with_bilinear_interpolation_pad));
const auto deformableConv2DParams_DeformableGroups_AutoPadExplicit = ::testing::Combine(
::testing::ValuesIn(deformable_values_1),
::testing::ValuesIn(kernel_shapes_1), ::testing::ValuesIn(stride_values),
::testing::ValuesIn(stride_values),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::ValuesIn(dilation_values), ::testing::ValuesIn(num_groups),
::testing::ValuesIn(multiple_defor_groups), ::testing::ValuesIn(num_out_channels),
::testing::Values(ngraph::op::PadType::EXPLICIT),
::testing::ValuesIn(with_bilinear_interpolation_pad),
::testing::ValuesIn(with_modulated_scalar));
::testing::ValuesIn(dilation_values),
::testing::ValuesIn(num_groups),
::testing::ValuesIn(multiple_defor_groups),
::testing::ValuesIn(num_out_channels),
::testing::Values(ov::op::PadType::EXPLICIT),
::testing::ValuesIn(with_bilinear_interpolation_pad));
INSTANTIATE_TEST_SUITE_P(
smoke_DeformableConvolution2D_ExplicitPadding, DeformableConvolutionLayerTest,
::testing::Combine(
deformableConv2DParams_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<size_t>({1, 2, 3, 3})),
deformableConv2DParams_ExplicitPadding,
::testing::ValuesIn(with_modulated_scalar),
::testing::ValuesIn(netPrecisions),
::testing::Values(ov::test::static_shapes_to_test_representation(std::vector<ov::Shape>({{1, 2, 3, 3}, {1, 16, 2, 2}, {2, 2, 2, 2}, {1, 8, 2, 2}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(
smoke_DeformableConvolution2D_AutoPadValid, DeformableConvolutionLayerTest,
::testing::Combine(
deformableConv2DParams_AutoPadValid, ::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>({1, 2, 3, 3})),
deformableConv2DParams_AutoPadValid,
::testing::ValuesIn(with_modulated_scalar),
::testing::ValuesIn(netPrecisions),
::testing::Values(ov::test::static_shapes_to_test_representation(std::vector<ov::Shape>({{1, 2, 3, 3}, {1, 16, 2, 2}, {2, 2, 2, 2}, {1, 8, 2, 2}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
@ -88,12 +87,12 @@ INSTANTIATE_TEST_SUITE_P(
smoke_DeformableConvolution2D_DeformableGroups_ExplicitPadding, DeformableConvolutionLayerTest,
::testing::Combine(
deformableConv2DParams_DeformableGroups_AutoPadExplicit,
::testing::ValuesIn(with_modulated_scalar),
::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>({1, 16, 66, 66})),
::testing::Values(ov::test::static_shapes_to_test_representation(std::vector<ov::Shape>({{1, 16, 66, 66},
{1, 72, 64, 64},
{16, 16, 3, 3},
{1, 36, 64, 64}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
@ -103,8 +102,6 @@ const std::vector<std::vector<size_t>> kernel_shapes_2 = {{1, 3, 3, 3}};
const std::vector<size_t> num_deformable_groups_1 = {3};
const auto deformableConv2DParams_SingleTestCase = ::testing::Combine(
::testing::ValuesIn(deformable_values_2),
::testing::ValuesIn(kernel_shapes_2),
::testing::ValuesIn(stride_values),
::testing::ValuesIn(pad_begin_values),
::testing::ValuesIn(pad_end_values),
@ -112,310 +109,188 @@ const auto deformableConv2DParams_SingleTestCase = ::testing::Combine(
::testing::ValuesIn(num_groups),
::testing::ValuesIn(num_deformable_groups_1),
::testing::ValuesIn(num_out_channels),
::testing::Values(ngraph::op::PadType::EXPLICIT),
::testing::ValuesIn(with_bilinear_interpolation_pad),
::testing::ValuesIn(with_modulated_scalar)
::testing::Values(ov::op::PadType::EXPLICIT),
::testing::ValuesIn(with_bilinear_interpolation_pad)
);
INSTANTIATE_TEST_SUITE_P(
smoke_DeformableConvolution2D_SingleTestCase, DeformableConvolutionLayerTest,
::testing::Combine(
deformableConv2DParams_SingleTestCase,
::testing::ValuesIn(with_modulated_scalar),
::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>({1, 3, 30, 30})),
::testing::Values(ov::test::static_shapes_to_test_representation(std::vector<ov::Shape>({{1, 3, 30, 30},
{1, 54, 28, 28},
{1, 3, 3, 3},
{1, 27, 28, 28}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
/* ============= Multiple groups case ============= */
const auto DeformableConvolution2D_MultipleGroups22 = ::testing::Combine(
::testing::ValuesIn(stride_values),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::ValuesIn(dilation_values),
::testing::ValuesIn(std::vector<size_t>({2})),
::testing::ValuesIn(std::vector<size_t>({2})),
::testing::ValuesIn(num_out_channels),
::testing::Values(ov::op::PadType::EXPLICIT),
::testing::ValuesIn(with_bilinear_interpolation_pad)
);
INSTANTIATE_TEST_SUITE_P(
smoke_DeformableConvolution2D_MultipleGroups, DeformableConvolutionLayerTest,
::testing::Combine(
::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>> {{1, 16, 2, 2}}), // offsets
::testing::ValuesIn(std::vector<std::vector<size_t>> {{2, 2, 2, 2}}), // ker.
::testing::ValuesIn(stride_values),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::ValuesIn(dilation_values),
::testing::ValuesIn(std::vector<size_t> {2}), // gr.
::testing::ValuesIn(std::vector<size_t> {2}), // def. gr.
::testing::ValuesIn(num_out_channels),
::testing::Values(ngraph::op::PadType::EXPLICIT),
::testing::ValuesIn(with_bilinear_interpolation_pad),
::testing::ValuesIn(with_modulated_scalar)),
::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>({1, 4, 3, 3})),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
DeformableConvolution2D_MultipleGroups22,
::testing::ValuesIn(with_modulated_scalar),
::testing::ValuesIn(netPrecisions),
::testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{1, 4, 3, 3}, {1, 16, 2, 2}, {2, 2, 2, 2}, {1, 8, 2, 2}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(
smoke_DeformableConvolution2D_MultipleGroups_Batch2, DeformableConvolutionLayerTest,
::testing::Combine(
::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>> {{2, 16, 2, 2}}), // offsets
::testing::ValuesIn(std::vector<std::vector<size_t>> {{2, 2, 2, 2}}), // ker.
::testing::ValuesIn(stride_values),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::ValuesIn(dilation_values),
::testing::ValuesIn(std::vector<size_t> {2}), // gr.
::testing::ValuesIn(std::vector<size_t> {2}), // def. gr.
::testing::ValuesIn(num_out_channels),
::testing::Values(ngraph::op::PadType::EXPLICIT),
::testing::ValuesIn(with_bilinear_interpolation_pad),
::testing::ValuesIn(with_modulated_scalar)),
::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>({2, 4, 3, 3})),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
DeformableConvolution2D_MultipleGroups22,
::testing::ValuesIn(with_modulated_scalar),
::testing::ValuesIn(netPrecisions),
::testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{2, 4, 3, 3}, {2, 16, 2, 2}, {2, 2, 2, 2}, {2, 8, 2, 2}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(
smoke_DeformableConvolution2D_MultipleGroups_Batch3, DeformableConvolutionLayerTest,
::testing::Combine(
::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>> {{3, 16, 2, 2}}), // offsets
::testing::ValuesIn(std::vector<std::vector<size_t>> {{2, 2, 2, 2}}), // ker.
::testing::ValuesIn(stride_values),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::ValuesIn(dilation_values),
::testing::ValuesIn(std::vector<size_t> {2}), // gr.
::testing::ValuesIn(std::vector<size_t> {2}), // def. gr.
::testing::ValuesIn(num_out_channels),
::testing::Values(ngraph::op::PadType::EXPLICIT),
::testing::ValuesIn(with_bilinear_interpolation_pad),
::testing::ValuesIn(with_modulated_scalar)),
::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>({3, 4, 3, 3})),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
DeformableConvolution2D_MultipleGroups22,
::testing::ValuesIn(with_modulated_scalar),
::testing::ValuesIn(netPrecisions),
::testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{3, 4, 3, 3}, {3, 16, 2, 2}, {2, 2, 2, 2}, {3, 8, 2, 2}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(
smoke_DeformableConvolution2D_MultipleGroups_Batch4, DeformableConvolutionLayerTest,
::testing::Combine(
::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>> {{4, 16, 2, 2}}), // offsets
::testing::ValuesIn(std::vector<std::vector<size_t>> {{2, 2, 2, 2}}), // ker.
::testing::ValuesIn(stride_values),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::ValuesIn(dilation_values),
::testing::ValuesIn(std::vector<size_t> {2}), // gr.
::testing::ValuesIn(std::vector<size_t> {2}), // def. gr.
::testing::ValuesIn(num_out_channels),
::testing::Values(ngraph::op::PadType::EXPLICIT),
::testing::ValuesIn(with_bilinear_interpolation_pad),
::testing::ValuesIn(with_modulated_scalar)),
::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>({4, 4, 3, 3})),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
DeformableConvolution2D_MultipleGroups22,
::testing::ValuesIn(with_modulated_scalar),
::testing::ValuesIn(netPrecisions),
::testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{4, 4, 3, 3}, {4, 16, 2, 2}, {2, 2, 2, 2}, {4, 8, 2, 2}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
const auto DeformableConvolution2D_MultipleGroups_41 = ::testing::Combine(
::testing::ValuesIn(stride_values),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::ValuesIn(dilation_values),
::testing::ValuesIn(std::vector<size_t>({4})),
::testing::ValuesIn(std::vector<size_t>({1})),
::testing::ValuesIn(num_out_channels),
::testing::Values(ov::op::PadType::EXPLICIT),
::testing::ValuesIn(with_bilinear_interpolation_pad)
);
INSTANTIATE_TEST_SUITE_P(
smoke_DeformableConvolution2D_MultipleGroups_2, DeformableConvolutionLayerTest,
::testing::Combine(
::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>> {{1, 18, 66, 66}}), // offsets
::testing::ValuesIn(std::vector<std::vector<size_t>> {{4, 2, 3, 3}}), // ker.
::testing::ValuesIn(stride_values),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::ValuesIn(dilation_values),
::testing::ValuesIn(std::vector<size_t> {4}), // gr.
::testing::ValuesIn(std::vector<size_t> {1}), // def. gr.
::testing::ValuesIn(num_out_channels),
::testing::Values(ngraph::op::PadType::EXPLICIT),
::testing::ValuesIn(with_bilinear_interpolation_pad),
::testing::ValuesIn(with_modulated_scalar)),
::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>({1, 8, 68, 68})),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
DeformableConvolution2D_MultipleGroups_41,
::testing::ValuesIn(with_modulated_scalar),
::testing::ValuesIn(netPrecisions),
::testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{1, 8, 68, 68}, {1, 18, 66, 66}, {4, 2, 3, 3}, {1, 9, 66, 66}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(
smoke_DeformableConvolution2D_MultipleGroups_2_Batch2, DeformableConvolutionLayerTest,
::testing::Combine(
::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>> {{2, 18, 66, 66}}), // offsets
::testing::ValuesIn(std::vector<std::vector<size_t>> {{4, 2, 3, 3}}), // ker.
::testing::ValuesIn(stride_values),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::ValuesIn(dilation_values),
::testing::ValuesIn(std::vector<size_t> {4}), // gr.
::testing::ValuesIn(std::vector<size_t> {1}), // def. gr.
::testing::ValuesIn(num_out_channels),
::testing::Values(ngraph::op::PadType::EXPLICIT),
::testing::ValuesIn(with_bilinear_interpolation_pad),
::testing::ValuesIn(with_modulated_scalar)),
::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>({2, 8, 68, 68})),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
DeformableConvolution2D_MultipleGroups_41,
::testing::ValuesIn(with_modulated_scalar),
::testing::ValuesIn(netPrecisions),
::testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{2, 8, 68, 68}, {2, 18, 66, 66}, {4, 2, 3, 3}, {2, 9, 66, 66}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(
smoke_DeformableConvolution2D_MultipleGroups_2_Batch3, DeformableConvolutionLayerTest,
::testing::Combine(
::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>> {{3, 18, 66, 66}}), // offsets
::testing::ValuesIn(std::vector<std::vector<size_t>> {{4, 2, 3, 3}}), // ker.
::testing::ValuesIn(stride_values),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::ValuesIn(dilation_values),
::testing::ValuesIn(std::vector<size_t> {4}), // gr.
::testing::ValuesIn(std::vector<size_t> {1}), // def. gr.
::testing::ValuesIn(num_out_channels),
::testing::Values(ngraph::op::PadType::EXPLICIT),
::testing::ValuesIn(with_bilinear_interpolation_pad),
::testing::ValuesIn(with_modulated_scalar)),
::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>({3, 8, 68, 68})),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
DeformableConvolution2D_MultipleGroups_41,
::testing::ValuesIn(with_modulated_scalar),
::testing::ValuesIn(netPrecisions),
::testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{3, 8, 68, 68}, {3, 18, 66, 66}, {4, 2, 3, 3}, {3, 9, 66, 66}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(
smoke_DeformableConvolution2D_MultipleGroups_2_Batch4, DeformableConvolutionLayerTest,
::testing::Combine(
::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>> {{4, 18, 66, 66}}), // offsets
::testing::ValuesIn(std::vector<std::vector<size_t>> {{4, 2, 3, 3}}), // ker.
::testing::ValuesIn(stride_values),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::ValuesIn(dilation_values),
::testing::ValuesIn(std::vector<size_t> {4}), // gr.
::testing::ValuesIn(std::vector<size_t> {1}), // def. gr.
::testing::ValuesIn(num_out_channels),
::testing::Values(ngraph::op::PadType::EXPLICIT),
::testing::ValuesIn(with_bilinear_interpolation_pad),
::testing::ValuesIn(with_modulated_scalar)),
::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>({4, 8, 68, 68})),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
DeformableConvolution2D_MultipleGroups_41,
::testing::ValuesIn(with_modulated_scalar),
::testing::ValuesIn(netPrecisions),
::testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{4, 8, 68, 68}, {4, 18, 66, 66}, {4, 2, 3, 3}, {4, 9, 66, 66}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
const auto DeformableConvolution2D_MultipleGroups_42 = ::testing::Combine(
::testing::ValuesIn(stride_values),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::ValuesIn(dilation_values),
::testing::ValuesIn(std::vector<size_t>({4})),
::testing::ValuesIn(std::vector<size_t>({2})),
::testing::ValuesIn(num_out_channels),
::testing::Values(ov::op::PadType::EXPLICIT),
::testing::ValuesIn(with_bilinear_interpolation_pad)
);
INSTANTIATE_TEST_SUITE_P(
smoke_DeformableConvolution2D_MultipleGroups_3, DeformableConvolutionLayerTest,
::testing::Combine(
::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>> {{1, 36, 66, 66}}), // offsets
::testing::ValuesIn(std::vector<std::vector<size_t>> {{4, 2, 3, 3}}), // ker.
::testing::ValuesIn(stride_values),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::ValuesIn(dilation_values),
::testing::ValuesIn(std::vector<size_t> {4}), // gr.
::testing::ValuesIn(std::vector<size_t> {2}), // def. gr.
::testing::ValuesIn(num_out_channels),
::testing::Values(ngraph::op::PadType::EXPLICIT),
::testing::ValuesIn(with_bilinear_interpolation_pad),
::testing::ValuesIn(with_modulated_scalar)),
::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>({1, 8, 68, 68})),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
DeformableConvolution2D_MultipleGroups_42,
::testing::ValuesIn(with_modulated_scalar),
::testing::ValuesIn(netPrecisions),
::testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{1, 8, 68, 68}, {1, 36, 66, 66}, {4, 2, 3, 3}, {1, 18, 66, 66}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(
smoke_DeformableConvolution2D_MultipleGroups_3_Batch2, DeformableConvolutionLayerTest,
::testing::Combine(
::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>> {{2, 36, 66, 66}}), // offsets
::testing::ValuesIn(std::vector<std::vector<size_t>> {{4, 2, 3, 3}}), // ker.
::testing::ValuesIn(stride_values),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::ValuesIn(dilation_values),
::testing::ValuesIn(std::vector<size_t> {4}), // gr.
::testing::ValuesIn(std::vector<size_t> {2}), // def. gr.
::testing::ValuesIn(num_out_channels),
::testing::Values(ngraph::op::PadType::EXPLICIT),
::testing::ValuesIn(with_bilinear_interpolation_pad),
::testing::ValuesIn(with_modulated_scalar)),
::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>({2, 8, 68, 68})),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
DeformableConvolution2D_MultipleGroups_42,
::testing::ValuesIn(with_modulated_scalar),
::testing::ValuesIn(netPrecisions),
::testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{2, 8, 68, 68}, {2, 36, 66, 66}, {4, 2, 3, 3}, {2, 18, 66, 66}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(
smoke_DeformableConvolution2D_MultipleGroups_3_Batch3, DeformableConvolutionLayerTest,
::testing::Combine(
::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>> {{3, 36, 66, 66}}), // offsets
::testing::ValuesIn(std::vector<std::vector<size_t>> {{4, 2, 3, 3}}), // ker.
::testing::ValuesIn(stride_values),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::ValuesIn(dilation_values),
::testing::ValuesIn(std::vector<size_t> {4}), // gr.
::testing::ValuesIn(std::vector<size_t> {2}), // def. gr.
::testing::ValuesIn(num_out_channels),
::testing::Values(ngraph::op::PadType::EXPLICIT),
::testing::ValuesIn(with_bilinear_interpolation_pad),
::testing::ValuesIn(with_modulated_scalar)),
::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>({3, 8, 68, 68})),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
DeformableConvolution2D_MultipleGroups_42,
::testing::ValuesIn(with_modulated_scalar),
::testing::ValuesIn(netPrecisions),
::testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{3, 8, 68, 68}, {3, 36, 66, 66}, {4, 2, 3, 3}, {3, 18, 66, 66}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(
smoke_DeformableConvolution2D_MultipleGroups_3_Batch4, DeformableConvolutionLayerTest,
::testing::Combine(
::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>> {{4, 36, 66, 66}}), // offsets
::testing::ValuesIn(std::vector<std::vector<size_t>> {{4, 2, 3, 3}}), // ker.
::testing::ValuesIn(stride_values),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::Values(std::vector<ptrdiff_t>({0, 0})),
::testing::ValuesIn(dilation_values),
::testing::ValuesIn(std::vector<size_t> {4}), // gr.
::testing::ValuesIn(std::vector<size_t> {2}), // def. gr.
::testing::ValuesIn(num_out_channels),
::testing::Values(ngraph::op::PadType::EXPLICIT),
::testing::ValuesIn(with_bilinear_interpolation_pad),
::testing::ValuesIn(with_modulated_scalar)),
::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>({4, 8, 68, 68})),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
DeformableConvolution2D_MultipleGroups_42,
::testing::ValuesIn(with_modulated_scalar),
::testing::ValuesIn(netPrecisions),
::testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{4, 8, 68, 68}, {4, 36, 66, 66}, {4, 2, 3, 3}, {4, 18, 66, 66}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DeformableConvolutionLayerTest::getTestCaseName);
} // namespace

39
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/deformable_psroi_pooling.cpp
View File

@ -2,21 +2,24 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "single_layer_tests/deformable_psroi_pooling.hpp"
#include "single_op_tests/deformable_psroi_pooling.hpp"
#include <vector>
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
namespace {
using ov::test::DeformablePSROIPoolingLayerTest;
std::vector<std::vector<ov::Shape>> shapes_static {
//dataShape, roisShape, offsetsShape
{{3, 8, 16, 16}, {10, 5}},
{{1, 8, 67, 32}, {10, 5}},
{{3, 8, 16, 16}, {10, 5}, {10, 2, 2, 2}},
{{1, 8, 67, 32}, {10, 5}, {10, 2, 2, 2}},
};
const auto params = testing::Combine(
testing::ValuesIn(std::vector<std::vector<size_t>>{{3, 8, 16, 16}, {1, 8, 67, 32}}), // data input shape
testing::Values(std::vector<size_t>{10, 5}), // rois input shape
// Empty offsets shape means test without optional third input
testing::ValuesIn(std::vector<std::vector<size_t>>{{}, {10, 2, 2, 2}}), // offsets input shape
testing::Values(2), // output_dim
testing::Values(2), // group_size
testing::ValuesIn(std::vector<float>{1.0f, 0.5f, 0.0625f}), // spatial_scale
@ -27,16 +30,17 @@ const auto params = testing::Combine(
INSTANTIATE_TEST_SUITE_P(smoke_DeformablePSROIPooling,
DeformablePSROIPoolingLayerTest,
testing::Combine(params,
testing::Values(InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16),
testing::Values(ov::test::utils::DEVICE_GPU)),
testing::ValuesIn(ov::test::static_shapes_to_test_representation(shapes_static)),
testing::Values(ov::element::f32,
ov::element::f16),
testing::Values(ov::test::utils::DEVICE_GPU)),
DeformablePSROIPoolingLayerTest::getTestCaseName);
std::vector<std::vector<ov::Shape>> shapes_advanced_static {
//dataShape, roisShape, offsetsShape
{{2, 441, 63, 38}, {30, 5}, {30, 2, 3, 3}}
};
const auto params_advanced =
testing::Combine(testing::ValuesIn(std::vector<std::vector<size_t>>{{2, 441, 63, 38}}), // data input shape
testing::Values(std::vector<size_t>{30, 5}), // rois input shape
testing::Values(std::vector<size_t>{30, 2, 3, 3}), // offsets input shape
testing::Values(49), // output_dim
testing::Combine(testing::Values(49), // output_dim
testing::Values(3), // group_size
testing::ValuesIn(std::vector<float>{0.0625f}), // spatial_scale
testing::ValuesIn(std::vector<std::vector<int64_t>>{{4, 4}}), // spatial_bins_x_y
@ -46,8 +50,9 @@ const auto params_advanced =
INSTANTIATE_TEST_SUITE_P(smoke_DeformablePSROIPooling_advanced,
DeformablePSROIPoolingLayerTest,
testing::Combine(params_advanced,
testing::Values(InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16),
testing::ValuesIn(ov::test::static_shapes_to_test_representation(shapes_advanced_static)),
testing::Values(ov::element::f32,
ov::element::f16),
testing::Values(ov::test::utils::DEVICE_GPU)),
DeformablePSROIPoolingLayerTest::getTestCaseName);

32
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/depth_to_space.cpp
View File

@ -5,43 +5,43 @@
#include <vector>
#include <ngraph/opsets/opset3.hpp>
#include "single_layer_tests/depth_to_space.hpp"
#include "single_op_tests/depth_to_space.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
using namespace ngraph::opset3;
namespace {
const std::vector<InferenceEngine::Precision> inputPrecisions = {
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::U8,
InferenceEngine::Precision::I16,
using ov::test::DepthToSpaceLayerTest;
using ov::op::v0::DepthToSpace;
const std::vector<ov::element::Type> inputPrecisions = {
ov::element::f32,
ov::element::u8,
ov::element::i16,
};
const std::vector<DepthToSpace::DepthToSpaceMode> modes = {
DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST,
DepthToSpace::DepthToSpaceMode::DEPTH_FIRST};
const std::vector<std::vector<size_t >> inputShapesBS2 = {
{1, 4, 1, 1}, {1, 4, 2, 2}, {1, 4, 3, 3}, {2, 32, 3, 3}, {2, 16, 5, 4},
{1, 8, 1, 1, 1}, {1, 8, 2, 2, 2}, {1, 8, 3, 3, 3}, {2, 32, 3, 3, 3}, {2, 16, 5, 4, 6}};
const std::vector<std::vector<ov::Shape>> inputShapesBS2 = {
{{1, 4, 1, 1}}, {{1, 4, 2, 2}}, {{1, 4, 3, 3}}, {{2, 32, 3, 3}}, {{2, 16, 5, 4}},
{{1, 8, 1, 1, 1}}, {{1, 8, 2, 2, 2}}, {{1, 8, 3, 3, 3}}, {{2, 32, 3, 3, 3}}, {{2, 16, 5, 4, 6}}};
INSTANTIATE_TEST_SUITE_P(smoke_DepthToSpaceBS2,
DepthToSpaceLayerTest,
::testing::Combine(::testing::ValuesIn(inputShapesBS2),
::testing::Combine(::testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapesBS2)),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(modes),
::testing::Values(2),
::testing::Values(ov::test::utils::DEVICE_GPU)),
DepthToSpaceLayerTest::getTestCaseName);
const std::vector<std::vector<size_t >> inputShapesBS3 = {
{1, 9, 1, 1}, {1, 9, 2, 2}, {1, 9, 3, 3}, {2, 36, 3, 3}, {2, 27, 5, 4},
{1, 27, 1, 1, 1}, {1, 27, 2, 2, 2}, {1, 27, 3, 3, 3}, {2, 108, 3, 3, 3}, {2, 54, 5, 4, 6}};
const std::vector<std::vector<ov::Shape>> inputShapesBS3 = {
{{1, 9, 1, 1}}, {{1, 9, 2, 2}}, {{1, 9, 3, 3}}, {{2, 36, 3, 3}}, {{2, 27, 5, 4}},
{{1, 27, 1, 1, 1}}, {{1, 27, 2, 2, 2}}, {{1, 27, 3, 3, 3}}, {{2, 108, 3, 3, 3}}, {{2, 54, 5, 4, 6}}};
INSTANTIATE_TEST_SUITE_P(smoke_DepthToSpaceBS3,
DepthToSpaceLayerTest,
::testing::Combine(::testing::ValuesIn(inputShapesBS3),
::testing::Combine(::testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapesBS3)),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(modes),
::testing::Values(3),

6
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/detection_output.cpp
View File

@ -2,11 +2,11 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "single_layer_tests/detection_output.hpp"
using namespace LayerTestsDefinitions;
#include "single_op_tests/detection_output.hpp"
namespace {
using ov::test::DetectionOutputLayerTest;
using ov::test::ParamsWhichSizeDepends;
const int numClasses = 11;
const int backgroundLabelId = 0;

38
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/eltwise.cpp
View File

@ -3,12 +3,16 @@
//
#include <vector>
#include "single_layer_tests/eltwise.hpp"
#include "single_op_tests/eltwise.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace ov::test::subgraph;
namespace {
using ov::test::EltwiseLayerTest;
using ov::test::utils::InputLayerType;
using ov::test::utils::OpType;
using ov::test::utils::EltwiseTypes;
std::vector<std::vector<ov::Shape>> inShapes = {
{{2}},
{{}, {34100}},
@ -36,9 +40,9 @@ std::vector<ov::test::ElementType> netPrecisions = {
ov::element::i64,
};
std::vector<ngraph::helpers::InputLayerType> secondaryInputTypes = {
ngraph::helpers::InputLayerType::CONSTANT,
ngraph::helpers::InputLayerType::PARAMETER,
std::vector<InputLayerType> secondaryInputTypes = {
InputLayerType::CONSTANT,
InputLayerType::PARAMETER,
};
std::vector<ov::test::utils::OpType> opTypes = {
@ -46,20 +50,20 @@ std::vector<ov::test::utils::OpType> opTypes = {
ov::test::utils::OpType::VECTOR,
};
std::vector<ngraph::helpers::EltwiseTypes> smoke_eltwiseOpTypes = {
ngraph::helpers::EltwiseTypes::ADD,
ngraph::helpers::EltwiseTypes::MULTIPLY,
std::vector<EltwiseTypes> smoke_eltwiseOpTypes = {
EltwiseTypes::ADD,
EltwiseTypes::MULTIPLY,
};
std::vector<ngraph::helpers::EltwiseTypes> eltwiseOpTypes = {
ngraph::helpers::EltwiseTypes::ADD,
ngraph::helpers::EltwiseTypes::MULTIPLY,
ngraph::helpers::EltwiseTypes::SUBTRACT,
ngraph::helpers::EltwiseTypes::DIVIDE,
ngraph::helpers::EltwiseTypes::FLOOR_MOD,
ngraph::helpers::EltwiseTypes::SQUARED_DIFF,
ngraph::helpers::EltwiseTypes::POWER,
ngraph::helpers::EltwiseTypes::MOD
std::vector<EltwiseTypes> eltwiseOpTypes = {
EltwiseTypes::ADD,
EltwiseTypes::MULTIPLY,
EltwiseTypes::SUBTRACT,
EltwiseTypes::DIVIDE,
EltwiseTypes::FLOOR_MOD,
EltwiseTypes::SQUARED_DIFF,
EltwiseTypes::POWER,
EltwiseTypes::MOD
};
ov::AnyMap additional_config = {};

34
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/embedding_bag_offsets_sum.cpp
View File

@ -2,30 +2,29 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "single_layer_tests/embedding_bag_offsets_sum.hpp"
#include "single_op_tests/embedding_bag_offsets_sum.hpp"
#include <vector>
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
namespace {
using ov::test::EmbeddingBagOffsetsSumLayerTest;
const std::vector<InferenceEngine::Precision> netPrecisions = {
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16
const std::vector<ov::element::Type> netPrecisions = {
ov::element::f32,
ov::element::f16
};
const std::vector<InferenceEngine::Precision> indPrecisions = {
InferenceEngine::Precision::I64,
InferenceEngine::Precision::I32
const std::vector<ov::element::Type> indPrecisions = {
ov::element::i64,
ov::element::i32
};
const std::vector<std::vector<size_t>> emb_table_shape = {
{5, 6},
{10, 35},
{5, 4, 16}
const std::vector<std::vector<ov::Shape>> emb_table_shape = {
{{5, 6}},
{{10, 35}},
{{5, 4, 16}}
};
const std::vector<std::vector<size_t>> indices = {
@ -45,13 +44,16 @@ const std::vector<bool> with_weights = {false, true};
const std::vector<bool> with_default_index = {false, true};
const auto embBagOffsetSumArgSet = ::testing::Combine(
::testing::ValuesIn(emb_table_shape), ::testing::ValuesIn(indices),
::testing::ValuesIn(offsets), ::testing::ValuesIn(default_index),
::testing::ValuesIn(with_weights), ::testing::ValuesIn(with_default_index));
::testing::ValuesIn(indices),
::testing::ValuesIn(offsets),
::testing::ValuesIn(default_index),
::testing::ValuesIn(with_weights),
::testing::ValuesIn(with_default_index));
INSTANTIATE_TEST_SUITE_P(
smoke, EmbeddingBagOffsetsSumLayerTest,
::testing::Combine(embBagOffsetSumArgSet,
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(emb_table_shape)),
::testing::ValuesIn(netPrecisions),
::testing::ValuesIn(indPrecisions),
::testing::Values(ov::test::utils::DEVICE_GPU)),

28
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/embedding_bag_packed_sum.cpp
View File

@ -2,30 +2,29 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "single_layer_tests/embedding_bag_packed_sum.hpp"
#include "single_op_tests/embedding_bag_packed_sum.hpp"
#include <vector>
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
namespace {
using ov::test::EmbeddingBagPackedSumLayerTest;
const std::vector<InferenceEngine::Precision> netPrecisions = {
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16,
const std::vector<ov::element::Type> netPrecisions = {
ov::element::f32,
ov::element::f16,
};
const std::vector<InferenceEngine::Precision> indPrecisions = {
InferenceEngine::Precision::I64,
InferenceEngine::Precision::I32
const std::vector<ov::element::Type> indPrecisions = {
ov::element::i64,
ov::element::i32
};
const std::vector<std::vector<size_t>> emb_table_shape = {
{5, 6},
{10, 35},
{5, 4, 16}
const std::vector<std::vector<ov::Shape>> emb_table_shape = {
{{5, 6}},
{{10, 35}},
{{5, 4, 16}}
};
const std::vector<std::vector<std::vector<size_t>>> indices = {
@ -36,12 +35,13 @@ const std::vector<std::vector<std::vector<size_t>>> indices = {
const std::vector<bool> with_weights = {false, true};
const auto embBagPackedSumArgSet = ::testing::Combine(
::testing::ValuesIn(emb_table_shape), ::testing::ValuesIn(indices),
::testing::ValuesIn(indices),
::testing::ValuesIn(with_weights));
INSTANTIATE_TEST_SUITE_P(
smoke, EmbeddingBagPackedSumLayerTest,
::testing::Combine(embBagPackedSumArgSet,
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(emb_table_shape)),
::testing::ValuesIn(netPrecisions),
::testing::ValuesIn(indPrecisions),
::testing::Values(ov::test::utils::DEVICE_GPU)),

36
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/embedding_segments_sum.cpp
View File

@ -4,27 +4,27 @@
#include <vector>
#include "single_layer_tests/embedding_segments_sum.hpp"
#include "single_op_tests/embedding_segments_sum.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
namespace {
using ov::test::EmbeddingSegmentsSumLayerTest;
const std::vector<InferenceEngine::Precision> netPrecisions = {
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16
const std::vector<ov::element::Type> netPrecisions = {
ov::element::f32,
ov::element::f16
};
const std::vector<InferenceEngine::Precision> indPrecisions = {
InferenceEngine::Precision::I64,
InferenceEngine::Precision::I32
const std::vector<ov::element::Type> indPrecisions = {
ov::element::i64,
ov::element::i32
};
const std::vector<std::vector<size_t>> emb_table_shape = {
{5, 6},
{10, 35},
{5, 4, 16}
const std::vector<std::vector<ov::Shape>> emb_table_shape = {
{{5, 6}},
{{10, 35}},
{{5, 4, 16}}
};
const std::vector<std::vector<size_t>> indices = {
{0, 1, 2, 2, 3},
@ -40,14 +40,18 @@ const std::vector<bool> with_weights = {false, true};
const std::vector<bool> with_default_index = {false, true};
const auto embSegmentsSumArgSet = ::testing::Combine(
::testing::ValuesIn(emb_table_shape), ::testing::ValuesIn(indices),
::testing::ValuesIn(segment_ids), ::testing::ValuesIn(num_segments),
::testing::ValuesIn(default_index), ::testing::ValuesIn(with_weights),
::testing::ValuesIn(indices),
::testing::ValuesIn(segment_ids),
::testing::ValuesIn(num_segments),
::testing::ValuesIn(default_index),
::testing::ValuesIn(with_weights),
::testing::ValuesIn(with_default_index));
INSTANTIATE_TEST_SUITE_P(
smoke, EmbeddingSegmentsSumLayerTest,
::testing::Combine(embSegmentsSumArgSet, ::testing::ValuesIn(netPrecisions),
::testing::Combine(embSegmentsSumArgSet,
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(emb_table_shape)),
::testing::ValuesIn(netPrecisions),
::testing::ValuesIn(indPrecisions),
::testing::Values(ov::test::utils::DEVICE_GPU)),
EmbeddingSegmentsSumLayerTest::getTestCaseName);

29
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/extract_image_patches.cpp
View File

@ -4,16 +4,16 @@
#include <vector>
#include "single_layer_tests/extract_image_patches.hpp"
#include "single_op_tests/extract_image_patches.hpp"
using namespace LayerTestsDefinitions;
using ngraph::op::PadType;
namespace {
using ov::test::ExtractImagePatchesTest;
using ov::op::PadType;
const std::vector<std::vector<size_t>> inDataShape = {
{1, 1, 10, 10},
{1, 3, 10, 10}
const std::vector<std::vector<ov::Shape>> inDataShape = {
{{1, 1, 10, 10}},
{{1, 3, 10, 10}}
};
const std::vector<std::vector<size_t>> kernels = {
{2, 2},
@ -40,12 +40,12 @@ const std::vector<PadType> autoPads = {
PadType::SAME_UPPER,
PadType::SAME_LOWER
};
const std::vector<InferenceEngine::Precision> netPrecisions = {
//InferenceEngine::Precision::I8,
InferenceEngine::Precision::U8,
InferenceEngine::Precision::I16,
InferenceEngine::Precision::I32,
InferenceEngine::Precision::FP32
const std::vector<ov::element::Type> netPrecisions = {
//ov::element::i8,
ov::element::u8,
ov::element::i16,
ov::element::i32,
ov::element::f32
};
const auto extractImagePatchesParamsSet = ::testing::Combine(
@ -58,15 +58,12 @@ const auto extractImagePatchesParamsSet = ::testing::Combine(
INSTANTIATE_TEST_SUITE_P(smoke_layers_GPU, ExtractImagePatchesTest,
::testing::Combine(
::testing::ValuesIn(inDataShape),
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(inDataShape)),
::testing::ValuesIn(kernels),
::testing::ValuesIn(strides),
::testing::ValuesIn(rates),
::testing::ValuesIn(autoPads),
::testing::ValuesIn(netPrecisions),
::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::Values(ov::test::utils::DEVICE_GPU)),
ExtractImagePatchesTest::getTestCaseName);

28
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/fake_quantize.cpp
View File

@ -4,46 +4,36 @@
#include <vector>
#include "single_layer_tests/fake_quantize.hpp"
#include "single_op_tests/fake_quantize.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
namespace {
using ov::test::FakeQuantizeLayerTest;
const std::vector<InferenceEngine::Precision> netPrecisions = {
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16
const std::vector<ov::element::Type> netPrecisions = {
ov::element::f32,
ov::element::f16
};
const std::vector<std::vector<size_t>> inputShapes = {{1, 1, 1, 1}, {3, 10, 5, 6}, {1, 2, 3, 4, 2, 3, 2, 2}};
const std::vector<std::vector<ov::Shape>> inputShapes = {{{1, 1, 1, 1}}, {{3, 10, 5, 6}}, {{1, 2, 3, 4, 2, 3, 2, 2}}};
const std::vector<std::vector<size_t>> constShapes = {{1}};
const std::vector<size_t> levels = {16, 255, 256};
const std::pair<std::string, std::map<std::string, std::string>> config = {};
const std::vector<float> fqArgs = {};
const std::vector<float> inputParams = {};
const auto fqParams = ::testing::Combine(
::testing::ValuesIn(levels),
::testing::ValuesIn(constShapes),
::testing::Values(fqArgs),
::testing::Values(inputParams),
::testing::Values(ngraph::op::AutoBroadcastType::NUMPY)
::testing::Values(ov::op::AutoBroadcastType::NUMPY)
);
INSTANTIATE_TEST_SUITE_P(smoke_FakeQuantize, FakeQuantizeLayerTest,
::testing::Combine(
fqParams,
::testing::ValuesIn(netPrecisions),
::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::ValuesIn(inputShapes),
::testing::Values(ov::test::utils::DEVICE_GPU),
::testing::Values(config)),
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapes)),
::testing::Values(ov::test::utils::DEVICE_GPU)),
FakeQuantizeLayerTest::getTestCaseName);
} // namespace

482
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/gather.cpp
View File

@ -4,40 +4,44 @@
#include <vector>
#include "single_layer_tests/gather.hpp"
#include "single_op_tests/gather.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
namespace {
using ov::test::GatherLayerTest;
using ov::test::Gather7LayerTest;
using ov::test::Gather8LayerTest;
using ov::test::gather7ParamsTuple;
using ov::test::Gather8IndiceScalarLayerTest;
using ov::test::Gather8withIndicesDataLayerTest;
const std::vector<InferenceEngine::Precision> netPrecisionsFP32 = {
InferenceEngine::Precision::FP32,
const std::vector<ov::element::Type> netPrecisionsFP32 = {
ov::element::f32,
};
const std::vector<InferenceEngine::Precision> netPrecisionsI32 = {
InferenceEngine::Precision::I32,
const std::vector<ov::element::Type> netPrecisionsI32 = {
ov::element::i32,
};
const std::vector<InferenceEngine::Precision> netPrecisionsFP16 = {
InferenceEngine::Precision::FP16,
const std::vector<ov::element::Type> netPrecisionsFP16 = {
ov::element::f16,
};
const std::vector<InferenceEngine::Precision> netPrecisions = {
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16,
InferenceEngine::Precision::I32,
const std::vector<ov::element::Type> netPrecisions = {
ov::element::f32,
ov::element::f16,
ov::element::i32,
};
const std::vector<std::vector<size_t>> indicesShapes2 = {
std::vector<size_t>{2, 2},
std::vector<size_t>{2, 2, 2},
std::vector<size_t>{2, 4},
const std::vector<ov::Shape> indicesShapes2 = {
{2, 2},
{2, 2, 2},
{2, 4},
};
const std::vector<std::vector<size_t>> indicesShapes23 = {
std::vector<size_t>{2, 3, 2},
std::vector<size_t>{2, 3, 4},
const std::vector<ov::Shape> indicesShapes23 = {
{2, 3, 2},
{2, 3, 4},
};
const std::vector<std::tuple<int, int>> axis_batch41 = {
@ -50,79 +54,63 @@ const std::vector<std::tuple<int, int>> axis_batch42 = {
std::tuple<int, int>(4, 2),
};
const std::vector<std::vector<size_t>> inputShapesAxes4b1 = {
std::vector<size_t>{2, 6, 7, 8, 9},
std::vector<size_t>{2, 1, 7, 8, 9},
std::vector<size_t>{2, 1, 1, 8, 9},
std::vector<size_t>{2, 6, 1, 4, 9},
std::vector<size_t>{2, 6, 7, 4, 1},
std::vector<size_t>{2, 6, 1, 8, 9},
std::vector<size_t>{2, 1, 7, 1, 9},
std::vector<size_t>{2, 6, 1, 8, 4},
std::vector<size_t>{2, 6, 7, 4, 9},
std::vector<size_t>{2, 1, 7, 8, 4},
std::vector<size_t>{2, 6, 7, 8, 4},
const std::vector<std::vector<ov::Shape>> inputShapesAxes4b1 = {
{{2, 6, 7, 8, 9}},
{{2, 1, 7, 8, 9}},
{{2, 1, 1, 8, 9}},
{{2, 6, 1, 4, 9}},
{{2, 6, 7, 4, 1}},
{{2, 6, 1, 8, 9}},
{{2, 1, 7, 1, 9}},
{{2, 6, 1, 8, 4}},
{{2, 6, 7, 4, 9}},
{{2, 1, 7, 8, 4}},
{{2, 6, 7, 8, 4}},
};
const std::vector<std::vector<size_t>> inputShapesAxes4b2 = {
std::vector<size_t>{2, 3, 7, 8, 9},
std::vector<size_t>{2, 3, 7, 6, 9},
std::vector<size_t>{2, 3, 9, 8, 9},
std::vector<size_t>{2, 3, 9, 4, 9},
std::vector<size_t>{2, 3, 7, 4, 2},
std::vector<size_t>{2, 3, 5, 8, 9},
std::vector<size_t>{2, 3, 7, 2, 9},
std::vector<size_t>{2, 3, 9, 8, 4},
std::vector<size_t>{2, 3, 7, 4, 9},
std::vector<size_t>{2, 3, 7, 5, 4},
std::vector<size_t>{2, 3, 7, 8, 4},
const std::vector<std::vector<ov::Shape>> inputShapesAxes4b2 = {
{{2, 3, 7, 8, 9}},
{{2, 3, 7, 6, 9}},
{{2, 3, 9, 8, 9}},
{{2, 3, 9, 4, 9}},
{{2, 3, 7, 4, 2}},
{{2, 3, 5, 8, 9}},
{{2, 3, 7, 2, 9}},
{{2, 3, 9, 8, 4}},
{{2, 3, 7, 4, 9}},
{{2, 3, 7, 5, 4}},
{{2, 3, 7, 8, 4}},
};
const auto GatherIndiceScalar = []() {
return testing::Combine(testing::Values(std::vector<size_t>{1, 3, 4, 5}),
testing::Values(std::vector<size_t>{}),
return testing::Combine(testing::Values(ov::test::static_shapes_to_test_representation(std::vector<ov::Shape>({{1, 3, 4, 5}}))),
testing::Values(ov::Shape({})),
testing::Values(std::tuple<int, int>(2, 0)),
testing::Values(InferenceEngine::Precision::FP32),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(ov::element::f32),
testing::Values(ov::test::utils::DEVICE_GPU));
};
const auto GatherAxes4i4b1 = []() {
return testing::Combine(testing::ValuesIn(inputShapesAxes4b1),
return testing::Combine(testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapesAxes4b1)),
testing::ValuesIn(indicesShapes2),
testing::ValuesIn(axis_batch41),
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(ov::test::utils::DEVICE_GPU));
};
const auto GatherAxes4i8b1 = []() {
return testing::Combine(testing::ValuesIn(inputShapesAxes4b1),
return testing::Combine(testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapesAxes4b1)),
testing::ValuesIn(indicesShapes2),
testing::ValuesIn(axis_batch41),
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(ov::test::utils::DEVICE_GPU));
};
const auto GatherAxes4i8b2 = []() {
return testing::Combine(testing::ValuesIn(inputShapesAxes4b2),
return testing::Combine(testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapesAxes4b2)),
testing::ValuesIn(indicesShapes23),
testing::ValuesIn(axis_batch42),
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(ov::test::utils::DEVICE_GPU));
};
@ -190,53 +178,37 @@ INSTANTIATE_TEST_SUITE_P(
);
const std::vector<std::vector<int>> indices = {
std::vector<int>{0, 3, 2, 1},
{0, 3, 2, 1},
};
const std::vector<std::vector<size_t>> indicesShapes12 = {
std::vector<size_t>{4},
std::vector<size_t>{2, 2}
const std::vector<ov::Shape> indicesShapes12 = {
{4},
{2, 2}
};
const std::vector<std::vector<size_t>> indicesShapes1 = {
std::vector<size_t>{4},
const std::vector<ov::Shape> indicesShapes1 = {
{4},
};
const std::vector<std::vector<size_t>> inputShapes6DAxes5 = {
std::vector<size_t>{5, 6, 7, 8, 9, 10},
std::vector<size_t>{1, 1, 7, 8, 9, 10},
std::vector<size_t>{5, 1, 1, 8, 9, 10},
std::vector<size_t>{5, 6, 1, 1, 9, 10},
std::vector<size_t>{5, 6, 7, 1, 1, 10},
std::vector<size_t>{1, 6, 1, 8, 9, 10},
std::vector<size_t>{5, 1, 7, 1, 9, 10},
std::vector<size_t>{5, 6, 1, 8, 1, 10},
std::vector<size_t>{1, 6, 7, 1, 9, 10},
std::vector<size_t>{5, 1, 7, 8, 1, 10},
std::vector<size_t>{1, 6, 7, 8, 1, 10},
const std::vector<std::vector<ov::Shape>> inputShapesAxes4 = {
{{5, 6, 7, 8, 9}},
{{1, 6, 7, 8, 9}},
{{5, 1, 7, 8, 9}},
{{5, 6, 1, 8, 9}},
{{5, 6, 7, 1, 9}},
};
const std::vector<int> axes5 = {5};
const std::vector<std::vector<size_t>> inputShapesAxes4 = {
std::vector<size_t>{5, 6, 7, 8, 9},
std::vector<size_t>{1, 6, 7, 8, 9},
std::vector<size_t>{5, 1, 7, 8, 9},
std::vector<size_t>{5, 6, 1, 8, 9},
std::vector<size_t>{5, 6, 7, 1, 9},
};
const std::vector<std::vector<size_t>> inputShapes6DAxes4 = {
std::vector<size_t>{5, 6, 7, 8, 9, 10},
std::vector<size_t>{1, 1, 7, 8, 9, 10},
std::vector<size_t>{5, 1, 1, 8, 9, 10},
std::vector<size_t>{5, 6, 1, 1, 9, 10},
std::vector<size_t>{5, 6, 7, 1, 9, 1},
std::vector<size_t>{1, 6, 1, 8, 9, 10},
std::vector<size_t>{5, 1, 7, 1, 9, 10},
std::vector<size_t>{5, 6, 1, 8, 9, 1},
std::vector<size_t>{1, 6, 7, 1, 9, 10},
std::vector<size_t>{5, 1, 7, 8, 9, 1},
std::vector<size_t>{1, 6, 7, 8, 9, 1},
const std::vector<std::vector<ov::Shape>> inputShapes6DAxes4 = {
{{5, 6, 7, 8, 9, 10}},
{{1, 1, 7, 8, 9, 10}},
{{5, 1, 1, 8, 9, 10}},
{{5, 6, 1, 1, 9, 10}},
{{5, 6, 7, 1, 9, 1}},
{{1, 6, 1, 8, 9, 10}},
{{5, 1, 7, 1, 9, 10}},
{{5, 6, 1, 8, 9, 1}},
{{1, 6, 7, 1, 9, 10}},
{{5, 1, 7, 8, 9, 1}},
{{1, 6, 7, 8, 9, 1}},
};
const std::vector<int> axes4 = {4};
@ -245,12 +217,8 @@ const auto GatherAxes4 = []() {
return testing::Combine(testing::ValuesIn(indices),
testing::ValuesIn(indicesShapes12),
testing::ValuesIn(axes4),
testing::ValuesIn(inputShapesAxes4),
testing::ValuesIn(netPrecisionsFP16),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(InferenceEngine::Layout::ANY),
testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapesAxes4)),
testing::Values(ov::element::f16),
testing::Values(ov::test::utils::DEVICE_GPU));
};
@ -265,12 +233,8 @@ const auto Gather6dAxes4 = []() {
return testing::Combine(testing::ValuesIn(indices),
testing::ValuesIn(indicesShapes1),
testing::ValuesIn(axes4),
testing::ValuesIn(inputShapes6DAxes4),
testing::ValuesIn(netPrecisionsFP32),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(InferenceEngine::Layout::ANY),
testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapes6DAxes4)),
testing::Values(ov::element::f32),
testing::Values(ov::test::utils::DEVICE_GPU));
};
@ -281,30 +245,30 @@ INSTANTIATE_TEST_SUITE_P(
GatherLayerTest::getTestCaseName
);
const std::vector<std::vector<size_t>> inputShapesAxes3 = {
std::vector<size_t>{5, 6, 7, 8},
std::vector<size_t>{1, 6, 7, 8},
std::vector<size_t>{5, 1, 7, 8},
std::vector<size_t>{5, 6, 1, 8},
std::vector<size_t>{5, 6, 7, 8, 9},
std::vector<size_t>{1, 6, 7, 8, 9},
std::vector<size_t>{5, 1, 7, 8, 9},
std::vector<size_t>{5, 6, 1, 8, 9},
std::vector<size_t>{5, 6, 7, 8, 1},
const std::vector<std::vector<ov::Shape>> inputShapesAxes3 = {
{{5, 6, 7, 8}},
{{1, 6, 7, 8}},
{{5, 1, 7, 8}},
{{5, 6, 1, 8}},
{{5, 6, 7, 8, 9}},
{{1, 6, 7, 8, 9}},
{{5, 1, 7, 8, 9}},
{{5, 6, 1, 8, 9}},
{{5, 6, 7, 8, 1}},
};
const std::vector<std::vector<size_t>> inputShapes6DAxes3 = {
std::vector<size_t>{5, 6, 7, 8, 9, 10},
std::vector<size_t>{1, 1, 7, 8, 9, 10},
std::vector<size_t>{5, 1, 1, 8, 9, 10},
std::vector<size_t>{5, 6, 1, 8, 1, 10},
std::vector<size_t>{5, 6, 7, 8, 1, 1},
std::vector<size_t>{1, 6, 1, 8, 9, 10},
std::vector<size_t>{5, 1, 7, 8, 1, 10},
std::vector<size_t>{5, 6, 1, 8, 9, 1},
std::vector<size_t>{1, 6, 7, 8, 1, 10},
std::vector<size_t>{5, 1, 7, 8, 9, 1},
std::vector<size_t>{1, 6, 7, 8, 9, 1},
const std::vector<std::vector<ov::Shape>> inputShapes6DAxes3 = {
{{5, 6, 7, 8, 9, 10}},
{{1, 1, 7, 8, 9, 10}},
{{5, 1, 1, 8, 9, 10}},
{{5, 6, 1, 8, 1, 10}},
{{5, 6, 7, 8, 1, 1}},
{{1, 6, 1, 8, 9, 10}},
{{5, 1, 7, 8, 1, 10}},
{{5, 6, 1, 8, 9, 1}},
{{1, 6, 7, 8, 1, 10}},
{{5, 1, 7, 8, 9, 1}},
{{1, 6, 7, 8, 9, 1}},
};
const std::vector<int> axes3 = {3};
@ -313,12 +277,8 @@ const auto GatherAxes3 = []() {
return testing::Combine(testing::ValuesIn(indices),
testing::ValuesIn(indicesShapes12),
testing::ValuesIn(axes3),
testing::ValuesIn(inputShapesAxes3),
testing::ValuesIn(netPrecisionsFP32),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(InferenceEngine::Layout::ANY),
testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapesAxes3)),
testing::Values(ov::element::f32),
testing::Values(ov::test::utils::DEVICE_GPU));
};
@ -333,12 +293,8 @@ const auto Gather6dAxes3 = []() {
return testing::Combine(testing::ValuesIn(indices),
testing::ValuesIn(indicesShapes1),
testing::ValuesIn(axes3),
testing::ValuesIn(inputShapes6DAxes3),
testing::ValuesIn(netPrecisionsI32),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(InferenceEngine::Layout::ANY),
testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapes6DAxes3)),
testing::Values(ov::element::i32),
testing::Values(ov::test::utils::DEVICE_GPU));
};
@ -349,31 +305,31 @@ INSTANTIATE_TEST_SUITE_P(
GatherLayerTest::getTestCaseName
);
const std::vector<std::vector<size_t>> inputShapesAxes2 = {
std::vector<size_t>{5, 6, 7},
std::vector<size_t>{5, 6, 7, 8},
std::vector<size_t>{1, 6, 7, 8},
std::vector<size_t>{5, 1, 7, 8},
std::vector<size_t>{5, 6, 7, 1},
std::vector<size_t>{5, 6, 7, 8, 9},
std::vector<size_t>{1, 6, 7, 8, 9},
std::vector<size_t>{5, 1, 7, 8, 9},
std::vector<size_t>{5, 6, 7, 1, 9},
std::vector<size_t>{5, 6, 7, 8, 1},
const std::vector<std::vector<ov::Shape>> inputShapesAxes2 = {
{{5, 6, 7}},
{{5, 6, 7, 8}},
{{1, 6, 7, 8}},
{{5, 1, 7, 8}},
{{5, 6, 7, 1}},
{{5, 6, 7, 8, 9}},
{{1, 6, 7, 8, 9}},
{{5, 1, 7, 8, 9}},
{{5, 6, 7, 1, 9}},
{{5, 6, 7, 8, 1}},
};
const std::vector<std::vector<size_t>> inputShapes6DAxes2 = {
std::vector<size_t>{5, 6, 7, 8, 9, 10},
std::vector<size_t>{1, 1, 7, 8, 9, 10},
std::vector<size_t>{5, 1, 7, 1, 9, 10},
std::vector<size_t>{5, 6, 7, 1, 1, 10},
std::vector<size_t>{5, 6, 7, 8, 1, 1},
std::vector<size_t>{1, 6, 7, 1, 9, 10},
std::vector<size_t>{5, 1, 7, 8, 1, 10},
std::vector<size_t>{5, 6, 7, 1, 9, 1},
std::vector<size_t>{1, 6, 7, 8, 1, 10},
std::vector<size_t>{5, 1, 7, 8, 9, 1},
std::vector<size_t>{1, 6, 7, 8, 9, 1},
const std::vector<std::vector<ov::Shape>> inputShapes6DAxes2 = {
{{5, 6, 7, 8, 9, 10}},
{{1, 1, 7, 8, 9, 10}},
{{5, 1, 7, 1, 9, 10}},
{{5, 6, 7, 1, 1, 10}},
{{5, 6, 7, 8, 1, 1}},
{{1, 6, 7, 1, 9, 10}},
{{5, 1, 7, 8, 1, 10}},
{{5, 6, 7, 1, 9, 1}},
{{1, 6, 7, 8, 1, 10}},
{{5, 1, 7, 8, 9, 1}},
{{1, 6, 7, 8, 9, 1}},
};
const std::vector<int> axes2 = {2};
@ -382,12 +338,8 @@ const auto GatherAxes2 = []() {
return testing::Combine(testing::ValuesIn(indices),
testing::ValuesIn(indicesShapes12),
testing::ValuesIn(axes2),
testing::ValuesIn(inputShapesAxes2),
testing::ValuesIn(netPrecisionsFP32),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(InferenceEngine::Layout::ANY),
testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapesAxes2)),
testing::Values(ov::element::f32),
testing::Values(ov::test::utils::DEVICE_GPU));
};
@ -402,12 +354,8 @@ const auto Gather6dAxes2 = []() {
return testing::Combine(testing::ValuesIn(indices),
testing::ValuesIn(indicesShapes1),
testing::ValuesIn(axes2),
testing::ValuesIn(inputShapes6DAxes2),
testing::ValuesIn(netPrecisionsFP16),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(InferenceEngine::Layout::ANY),
testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapes6DAxes2)),
testing::Values(ov::element::f16),
testing::Values(ov::test::utils::DEVICE_GPU));
};
@ -418,32 +366,32 @@ INSTANTIATE_TEST_SUITE_P(
GatherLayerTest::getTestCaseName
);
const std::vector<std::vector<size_t>> inputShapesAxes1 = {
std::vector<size_t>{5, 6},
std::vector<size_t>{5, 6, 7},
std::vector<size_t>{5, 6, 7, 8},
std::vector<size_t>{1, 6, 7, 8},
std::vector<size_t>{5, 6, 1, 8},
std::vector<size_t>{5, 6, 7, 1},
std::vector<size_t>{5, 6, 7, 8, 9},
std::vector<size_t>{1, 6, 7, 8, 9},
std::vector<size_t>{5, 6, 1, 8, 9},
std::vector<size_t>{5, 6, 7, 1, 9},
std::vector<size_t>{5, 6, 7, 8, 1},
const std::vector<std::vector<ov::Shape>> inputShapesAxes1 = {
{{5, 6}},
{{5, 6, 7}},
{{5, 6, 7, 8}},
{{1, 6, 7, 8}},
{{5, 6, 1, 8}},
{{5, 6, 7, 1}},
{{5, 6, 7, 8, 9}},
{{1, 6, 7, 8, 9}},
{{5, 6, 1, 8, 9}},
{{5, 6, 7, 1, 9}},
{{5, 6, 7, 8, 1}},
};
const std::vector<std::vector<size_t>> inputShapes6DAxes1 = {
std::vector<size_t>{5, 6, 7, 8, 9, 10},
std::vector<size_t>{1, 6, 1, 8, 9, 10},
std::vector<size_t>{5, 6, 1, 1, 9, 10},
std::vector<size_t>{5, 6, 7, 1, 1, 10},
std::vector<size_t>{5, 6, 7, 8, 1, 1},
std::vector<size_t>{1, 6, 7, 1, 9, 10},
std::vector<size_t>{5, 6, 1, 8, 1, 10},
std::vector<size_t>{5, 6, 1, 8, 9, 1},
std::vector<size_t>{1, 6, 7, 8, 1, 10},
std::vector<size_t>{1, 6, 7, 8, 9, 1},
std::vector<size_t>{5, 6, 7, 1, 9, 1},
const std::vector<std::vector<ov::Shape>> inputShapes6DAxes1 = {
{{5, 6, 7, 8, 9, 10}},
{{1, 6, 1, 8, 9, 10}},
{{5, 6, 1, 1, 9, 10}},
{{5, 6, 7, 1, 1, 10}},
{{5, 6, 7, 8, 1, 1}},
{{1, 6, 7, 1, 9, 10}},
{{5, 6, 1, 8, 1, 10}},
{{5, 6, 1, 8, 9, 1}},
{{1, 6, 7, 8, 1, 10}},
{{1, 6, 7, 8, 9, 1}},
{{5, 6, 7, 1, 9, 1}},
};
const std::vector<int> axes1 = {1};
@ -452,12 +400,8 @@ const auto GatherAxes1 = []() {
return testing::Combine(testing::ValuesIn(indices),
testing::ValuesIn(indicesShapes12),
testing::ValuesIn(axes1),
testing::ValuesIn(inputShapesAxes1),
testing::ValuesIn(netPrecisionsI32),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(InferenceEngine::Layout::ANY),
testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapesAxes1)),
testing::Values(ov::element::i32),
testing::Values(ov::test::utils::DEVICE_GPU));
};
@ -472,12 +416,8 @@ const auto Gather6dAxes1 = []() {
return testing::Combine(testing::ValuesIn(indices),
testing::ValuesIn(indicesShapes1),
testing::ValuesIn(axes1),
testing::ValuesIn(inputShapes6DAxes1),
testing::ValuesIn(netPrecisionsFP32),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(InferenceEngine::Layout::ANY),
testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapes6DAxes1)),
testing::Values(ov::element::f32),
testing::Values(ov::test::utils::DEVICE_GPU));
};
@ -488,33 +428,33 @@ INSTANTIATE_TEST_SUITE_P(
GatherLayerTest::getTestCaseName
);
const std::vector<std::vector<size_t>> inputShapesAxes0 = {
std::vector<size_t>{5},
std::vector<size_t>{5, 6},
std::vector<size_t>{5, 6, 7},
std::vector<size_t>{5, 6, 7, 8},
std::vector<size_t>{5, 1, 7, 8},
std::vector<size_t>{5, 6, 1, 8},
std::vector<size_t>{5, 6, 7, 1},
std::vector<size_t>{5, 6, 7, 8, 9},
std::vector<size_t>{5, 1, 7, 8, 9},
std::vector<size_t>{5, 6, 1, 8, 9},
std::vector<size_t>{5, 6, 7, 1, 9},
std::vector<size_t>{5, 6, 7, 8, 1},
const std::vector<std::vector<ov::Shape>> inputShapesAxes0 = {
{{5}},
{{5, 6}},
{{5, 6, 7}},
{{5, 6, 7, 8}},
{{5, 1, 7, 8}},
{{5, 6, 1, 8}},
{{5, 6, 7, 1}},
{{5, 6, 7, 8, 9}},
{{5, 1, 7, 8, 9}},
{{5, 6, 1, 8, 9}},
{{5, 6, 7, 1, 9}},
{{5, 6, 7, 8, 1}},
};
const std::vector<std::vector<size_t>> inputShapes6DAxes0 = {
std::vector<size_t>{5, 6, 7, 8, 9, 10},
std::vector<size_t>{5, 1, 1, 8, 9, 10},
std::vector<size_t>{5, 6, 1, 1, 9, 10},
std::vector<size_t>{5, 6, 7, 1, 1, 10},
std::vector<size_t>{5, 6, 7, 8, 1, 1},
std::vector<size_t>{5, 1, 7, 1, 9, 10},
std::vector<size_t>{5, 6, 1, 8, 1, 10},
std::vector<size_t>{5, 6, 1, 8, 9, 1},
std::vector<size_t>{5, 1, 7, 8, 1, 10},
std::vector<size_t>{5, 1, 7, 8, 9, 1},
std::vector<size_t>{5, 6, 7, 1, 9, 1},
const std::vector<std::vector<ov::Shape>> inputShapes6DAxes0 = {
{{5, 6, 7, 8, 9, 10}},
{{5, 1, 1, 8, 9, 10}},
{{5, 6, 1, 1, 9, 10}},
{{5, 6, 7, 1, 1, 10}},
{{5, 6, 7, 8, 1, 1}},
{{5, 1, 7, 1, 9, 10}},
{{5, 6, 1, 8, 1, 10}},
{{5, 6, 1, 8, 9, 1}},
{{5, 1, 7, 8, 1, 10}},
{{5, 1, 7, 8, 9, 1}},
{{5, 6, 7, 1, 9, 1}},
};
const std::vector<int> axes0 = {0};
@ -523,12 +463,8 @@ const auto GatherAxes0 = []() {
return testing::Combine(testing::ValuesIn(indices),
testing::ValuesIn(indicesShapes12),
testing::ValuesIn(axes0),
testing::ValuesIn(inputShapesAxes0),
testing::ValuesIn(netPrecisionsFP32),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(InferenceEngine::Layout::ANY),
testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapesAxes0)),
testing::Values(ov::element::f32),
testing::Values(ov::test::utils::DEVICE_GPU));
};
@ -543,12 +479,8 @@ const auto Gather6dAxes0 = []() {
return testing::Combine(testing::ValuesIn(indices),
testing::ValuesIn(indicesShapes1),
testing::ValuesIn(axes0),
testing::ValuesIn(inputShapes6DAxes0),
testing::ValuesIn(netPrecisionsFP32),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(InferenceEngine::Layout::ANY),
testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapes6DAxes0)),
testing::Values(ov::element::f32),
testing::Values(ov::test::utils::DEVICE_GPU));
};
@ -560,14 +492,10 @@ INSTANTIATE_TEST_SUITE_P(
);
const auto GatherAxes0Optimized = []() {
return testing::Combine(testing::ValuesIn({std::vector<size_t>{4, 8, 2, 2}}),
testing::ValuesIn({std::vector<size_t>{}}),
testing::ValuesIn({std::tuple<int, int>{0, 0}}),
testing::ValuesIn(netPrecisionsFP32),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(InferenceEngine::Layout::ANY),
return testing::Combine(testing::ValuesIn(ov::test::static_shapes_to_test_representation(std::vector<std::vector<ov::Shape>>({{{4, 8, 2, 2}}}))),
testing::Values(ov::Shape({})),
testing::Values(std::tuple<int, int>(0, 0)),
testing::Values(ov::element::f32),
testing::Values(ov::test::utils::DEVICE_GPU));
};
@ -579,18 +507,14 @@ INSTANTIATE_TEST_SUITE_P(
);
gather7ParamsTuple dummyParams = {
std::vector<size_t>{2, 3},
std::vector<size_t>{2, 2},
ov::test::static_shapes_to_test_representation(std::vector<ov::Shape>({{2, 3}})),
ov::Shape({2, 2}),
std::tuple<int, int>{1, 1},
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Layout::ANY,
InferenceEngine::Layout::ANY,
ov::element::f32,
ov::test::utils::DEVICE_GPU,
};
std::vector<std::vector<int>> indicesData = {
std::vector<std::vector<int64_t>> indicesData = {
{0, 1, 2, 0}, // positive in bound
{-1, -2, -3, -1}, // negative in bound
{-1, 0, 1, 2}, // positive and negative in bound
@ -604,6 +528,10 @@ const auto gatherWithIndicesParams = testing::Combine(
testing::ValuesIn(indicesData)
);
INSTANTIATE_TEST_CASE_P(smoke, Gather8withIndicesDataLayerTest, gatherWithIndicesParams, Gather8withIndicesDataLayerTest::getTestCaseName);
INSTANTIATE_TEST_CASE_P(smoke,
Gather8withIndicesDataLayerTest,
gatherWithIndicesParams,
Gather8withIndicesDataLayerTest::getTestCaseName
);
} // namespace

184
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/gather_elements.cpp
View File

@ -5,222 +5,220 @@
#include <vector>
#include <ngraph/opsets/opset6.hpp>
#include "single_layer_tests/gather_elements.hpp"
#include "single_op_tests/gather_elements.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
using namespace ngraph::opset6;
namespace {
using ov::test::GatherElementsLayerTest;
const std::vector<InferenceEngine::Precision> inputPrecisions = {
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16,
InferenceEngine::Precision::I32,
const std::vector<ov::element::Type> model_types = {
ov::element::f32,
ov::element::f16,
ov::element::i32,
};
const std::vector<InferenceEngine::Precision> idxPrecisions = {
InferenceEngine::Precision::I32,
InferenceEngine::Precision::I64,
const std::vector<ov::element::Type> indices_types = {
ov::element::i32,
ov::element::i64,
};
INSTANTIATE_TEST_SUITE_P(smoke_set1, GatherElementsLayerTest,
::testing::Combine(
::testing::Values(std::vector<size_t>({2, 2})),
::testing::Values(std::vector<size_t>({2, 2})),
::testing::ValuesIn(std::vector<int>({-1, 0, 1})),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::Values(ov::test::static_shapes_to_test_representation({ov::Shape{2, 2}})),
::testing::Values(ov::Shape{2, 2}),
::testing::ValuesIn(std::vector<int>{-1, 0, 1}),
::testing::ValuesIn(model_types),
::testing::ValuesIn(indices_types),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherElementsLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_set2, GatherElementsLayerTest,
::testing::Combine(
::testing::Values(std::vector<size_t>({2, 2, 1})),
::testing::Values(std::vector<size_t>({4, 2, 1})),
::testing::Values(ov::test::static_shapes_to_test_representation({ov::Shape{2, 2, 1}})),
::testing::Values(ov::Shape{4, 2, 1}),
::testing::ValuesIn(std::vector<int>({0, -3})),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(model_types),
::testing::ValuesIn(indices_types),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherElementsLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_set3, GatherElementsLayerTest,
::testing::Combine(
::testing::Values(std::vector<size_t>({2, 2, 3, 5})),
::testing::Values(std::vector<size_t>({2, 2, 3, 7})),
::testing::Values(ov::test::static_shapes_to_test_representation({ov::Shape{2, 2, 3, 5}})),
::testing::Values(ov::Shape{2, 2, 3, 7}),
::testing::Values(3, -1),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(model_types),
::testing::ValuesIn(indices_types),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherElementsLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_set4, GatherElementsLayerTest,
::testing::Combine(
::testing::Values(std::vector<size_t>({3, 2, 3, 8})),
::testing::Values(std::vector<size_t>({2, 2, 3, 8})),
::testing::Values(ov::test::static_shapes_to_test_representation({ov::Shape{3, 2, 3, 8}})),
::testing::Values(ov::Shape{2, 2, 3, 8}),
::testing::Values(0, -4),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(model_types),
::testing::ValuesIn(indices_types),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherElementsLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_set5, GatherElementsLayerTest,
::testing::Combine(
::testing::Values(std::vector<size_t>({3, 2, 3, 4, 8})),
::testing::Values(std::vector<size_t>({3, 2, 3, 5, 8})),
::testing::Values(ov::test::static_shapes_to_test_representation({ov::Shape{3, 2, 3, 4, 8}})),
::testing::Values(ov::Shape{3, 2, 3, 5, 8}),
::testing::Values(3, -2),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(model_types),
::testing::ValuesIn(indices_types),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherElementsLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_GatherElements_rank4axis0, GatherElementsLayerTest,
::testing::Combine(
::testing::Values(std::vector<size_t>{7, 7, 8, 4}),
::testing::Values(std::vector<size_t>{2, 7, 8, 4}),
::testing::Values(ov::test::static_shapes_to_test_representation({ov::Shape{7, 7, 8, 4}})),
::testing::Values(ov::Shape{2, 7, 8, 4}),
::testing::Values(0),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(model_types),
::testing::ValuesIn(indices_types),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherElementsLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_GatherElements_rank4axis1, GatherElementsLayerTest,
::testing::Combine(
::testing::Values(std::vector<size_t>{6, 1, 8, 4}),
::testing::Values(std::vector<size_t>{6, 8, 8, 4}),
::testing::Values(ov::test::static_shapes_to_test_representation({ov::Shape{6, 1, 8, 4}})),
::testing::Values(ov::Shape{6, 8, 8, 4}),
::testing::Values(1, -3),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(model_types),
::testing::ValuesIn(indices_types),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherElementsLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_GatherElements_rank4axis2, GatherElementsLayerTest,
::testing::Combine(
::testing::Values(std::vector<size_t>{6, 7, 4, 4}),
::testing::Values(std::vector<size_t>{6, 7, 2, 4}),
::testing::Values(ov::test::static_shapes_to_test_representation({ov::Shape{6, 7, 4, 4}})),
::testing::Values(ov::Shape{6, 7, 2, 4}),
::testing::Values(2, -2),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(model_types),
::testing::ValuesIn(indices_types),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherElementsLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_GatherElements_rank4axis3, GatherElementsLayerTest,
::testing::Combine(
::testing::Values(std::vector<size_t>{6, 5, 8, 7}),
::testing::Values(std::vector<size_t>{6, 5, 8, 7}),
::testing::Values(3, -1),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::Values(ov::test::static_shapes_to_test_representation({ov::Shape{6, 5, 8, 7}})),
::testing::Values(ov::Shape{6, 5, 8, 7}),
::testing::Values(1, -3),
::testing::ValuesIn(model_types),
::testing::ValuesIn(indices_types),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherElementsLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_GatherElements_rank5axis0, GatherElementsLayerTest,
::testing::Combine(
::testing::Values(std::vector<size_t>{2, 3, 9, 4, 9}),
::testing::Values(std::vector<size_t>{1, 3, 9, 4, 9}),
::testing::Values(ov::test::static_shapes_to_test_representation({ov::Shape{2, 3, 9, 4, 9}})),
::testing::Values(ov::Shape{1, 3, 9, 4, 9}),
::testing::Values(0),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(model_types),
::testing::ValuesIn(indices_types),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherElementsLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_GatherElements_rank5axis1, GatherElementsLayerTest,
::testing::Combine(
::testing::Values(std::vector<size_t>{2, 3, 5, 4, 7}),
::testing::Values(std::vector<size_t>{2, 9, 5, 4, 7}),
::testing::Values(ov::test::static_shapes_to_test_representation({ov::Shape{2, 3, 5, 4, 7}})),
::testing::Values(ov::Shape{2, 9, 5, 4, 7}),
::testing::Values(1, -4),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(model_types),
::testing::ValuesIn(indices_types),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherElementsLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_GatherElements_rank5axis2, GatherElementsLayerTest,
::testing::Combine(
::testing::Values(std::vector<size_t>{1, 2, 6, 8, 9}),
::testing::Values(std::vector<size_t>{1, 2, 6, 8, 9}),
::testing::Values(ov::test::static_shapes_to_test_representation({ov::Shape{1, 2, 6, 8, 9}})),
::testing::Values(ov::Shape{1, 2, 6, 8, 9}),
::testing::Values(2, -3),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(model_types),
::testing::ValuesIn(indices_types),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherElementsLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_GatherElements_rank5axis3, GatherElementsLayerTest,
::testing::Combine(
::testing::Values(std::vector<size_t>{2, 2, 4, 7, 7}),
::testing::Values(std::vector<size_t>{2, 2, 4, 3, 7}),
::testing::Values(ov::test::static_shapes_to_test_representation({ov::Shape{2, 2, 4, 7, 7}})),
::testing::Values(ov::Shape{2, 2, 4, 3, 7}),
::testing::Values(3, -2),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(model_types),
::testing::ValuesIn(indices_types),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherElementsLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_GatherElements_rank5axis4, GatherElementsLayerTest,
::testing::Combine(
::testing::Values(std::vector<size_t>{1, 3, 9, 3, 2}),
::testing::Values(std::vector<size_t>{1, 3, 9, 3, 9}),
::testing::Values(ov::test::static_shapes_to_test_representation({ov::Shape{1, 3, 9, 3, 2}})),
::testing::Values(ov::Shape{1, 3, 9, 3, 9}),
::testing::Values(4, -1),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(model_types),
::testing::ValuesIn(indices_types),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherElementsLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_GatherElements_rank6axis0, GatherElementsLayerTest,
::testing::Combine(
::testing::Values(std::vector<size_t>{3, 3, 2, 4, 4, 3}),
::testing::Values(std::vector<size_t>{7, 3, 2, 4, 4, 3}),
::testing::Values(ov::test::static_shapes_to_test_representation({ov::Shape{3, 3, 2, 4, 4, 3}})),
::testing::Values(ov::Shape{7, 3, 2, 4, 4, 3}),
::testing::Values(0),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(model_types),
::testing::ValuesIn(indices_types),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherElementsLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_GatherElements_rank6axis1, GatherElementsLayerTest,
::testing::Combine(
::testing::Values(std::vector<size_t>{1, 6, 2, 3, 5, 9}),
::testing::Values(std::vector<size_t>{1, 6, 2, 3, 5, 9}),
::testing::Values(ov::test::static_shapes_to_test_representation({ov::Shape{1, 6, 2, 3, 5, 9}})),
::testing::Values(ov::Shape{1, 6, 2, 3, 5, 9}),
::testing::Values(1, -5),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(model_types),
::testing::ValuesIn(indices_types),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherElementsLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_GatherElements_rank6axis2, GatherElementsLayerTest,
::testing::Combine(
::testing::Values(std::vector<size_t>{2, 3, 9, 7, 2, 1}),
::testing::Values(std::vector<size_t>{2, 3, 5, 7, 2, 1}),
::testing::Values(ov::test::static_shapes_to_test_representation({ov::Shape{2, 3, 9, 7, 2, 1}})),
::testing::Values(ov::Shape{2, 3, 5, 7, 2, 1}),
::testing::Values(2, -4),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(model_types),
::testing::ValuesIn(indices_types),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherElementsLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_GatherElements_rank6axis3, GatherElementsLayerTest,
::testing::Combine(
::testing::Values(std::vector<size_t>{1, 3, 4, 5, 1, 3}),
::testing::Values(std::vector<size_t>{1, 3, 4, 4, 1, 3}),
::testing::Values(ov::test::static_shapes_to_test_representation({ov::Shape{1, 3, 4, 5, 1, 3}})),
::testing::Values(ov::Shape{1, 3, 4, 4, 1, 3}),
::testing::Values(3, -3),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(model_types),
::testing::ValuesIn(indices_types),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherElementsLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_GatherElements_rank6axis4, GatherElementsLayerTest,
::testing::Combine(
::testing::Values(std::vector<size_t>{1, 3, 2, 4, 3, 3}),
::testing::Values(std::vector<size_t>{1, 3, 2, 4, 6, 3}),
::testing::Values(ov::test::static_shapes_to_test_representation({ov::Shape{1, 3, 2, 4, 3, 3}})),
::testing::Values(ov::Shape{1, 3, 2, 4, 6, 3}),
::testing::Values(4, -2),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(model_types),
::testing::ValuesIn(indices_types),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherElementsLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_GatherElements_rank6axis5, GatherElementsLayerTest,
::testing::Combine(
::testing::Values(std::vector<size_t>{2, 1, 7, 8, 1, 6}),
::testing::Values(std::vector<size_t>{2, 1, 7, 8, 1, 5}),
::testing::Values(ov::test::static_shapes_to_test_representation({ov::Shape{2, 1, 7, 8, 1, 6}})),
::testing::Values(ov::Shape{2, 1, 7, 8, 1, 5}),
::testing::Values(5, -1),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(model_types),
::testing::ValuesIn(indices_types),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherElementsLayerTest::getTestCaseName);

96
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/gather_nd.cpp
View File

@ -4,107 +4,103 @@
#include <vector>
#include "single_layer_tests/gather_nd.hpp"
#include "single_op_tests/gather_nd.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
using namespace ngraph::opset5;
namespace {
using ov::test::GatherNDLayerTest;
using ov::test::GatherND8LayerTest;
const std::vector<InferenceEngine::Precision> inputPrecisions = {
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16,
InferenceEngine::Precision::I32,
const std::vector<ov::element::Type> inputPrecisions = {
ov::element::f32,
ov::element::f16,
ov::element::i32,
};
const std::vector<InferenceEngine::Precision> idxPrecisions = {
InferenceEngine::Precision::I32,
InferenceEngine::Precision::I64,
const std::vector<ov::element::Type> idxPrecisions = {
ov::element::i32,
ov::element::i64,
};
// set1
const auto gatherNDArgsSubset1 = ::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>>(
{ {2, 2}, {2, 3, 4} })), // Data shape
::testing::ValuesIn(std::vector<std::vector<size_t>>(
{ {2, 1}, {2, 1, 1} })), // Indices shape
::testing::ValuesIn(std::vector<int>({ 0, 1 })) // Batch dims
);
std::vector<std::vector<ov::Shape>> shapes_subset1_static = std::vector<std::vector<ov::Shape>>({
{{2, 2}}, {{2, 3, 4}} });
std::vector<ov::Shape> indices_subset1_static = std::vector<ov::Shape>({
{2, 1}, {2, 1, 1}});
// set2
const auto gatherNDArgsSubset2 = ::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>>(
{ {15, 12, 20, 15, 2}, {15, 12, 18, 7, 17} })), // Data shape
::testing::ValuesIn(std::vector<std::vector<size_t>>(
{ {15, 12, 2}, {15, 12, 5, 9, 1, 3} })), // Indices shape
::testing::ValuesIn(std::vector<int>({ 1, 2 })) // Batch dims
);
std::vector<std::vector<ov::Shape>> shapes_subset2_static = std::vector<std::vector<ov::Shape>>({
{{15, 12, 20, 15, 2}}, {{15, 12, 18, 7, 17}}});
std::vector<ov::Shape> indices_subset2_static = std::vector<ov::Shape>({
{15, 12, 2}, {15, 12, 5, 9, 1, 3}});
// set3
const auto gatherNDArgsSubset3 = ::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>>(
{ {4, 3, 2, 5, 5, 2}, {4, 3, 2, 5, 7, 2} })), // Data shape
::testing::ValuesIn(std::vector<std::vector<size_t>>(
{ {4, 3, 2, 5, 1}, {4, 3, 2, 5, 6, 2} })), // Indices shape
::testing::ValuesIn(std::vector<int>({ 3, 4 })) // Batch dims
);
std::vector<std::vector<ov::Shape>> shapes_subset3_static = std::vector<std::vector<ov::Shape>>({
{{4, 3, 2, 5, 5, 2}}, {{4, 3, 2, 5, 7, 2}} });
std::vector<ov::Shape> indices_subset3_static = std::vector<ov::Shape>({
{4, 3, 2, 5, 1}, {4, 3, 2, 5, 6, 2}});
// -------------------------------- V5 --------------------------------
INSTANTIATE_TEST_SUITE_P(smoke_GatherND5_set1, GatherNDLayerTest,
::testing::Combine(
gatherNDArgsSubset1,
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(shapes_subset1_static)),
::testing::ValuesIn(std::vector<ov::Shape>(indices_subset1_static)),
::testing::ValuesIn(std::vector<int>({ 0, 1 })),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::Values(ov::test::utils::DEVICE_GPU),
::testing::Values<Config>({})),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherNDLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_GatherND5_set2, GatherNDLayerTest,
::testing::Combine(
gatherNDArgsSubset2,
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(shapes_subset2_static)),
::testing::ValuesIn(std::vector<ov::Shape>(indices_subset2_static)),
::testing::ValuesIn(std::vector<int>({ 1, 2 })),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::Values(ov::test::utils::DEVICE_GPU),
::testing::Values<Config>({})),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherNDLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_GatherND5_set3, GatherNDLayerTest,
::testing::Combine(
gatherNDArgsSubset3,
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(shapes_subset3_static)),
::testing::ValuesIn(std::vector<ov::Shape>(indices_subset3_static)),
::testing::ValuesIn(std::vector<int>({ 3, 4 })),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::Values(ov::test::utils::DEVICE_GPU),
::testing::Values<Config>({})),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherNDLayerTest::getTestCaseName);
// -------------------------------- V8 --------------------------------
INSTANTIATE_TEST_SUITE_P(smoke_GatherND8_set1, GatherND8LayerTest,
::testing::Combine(
gatherNDArgsSubset1,
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(shapes_subset1_static)),
::testing::ValuesIn(std::vector<ov::Shape>(indices_subset1_static)),
::testing::ValuesIn(std::vector<int>({ 0, 1 })),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::Values(ov::test::utils::DEVICE_GPU),
::testing::Values<Config>({})),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherND8LayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_GatherND8_set2, GatherND8LayerTest,
::testing::Combine(
gatherNDArgsSubset2,
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(shapes_subset2_static)),
::testing::ValuesIn(std::vector<ov::Shape>(indices_subset2_static)),
::testing::ValuesIn(std::vector<int>({ 1, 2 })),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::Values(ov::test::utils::DEVICE_GPU),
::testing::Values<Config>({})),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherND8LayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_GatherND8_set3, GatherND8LayerTest,
::testing::Combine(
gatherNDArgsSubset3,
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(shapes_subset3_static)),
::testing::ValuesIn(std::vector<ov::Shape>(indices_subset3_static)),
::testing::ValuesIn(std::vector<int>({ 3, 4 })),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::Values(ov::test::utils::DEVICE_GPU),
::testing::Values<Config>({})),
::testing::Values(ov::test::utils::DEVICE_GPU)),
GatherND8LayerTest::getTestCaseName);
} // namespace

26
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/gather_tree.cpp
View File

@ -4,24 +4,24 @@
#include <vector>
#include "single_layer_tests/gather_tree.hpp"
#include "single_op_tests/gather_tree.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
namespace {
using ov::test::GatherTreeLayerTest;
using ov::test::utils::InputLayerType;
const std::vector<InferenceEngine::Precision> netPrecisions = {
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16,
InferenceEngine::Precision::I32
const std::vector<ov::element::Type> netPrecisions = {
ov::element::f32,
ov::element::f16,
ov::element::i32
};
const std::vector<std::vector<size_t>> inputShapes = { {5, 1, 10}, {1, 1, 10}, {20, 1, 10}, {20, 20, 10} };
const std::vector<ov::Shape> inputShapes = { {5, 1, 10}, {1, 1, 10}, {20, 1, 10}, {20, 20, 10} };
const std::vector<ngraph::helpers::InputLayerType> secondaryInputTypes = {
ngraph::helpers::InputLayerType::CONSTANT,
ngraph::helpers::InputLayerType::PARAMETER
const std::vector<InputLayerType> secondaryInputTypes = {
InputLayerType::CONSTANT,
InputLayerType::PARAMETER
};
INSTANTIATE_TEST_SUITE_P(Basic_smoke, GatherTreeLayerTest,
@ -29,10 +29,6 @@ INSTANTIATE_TEST_SUITE_P(Basic_smoke, GatherTreeLayerTest,
::testing::ValuesIn(inputShapes),
::testing::ValuesIn(secondaryInputTypes),
::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(ov::test::utils::DEVICE_GPU)),
GatherTreeLayerTest::getTestCaseName);