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

Template plugin tests refactoring (#19397)

Browse Source 
* Template plugin tests refactoring

* Apply comments
This commit is contained in:
Oleg Pipikin 2023-08-29 15:48:53 +02:00 committed by GitHub
parent 84fc6fb626
commit e3e1e8c811
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
49 changed files with 646 additions and 471 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/plugins/template/tests/functional/op_reference/acos.cpp
View File

@ -55,9 +55,9 @@ TEST_P(ReferenceAcosLayerTest, AcosWithHardcodedRefs) {
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_SUITE_P(
smoke_Acos_With_Hardcoded_Refs, ReferenceAcosLayerTest, smoke_Acos_With_Hardcoded_Refs, ReferenceAcosLayerTest,
::testing::Values(Builder {} ::testing::Values(Builder {}
.input({{11}, element::f16, std::vector<ngraph::float16> {-1.f, -0.75f, -0.5f, -0.25f, -0.125f, .input({{11}, element::f16, std::vector<ov::float16> {-1.f, -0.75f, -0.5f, -0.25f, -0.125f,
0.f, 0.125f, 0.25f, 0.5f, 0.75f, 1.f}}) 0.f, 0.125f, 0.25f, 0.5f, 0.75f, 1.f}})
.expected({{11}, element::f16, std::vector<ngraph::float16> {3.14159265f, 2.41885841f, 2.09439510f, 1.82347658f, 1.69612416f, .expected({{11}, element::f16, std::vector<ov::float16> {3.14159265f, 2.41885841f, 2.09439510f, 1.82347658f, 1.69612416f,
1.57079633f, 1.44546850f, 1.31811607f, 1.04719755f, 0.72273425f, 1.57079633f, 1.44546850f, 1.31811607f, 1.04719755f, 0.72273425f,
0.00000000f}}), 0.00000000f}}),
Builder {} Builder {}

4
src/plugins/template/tests/functional/op_reference/acosh.cpp
View File

@ -55,8 +55,8 @@ TEST_P(ReferenceAcoshLayerTest, AcoshWithHardcodedRefs) {
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_SUITE_P(
smoke_Acosh_With_Hardcoded_Refs, ReferenceAcoshLayerTest, smoke_Acosh_With_Hardcoded_Refs, ReferenceAcoshLayerTest,
::testing::Values(Builder {} ::testing::Values(Builder {}
.input({{8}, element::f16, std::vector<ngraph::float16> {1.f, 2.f, 3.f, 4.f, 5.f, 10.f, 100.f, 1000.f}}) .input({{8}, element::f16, std::vector<ov::float16> {1.f, 2.f, 3.f, 4.f, 5.f, 10.f, 100.f, 1000.f}})
.expected({{8}, element::f16, std::vector<ngraph::float16> {0., 1.317, 1.763, 2.063, 2.292, 2.993, 5.298, 7.6012}}), .expected({{8}, element::f16, std::vector<ov::float16> {0., 1.317, 1.763, 2.063, 2.292, 2.993, 5.298, 7.6012}}),
Builder {} Builder {}
.input({{8}, element::f32, std::vector<float> {1.f, 2.f, 3.f, 4.f, 5.f, 10.f, 100.f, 1000.f}}) .input({{8}, element::f32, std::vector<float> {1.f, 2.f, 3.f, 4.f, 5.f, 10.f, 100.f, 1000.f}})
.expected({{8}, element::f32, std::vector<float> {0., 1.317, 1.763, 2.063, 2.292, 2.993, 5.298, 7.6012}}), .expected({{8}, element::f32, std::vector<float> {0., 1.317, 1.763, 2.063, 2.292, 2.993, 5.298, 7.6012}}),

4
src/plugins/template/tests/functional/op_reference/asin.cpp
View File

@ -57,8 +57,8 @@ INSTANTIATE_TEST_SUITE_P(
smoke_Asin_With_Hardcoded_Refs, ReferenceAsinLayerTest, smoke_Asin_With_Hardcoded_Refs, ReferenceAsinLayerTest,
::testing::Values( ::testing::Values(
Builder {} Builder {}
.input({{11}, element::f16, std::vector<ngraph::float16> {-1.f, -0.75f, -0.5f, -0.25f, -0.125f, 0.f, 0.125f, 0.25f, 0.5f, 0.75f, 1.f}}) .input({{11}, element::f16, std::vector<ov::float16> {-1.f, -0.75f, -0.5f, -0.25f, -0.125f, 0.f, 0.125f, 0.25f, 0.5f, 0.75f, 1.f}})
.expected({{11}, element::f16, std::vector<ngraph::float16> {-1.57079633f, .expected({{11}, element::f16, std::vector<ov::float16> {-1.57079633f,
-0.84806208f, -0.84806208f,
-0.52359878f, -0.52359878f,
-0.25268026f, -0.25268026f,

4
src/plugins/template/tests/functional/op_reference/asinh.cpp
View File

@ -57,8 +57,8 @@ INSTANTIATE_TEST_SUITE_P(
smoke_Asinh_With_Hardcoded_Refs, ReferenceAsinhLayerTest, smoke_Asinh_With_Hardcoded_Refs, ReferenceAsinhLayerTest,
::testing::Values( ::testing::Values(
Builder {} Builder {}
.input({{11}, element::f16, std::vector<ngraph::float16> {0.f, 1.f, -1.f, 2.f, -2.f, 3.f, -3.f, 4.f, 5.f, 10.f, 100.f}}) .input({{11}, element::f16, std::vector<ov::float16> {0.f, 1.f, -1.f, 2.f, -2.f, 3.f, -3.f, 4.f, 5.f, 10.f, 100.f}})
.expected({{11}, element::f16, std::vector<ngraph::float16> {0.00000000f, .expected({{11}, element::f16, std::vector<ov::float16> {0.00000000f,
0.88137359f, 0.88137359f,
-0.88137359f, -0.88137359f,
1.44363548f, 1.44363548f,

4
src/plugins/template/tests/functional/op_reference/atan.cpp
View File

@ -56,8 +56,8 @@ INSTANTIATE_TEST_SUITE_P(
smoke_Atan_With_Hardcoded_Refs, ReferenceAtanLayerTest, smoke_Atan_With_Hardcoded_Refs, ReferenceAtanLayerTest,
::testing::Values( ::testing::Values(
Builder{} Builder{}
.input({{11}, element::f16, std::vector<ngraph::float16>{-4.f, -2.f, -1.f, -0.5f, -0.25f, 0.f, 0.25f, 0.5f, 1.f, 2.f, 4.f}}) .input({{11}, element::f16, std::vector<ov::float16>{-4.f, -2.f, -1.f, -0.5f, -0.25f, 0.f, 0.25f, 0.5f, 1.f, 2.f, 4.f}})
.expected({{11}, element::f16, std::vector<ngraph::float16>{-1.32581766f, .expected({{11}, element::f16, std::vector<ov::float16>{-1.32581766f,
-1.10714872f, -1.10714872f,
-0.78539816f, -0.78539816f,
-0.46364761f, -0.46364761f,

4
src/plugins/template/tests/functional/op_reference/atanh.cpp
View File

@ -62,10 +62,10 @@ INSTANTIATE_TEST_SUITE_P(
ReferenceAtanhLayerTest, ReferenceAtanhLayerTest,
::testing::Values( ::testing::Values(
Builder{} Builder{}
.input({{5}, element::f16, std::vector<ngraph::float16>{-1.0f, -0.5f, 0.0f, 0.8f, 1.0f}}) .input({{5}, element::f16, std::vector<ov::float16>{-1.0f, -0.5f, 0.0f, 0.8f, 1.0f}})
.expected({{5}, .expected({{5},
element::f16, element::f16,
std::vector<ngraph::float16>{-INFINITY, -0.54930614f, 0.00000000f, 1.0986123f, INFINITY}}), std::vector<ov::float16>{-INFINITY, -0.54930614f, 0.00000000f, 1.0986123f, INFINITY}}),
Builder{} Builder{}
.input({{5}, element::f32, std::vector<float>{-1.0f, -0.5f, 0.0f, 0.8f, 1.0f}}) .input({{5}, element::f32, std::vector<float>{-1.0f, -0.5f, 0.0f, 0.8f, 1.0f}})
.expected( .expected(

1
src/plugins/template/tests/functional/op_reference/binary_convolution.cpp
View File

@ -4,7 +4,6 @@
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include <ngraph_functions/builders.hpp>
#include "openvino/op/binary_convolution.hpp" #include "openvino/op/binary_convolution.hpp"
#include "base_reference_test.hpp" #include "base_reference_test.hpp"
#include "openvino/opsets/opset8.hpp" #include "openvino/opsets/opset8.hpp"

66
src/plugins/template/tests/functional/op_reference/comparison.hpp
View File

@ -5,15 +5,26 @@
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include "base_reference_test.hpp" #include "base_reference_test.hpp"
#include "ngraph_functions/builders.hpp" #include "common_test_utils/test_enums.hpp"
#include "openvino/op/equal.hpp"
#include "openvino/op/not_equal.hpp"
#include "openvino/op/greater.hpp"
#include "openvino/op/greater_eq.hpp"
#include "openvino/op/less.hpp"
#include "openvino/op/less_eq.hpp"
#include "openvino/op/is_inf.hpp"
#include "openvino/op/is_finite.hpp"
#include "openvino/op/is_nan.hpp"
using namespace ov; using namespace ov;
namespace reference_tests { namespace reference_tests {
namespace ComparisonOpsRefTestDefinitions { namespace ComparisonOpsRefTestDefinitions {
using ov::test::utils::ComparisonTypes;
struct RefComparisonParams { struct RefComparisonParams {
ngraph::helpers::ComparisonTypes compType; ComparisonTypes compType;
reference_tests::Tensor input1; reference_tests::Tensor input1;
reference_tests::Tensor input2; reference_tests::Tensor input2;
reference_tests::Tensor expected; reference_tests::Tensor expected;
@ -46,13 +57,54 @@ public:
} }
private: private:
static std::shared_ptr<ov::Model> CreateFunction(ngraph::helpers::ComparisonTypes comp_op_type, const ov::PartialShape& input_shape1, static std::shared_ptr<ov::Model> CreateFunction(ComparisonTypes comp_op_type, const ov::PartialShape& input_shape1,
const ov::PartialShape& input_shape2, const ov::element::Type& input_type, const ov::PartialShape& input_shape2, const ov::element::Type& input_type,
const ov::element::Type& expected_output_type) { const ov::element::Type& expected_output_type) {
const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape1); const auto in0 = std::make_shared<op::v0::Parameter>(input_type, input_shape1);
const auto in2 = std::make_shared<op::v0::Parameter>(input_type, input_shape2); const auto in1 = std::make_shared<op::v0::Parameter>(input_type, input_shape2);
const auto comp = ngraph::builder::makeComparison(in, in2, comp_op_type); std::shared_ptr<ov::Node> comp;
return std::make_shared<ov::Model>(ov::NodeVector {comp}, ov::ParameterVector {in, in2}); switch (comp_op_type) {
case ComparisonTypes::EQUAL: {
comp = std::make_shared<ov::op::v1::Equal>(in0, in1);
break;
}
case ComparisonTypes::NOT_EQUAL: {
comp = std::make_shared<ov::op::v1::NotEqual>(in0, in1);
break;
}
case ComparisonTypes::GREATER: {
comp = std::make_shared<ov::op::v1::Greater>(in0, in1);
break;
}
case ComparisonTypes::GREATER_EQUAL: {
comp = std::make_shared<ov::op::v1::GreaterEqual>(in0, in1);
break;
}
case ComparisonTypes::IS_FINITE: {
comp = std::make_shared<ov::op::v10::IsFinite>(in0);
break;
}
case ComparisonTypes::IS_INF: {
comp = std::make_shared<ov::op::v10::IsInf>(in0);
break;
}
case ComparisonTypes::IS_NAN: {
comp = std::make_shared<ov::op::v10::IsNaN>(in0);
break;
}
case ComparisonTypes::LESS: {
comp = std::make_shared<ov::op::v1::Less>(in0, in1);
break;
}
case ComparisonTypes::LESS_EQUAL: {
comp = std::make_shared<ov::op::v1::LessEqual>(in0, in1);
break;
}
default: {
throw std::runtime_error("Incorrect type of Comparison operation");
}
}
return std::make_shared<ov::Model>(ov::NodeVector {comp}, ov::ParameterVector {in0, in1});
} }
}; };
} // namespace ComparisonOpsRefTestDefinitions } // namespace ComparisonOpsRefTestDefinitions

29
src/plugins/template/tests/functional/op_reference/conversion.hpp
View File

@ -5,25 +5,30 @@
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include "base_reference_test.hpp" #include "base_reference_test.hpp"
#include "ngraph_functions/builders.hpp" #include "common_test_utils/test_enums.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/convert.hpp"
#include "openvino/op/convert_like.hpp"
using namespace ov; using namespace ov;
namespace reference_tests { namespace reference_tests {
namespace ConversionOpsRefTestDefinitions { namespace ConversionOpsRefTestDefinitions {
static std::map<ngraph::helpers::ConversionTypes, std::string> conversionNames = { using ov::test::utils::ConversionTypes;
{ngraph::helpers::ConversionTypes::CONVERT, "Convert"},
{ngraph::helpers::ConversionTypes::CONVERT_LIKE, "ConvertLike"} static std::map<ConversionTypes, std::string> conversionNames = {
{ConversionTypes::CONVERT, "Convert"},
{ConversionTypes::CONVERT_LIKE, "ConvertLike"}
}; };
struct ConvertParams { struct ConvertParams {
template <class IT, class OT> template <class IT, class OT>
ConvertParams(ngraph::helpers::ConversionTypes convType, const ov::PartialShape& shape, const ov::element::Type& iType, ConvertParams(ConversionTypes convType, const ov::PartialShape& shape, const ov::element::Type& iType,
const ov::element::Type& oType, const std::vector<IT>& iValues, const std::vector<OT>& oValues, size_t iSize = 0, size_t oSize = 0) const ov::element::Type& oType, const std::vector<IT>& iValues, const std::vector<OT>& oValues, size_t iSize = 0, size_t oSize = 0)
: conversionType(convType), pshape(shape), inType(iType), outType(oType), inputData(CreateTensor(iType, iValues, iSize)), : conversionType(convType), pshape(shape), inType(iType), outType(oType), inputData(CreateTensor(iType, iValues, iSize)),
refData(CreateTensor(oType, oValues, oSize)) {} refData(CreateTensor(oType, oValues, oSize)) {}
ngraph::helpers::ConversionTypes conversionType; ConversionTypes conversionType;
ov::PartialShape pshape; ov::PartialShape pshape;
ov::element::Type inType; ov::element::Type inType;
ov::element::Type outType; ov::element::Type outType;
@ -53,9 +58,17 @@ public:
private: private:
static std::shared_ptr<ov::Model> CreateFunction(const ov::PartialShape& input_shape, const ov::element::Type& input_type, static std::shared_ptr<ov::Model> CreateFunction(const ov::PartialShape& input_shape, const ov::element::Type& input_type,
const ov::element::Type& expected_output_type, const ov::element::Type& expected_output_type,
const ngraph::helpers::ConversionTypes& conversion_type) { const ConversionTypes& conversion_type) {
const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape); const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
const auto convert = ngraph::builder::makeConversion(in, expected_output_type, conversion_type); std::shared_ptr<ov::Node> convert;
if (conversion_type == ConversionTypes::CONVERT) {
convert = std::make_shared<ov::op::v0::Convert>(in, expected_output_type);
} else if (conversion_type == ConversionTypes::CONVERT_LIKE) {
const auto like = std::make_shared<ov::op::v0::Constant>(expected_output_type, ov::Shape{1});
convert = std::make_shared<ov::op::v1::ConvertLike>(in, like);
} else {
throw std::runtime_error("Incorrect type of Conversion operation");
}
return std::make_shared<ov::Model>(ov::NodeVector {convert}, ov::ParameterVector {in}); return std::make_shared<ov::Model>(ov::NodeVector {convert}, ov::ParameterVector {in});
} }
}; };

45
src/plugins/template/tests/functional/op_reference/convert.cpp
View File

@ -9,7 +9,6 @@
#include "conversion.hpp" #include "conversion.hpp"
using namespace ov; using namespace ov;
using ConversionTypes = ngraph::helpers::ConversionTypes;
namespace reference_tests { namespace reference_tests {
namespace ConversionOpsRefTestDefinitions { namespace ConversionOpsRefTestDefinitions {
@ -101,9 +100,9 @@ INSTANTIATE_TEST_SUITE_P(
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::i4, std::vector<int64_t> {-1, -2, 2, 3}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::i4, std::vector<int64_t> {-1, -2, 2, 3},
std::vector<uint8_t> {0xFE, 0x23}, 4, 4), std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::i4, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::i4,
std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4), std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::i4, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::i4,
std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4), std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::i4, std::vector<float> {-1, -2, 2, 3}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::i4, std::vector<float> {-1, -2, 2, 3},
std::vector<uint8_t> {0xFE, 0x23}, 4, 4), std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
// destination i8 // destination i8
@ -130,9 +129,9 @@ INSTANTIATE_TEST_SUITE_P(
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::i8, std::vector<int64_t> {-1, -2, 2, 3}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::i8, std::vector<int64_t> {-1, -2, 2, 3},
std::vector<int8_t> {-1, -2, 2, 3}), std::vector<int8_t> {-1, -2, 2, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::i8, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::i8,
std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<int8_t> {-1, -2, 0, 3}), std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<int8_t> {-1, -2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::i8, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::i8,
std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<int8_t> {-1, -2, 0, 3}), std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<int8_t> {-1, -2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::i8, std::vector<float> {-1, -2, 2.2, 3.8}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::i8, std::vector<float> {-1, -2, 2.2, 3.8},
std::vector<int8_t> {-1, -2, 2, 3}), std::vector<int8_t> {-1, -2, 2, 3}),
// destination i16 // destination i16
@ -159,9 +158,9 @@ INSTANTIATE_TEST_SUITE_P(
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::i16, std::vector<int64_t> {-1, -2, 2, 3}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::i16, std::vector<int64_t> {-1, -2, 2, 3},
std::vector<int16_t> {-1, -2, 2, 3}), std::vector<int16_t> {-1, -2, 2, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::i16, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::i16,
std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<int16_t> {-1, -2, 0, 3}), std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<int16_t> {-1, -2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::i16, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::i16,
std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<int16_t> {-1, -2, 0, 3}), std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<int16_t> {-1, -2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::i16, std::vector<float> {-1, -2, 2.2, 3.8}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::i16, std::vector<float> {-1, -2, 2.2, 3.8},
std::vector<int16_t> {-1, -2, 2, 3}), std::vector<int16_t> {-1, -2, 2, 3}),
// destination i32 // destination i32
@ -188,9 +187,9 @@ INSTANTIATE_TEST_SUITE_P(
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::i32, std::vector<int64_t> {-1, -2, 2, 3}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::i32, std::vector<int64_t> {-1, -2, 2, 3},
std::vector<int32_t> {-1, -2, 2, 3}), std::vector<int32_t> {-1, -2, 2, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::i32, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::i32,
std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<int32_t> {-1, -2, 0, 3}), std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<int32_t> {-1, -2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::i32, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::i32,
std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<int32_t> {-1, -2, 0, 3}), std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<int32_t> {-1, -2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::i32, std::vector<float> {-1, -2, 2.2, 3.8}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::i32, std::vector<float> {-1, -2, 2.2, 3.8},
std::vector<int32_t> {-1, -2, 2, 3}), std::vector<int32_t> {-1, -2, 2, 3}),
// destination i64 // destination i64
@ -217,9 +216,9 @@ INSTANTIATE_TEST_SUITE_P(
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::i64, std::vector<int64_t> {-1, -2, 2, 3}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::i64, std::vector<int64_t> {-1, -2, 2, 3},
std::vector<int64_t> {-1, -2, 2, 3}), std::vector<int64_t> {-1, -2, 2, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::i64, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::i64,
std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<int64_t> {-1, -2, 0, 3}), std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<int64_t> {-1, -2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::i64, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::i64,
std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<int64_t> {-1, -2, 0, 3}), std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<int64_t> {-1, -2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::i64, std::vector<float> {-1, -2, 2.2, 3.8}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::i64, std::vector<float> {-1, -2, 2.2, 3.8},
std::vector<int64_t> {-1, -2, 2, 3}), std::vector<int64_t> {-1, -2, 2, 3}),
@ -247,9 +246,9 @@ INSTANTIATE_TEST_SUITE_P(
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::i64, ov::element::u1, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::i64, ov::element::u1,
std::vector<int64_t> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8), std::vector<int64_t> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::f16, ov::element::u1, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::f16, ov::element::u1,
std::vector<ngraph::float16> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8), std::vector<ov::float16> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::bf16, ov::element::u1, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::bf16, ov::element::u1,
std::vector<ngraph::bfloat16> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8), std::vector<ov::bfloat16> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::f32, ov::element::u1, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::f32, ov::element::u1,
std::vector<float> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8), std::vector<float> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
@ -277,9 +276,9 @@ INSTANTIATE_TEST_SUITE_P(
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::u4, std::vector<int64_t> {-1, -2, 2, 3}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::u4, std::vector<int64_t> {-1, -2, 2, 3},
std::vector<uint8_t> {0xFE, 0x23}, 4, 4), std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::u4, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::u4,
std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4), std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::u4, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::u4,
std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4), std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::u4, std::vector<float> {-1, -2, 2, 3}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::u4, std::vector<float> {-1, -2, 2, 3},
std::vector<uint8_t> {0xFE, 0x23}, 4, 4), std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
@ -306,10 +305,10 @@ INSTANTIATE_TEST_SUITE_P(
std::vector<uint8_t> {1, 2, 2, 3}), std::vector<uint8_t> {1, 2, 2, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::u8, std::vector<int64_t> {1, 2, 2, 3}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::u8, std::vector<int64_t> {1, 2, 2, 3},
std::vector<uint8_t> {1, 2, 2, 3}), std::vector<uint8_t> {1, 2, 2, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::u8, std::vector<ngraph::float16> {1, 2, 0, 3}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::u8, std::vector<ov::float16> {1, 2, 0, 3},
std::vector<uint8_t> {1, 2, 0, 3}), std::vector<uint8_t> {1, 2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::u8, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::u8,
std::vector<ngraph::bfloat16> {1, 2, 0, 3}, std::vector<uint8_t> {1, 2, 0, 3}), std::vector<ov::bfloat16> {1, 2, 0, 3}, std::vector<uint8_t> {1, 2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::u8, std::vector<float> {1, 2, 2.2, 3.8}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::u8, std::vector<float> {1, 2, 2.2, 3.8},
std::vector<uint8_t> {1, 2, 2, 3}), std::vector<uint8_t> {1, 2, 2, 3}),
@ -336,10 +335,10 @@ INSTANTIATE_TEST_SUITE_P(
std::vector<uint16_t> {1, 2, 2, 3}), std::vector<uint16_t> {1, 2, 2, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::u16, std::vector<int64_t> {1, 2, 2, 3}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::u16, std::vector<int64_t> {1, 2, 2, 3},
std::vector<uint16_t> {1, 2, 2, 3}), std::vector<uint16_t> {1, 2, 2, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::u16, std::vector<ngraph::float16> {1, 2, 0, 3}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::u16, std::vector<ov::float16> {1, 2, 0, 3},
std::vector<uint16_t> {1, 2, 0, 3}), std::vector<uint16_t> {1, 2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::u16, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::u16,
std::vector<ngraph::bfloat16> {1, 2, 0, 3}, std::vector<uint16_t> {1, 2, 0, 3}), std::vector<ov::bfloat16> {1, 2, 0, 3}, std::vector<uint16_t> {1, 2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::u16, std::vector<float> {1, 2, 2.2, 3.8}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::u16, std::vector<float> {1, 2, 2.2, 3.8},
std::vector<uint16_t> {1, 2, 2, 3}), std::vector<uint16_t> {1, 2, 2, 3}),
@ -366,10 +365,10 @@ INSTANTIATE_TEST_SUITE_P(
std::vector<uint32_t> {1, 2, 2, 3}), std::vector<uint32_t> {1, 2, 2, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::u32, std::vector<int64_t> {1, 2, 2, 3}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::u32, std::vector<int64_t> {1, 2, 2, 3},
std::vector<uint32_t> {1, 2, 2, 3}), std::vector<uint32_t> {1, 2, 2, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::u32, std::vector<ngraph::float16> {1, 2, 0, 3}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::u32, std::vector<ov::float16> {1, 2, 0, 3},
std::vector<uint32_t> {1, 2, 0, 3}), std::vector<uint32_t> {1, 2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::u32, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::u32,
std::vector<ngraph::bfloat16> {1, 2, 0, 3}, std::vector<uint32_t> {1, 2, 0, 3}), std::vector<ov::bfloat16> {1, 2, 0, 3}, std::vector<uint32_t> {1, 2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::u32, std::vector<float> {1, 2, 2.2, 3.8}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::u32, std::vector<float> {1, 2, 2.2, 3.8},
std::vector<uint32_t> {1, 2, 2, 3}), std::vector<uint32_t> {1, 2, 2, 3}),
// destination u64 // destination u64
@ -395,10 +394,10 @@ INSTANTIATE_TEST_SUITE_P(
std::vector<uint64_t> {1, 2, 2, 3}), std::vector<uint64_t> {1, 2, 2, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::u64, std::vector<int64_t> {1, 2, 2, 3}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::u64, std::vector<int64_t> {1, 2, 2, 3},
std::vector<uint64_t> {1, 2, 2, 3}), std::vector<uint64_t> {1, 2, 2, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::u64, std::vector<ngraph::float16> {1, 2, 0, 3}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::u64, std::vector<ov::float16> {1, 2, 0, 3},
std::vector<uint64_t> {1, 2, 0, 3}), std::vector<uint64_t> {1, 2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::u64, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::u64,
std::vector<ngraph::bfloat16> {1, 2, 0, 3}, std::vector<uint64_t> {1, 2, 0, 3}), std::vector<ov::bfloat16> {1, 2, 0, 3}, std::vector<uint64_t> {1, 2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::u64, std::vector<float> {1, 2, 2.2, 3.8}, ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::u64, std::vector<float> {1, 2, 2.2, 3.8},
std::vector<uint64_t> {1, 2, 2, 3})), std::vector<uint64_t> {1, 2, 2, 3})),
ReferenceConversionLayerTest::getTestCaseName); ReferenceConversionLayerTest::getTestCaseName);

45
src/plugins/template/tests/functional/op_reference/convert_like.cpp
View File

@ -8,7 +8,6 @@
#include "conversion.hpp" #include "conversion.hpp"
using namespace ov; using namespace ov;
using ConversionTypes = ngraph::helpers::ConversionTypes;
namespace reference_tests { namespace reference_tests {
namespace ConversionOpsRefTestDefinitions { namespace ConversionOpsRefTestDefinitions {
@ -101,9 +100,9 @@ INSTANTIATE_TEST_SUITE_P(
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::i4, std::vector<int64_t> {-1, -2, 2, 3}, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::i4, std::vector<int64_t> {-1, -2, 2, 3},
std::vector<uint8_t> {0xFE, 0x23}, 4, 4), std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::i4, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::i4,
std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4), std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::i4, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::i4,
std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4), std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::i4, std::vector<float> {-1, -2, 2, 3}, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::i4, std::vector<float> {-1, -2, 2, 3},
std::vector<uint8_t> {0xFE, 0x23}, 4, 4), std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
// destination i8 // destination i8
@ -130,9 +129,9 @@ INSTANTIATE_TEST_SUITE_P(
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::i8, std::vector<int64_t> {-1, -2, 2, 3}, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::i8, std::vector<int64_t> {-1, -2, 2, 3},
std::vector<int8_t> {-1, -2, 2, 3}), std::vector<int8_t> {-1, -2, 2, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::i8, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::i8,
std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<int8_t> {-1, -2, 0, 3}), std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<int8_t> {-1, -2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::i8, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::i8,
std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<int8_t> {-1, -2, 0, 3}), std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<int8_t> {-1, -2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::i8, std::vector<float> {-1, -2, 2, 3}, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::i8, std::vector<float> {-1, -2, 2, 3},
std::vector<int8_t> {-1, -2, 2, 3}), std::vector<int8_t> {-1, -2, 2, 3}),
// destination i16 // destination i16
@ -159,9 +158,9 @@ INSTANTIATE_TEST_SUITE_P(
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::i16, std::vector<int64_t> {-1, -2, 2, 3}, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::i16, std::vector<int64_t> {-1, -2, 2, 3},
std::vector<int16_t> {-1, -2, 2, 3}), std::vector<int16_t> {-1, -2, 2, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::i16, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::i16,
std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<int16_t> {-1, -2, 0, 3}), std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<int16_t> {-1, -2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::i16, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::i16,
std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<int16_t> {-1, -2, 0, 3}), std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<int16_t> {-1, -2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::i16, std::vector<float> {-1, -2, 2, 3}, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::i16, std::vector<float> {-1, -2, 2, 3},
std::vector<int16_t> {-1, -2, 2, 3}), std::vector<int16_t> {-1, -2, 2, 3}),
// destination i32 // destination i32
@ -188,9 +187,9 @@ INSTANTIATE_TEST_SUITE_P(
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::i32, std::vector<int64_t> {-1, -2, 2, 3}, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::i32, std::vector<int64_t> {-1, -2, 2, 3},
std::vector<int32_t> {-1, -2, 2, 3}), std::vector<int32_t> {-1, -2, 2, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::i32, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::i32,
std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<int32_t> {-1, -2, 0, 3}), std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<int32_t> {-1, -2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::i32, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::i32,
std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<int32_t> {-1, -2, 0, 3}), std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<int32_t> {-1, -2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::i32, std::vector<float> {-1, -2, 2, 3}, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::i32, std::vector<float> {-1, -2, 2, 3},
std::vector<int32_t> {-1, -2, 2, 3}), std::vector<int32_t> {-1, -2, 2, 3}),
// destination i64 // destination i64
@ -217,9 +216,9 @@ INSTANTIATE_TEST_SUITE_P(
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::i64, std::vector<int64_t> {-1, -2, 2, 3}, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::i64, std::vector<int64_t> {-1, -2, 2, 3},
std::vector<int64_t> {-1, -2, 2, 3}), std::vector<int64_t> {-1, -2, 2, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::i64, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::i64,
std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<int64_t> {-1, -2, 0, 3}), std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<int64_t> {-1, -2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::i64, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::i64,
std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<int64_t> {-1, -2, 0, 3}), std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<int64_t> {-1, -2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::i64, std::vector<float> {-1, -2, 2, 3}, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::i64, std::vector<float> {-1, -2, 2, 3},
std::vector<int64_t> {-1, -2, 2, 3}), std::vector<int64_t> {-1, -2, 2, 3}),
@ -247,9 +246,9 @@ INSTANTIATE_TEST_SUITE_P(
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::i64, ov::element::u1, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::i64, ov::element::u1,
std::vector<int64_t> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8), std::vector<int64_t> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::f16, ov::element::u1, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::f16, ov::element::u1,
std::vector<ngraph::float16> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8), std::vector<ov::float16> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::bf16, ov::element::u1, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::bf16, ov::element::u1,
std::vector<ngraph::bfloat16> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8), std::vector<ov::bfloat16> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::f32, ov::element::u1, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::f32, ov::element::u1,
std::vector<float> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8), std::vector<float> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
@ -277,9 +276,9 @@ INSTANTIATE_TEST_SUITE_P(
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::u4, std::vector<int64_t> {-1, -2, 2, 3}, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::u4, std::vector<int64_t> {-1, -2, 2, 3},
std::vector<uint8_t> {0xFE, 0x23}, 4, 4), std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::u4, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::u4,
std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4), std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::u4, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::u4,
std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4), std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::u4, std::vector<float> {-1, -2, 2, 3}, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::u4, std::vector<float> {-1, -2, 2, 3},
std::vector<uint8_t> {0xFE, 0x23}, 4, 4), std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
@ -307,9 +306,9 @@ INSTANTIATE_TEST_SUITE_P(
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::u8, std::vector<int64_t> {1, 2, 2, 3}, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::u8, std::vector<int64_t> {1, 2, 2, 3},
std::vector<uint8_t> {1, 2, 2, 3}), std::vector<uint8_t> {1, 2, 2, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::u8, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::u8,
std::vector<ngraph::float16> {1, 2, 0, 3}, std::vector<uint8_t> {1, 2, 0, 3}), std::vector<ov::float16> {1, 2, 0, 3}, std::vector<uint8_t> {1, 2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::u8, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::u8,
std::vector<ngraph::bfloat16> {1, 2, 0, 3}, std::vector<uint8_t> {1, 2, 0, 3}), std::vector<ov::bfloat16> {1, 2, 0, 3}, std::vector<uint8_t> {1, 2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::u8, std::vector<float> {1, 2, 2, 3}, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::u8, std::vector<float> {1, 2, 2, 3},
std::vector<uint8_t> {1, 2, 2, 3}), std::vector<uint8_t> {1, 2, 2, 3}),
@ -337,9 +336,9 @@ INSTANTIATE_TEST_SUITE_P(
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::u16, std::vector<int64_t> {1, 2, 2, 3}, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::u16, std::vector<int64_t> {1, 2, 2, 3},
std::vector<uint16_t> {1, 2, 2, 3}), std::vector<uint16_t> {1, 2, 2, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::u16, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::u16,
std::vector<ngraph::float16> {1, 2, 0, 3}, std::vector<uint16_t> {1, 2, 0, 3}), std::vector<ov::float16> {1, 2, 0, 3}, std::vector<uint16_t> {1, 2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::u16, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::u16,
std::vector<ngraph::bfloat16> {1, 2, 0, 3}, std::vector<uint16_t> {1, 2, 0, 3}), std::vector<ov::bfloat16> {1, 2, 0, 3}, std::vector<uint16_t> {1, 2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::u16, std::vector<float> {1, 2, 2, 3}, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::u16, std::vector<float> {1, 2, 2, 3},
std::vector<uint16_t> {1, 2, 2, 3}), std::vector<uint16_t> {1, 2, 2, 3}),
@ -367,9 +366,9 @@ INSTANTIATE_TEST_SUITE_P(
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::u32, std::vector<int64_t> {1, 2, 2, 3}, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::u32, std::vector<int64_t> {1, 2, 2, 3},
std::vector<uint32_t> {1, 2, 2, 3}), std::vector<uint32_t> {1, 2, 2, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::u32, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::u32,
std::vector<ngraph::float16> {1, 2, 0, 3}, std::vector<uint32_t> {1, 2, 0, 3}), std::vector<ov::float16> {1, 2, 0, 3}, std::vector<uint32_t> {1, 2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::u32, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::u32,
std::vector<ngraph::bfloat16> {1, 2, 0, 3}, std::vector<uint32_t> {1, 2, 0, 3}), std::vector<ov::bfloat16> {1, 2, 0, 3}, std::vector<uint32_t> {1, 2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::u32, std::vector<float> {1, 2, 2, 3}, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::u32, std::vector<float> {1, 2, 2, 3},
std::vector<uint32_t> {1, 2, 2, 3}), std::vector<uint32_t> {1, 2, 2, 3}),
// destination u64 // destination u64
@ -396,9 +395,9 @@ INSTANTIATE_TEST_SUITE_P(
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::u64, std::vector<int64_t> {1, 2, 2, 3}, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::u64, std::vector<int64_t> {1, 2, 2, 3},
std::vector<uint64_t> {1, 2, 2, 3}), std::vector<uint64_t> {1, 2, 2, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::u64, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::u64,
std::vector<ngraph::float16> {1, 2, 0, 3}, std::vector<uint64_t> {1, 2, 0, 3}), std::vector<ov::float16> {1, 2, 0, 3}, std::vector<uint64_t> {1, 2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::u64, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::u64,
std::vector<ngraph::bfloat16> {1, 2, 0, 3}, std::vector<uint64_t> {1, 2, 0, 3}), std::vector<ov::bfloat16> {1, 2, 0, 3}, std::vector<uint64_t> {1, 2, 0, 3}),
ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::u64, std::vector<float> {1, 2, 2, 3}, ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::u64, std::vector<float> {1, 2, 2, 3},
std::vector<uint64_t> {1, 2, 2, 3})), std::vector<uint64_t> {1, 2, 2, 3})),
ReferenceConversionLayerTest::getTestCaseName); ReferenceConversionLayerTest::getTestCaseName);

4
src/plugins/template/tests/functional/op_reference/cos.cpp
View File

@ -56,8 +56,8 @@ INSTANTIATE_TEST_SUITE_P(
smoke_Cos_With_Hardcoded_Refs, ReferenceCosLayerTest, smoke_Cos_With_Hardcoded_Refs, ReferenceCosLayerTest,
::testing::Values( ::testing::Values(
Builder {} Builder {}
.input({{11}, element::f16, std::vector<ngraph::float16> {0.f, 0.25f, -0.25f, 0.5f, -0.5f, 1.f, -1.f, 2.f, -2.f, 4.f, -4.f}}) .input({{11}, element::f16, std::vector<ov::float16> {0.f, 0.25f, -0.25f, 0.5f, -0.5f, 1.f, -1.f, 2.f, -2.f, 4.f, -4.f}})
.expected({{11}, element::f16, std::vector<ngraph::float16> {1.00000000f, .expected({{11}, element::f16, std::vector<ov::float16> {1.00000000f,
0.96891242f, 0.96891242f,
0.96891242f, 0.96891242f,
0.87758256f, 0.87758256f,

4
src/plugins/template/tests/functional/op_reference/cosh.cpp
View File

@ -56,8 +56,8 @@ INSTANTIATE_TEST_SUITE_P(
smoke_Cosh_With_Hardcoded_Refs, ReferenceCoshLayerTest, smoke_Cosh_With_Hardcoded_Refs, ReferenceCoshLayerTest,
::testing::Values( ::testing::Values(
Builder {} Builder {}
.input({{11}, element::f16, std::vector<ngraph::float16> {-4.f, -2.f, -1.f, -0.5f, -0.25f, 0.f, 0.25f, 0.5f, 1.f, 2.f, 4.f}}) .input({{11}, element::f16, std::vector<ov::float16> {-4.f, -2.f, -1.f, -0.5f, -0.25f, 0.f, 0.25f, 0.5f, 1.f, 2.f, 4.f}})
.expected({{11}, element::f16, std::vector<ngraph::float16> {27.30823284f, .expected({{11}, element::f16, std::vector<ov::float16> {27.30823284f,
3.76219569f, 3.76219569f,
1.54308063f, 1.54308063f,
1.12762597f, 1.12762597f,

94
src/plugins/template/tests/functional/op_reference/embedding_segments_sum.cpp
View File

@ -20,11 +20,11 @@ struct EmbeddingSegmentsSumParams {
const ov::PartialShape& oShape, const ov::PartialShape& oShape,
const ov::element::Type& oType, const ov::element::Type& oType,
const std::vector<IT>& oValues, const std::vector<IT>& oValues,
const std::shared_ptr<ngraph::opset1::Constant>& indices, const std::shared_ptr<ov::op::v0::Constant>& indices,
const std::shared_ptr<ngraph::opset1::Constant>& segment_ids, const std::shared_ptr<ov::op::v0::Constant>& segment_ids,
const std::shared_ptr<ngraph::opset1::Constant>& num_segments, const std::shared_ptr<ov::op::v0::Constant>& num_segments,
const std::shared_ptr<ngraph::opset1::Constant>& default_index = nullptr, const std::shared_ptr<ov::op::v0::Constant>& default_index = nullptr,
const std::shared_ptr<ngraph::opset1::Constant>& per_sample_weights = nullptr) const std::shared_ptr<ov::op::v0::Constant>& per_sample_weights = nullptr)
: _iShape(iShape), : _iShape(iShape),
_iType(iType), _iType(iType),
_iData(CreateTensor(iType, iValues)), _iData(CreateTensor(iType, iValues)),
@ -46,11 +46,11 @@ struct EmbeddingSegmentsSumParams {
ov::element::Type _refType; ov::element::Type _refType;
ov::Tensor _refData; ov::Tensor _refData;
std::shared_ptr<ngraph::opset1::Constant> _indices; std::shared_ptr<ov::op::v0::Constant> _indices;
std::shared_ptr<ngraph::opset1::Constant> _segmentIds; std::shared_ptr<ov::op::v0::Constant> _segmentIds;
std::shared_ptr<ngraph::opset1::Constant> _numSegments; std::shared_ptr<ov::op::v0::Constant> _numSegments;
std::shared_ptr<ngraph::opset1::Constant> _defaultIndex; // Optional, default filled zero. std::shared_ptr<ov::op::v0::Constant> _defaultIndex; // Optional, default filled zero.
std::shared_ptr<ngraph::opset1::Constant> _perSampleWeights; // Optional, default is tensor of ones. std::shared_ptr<ov::op::v0::Constant> _perSampleWeights; // Optional, default is tensor of ones.
}; };
class ReferenceEmbeddingSegmentsSumLayerTest : public testing::TestWithParam<EmbeddingSegmentsSumParams>, class ReferenceEmbeddingSegmentsSumLayerTest : public testing::TestWithParam<EmbeddingSegmentsSumParams>,
@ -82,11 +82,11 @@ private:
static std::shared_ptr<Model> CreateFunction( static std::shared_ptr<Model> CreateFunction(
const PartialShape& input_shape, const PartialShape& input_shape,
const element::Type& input_type, const element::Type& input_type,
const std::shared_ptr<ngraph::opset1::Constant> indices, const std::shared_ptr<ov::op::v0::Constant> indices,
const std::shared_ptr<ngraph::opset1::Constant> segment_ids, const std::shared_ptr<ov::op::v0::Constant> segment_ids,
const std::shared_ptr<ngraph::opset1::Constant> num_segments, const std::shared_ptr<ov::op::v0::Constant> num_segments,
const std::shared_ptr<ngraph::opset1::Constant> default_index, const std::shared_ptr<ov::op::v0::Constant> default_index,
const std::shared_ptr<ngraph::opset1::Constant> per_sample_weights) { const std::shared_ptr<ov::op::v0::Constant> per_sample_weights) {
const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape); const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
if (default_index) { if (default_index) {
@ -128,11 +128,11 @@ INSTANTIATE_TEST_SUITE_P(
ov::PartialShape{3, 2}, ov::PartialShape{3, 2},
ov::element::f32, ov::element::f32,
{-1.05f, -1.2f, -0.2f, -0.6f, -0.1f, 0.4f}, {-1.05f, -1.2f, -0.2f, -0.6f, -0.1f, 0.4f},
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 0, 2, 2}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 0, 2, 2}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{3}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{3}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0}),
std::make_shared<ngraph::opset1::Constant>(element::f32, std::make_shared<ov::op::v0::Constant>(element::f32,
ov::Shape({4}), ov::Shape({4}),
std::vector<float>{0.5, 0.5, 0.5, 0.5})), std::vector<float>{0.5, 0.5, 0.5, 0.5})),
EmbeddingSegmentsSumParams( EmbeddingSegmentsSumParams(
@ -142,10 +142,10 @@ INSTANTIATE_TEST_SUITE_P(
ov::PartialShape{3, 2}, ov::PartialShape{3, 2},
ov::element::f64, ov::element::f64,
std::vector<double>{-2.1, -2.4, -0.2, -0.6, -0.2, 0.8}, std::vector<double>{-2.1, -2.4, -0.2, -0.6, -0.2, 0.8},
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 0, 2, 2}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 0, 2, 2}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{3}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{3}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0})), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0})),
EmbeddingSegmentsSumParams( EmbeddingSegmentsSumParams(
ov::PartialShape{5, 2}, ov::PartialShape{5, 2},
ov::element::i32, ov::element::i32,
@ -153,9 +153,9 @@ INSTANTIATE_TEST_SUITE_P(
ov::PartialShape{3, 2}, ov::PartialShape{3, 2},
ov::element::i32, ov::element::i32,
std::vector<int32_t>{-6, -4, 0, 0, 2, 18}, std::vector<int32_t>{-6, -4, 0, 0, 2, 18},
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 0, 2, 2}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 0, 2, 2}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{3})), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{3})),
EmbeddingSegmentsSumParams( EmbeddingSegmentsSumParams(
ov::PartialShape{5, 2}, ov::PartialShape{5, 2},
ov::element::u32, ov::element::u32,
@ -163,10 +163,10 @@ INSTANTIATE_TEST_SUITE_P(
ov::PartialShape{3, 2}, ov::PartialShape{3, 2},
ov::element::u32, ov::element::u32,
std::vector<uint32_t>{6, 8, 3, 4, 16, 18}, std::vector<uint32_t>{6, 8, 3, 4, 16, 18},
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 0, 2, 2}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 0, 2, 2}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{3}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{3}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{1})), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{1})),
EmbeddingSegmentsSumParams( EmbeddingSegmentsSumParams(
ov::PartialShape{5, 2}, ov::PartialShape{5, 2},
ov::element::f16, ov::element::f16,
@ -174,9 +174,9 @@ INSTANTIATE_TEST_SUITE_P(
ov::PartialShape{3, 2}, ov::PartialShape{3, 2},
ov::element::f16, ov::element::f16,
std::vector<float16>{-2.1, -2.4, 0, 0, -0.2, 0.8}, std::vector<float16>{-2.1, -2.4, 0, 0, -0.2, 0.8},
std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}), std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}),
std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 0, 2, 2}), std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 0, 2, 2}),
std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{3})), std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{3})),
EmbeddingSegmentsSumParams( EmbeddingSegmentsSumParams(
ov::PartialShape{5, 2}, ov::PartialShape{5, 2},
ov::element::i64, ov::element::i64,
@ -184,10 +184,10 @@ INSTANTIATE_TEST_SUITE_P(
ov::PartialShape{3, 2}, ov::PartialShape{3, 2},
ov::element::i64, ov::element::i64,
std::vector<int64_t>{-6, -4, -1, 2, 2, 18}, std::vector<int64_t>{-6, -4, -1, 2, 2, 18},
std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}), std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}),
std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 0, 2, 2}), std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 0, 2, 2}),
std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{3}), std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{3}),
std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{0})), std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{0})),
EmbeddingSegmentsSumParams( EmbeddingSegmentsSumParams(
ov::PartialShape{5, 2}, ov::PartialShape{5, 2},
ov::element::i8, ov::element::i8,
@ -195,11 +195,11 @@ INSTANTIATE_TEST_SUITE_P(
ov::PartialShape{3, 2}, ov::PartialShape{3, 2},
ov::element::i8, ov::element::i8,
std::vector<int8_t>{-12, -8, -1, 2, 4, 36}, std::vector<int8_t>{-12, -8, -1, 2, 4, 36},
std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}), std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}),
std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 0, 2, 2}), std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 0, 2, 2}),
std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{3}), std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{3}),
std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{0}), std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{0}),
std::make_shared<ngraph::opset1::Constant>(element::i8, ov::Shape({4}), std::vector<int8_t>{2, 2, 2, 2})), std::make_shared<ov::op::v0::Constant>(element::i8, ov::Shape({4}), std::vector<int8_t>{2, 2, 2, 2})),
EmbeddingSegmentsSumParams( EmbeddingSegmentsSumParams(
ov::PartialShape{5, 2}, ov::PartialShape{5, 2},
ov::element::u8, ov::element::u8,
@ -207,8 +207,8 @@ INSTANTIATE_TEST_SUITE_P(
ov::PartialShape{3, 2}, ov::PartialShape{3, 2},
ov::element::u8, ov::element::u8,
std::vector<uint8_t>{6, 8, 1, 2, 16, 18}, std::vector<uint8_t>{6, 8, 1, 2, 16, 18},
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 0, 2, 2}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 0, 2, 2}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{3}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{3}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0}))), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0}))),
ReferenceEmbeddingSegmentsSumLayerTest::getTestCaseName); ReferenceEmbeddingSegmentsSumLayerTest::getTestCaseName);

72
src/plugins/template/tests/functional/op_reference/embeddingbag_offsetssum.cpp
View File

@ -20,10 +20,10 @@ struct EmbeddingBagOffsetsSumParams {
const ov::PartialShape& oShape, const ov::PartialShape& oShape,
const ov::element::Type& oType, const ov::element::Type& oType,
const std::vector<IT>& oValues, const std::vector<IT>& oValues,
const std::shared_ptr<ngraph::opset1::Constant>& indices, const std::shared_ptr<ov::op::v0::Constant>& indices,
const std::shared_ptr<ngraph::opset1::Constant>& offsets, const std::shared_ptr<ov::op::v0::Constant>& offsets,
const std::shared_ptr<ngraph::opset1::Constant>& default_index = nullptr, const std::shared_ptr<ov::op::v0::Constant>& default_index = nullptr,
const std::shared_ptr<ngraph::opset1::Constant>& per_sample_weights = nullptr) const std::shared_ptr<ov::op::v0::Constant>& per_sample_weights = nullptr)
: _iShape(iShape), : _iShape(iShape),
_iType(iType), _iType(iType),
_iData(CreateTensor(iType, iValues)), _iData(CreateTensor(iType, iValues)),
@ -43,10 +43,10 @@ struct EmbeddingBagOffsetsSumParams {
ov::element::Type _refType; ov::element::Type _refType;
ov::Tensor _refData; ov::Tensor _refData;
std::shared_ptr<ngraph::opset1::Constant> _indices; std::shared_ptr<ov::op::v0::Constant> _indices;
std::shared_ptr<ngraph::opset1::Constant> _offsets; std::shared_ptr<ov::op::v0::Constant> _offsets;
std::shared_ptr<ngraph::opset1::Constant> _defaultIndex; // Optional, default filled zero. std::shared_ptr<ov::op::v0::Constant> _defaultIndex; // Optional, default filled zero.
std::shared_ptr<ngraph::opset1::Constant> _perSampleWeights; // Optional, default is tensor of ones. std::shared_ptr<ov::op::v0::Constant> _perSampleWeights; // Optional, default is tensor of ones.
}; };
class ReferenceEmbeddingBagOffsetsSumLayerTest : public testing::TestWithParam<EmbeddingBagOffsetsSumParams>, class ReferenceEmbeddingBagOffsetsSumLayerTest : public testing::TestWithParam<EmbeddingBagOffsetsSumParams>,
@ -77,10 +77,10 @@ private:
static std::shared_ptr<ov::Model> CreateFunction( static std::shared_ptr<ov::Model> CreateFunction(
const PartialShape& input_shape, const PartialShape& input_shape,
const element::Type& input_type, const element::Type& input_type,
const std::shared_ptr<ngraph::opset1::Constant> indices, const std::shared_ptr<ov::op::v0::Constant> indices,
const std::shared_ptr<ngraph::opset1::Constant> offsets, const std::shared_ptr<ov::op::v0::Constant> offsets,
const std::shared_ptr<ngraph::opset1::Constant> default_index, const std::shared_ptr<ov::op::v0::Constant> default_index,
const std::shared_ptr<ngraph::opset1::Constant> per_sample_weights) { const std::shared_ptr<ov::op::v0::Constant> per_sample_weights) {
const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape); const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
if (default_index) { if (default_index) {
@ -117,10 +117,10 @@ INSTANTIATE_TEST_SUITE_P(
ov::PartialShape{3, 2}, ov::PartialShape{3, 2},
ov::element::f32, ov::element::f32,
{-1.05f, -1.2f, -0.2f, -0.6f, -0.1f, 0.4f}, {-1.05f, -1.2f, -0.2f, -0.6f, -0.1f, 0.4f},
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({3}), std::vector<int32_t>{0, 2, 2}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({3}), std::vector<int32_t>{0, 2, 2}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0}),
std::make_shared<ngraph::opset1::Constant>(element::f32, std::make_shared<ov::op::v0::Constant>(element::f32,
ov::Shape({4}), ov::Shape({4}),
std::vector<float>{0.5, 0.5, 0.5, 0.5})), std::vector<float>{0.5, 0.5, 0.5, 0.5})),
EmbeddingBagOffsetsSumParams( EmbeddingBagOffsetsSumParams(
@ -130,9 +130,9 @@ INSTANTIATE_TEST_SUITE_P(
ov::PartialShape{3, 2}, ov::PartialShape{3, 2},
ov::element::f64, ov::element::f64,
std::vector<double>{-2.1, -2.4, -0.2, -0.6, -0.2, 0.8}, std::vector<double>{-2.1, -2.4, -0.2, -0.6, -0.2, 0.8},
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({3}), std::vector<int32_t>{0, 2, 2}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({3}), std::vector<int32_t>{0, 2, 2}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0})), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0})),
EmbeddingBagOffsetsSumParams( EmbeddingBagOffsetsSumParams(
ov::PartialShape{5, 2}, ov::PartialShape{5, 2},
ov::element::i32, ov::element::i32,
@ -140,8 +140,8 @@ INSTANTIATE_TEST_SUITE_P(
ov::PartialShape{3, 2}, ov::PartialShape{3, 2},
ov::element::i32, ov::element::i32,
std::vector<int32_t>{-6, -4, 0, 0, 2, 18}, std::vector<int32_t>{-6, -4, 0, 0, 2, 18},
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({3}), std::vector<int32_t>{0, 2, 2})), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({3}), std::vector<int32_t>{0, 2, 2})),
EmbeddingBagOffsetsSumParams( EmbeddingBagOffsetsSumParams(
ov::PartialShape{5, 2}, ov::PartialShape{5, 2},
ov::element::u32, ov::element::u32,
@ -149,9 +149,9 @@ INSTANTIATE_TEST_SUITE_P(
ov::PartialShape{3, 2}, ov::PartialShape{3, 2},
ov::element::u32, ov::element::u32,
std::vector<uint32_t>{6, 8, 3, 4, 16, 18}, std::vector<uint32_t>{6, 8, 3, 4, 16, 18},
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({3}), std::vector<int32_t>{0, 2, 2}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({3}), std::vector<int32_t>{0, 2, 2}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{1})), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{1})),
EmbeddingBagOffsetsSumParams( EmbeddingBagOffsetsSumParams(
ov::PartialShape{5, 2}, ov::PartialShape{5, 2},
ov::element::f16, ov::element::f16,
@ -159,8 +159,8 @@ INSTANTIATE_TEST_SUITE_P(
ov::PartialShape{3, 2}, ov::PartialShape{3, 2},
ov::element::f16, ov::element::f16,
std::vector<float16>{-2.1, -2.4, 0, 0, -0.2, 0.8}, std::vector<float16>{-2.1, -2.4, 0, 0, -0.2, 0.8},
std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}), std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}),
std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({3}), std::vector<int64_t>{0, 2, 2})), std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({3}), std::vector<int64_t>{0, 2, 2})),
EmbeddingBagOffsetsSumParams( EmbeddingBagOffsetsSumParams(
ov::PartialShape{5, 2}, ov::PartialShape{5, 2},
ov::element::i64, ov::element::i64,
@ -168,9 +168,9 @@ INSTANTIATE_TEST_SUITE_P(
ov::PartialShape{3, 2}, ov::PartialShape{3, 2},
ov::element::i64, ov::element::i64,
std::vector<int64_t>{-6, -4, -1, 2, 2, 18}, std::vector<int64_t>{-6, -4, -1, 2, 2, 18},
std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}), std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}),
std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({3}), std::vector<int64_t>{0, 2, 2}), std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({3}), std::vector<int64_t>{0, 2, 2}),
std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{0})), std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{0})),
EmbeddingBagOffsetsSumParams( EmbeddingBagOffsetsSumParams(
ov::PartialShape{5, 2}, ov::PartialShape{5, 2},
ov::element::i8, ov::element::i8,
@ -178,10 +178,10 @@ INSTANTIATE_TEST_SUITE_P(
ov::PartialShape{3, 2}, ov::PartialShape{3, 2},
ov::element::i8, ov::element::i8,
std::vector<int8_t>{-12, -8, -1, 2, 4, 36}, std::vector<int8_t>{-12, -8, -1, 2, 4, 36},
std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}), std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}),
std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({3}), std::vector<int64_t>{0, 2, 2}), std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({3}), std::vector<int64_t>{0, 2, 2}),
std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{0}), std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{0}),
std::make_shared<ngraph::opset1::Constant>(element::i8, ov::Shape({4}), std::vector<int8_t>{2, 2, 2, 2})), std::make_shared<ov::op::v0::Constant>(element::i8, ov::Shape({4}), std::vector<int8_t>{2, 2, 2, 2})),
EmbeddingBagOffsetsSumParams( EmbeddingBagOffsetsSumParams(
ov::PartialShape{5, 2}, ov::PartialShape{5, 2},
ov::element::u8, ov::element::u8,
@ -189,7 +189,7 @@ INSTANTIATE_TEST_SUITE_P(
ov::PartialShape{3, 2}, ov::PartialShape{3, 2},
ov::element::u8, ov::element::u8,
std::vector<uint8_t>{6, 8, 1, 2, 16, 18}, std::vector<uint8_t>{6, 8, 1, 2, 16, 18},
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({3}), std::vector<int32_t>{0, 2, 2}), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({3}), std::vector<int32_t>{0, 2, 2}),
std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0}))), std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0}))),
ReferenceEmbeddingBagOffsetsSumLayerTest::getTestCaseName); ReferenceEmbeddingBagOffsetsSumLayerTest::getTestCaseName);

18
src/plugins/template/tests/functional/op_reference/embeddingbag_packedsum.cpp
View File

@ -20,8 +20,8 @@ struct EmbeddingBagPackedSumParams {
const ov::PartialShape& oShape, const ov::PartialShape& oShape,
const ov::element::Type& oType, const ov::element::Type& oType,
const std::vector<IT>& oValues, const std::vector<IT>& oValues,
const std::shared_ptr<ngraph::opset1::Constant>& indices, const std::shared_ptr<ov::op::v0::Constant>& indices,
const std::shared_ptr<ngraph::opset1::Constant>& per_sample_weights = nullptr) const std::shared_ptr<ov::op::v0::Constant>& per_sample_weights = nullptr)
: _iShape(iShape), : _iShape(iShape),
_iType(iType), _iType(iType),
_iData(CreateTensor(iType, iValues)), _iData(CreateTensor(iType, iValues)),
@ -39,8 +39,8 @@ struct EmbeddingBagPackedSumParams {
ov::element::Type _refType; ov::element::Type _refType;
ov::Tensor _refData; ov::Tensor _refData;
std::shared_ptr<ngraph::opset1::Constant> _indices; std::shared_ptr<ov::op::v0::Constant> _indices;
std::shared_ptr<ngraph::opset1::Constant> _perSampleWeights; // Optional, default is tensor of ones. std::shared_ptr<ov::op::v0::Constant> _perSampleWeights; // Optional, default is tensor of ones.
}; };
class ReferenceEmbeddingBagPackedSumLayerTest : public testing::TestWithParam<EmbeddingBagPackedSumParams>, class ReferenceEmbeddingBagPackedSumLayerTest : public testing::TestWithParam<EmbeddingBagPackedSumParams>,
@ -66,8 +66,8 @@ private:
static std::shared_ptr<Model> CreateFunction( static std::shared_ptr<Model> CreateFunction(
const PartialShape& input_shape, const PartialShape& input_shape,
const element::Type& input_type, const element::Type& input_type,
const std::shared_ptr<ngraph::opset1::Constant> indices, const std::shared_ptr<ov::op::v0::Constant> indices,
const std::shared_ptr<ngraph::opset1::Constant> per_sample_weights) { const std::shared_ptr<ov::op::v0::Constant> per_sample_weights) {
const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape); const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
if (per_sample_weights) { if (per_sample_weights) {
@ -85,7 +85,7 @@ TEST_P(ReferenceEmbeddingBagPackedSumLayerTest, CompareWithRefs) {
} }
template <class T> template <class T>
inline std::shared_ptr<ngraph::opset1::Constant> CreateConstant(const std::vector<std::vector<T>>& val, inline std::shared_ptr<ov::op::v0::Constant> CreateConstant(const std::vector<std::vector<T>>& val,
const ov::element::Type& element_type) { const ov::element::Type& element_type) {
if (val.size() > 0) { if (val.size() > 0) {
ov::Shape i_shape({val.size(), val[0].size()}); ov::Shape i_shape({val.size(), val[0].size()});
@ -99,9 +99,9 @@ inline std::shared_ptr<ngraph::opset1::Constant> CreateConstant(const std::vecto
} }
} }
return std::make_shared<ngraph::opset1::Constant>(element_type, i_shape, i_values); return std::make_shared<ov::op::v0::Constant>(element_type, i_shape, i_values);
} else { } else {
return std::make_shared<ngraph::opset1::Constant>(element_type, ov::Shape(), std::vector<T>()); return std::make_shared<ov::op::v0::Constant>(element_type, ov::Shape(), std::vector<T>());
} }
} }

1
src/plugins/template/tests/functional/op_reference/equal.cpp
View File

@ -8,7 +8,6 @@
#include "comparison.hpp" #include "comparison.hpp"
using namespace ov; using namespace ov;
using ComparisonTypes = ngraph::helpers::ComparisonTypes;
namespace reference_tests { namespace reference_tests {
namespace ComparisonOpsRefTestDefinitions { namespace ComparisonOpsRefTestDefinitions {

16
src/plugins/template/tests/functional/op_reference/experimental_detectron_roi_feature_extractor.cpp
View File

@ -127,13 +127,13 @@ INSTANTIATE_TEST_SUITE_P(
ExperimentalROIParams( ExperimentalROIParams(
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{2, 4}, std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{2, 4},
ov::element::f16, ov::element::f16,
std::vector<ngraph::float16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0}), std::vector<ov::float16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0}),
reference_tests::Tensor(Shape{1, 2, 2, 3}, reference_tests::Tensor(Shape{1, 2, 2, 3},
ov::element::f16, ov::element::f16,
std::vector<ngraph::float16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0})}, std::vector<ov::float16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0})},
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{2, 2, 3, 3}, std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{2, 2, 3, 3},
ov::element::f16, ov::element::f16,
std::vector<ngraph::float16>{1.416667, std::vector<ov::float16>{1.416667,
1.75, 1.75,
2.083333, 2.083333,
2.416667, 2.416667,
@ -171,18 +171,18 @@ INSTANTIATE_TEST_SUITE_P(
5.416667}), 5.416667}),
reference_tests::Tensor(Shape{2, 4}, reference_tests::Tensor(Shape{2, 4},
ov::element::f16, ov::element::f16,
std::vector<ngraph::float16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0})}, std::vector<ov::float16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0})},
"experimental_detectron_roi_feature_eval_f16"), "experimental_detectron_roi_feature_eval_f16"),
ExperimentalROIParams( ExperimentalROIParams(
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{2, 4}, std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{2, 4},
ov::element::bf16, ov::element::bf16,
std::vector<ngraph::bfloat16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0}), std::vector<ov::bfloat16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0}),
reference_tests::Tensor(Shape{1, 2, 2, 3}, reference_tests::Tensor(Shape{1, 2, 2, 3},
ov::element::bf16, ov::element::bf16,
std::vector<ngraph::bfloat16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0})}, std::vector<ov::bfloat16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0})},
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{2, 2, 3, 3}, std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{2, 2, 3, 3},
ov::element::bf16, ov::element::bf16,
std::vector<ngraph::bfloat16>{1.416667, std::vector<ov::bfloat16>{1.416667,
1.75, 1.75,
2.083333, 2.083333,
2.416667, 2.416667,
@ -220,5 +220,5 @@ INSTANTIATE_TEST_SUITE_P(
5.416667}), 5.416667}),
reference_tests::Tensor(Shape{2, 4}, reference_tests::Tensor(Shape{2, 4},
ov::element::bf16, ov::element::bf16,
std::vector<ngraph::bfloat16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0})}, std::vector<ov::bfloat16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0})},
"experimental_detectron_roi_feature_eval_bf16"))); "experimental_detectron_roi_feature_eval_bf16")));

1
src/plugins/template/tests/functional/op_reference/greater.cpp
View File

@ -8,7 +8,6 @@
#include "comparison.hpp" #include "comparison.hpp"
using namespace ov; using namespace ov;
using ComparisonTypes = ngraph::helpers::ComparisonTypes;
namespace reference_tests { namespace reference_tests {
namespace ComparisonOpsRefTestDefinitions { namespace ComparisonOpsRefTestDefinitions {

1
src/plugins/template/tests/functional/op_reference/greater_equal.cpp
View File

@ -8,7 +8,6 @@
#include "comparison.hpp" #include "comparison.hpp"
using namespace ov; using namespace ov;
using ComparisonTypes = ngraph::helpers::ComparisonTypes;
namespace reference_tests { namespace reference_tests {
namespace ComparisonOpsRefTestDefinitions { namespace ComparisonOpsRefTestDefinitions {

6
src/plugins/template/tests/functional/op_reference/hard_sigmoid.cpp
View File

@ -3,10 +3,10 @@
// //
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include <ngraph/ngraph.hpp>
#include "openvino/op/hard_sigmoid.hpp" #include "openvino/op/hard_sigmoid.hpp"
#include "base_reference_test.hpp" #include "base_reference_test.hpp"
#include "openvino/op/constant.hpp"
using namespace reference_tests; using namespace reference_tests;
using namespace ov; using namespace ov;
@ -60,8 +60,8 @@ private:
alphaArray.push_back(alphaData); alphaArray.push_back(alphaData);
betaArray.push_back(betaData); betaArray.push_back(betaData);
const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape); const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
const auto alpha = ngraph::op::Constant::create(input_type, Shape{}, {alphaData}); const auto alpha = ov::op::v0::Constant::create(input_type, Shape{}, {alphaData});
const auto beta = ngraph::op::Constant::create(input_type, Shape{}, {betaData}); const auto beta = ov::op::v0::Constant::create(input_type, Shape{}, {betaData});
const auto HardSigmoid = std::make_shared<op::v0::HardSigmoid>(in, alpha, beta); const auto HardSigmoid = std::make_shared<op::v0::HardSigmoid>(in, alpha, beta);
return std::make_shared<ov::Model>(NodeVector {HardSigmoid}, ParameterVector {in}); return std::make_shared<ov::Model>(NodeVector {HardSigmoid}, ParameterVector {in});
} }

140
src/plugins/template/tests/functional/op_reference/if.cpp
View File

@ -6,9 +6,7 @@
#include <algorithm> #include <algorithm>
#include <ie_core.hpp> #include <ie_core.hpp>
#include <ie_ngraph_utils.hpp>
#include <limits> #include <limits>
#include <ngraph/ngraph.hpp>
#include <shared_test_classes/base/layer_test_utils.hpp> #include <shared_test_classes/base/layer_test_utils.hpp>
#include "base_reference_test.hpp" #include "base_reference_test.hpp"
@ -26,12 +24,12 @@ struct IfFunctionalBase {
struct IfCondConst : public IfFunctionalBase { struct IfCondConst : public IfFunctionalBase {
std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs, std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs,
const std::vector<reference_tests::Tensor>& results) override { const std::vector<reference_tests::Tensor>& results) override {
NGRAPH_CHECK(if_inputs.size() == 2, "Incorrect test case! Number of inputs is not 2."); OPENVINO_ASSERT(if_inputs.size() == 2, "Incorrect test case! Number of inputs is not 2.");
NGRAPH_CHECK(results.size() == 1, "Incorrect test case! Number of outputs is not 1."); OPENVINO_ASSERT(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
auto X = std::make_shared<op::v0::Parameter>(if_inputs[0].type, if_inputs[0].shape); auto X = std::make_shared<op::v0::Parameter>(if_inputs[0].type, if_inputs[0].shape);
auto Y = std::make_shared<op::v0::Parameter>(if_inputs[1].type, if_inputs[1].shape); auto Y = std::make_shared<op::v0::Parameter>(if_inputs[1].type, if_inputs[1].shape);
auto cond = std::make_shared<op::v0::Constant>(ngraph::element::boolean, Shape{1}, cond_value); auto cond = std::make_shared<op::v0::Constant>(ov::element::boolean, Shape{1}, cond_value);
auto Xt = std::make_shared<op::v0::Parameter>(if_inputs[0].type, PartialShape::dynamic()); auto Xt = std::make_shared<op::v0::Parameter>(if_inputs[0].type, PartialShape::dynamic());
auto Yt = std::make_shared<op::v0::Parameter>(if_inputs[1].type, PartialShape::dynamic()); auto Yt = std::make_shared<op::v0::Parameter>(if_inputs[1].type, PartialShape::dynamic());
auto Xe = std::make_shared<op::v0::Parameter>(if_inputs[0].type, PartialShape::dynamic()); auto Xe = std::make_shared<op::v0::Parameter>(if_inputs[0].type, PartialShape::dynamic());
@ -58,8 +56,8 @@ struct IfCondConst : public IfFunctionalBase {
struct IfCondIsNonConst : public IfFunctionalBase { struct IfCondIsNonConst : public IfFunctionalBase {
std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs, std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs,
const std::vector<reference_tests::Tensor>& results) override { const std::vector<reference_tests::Tensor>& results) override {
NGRAPH_CHECK(if_inputs.size() == 3, "Incorrect test case! Number of inputs is not 3."); OPENVINO_ASSERT(if_inputs.size() == 3, "Incorrect test case! Number of inputs is not 3.");
NGRAPH_CHECK(results.size() == 1, "Incorrect test case! Number of outputs is not 1."); OPENVINO_ASSERT(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
auto X = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2}); auto X = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
auto Y = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2}); auto Y = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
@ -92,8 +90,8 @@ struct IfCondIsNonConst : public IfFunctionalBase {
struct IfWithoutAdditionalInputs : IfFunctionalBase { struct IfWithoutAdditionalInputs : IfFunctionalBase {
std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs, std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs,
const std::vector<reference_tests::Tensor>& results) override { const std::vector<reference_tests::Tensor>& results) override {
NGRAPH_CHECK(if_inputs.size() == 1, "Incorrect test case! Number of inputs is not 1."); OPENVINO_ASSERT(if_inputs.size() == 1, "Incorrect test case! Number of inputs is not 1.");
NGRAPH_CHECK(results.size() == 1, "Incorrect test case! Number of outputs is not 1."); OPENVINO_ASSERT(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
auto cond = std::make_shared<op::v0::Parameter>(element::boolean, Shape{1}); auto cond = std::make_shared<op::v0::Parameter>(element::boolean, Shape{1});
auto A = std::make_shared<op::v0::Constant>(element::f32, Shape{1}, 8.0); auto A = std::make_shared<op::v0::Constant>(element::f32, Shape{1}, 8.0);
@ -114,8 +112,8 @@ struct IfWithoutAdditionalInputs : IfFunctionalBase {
struct IfDynamismCaseWithStaticInputs : public IfFunctionalBase { struct IfDynamismCaseWithStaticInputs : public IfFunctionalBase {
std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs, std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs,
const std::vector<reference_tests::Tensor>& results) override { const std::vector<reference_tests::Tensor>& results) override {
NGRAPH_CHECK(if_inputs.size() == 4, "Incorrect test case! Number of inputs is not 4."); OPENVINO_ASSERT(if_inputs.size() == 4, "Incorrect test case! Number of inputs is not 4.");
NGRAPH_CHECK(results.size() == 2, "Incorrect test case! Number of outputs is not 2."); OPENVINO_ASSERT(results.size() == 2, "Incorrect test case! Number of outputs is not 2.");
auto X = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2}); auto X = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
auto Y = std::make_shared<op::v0::Parameter>(element::f32, Shape{4, 2, 2}); auto Y = std::make_shared<op::v0::Parameter>(element::f32, Shape{4, 2, 2});
@ -156,8 +154,8 @@ struct IfDynamismCaseWithStaticInputs : public IfFunctionalBase {
struct IfConditionIsScalar : public IfFunctionalBase { struct IfConditionIsScalar : public IfFunctionalBase {
std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs, std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs,
const std::vector<reference_tests::Tensor>& results) override { const std::vector<reference_tests::Tensor>& results) override {
NGRAPH_CHECK(if_inputs.size() == 3, "Incorrect test case! Number of inputs is not 3."); OPENVINO_ASSERT(if_inputs.size() == 3, "Incorrect test case! Number of inputs is not 3.");
NGRAPH_CHECK(results.size() == 1, "Incorrect test case! Number of outputs is not 1."); OPENVINO_ASSERT(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
auto X = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2}); auto X = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
auto Y = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2}); auto Y = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
@ -192,8 +190,8 @@ struct IfConditionIsScalar : public IfFunctionalBase {
struct IfConditionIsDynamic : public IfFunctionalBase { struct IfConditionIsDynamic : public IfFunctionalBase {
std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs, std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs,
const std::vector<reference_tests::Tensor>& results) override { const std::vector<reference_tests::Tensor>& results) override {
NGRAPH_CHECK(if_inputs.size() == 3, "Incorrect test case! Number of inputs is not 3."); OPENVINO_ASSERT(if_inputs.size() == 3, "Incorrect test case! Number of inputs is not 3.");
NGRAPH_CHECK(results.size() == 1, "Incorrect test case! Number of outputs is not 1."); OPENVINO_ASSERT(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
auto X = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2}); auto X = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
auto Y = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2}); auto Y = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
@ -227,8 +225,8 @@ struct IfConditionIsDynamic : public IfFunctionalBase {
struct IfDynamicInputs : public IfFunctionalBase { struct IfDynamicInputs : public IfFunctionalBase {
std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs, std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs,
const std::vector<reference_tests::Tensor>& results) override { const std::vector<reference_tests::Tensor>& results) override {
NGRAPH_CHECK(if_inputs.size() == 3, "Incorrect test case! Number of inputs is not 3."); OPENVINO_ASSERT(if_inputs.size() == 3, "Incorrect test case! Number of inputs is not 3.");
NGRAPH_CHECK(results.size() == 1, "Incorrect test case! Number of outputs is not 1."); OPENVINO_ASSERT(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
auto X = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic()); auto X = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Y = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic()); auto Y = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic());
@ -322,95 +320,95 @@ INSTANTIATE_TEST_SUITE_P(
::testing::Values( ::testing::Values(
IfParams( IfParams(
std::make_shared<IfCondConst>(true), std::make_shared<IfCondConst>(true),
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 1.0, 1.0, 1.0}), std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 1.0, 1.0, 1.0}),
reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 2.0, 2.0, 2.0})}, reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 2.0, 2.0, 2.0})},
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 2.0, 2.0, 2.0})}, std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 2.0, 2.0, 2.0})},
"if_condition_const_is_true"), "if_condition_const_is_true"),
IfParams( IfParams(
std::make_shared<IfCondConst>(false), std::make_shared<IfCondConst>(false),
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 1.0, 1.0, 1.0}), std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 1.0, 1.0, 1.0}),
reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 2.0, 2.0, 2.0})}, reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 2.0, 2.0, 2.0})},
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 1.0, 1.0, 1.0})}, std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 1.0, 1.0, 1.0})},
"if_condition_const_is_false"), "if_condition_const_is_false"),
IfParams( IfParams(
std::make_shared<IfCondIsNonConst>(), std::make_shared<IfCondIsNonConst>(),
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ngraph::element::boolean, std::vector<unsigned char>{1}), std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ov::element::boolean, std::vector<unsigned char>{1}),
reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}), reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})}, reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 2.0, 6.0, 12.0})}, std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 2.0, 6.0, 12.0})},
"if_condition_si_non_const_true"), "if_condition_si_non_const_true"),
IfParams( IfParams(
std::make_shared<IfCondIsNonConst>(), std::make_shared<IfCondIsNonConst>(),
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ngraph::element::boolean, std::vector<unsigned char>{0}), std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ov::element::boolean, std::vector<unsigned char>{0}),
reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}), reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})}, reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{3.0, 3.0, 5.0, 7.0})}, std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{3.0, 3.0, 5.0, 7.0})},
"if_condition_is_non_const_false"), "if_condition_is_non_const_false"),
IfParams(std::make_shared<IfWithoutAdditionalInputs>(), IfParams(std::make_shared<IfWithoutAdditionalInputs>(),
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ngraph::element::boolean, std::vector<unsigned char>{1})}, std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ov::element::boolean, std::vector<unsigned char>{1})},
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ngraph::element::f32, std::vector<float>{8.0})}, std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ov::element::f32, std::vector<float>{8.0})},
"if_without_addition_inputs_condition_is_true"), "if_without_addition_inputs_condition_is_true"),
IfParams(std::make_shared<IfWithoutAdditionalInputs>(), IfParams(std::make_shared<IfWithoutAdditionalInputs>(),
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ngraph::element::boolean, std::vector<unsigned char>{0})}, std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ov::element::boolean, std::vector<unsigned char>{0})},
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ngraph::element::f32, std::vector<float>{2.0})}, std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ov::element::f32, std::vector<float>{2.0})},
"if_without_addition_inputs_condition_is_false"), "if_without_addition_inputs_condition_is_false"),
IfParams( IfParams(
std::make_shared<IfConditionIsScalar>(), std::make_shared<IfConditionIsScalar>(),
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ngraph::element::boolean, std::vector<unsigned char>{1}), std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ov::element::boolean, std::vector<unsigned char>{1}),
reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}), reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})}, reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 2.0, 6.0, 12.0})}, std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 2.0, 6.0, 12.0})},
"if_condition_is_scalar_cond_true"), "if_condition_is_scalar_cond_true"),
IfParams( IfParams(
std::make_shared<IfConditionIsScalar>(), std::make_shared<IfConditionIsScalar>(),
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ngraph::element::boolean, std::vector<unsigned char>{0}), std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ov::element::boolean, std::vector<unsigned char>{0}),
reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}), reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})}, reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{3.0, 3.0, 5.0, 7.0})}, std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{3.0, 3.0, 5.0, 7.0})},
"if_condition_is_scalar_cond_false"), "if_condition_is_scalar_cond_false"),
IfParams( IfParams(
std::make_shared<IfDynamismCaseWithStaticInputs>(), std::make_shared<IfDynamismCaseWithStaticInputs>(),
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ngraph::element::boolean, std::vector<unsigned char>{1}), std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ov::element::boolean, std::vector<unsigned char>{1}),
reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}), reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
reference_tests::Tensor(Shape{4, 2, 2}, ngraph::element::f32, Y_gen()), reference_tests::Tensor(Shape{4, 2, 2}, ov::element::f32, Y_gen()),
reference_tests::Tensor(Shape{8, 8, 8}, ngraph::element::f32, Z_gen())}, reference_tests::Tensor(Shape{8, 8, 8}, ov::element::f32, Z_gen())},
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 4.0, 9.0, 16.0}), std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 4.0, 9.0, 16.0}),
reference_tests::Tensor(Shape{4, 2, 2}, ngraph::element::f32, Y_gen())}, reference_tests::Tensor(Shape{4, 2, 2}, ov::element::f32, Y_gen())},
"If_dynamism_case_with_static_inputs_condition_true"), "If_dynamism_case_with_static_inputs_condition_true"),
IfParams( IfParams(
std::make_shared<IfDynamismCaseWithStaticInputs>(), std::make_shared<IfDynamismCaseWithStaticInputs>(),
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ngraph::element::boolean, std::vector<unsigned char>{0}), std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ov::element::boolean, std::vector<unsigned char>{0}),
reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}), reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
reference_tests::Tensor(Shape{4, 2, 2}, ngraph::element::f32, Y_gen()), reference_tests::Tensor(Shape{4, 2, 2}, ov::element::f32, Y_gen()),
reference_tests::Tensor(Shape{8, 8, 8}, ngraph::element::f32, Z_gen())}, reference_tests::Tensor(Shape{8, 8, 8}, ov::element::f32, Z_gen())},
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 4.0, 6.0, 8.0}), std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 4.0, 6.0, 8.0}),
reference_tests::Tensor(Shape{8, 8, 8}, ngraph::element::f32, Z_gen())}, reference_tests::Tensor(Shape{8, 8, 8}, ov::element::f32, Z_gen())},
"If_dynamism_case_with_static_inputs_condition_false"), "If_dynamism_case_with_static_inputs_condition_false"),
IfParams( IfParams(
std::make_shared<IfConditionIsDynamic>(), std::make_shared<IfConditionIsDynamic>(),
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ngraph::element::boolean, std::vector<unsigned char>{1}), std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ov::element::boolean, std::vector<unsigned char>{1}),
reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}), reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})}, reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 2.0, 6.0, 12.0})}, std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 2.0, 6.0, 12.0})},
"if_condition_is_dynamic_cond_true"), "if_condition_is_dynamic_cond_true"),
IfParams( IfParams(
std::make_shared<IfConditionIsDynamic>(), std::make_shared<IfConditionIsDynamic>(),
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ngraph::element::boolean, std::vector<unsigned char>{0}), std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ov::element::boolean, std::vector<unsigned char>{0}),
reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}), reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})}, reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{3.0, 3.0, 5.0, 7.0})}, std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{3.0, 3.0, 5.0, 7.0})},
"if_condition_is_dynamic_cond_false"), "if_condition_is_dynamic_cond_false"),
IfParams( IfParams(
std::make_shared<IfDynamicInputs>(), std::make_shared<IfDynamicInputs>(),
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ngraph::element::boolean, std::vector<unsigned char>{1}), std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ov::element::boolean, std::vector<unsigned char>{1}),
reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}), reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})}, reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 2.0, 6.0, 12.0})}, std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 2.0, 6.0, 12.0})},
"if_dynamic_inputs_cond_true"), "if_dynamic_inputs_cond_true"),
IfParams( IfParams(
std::make_shared<IfDynamicInputs>(), std::make_shared<IfDynamicInputs>(),
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ngraph::element::boolean, std::vector<unsigned char>{0}), std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ov::element::boolean, std::vector<unsigned char>{0}),
reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}), reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})}, reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{3.0, 3.0, 5.0, 7.0})}, std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{3.0, 3.0, 5.0, 7.0})},
"if_dynamic_inputs_cond_false"))); "if_dynamic_inputs_cond_false")));

1
src/plugins/template/tests/functional/op_reference/less.cpp
View File

@ -8,7 +8,6 @@
#include "comparison.hpp" #include "comparison.hpp"
using namespace ov; using namespace ov;
using ComparisonTypes = ngraph::helpers::ComparisonTypes;
namespace reference_tests { namespace reference_tests {
namespace ComparisonOpsRefTestDefinitions { namespace ComparisonOpsRefTestDefinitions {

1
src/plugins/template/tests/functional/op_reference/less_eq.cpp
View File

@ -8,7 +8,6 @@
#include "comparison.hpp" #include "comparison.hpp"
using namespace ov; using namespace ov;
using ComparisonTypes = ngraph::helpers::ComparisonTypes;
namespace reference_tests { namespace reference_tests {
namespace ComparisonOpsRefTestDefinitions { namespace ComparisonOpsRefTestDefinitions {

40
src/plugins/template/tests/functional/op_reference/logical.hpp
View File

@ -5,15 +5,26 @@
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include "base_reference_test.hpp" #include "base_reference_test.hpp"
#include "ngraph_functions/builders.hpp"
#include "openvino/op/logical_and.hpp"
#include "openvino/op/logical_not.hpp"
#include "openvino/op/logical_or.hpp"
#include "openvino/op/logical_xor.hpp"
using namespace ov; using namespace ov;
namespace reference_tests { namespace reference_tests {
namespace LogicalOpsRefTestDefinitions { namespace LogicalOpsRefTestDefinitions {
enum LogicalTypes {
LOGICAL_AND,
LOGICAL_OR,
LOGICAL_XOR,
LOGICAL_NOT
};
struct RefLogicalParams { struct RefLogicalParams {
ngraph::helpers::LogicalTypes opType; LogicalTypes opType;
std::vector<reference_tests::Tensor> inputs; std::vector<reference_tests::Tensor> inputs;
reference_tests::Tensor expected; reference_tests::Tensor expected;
}; };
@ -48,13 +59,34 @@ public:
} }
private: private:
static std::shared_ptr<ov::Model> CreateFunction(ngraph::helpers::LogicalTypes op_type, const std::vector<reference_tests::Tensor>& inputs) { static std::shared_ptr<ov::Model> CreateFunction(LogicalTypes op_type, const std::vector<reference_tests::Tensor>& inputs) {
ov::ParameterVector params_vec; ov::ParameterVector params_vec;
for (auto& input : inputs) { for (auto& input : inputs) {
params_vec.push_back(std::make_shared<op::v0::Parameter>(input.type, input.shape)); params_vec.push_back(std::make_shared<op::v0::Parameter>(input.type, input.shape));
} }
const auto logical_op = ngraph::builder::makeLogical(params_vec, op_type); std::shared_ptr<ov::Node> logical_op;
switch (op_type) {
case LogicalTypes::LOGICAL_AND: {
logical_op = std::make_shared<ov::op::v1::LogicalAnd>(params_vec[0], params_vec[1]);
break;
}
case LogicalTypes::LOGICAL_OR: {
logical_op = std::make_shared<ov::op::v1::LogicalOr>(params_vec[0], params_vec[1]);
break;
}
case LogicalTypes::LOGICAL_NOT: {
logical_op = std::make_shared<ov::op::v1::LogicalNot>(params_vec[0]);
break;
}
case LogicalTypes::LOGICAL_XOR: {
logical_op = std::make_shared<ov::op::v1::LogicalXor>(params_vec[0], params_vec[1]);
break;
}
default: {
throw std::runtime_error("Incorrect type of Logical operation");
}
}
return std::make_shared<ov::Model>(ov::NodeVector {logical_op}, ov::ParameterVector {params_vec}); return std::make_shared<ov::Model>(ov::NodeVector {logical_op}, ov::ParameterVector {params_vec});
} }
}; };

1
src/plugins/template/tests/functional/op_reference/logical_and.cpp
View File

@ -8,7 +8,6 @@
#include "logical.hpp" #include "logical.hpp"
using namespace ov; using namespace ov;
using LogicalTypes = ngraph::helpers::LogicalTypes;
namespace reference_tests { namespace reference_tests {
namespace LogicalOpsRefTestDefinitions { namespace LogicalOpsRefTestDefinitions {

1
src/plugins/template/tests/functional/op_reference/logical_not.cpp
View File

@ -8,7 +8,6 @@
#include "logical.hpp" #include "logical.hpp"
using namespace ov; using namespace ov;
using LogicalTypes = ngraph::helpers::LogicalTypes;
namespace reference_tests { namespace reference_tests {
namespace LogicalOpsRefTestDefinitions { namespace LogicalOpsRefTestDefinitions {

1
src/plugins/template/tests/functional/op_reference/logical_or.cpp
View File

@ -8,7 +8,6 @@
#include "logical.hpp" #include "logical.hpp"
using namespace ov; using namespace ov;
using LogicalTypes = ngraph::helpers::LogicalTypes;
namespace reference_tests { namespace reference_tests {
namespace LogicalOpsRefTestDefinitions { namespace LogicalOpsRefTestDefinitions {

1
src/plugins/template/tests/functional/op_reference/logical_xor.cpp
View File

@ -8,7 +8,6 @@
#include "logical.hpp" #include "logical.hpp"
using namespace ov; using namespace ov;
using LogicalTypes = ngraph::helpers::LogicalTypes;
namespace reference_tests { namespace reference_tests {
namespace LogicalOpsRefTestDefinitions { namespace LogicalOpsRefTestDefinitions {

4
src/plugins/template/tests/functional/op_reference/loop.cpp
View File

@ -44,8 +44,8 @@ struct LoopDynamicInputs : public LoopFunctionalBase {
auto M_body = std::make_shared<ov::opset8::Parameter>(ov::element::f32, ov::PartialShape::dynamic()); auto M_body = std::make_shared<ov::opset8::Parameter>(ov::element::f32, ov::PartialShape::dynamic());
auto body_condition = std::make_shared<ov::opset8::Constant>(ov::element::boolean, ov::Shape{1}, true); auto body_condition = std::make_shared<ov::opset8::Constant>(ov::element::boolean, ov::Shape{1}, true);
auto trip_count = std::make_shared<ov::opset8::Constant>(ngraph::element::i64, ov::Shape{1}, 3); auto trip_count = std::make_shared<ov::opset8::Constant>(ov::element::i64, ov::Shape{1}, 3);
auto exec_condition = std::make_shared<ov::opset8::Constant>(ngraph::element::boolean, ov::Shape{1}, true); auto exec_condition = std::make_shared<ov::opset8::Constant>(ov::element::boolean, ov::Shape{1}, true);
// Body // Body
auto sum = std::make_shared<ov::opset8::Add>(Xi, Yi); auto sum = std::make_shared<ov::opset8::Add>(Xi, Yi);
auto Zo = std::make_shared<ov::opset8::Multiply>(sum, M_body); auto Zo = std::make_shared<ov::opset8::Multiply>(sum, M_body);

8
src/plugins/template/tests/functional/op_reference/mvn.cpp
View File

@ -14,7 +14,7 @@ using namespace reference_tests;
// ------------------------------ V0 ------------------------------ // ------------------------------ V0 ------------------------------
struct MVN1Params { struct MVN1Params {
MVN1Params(const reference_tests::Tensor& paramInput, const ngraph::AxisSet& paramReductionAxes, const bool paramAcrossChannels, const bool paramNormalizeVariance, MVN1Params(const reference_tests::Tensor& paramInput, const ov::AxisSet& paramReductionAxes, const bool paramAcrossChannels, const bool paramNormalizeVariance,
const double paramEps, const reference_tests::Tensor& paramExpected) const double paramEps, const reference_tests::Tensor& paramExpected)
: input(paramInput), : input(paramInput),
reductionAxes(paramReductionAxes), reductionAxes(paramReductionAxes),
@ -23,7 +23,7 @@ struct MVN1Params {
eps(paramEps), eps(paramEps),
expected(paramExpected) {} expected(paramExpected) {}
reference_tests::Tensor input; reference_tests::Tensor input;
ngraph::AxisSet reductionAxes; ov::AxisSet reductionAxes;
bool acrossChannels; bool acrossChannels;
bool normalizeVariance; bool normalizeVariance;
double eps; double eps;
@ -54,7 +54,7 @@ public:
} }
private: private:
static std::shared_ptr<Model> CreateFunction(const reference_tests::Tensor& input, const ngraph::AxisSet& reductionAxes, const bool acrossChannels, static std::shared_ptr<Model> CreateFunction(const reference_tests::Tensor& input, const ov::AxisSet& reductionAxes, const bool acrossChannels,
const bool normalizeVariance, const double eps) { const bool normalizeVariance, const double eps) {
const auto in = std::make_shared<op::v0::Parameter>(input.type, input.shape); const auto in = std::make_shared<op::v0::Parameter>(input.type, input.shape);
auto mvn = std::make_shared<op::v0::MVN>(in, acrossChannels, normalizeVariance, eps); auto mvn = std::make_shared<op::v0::MVN>(in, acrossChannels, normalizeVariance, eps);
@ -69,7 +69,7 @@ TEST_P(ReferenceMVN1LayerTest, CompareWithHardcodedRefs) {
Exec(); Exec();
} }
const ngraph::AxisSet emptyReductionAxes {}; const ov::AxisSet emptyReductionAxes {};
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_SUITE_P(
smoke_MVN1_With_Hardcoded_Refs, ReferenceMVN1LayerTest, smoke_MVN1_With_Hardcoded_Refs, ReferenceMVN1LayerTest,

2
src/plugins/template/tests/functional/op_reference/not_equal.cpp
View File

@ -8,8 +8,6 @@
#include "comparison.hpp" #include "comparison.hpp"
using namespace ov; using namespace ov;
using ComparisonTypes = ngraph::helpers::ComparisonTypes;
namespace reference_tests { namespace reference_tests {
namespace ComparisonOpsRefTestDefinitions { namespace ComparisonOpsRefTestDefinitions {

1
src/plugins/template/tests/functional/op_reference/prelu.cpp
View File

@ -4,7 +4,6 @@
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include <ngraph_functions/builders.hpp>
#include "openvino/op/prelu.hpp" #include "openvino/op/prelu.hpp"
#include "base_reference_test.hpp" #include "base_reference_test.hpp"

3
src/plugins/template/tests/functional/op_reference/reduce_l1.cpp
View File

@ -8,7 +8,6 @@
#include "reduction.hpp" #include "reduction.hpp"
using namespace ov; using namespace ov;
using ReductionType = ngraph::helpers::ReductionType;
namespace reference_tests { namespace reference_tests {
namespace ReductionOpsRefTestDefinitions { namespace ReductionOpsRefTestDefinitions {
@ -20,7 +19,7 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
std::vector<ReductionParams> params = { std::vector<ReductionParams> params = {
ReductionParams(ReductionType::L1, keep_dims, std::vector<int64_t>{2}, ReductionParams(ReductionType::L1, keep_dims, std::vector<int64_t>{2},
reference_tests::Tensor({3, 2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}), reference_tests::Tensor({3, 2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 2, 2}, AxisSet{2}, keep_dims), reference_tests::Tensor(reduce(Shape{3, 2, 2}, AxisSet{2}, keep_dims),
element::Type(IN_ET), std::vector<T>{3, 7, 11, 15, 19, 23})) element::Type(IN_ET), std::vector<T>{3, 7, 11, 15, 19, 23}))
}; };
return params; return params;

5
src/plugins/template/tests/functional/op_reference/reduce_l2.cpp
View File

@ -8,7 +8,6 @@
#include "reduction.hpp" #include "reduction.hpp"
using namespace ov; using namespace ov;
using ReductionType = ngraph::helpers::ReductionType;
namespace reference_tests { namespace reference_tests {
namespace ReductionOpsRefTestDefinitions { namespace ReductionOpsRefTestDefinitions {
@ -21,7 +20,7 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
std::vector<ReductionParams> params = { std::vector<ReductionParams> params = {
ReductionParams(ReductionType::L2, keep_dims, std::vector<int64_t>{2}, ReductionParams(ReductionType::L2, keep_dims, std::vector<int64_t>{2},
reference_tests::Tensor({3, 2, 2}, element::Type(IN_ET), std::vector<T>{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0}), reference_tests::Tensor({3, 2, 2}, element::Type(IN_ET), std::vector<T>{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 2, 2}, AxisSet{2}, keep_dims), reference_tests::Tensor(reduce(Shape{3, 2, 2}, AxisSet{2}, keep_dims),
element::Type(IN_ET), std::vector<T>{2.23606798, 5.0, 7.81024968, 10.63014581, 13.45362405, 16.2788206})) element::Type(IN_ET), std::vector<T>{2.23606798, 5.0, 7.81024968, 10.63014581, 13.45362405, 16.2788206}))
}; };
return params; return params;
@ -34,7 +33,7 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
std::vector<ReductionParams> params = { std::vector<ReductionParams> params = {
ReductionParams(ReductionType::L2, keep_dims, std::vector<int64_t>{2}, ReductionParams(ReductionType::L2, keep_dims, std::vector<int64_t>{2},
reference_tests::Tensor({3, 2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}), reference_tests::Tensor({3, 2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 2, 2}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{2, 5, 8, 11, 13, 16})) reference_tests::Tensor(reduce(Shape{3, 2, 2}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{2, 5, 8, 11, 13, 16}))
}; };
return params; return params;
} }

15
src/plugins/template/tests/functional/op_reference/reduce_max.cpp
View File

@ -8,7 +8,6 @@
#include "reduction.hpp" #include "reduction.hpp"
using namespace ov; using namespace ov;
using ReductionType = ngraph::helpers::ReductionType;
namespace reference_tests { namespace reference_tests {
namespace ReductionOpsRefTestDefinitions { namespace ReductionOpsRefTestDefinitions {
@ -20,30 +19,30 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
std::vector<ReductionParams> params = { std::vector<ReductionParams> params = {
ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{0, 1}, ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{0, 1},
reference_tests::Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}), reference_tests::Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}),
reference_tests::Tensor(ngraph::reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{4})), reference_tests::Tensor(reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{4})),
ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{0}, ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{0},
reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}), reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{5, 6})), reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{5, 6})),
ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{1}, ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{1},
reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}), reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{2, 4, 6})), reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{2, 4, 6})),
ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{0}, ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{0},
reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}), 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0}, keep_dims), reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{0}, keep_dims),
element::Type(IN_ET), std::vector<T>{19, 20, 21, 22, 23, 24, 25, 26, 27})), element::Type(IN_ET), std::vector<T>{19, 20, 21, 22, 23, 24, 25, 26, 27})),
ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{2}, ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{2},
reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}), 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{3, 6, 9, 12, 15, 18, 21, 24, 27})), reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{3, 6, 9, 12, 15, 18, 21, 24, 27})),
ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{0, 1}, ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{0, 1},
reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}), 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{25, 26, 27})), reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{25, 26, 27})),
ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{0, 1, 2}, ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{0, 1, 2},
reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}), 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0, 1, 2}, keep_dims), element::Type(IN_ET), std::vector<T>{27})) reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{0, 1, 2}, keep_dims), element::Type(IN_ET), std::vector<T>{27}))
}; };
return params; return params;
} }

13
src/plugins/template/tests/functional/op_reference/reduce_mean.cpp
View File

@ -8,7 +8,6 @@
#include "reduction.hpp" #include "reduction.hpp"
using namespace ov; using namespace ov;
using ReductionType = ngraph::helpers::ReductionType;
namespace reference_tests { namespace reference_tests {
namespace ReductionOpsRefTestDefinitions { namespace ReductionOpsRefTestDefinitions {
@ -21,13 +20,13 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
std::vector<ReductionParams> params = { std::vector<ReductionParams> params = {
ReductionParams(ReductionType::Mean, keep_dims, std::vector<int64_t>{0, 1}, ReductionParams(ReductionType::Mean, keep_dims, std::vector<int64_t>{0, 1},
reference_tests::Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}), reference_tests::Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}),
reference_tests::Tensor(ngraph::reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{2.5})), reference_tests::Tensor(reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{2.5})),
ReductionParams(ReductionType::Mean, keep_dims, std::vector<int64_t>{0}, ReductionParams(ReductionType::Mean, keep_dims, std::vector<int64_t>{0},
reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}), reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{3, 4})), reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{3, 4})),
ReductionParams(ReductionType::Mean, keep_dims, std::vector<int64_t>{1}, ReductionParams(ReductionType::Mean, keep_dims, std::vector<int64_t>{1},
reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}), reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{1.5, 3.5, 5.5})) reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{1.5, 3.5, 5.5}))
}; };
return params; return params;
} }
@ -39,13 +38,13 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
std::vector<ReductionParams> params = { std::vector<ReductionParams> params = {
ReductionParams(ReductionType::Mean, keep_dims, std::vector<int64_t>{0, 1}, ReductionParams(ReductionType::Mean, keep_dims, std::vector<int64_t>{0, 1},
reference_tests::Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}), reference_tests::Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}),
reference_tests::Tensor(ngraph::reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{2})), reference_tests::Tensor(reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{2})),
ReductionParams(ReductionType::Mean, keep_dims, std::vector<int64_t>{0}, ReductionParams(ReductionType::Mean, keep_dims, std::vector<int64_t>{0},
reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}), reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{3, 4})), reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{3, 4})),
ReductionParams(ReductionType::Mean, keep_dims, std::vector<int64_t>{1}, ReductionParams(ReductionType::Mean, keep_dims, std::vector<int64_t>{1},
reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}), reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 3, 5})) reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 3, 5}))
}; };
return params; return params;
} }

15
src/plugins/template/tests/functional/op_reference/reduce_min.cpp
View File

@ -8,7 +8,6 @@
#include "reduction.hpp" #include "reduction.hpp"
using namespace ov; using namespace ov;
using ReductionType = ngraph::helpers::ReductionType;
namespace reference_tests { namespace reference_tests {
namespace ReductionOpsRefTestDefinitions { namespace ReductionOpsRefTestDefinitions {
@ -20,29 +19,29 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
std::vector<ReductionParams> params = { std::vector<ReductionParams> params = {
ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{0, 1}, ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{0, 1},
reference_tests::Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}), reference_tests::Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}),
reference_tests::Tensor(ngraph::reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{1})), reference_tests::Tensor(reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{1})),
ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{0}, ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{0},
reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}), reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 2})), reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 2})),
ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{1}, ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{1},
reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}), reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 3, 5})), reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 3, 5})),
ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{0}, ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{0},
reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}), 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9})), reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9})),
ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{2}, ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{2},
reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}), 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 4, 7, 10, 13, 16, 19, 22, 25})), reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 4, 7, 10, 13, 16, 19, 22, 25})),
ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{0, 1}, ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{0, 1},
reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}), 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 2, 3})), reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 2, 3})),
ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{0, 1, 2}, ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{0, 1, 2},
reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}), 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0, 1, 2}, keep_dims), element::Type(IN_ET), std::vector<T>{1})) reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{0, 1, 2}, keep_dims), element::Type(IN_ET), std::vector<T>{1}))
}; };
return params; return params;
} }

11
src/plugins/template/tests/functional/op_reference/reduce_prod.cpp
View File

@ -8,7 +8,6 @@
#include "reduction.hpp" #include "reduction.hpp"
using namespace ov; using namespace ov;
using ReductionType = ngraph::helpers::ReductionType;
namespace reference_tests { namespace reference_tests {
namespace ReductionOpsRefTestDefinitions { namespace ReductionOpsRefTestDefinitions {
@ -19,17 +18,17 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
std::vector<ReductionParams> params = { std::vector<ReductionParams> params = {
ReductionParams(ReductionType::Prod, keep_dims, std::vector<int64_t>{0, 1}, ReductionParams(ReductionType::Prod, keep_dims, std::vector<int64_t>{0, 1},
reference_tests::Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}), reference_tests::Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}),
reference_tests::Tensor(ngraph::reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{24})), reference_tests::Tensor(reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{24})),
ReductionParams(ReductionType::Prod, keep_dims, std::vector<int64_t>{0}, ReductionParams(ReductionType::Prod, keep_dims, std::vector<int64_t>{0},
reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}), reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{15, 48})), reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{15, 48})),
ReductionParams(ReductionType::Prod, keep_dims, std::vector<int64_t>{1}, ReductionParams(ReductionType::Prod, keep_dims, std::vector<int64_t>{1},
reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}), reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{2, 12, 30})), reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{2, 12, 30})),
ReductionParams(ReductionType::Prod, keep_dims, std::vector<int64_t>{0}, ReductionParams(ReductionType::Prod, keep_dims, std::vector<int64_t>{0},
reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}), 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{1 * 10 * 19, reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{1 * 10 * 19,
2 * 11 * 20, 2 * 11 * 20,
3 * 12 * 21, 3 * 12 * 21,
4 * 13 * 22, 4 * 13 * 22,
@ -41,7 +40,7 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
ReductionParams(ReductionType::Prod, keep_dims, std::vector<int64_t>{2}, ReductionParams(ReductionType::Prod, keep_dims, std::vector<int64_t>{2},
reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}), 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{1 * 2 * 3, reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{1 * 2 * 3,
4 * 5 * 6, 4 * 5 * 6,
7 * 8 * 9, 7 * 8 * 9,
10 * 11 * 12, 10 * 11 * 12,

21
src/plugins/template/tests/functional/op_reference/reduce_sum.cpp
View File

@ -8,7 +8,6 @@
#include "reduction.hpp" #include "reduction.hpp"
using namespace ov; using namespace ov;
using ReductionType = ngraph::helpers::ReductionType;
static std::mt19937_64 random_generator; static std::mt19937_64 random_generator;
@ -31,17 +30,17 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
std::vector<ReductionParams> params = { std::vector<ReductionParams> params = {
ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0, 1}, ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0, 1},
reference_tests::Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}), reference_tests::Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}),
reference_tests::Tensor(ngraph::reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{10})), reference_tests::Tensor(reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{10})),
ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0}, ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0},
reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}), reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{9, 12})), reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{9, 12})),
ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{1}, ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{1},
reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}), reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{3, 7, 11})), reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{3, 7, 11})),
ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0}, ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0},
reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}), 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{1 + 10 + 19, reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{1 + 10 + 19,
2 + 11 + 20, 2 + 11 + 20,
3 + 12 + 21, 3 + 12 + 21,
4 + 13 + 22, 4 + 13 + 22,
@ -53,7 +52,7 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{2}, ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{2},
reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}), 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{1 + 2 + 3, reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{1 + 2 + 3,
4 + 5 + 6, 4 + 5 + 6,
7 + 8 + 9, 7 + 8 + 9,
10 + 11 + 12, 10 + 11 + 12,
@ -65,19 +64,19 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0, 1}, ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0, 1},
reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}), 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0, 1}, keep_dims), reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{0, 1}, keep_dims),
element::Type(IN_ET), std::vector<T>{1 + 10 + 19 + 4 + 13 + 22 + 7 + 16 + 25, element::Type(IN_ET), std::vector<T>{1 + 10 + 19 + 4 + 13 + 22 + 7 + 16 + 25,
2 + 11 + 20 + 5 + 14 + 23 + 8 + 17 + 26, 2 + 11 + 20 + 5 + 14 + 23 + 8 + 17 + 26,
3 + 12 + 21 + 6 + 15 + 24 + 9 + 18 + 27})), 3 + 12 + 21 + 6 + 15 + 24 + 9 + 18 + 27})),
ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0, 1, 2}, ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0, 1, 2},
reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}), 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0, 1, 2}, keep_dims), element::Type(IN_ET), reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{0, 1, 2}, keep_dims), element::Type(IN_ET),
std::vector<T>{1 + 10 + 19 + 4 + 13 + 22 + 7 + 16 + 25 + 2 + 11 + 20 + 5 + 14 + 23 + 8 + std::vector<T>{1 + 10 + 19 + 4 + 13 + 22 + 7 + 16 + 25 + 2 + 11 + 20 + 5 + 14 + 23 + 8 +
17 + 26 + 3 + 12 + 21 + 6 + 15 + 24 + 9 + 18 + 27})), 17 + 26 + 3 + 12 + 21 + 6 + 15 + 24 + 9 + 18 + 27})),
ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0, 1, 2, 3, 4}, ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0, 1, 2, 3, 4},
reference_tests::Tensor({3, 3, 3, 3, 3}, element::Type(IN_ET), std::vector<T>(static_cast<uint64_t>(std::pow(3, 5)), 1)), reference_tests::Tensor({3, 3, 3, 3, 3}, element::Type(IN_ET), std::vector<T>(static_cast<uint64_t>(std::pow(3, 5)), 1)),
reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3, 3, 3}, AxisSet{0, 1, 2, 3, 4}, keep_dims), element::Type(IN_ET), std::vector<T>{243})) reference_tests::Tensor(reduce(Shape{3, 3, 3, 3, 3}, AxisSet{0, 1, 2, 3, 4}, keep_dims), element::Type(IN_ET), std::vector<T>{243}))
}; };
return params; return params;
} }
@ -88,12 +87,12 @@ std::vector<ReductionParams> generateReductionParamsFloat(const bool keep_dims)
std::vector<ReductionParams> params = { std::vector<ReductionParams> params = {
ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0}, ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0},
reference_tests::Tensor({1000000}, element::f32, in), reference_tests::Tensor({1000000}, element::f32, in),
reference_tests::Tensor(ngraph::reduce(Shape{1000000}, AxisSet{0}, keep_dims), element::f32, std::vector<float>{res})), reference_tests::Tensor(reduce(Shape{1000000}, AxisSet{0}, keep_dims), element::f32, std::vector<float>{res})),
ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0}, ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0},
reference_tests::Tensor({20}, element::f32, std::vector<float>{10000000.0f, 0.9f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, reference_tests::Tensor({20}, element::f32, std::vector<float>{10000000.0f, 0.9f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f,
0.8f, 0.1f, 0.9f, 0.5f, 0.2f, 0.3f, 0.4f, 0.8f, 0.1f, 0.9f, 0.5f, 0.2f, 0.3f, 0.4f,
0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 0.1f}), 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 0.1f}),
reference_tests::Tensor(ngraph::reduce(Shape{20}, AxisSet{0}, keep_dims), element::f32, std::vector<float>{10000010.2f})) reference_tests::Tensor(reduce(Shape{20}, AxisSet{0}, keep_dims), element::f32, std::vector<float>{10000010.2f}))
}; };
return params; return params;
} }

77
src/plugins/template/tests/functional/op_reference/reduction.hpp
View File

@ -5,21 +5,48 @@
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include "base_reference_test.hpp" #include "base_reference_test.hpp"
#include "common_test_utils/test_enums.hpp"
#include "shared_test_classes/base/layer_test_utils.hpp" #include "shared_test_classes/base/layer_test_utils.hpp"
#include "ngraph_functions/builders.hpp" #include "openvino/op/reduce_logical_and.hpp"
#include "ngraph/shape_util.hpp" #include "openvino/op/reduce_logical_or.hpp"
#include "openvino/op/reduce_l1.hpp"
#include "openvino/op/reduce_l2.hpp"
#include "openvino/op/reduce_min.hpp"
#include "openvino/op/reduce_max.hpp"
#include "openvino/op/reduce_mean.hpp"
#include "openvino/op/reduce_prod.hpp"
#include "openvino/op/reduce_sum.hpp"
using namespace ov; using namespace ov;
namespace reference_tests { namespace reference_tests {
namespace ReductionOpsRefTestDefinitions { namespace ReductionOpsRefTestDefinitions {
using ov::test::utils::ReductionType;
// Removes some values from a vector of axis values
template <typename AXIS_VALUES>
AXIS_VALUES reduce(const AXIS_VALUES& axis_values, const ov::AxisSet& deleted_axes, bool keep_dims) {
AXIS_VALUES result;
for (size_t i = 0; i < axis_values.size(); i++) {
if (deleted_axes.find(i) == deleted_axes.end()) {
result.push_back(axis_values[i]);
} else {
if (keep_dims)
result.push_back(1);
}
}
return result;
}
struct ReductionParams { struct ReductionParams {
ReductionParams(const ngraph::helpers::ReductionType& reductType, const bool keepDims, const std::vector<int64_t>& axes, ReductionParams(const ReductionType& reductType, const bool keepDims, const std::vector<int64_t>& axes,
const reference_tests::Tensor& dataTensor, const reference_tests::Tensor& outputTensor) : reductionType(reductType), keepDimensions(keepDims), reductionAxes(axes), const reference_tests::Tensor& dataTensor, const reference_tests::Tensor& outputTensor) : reductionType(reductType), keepDimensions(keepDims), reductionAxes(axes),
data(dataTensor), output(outputTensor) {} data(dataTensor), output(outputTensor) {}
ngraph::helpers::ReductionType reductionType; ReductionType reductionType;
bool keepDimensions; bool keepDimensions;
std::vector<int64_t> reductionAxes; std::vector<int64_t> reductionAxes;
reference_tests::Tensor data; reference_tests::Tensor data;
@ -54,7 +81,47 @@ private:
const auto axes = std::make_shared<op::v0::Constant>(ov::element::i64, const auto axes = std::make_shared<op::v0::Constant>(ov::element::i64,
ov::Shape{params.reductionAxes.size()}, ov::Shape{params.reductionAxes.size()},
params.reductionAxes); params.reductionAxes);
const auto reduction = ngraph::builder::makeReduce(data, axes, params.keepDimensions, params.reductionType); std::shared_ptr<ov::Node> reduction;
switch (params.reductionType) {
case ReductionType::Mean: {
reduction = std::make_shared<ov::op::v1::ReduceMean>(data, axes, params.keepDimensions);
break;
}
case ReductionType::Max: {
reduction = std::make_shared<ov::op::v1::ReduceMax>(data, axes, params.keepDimensions);
break;
}
case ReductionType::Min: {
reduction = std::make_shared<ov::op::v1::ReduceMin>(data, axes, params.keepDimensions);
break;
}
case ReductionType::Prod: {
reduction = std::make_shared<ov::op::v1::ReduceProd>(data, axes, params.keepDimensions);
break;
}
case ReductionType::Sum: {
reduction = std::make_shared<ov::op::v1::ReduceSum>(data, axes, params.keepDimensions);
break;
}
case ReductionType::LogicalOr: {
reduction = std::make_shared<ov::op::v1::ReduceLogicalOr>(data, axes, params.keepDimensions);
break;
}
case ReductionType::LogicalAnd: {
reduction = std::make_shared<ov::op::v1::ReduceLogicalAnd>(data, axes, params.keepDimensions);
break;
}
case ReductionType::L1: {
reduction = std::make_shared<ov::op::v4::ReduceL1>(data, axes, params.keepDimensions);
break;
}
case ReductionType::L2: {
reduction = std::make_shared<ov::op::v4::ReduceL2>(data, axes, params.keepDimensions);
break;
}
default:
throw std::runtime_error("Can't create layer for this reduction type");
}
return std::make_shared<ov::Model>(reduction, ov::ParameterVector{data}); return std::make_shared<ov::Model>(reduction, ov::ParameterVector{data});
} }
}; };

8
src/plugins/template/tests/functional/op_reference/reverse.cpp
View File

@ -89,28 +89,28 @@ TEST_P(ReferenceReverseTestAxesRankIndexMode, CompareWithRefs) {
EXPECT_THROW(const auto unused = std::make_shared<ov::Model>( EXPECT_THROW(const auto unused = std::make_shared<ov::Model>(
std::make_shared<op::v1::Reverse>(Data, Rev_Axes, op::v1::Reverse::Mode::INDEX), std::make_shared<op::v1::Reverse>(Data, Rev_Axes, op::v1::Reverse::Mode::INDEX),
ParameterVector{Data, Rev_Axes}), ParameterVector{Data, Rev_Axes}),
ngraph::NodeValidationFailure); ov::NodeValidationFailure);
} }
TEST_P(ReferenceReverseTestAxesElemsMaskMode, CompareWithRefs) { TEST_P(ReferenceReverseTestAxesElemsMaskMode, CompareWithRefs) {
const auto Data = std::make_shared<op::v0::Parameter>(element::f32, Shape{2, 2, 2}); const auto Data = std::make_shared<op::v0::Parameter>(element::f32, Shape{2, 2, 2});
const auto Rev_Axes = std::make_shared<op::v0::Parameter>(element::boolean, Shape{2}); // correct: 3 const auto Rev_Axes = std::make_shared<op::v0::Parameter>(element::boolean, Shape{2}); // correct: 3
EXPECT_THROW(const auto unused = std::make_shared<op::v1::Reverse>(Data, Rev_Axes, op::v1::Reverse::Mode::MASK), EXPECT_THROW(const auto unused = std::make_shared<op::v1::Reverse>(Data, Rev_Axes, op::v1::Reverse::Mode::MASK),
ngraph::NodeValidationFailure); ov::NodeValidationFailure);
} }
TEST_P(ReferenceReverseTestAxesOutOfBounds, CompareWithRefs) { TEST_P(ReferenceReverseTestAxesOutOfBounds, CompareWithRefs) {
const auto Data = std::make_shared<op::v0::Parameter>(element::f32, Shape{2, 2, 2}); const auto Data = std::make_shared<op::v0::Parameter>(element::f32, Shape{2, 2, 2});
const auto Rev_Axes = op::v0::Constant::create(element::i64, Shape{2}, {1, 10}); const auto Rev_Axes = op::v0::Constant::create(element::i64, Shape{2}, {1, 10});
EXPECT_THROW(const auto unused = std::make_shared<op::v1::Reverse>(Data, Rev_Axes, op::v1::Reverse::Mode::INDEX), EXPECT_THROW(const auto unused = std::make_shared<op::v1::Reverse>(Data, Rev_Axes, op::v1::Reverse::Mode::INDEX),
ngraph::NodeValidationFailure); ov::NodeValidationFailure);
} }
TEST_P(ReferenceReverseTestAxesOutOfBounds4, CompareWithRefs) { TEST_P(ReferenceReverseTestAxesOutOfBounds4, CompareWithRefs) {
const auto Data = std::make_shared<op::v0::Parameter>(element::f32, Shape{2, 2, 2}); const auto Data = std::make_shared<op::v0::Parameter>(element::f32, Shape{2, 2, 2});
const auto Rev_Axes = op::v0::Constant::create(element::i64, Shape{4}, {0, 1, 2, 3}); const auto Rev_Axes = op::v0::Constant::create(element::i64, Shape{4}, {0, 1, 2, 3});
EXPECT_THROW(const auto unused = std::make_shared<op::v1::Reverse>(Data, Rev_Axes, op::v1::Reverse::Mode::INDEX), EXPECT_THROW(const auto unused = std::make_shared<op::v1::Reverse>(Data, Rev_Axes, op::v1::Reverse::Mode::INDEX),
ngraph::NodeValidationFailure); ov::NodeValidationFailure);
} }
template <element::Type_t IN_ET> template <element::Type_t IN_ET>

215
src/plugins/template/tests/functional/op_reference/scatter_update.cpp
View File

@ -2,19 +2,14 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include <gtest/gtest.h>
#include <ie_core.hpp>
#include <ie_ngraph_utils.hpp>
#include <ngraph/ngraph.hpp>
#include <shared_test_classes/base/layer_test_utils.hpp>
#include <vector> #include <vector>
#include "base_reference_test.hpp" #include "base_reference_test.hpp"
#include "ngraph_functions/builders.hpp" #include "gtest/gtest.h"
#include "openvino/op/parameter.hpp"
#include "openvino/op/scatter_update.hpp"
using namespace ngraph;
using namespace InferenceEngine;
using namespace reference_tests; using namespace reference_tests;
namespace reference_tests { namespace reference_tests {
@ -73,12 +68,12 @@ private:
const auto indices_type = params.indices.type; const auto indices_type = params.indices.type;
const auto axis_type = params.axis.type; const auto axis_type = params.axis.type;
const auto data = std::make_shared<ngraph::op::Parameter>(numeric_type, data_shape); const auto data = std::make_shared<ov::op::v0::Parameter>(numeric_type, data_shape);
const auto indices = std::make_shared<ngraph::op::Parameter>(indices_type, indices_shape); const auto indices = std::make_shared<ov::op::v0::Parameter>(indices_type, indices_shape);
const auto updates = std::make_shared<ngraph::op::Parameter>(numeric_type, updates_shape); const auto updates = std::make_shared<ov::op::v0::Parameter>(numeric_type, updates_shape);
const auto axis = std::make_shared<ngraph::op::Parameter>(axis_type, axis_shape); const auto axis = std::make_shared<ov::op::v0::Parameter>(axis_type, axis_shape);
const auto scatter_update = std::make_shared<op::v3::ScatterUpdate>(data, indices, updates, axis); const auto scatter_update = std::make_shared<ov::op::v3::ScatterUpdate>(data, indices, updates, axis);
return std::make_shared<ov::Model>(ngraph::NodeVector {scatter_update}, ngraph::ParameterVector {data, indices, updates, axis}); return std::make_shared<ov::Model>(ov::NodeVector {scatter_update}, ov::ParameterVector {data, indices, updates, axis});
} }
}; };
@ -86,10 +81,10 @@ TEST_P(ReferenceScatterUpdate6LayerTest, ScatterUpdateWithHardcodedRefs) {
Exec(); Exec();
} }
template <element::Type_t NUM_ET, element::Type_t INT_ET> template <ov::element::Type_t NUM_ET, ov::element::Type_t INT_ET>
std::vector<ScatterUpdate3Params> generateScatterUpdate3Params(const element::Type& numeric_type, const element::Type& integer_type) { std::vector<ScatterUpdate3Params> generateScatterUpdate3Params(const ov::element::Type& numeric_type, const ov::element::Type& integer_type) {
using N = typename element_type_traits<NUM_ET>::value_type; using N = typename ov::element_type_traits<NUM_ET>::value_type;
using I = typename element_type_traits<INT_ET>::value_type; using I = typename ov::element_type_traits<INT_ET>::value_type;
std::vector<ScatterUpdate3Params> ScatterUpdateParams { std::vector<ScatterUpdate3Params> ScatterUpdateParams {
Builder {} Builder {}
.data({{3, 2, 2, 3}, numeric_type, std::vector<N> { .data({{3, 2, 2, 3}, numeric_type, std::vector<N> {
@ -769,10 +764,10 @@ Builder {}
return ScatterUpdateParams; return ScatterUpdateParams;
} }
template <element::Type_t NUM_ET, element::Type_t INT_ET> template <ov::element::Type_t NUM_ET, ov::element::Type_t INT_ET>
std::vector<ScatterUpdate3Params> generateScatterUpdate3ParamsNegativeAxis(const element::Type& numeric_type, const element::Type& integer_type) { std::vector<ScatterUpdate3Params> generateScatterUpdate3ParamsNegativeAxis(const ov::element::Type& numeric_type, const ov::element::Type& integer_type) {
using N = typename element_type_traits<NUM_ET>::value_type; using N = typename ov::element_type_traits<NUM_ET>::value_type;
using I = typename element_type_traits<INT_ET>::value_type; using I = typename ov::element_type_traits<INT_ET>::value_type;
std::vector<ScatterUpdate3Params> ScatterUpdateParams { std::vector<ScatterUpdate3Params> ScatterUpdateParams {
Builder {} Builder {}
.data({{2, 2, 3}, numeric_type, std::vector<N> {0, 0, 0, .data({{2, 2, 3}, numeric_type, std::vector<N> {0, 0, 0,
@ -870,72 +865,72 @@ std::vector<ScatterUpdate3Params> generateScatterUpdate3ParamsNegativeAxis(const
std::vector<ScatterUpdate3Params> generateScatterUpdateCombinedParams() { std::vector<ScatterUpdate3Params> generateScatterUpdateCombinedParams() {
const std::vector<std::vector<ScatterUpdate3Params>> ScatterUpdateTypeParams { const std::vector<std::vector<ScatterUpdate3Params>> ScatterUpdateTypeParams {
// f32 // f32
generateScatterUpdate3Params<element::Type_t::f32, element::Type_t::i16>(element::f32, element::i16), generateScatterUpdate3Params<ov::element::Type_t::f32, ov::element::Type_t::i16>(ov::element::f32, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::f32, element::Type_t::i32>(element::f32, element::i32), generateScatterUpdate3Params<ov::element::Type_t::f32, ov::element::Type_t::i32>(ov::element::f32, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::f32, element::Type_t::i64>(element::f32, element::i64), generateScatterUpdate3Params<ov::element::Type_t::f32, ov::element::Type_t::i64>(ov::element::f32, ov::element::i64),
generateScatterUpdate3Params<element::Type_t::f32, element::Type_t::u32>(element::f32, element::u32), generateScatterUpdate3Params<ov::element::Type_t::f32, ov::element::Type_t::u32>(ov::element::f32, ov::element::u32),
generateScatterUpdate3Params<element::Type_t::f32, element::Type_t::u64>(element::f32, element::u64), generateScatterUpdate3Params<ov::element::Type_t::f32, ov::element::Type_t::u64>(ov::element::f32, ov::element::u64),
// f16 // f16
generateScatterUpdate3Params<element::Type_t::f16, element::Type_t::i16>(element::f16, element::i16), generateScatterUpdate3Params<ov::element::Type_t::f16, ov::element::Type_t::i16>(ov::element::f16, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::f16, element::Type_t::i32>(element::f16, element::i32), generateScatterUpdate3Params<ov::element::Type_t::f16, ov::element::Type_t::i32>(ov::element::f16, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::f16, element::Type_t::i64>(element::f16, element::i64), generateScatterUpdate3Params<ov::element::Type_t::f16, ov::element::Type_t::i64>(ov::element::f16, ov::element::i64),
generateScatterUpdate3Params<element::Type_t::f16, element::Type_t::u32>(element::f16, element::u32), generateScatterUpdate3Params<ov::element::Type_t::f16, ov::element::Type_t::u32>(ov::element::f16, ov::element::u32),
generateScatterUpdate3Params<element::Type_t::f16, element::Type_t::u64>(element::f16, element::u64), generateScatterUpdate3Params<ov::element::Type_t::f16, ov::element::Type_t::u64>(ov::element::f16, ov::element::u64),
// i8 // i8
generateScatterUpdate3Params<element::Type_t::i8, element::Type_t::i16>(element::i8, element::i16), generateScatterUpdate3Params<ov::element::Type_t::i8, ov::element::Type_t::i16>(ov::element::i8, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::i8, element::Type_t::i32>(element::i8, element::i32), generateScatterUpdate3Params<ov::element::Type_t::i8, ov::element::Type_t::i32>(ov::element::i8, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::i8, element::Type_t::i64>(element::i8, element::i64), generateScatterUpdate3Params<ov::element::Type_t::i8, ov::element::Type_t::i64>(ov::element::i8, ov::element::i64),
generateScatterUpdate3Params<element::Type_t::i8, element::Type_t::u32>(element::i8, element::u32), generateScatterUpdate3Params<ov::element::Type_t::i8, ov::element::Type_t::u32>(ov::element::i8, ov::element::u32),
generateScatterUpdate3Params<element::Type_t::i8, element::Type_t::u64>(element::i8, element::u64), generateScatterUpdate3Params<ov::element::Type_t::i8, ov::element::Type_t::u64>(ov::element::i8, ov::element::u64),
// i16 // i16
generateScatterUpdate3Params<element::Type_t::i16, element::Type_t::i16>(element::i16, element::i16), generateScatterUpdate3Params<ov::element::Type_t::i16, ov::element::Type_t::i16>(ov::element::i16, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::i16, element::Type_t::i32>(element::i16, element::i32), generateScatterUpdate3Params<ov::element::Type_t::i16, ov::element::Type_t::i32>(ov::element::i16, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::i16, element::Type_t::i64>(element::i16, element::i64), generateScatterUpdate3Params<ov::element::Type_t::i16, ov::element::Type_t::i64>(ov::element::i16, ov::element::i64),
generateScatterUpdate3Params<element::Type_t::i16, element::Type_t::u32>(element::i16, element::u32), generateScatterUpdate3Params<ov::element::Type_t::i16, ov::element::Type_t::u32>(ov::element::i16, ov::element::u32),
generateScatterUpdate3Params<element::Type_t::i16, element::Type_t::u64>(element::i16, element::u64), generateScatterUpdate3Params<ov::element::Type_t::i16, ov::element::Type_t::u64>(ov::element::i16, ov::element::u64),
// i32 // i32
generateScatterUpdate3Params<element::Type_t::i32, element::Type_t::i16>(element::i32, element::i16), generateScatterUpdate3Params<ov::element::Type_t::i32, ov::element::Type_t::i16>(ov::element::i32, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::i32, element::Type_t::i32>(element::i32, element::i32), generateScatterUpdate3Params<ov::element::Type_t::i32, ov::element::Type_t::i32>(ov::element::i32, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::i32, element::Type_t::i64>(element::i32, element::i64), generateScatterUpdate3Params<ov::element::Type_t::i32, ov::element::Type_t::i64>(ov::element::i32, ov::element::i64),
generateScatterUpdate3Params<element::Type_t::i32, element::Type_t::u32>(element::i32, element::u32), generateScatterUpdate3Params<ov::element::Type_t::i32, ov::element::Type_t::u32>(ov::element::i32, ov::element::u32),
generateScatterUpdate3Params<element::Type_t::i32, element::Type_t::u64>(element::i32, element::u64), generateScatterUpdate3Params<ov::element::Type_t::i32, ov::element::Type_t::u64>(ov::element::i32, ov::element::u64),
// i64 // i64
generateScatterUpdate3Params<element::Type_t::i64, element::Type_t::i16>(element::i64, element::i16), generateScatterUpdate3Params<ov::element::Type_t::i64, ov::element::Type_t::i16>(ov::element::i64, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::i64, element::Type_t::i32>(element::i64, element::i32), generateScatterUpdate3Params<ov::element::Type_t::i64, ov::element::Type_t::i32>(ov::element::i64, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::i64, element::Type_t::i64>(element::i64, element::i64), generateScatterUpdate3Params<ov::element::Type_t::i64, ov::element::Type_t::i64>(ov::element::i64, ov::element::i64),
generateScatterUpdate3Params<element::Type_t::i64, element::Type_t::u32>(element::i64, element::u32), generateScatterUpdate3Params<ov::element::Type_t::i64, ov::element::Type_t::u32>(ov::element::i64, ov::element::u32),
generateScatterUpdate3Params<element::Type_t::i64, element::Type_t::u64>(element::i64, element::u64), generateScatterUpdate3Params<ov::element::Type_t::i64, ov::element::Type_t::u64>(ov::element::i64, ov::element::u64),
// u8 // u8
generateScatterUpdate3Params<element::Type_t::u8, element::Type_t::i16>(element::u8, element::i16), generateScatterUpdate3Params<ov::element::Type_t::u8, ov::element::Type_t::i16>(ov::element::u8, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::u8, element::Type_t::i32>(element::u8, element::i32), generateScatterUpdate3Params<ov::element::Type_t::u8, ov::element::Type_t::i32>(ov::element::u8, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::u8, element::Type_t::i64>(element::u8, element::i64), generateScatterUpdate3Params<ov::element::Type_t::u8, ov::element::Type_t::i64>(ov::element::u8, ov::element::i64),
generateScatterUpdate3Params<element::Type_t::u8, element::Type_t::u32>(element::u8, element::u32), generateScatterUpdate3Params<ov::element::Type_t::u8, ov::element::Type_t::u32>(ov::element::u8, ov::element::u32),
generateScatterUpdate3Params<element::Type_t::u8, element::Type_t::u64>(element::u8, element::u64), generateScatterUpdate3Params<ov::element::Type_t::u8, ov::element::Type_t::u64>(ov::element::u8, ov::element::u64),
// u16 // u16
generateScatterUpdate3Params<element::Type_t::u16, element::Type_t::i16>(element::u16, element::i16), generateScatterUpdate3Params<ov::element::Type_t::u16, ov::element::Type_t::i16>(ov::element::u16, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::u16, element::Type_t::i32>(element::u16, element::i32), generateScatterUpdate3Params<ov::element::Type_t::u16, ov::element::Type_t::i32>(ov::element::u16, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::u16, element::Type_t::i64>(element::u16, element::i64), generateScatterUpdate3Params<ov::element::Type_t::u16, ov::element::Type_t::i64>(ov::element::u16, ov::element::i64),
generateScatterUpdate3Params<element::Type_t::u16, element::Type_t::u32>(element::u16, element::u32), generateScatterUpdate3Params<ov::element::Type_t::u16, ov::element::Type_t::u32>(ov::element::u16, ov::element::u32),
generateScatterUpdate3Params<element::Type_t::u16, element::Type_t::u64>(element::u16, element::u64), generateScatterUpdate3Params<ov::element::Type_t::u16, ov::element::Type_t::u64>(ov::element::u16, ov::element::u64),
// u32 // u32
generateScatterUpdate3Params<element::Type_t::u32, element::Type_t::i16>(element::u32, element::i16), generateScatterUpdate3Params<ov::element::Type_t::u32, ov::element::Type_t::i16>(ov::element::u32, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::u32, element::Type_t::i32>(element::u32, element::i32), generateScatterUpdate3Params<ov::element::Type_t::u32, ov::element::Type_t::i32>(ov::element::u32, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::u32, element::Type_t::i64>(element::u32, element::i64), generateScatterUpdate3Params<ov::element::Type_t::u32, ov::element::Type_t::i64>(ov::element::u32, ov::element::i64),
generateScatterUpdate3Params<element::Type_t::u32, element::Type_t::u32>(element::u32, element::u32), generateScatterUpdate3Params<ov::element::Type_t::u32, ov::element::Type_t::u32>(ov::element::u32, ov::element::u32),
generateScatterUpdate3Params<element::Type_t::u32, element::Type_t::u64>(element::u32, element::u64), generateScatterUpdate3Params<ov::element::Type_t::u32, ov::element::Type_t::u64>(ov::element::u32, ov::element::u64),
// u64 // u64
generateScatterUpdate3Params<element::Type_t::u64, element::Type_t::i16>(element::u64, element::i16), generateScatterUpdate3Params<ov::element::Type_t::u64, ov::element::Type_t::i16>(ov::element::u64, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::u64, element::Type_t::i32>(element::u64, element::i32), generateScatterUpdate3Params<ov::element::Type_t::u64, ov::element::Type_t::i32>(ov::element::u64, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::u64, element::Type_t::i64>(element::u64, element::i64), generateScatterUpdate3Params<ov::element::Type_t::u64, ov::element::Type_t::i64>(ov::element::u64, ov::element::i64),
generateScatterUpdate3Params<element::Type_t::u64, element::Type_t::u32>(element::u64, element::u32), generateScatterUpdate3Params<ov::element::Type_t::u64, ov::element::Type_t::u32>(ov::element::u64, ov::element::u32),
generateScatterUpdate3Params<element::Type_t::u64, element::Type_t::u64>(element::u64, element::u64), generateScatterUpdate3Params<ov::element::Type_t::u64, ov::element::Type_t::u64>(ov::element::u64, ov::element::u64),
// bf16 // bf16
generateScatterUpdate3Params<element::Type_t::bf16, element::Type_t::i16>(element::bf16, element::i16), generateScatterUpdate3Params<ov::element::Type_t::bf16, ov::element::Type_t::i16>(ov::element::bf16, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::bf16, element::Type_t::i32>(element::bf16, element::i32), generateScatterUpdate3Params<ov::element::Type_t::bf16, ov::element::Type_t::i32>(ov::element::bf16, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::bf16, element::Type_t::i64>(element::bf16, element::i64), generateScatterUpdate3Params<ov::element::Type_t::bf16, ov::element::Type_t::i64>(ov::element::bf16, ov::element::i64),
generateScatterUpdate3Params<element::Type_t::bf16, element::Type_t::u32>(element::bf16, element::u32), generateScatterUpdate3Params<ov::element::Type_t::bf16, ov::element::Type_t::u32>(ov::element::bf16, ov::element::u32),
generateScatterUpdate3Params<element::Type_t::bf16, element::Type_t::u64>(element::bf16, element::u64)}; generateScatterUpdate3Params<ov::element::Type_t::bf16, ov::element::Type_t::u64>(ov::element::bf16, ov::element::u64)};
std::vector<ScatterUpdate3Params> combinedParams; std::vector<ScatterUpdate3Params> combinedParams;
for (const auto& params : ScatterUpdateTypeParams) { for (const auto& params : ScatterUpdateTypeParams) {
@ -947,49 +942,49 @@ std::vector<ScatterUpdate3Params> generateScatterUpdateCombinedParams() {
std::vector<ScatterUpdate3Params> generateScatterUpdateNegativeAxisParams() { std::vector<ScatterUpdate3Params> generateScatterUpdateNegativeAxisParams() {
const std::vector<std::vector<ScatterUpdate3Params>> ScatterUpdateTypeParams { const std::vector<std::vector<ScatterUpdate3Params>> ScatterUpdateTypeParams {
// f32 // f32
generateScatterUpdate3Params<element::Type_t::f32, element::Type_t::i16>(element::f32, element::i16), generateScatterUpdate3Params<ov::element::Type_t::f32, ov::element::Type_t::i16>(ov::element::f32, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::f32, element::Type_t::i32>(element::f32, element::i32), generateScatterUpdate3Params<ov::element::Type_t::f32, ov::element::Type_t::i32>(ov::element::f32, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::f32, element::Type_t::i64>(element::f32, element::i64), generateScatterUpdate3Params<ov::element::Type_t::f32, ov::element::Type_t::i64>(ov::element::f32, ov::element::i64),
// f16 // f16
generateScatterUpdate3Params<element::Type_t::f16, element::Type_t::i16>(element::f16, element::i16), generateScatterUpdate3Params<ov::element::Type_t::f16, ov::element::Type_t::i16>(ov::element::f16, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::f16, element::Type_t::i32>(element::f16, element::i32), generateScatterUpdate3Params<ov::element::Type_t::f16, ov::element::Type_t::i32>(ov::element::f16, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::f16, element::Type_t::i64>(element::f16, element::i64), generateScatterUpdate3Params<ov::element::Type_t::f16, ov::element::Type_t::i64>(ov::element::f16, ov::element::i64),
// i8 // i8
generateScatterUpdate3Params<element::Type_t::i8, element::Type_t::i16>(element::i8, element::i16), generateScatterUpdate3Params<ov::element::Type_t::i8, ov::element::Type_t::i16>(ov::element::i8, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::i8, element::Type_t::i32>(element::i8, element::i32), generateScatterUpdate3Params<ov::element::Type_t::i8, ov::element::Type_t::i32>(ov::element::i8, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::i8, element::Type_t::i64>(element::i8, element::i64), generateScatterUpdate3Params<ov::element::Type_t::i8, ov::element::Type_t::i64>(ov::element::i8, ov::element::i64),
// i16 // i16
generateScatterUpdate3Params<element::Type_t::i16, element::Type_t::i16>(element::i16, element::i16), generateScatterUpdate3Params<ov::element::Type_t::i16, ov::element::Type_t::i16>(ov::element::i16, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::i16, element::Type_t::i32>(element::i16, element::i32), generateScatterUpdate3Params<ov::element::Type_t::i16, ov::element::Type_t::i32>(ov::element::i16, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::i16, element::Type_t::i64>(element::i16, element::i64), generateScatterUpdate3Params<ov::element::Type_t::i16, ov::element::Type_t::i64>(ov::element::i16, ov::element::i64),
// i32 // i32
generateScatterUpdate3Params<element::Type_t::i32, element::Type_t::i16>(element::i32, element::i16), generateScatterUpdate3Params<ov::element::Type_t::i32, ov::element::Type_t::i16>(ov::element::i32, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::i32, element::Type_t::i32>(element::i32, element::i32), generateScatterUpdate3Params<ov::element::Type_t::i32, ov::element::Type_t::i32>(ov::element::i32, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::i32, element::Type_t::i64>(element::i32, element::i64), generateScatterUpdate3Params<ov::element::Type_t::i32, ov::element::Type_t::i64>(ov::element::i32, ov::element::i64),
// i64 // i64
generateScatterUpdate3Params<element::Type_t::i64, element::Type_t::i16>(element::i64, element::i16), generateScatterUpdate3Params<ov::element::Type_t::i64, ov::element::Type_t::i16>(ov::element::i64, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::i64, element::Type_t::i32>(element::i64, element::i32), generateScatterUpdate3Params<ov::element::Type_t::i64, ov::element::Type_t::i32>(ov::element::i64, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::i64, element::Type_t::i64>(element::i64, element::i64), generateScatterUpdate3Params<ov::element::Type_t::i64, ov::element::Type_t::i64>(ov::element::i64, ov::element::i64),
// u8 // u8
generateScatterUpdate3Params<element::Type_t::u8, element::Type_t::i16>(element::u8, element::i16), generateScatterUpdate3Params<ov::element::Type_t::u8, ov::element::Type_t::i16>(ov::element::u8, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::u8, element::Type_t::i32>(element::u8, element::i32), generateScatterUpdate3Params<ov::element::Type_t::u8, ov::element::Type_t::i32>(ov::element::u8, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::u8, element::Type_t::i64>(element::u8, element::i64), generateScatterUpdate3Params<ov::element::Type_t::u8, ov::element::Type_t::i64>(ov::element::u8, ov::element::i64),
// u16 // u16
generateScatterUpdate3Params<element::Type_t::u16, element::Type_t::i16>(element::u16, element::i16), generateScatterUpdate3Params<ov::element::Type_t::u16, ov::element::Type_t::i16>(ov::element::u16, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::u16, element::Type_t::i32>(element::u16, element::i32), generateScatterUpdate3Params<ov::element::Type_t::u16, ov::element::Type_t::i32>(ov::element::u16, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::u16, element::Type_t::i64>(element::u16, element::i64), generateScatterUpdate3Params<ov::element::Type_t::u16, ov::element::Type_t::i64>(ov::element::u16, ov::element::i64),
// u32 // u32
generateScatterUpdate3Params<element::Type_t::u32, element::Type_t::i16>(element::u32, element::i16), generateScatterUpdate3Params<ov::element::Type_t::u32, ov::element::Type_t::i16>(ov::element::u32, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::u32, element::Type_t::i32>(element::u32, element::i32), generateScatterUpdate3Params<ov::element::Type_t::u32, ov::element::Type_t::i32>(ov::element::u32, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::u32, element::Type_t::i64>(element::u32, element::i64), generateScatterUpdate3Params<ov::element::Type_t::u32, ov::element::Type_t::i64>(ov::element::u32, ov::element::i64),
// u64 // u64
generateScatterUpdate3Params<element::Type_t::u64, element::Type_t::i16>(element::u64, element::i16), generateScatterUpdate3Params<ov::element::Type_t::u64, ov::element::Type_t::i16>(ov::element::u64, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::u64, element::Type_t::i32>(element::u64, element::i32), generateScatterUpdate3Params<ov::element::Type_t::u64, ov::element::Type_t::i32>(ov::element::u64, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::u64, element::Type_t::i64>(element::u64, element::i64), generateScatterUpdate3Params<ov::element::Type_t::u64, ov::element::Type_t::i64>(ov::element::u64, ov::element::i64),
// bf16 // bf16
generateScatterUpdate3Params<element::Type_t::bf16, element::Type_t::i16>(element::bf16, element::i16), generateScatterUpdate3Params<ov::element::Type_t::bf16, ov::element::Type_t::i16>(ov::element::bf16, ov::element::i16),
generateScatterUpdate3Params<element::Type_t::bf16, element::Type_t::i32>(element::bf16, element::i32), generateScatterUpdate3Params<ov::element::Type_t::bf16, ov::element::Type_t::i32>(ov::element::bf16, ov::element::i32),
generateScatterUpdate3Params<element::Type_t::bf16, element::Type_t::i64>(element::bf16, element::i64)}; generateScatterUpdate3Params<ov::element::Type_t::bf16, ov::element::Type_t::i64>(ov::element::bf16, ov::element::i64)};
std::vector<ScatterUpdate3Params> combinedParams; std::vector<ScatterUpdate3Params> combinedParams;
for (const auto& params : ScatterUpdateTypeParams) { for (const auto& params : ScatterUpdateTypeParams) {

4
src/plugins/template/tests/functional/op_reference/sin.cpp
View File

@ -56,8 +56,8 @@ INSTANTIATE_TEST_SUITE_P(
smoke_Sin_With_Hardcoded_Refs, ReferenceSinLayerTest, smoke_Sin_With_Hardcoded_Refs, ReferenceSinLayerTest,
::testing::Values( ::testing::Values(
Builder {} Builder {}
.input({{11}, element::f16, std::vector<ngraph::float16> {0.f, 0.25f, -0.25f, 0.5f, -0.5f, 1.f, -1.f, 2.f, -2.f, 4.f, -4.f}}) .input({{11}, element::f16, std::vector<ov::float16> {0.f, 0.25f, -0.25f, 0.5f, -0.5f, 1.f, -1.f, 2.f, -2.f, 4.f, -4.f}})
.expected({{11}, element::f16, std::vector<ngraph::float16> {0.00000000f, .expected({{11}, element::f16, std::vector<ov::float16> {0.00000000f,
0.24740396f, 0.24740396f,
-0.24740396f, -0.24740396f,
0.47942554f, 0.47942554f,

4
src/plugins/template/tests/functional/op_reference/sinh.cpp
View File

@ -56,8 +56,8 @@ INSTANTIATE_TEST_SUITE_P(
smoke_Sinh_With_Hardcoded_Refs, ReferenceSinhLayerTest, smoke_Sinh_With_Hardcoded_Refs, ReferenceSinhLayerTest,
::testing::Values( ::testing::Values(
Builder {} Builder {}
.input({{11}, element::f16, std::vector<ngraph::float16> {-4.f, -2.f, -1.f, -0.5f, -0.25f, 0.f, 0.25f, 0.5f, 1.f, 2.f, 4.f}}) .input({{11}, element::f16, std::vector<ov::float16> {-4.f, -2.f, -1.f, -0.5f, -0.25f, 0.f, 0.25f, 0.5f, 1.f, 2.f, 4.f}})
.expected({{11}, element::f16, std::vector<ngraph::float16> {-27.28991720f, .expected({{11}, element::f16, std::vector<ov::float16> {-27.28991720f,
-3.62686041f, -3.62686041f,
-1.17520120f, -1.17520120f,
-0.52109531f, -0.52109531f,

4
src/plugins/template/tests/functional/op_reference/tanh.cpp
View File

@ -56,8 +56,8 @@ INSTANTIATE_TEST_SUITE_P(
smoke_Tanh_With_Hardcoded_Refs, ReferenceTanhLayerTest, smoke_Tanh_With_Hardcoded_Refs, ReferenceTanhLayerTest,
::testing::Values( ::testing::Values(
Builder {} Builder {}
.input({{11}, element::f16, std::vector<ngraph::float16> {-4.f, -2.f, -1.f, -0.5f, -0.25f, 0.f, 0.25f, 0.5f, 1.f, 2.f, 4.f}}) .input({{11}, element::f16, std::vector<ov::float16> {-4.f, -2.f, -1.f, -0.5f, -0.25f, 0.f, 0.25f, 0.5f, 1.f, 2.f, 4.f}})
.expected({{11}, element::f16, std::vector<ngraph::float16> {-0.99932930f, .expected({{11}, element::f16, std::vector<ov::float16> {-0.99932930f,
-0.96402758f, -0.96402758f,
-0.76159416f, -0.76159416f,
-0.46211716f, -0.46211716f,

32
src/plugins/template/tests/functional/op_reference/tensor_iterator.cpp
View File

@ -10,8 +10,6 @@
#include "base_reference_test.hpp" #include "base_reference_test.hpp"
#include "functional_test_utils/skip_tests_config.hpp" #include "functional_test_utils/skip_tests_config.hpp"
#include "ngraph_functions/builders.hpp"
namespace { namespace {
struct TIFunctionalBase { struct TIFunctionalBase {
virtual std::shared_ptr<ov::Model> create_function(const std::vector<reference_tests::Tensor> &ti_inputs, virtual std::shared_ptr<ov::Model> create_function(const std::vector<reference_tests::Tensor> &ti_inputs,
@ -36,8 +34,8 @@ struct TIDynamicInputs : public TIFunctionalBase {
auto M_body = std::make_shared<ov::opset8::Parameter>(ov::element::f32, ov::PartialShape::dynamic()); auto M_body = std::make_shared<ov::opset8::Parameter>(ov::element::f32, ov::PartialShape::dynamic());
auto body_condition = std::make_shared<ov::opset8::Constant>(ov::element::boolean, ov::Shape{1}, true); auto body_condition = std::make_shared<ov::opset8::Constant>(ov::element::boolean, ov::Shape{1}, true);
auto trip_count = std::make_shared<ov::opset8::Constant>(ngraph::element::i64, ov::Shape{1}, 3); auto trip_count = std::make_shared<ov::opset8::Constant>(ov::element::i64, ov::Shape{1}, 3);
auto exec_condition = std::make_shared<ov::opset8::Constant>(ngraph::element::boolean, ov::Shape{1}, true); auto exec_condition = std::make_shared<ov::opset8::Constant>(ov::element::boolean, ov::Shape{1}, true);
// Body // Body
auto sum = std::make_shared<ov::opset8::Add>(Xi, Yi); auto sum = std::make_shared<ov::opset8::Add>(Xi, Yi);
auto Zo = std::make_shared<ov::opset8::Multiply>(sum, M_body); auto Zo = std::make_shared<ov::opset8::Multiply>(sum, M_body);
@ -297,7 +295,7 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
ov::ResultVector results{std::make_shared<ov::opset8::Result>(unsqueeze), ov::ResultVector results{std::make_shared<ov::opset8::Result>(unsqueeze),
std::make_shared<ov::opset8::Result>(lstm_cell->output(0)), std::make_shared<ov::opset8::Result>(lstm_cell->output(0)),
std::make_shared<ov::opset8::Result>(lstm_cell->output(1))}; std::make_shared<ov::opset8::Result>(lstm_cell->output(1))};
auto body = std::make_shared<ngraph::Function>(results, body_params, "lstm_cell"); auto body = std::make_shared<ov::Model>(results, body_params, "lstm_cell");
tensor_iterator->set_function(body); tensor_iterator->set_function(body);
// 2. Set PortMap // 2. Set PortMap
@ -308,7 +306,7 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
tensor_iterator->set_sliced_input(body_params[0], outer_params[0], -1, -1, 1, 0, params.sequenceAxis); tensor_iterator->set_sliced_input(body_params[0], outer_params[0], -1, -1, 1, 0, params.sequenceAxis);
tensor_iterator->get_concatenated_slices(results[0], -1, -1, 1, 0, params.sequenceAxis); tensor_iterator->get_concatenated_slices(results[0], -1, -1, 1, 0, params.sequenceAxis);
} else { } else {
NGRAPH_CHECK(false, "Bidirectional case is not supported."); OPENVINO_ASSERT(false, "Bidirectional case is not supported.");
} }
tensor_iterator->set_merged_input(body_params[1], outer_params[1], results[1]); tensor_iterator->set_merged_input(body_params[1], outer_params[1], results[1]);
@ -317,7 +315,7 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
tensor_iterator->get_iter_value(results[2]); tensor_iterator->get_iter_value(results[2]);
// 3. Outer function // 3. Outer function
function = std::make_shared<ngraph::Function>(ngraph::OutputVector{tensor_iterator->output(0), tensor_iterator->output(1), function = std::make_shared<ov::Model>(ov::OutputVector{tensor_iterator->output(0), tensor_iterator->output(1),
tensor_iterator->output(2)}, outer_params); tensor_iterator->output(2)}, outer_params);
break; break;
} }
@ -342,7 +340,7 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[1])}; std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[1])};
auto squeeze = std::make_shared<ov::opset8::Squeeze>(body_params[0], axis); auto squeeze = std::make_shared<ov::opset8::Squeeze>(body_params[0], axis);
ngraph::OutputVector out_vector = {squeeze, body_params[1]}; ov::OutputVector out_vector = {squeeze, body_params[1]};
auto W = std::make_shared<ov::opset8::Constant>(params.W.type, params.W.shape, params.W.data.data()); auto W = std::make_shared<ov::opset8::Constant>(params.W.type, params.W.shape, params.W.data.data());
auto R = std::make_shared<ov::opset8::Constant>(params.R.type, params.R.shape, params.R.data.data()); auto R = std::make_shared<ov::opset8::Constant>(params.R.type, params.R.shape, params.R.data.data());
@ -360,9 +358,9 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
false); false);
auto unsqueeze = std::make_shared<ov::opset8::Unsqueeze>(gru_cell->output(0), axis); auto unsqueeze = std::make_shared<ov::opset8::Unsqueeze>(gru_cell->output(0), axis);
ngraph::ResultVector results{std::make_shared<ov::opset8::Result>(gru_cell->output(0)), ov::ResultVector results{std::make_shared<ov::opset8::Result>(gru_cell->output(0)),
std::make_shared<ov::opset8::Result>(unsqueeze)}; std::make_shared<ov::opset8::Result>(unsqueeze)};
auto body = std::make_shared<ngraph::Function>(results, body_params, "gru_cell"); auto body = std::make_shared<ov::Model>(results, body_params, "gru_cell");
tensor_iterator->set_function(body); tensor_iterator->set_function(body);
// 2. Set PortMap // 2. Set PortMap
@ -373,14 +371,14 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
tensor_iterator->set_sliced_input(body_params[0], outer_params[0], -1, -1, 1, 0, params.sequenceAxis); tensor_iterator->set_sliced_input(body_params[0], outer_params[0], -1, -1, 1, 0, params.sequenceAxis);
tensor_iterator->get_concatenated_slices(results[1], -1, -1, 1, 0, params.sequenceAxis); tensor_iterator->get_concatenated_slices(results[1], -1, -1, 1, 0, params.sequenceAxis);
} else { } else {
NGRAPH_CHECK(false, "Bidirectional case is not supported."); OPENVINO_ASSERT(false, "Bidirectional case is not supported.");
} }
tensor_iterator->set_merged_input(body_params[1], outer_params[1], results[0]); tensor_iterator->set_merged_input(body_params[1], outer_params[1], results[0]);
tensor_iterator->get_iter_value(results[0]); tensor_iterator->get_iter_value(results[0]);
// 3. Outer function // 3. Outer function
function = std::make_shared<ngraph::Function>(ngraph::OutputVector{tensor_iterator->output(0), tensor_iterator->output(1)}, outer_params); function = std::make_shared<ov::Model>(ov::OutputVector{tensor_iterator->output(0), tensor_iterator->output(1)}, outer_params);
break; break;
} }
case TensorIteratorBodyType::RNN: { case TensorIteratorBodyType::RNN: {
@ -403,7 +401,7 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
ov::ParameterVector body_params{std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[0]), ov::ParameterVector body_params{std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[0]),
std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[1])}; std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[1])};
auto squeeze = std::make_shared<ov::opset8::Squeeze>(body_params[0], axis); auto squeeze = std::make_shared<ov::opset8::Squeeze>(body_params[0], axis);
ngraph::OutputVector out_vector = {squeeze, body_params[1]}; ov::OutputVector out_vector = {squeeze, body_params[1]};
auto W = std::make_shared<ov::opset8::Constant>(params.W.type, params.W.shape, params.W.data.data()); auto W = std::make_shared<ov::opset8::Constant>(params.W.type, params.W.shape, params.W.data.data());
auto R = std::make_shared<ov::opset8::Constant>(params.R.type, params.R.shape, params.R.data.data()); auto R = std::make_shared<ov::opset8::Constant>(params.R.type, params.R.shape, params.R.data.data());
@ -420,9 +418,9 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
params.clip); params.clip);
auto unsqueeze = std::make_shared<ov::opset8::Unsqueeze>(rnn_cell->output(0), axis); auto unsqueeze = std::make_shared<ov::opset8::Unsqueeze>(rnn_cell->output(0), axis);
ngraph::ResultVector results{std::make_shared<ov::opset8::Result>(rnn_cell), ov::ResultVector results{std::make_shared<ov::opset8::Result>(rnn_cell),
std::make_shared<ov::opset8::Result>(unsqueeze)}; std::make_shared<ov::opset8::Result>(unsqueeze)};
auto body = std::make_shared<ngraph::Function>(results, body_params, "rnn_cell"); auto body = std::make_shared<ov::Model>(results, body_params, "rnn_cell");
tensor_iterator->set_function(body); tensor_iterator->set_function(body);
// 2. Set PortMap // 2. Set PortMap
@ -433,14 +431,14 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
tensor_iterator->set_sliced_input(body_params[0], outer_params[0], -1, -1, 1, 0, params.sequenceAxis); tensor_iterator->set_sliced_input(body_params[0], outer_params[0], -1, -1, 1, 0, params.sequenceAxis);
tensor_iterator->get_concatenated_slices(results[1], -1, -1, 1, 0, params.sequenceAxis); tensor_iterator->get_concatenated_slices(results[1], -1, -1, 1, 0, params.sequenceAxis);
} else { } else {
NGRAPH_CHECK(false, "Bidirectional case is not supported."); OPENVINO_ASSERT(false, "Bidirectional case is not supported.");
} }
tensor_iterator->set_merged_input(body_params[1], outer_params[1], results[0]); tensor_iterator->set_merged_input(body_params[1], outer_params[1], results[0]);
tensor_iterator->get_iter_value(results[0]); tensor_iterator->get_iter_value(results[0]);
// 3. Outer function // 3. Outer function
function = std::make_shared<ngraph::Function>(ngraph::OutputVector{tensor_iterator->output(0), tensor_iterator->output(1)}, outer_params); function = std::make_shared<ov::Model>(ov::OutputVector{tensor_iterator->output(0), tensor_iterator->output(1)}, outer_params);
break; break;
} }
} }

20
src/plugins/template/tests/functional/op_reference/topk.cpp
View File

@ -1479,18 +1479,18 @@ INSTANTIATE_TEST_SUITE_P(smoke_TopK_With_Hardcoded_Refs, ReferenceTopKTestSingle
TEST(ReferenceTopKTestInvalid, topk_v1_invalid_strings) { TEST(ReferenceTopKTestInvalid, topk_v1_invalid_strings) {
const auto data = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 2, 3}); const auto data = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 2, 3});
const auto k = opset1::Constant::create(element::i64, Shape{}, {1}); const auto k = opset1::Constant::create(element::i64, Shape{}, {1});
EXPECT_THROW(opset1::TopK(data, k, 0, "max", "invalid_mode"), ngraph::CheckFailure); EXPECT_THROW(opset1::TopK(data, k, 0, "max", "invalid_mode"), ov::AssertFailure);
EXPECT_THROW(opset1::TopK(data, k, 0, "invalid_sort", "index"), ngraph::CheckFailure); EXPECT_THROW(opset1::TopK(data, k, 0, "invalid_sort", "index"), ov::AssertFailure);
} }
TEST(ReferenceTopKTestInvalid, topk_v1_invalid_k) { TEST(ReferenceTopKTestInvalid, topk_v1_invalid_k) {
const auto data = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 2, 3}); const auto data = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 2, 3});
const auto k_non_scalar = opset1::Constant::create(element::i64, Shape{2}, {1, 2}); const auto k_non_scalar = opset1::Constant::create(element::i64, Shape{2}, {1, 2});
EXPECT_THROW(opset1::TopK(data, k_non_scalar, 0, "max", "index"), ngraph::NodeValidationFailure); EXPECT_THROW(opset1::TopK(data, k_non_scalar, 0, "max", "index"), ov::NodeValidationFailure);
const auto k_float = opset1::Constant::create(element::f32, Shape{}, {1.0f}); const auto k_float = opset1::Constant::create(element::f32, Shape{}, {1.0f});
EXPECT_THROW(opset1::TopK(data, k_float, 0, "max", "index"), ngraph::NodeValidationFailure); EXPECT_THROW(opset1::TopK(data, k_float, 0, "max", "index"), ov::NodeValidationFailure);
const auto k_negative = opset1::Constant::create(element::i8, Shape{}, {-1}); const auto k_negative = opset1::Constant::create(element::i8, Shape{}, {-1});
EXPECT_THROW(opset1::TopK(data, k_negative, 0, "max", "index"), ngraph::NodeValidationFailure); EXPECT_THROW(opset1::TopK(data, k_negative, 0, "max", "index"), ov::NodeValidationFailure);
} }
@ -1641,18 +1641,18 @@ INSTANTIATE_TEST_SUITE_P(smoke_TopK_With_Hardcoded_Refs, ReferenceTopKTestSingle
TEST(ReferenceTopKTestInvalidV3, topk_v3_invalid_strings) { TEST(ReferenceTopKTestInvalidV3, topk_v3_invalid_strings) {
const auto data = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 2, 3}); const auto data = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 2, 3});
const auto k = opset1::Constant::create(element::i64, Shape{}, {1}); const auto k = opset1::Constant::create(element::i64, Shape{}, {1});
EXPECT_THROW(opset3::TopK(data, k, 0, "max", "invalid_mode"), ngraph::CheckFailure); EXPECT_THROW(opset3::TopK(data, k, 0, "max", "invalid_mode"), ov::AssertFailure);
EXPECT_THROW(opset3::TopK(data, k, 0, "invalid_sort", "index"), ngraph::CheckFailure); EXPECT_THROW(opset3::TopK(data, k, 0, "invalid_sort", "index"), ov::AssertFailure);
} }
TEST(ReferenceTopKTestInvalidV3, topk_v3_invalid_k) { TEST(ReferenceTopKTestInvalidV3, topk_v3_invalid_k) {
const auto data = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 2, 3}); const auto data = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 2, 3});
const auto k_non_scalar = opset1::Constant::create(element::i64, Shape{2}, {1, 2}); const auto k_non_scalar = opset1::Constant::create(element::i64, Shape{2}, {1, 2});
EXPECT_THROW(opset3::TopK(data, k_non_scalar, 0, "max", "index"), ngraph::NodeValidationFailure); EXPECT_THROW(opset3::TopK(data, k_non_scalar, 0, "max", "index"), ov::NodeValidationFailure);
const auto k_float = opset1::Constant::create(element::f32, Shape{}, {1.0f}); const auto k_float = opset1::Constant::create(element::f32, Shape{}, {1.0f});
EXPECT_THROW(opset3::TopK(data, k_float, 0, "max", "index"), ngraph::NodeValidationFailure); EXPECT_THROW(opset3::TopK(data, k_float, 0, "max", "index"), ov::NodeValidationFailure);
const auto k_negative = opset1::Constant::create(element::i8, Shape{}, {-1}); const auto k_negative = opset1::Constant::create(element::i8, Shape{}, {-1});
EXPECT_THROW(opset3::TopK(data, k_negative, 0, "max", "index"), ngraph::NodeValidationFailure); EXPECT_THROW(opset3::TopK(data, k_negative, 0, "max", "index"), ov::NodeValidationFailure);
} }
class ReferenceTopKv11StableTest : public ReferenceTopKTest { class ReferenceTopKv11StableTest : public ReferenceTopKTest {

42
src/tests/test_utils/common_test_utils/include/common_test_utils/test_enums.hpp Normal file
View File

@ -0,0 +1,42 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#pragma once
namespace ov {
namespace test {
namespace utils {
enum ComparisonTypes {
EQUAL,
NOT_EQUAL,
IS_FINITE,
IS_INF,
IS_NAN,
LESS,
LESS_EQUAL,
GREATER,
GREATER_EQUAL
};
enum ConversionTypes {
CONVERT,
CONVERT_LIKE
};
enum ReductionType {
Mean,
Max,
Min,
Prod,
Sum,
LogicalOr,
LogicalAnd,
L1,
L2
};
} // namespace utils
} // namespace test
} // namespace ov