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

[GPU] Refactor (#20938)

Browse Source 
* maxmin

* mvn

* normalize_l2 and fix mvn

* prior_box_clustered

* prior_box

* pad

* roi_align

* scatter_update

* select

* shape_of

* shuffle_channels

* space_to_batch

* space_to_depth

* split

* squeeze_unsqueeze

* tile

* transpose

* variadic_split

* scatter_nd_update
This commit is contained in:
Andrei Gorbachev 2023-11-08 09:42:44 +00:00 committed by GitHub
parent 9e7243d67c
commit 87cef53088
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
19 changed files with 449 additions and 545 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -2,15 +2,13 @@
// SPDX-License-Identifier: Apache-2.0
//
#include <vector>
#include "single_layer_tests/minimum_maximum.hpp"
#include "single_op_tests/minimum_maximum.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
namespace {
using ov::test::MaxMinLayerTest;
const std::vector<std::vector<std::vector<size_t>>> inShapes = {
const std::vector<std::vector<ov::Shape>> inShapes = {
{{2}, {1}},
{{1, 1, 1, 3}, {1}},
{{1, 2, 4}, {1}},
@ -20,31 +18,27 @@ const std::vector<std::vector<std::vector<size_t>>> inShapes = {
{{8, 1, 6, 1}, {7, 1, 5}},
};
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<ngraph::helpers::MinMaxOpType> opType = {
ngraph::helpers::MinMaxOpType::MINIMUM,
ngraph::helpers::MinMaxOpType::MAXIMUM,
const std::vector<ov::test::utils::MinMaxOpType> opType = {
ov::test::utils::MinMaxOpType::MINIMUM,
ov::test::utils::MinMaxOpType::MAXIMUM,
};
const std::vector<ngraph::helpers::InputLayerType> inputType = {
ngraph::helpers::InputLayerType::CONSTANT,
ngraph::helpers::InputLayerType::PARAMETER,
const std::vector<ov::test::utils::InputLayerType> second_inputType = {
ov::test::utils::InputLayerType::CONSTANT,
ov::test::utils::InputLayerType::PARAMETER,
};
INSTANTIATE_TEST_SUITE_P(smoke_maximum, MaxMinLayerTest,
::testing::Combine(
::testing::ValuesIn(inShapes),
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(inShapes)),
::testing::ValuesIn(opType),
::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(inputType),
::testing::ValuesIn(second_inputType),
::testing::Values(ov::test::utils::DEVICE_GPU)),
MaxMinLayerTest::getTestCaseName);

74
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/mvn.cpp
View File

@ -4,26 +4,28 @@
#include <vector>
#include "single_layer_tests/mvn.hpp"
#include "single_op_tests/mvn.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
namespace {
using ov::test::Mvn1LayerTest;
using ov::test::Mvn6LayerTest;
const std::vector<ngraph::AxisSet> emptyReductionAxes = {{}};
const std::vector<std::vector<size_t>> inputShapes = {
{1, 32, 17},
{1, 37, 9},
{1, 16, 5, 8},
{2, 19, 5, 10},
{7, 32, 2, 8},
{5, 8, 3, 5},
{4, 41, 6, 9},
{1, 32, 8, 1, 6},
{1, 9, 1, 15, 9},
{6, 64, 6, 1, 18},
{2, 31, 2, 9, 1},
{10, 16, 5, 10, 6}
const std::vector<std::vector<ov::Shape>> inputShapes = {
{{1, 32, 17}},
{{1, 37, 9}},
{{1, 16, 5, 8}},
{{2, 19, 5, 10}},
{{7, 32, 2, 8}},
{{5, 8, 3, 5}},
{{4, 41, 6, 9}},
{{1, 32, 8, 1, 6}},
{{1, 9, 1, 15, 9}},
{{6, 64, 6, 1, 18}},
{{2, 31, 2, 9, 1}},
{{10, 16, 5, 10, 6}}
};
const std::vector<bool> acrossChannels = {
@ -42,8 +44,8 @@ const std::vector<double> epsilon = {
INSTANTIATE_TEST_SUITE_P(smoke_CLDNN_TestsMVN,
Mvn1LayerTest,
::testing::Combine(::testing::ValuesIn(inputShapes),
::testing::Values(InferenceEngine::Precision::FP32),
::testing::Combine(::testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapes)),
::testing::Values(ov::element::f32),
::testing::ValuesIn(emptyReductionAxes),
::testing::ValuesIn(acrossChannels),
::testing::ValuesIn(normalizeVariance),
@ -51,14 +53,14 @@ INSTANTIATE_TEST_SUITE_P(smoke_CLDNN_TestsMVN,
::testing::Values(ov::test::utils::DEVICE_GPU)),
Mvn1LayerTest::getTestCaseName);
std::vector<InferenceEngine::Precision> dataPrecisions = {
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16
std::vector<ov::element::Type> dataPrecisions = {
ov::element::f32,
ov::element::f16
};
std::vector<InferenceEngine::Precision> idxPrecisions = {
InferenceEngine::Precision::I32,
InferenceEngine::Precision::I64
std::vector<ov::element::Type> idxPrecisions = {
ov::element::i32,
ov::element::i64
};
const std::vector<std::string> epsMode = {
@ -72,7 +74,8 @@ const std::vector<float> epsilonF = {
INSTANTIATE_TEST_SUITE_P(smoke_MVN_5D, Mvn6LayerTest,
::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>>{{1, 10, 5, 7, 8}, {1, 3, 8, 9, 49}}),
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(
std::vector<std::vector<ov::Shape>>{{{1, 10, 5, 7, 8}}, {{1, 3, 8, 9, 49}}})),
::testing::ValuesIn(dataPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(std::vector<std::vector<int>>{{1, 2, 3, 4}, {2, 3, 4}, {-3, -2, -1}, {-1, -4, -2, -3}, {-1}}),
@ -84,7 +87,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_MVN_5D, Mvn6LayerTest,
INSTANTIATE_TEST_SUITE_P(smoke_MVN_4D, Mvn6LayerTest,
::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>>{{1, 10, 5, 17}, {1, 3, 8, 9}}),
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(
std::vector<std::vector<ov::Shape>>{{{1, 10, 5, 17}}, {{1, 3, 8, 9}}})),
::testing::ValuesIn(dataPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(std::vector<std::vector<int>>{{1, 2, 3}, {2, 3}, {-2, -1}, {-2, -1, -3}, {-1}}),
@ -96,7 +100,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_MVN_4D, Mvn6LayerTest,
INSTANTIATE_TEST_SUITE_P(smoke_MVN_3D, Mvn6LayerTest,
::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>>{{1, 32, 17}, {1, 37, 9}}),
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(
std::vector<std::vector<ov::Shape>>{{{1, 32, 17}}, {{1, 37, 9}}})),
::testing::ValuesIn(dataPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(std::vector<std::vector<int>>{{1, 2}, {2}, {-1}, {-1, -2}}),
@ -108,7 +113,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_MVN_3D, Mvn6LayerTest,
INSTANTIATE_TEST_SUITE_P(smoke_MVN_2D, Mvn6LayerTest,
::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>>{{3, 5}, {2, 55}}),
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(
std::vector<std::vector<ov::Shape>>{{{3, 5}}, {{2, 55}}})),
::testing::ValuesIn(dataPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(std::vector<std::vector<int>>{{1}}),
@ -120,7 +126,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_MVN_2D, Mvn6LayerTest,
INSTANTIATE_TEST_SUITE_P(smoke_Decomposition_1D, Mvn6LayerTest,
::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>>{{3}, {9}, {55}}),
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(
std::vector<std::vector<ov::Shape>>{{{3}}, {{9}}, {{55}}})),
::testing::ValuesIn(dataPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(std::vector<std::vector<int>>{{}}),
@ -132,7 +139,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_Decomposition_1D, Mvn6LayerTest,
INSTANTIATE_TEST_SUITE_P(smoke_Decomposition_3D, Mvn6LayerTest,
::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>>{{1, 32, 17}, {1, 37, 9}}),
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(
std::vector<std::vector<ov::Shape>>{{{1, 32, 17}}, {{1, 37, 9}}})),
::testing::ValuesIn(dataPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(std::vector<std::vector<int>>{{0, 1, 2}, {0}, {1}}),
@ -144,7 +152,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_Decomposition_3D, Mvn6LayerTest,
INSTANTIATE_TEST_SUITE_P(smoke_Decomposition_4D, Mvn6LayerTest,
::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>>{{1, 16, 5, 8}, {2, 19, 5, 10}}),
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(
std::vector<std::vector<ov::Shape>>{{{1, 16, 5, 8}}, {{2, 19, 5, 10}}})),
::testing::ValuesIn(dataPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(std::vector<std::vector<int>>{{0, 1, 2, 3}, {0, 1, 2}, {0, 3}, {0}, {1}, {2}, {3}}),
@ -156,7 +165,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_Decomposition_4D, Mvn6LayerTest,
INSTANTIATE_TEST_SUITE_P(smoke_Decomposition_6D, Mvn6LayerTest,
::testing::Combine(
::testing::ValuesIn(std::vector<std::vector<size_t>>{{1, 3, 5, 4, 2, 6}}),
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(
std::vector<std::vector<ov::Shape>>{{{1, 3, 5, 4, 2, 6}}})),
::testing::ValuesIn(dataPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::ValuesIn(std::vector<std::vector<int>>{{0, 1, 5}, {0, 1, 2, 3}, {0, 1, 2}, {0, 3}, {0}, {3}}),
@ -165,3 +175,5 @@ INSTANTIATE_TEST_SUITE_P(smoke_Decomposition_6D, Mvn6LayerTest,
::testing::ValuesIn(epsMode),
::testing::Values(ov::test::utils::DEVICE_GPU)),
Mvn6LayerTest::getTestCaseName);
} // namespace

17
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/normalize_l2.cpp
View File

@ -2,16 +2,14 @@
// SPDX-License-Identifier: Apache-2.0
//
#include <vector>
#include "single_layer_tests/normalize_l2.hpp"
using namespace LayerTestsDefinitions;
#include "single_op_tests/normalize_l2.hpp"
namespace {
const std::vector<InferenceEngine::Precision> netPrecisions = {
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16
using ov::test::NormalizeL2LayerTest;
const std::vector<ov::element::Type> netPrecisions = {
ov::element::f32,
ov::element::f16
};
const std::vector<std::vector<int64_t>> axes = {
@ -30,7 +28,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_NormalizeL2,
testing::Combine(testing::ValuesIn(axes),
testing::ValuesIn(eps),
testing::ValuesIn(epsMode),
testing::Values(std::vector<size_t>{1, 3, 10, 5}),
testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>{{1, 3, 10, 5}})),
testing::ValuesIn(netPrecisions),
testing::Values(ov::test::utils::DEVICE_GPU)),
NormalizeL2LayerTest::getTestCaseName);

93
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/pad.cpp
View File

@ -1,27 +1,26 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include <vector>
#include "single_layer_tests/pad.hpp"
using namespace LayerTestsDefinitions;
#include "single_op_tests/pad.hpp"
namespace {
const std::vector<InferenceEngine::Precision> netPrecisions = {
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16
using ov::test::PadLayerTest;
using ov::test::Pad12LayerTest;
using ov::op::PadMode;
const std::vector<ov::element::Type> netPrecisions = {
ov::element::f32,
ov::element::f16
};
const std::vector<std::vector<int64_t>> padsBegin2D = {{0, 0}, {1, 1}, {2, 0}, {0, 3}};
const std::vector<std::vector<int64_t>> padsEnd2D = {{0, 0}, {1, 1}, {0, 1}, {3, 2}};
const std::vector<float> argPadValue = {0.f, 1.f, 2.f, -1.f};
const std::vector<ngraph::helpers::PadMode> padMode = {
ngraph::helpers::PadMode::EDGE,
ngraph::helpers::PadMode::REFLECT,
ngraph::helpers::PadMode::SYMMETRIC
const std::vector<PadMode> padMode = {
PadMode::EDGE,
PadMode::REFLECT,
PadMode::SYMMETRIC
};
INSTANTIATE_TEST_SUITE_P(smoke_Pad2DConst,
@ -29,12 +28,10 @@ INSTANTIATE_TEST_SUITE_P(smoke_Pad2DConst,
testing::Combine(testing::ValuesIn(padsBegin2D),
testing::ValuesIn(padsEnd2D),
testing::ValuesIn(argPadValue),
testing::Values(ngraph::helpers::PadMode::CONSTANT),
testing::Values(PadMode::CONSTANT),
testing::ValuesIn(netPrecisions),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(std::vector<size_t>{13, 5}),
testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>{{13, 5}})),
testing::Values(ov::test::utils::DEVICE_GPU)),
PadLayerTest::getTestCaseName);
@ -45,10 +42,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_Pad2D,
testing::Values(0),
testing::ValuesIn(padMode),
testing::ValuesIn(netPrecisions),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(std::vector<size_t>{13, 5}),
testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>{{13, 5}})),
testing::Values(ov::test::utils::DEVICE_GPU)),
PadLayerTest::getTestCaseName);
@ -60,12 +55,10 @@ INSTANTIATE_TEST_SUITE_P(smoke_Pad4DConst,
testing::Combine(testing::ValuesIn(padsBegin4D),
testing::ValuesIn(padsEnd4D),
testing::ValuesIn(argPadValue),
testing::Values(ngraph::helpers::PadMode::CONSTANT),
testing::Values(PadMode::CONSTANT),
testing::ValuesIn(netPrecisions),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(std::vector<size_t>{3, 5, 10, 11}),
testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>{{3, 5, 10, 11}})),
testing::Values(ov::test::utils::DEVICE_GPU)),
PadLayerTest::getTestCaseName);
@ -73,13 +66,11 @@ INSTANTIATE_TEST_SUITE_P(smoke_Pad4D,
PadLayerTest,
testing::Combine(testing::ValuesIn(padsBegin4D),
testing::ValuesIn(padsEnd4D),
testing::Values(0),
testing::Values(0.0f),
testing::ValuesIn(padMode),
testing::ValuesIn(netPrecisions),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(std::vector<size_t>{3, 5, 10, 11}),
testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>{{3, 5, 10, 11}})),
testing::Values(ov::test::utils::DEVICE_GPU)),
PadLayerTest::getTestCaseName);
@ -87,30 +78,26 @@ const std::vector<std::vector<int64_t>> padsBegin2DMixed = {{0, 0}, {1, 1}, {-2,
const std::vector<std::vector<int64_t>> padsEnd2DMixed = {{0, 0}, {1, 1}, {0, 1}, {-3, -2}, {2, -1}};
INSTANTIATE_TEST_SUITE_P(smoke_Pad2DConst,
PadLayerTest12,
Pad12LayerTest,
testing::Combine(testing::ValuesIn(padsEnd2DMixed),
testing::ValuesIn(padsEnd2D),
testing::ValuesIn(argPadValue),
testing::Values(ngraph::helpers::PadMode::CONSTANT),
testing::Values(PadMode::CONSTANT),
testing::ValuesIn(netPrecisions),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(std::vector<size_t>{13, 5}),
testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>{{13, 5}})),
testing::Values(ov::test::utils::DEVICE_GPU)),
PadLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Pad2D,
PadLayerTest12,
Pad12LayerTest,
testing::Combine(testing::ValuesIn(padsBegin2DMixed),
testing::ValuesIn(padsEnd2DMixed),
testing::Values(-333),
testing::Values(-333.0f),
testing::ValuesIn(padMode),
testing::ValuesIn(netPrecisions),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(std::vector<size_t>{13, 5}),
testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>{{13, 5}})),
testing::Values(ov::test::utils::DEVICE_GPU)),
PadLayerTest::getTestCaseName);
@ -118,30 +105,26 @@ const std::vector<std::vector<int64_t>> padsBegin4DMixed = {{0, 0, 0, 0}, {0, 3,
const std::vector<std::vector<int64_t>> padsEnd4DMixed = {{0, 0, 0, 0}, {0, 3, 0, 0}, {1, 0, 0, 0}, {0, 0, 0, 2}, {1, -3, 0, 0}, {0, 3, 0, -1}};
INSTANTIATE_TEST_SUITE_P(smoke_Pad4DConst,
PadLayerTest12,
Pad12LayerTest,
testing::Combine(testing::ValuesIn(padsBegin4DMixed),
testing::ValuesIn(padsEnd4DMixed),
testing::ValuesIn(argPadValue),
testing::Values(ngraph::helpers::PadMode::CONSTANT),
testing::Values(PadMode::CONSTANT),
testing::ValuesIn(netPrecisions),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(std::vector<size_t>{3, 5, 10, 11}),
testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>{{3, 5, 10, 11}})),
testing::Values(ov::test::utils::DEVICE_GPU)),
PadLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Pad4D,
PadLayerTest12,
Pad12LayerTest,
testing::Combine(testing::ValuesIn(padsBegin4DMixed),
testing::ValuesIn(padsEnd4DMixed),
testing::Values(-333),
testing::ValuesIn(padMode),
testing::ValuesIn(netPrecisions),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Precision::UNSPECIFIED),
testing::Values(InferenceEngine::Layout::ANY),
testing::Values(std::vector<size_t>{3, 5, 10, 11}),
testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>{{3, 5, 10, 11}})),
testing::Values(ov::test::utils::DEVICE_GPU)),
PadLayerTest::getTestCaseName);

55
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/prior_box.cpp
View File

@ -2,16 +2,14 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "single_layer_tests/prior_box.hpp"
#include <vector>
#include "single_op_tests/prior_box.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
namespace {
using ov::test::PriorBoxLayerTest;
const std::vector<InferenceEngine::Precision> netPrecisions = {InferenceEngine::Precision::I32,
InferenceEngine::Precision::U16};
const std::vector<ov::element::Type> netPrecisions = {ov::element::i32,
ov::element::u16};
const std::vector<std::vector<float>> min_sizes = {{256.0f}};
@ -41,33 +39,27 @@ const std::vector<std::vector<float>> variances = {{}};
const std::vector<bool> min_max_aspect_ratios_order = {false, true};
const std::vector<size_t> inputShape = {300, 300};
const std::vector<size_t> imageShape = {32, 32};
std::vector<ov::Shape> input_shapes_static = {{32, 32}, {300, 300}};
const auto scaleSizesParams = ::testing::Combine(::testing::ValuesIn(min_sizes),
::testing::ValuesIn(max_sizes),
::testing::ValuesIn(aspect_ratios),
::testing::ValuesIn(densities),
::testing::ValuesIn(fixed_ratios),
::testing::ValuesIn(fixed_sizes),
::testing::ValuesIn(clips),
::testing::ValuesIn(flips),
::testing::ValuesIn(steps),
::testing::ValuesIn(offsets),
::testing::ValuesIn(variances),
::testing::Values(true),
::testing::ValuesIn(min_max_aspect_ratios_order));
::testing::ValuesIn(max_sizes),
::testing::ValuesIn(aspect_ratios),
::testing::ValuesIn(densities),
::testing::ValuesIn(fixed_ratios),
::testing::ValuesIn(fixed_sizes),
::testing::ValuesIn(clips),
::testing::ValuesIn(flips),
::testing::ValuesIn(steps),
::testing::ValuesIn(offsets),
::testing::ValuesIn(variances),
::testing::Values(true),
::testing::ValuesIn(min_max_aspect_ratios_order));
INSTANTIATE_TEST_SUITE_P(DISABLED_smoke_PriorBox8_Scale,
PriorBoxLayerTest,
::testing::Combine(scaleSizesParams,
::testing::ValuesIn(netPrecisions),
::testing::Values(InferenceEngine::Precision::I32),
::testing::Values(InferenceEngine::Precision::FP32),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::Values(inputShape),
::testing::Values(imageShape),
::testing::Values(ov::test::static_shapes_to_test_representation(input_shapes_static)),
::testing::Values(ov::test::utils::DEVICE_GPU)),
PriorBoxLayerTest::getTestCaseName);
@ -89,11 +81,8 @@ INSTANTIATE_TEST_SUITE_P(DISABLED_smoke_PriorBox8_NoScale,
PriorBoxLayerTest,
::testing::Combine(scaleSizesParams,
::testing::ValuesIn(netPrecisions),
::testing::Values(InferenceEngine::Precision::I32),
::testing::Values(InferenceEngine::Precision::FP32),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::Values(inputShape),
::testing::Values(imageShape),
::testing::Values(ov::test::static_shapes_to_test_representation(input_shapes_static)),
::testing::Values(ov::test::utils::DEVICE_GPU)),
PriorBoxLayerTest::getTestCaseName);
} // namespace

22
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/prior_box_clustered.cpp
View File

@ -2,18 +2,16 @@
// SPDX-License-Identifier: Apache-2.0
//
#include <vector>
#include "single_layer_tests/prior_box_clustered.hpp"
#include "single_op_tests/prior_box_clustered.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
using namespace ngraph::helpers;
namespace {
using ov::test::PriorBoxClusteredLayerTest;
// Common params
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<float>> widths = {
@ -65,12 +63,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_PriorBoxClustered_Basic, PriorBoxClusteredLayerTe
::testing::Combine(
layerSpeficParams,
::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 })),
::testing::Values(std::vector<size_t>({ 50, 50 })),
::testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{4, 4}, {50, 50}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
PriorBoxClusteredLayerTest::getTestCaseName
);

63
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/roi_align.cpp
View File

@ -1,16 +1,15 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "single_layer_tests/roi_align.hpp"
#include <vector>
#include "single_op_tests/roi_align.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
namespace {
using ov::test::ROIAlignLayerTest;
using ov::test::ROIAlignV9LayerTest;
const std::vector<InferenceEngine::Precision> netPRCs = {
InferenceEngine::Precision::FP32
const std::vector<ov::element::Type> netPRCs = {
ov::element::f32
// There is no possibility to test ROIAlign in fp16 precision,
// because on edge cases where in fp32 version ROI value is
// a little bit smaller than the nearest integer value,
@ -19,14 +18,15 @@ const std::vector<InferenceEngine::Precision> netPRCs = {
// in fp32 and fp16 precisions.
// In real AI applications this problem is solved by precision-aware training.
// InferenceEngine::Precision::FP16
// ov::element::f16
};
INSTANTIATE_TEST_SUITE_P(smoke_TestsROIAlign_average,
ROIAlignLayerTest,
::testing::Combine(::testing::ValuesIn(std::vector<std::vector<size_t>>{{3, 8, 16, 16},
{2, 1, 16, 16},
{2, 1, 8, 16}}),
::testing::Combine(::testing::ValuesIn(ov::test::static_shapes_to_test_representation(
std::vector<std::vector<ov::Shape>>{{{3, 8, 16, 16}},
{{2, 1, 16, 16}},
{{2, 1, 8, 16}}})),
::testing::Values(std::vector<size_t>{2, 4}),
::testing::Values(2),
::testing::Values(2),
@ -39,9 +39,10 @@ INSTANTIATE_TEST_SUITE_P(smoke_TestsROIAlign_average,
INSTANTIATE_TEST_SUITE_P(smoke_TestsROIAlign_max,
ROIAlignLayerTest,
::testing::Combine(::testing::ValuesIn(std::vector<std::vector<size_t>>{{2, 8, 20, 20},
{2, 1, 20, 20},
{2, 1, 10, 20}}),
::testing::Combine(::testing::ValuesIn(ov::test::static_shapes_to_test_representation(
std::vector<std::vector<ov::Shape>>{{{2, 8, 20, 20}},
{{2, 1, 20, 20}},
{{2, 1, 10, 20}}})),
::testing::Values(std::vector<size_t>{2, 4}),
::testing::Values(2),
::testing::Values(2),
@ -54,11 +55,12 @@ INSTANTIATE_TEST_SUITE_P(smoke_TestsROIAlign_max,
INSTANTIATE_TEST_SUITE_P(smoke_TestsROIAlign_avg_asym,
ROIAlignV9LayerTest,
::testing::Combine(::testing::ValuesIn(std::vector<std::vector<size_t>>{{2, 1, 8, 8},
{2, 8, 20, 20},
{2, 1, 20, 20},
{2, 1, 10, 20}}),
::testing::Values(std::vector<size_t>{2, 4}),
::testing::Combine(::testing::ValuesIn(ov::test::static_shapes_to_test_representation(
std::vector<std::vector<ov::Shape>>{{{2, 1, 8, 8}},
{{2, 8, 20, 20}},
{{2, 1, 20, 20}},
{{2, 1, 10, 20}}})),
::testing::Values(ov::Shape{2, 4}),
::testing::Values(2),
::testing::Values(2),
::testing::ValuesIn(std::vector<float>{1, 0.625}),
@ -71,11 +73,12 @@ INSTANTIATE_TEST_SUITE_P(smoke_TestsROIAlign_avg_asym,
INSTANTIATE_TEST_SUITE_P(smoke_TestsROIAlign_avg_hpfn,
ROIAlignV9LayerTest,
::testing::Combine(::testing::ValuesIn(std::vector<std::vector<size_t>>{{2, 1, 8, 8},
{2, 8, 20, 20},
{2, 1, 20, 20},
{2, 1, 10, 20}}),
::testing::Values(std::vector<size_t>{2, 4}),
::testing::Combine(::testing::ValuesIn(ov::test::static_shapes_to_test_representation(
std::vector<std::vector<ov::Shape>>{{{2, 1, 8, 8}},
{{2, 8, 20, 20}},
{{2, 1, 20, 20}},
{{2, 1, 10, 20}}})),
::testing::Values(ov::Shape{2, 4}),
::testing::Values(2),
::testing::Values(2),
::testing::ValuesIn(std::vector<float>{1, 0.625}),
@ -88,11 +91,12 @@ INSTANTIATE_TEST_SUITE_P(smoke_TestsROIAlign_avg_hpfn,
INSTANTIATE_TEST_SUITE_P(smoke_TestsROIAlign_max_hp,
ROIAlignV9LayerTest,
::testing::Combine(::testing::ValuesIn(std::vector<std::vector<size_t>>{{2, 1, 8, 8},
{2, 8, 20, 20},
{2, 1, 20, 20},
{2, 1, 10, 20}}),
::testing::Values(std::vector<size_t>{2, 4}),
::testing::Combine(::testing::ValuesIn(ov::test::static_shapes_to_test_representation(
std::vector<std::vector<ov::Shape>>{{{2, 1, 8, 8}},
{{2, 8, 20, 20}},
{{2, 1, 20, 20}},
{{2, 1, 10, 20}}})),
::testing::Values(ov::Shape{2, 4}),
::testing::Values(2),
::testing::Values(2),
::testing::ValuesIn(std::vector<float>{1, 0.625}),
@ -102,3 +106,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_TestsROIAlign_max_hp,
::testing::ValuesIn(netPRCs),
::testing::Values(ov::test::utils::DEVICE_GPU)),
ROIAlignV9LayerTest::getTestCaseName);
} // namespace

50
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/scatter_nd_update.cpp
View File

@ -2,16 +2,11 @@
// SPDX-License-Identifier: Apache-2.0
//
#include <vector>
#include <ngraph/opsets/opset3.hpp>
#include "single_layer_tests/scatter_ND_update.hpp"
#include "single_op_tests/scatter_ND_update.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
using namespace ngraph::opset3;
namespace {
using ov::test::ScatterNDUpdateLayerTest;
// map<inputShape map<indicesShape, indicesValue>>
// updateShape is gotten from inputShape and indicesShape
@ -30,22 +25,47 @@ std::map<std::vector<size_t>, std::map<std::vector<size_t>, std::vector<size_t>>
{{1, 2, 4}, {2, 3, 1, 8, 7, 5, 6, 5}}, {{2, 5}, {2, 3, 1, 8, 6, 9, 7, 5, 6, 5}}, {{2, 6}, {2, 3, 1, 8, 6, 5, 9, 7, 5, 6, 5, 7}}}}
};
std::vector<ov::test::scatterNDUpdateSpecParams> combineShapes(
const std::map<std::vector<size_t>, std::map<std::vector<size_t>, std::vector<size_t>>>& input_shapes) {
std::vector<ov::test::scatterNDUpdateSpecParams> resVec;
for (auto& input_shape : input_shapes) {
for (auto& item : input_shape.second) {
auto indices_shape = item.first;
size_t indices_rank = indices_shape.size();
std::vector<size_t> update_shape;
for (size_t i = 0; i < indices_rank - 1; i++) {
update_shape.push_back(indices_shape[i]);
}
auto src_shape = input_shape.first;
for (size_t j = indices_shape[indices_rank - 1]; j < src_shape.size(); j++) {
update_shape.push_back(src_shape[j]);
}
std::vector<ov::Shape> in_shapes{src_shape, update_shape};
resVec.push_back(
ov::test::scatterNDUpdateSpecParams{
ov::test::static_shapes_to_test_representation(in_shapes),
ov::Shape{indices_shape},
item.second});
}
}
return resVec;
}
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,
};
INSTANTIATE_TEST_SUITE_P(
smoke_ScatterNDUpdate,
ScatterNDUpdateLayerTest,
::testing::Combine(::testing::ValuesIn(ScatterNDUpdateLayerTest::combineShapes(sliceSelectInShape)),
::testing::Combine(::testing::ValuesIn(combineShapes(sliceSelectInShape)),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),
::testing::Values(ov::test::utils::DEVICE_GPU)),

60
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/scatter_update.cpp
View File

@ -1,26 +1,21 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include <vector>
#include <ngraph/opsets/opset3.hpp>
#include "single_layer_tests/scatter_update.hpp"
#include "single_op_tests/scatter_update.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::FP16,
InferenceEngine::Precision::I32,
using ov::test::ScatterUpdateLayerTest;
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,
};
// map<inputShape, map<indicesShape, axis>>
@ -36,10 +31,43 @@ const std::vector<std::vector<int64_t>> idxValue = {
{0, 2, 4, 6, 1, 3, 5, 7}
};
std::vector<ov::test::axisUpdateShapeInShape> combine_shapes(
const std::map<std::vector<size_t>, std::map<std::vector<size_t>, std::vector<int>>>& input_shapes) {
std::vector<ov::test::axisUpdateShapeInShape> res_vec;
for (auto& input_shape : input_shapes) {
auto src_shape = input_shape.first;
auto srcRank = src_shape.size();
for (auto& item : input_shape.second) {
auto indices_shape = item.first;
auto indices_rank = indices_shape.size();
for (auto& axis : item.second) {
auto axisP = axis < 0 ? axis + srcRank : axis;
std::vector<size_t> update_shape;
for (size_t rs = 0; rs < srcRank; rs++) {
if (rs != axisP) {
update_shape.push_back(src_shape[rs]);
} else {
for (size_t ri = 0; ri < indices_rank; ri++) {
update_shape.push_back(indices_shape[ri]);
}
}
}
std::vector<ov::Shape> in_shapes{src_shape, update_shape};
res_vec.push_back(
ov::test::axisUpdateShapeInShape{
ov::test::static_shapes_to_test_representation(in_shapes),
ov::Shape{indices_shape},
axis});
}
}
}
return res_vec;
}
INSTANTIATE_TEST_SUITE_P(
smoke_ScatterUpdate,
ScatterUpdateLayerTest,
::testing::Combine(::testing::ValuesIn(ScatterUpdateLayerTest::combineShapes(axesShapeInShape)),
::testing::Combine(::testing::ValuesIn(combine_shapes(axesShapeInShape)),
::testing::ValuesIn(idxValue),
::testing::ValuesIn(inputPrecisions),
::testing::ValuesIn(idxPrecisions),

31
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/select.cpp
View File

@ -1,23 +1,20 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include <vector>
#include "single_layer_tests/select.hpp"
#include "single_op_tests/select.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
using ov::test::SelectLayerTest;
const std::vector<InferenceEngine::Precision> inputPrecision = {
InferenceEngine::Precision::U8,
InferenceEngine::Precision::FP16,
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::I16,
InferenceEngine::Precision::I32
const std::vector<ov::element::Type> inputPrecision = {
ov::element::u8,
ov::element::f16,
ov::element::f32,
ov::element::i16,
ov::element::i32
};
const std::vector<std::vector<std::vector<size_t>>> noneShapes = {
const std::vector<std::vector<ov::Shape>> noneShapes = {
{{1}, {1}, {1}},
{{8}, {8}, {8}},
{{4, 5}, {4, 5}, {4, 5}},
@ -25,7 +22,7 @@ const std::vector<std::vector<std::vector<size_t>>> noneShapes = {
{{2, 3, 4, 5}, {2, 3, 4, 5}, {2, 3, 4, 5}}
};
const std::vector<std::vector<std::vector<size_t>>> numpyShapes = {
const std::vector<std::vector<ov::Shape>> numpyShapes = {
{{1}, {16}, {1}},
{{1}, {1}, {16}},
{{1}, {8}, {8}},
@ -52,16 +49,16 @@ const std::vector<std::vector<std::vector<size_t>>> numpyShapes = {
INSTANTIATE_TEST_SUITE_P(smoke_CLDNN_TestsSelect_none,
SelectLayerTest,
::testing::Combine(::testing::ValuesIn(noneShapes),
::testing::Combine(::testing::ValuesIn(ov::test::static_shapes_to_test_representation(noneShapes)),
::testing::ValuesIn(inputPrecision),
::testing::Values(ngraph::op::AutoBroadcastType::NONE),
::testing::Values(ov::op::AutoBroadcastType::NONE),
::testing::Values(ov::test::utils::DEVICE_GPU)),
SelectLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_CLDNN_TestsSelect_numpy,
SelectLayerTest,
::testing::Combine(::testing::ValuesIn(numpyShapes),
::testing::Combine(::testing::ValuesIn(ov::test::static_shapes_to_test_representation(numpyShapes)),
::testing::ValuesIn(inputPrecision),
::testing::Values(ngraph::op::AutoBroadcastType::NUMPY),
::testing::Values(ov::op::AutoBroadcastType::NUMPY),
::testing::Values(ov::test::utils::DEVICE_GPU)),
SelectLayerTest::getTestCaseName);

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

@ -2,30 +2,28 @@
// SPDX-License-Identifier: Apache-2.0
//
#include <vector>
#include "single_layer_tests/shape_of.hpp"
#include "single_op_tests/shape_of.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
namespace {
const std::vector<InferenceEngine::Precision> model_precisions = {
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::I32
using ov::test::ShapeOfLayerTest;
const std::vector<ov::element::Type> model_precisions = {
ov::element::f32,
ov::element::i32
};
const std::vector<InferenceEngine::SizeVector> input_shapes = {
std::vector<size_t>({1, 2, 3, 4, 5}),
std::vector<size_t>({1, 2, 3, 4}),
std::vector<size_t>({1, 2})
const std::vector<std::vector<ov::Shape>> input_shapes = {
{{1, 2, 3, 4, 5}},
{{1, 2, 3, 4}},
{{1, 2}}
};
INSTANTIATE_TEST_SUITE_P(smoke_Check, ShapeOfLayerTest,
::testing::Combine(
::testing::ValuesIn(model_precisions),
::testing::Values(InferenceEngine::Precision::I64),
::testing::ValuesIn(input_shapes),
::testing::Values(ov::element::i64),
::testing::ValuesIn(ov::test::static_shapes_to_test_representation(input_shapes)),
::testing::Values(ov::test::utils::DEVICE_GPU)),
ShapeOfLayerTest::getTestCaseName);
} // namespace

43
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/shuffle_channels.cpp
View File

@ -4,18 +4,18 @@
#include <vector>
#include "single_layer_tests/shuffle_channels.hpp"
#include "single_op_tests/shuffle_channels.hpp"
using namespace LayerTestsDefinitions;
using ov::test::ShuffleChannelsLayerTest;
const std::vector<InferenceEngine::Precision> netPrecisions = {
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16,
InferenceEngine::Precision::U8,
const std::vector<ov::element::Type> netPrecisions = {
ov::element::f32,
ov::element::f16,
ov::element::u8,
};
const std::vector<std::vector<size_t>> inputShapes = {
{3, 4, 9, 5}, {2, 16, 24, 15}, {1, 32, 12, 25}
const std::vector<std::vector<ov::Shape>> inputShapes = {
{{3, 4, 9, 5}}, {{2, 16, 24, 15}}, {{1, 32, 12, 25}}
};
const std::vector<std::tuple<int, int>> shuffleParameters = {
@ -28,11 +28,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_GPU_ShuffleChannels,
ShuffleChannelsLayerTest,
::testing::Combine(::testing::ValuesIn(shuffleParameters),
::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::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapes)),
::testing::Values(ov::test::utils::DEVICE_GPU)),
ShuffleChannelsLayerTest::getTestCaseName);
@ -41,11 +37,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_ShuffleChannels3D,
ShuffleChannelsLayerTest,
::testing::Combine(::testing::Values(std::tuple<int, int>(1, 3)),
::testing::ValuesIn(netPrecisions),
::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::Values(std::vector<size_t>({18, 30, 36})),
::testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{18, 30, 36}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
ShuffleChannelsLayerTest::getTestCaseName);
@ -53,11 +46,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_ShuffleChannels2D,
ShuffleChannelsLayerTest,
::testing::Combine(::testing::Values(std::tuple<int, int>(1, 3)),
::testing::ValuesIn(netPrecisions),
::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::Values(std::vector<size_t>({18, 30})),
::testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{18, 30}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
ShuffleChannelsLayerTest::getTestCaseName);
@ -65,10 +55,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_ShuffleChannels1D,
ShuffleChannelsLayerTest,
::testing::Combine(::testing::Values(std::tuple<int, int>(0, 3)),
::testing::ValuesIn(netPrecisions),
::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::Values(std::vector<size_t>({30})),
::testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{30}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
ShuffleChannelsLayerTest::getTestCaseName);

152
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/space_to_batch.cpp
View File

@ -2,176 +2,126 @@
// SPDX-License-Identifier: Apache-2.0
//
#include <vector>
#include "single_layer_tests/space_to_batch.hpp"
#include "single_op_tests/space_to_batch.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
namespace {
using ov::test::SpaceToBatchLayerTest;
using ov::test::spaceToBatchParamsTuple;
auto stb_only_test_cases = []() {
return std::vector<spaceToBatchParamsTuple>{
spaceToBatchParamsTuple({1, 2, 2},
{0, 0, 0},
{0, 0, 0},
{1, 2, 2},
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Layout::ANY,
InferenceEngine::Layout::ANY,
ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{1, 2, 2}})),
ov::element::f32,
ov::test::utils::DEVICE_GPU),
spaceToBatchParamsTuple({1, 1, 2, 2},
{0, 0, 0, 0},
{0, 0, 0, 0},
{1, 1, 2, 2},
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Layout::ANY,
InferenceEngine::Layout::ANY,
ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{1, 1, 2, 2}})),
ov::element::f32,
ov::test::utils::DEVICE_GPU),
spaceToBatchParamsTuple({1, 1, 2, 2},
{0, 0, 0, 0},
{0, 0, 0, 0},
{1, 3, 2, 2},
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Layout::ANY,
InferenceEngine::Layout::ANY,
ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{1, 3, 2, 2}})),
ov::element::f32,
ov::test::utils::DEVICE_GPU),
spaceToBatchParamsTuple({1, 1, 2, 2},
{0, 0, 0, 0},
{0, 0, 0, 0},
{1, 1, 4, 4},
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Layout::ANY,
InferenceEngine::Layout::ANY,
ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{1, 1, 4, 4}})),
ov::element::f32,
ov::test::utils::DEVICE_GPU),
spaceToBatchParamsTuple({1, 1, 2, 2},
{0, 0, 0, 2},
{0, 0, 0, 0},
{2, 1, 2, 4},
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Layout::ANY,
InferenceEngine::Layout::ANY,
ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{2, 1, 2, 4}})),
ov::element::f32,
ov::test::utils::DEVICE_GPU),
spaceToBatchParamsTuple({1, 1, 3, 2, 2},
{0, 0, 1, 0, 3},
{0, 0, 2, 0, 0},
{1, 1, 3, 2, 1},
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Layout::ANY,
InferenceEngine::Layout::ANY,
ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{1, 1, 3, 2, 1}})),
ov::element::f32,
ov::test::utils::DEVICE_GPU),
spaceToBatchParamsTuple({1, 1, 2, 2},
{0, 0, 0, 0},
{0, 0, 0, 0},
{1, 1, 2, 2},
InferenceEngine::Precision::I8,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Layout::ANY,
InferenceEngine::Layout::ANY,
ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{1, 1, 2, 2}})),
ov::element::i8,
ov::test::utils::DEVICE_GPU),
spaceToBatchParamsTuple({1, 1, 2, 2},
{0, 0, 0, 0},
{0, 0, 0, 0},
{1, 3, 2, 2},
InferenceEngine::Precision::I8,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Layout::ANY,
InferenceEngine::Layout::ANY,
ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{1, 3, 2, 2}})),
ov::element::i8,
ov::test::utils::DEVICE_GPU),
spaceToBatchParamsTuple({1, 1, 2, 2},
{0, 0, 0, 0},
{0, 0, 0, 0},
{1, 1, 4, 4},
InferenceEngine::Precision::I8,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Layout::ANY,
InferenceEngine::Layout::ANY,
ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{1, 1, 4, 4}})),
ov::element::i8,
ov::test::utils::DEVICE_GPU),
spaceToBatchParamsTuple({1, 1, 2, 2},
{0, 0, 0, 2},
{0, 0, 0, 0},
{2, 1, 2, 4},
InferenceEngine::Precision::I8,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Layout::ANY,
InferenceEngine::Layout::ANY,
ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{2, 1, 2, 4}})),
ov::element::i8,
ov::test::utils::DEVICE_GPU),
spaceToBatchParamsTuple({1, 1, 3, 2, 2},
{0, 0, 1, 0, 3},
{0, 0, 2, 0, 0},
{1, 1, 3, 2, 1},
InferenceEngine::Precision::I8,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Layout::ANY,
InferenceEngine::Layout::ANY,
ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{1, 1, 3, 2, 1}})),
ov::element::i8,
ov::test::utils::DEVICE_GPU),
spaceToBatchParamsTuple({1, 1, 2, 2},
{0, 0, 0, 0},
{0, 0, 0, 0},
{1, 1, 2, 2},
InferenceEngine::Precision::U8,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Layout::ANY,
InferenceEngine::Layout::ANY,
ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{1, 1, 2, 2}})),
ov::element::u8,
ov::test::utils::DEVICE_GPU),
spaceToBatchParamsTuple({1, 1, 2, 2},
{0, 0, 0, 0},
{0, 0, 0, 0},
{1, 3, 2, 2},
InferenceEngine::Precision::U8,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Layout::ANY,
InferenceEngine::Layout::ANY,
ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{1, 3, 2, 2}})),
ov::element::u8,
ov::test::utils::DEVICE_GPU),
spaceToBatchParamsTuple({1, 1, 2, 2},
{0, 0, 0, 0},
{0, 0, 0, 0},
{1, 1, 4, 4},
InferenceEngine::Precision::U8,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Layout::ANY,
InferenceEngine::Layout::ANY,
ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{1, 1, 4, 4}})),
ov::element::u8,
ov::test::utils::DEVICE_GPU),
spaceToBatchParamsTuple({1, 1, 2, 2},
{0, 0, 0, 2},
{0, 0, 0, 0},
{2, 1, 2, 4},
InferenceEngine::Precision::U8,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Layout::ANY,
InferenceEngine::Layout::ANY,
ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{2, 1, 2, 4}})),
ov::element::u8,
ov::test::utils::DEVICE_GPU),
spaceToBatchParamsTuple({1, 1, 3, 2, 2},
{0, 0, 1, 0, 3},
{0, 0, 2, 0, 0},
{1, 1, 3, 2, 1},
InferenceEngine::Precision::U8,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Precision::UNSPECIFIED,
InferenceEngine::Layout::ANY,
InferenceEngine::Layout::ANY,
ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{1, 1, 3, 2, 1}})),
ov::element::u8,
ov::test::utils::DEVICE_GPU),
};
};

35
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/space_to_depth.cpp
View File

@ -2,46 +2,43 @@
// SPDX-License-Identifier: Apache-2.0
//
#include <vector>
#include <ngraph/opsets/opset3.hpp>
#include "single_layer_tests/space_to_depth.hpp"
#include "single_op_tests/space_to_depth.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::SpaceToDepthLayerTest;
using ov::op::v0::SpaceToDepth;
const std::vector<ov::element::Type> inputPrecisions = {
ov::element::f32,
ov::element::u8,
ov::element::i16,
};
const std::vector<SpaceToDepth::SpaceToDepthMode> modes = {
SpaceToDepth::SpaceToDepthMode::BLOCKS_FIRST,
SpaceToDepth::SpaceToDepthMode::DEPTH_FIRST};
const std::vector<std::vector<size_t >> inputShapesBS2 = {
{1, 1, 2, 2}, {1, 1, 4, 4}, {1, 1, 6, 6}, {2, 8, 6, 6}, {2, 4, 10, 8},
{1, 1, 2, 2, 2}, {1, 1, 4, 4, 4}, {1, 1, 6, 6, 6}, {2, 8, 6, 6, 6}, {2, 4, 10, 8, 12}};
const std::vector<std::vector<ov::Shape>> inputShapesBS2 = {
{{1, 1, 2, 2}}, {{1, 1, 4, 4}}, {{1, 1, 6, 6}}, {{2, 8, 6, 6}}, {{2, 4, 10, 8}},
{{1, 1, 2, 2, 2}}, {{1, 1, 4, 4, 4}}, {{1, 1, 6, 6, 6}}, {{2, 8, 6, 6, 6}}, {{2, 4, 10, 8, 12}}};
INSTANTIATE_TEST_SUITE_P(SpaceToDepthBS2,
SpaceToDepthLayerTest,
::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)),
SpaceToDepthLayerTest::getTestCaseName);
const std::vector<std::vector<size_t >> inputShapesBS3 = {
{1, 1, 3, 3}, {1, 1, 6, 6}, {1, 1, 9, 9}, {2, 4, 9, 9}, {2, 3, 15, 12},
{1, 1, 3, 3, 3}, {1, 1, 6, 6, 6}, {1, 1, 9, 9, 9}, {2, 4, 9, 9, 9}, {2, 3, 15, 12, 18}};
const std::vector<std::vector<ov::Shape>> inputShapesBS3 = {
{{1, 1, 3, 3}}, {{1, 1, 6, 6}}, {{1, 1, 9, 9}}, {{2, 4, 9, 9}}, {{2, 3, 15, 12}},
{{1, 1, 3, 3, 3}}, {{1, 1, 6, 6, 6}}, {{1, 1, 9, 9, 9}}, {{2, 4, 9, 9, 9}}, {{2, 3, 15, 12, 18}}};
INSTANTIATE_TEST_SUITE_P(SpaceToDepthBS3,
SpaceToDepthLayerTest,
::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),

30
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/split.cpp
View File

@ -1,20 +1,16 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include <vector>
#include "single_layer_tests/split.hpp"
#include "single_op_tests/split.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
namespace {
using ov::test::SplitLayerTest;
const std::vector<InferenceEngine::Precision> netPrecisions = {
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16,
InferenceEngine::Precision::I64
const std::vector<ov::element::Type> netPrecisions = {
ov::element::f32,
ov::element::f16,
ov::element::i64
};
INSTANTIATE_TEST_SUITE_P(smoke_NumSplitsCheck, SplitLayerTest,
@ -22,11 +18,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_NumSplitsCheck, SplitLayerTest,
::testing::Values(1),
::testing::Values(0, 1, 2, 3),
::testing::ValuesIn(netPrecisions),
::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::Values(std::vector<size_t>({30, 30, 30, 30})),
::testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{30, 30, 30, 30}}))),
::testing::Values(std::vector<size_t>({})),
::testing::Values(ov::test::utils::DEVICE_GPU)),
SplitLayerTest::getTestCaseName);
@ -36,11 +29,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_splitWithUnusedOutputsTest, SplitLayerTest,
::testing::Values(5),
::testing::Values(0),
::testing::ValuesIn(netPrecisions),
::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::Values(std::vector<size_t>({30, 30, 30, 30})),
::testing::Values(ov::test::static_shapes_to_test_representation(
std::vector<ov::Shape>({{30, 30, 30, 30}}))),
::testing::Values(std::vector<size_t>({0, 3})),
::testing::Values(ov::test::utils::DEVICE_GPU)),
SplitLayerTest::getTestCaseName);

71
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/squeeze_unsqueeze.cpp
View File

@ -2,63 +2,62 @@
// SPDX-License-Identifier: Apache-2.0
//
#include <vector>
#include "single_layer_tests/squeeze_unsqueeze.hpp"
#include "single_op_tests/squeeze_unsqueeze.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
namespace {
std::map<std::vector<size_t>, std::vector<std::vector<int>>> axesVectors = {
{{1, 1, 1, 1}, {{-1}, {0}, {1}, {2}, {3}, {0, 1}, {0, 2}, {0, 3}, {1, 2}, {2, 3}, {0, 1, 2}, {0, 2, 3}, {1, 2, 3}, {0, 1, 2, 3}}},
{{1, 2, 3, 4}, {{0}}},
{{2, 1, 3, 4}, {{1}}},
{{1}, {{-1}, {0}}},
{{1, 2}, {{0}}},
{{2, 1}, {{1}, {-1}}},
using ov::test::SqueezeUnsqueezeLayerTest;
using ov::test::utils::SqueezeOpType;
std::map<std::vector<ov::Shape>, std::vector<std::vector<int>>> axesVectors = {
{{{1, 1, 1, 1}}, {{-1}, {0}, {1}, {2}, {3}, {0, 1}, {0, 2}, {0, 3}, {1, 2}, {2, 3}, {0, 1, 2}, {0, 2, 3}, {1, 2, 3}, {0, 1, 2, 3}}},
{{{1, 2, 3, 4}}, {{0}}},
{{{2, 1, 3, 4}}, {{1}}},
{{{1}}, {{-1}, {0}}},
{{{1, 2}}, {{0}}},
{{{2, 1}}, {{1}, {-1}}},
};
std::map<std::vector<size_t>, std::vector<std::vector<int>>> emptyAxesVectors = {
{{1, 1, 1, 1}, {{}}},
{{1, 2, 3, 4}, {{}}},
{{2, 1, 3, 4}, {{}}},
{{1}, {{}}},
{{1, 2}, {{}}},
{{2, 1}, {{}}},
std::map<std::vector<ov::Shape>, std::vector<std::vector<int>>> emptyAxesVectors = {
{{{1, 1, 1, 1}}, {{}}},
{{{1, 2, 3, 4}}, {{}}},
{{{2, 1, 3, 4}}, {{}}},
{{{1}}, {{}}},
{{{1, 2}}, {{}}},
{{{2, 1}}, {{}}},
};
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<ngraph::helpers::SqueezeOpType> opTypes = {
ngraph::helpers::SqueezeOpType::SQUEEZE,
ngraph::helpers::SqueezeOpType::UNSQUEEZE
const std::vector<SqueezeOpType> opTypes = {
SqueezeOpType::SQUEEZE,
SqueezeOpType::UNSQUEEZE
};
auto prepare_cases = [](const std::vector<std::pair<std::vector<ov::Shape>, std::vector<int>>>& raw_axes) {
std::vector<std::pair<std::vector<ov::test::InputShape>, std::vector<int>>> cases;
for (const auto& raw_case : raw_axes)
cases.emplace_back(ov::test::static_shapes_to_test_representation(raw_case.first),
raw_case.second);
return cases;
};
INSTANTIATE_TEST_SUITE_P(smoke_Basic, SqueezeUnsqueezeLayerTest,
::testing::Combine(
::testing::ValuesIn(ov::test::utils::combineParams(axesVectors)),
::testing::ValuesIn(prepare_cases(ov::test::utils::combineParams(axesVectors))),
::testing::ValuesIn(opTypes),
::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)),
SqueezeUnsqueezeLayerTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Basic_emptyAxes, SqueezeUnsqueezeLayerTest,
::testing::Combine(
::testing::ValuesIn(ov::test::utils::combineParams(emptyAxesVectors)),
::testing::Values(ngraph::helpers::SqueezeOpType::SQUEEZE),
::testing::ValuesIn(prepare_cases(ov::test::utils::combineParams(emptyAxesVectors))),
::testing::Values(SqueezeOpType::SQUEEZE),
::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)),
SqueezeUnsqueezeLayerTest::getTestCaseName);
} // namespace

23
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/tile.cpp
View File

@ -2,16 +2,13 @@
// SPDX-License-Identifier: Apache-2.0
//
#include <vector>
#include "single_layer_tests/tile.hpp"
using namespace LayerTestsDefinitions;
#include "single_op_tests/tile.hpp"
namespace {
using ov::test::TileLayerTest;
const std::vector<InferenceEngine::Precision> netPrecisions = {
InferenceEngine::Precision::FP32
const std::vector<ov::element::Type> netPrecisions = {
ov::element::f32
};
const std::vector<std::vector<int64_t>> repeats = {
@ -27,11 +24,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_Tile, TileLayerTest,
::testing::Combine(
::testing::ValuesIn(repeats),
::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, 3, 4})),
::testing::Values(ov::test::static_shapes_to_test_representation(std::vector<ov::Shape>({{2, 3, 4}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
TileLayerTest::getTestCaseName);
@ -39,11 +32,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_Tile6d, TileLayerTest,
::testing::Combine(
::testing::Values(std::vector<int64_t>({1, 1, 1, 2, 1, 2})),
::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, 1, 3, 1})),
::testing::Values(ov::test::static_shapes_to_test_representation(std::vector<ov::Shape>({{1, 4, 3, 1, 3, 1}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
TileLayerTest::getTestCaseName);

71
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/transpose.cpp
View File

@ -2,29 +2,26 @@
// SPDX-License-Identifier: Apache-2.0
//
#include <vector>
#include "single_layer_tests/transpose.hpp"
#include "single_op_tests/transpose.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
namespace {
using ov::test::TransposeLayerTest;
const std::vector<InferenceEngine::Precision> netPrecisions = {
InferenceEngine::Precision::FP32,
const std::vector<ov::element::Type> netPrecisions = {
ov::element::f32,
};
/**
* 4D permute tests
*/
const std::vector<std::vector<size_t>> inputShapes = {
std::vector<size_t>{1, 3, 100, 100},
const std::vector<std::vector<ov::Shape>> inputShapes = {
{{1, 3, 100, 100}},
// use permute_8x8_4x4 kernel
std::vector<size_t>{2, 8, 64, 64},
std::vector<size_t>{2, 5, 64, 64},
std::vector<size_t>{2, 8, 64, 5},
std::vector<size_t>{2, 5, 64, 5},
{{2, 8, 64, 64}},
{{2, 5, 64, 64}},
{{2, 8, 64, 5}},
{{2, 5, 64, 5}},
};
const std::vector<std::vector<size_t>> inputOrder = {
@ -39,22 +36,18 @@ INSTANTIATE_TEST_SUITE_P(smoke_Transpose,
TransposeLayerTest,
testing::Combine(testing::ValuesIn(inputOrder),
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::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapes)),
testing::Values(ov::test::utils::DEVICE_GPU)),
TransposeLayerTest::getTestCaseName);
/**
* 5D permute tests
*/
const std::vector<std::vector<size_t>> inputShapes5D = {
std::vector<size_t>{2, 3, 4, 12, 64},
std::vector<size_t>{2, 5, 11, 32, 32},
std::vector<size_t>{2, 8, 64, 32, 5},
std::vector<size_t>{2, 5, 64, 32, 5},
const std::vector<std::vector<ov::Shape>> inputShapes5D = {
{{2, 3, 4, 12, 64}},
{{2, 5, 11, 32, 32}},
{{2, 8, 64, 32, 5}},
{{2, 5, 64, 32, 5}},
};
const std::vector<std::vector<size_t>> inputOrder5D = {
@ -71,22 +64,18 @@ INSTANTIATE_TEST_SUITE_P(smoke_Transpose_5D,
TransposeLayerTest,
testing::Combine(testing::ValuesIn(inputOrder5D),
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(inputShapes5D),
testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapes5D)),
testing::Values(ov::test::utils::DEVICE_GPU)),
TransposeLayerTest::getTestCaseName);
/**
* 6D permute tests
*/
const std::vector<std::vector<size_t>> inputShapes6D = {
std::vector<size_t>{2, 8, 5, 13, 11, 16},
std::vector<size_t>{2, 11, 6, 2, 15, 10},
std::vector<size_t>{2, 13, 1, 3, 14, 32},
std::vector<size_t>{2, 14, 3, 4, 4, 22},
const std::vector<std::vector<ov::Shape>> inputShapes6D = {
{{2, 8, 5, 13, 11, 16}},
{{2, 11, 6, 2, 15, 10}},
{{2, 13, 1, 3, 14, 32}},
{{2, 14, 3, 4, 4, 22}},
};
const std::vector<std::vector<size_t>> inputOrder6D = {
@ -101,19 +90,15 @@ INSTANTIATE_TEST_SUITE_P(smoke_Transpose_6D,
TransposeLayerTest,
testing::Combine(testing::ValuesIn(inputOrder6D),
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(inputShapes6D),
testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapes6D)),
testing::Values(ov::test::utils::DEVICE_GPU)),
TransposeLayerTest::getTestCaseName);
/**
* 8D permute tests
*/
const std::vector<std::vector<size_t>> inputShapes8D = {
std::vector<size_t>{1, 2, 3, 4, 5, 6, 7, 8},
const std::vector<std::vector<ov::Shape>> inputShapes8D = {
{{1, 2, 3, 4, 5, 6, 7, 8}},
};
const std::vector<std::vector<size_t>> inputOrder8D = {
@ -124,11 +109,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_Transpose_8D,
TransposeLayerTest,
testing::Combine(testing::ValuesIn(inputOrder8D),
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(inputShapes8D),
testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapes8D)),
testing::Values(ov::test::utils::DEVICE_GPU)),
TransposeLayerTest::getTestCaseName);

44
src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/variadic_split.cpp
View File

@ -1,40 +1,32 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include <vector>
#include "single_layer_tests/variadic_split.hpp"
#include "single_op_tests/variadic_split.hpp"
#include "common_test_utils/test_constants.hpp"
using namespace LayerTestsDefinitions;
namespace {
using ov::test::VariadicSplitLayerTest;
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
};
// Sum of elements numSplits = inputShapes[Axis]
const std::vector<std::vector<size_t>> numSplits = {
{1, 16, 5, 8},
{2, 19, 5, 4},
{7, 13, 2, 8},
{5, 8, 12, 5},
{4, 11, 6, 9}
};
// Sum of elements numSplits = inputShapes[Axis]
const std::vector<std::vector<size_t>> numSplits = {
{1, 16, 5, 8},
{2, 19, 5, 4},
{7, 13, 2, 8},
{5, 8, 12, 5},
{4, 11, 6, 9}
};
INSTANTIATE_TEST_SUITE_P(smoke_NumSplitsCheck, VariadicSplitLayerTest,
::testing::Combine(
INSTANTIATE_TEST_SUITE_P(smoke_NumSplitsCheck, VariadicSplitLayerTest,
::testing::Combine(
::testing::ValuesIn(numSplits),
::testing::Values(0, 1, 2, 3),
::testing::ValuesIn(netPrecisions),
::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::Values(std::vector<size_t>({30, 30, 30, 30})),
::testing::Values(ov::test::static_shapes_to_test_representation(std::vector<ov::Shape>({{30, 30, 30, 30}}))),
::testing::Values(ov::test::utils::DEVICE_GPU)),
VariadicSplitLayerTest::getTestCaseName);
VariadicSplitLayerTest::getTestCaseName);
} // namespace