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

Remove legacy headers and namespaces from C-F type prop tests (#19332)

Browse Source
This commit is contained in:
Ilya Churaev 2023-08-24 06:56:53 +04:00 committed by GitHub
parent b77e47970d
commit 475ce744af
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
37 changed files with 1781 additions and 1676 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/core/tests/type_prop/ceiling.cpp
View File

@ -4,6 +4,6 @@
#include "unary_ops.hpp" #include "unary_ops.hpp"
using Type = ::testing::Types<ngraph::op::Ceiling>; using Type = ::testing::Types<ov::op::v0::Ceiling>;
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_ceiling, UnaryOperator, Type); INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_ceiling, UnaryOperator, Type);

84
src/core/tests/type_prop/clamp.cpp
View File

@ -2,74 +2,82 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include "openvino/op/clamp.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h" #include "openvino/op/constant.hpp"
#include "ngraph/ngraph.hpp" #include "openvino/op/gather.hpp"
#include "openvino/op/reshape.hpp"
#include "openvino/op/shape_of.hpp"
using namespace std; using namespace std;
using namespace ngraph;
TEST(type_prop, clamp_basic_f32) { TEST(type_prop, clamp_basic_f32) {
auto data = make_shared<op::Parameter>(element::f32, Shape{1, 32, 32}); auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 32, 32});
auto clamp = make_shared<op::Clamp>(data, 0.0, 2.1); auto clamp = make_shared<ov::op::v0::Clamp>(data, 0.0, 2.1);
ASSERT_EQ(clamp->get_element_type(), element::f32); ASSERT_EQ(clamp->get_element_type(), ov::element::f32);
ASSERT_EQ(clamp->get_min(), 0.0); ASSERT_EQ(clamp->get_min(), 0.0);
ASSERT_EQ(clamp->get_max(), 2.1); ASSERT_EQ(clamp->get_max(), 2.1);
ASSERT_EQ(clamp->get_output_shape(0), (Shape{1, 32, 32})); ASSERT_EQ(clamp->get_output_shape(0), (ov::Shape{1, 32, 32}));
} }
TEST(type_prop, clamp_basic_i32) { TEST(type_prop, clamp_basic_i32) {
auto data = make_shared<op::Parameter>(element::i32, Shape{1, 32, 32}); auto data = make_shared<ov::op::v0::Parameter>(ov::element::i32, ov::Shape{1, 32, 32});
auto clamp = make_shared<op::Clamp>(data, 0.0, 2.1); auto clamp = make_shared<ov::op::v0::Clamp>(data, 0.0, 2.1);
ASSERT_EQ(clamp->get_element_type(), element::i32); ASSERT_EQ(clamp->get_element_type(), ov::element::i32);
ASSERT_EQ(clamp->get_min(), 0.0); ASSERT_EQ(clamp->get_min(), 0.0);
ASSERT_EQ(clamp->get_max(), 2.1); ASSERT_EQ(clamp->get_max(), 2.1);
ASSERT_EQ(clamp->get_output_shape(0), (Shape{1, 32, 32})); ASSERT_EQ(clamp->get_output_shape(0), (ov::Shape{1, 32, 32}));
} }
TEST(type_prop, clamp_shape_static_rank) { TEST(type_prop, clamp_shape_static_rank) {
auto data = make_shared<op::Parameter>(element::f16, PartialShape{Dimension::dynamic(), Dimension::dynamic(), 32}); auto data =
auto clamp = make_shared<op::Clamp>(data, -2.1, 2.1); make_shared<ov::op::v0::Parameter>(ov::element::f16,
ov::PartialShape{ov::Dimension::dynamic(), ov::Dimension::dynamic(), 32});
auto clamp = make_shared<ov::op::v0::Clamp>(data, -2.1, 2.1);
ASSERT_EQ(clamp->get_element_type(), element::f16); ASSERT_EQ(clamp->get_element_type(), ov::element::f16);
ASSERT_EQ(clamp->get_min(), -2.1); ASSERT_EQ(clamp->get_min(), -2.1);
ASSERT_EQ(clamp->get_max(), 2.1); ASSERT_EQ(clamp->get_max(), 2.1);
ASSERT_EQ(clamp->get_output_partial_shape(0), (PartialShape{Dimension::dynamic(), Dimension::dynamic(), 32})); ASSERT_EQ(clamp->get_output_partial_shape(0),
(ov::PartialShape{ov::Dimension::dynamic(), ov::Dimension::dynamic(), 32}));
} }
TEST(type_prop, clamp_shape_dynamic) { TEST(type_prop, clamp_shape_dynamic) {
auto data = make_shared<op::Parameter>(element::u16, PartialShape::dynamic()); auto data = make_shared<ov::op::v0::Parameter>(ov::element::u16, ov::PartialShape::dynamic());
auto clamp = make_shared<op::Clamp>(data, 1.5, 15.0); auto clamp = make_shared<ov::op::v0::Clamp>(data, 1.5, 15.0);
ASSERT_EQ(clamp->get_element_type(), element::u16); ASSERT_EQ(clamp->get_element_type(), ov::element::u16);
ASSERT_EQ(clamp->get_min(), 1.5); ASSERT_EQ(clamp->get_min(), 1.5);
ASSERT_EQ(clamp->get_max(), 15.0); ASSERT_EQ(clamp->get_max(), 15.0);
ASSERT_EQ(clamp->get_output_partial_shape(0), (PartialShape::dynamic())); ASSERT_EQ(clamp->get_output_partial_shape(0), (ov::PartialShape::dynamic()));
} }
TEST(type_prop, clamp_evaluate_bounds) { TEST(type_prop, clamp_evaluate_bounds) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{Dimension(1, 8), 2, 3}); auto param = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{ov::Dimension(1, 8), 2, 3});
auto shape_of = make_shared<op::v3::ShapeOf>(param); auto shape_of = make_shared<ov::op::v3::ShapeOf>(param);
auto gather = make_shared<op::v1::Gather>(shape_of, auto gather = make_shared<ov::op::v1::Gather>(shape_of,
op::Constant::create(element::i64, {3}, {2, 1, 0}), ov::op::v0::Constant::create(ov::element::i64, {3}, {2, 1, 0}),
op::Constant::create(element::i64, {}, {0})); ov::op::v0::Constant::create(ov::element::i64, {}, {0}));
auto clamp = make_shared<op::Clamp>(gather, 0, 5); auto clamp = make_shared<ov::op::v0::Clamp>(gather, 0, 5);
auto r = make_shared<op::v1::Reshape>(param, clamp, false); auto r = make_shared<ov::op::v1::Reshape>(param, clamp, false);
ASSERT_EQ(r->get_element_type(), element::f32); ASSERT_EQ(r->get_element_type(), ov::element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), PartialShape({3, 2, Dimension(1, 5)})); ASSERT_EQ(r->get_output_partial_shape(0), ov::PartialShape({3, 2, ov::Dimension(1, 5)}));
} }
TEST(type_prop, clamp_invalid_element_type) { TEST(type_prop, clamp_invalid_element_type) {
auto data = make_shared<op::Parameter>(element::boolean, Shape{2, 2}); auto data = make_shared<ov::op::v0::Parameter>(ov::element::boolean, ov::Shape{2, 2});
try { try {
auto clamp = make_shared<op::Clamp>(data, 0.5, 5.5); auto clamp = make_shared<ov::op::v0::Clamp>(data, 0.5, 5.5);
// Input element type is boolean // Input element type is boolean
FAIL() << "Invalid boolean element type for input not detected"; FAIL() << "Invalid boolean element type for input not detected";
} catch (const NodeValidationFailure& error) { } catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), "Input element type must be numeric"); EXPECT_HAS_SUBSTRING(error.what(), "Input element type must be numeric");
} catch (...) { } catch (...) {
FAIL() << "Numeric element type node validation check failed for unexpected reason"; FAIL() << "Numeric element type node validation check failed for unexpected reason";
@ -77,23 +85,23 @@ TEST(type_prop, clamp_invalid_element_type) {
} }
TEST(type_prop, clamp_equal_attributes) { TEST(type_prop, clamp_equal_attributes) {
auto data = make_shared<op::Parameter>(element::f64, Shape{2, 2}); auto data = make_shared<ov::op::v0::Parameter>(ov::element::f64, ov::Shape{2, 2});
auto clamp = make_shared<op::Clamp>(data, 1.0, 1.0); auto clamp = make_shared<ov::op::v0::Clamp>(data, 1.0, 1.0);
ASSERT_EQ(clamp->get_element_type(), element::f64); ASSERT_EQ(clamp->get_element_type(), ov::element::f64);
ASSERT_EQ(clamp->get_min(), 1.0); ASSERT_EQ(clamp->get_min(), 1.0);
ASSERT_EQ(clamp->get_max(), 1.0); ASSERT_EQ(clamp->get_max(), 1.0);
ASSERT_EQ(clamp->get_output_shape(0), (Shape{2, 2})); ASSERT_EQ(clamp->get_output_shape(0), (ov::Shape{2, 2}));
} }
TEST(type_prop, clamp_invalid_attributes) { TEST(type_prop, clamp_invalid_attributes) {
auto data = make_shared<op::Parameter>(element::f64, Shape{2, 2}); auto data = make_shared<ov::op::v0::Parameter>(ov::element::f64, ov::Shape{2, 2});
try { try {
auto clamp = make_shared<op::Clamp>(data, 2.0, 1.0); auto clamp = make_shared<ov::op::v0::Clamp>(data, 2.0, 1.0);
// Attribute 'max' not greater than 'min' // Attribute 'max' not greater than 'min'
FAIL() << "Attribute 'min' bigger than 'max' not detected"; FAIL() << "Attribute 'min' bigger than 'max' not detected";
} catch (const NodeValidationFailure& error) { } catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), "Attribute 'min' must be less or equal than 'max'"); EXPECT_HAS_SUBSTRING(error.what(), "Attribute 'min' must be less or equal than 'max'");
} catch (...) { } catch (...) {
FAIL() << "'min' and 'max' attributes node validation check failed for unexpected reason"; FAIL() << "'min' and 'max' attributes node validation check failed for unexpected reason";

377
src/core/tests/type_prop/concat.cpp
View File

@ -2,39 +2,43 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include "openvino/op/concat.hpp"
#include <gmock/gmock.h>
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gmock/gmock.h"
#include "ngraph/ngraph.hpp"
#include "openvino/core/dimension_tracker.hpp" #include "openvino/core/dimension_tracker.hpp"
#include "openvino/op/broadcast.hpp"
#include "openvino/op/convert.hpp"
#include "openvino/op/shape_of.hpp"
#include "openvino/pass/graph_rewrite.hpp" #include "openvino/pass/graph_rewrite.hpp"
using namespace std; using namespace std;
using namespace ngraph;
using namespace testing; using namespace testing;
TEST(type_prop, concat_deduce) { TEST(type_prop, concat_deduce) {
// Deduce type // Deduce type
auto param0 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4}); auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{2, 7, 4}); auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 7, 4});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 2, 4}); auto param2 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2, 4});
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2}, 1); auto c = make_shared<ov::op::v0::Concat>(ov::NodeVector{param0, param1, param2}, 1);
EXPECT_EQ(c->get_element_type(), element::f32); EXPECT_EQ(c->get_element_type(), ov::element::f32);
ASSERT_EQ(c->get_shape(), (Shape{2, 12, 4})); ASSERT_EQ(c->get_shape(), (ov::Shape{2, 12, 4}));
} }
TEST(type_prop, concat_deduce_wrong_rank) { TEST(type_prop, concat_deduce_wrong_rank) {
auto param0 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4}); auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{2, 7, 4}); auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 7, 4});
auto param2 = make_shared<op::Parameter>(element::f32, auto param2 = make_shared<ov::op::v0::Parameter>(ov::element::f32,
Shape{ ov::Shape{
2, 2,
2, 2,
}); });
try { try {
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2}, 1); auto c = make_shared<ov::op::v0::Concat>(ov::NodeVector{param0, param1, param2}, 1);
// Should have thrown, so fail if it didn't // Should have thrown, so fail if it didn't
FAIL() << "Deduced type should disagree with specified type"; FAIL() << "Deduced type should disagree with specified type";
} catch (const NodeValidationFailure& error) { } catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), EXPECT_HAS_SUBSTRING(error.what(),
std::string("Argument shapes are inconsistent; they must have the same rank, and must " std::string("Argument shapes are inconsistent; they must have the same rank, and must "
"have equal dimension everywhere except on the concatenation axis")); "have equal dimension everywhere except on the concatenation axis"));
@ -44,14 +48,14 @@ TEST(type_prop, concat_deduce_wrong_rank) {
} }
TEST(type_prop, concat_deduce_wrong_shape) { TEST(type_prop, concat_deduce_wrong_shape) {
auto param0 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4}); auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{2, 7, 4}); auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 7, 4});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 2, 5}); auto param2 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2, 5});
try { try {
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2}, 1); auto c = make_shared<ov::op::v0::Concat>(ov::NodeVector{param0, param1, param2}, 1);
// Should have thrown, so fail if it didn't // Should have thrown, so fail if it didn't
FAIL() << "Deduced type should disagree with specified type"; FAIL() << "Deduced type should disagree with specified type";
} catch (const NodeValidationFailure& error) { } catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), EXPECT_HAS_SUBSTRING(error.what(),
std::string("Argument shapes are inconsistent; they must have the same rank, and must " std::string("Argument shapes are inconsistent; they must have the same rank, and must "
"have equal dimension everywhere except on the concatenation axis")); "have equal dimension everywhere except on the concatenation axis"));
@ -61,14 +65,14 @@ TEST(type_prop, concat_deduce_wrong_shape) {
} }
TEST(type_prop, concat_deduce_axis_oob) { TEST(type_prop, concat_deduce_axis_oob) {
auto param0 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4}); auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{2, 7, 4}); auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 7, 4});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 2, 5}); auto param2 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2, 5});
try { try {
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2}, 3); auto c = make_shared<ov::op::v0::Concat>(ov::NodeVector{param0, param1, param2}, 3);
// Should have thrown, so fail if it didn't // Should have thrown, so fail if it didn't
FAIL() << "Deduced type should disagree with specified type"; FAIL() << "Deduced type should disagree with specified type";
} catch (const NodeValidationFailure& error) { } catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("Concatenation axis (3) is out of bounds")); EXPECT_HAS_SUBSTRING(error.what(), std::string("Concatenation axis (3) is out of bounds"));
} catch (...) { } catch (...) {
FAIL() << "Deduced type check failed for unexpected reason"; FAIL() << "Deduced type check failed for unexpected reason";
@ -77,23 +81,23 @@ TEST(type_prop, concat_deduce_axis_oob) {
TEST(type_prop, concat_deduce_axis_barely_in_bounds) { TEST(type_prop, concat_deduce_axis_barely_in_bounds) {
// Deduce type // Deduce type
auto param0 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4}); auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 8}); auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 8});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 12}); auto param2 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 12});
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2}, 2); auto c = make_shared<ov::op::v0::Concat>(ov::NodeVector{param0, param1, param2}, 2);
EXPECT_EQ(c->get_element_type(), element::f32); EXPECT_EQ(c->get_element_type(), ov::element::f32);
ASSERT_EQ(c->get_shape(), (Shape{2, 3, 24})); ASSERT_EQ(c->get_shape(), (ov::Shape{2, 3, 24}));
} }
TEST(type_prop, concat_deduce_elem_type_mismatch) { TEST(type_prop, concat_deduce_elem_type_mismatch) {
auto param0 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4}); auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4});
auto param1 = make_shared<op::Parameter>(element::i32, Shape{2, 7, 4}); auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::i32, ov::Shape{2, 7, 4});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 2, 4}); auto param2 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2, 4});
try { try {
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2}, 1); auto c = make_shared<ov::op::v0::Concat>(ov::NodeVector{param0, param1, param2}, 1);
// Should have thrown, so fail if it didn't // Should have thrown, so fail if it didn't
FAIL() << "Deduced type should disagree with specified type"; FAIL() << "Deduced type should disagree with specified type";
} catch (const NodeValidationFailure& error) { } catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("Argument element types are inconsistent")); EXPECT_HAS_SUBSTRING(error.what(), std::string("Argument element types are inconsistent"));
} catch (...) { } catch (...) {
FAIL() << "Deduced type check failed for unexpected reason"; FAIL() << "Deduced type check failed for unexpected reason";
@ -101,24 +105,24 @@ TEST(type_prop, concat_deduce_elem_type_mismatch) {
} }
TEST(type_prop, concat_partial_et_consistent) { TEST(type_prop, concat_partial_et_consistent) {
auto param0 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4}); auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4});
auto param1 = make_shared<op::Parameter>(element::dynamic, Shape{2, 7, 4}); auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::dynamic, ov::Shape{2, 7, 4});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 2, 4}); auto param2 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2, 4});
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2}, 1); auto c = make_shared<ov::op::v0::Concat>(ov::NodeVector{param0, param1, param2}, 1);
EXPECT_EQ(c->get_element_type(), element::f32); EXPECT_EQ(c->get_element_type(), ov::element::f32);
ASSERT_EQ(c->get_shape(), (Shape{2, 12, 4})); ASSERT_EQ(c->get_shape(), (ov::Shape{2, 12, 4}));
} }
TEST(type_prop, concat_partial_et_inconsistent) { TEST(type_prop, concat_partial_et_inconsistent) {
auto param0 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4}); auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4});
auto param1 = make_shared<op::Parameter>(element::dynamic, Shape{2, 7, 4}); auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::dynamic, ov::Shape{2, 7, 4});
auto param2 = make_shared<op::Parameter>(element::i32, Shape{2, 2, 4}); auto param2 = make_shared<ov::op::v0::Parameter>(ov::element::i32, ov::Shape{2, 2, 4});
try { try {
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2}, 1); auto c = make_shared<ov::op::v0::Concat>(ov::NodeVector{param0, param1, param2}, 1);
// Should have thrown, so fail if it didn't // Should have thrown, so fail if it didn't
FAIL() << "Inconsistent element types not detected (some dynamic)"; FAIL() << "Inconsistent element types not detected (some dynamic)";
} catch (const NodeValidationFailure& error) { } catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("Argument element types are inconsistent")); EXPECT_HAS_SUBSTRING(error.what(), std::string("Argument element types are inconsistent"));
} catch (...) { } catch (...) {
FAIL() << "Deduced type check failed for unexpected reason"; FAIL() << "Deduced type check failed for unexpected reason";
@ -126,15 +130,17 @@ TEST(type_prop, concat_partial_et_inconsistent) {
} }
TEST(type_prop, concat_partial_some_rank_dynamic_others_rank_static_dynamic_rank_inconsistent) { TEST(type_prop, concat_partial_some_rank_dynamic_others_rank_static_dynamic_rank_inconsistent) {
auto param0 = make_shared<op::Parameter>(element::f32, PartialShape{2, Dimension::dynamic(), 3}); auto param0 =
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic()); make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, ov::Dimension::dynamic(), 3});
auto param2 = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, Dimension::dynamic(), 4}); auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape::dynamic());
auto param2 =
make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, ov::Dimension::dynamic(), 4});
try { try {
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2}, 1); auto c = make_shared<ov::op::v0::Concat>(ov::NodeVector{param0, param1, param2}, 1);
// Should have thrown, so fail if it didn't // Should have thrown, so fail if it didn't
FAIL() << "Inconsistent ranks not detected (some args rank-dynamic, some args rank-static " FAIL() << "Inconsistent ranks not detected (some args rank-dynamic, some args rank-static "
"dynamic)"; "dynamic)";
} catch (const NodeValidationFailure& error) { } catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), EXPECT_HAS_SUBSTRING(error.what(),
std::string("Argument shapes are inconsistent; they must have the same rank, and must " std::string("Argument shapes are inconsistent; they must have the same rank, and must "
"have equal dimension everywhere except on the concatenation axis")); "have equal dimension everywhere except on the concatenation axis"));
@ -144,15 +150,17 @@ TEST(type_prop, concat_partial_some_rank_dynamic_others_rank_static_dynamic_rank
} }
TEST(type_prop, concat_partial_some_rank_dynamic_others_rank_static_dynamic_dims_inconsistent) { TEST(type_prop, concat_partial_some_rank_dynamic_others_rank_static_dynamic_dims_inconsistent) {
auto param0 = make_shared<op::Parameter>(element::f32, PartialShape{2, Dimension::dynamic(), 3}); auto param0 =
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic()); make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, ov::Dimension::dynamic(), 3});
auto param2 = make_shared<op::Parameter>(element::f32, PartialShape{3, 3, Dimension::dynamic()}); auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape::dynamic());
auto param2 =
make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{3, 3, ov::Dimension::dynamic()});
try { try {
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2}, 1); auto c = make_shared<ov::op::v0::Concat>(ov::NodeVector{param0, param1, param2}, 1);
// Should have thrown, so fail if it didn't // Should have thrown, so fail if it didn't
FAIL() << "Inconsistent dimensions not detected (some args rank-dynamic, some args " FAIL() << "Inconsistent dimensions not detected (some args rank-dynamic, some args "
"rank-static dynamic)"; "rank-static dynamic)";
} catch (const NodeValidationFailure& error) { } catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), EXPECT_HAS_SUBSTRING(error.what(),
std::string("Argument shapes are inconsistent; they must have the same rank, and must " std::string("Argument shapes are inconsistent; they must have the same rank, and must "
"have equal dimension everywhere except on the concatenation axis")); "have equal dimension everywhere except on the concatenation axis"));
@ -162,16 +170,20 @@ TEST(type_prop, concat_partial_some_rank_dynamic_others_rank_static_dynamic_dims
} }
TEST(type_prop, concat_partial_some_rank_dynamic_others_rank_static_dynamic_dims_intransitively_inconsistent) { TEST(type_prop, concat_partial_some_rank_dynamic_others_rank_static_dynamic_dims_intransitively_inconsistent) {
auto param0 = make_shared<op::Parameter>(element::f32, PartialShape{2, Dimension::dynamic(), 3}); auto param0 =
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic()); make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, ov::Dimension::dynamic(), 3});
auto param2 = make_shared<op::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 3, Dimension::dynamic()}); auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape::dynamic());
auto param3 = make_shared<op::Parameter>(element::f32, PartialShape{3, 3, Dimension::dynamic()}); auto param2 =
make_shared<ov::op::v0::Parameter>(ov::element::f32,
ov::PartialShape{ov::Dimension::dynamic(), 3, ov::Dimension::dynamic()});
auto param3 =
make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{3, 3, ov::Dimension::dynamic()});
try { try {
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2, param3}, 1); auto c = make_shared<ov::op::v0::Concat>(ov::NodeVector{param0, param1, param2, param3}, 1);
// Should have thrown, so fail if it didn't // Should have thrown, so fail if it didn't
FAIL() << "Inconsistent dimensions not detected (some args rank-dynamic, some args " FAIL() << "Inconsistent dimensions not detected (some args rank-dynamic, some args "
"rank-static dynamic)"; "rank-static dynamic)";
} catch (const NodeValidationFailure& error) { } catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), EXPECT_HAS_SUBSTRING(error.what(),
std::string("Argument shapes are inconsistent; they must have the same rank, and must " std::string("Argument shapes are inconsistent; they must have the same rank, and must "
"have equal dimension everywhere except on the concatenation axis")); "have equal dimension everywhere except on the concatenation axis"));
@ -181,16 +193,17 @@ TEST(type_prop, concat_partial_some_rank_dynamic_others_rank_static_dynamic_dims
} }
TEST(type_prop, concat_partial_some_rank_dynamic_others_rank_static_with_concat_axis_static_dims_inconsistent) { TEST(type_prop, concat_partial_some_rank_dynamic_others_rank_static_with_concat_axis_static_dims_inconsistent) {
auto param0 = make_shared<op::Parameter>(element::f32, PartialShape{2, 2, 3}); auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 2, 3});
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic()); auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape::dynamic());
auto param2 = make_shared<op::Parameter>(element::f32, PartialShape{3, 3, Dimension::dynamic()}); auto param2 =
make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{3, 3, ov::Dimension::dynamic()});
try { try {
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2}, 1); auto c = make_shared<ov::op::v0::Concat>(ov::NodeVector{param0, param1, param2}, 1);
// Should have thrown, so fail if it didn't // Should have thrown, so fail if it didn't
FAIL() << "Inconsistent dimensions not detected (some args rank-dynamic, some args " FAIL() << "Inconsistent dimensions not detected (some args rank-dynamic, some args "
"rank-static dynamic)"; "rank-static dynamic)";
} catch (const NodeValidationFailure& error) { } catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), EXPECT_HAS_SUBSTRING(error.what(),
std::string("Argument shapes are inconsistent; they must have the same rank, and must " std::string("Argument shapes are inconsistent; they must have the same rank, and must "
"have equal dimension everywhere except on the concatenation axis")); "have equal dimension everywhere except on the concatenation axis"));
@ -200,24 +213,28 @@ TEST(type_prop, concat_partial_some_rank_dynamic_others_rank_static_with_concat_
} }
TEST(type_prop, concat_partial_all_static_with_concat_axis_static_compatible_result_static) { TEST(type_prop, concat_partial_all_static_with_concat_axis_static_compatible_result_static) {
auto param0 = make_shared<op::Parameter>(element::f32, PartialShape{2, 2, 3}); auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 2, 3});
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 4, 3}); auto param1 =
auto param2 = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, Dimension::dynamic()}); make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{ov::Dimension::dynamic(), 4, 3});
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2}, 1); auto param2 =
make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, ov::Dimension::dynamic()});
auto c = make_shared<ov::op::v0::Concat>(ov::NodeVector{param0, param1, param2}, 1);
ASSERT_EQ(c->get_shape(), (Shape{2, 9, 3})); ASSERT_EQ(c->get_shape(), (ov::Shape{2, 9, 3}));
} }
TEST(type_prop, concat_partial_all_static_with_concat_axis_static_dims_incompatible) { TEST(type_prop, concat_partial_all_static_with_concat_axis_static_dims_incompatible) {
auto param0 = make_shared<op::Parameter>(element::f32, PartialShape{2, 2, 3}); auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 2, 3});
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 4, 3}); auto param1 =
auto param2 = make_shared<op::Parameter>(element::f32, PartialShape{3, 3, Dimension::dynamic()}); make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{ov::Dimension::dynamic(), 4, 3});
auto param2 =
make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{3, 3, ov::Dimension::dynamic()});
try { try {
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2}, 1); auto c = make_shared<ov::op::v0::Concat>(ov::NodeVector{param0, param1, param2}, 1);
// Should have thrown, so fail if it didn't // Should have thrown, so fail if it didn't
FAIL() << "Inconsistent dimensions not detected (some args rank-dynamic, some args " FAIL() << "Inconsistent dimensions not detected (some args rank-dynamic, some args "
"rank-static dynamic)"; "rank-static dynamic)";
} catch (const NodeValidationFailure& error) { } catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), EXPECT_HAS_SUBSTRING(error.what(),
std::string("Argument shapes are inconsistent; they must have the same rank, and must " std::string("Argument shapes are inconsistent; they must have the same rank, and must "
"have equal dimension everywhere except on the concatenation axis")); "have equal dimension everywhere except on the concatenation axis"));
@ -227,26 +244,26 @@ TEST(type_prop, concat_partial_all_static_with_concat_axis_static_dims_incompati
} }
TEST(type_prop, concat_partial_negative_axis_correct) { TEST(type_prop, concat_partial_negative_axis_correct) {
auto param0 = make_shared<op::Parameter>(element::f32, Shape{3, 2, 4}); auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{3, 2, 4});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{7, 2, 4}); auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{7, 2, 4});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 2, 4}); auto param2 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2, 4});
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2}, -3); auto c = make_shared<ov::op::v0::Concat>(ov::NodeVector{param0, param1, param2}, -3);
EXPECT_EQ(c->get_element_type(), element::f32); EXPECT_EQ(c->get_element_type(), ov::element::f32);
ASSERT_EQ(c->get_shape(), (Shape{12, 2, 4})); ASSERT_EQ(c->get_shape(), (ov::Shape{12, 2, 4}));
} }
TEST(type_prop, concat_partial_negative_axis_incorrect) { TEST(type_prop, concat_partial_negative_axis_incorrect) {
auto param0 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4}); auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{2, 7, 4}); auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 7, 4});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 2, 4}); auto param2 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2, 4});
try { try {
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2}, -4); auto c = make_shared<ov::op::v0::Concat>(ov::NodeVector{param0, param1, param2}, -4);
// Should have thrown, so fail if it didn't // Should have thrown, so fail if it didn't
FAIL() << "Incorrect negative axis value not detected (out of bounds)"; FAIL() << "Incorrect negative axis value not detected (out of bounds)";
} catch (const NodeValidationFailure& error) { } catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("Concatenation axis (-1) is out of bounds")); EXPECT_HAS_SUBSTRING(error.what(), std::string("Concatenation axis (-1) is out of bounds"));
} catch (...) { } catch (...) {
FAIL() << "Deduced type check failed for unexpected reason"; FAIL() << "Deduced type check failed for unexpected reason";
@ -255,26 +272,26 @@ TEST(type_prop, concat_partial_negative_axis_incorrect) {
/** \brief Test uses evaluate lower/upper and label of concat op. */ /** \brief Test uses evaluate lower/upper and label of concat op. */
TEST(type_prop, concat_dynamic_value_and_label_propagation) { TEST(type_prop, concat_dynamic_value_and_label_propagation) {
Dimension marked_0 = Dimension(3); ov::Dimension marked_0 = ov::Dimension(3);
ov::DimensionTracker::set_label(marked_0, 10); ov::DimensionTracker::set_label(marked_0, 10);
PartialShape target_0 = PartialShape{marked_0, 4}; ov::PartialShape target_0 = ov::PartialShape{marked_0, 4};
Dimension marked_1 = Dimension(5); ov::Dimension marked_1 = ov::Dimension(5);
ov::DimensionTracker::set_label(marked_1, 15); ov::DimensionTracker::set_label(marked_1, 15);
PartialShape target_1 = PartialShape{4, marked_1, 9}; ov::PartialShape target_1 = ov::PartialShape{4, marked_1, 9};
auto param = make_shared<op::Parameter>(element::f32, Shape{1}); auto param = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1});
auto param_0 = make_shared<op::Parameter>(element::f32, target_0); auto param_0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, target_0);
auto shape_0 = make_shared<op::ShapeOf>(param_0); auto shape_0 = make_shared<ov::op::v0::ShapeOf>(param_0);
auto param_1 = make_shared<op::Parameter>(element::f32, target_1); auto param_1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, target_1);
auto shape_1 = make_shared<op::ShapeOf>(param_1); auto shape_1 = make_shared<ov::op::v0::ShapeOf>(param_1);
auto five = op::Constant::create(element::i64, {1}, {5}); auto five = ov::op::v0::Constant::create(ov::element::i64, {1}, {5});
auto target_shape = std::make_shared<op::Concat>(OutputVector{shape_0, five, shape_1}, 0); auto target_shape = std::make_shared<ov::op::v0::Concat>(ov::OutputVector{shape_0, five, shape_1}, 0);
auto bc = make_shared<op::v1::Broadcast>(param, target_shape); auto bc = make_shared<ov::op::v1::Broadcast>(param, target_shape);
EXPECT_EQ(bc->get_shape(), (Shape{3, 4, 5, 4, 5, 9})); EXPECT_EQ(bc->get_shape(), (ov::Shape{3, 4, 5, 4, 5, 9}));
const auto& output_shape = bc->get_output_partial_shape(0); const auto& output_shape = bc->get_output_partial_shape(0);
const auto labels = get_shape_labels(output_shape); const auto labels = get_shape_labels(output_shape);
@ -283,30 +300,30 @@ TEST(type_prop, concat_dynamic_value_and_label_propagation) {
/** \brief Test uses evaluate lower/upper and label of concat op. */ /** \brief Test uses evaluate lower/upper and label of concat op. */
TEST(type_prop, concat_dynamic_value_and_label_propagation_1) { TEST(type_prop, concat_dynamic_value_and_label_propagation_1) {
Dimension marked_0 = Dimension(3); ov::Dimension marked_0 = ov::Dimension(3);
ov::DimensionTracker::set_label(marked_0, 1000); ov::DimensionTracker::set_label(marked_0, 1000);
PartialShape target_0 = PartialShape{marked_0, 4}; ov::PartialShape target_0 = ov::PartialShape{marked_0, 4};
Dimension marked_1 = Dimension(5); ov::Dimension marked_1 = ov::Dimension(5);
ov::DimensionTracker::set_label(marked_1, 1500); ov::DimensionTracker::set_label(marked_1, 1500);
PartialShape target_1 = PartialShape{4, marked_1, 9}; ov::PartialShape target_1 = ov::PartialShape{4, marked_1, 9};
auto param = make_shared<op::Parameter>(element::f32, Shape{1}); auto param = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1});
auto param_0 = make_shared<op::Parameter>(element::f32, target_0); auto param_0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, target_0);
auto shape_0 = make_shared<op::ShapeOf>(param_0); auto shape_0 = make_shared<ov::op::v0::ShapeOf>(param_0);
auto convert_0 = make_shared<op::Convert>(shape_0, element::i8); auto convert_0 = make_shared<ov::op::v0::Convert>(shape_0, ov::element::i8);
auto param_1 = make_shared<op::Parameter>(element::f32, target_1); auto param_1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, target_1);
auto shape_1 = make_shared<op::ShapeOf>(param_1); auto shape_1 = make_shared<ov::op::v0::ShapeOf>(param_1);
auto convert_1 = make_shared<op::Convert>(shape_1, element::i8); auto convert_1 = make_shared<ov::op::v0::Convert>(shape_1, ov::element::i8);
auto five = op::Constant::create(element::i8, {1}, {5}); auto five = ov::op::v0::Constant::create(ov::element::i8, {1}, {5});
auto target_shape = std::make_shared<op::Concat>(OutputVector{convert_0, five, convert_1}, 0); auto target_shape = std::make_shared<ov::op::v0::Concat>(ov::OutputVector{convert_0, five, convert_1}, 0);
auto convert = make_shared<op::Convert>(target_shape, element::i64); auto convert = std::make_shared<ov::op::v0::Convert>(target_shape, ov::element::i64);
auto bc = make_shared<op::v1::Broadcast>(param, target_shape); auto bc = make_shared<ov::op::v1::Broadcast>(param, target_shape);
EXPECT_EQ(bc->get_shape(), (Shape{3, 4, 5, 4, 5, 9})); EXPECT_EQ(bc->get_shape(), (ov::Shape{3, 4, 5, 4, 5, 9}));
const auto& output_shape = bc->get_output_partial_shape(0); const auto& output_shape = bc->get_output_partial_shape(0);
const auto labels = get_shape_labels(output_shape); const auto labels = get_shape_labels(output_shape);
@ -314,20 +331,20 @@ TEST(type_prop, concat_dynamic_value_and_label_propagation_1) {
} }
TEST(type_prop, concat_interval_dimensions) { TEST(type_prop, concat_interval_dimensions) {
auto param0 = make_shared<op::Parameter>(element::f32, Shape{3, 2, 4}); auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{3, 2, 4});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{7, 2, 4}); auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{7, 2, 4});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 2, 4}); auto param2 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2, 4});
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2}, -3); auto c = make_shared<ov::op::v0::Concat>(ov::NodeVector{param0, param1, param2}, -3);
EXPECT_EQ(c->get_element_type(), element::f32); EXPECT_EQ(c->get_element_type(), ov::element::f32);
ASSERT_EQ(c->get_shape(), (Shape{12, 2, 4})); ASSERT_EQ(c->get_shape(), (ov::Shape{12, 2, 4}));
} }
using PartialShapeVector = std::vector<PartialShape>; using PartialShapeVector = std::vector<ov::PartialShape>;
using ConcatTestParams = std::tuple<PartialShapeVector, // input shapes using ConcatTestParams = std::tuple<PartialShapeVector, // input shapes
std::tuple<int64_t, // concatenation axis std::tuple<int64_t, // concatenation axis
PartialShape // expected shape ov::PartialShape // expected shape
>>; >>;
class ConcatTest : public TestWithParam<ConcatTestParams> { class ConcatTest : public TestWithParam<ConcatTestParams> {
@ -340,73 +357,75 @@ protected:
std::forward_as_tuple(input_shapes, std::tie(axis, exp_shape)) = GetParam(); std::forward_as_tuple(input_shapes, std::tie(axis, exp_shape)) = GetParam();
for (const auto& shape : input_shapes) { for (const auto& shape : input_shapes) {
params.make<op::Parameter>(element::f32, shape); params.make<ov::op::v0::Parameter>(ov::element::f32, shape);
} }
c = make_shared<op::Concat>(params.get(), axis); c = make_shared<ov::op::v0::Concat>(params.get(), axis);
} }
PartialShape exp_shape; ov::PartialShape exp_shape;
std::shared_ptr<op::Concat> c; std::shared_ptr<ov::op::v0::Concat> c;
}; };
const auto shapes_with_interval_dim = Values(PartialShapeVector{(PartialShape::dynamic()), const auto shapes_with_interval_dim = Values(PartialShapeVector{(ov::PartialShape::dynamic()),
{2, Dimension(2, 5), 3, 1}, {2, ov::Dimension(2, 5), 3, 1},
{2, 4, 3, Dimension(1, 4)}, {2, 4, 3, ov::Dimension(1, 4)},
{2, 4, 3, 1}}); {2, 4, 3, 1}});
INSTANTIATE_TEST_SUITE_P(type_prop_interval_dim_mixed_ranks, INSTANTIATE_TEST_SUITE_P(
ConcatTest, type_prop_interval_dim_mixed_ranks,
Combine(shapes_with_interval_dim, ConcatTest,
Values(std::make_tuple(1, PartialShape({2, Dimension(10, -1), 3, 1})), // axis 1 Combine(shapes_with_interval_dim,
std::make_tuple(-1, PartialShape({2, 4, 3, Dimension(3, -1)})), // axis 2 Values(std::make_tuple(1, ov::PartialShape({2, ov::Dimension(10, -1), 3, 1})), // axis 1
std::make_tuple(2, PartialShape({2, 4, Dimension(9, -1), 1})) // axis 3 std::make_tuple(-1, ov::PartialShape({2, 4, 3, ov::Dimension(3, -1)})), // axis 2
)), std::make_tuple(2, ov::PartialShape({2, 4, ov::Dimension(9, -1), 1})) // axis 3
PrintToStringParamName()); )),
PrintToStringParamName());
const auto shapes_all_dynamic_ranks = Values(PartialShapeVector{(PartialShape::dynamic()), const auto shapes_all_dynamic_ranks = Values(PartialShapeVector{(ov::PartialShape::dynamic()),
(PartialShape::dynamic()), (ov::PartialShape::dynamic()),
(PartialShape::dynamic()), (ov::PartialShape::dynamic()),
(PartialShape::dynamic())}); (ov::PartialShape::dynamic())});
INSTANTIATE_TEST_SUITE_P(type_prop_dynamic_ranks_against_axis_range, INSTANTIATE_TEST_SUITE_P(type_prop_dynamic_ranks_against_axis_range,
ConcatTest, ConcatTest,
Combine(shapes_all_dynamic_ranks, Combine(shapes_all_dynamic_ranks,
Combine(Range<int64_t>(-4, 4), Values(PartialShape::dynamic()))), Combine(Range<int64_t>(-4, 4), Values(ov::PartialShape::dynamic()))),
PrintToStringParamName()); PrintToStringParamName());
const auto shapes_static_dynamic_ranks = const auto shapes_static_dynamic_ranks =
Values(PartialShapeVector{PartialShape({4, 2, Dimension::dynamic(), 3}), Values(PartialShapeVector{ov::PartialShape({4, 2, ov::Dimension::dynamic(), 3}),
PartialShape::dynamic(), ov::PartialShape::dynamic(),
PartialShape({4, 2, Dimension::dynamic(), Dimension::dynamic()})}); ov::PartialShape({4, 2, ov::Dimension::dynamic(), ov::Dimension::dynamic()})});
INSTANTIATE_TEST_SUITE_P(type_prop_mixed_ranks_and_dims, INSTANTIATE_TEST_SUITE_P(
ConcatTest, type_prop_mixed_ranks_and_dims,
Combine(shapes_static_dynamic_ranks, ConcatTest,
Values( Combine(shapes_static_dynamic_ranks,
// concat all dynamic dims Values(
std::make_tuple(2, PartialShape({4, 2, Dimension::dynamic(), 3})), // concat all dynamic dims
// concat dynamic and interval dim std::make_tuple(2, ov::PartialShape({4, 2, ov::Dimension::dynamic(), 3})),
std::make_tuple(1, PartialShape({4, Dimension(4, -1), Dimension::dynamic(), 3})))), // concat dynamic and interval dim
PrintToStringParamName()); std::make_tuple(1, ov::PartialShape({4, ov::Dimension(4, -1), ov::Dimension::dynamic(), 3})))),
PrintToStringParamName());
INSTANTIATE_TEST_SUITE_P(type_prop_1d_shapes, INSTANTIATE_TEST_SUITE_P(
ConcatTest, type_prop_1d_shapes,
Values( ConcatTest,
// concat all dynamic dims Values(
std::make_tuple(PartialShapeVector{{-1}, {-1}, {-1}}, // concat all dynamic dims
std::make_tuple(0, PartialShape({-1}))), std::make_tuple(PartialShapeVector{{-1}, {-1}, {-1}}, std::make_tuple(0, ov::PartialShape({-1}))),
// concat dynamic and not matching static dims // concat dynamic and not matching static dims
std::make_tuple(PartialShapeVector{{3}, PartialShape::dynamic(), {2}}, std::make_tuple(PartialShapeVector{{3}, ov::PartialShape::dynamic(), {2}},
std::make_tuple(0, PartialShape({Dimension(5, -1)}))), std::make_tuple(0, ov::PartialShape({ov::Dimension(5, -1)}))),
// concat all static dim // concat all static dim
std::make_tuple(PartialShapeVector{{3}, {3}, {3}}, std::make_tuple(0, PartialShape({9}))), std::make_tuple(PartialShapeVector{{3}, {3}, {3}}, std::make_tuple(0, ov::PartialShape({9}))),
// concat dynamic and interval dim // concat dynamic and interval dim
std::make_tuple(PartialShapeVector{{3}, {Dimension::dynamic()}, {Dimension(3, 4)}}, std::make_tuple(PartialShapeVector{{3}, {ov::Dimension::dynamic()}, {ov::Dimension(3, 4)}},
std::make_tuple(0, PartialShape({Dimension(6, -1)})))), std::make_tuple(0, ov::PartialShape({ov::Dimension(6, -1)})))),
PrintToStringParamName()); PrintToStringParamName());
/** \brief Shape propagation no exception. */ /** \brief ov::Shape propagation no exception. */
TEST_P(ConcatTest, partial_shape_propagation) { TEST_P(ConcatTest, partial_shape_propagation) {
ASSERT_EQ(c->get_default_output().get_partial_shape(), exp_shape); ASSERT_EQ(c->get_default_output().get_partial_shape(), exp_shape);
} }

41
src/core/tests/type_prop/constant.cpp
View File

@ -2,43 +2,44 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include "openvino/op/constant.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
using namespace std; using namespace std;
using namespace ngraph;
TEST(type_prop, scalar_constant_deduce_float32) { TEST(type_prop, scalar_constant_deduce_float32) {
auto c = op::Constant::create(element::f32, Shape{}, {208}); auto c = ov::op::v0::Constant::create(ov::element::f32, ov::Shape{}, {208});
ASSERT_EQ(c->get_element_type(), element::f32); ASSERT_EQ(c->get_element_type(), ov::element::f32);
ASSERT_EQ(c->get_shape(), (Shape{})); ASSERT_EQ(c->get_shape(), (ov::Shape{}));
} }
TEST(type_prop, scalar_constant_deduce_bool) { TEST(type_prop, scalar_constant_deduce_bool) {
auto c = op::Constant::create(element::boolean, Shape{}, {1}); auto c = ov::op::v0::Constant::create(ov::element::boolean, ov::Shape{}, {1});
ASSERT_EQ(c->get_element_type(), element::boolean); ASSERT_EQ(c->get_element_type(), ov::element::boolean);
ASSERT_EQ(c->get_shape(), (Shape{})); ASSERT_EQ(c->get_shape(), (ov::Shape{}));
} }
TEST(type_prop, tensor_constant_deduce_float32) { TEST(type_prop, tensor_constant_deduce_float32) {
auto c = op::Constant::create(element::f32, Shape{2, 2}, {208, 208, 208, 208}); auto c = ov::op::v0::Constant::create(ov::element::f32, ov::Shape{2, 2}, {208, 208, 208, 208});
ASSERT_EQ(c->get_element_type(), element::f32); ASSERT_EQ(c->get_element_type(), ov::element::f32);
ASSERT_EQ(c->get_shape(), (Shape{2, 2})); ASSERT_EQ(c->get_shape(), (ov::Shape{2, 2}));
} }
TEST(type_prop, tensor_constant_deduce_bool) { TEST(type_prop, tensor_constant_deduce_bool) {
auto c = op::Constant::create(element::boolean, Shape{2, 2}, {1, 1, 1, 1}); auto c = ov::op::v0::Constant::create(ov::element::boolean, ov::Shape{2, 2}, {1, 1, 1, 1});
ASSERT_EQ(c->get_element_type(), element::boolean); ASSERT_EQ(c->get_element_type(), ov::element::boolean);
ASSERT_EQ(c->get_shape(), (Shape{2, 2})); ASSERT_EQ(c->get_shape(), (ov::Shape{2, 2}));
} }
TEST(type_prop, tensor_constant_bad_count) { TEST(type_prop, tensor_constant_bad_count) {
try { try {
auto c = op::Constant::create(element::boolean, Shape{2, 2}, {1, 1, 1}); auto c = ov::op::v0::Constant::create(ov::element::boolean, ov::Shape{2, 2}, {1, 1, 1});
// Should have thrown, so fail if it didn't // Should have thrown, so fail if it didn't
FAIL() << "Incorrect number of literals not detected"; FAIL() << "Incorrect number of literals not detected";
} catch (const NodeValidationFailure& error) { } catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), EXPECT_HAS_SUBSTRING(error.what(),
std::string("Did not get the expected number of literals for a " std::string("Did not get the expected number of literals for a "
"constant of shape [2,2] (got 3, expected 1 or 4)")); "constant of shape [2,2] (got 3, expected 1 or 4)"));
@ -48,7 +49,7 @@ TEST(type_prop, tensor_constant_bad_count) {
} }
TEST(type_prop, constant_zero_elements_one_string) { TEST(type_prop, constant_zero_elements_one_string) {
auto c = make_shared<op::Constant>(element::i64, Shape{2, 0, 2, 2}, std::vector<std::string>{"42"}); auto c = make_shared<ov::op::v0::Constant>(ov::element::i64, ov::Shape{2, 0, 2, 2}, std::vector<std::string>{"42"});
ASSERT_EQ(c->get_element_type(), element::i64); ASSERT_EQ(c->get_element_type(), ov::element::i64);
ASSERT_EQ(c->get_shape(), (Shape{2, 0, 2, 2})); ASSERT_EQ(c->get_shape(), (ov::Shape{2, 0, 2, 2}));
} }

35
src/core/tests/type_prop/convert.cpp
View File

@ -2,36 +2,39 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include "openvino/op/convert.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/core/dimension_tracker.hpp" #include "openvino/core/dimension_tracker.hpp"
#include "openvino/op/broadcast.hpp"
#include "openvino/op/shape_of.hpp"
using namespace std; using namespace std;
using namespace ngraph;
TEST(type_prop, convert_deduce) { TEST(type_prop, convert_deduce) {
// Deduce type // Deduce type
auto param = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4}); auto param = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4});
auto c = make_shared<op::Convert>(param, element::i32); auto c = make_shared<ov::op::v0::Convert>(param, ov::element::i32);
ASSERT_EQ(c->get_element_type(), element::i32); ASSERT_EQ(c->get_element_type(), ov::element::i32);
ASSERT_EQ(c->get_shape(), (Shape{2, 3, 4})); ASSERT_EQ(c->get_shape(), (ov::Shape{2, 3, 4}));
} }
TEST(type_prop, convert_dynamic_value_and_label_propagation) { TEST(type_prop, convert_dynamic_value_and_label_propagation) {
Dimension marked_0 = Dimension(3); ov::Dimension marked_0 = ov::Dimension(3);
ov::DimensionTracker::set_label(marked_0, 500); ov::DimensionTracker::set_label(marked_0, 500);
PartialShape target_0 = PartialShape{marked_0, 4}; ov::PartialShape target_0 = ov::PartialShape{marked_0, 4};
auto param = make_shared<op::Parameter>(element::f32, Shape{1}); auto param = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1});
auto param_0 = make_shared<op::Parameter>(element::f32, target_0); auto param_0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, target_0);
auto shape_0 = make_shared<op::ShapeOf>(param_0); auto shape_0 = make_shared<ov::op::v0::ShapeOf>(param_0);
auto convert_0 = make_shared<op::Convert>(shape_0, element::i8); auto convert_0 = make_shared<ov::op::v0::Convert>(shape_0, ov::element::i8);
auto convert_1 = make_shared<op::Convert>(convert_0, element::i64); auto convert_1 = make_shared<ov::op::v0::Convert>(convert_0, ov::element::i64);
auto bc = make_shared<op::v1::Broadcast>(param, convert_1); auto bc = make_shared<ov::op::v1::Broadcast>(param, convert_1);
ASSERT_EQ(bc->get_shape(), (Shape{3, 4})); ASSERT_EQ(bc->get_shape(), (ov::Shape{3, 4}));
const auto& output_shape = bc->get_output_partial_shape(0); const auto& output_shape = bc->get_output_partial_shape(0);
ASSERT_EQ(ov::DimensionTracker::get_label(output_shape[0]), 500); ASSERT_EQ(ov::DimensionTracker::get_label(output_shape[0]), 500);

3
src/core/tests/type_prop/convert_color_i420_base.hpp
View File

@ -2,11 +2,12 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include <gtest/gtest.h>
#include <vector> #include <vector>
#include "common_test_utils/test_assertions.hpp" #include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "openvino/op/op.hpp" #include "openvino/op/op.hpp"
#include "openvino/opsets/opset8.hpp" #include "openvino/opsets/opset8.hpp"

3
src/core/tests/type_prop/convert_color_nv12_base.hpp
View File

@ -2,10 +2,11 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include <gtest/gtest.h>
#include <vector> #include <vector>
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "openvino/op/op.hpp" #include "openvino/op/op.hpp"
#include "openvino/opsets/opset8.hpp" #include "openvino/opsets/opset8.hpp"

333
src/core/tests/type_prop/convolution.cpp
View File

@ -2,284 +2,291 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include <gtest/gtest.h>
#include "common_test_utils/test_assertions.hpp" #include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "convolution_shape_inference.hpp" #include "convolution_shape_inference.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
using namespace std; using namespace std;
using namespace ngraph;
using namespace testing; using namespace testing;
TEST(type_prop, convolution_v1_partial_rank) { TEST(type_prop, convolution_v1_partial_rank) {
PartialShape data_batch_shape{PartialShape::dynamic()}; ov::PartialShape data_batch_shape{ov::PartialShape::dynamic()};
PartialShape filters_shape{PartialShape::dynamic()}; ov::PartialShape filters_shape{ov::PartialShape::dynamic()};
Strides window_movement_strides{1, 1}; ov::Strides window_movement_strides{1, 1};
Strides window_dilation_strides{1, 1}; ov::Strides window_dilation_strides{1, 1};
CoordinateDiff padding_below{0, 0}; ov::CoordinateDiff padding_below{0, 0};
CoordinateDiff padding_above{0, 0}; ov::CoordinateDiff padding_above{0, 0};
auto param0 = make_shared<op::Parameter>(element::f32, data_batch_shape); auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, data_batch_shape);
auto param1 = make_shared<op::Parameter>(element::f32, filters_shape); auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, filters_shape);
auto conv = make_shared<op::v1::Convolution>(param0, auto conv = make_shared<ov::op::v1::Convolution>(param0,
param1, param1,
window_movement_strides, window_movement_strides,
padding_below, padding_below,
padding_above, padding_above,
window_dilation_strides); window_dilation_strides);
EXPECT_EQ(conv->get_output_partial_shape(0), PartialShape({-1, -1, {1, -1}, {1, -1}})); EXPECT_EQ(conv->get_output_partial_shape(0), ov::PartialShape({-1, -1, {1, -1}, {1, -1}}));
} }
TEST(type_prop, convolution_v1_partial_auto_padding_same) { TEST(type_prop, convolution_v1_partial_auto_padding_same) {
PartialShape data_batch_shape{1, 1, 5, 5}; ov::PartialShape data_batch_shape{1, 1, 5, 5};
PartialShape filters_shape{1, 1, 3, 3}; ov::PartialShape filters_shape{1, 1, 3, 3};
set_shape_labels(data_batch_shape, 10); set_shape_labels(data_batch_shape, 10);
set_shape_labels(filters_shape, 20); set_shape_labels(filters_shape, 20);
Strides strides{1, 1}; ov::Strides strides{1, 1};
CoordinateDiff pads_begin{0, 0}; ov::CoordinateDiff pads_begin{0, 0};
CoordinateDiff pads_end{0, 0}; ov::CoordinateDiff pads_end{0, 0};
Strides dilations{1, 1}; ov::Strides dilations{1, 1};
const auto auto_pad = op::PadType::SAME_LOWER; const auto auto_pad = ov::op::PadType::SAME_LOWER;
auto data_batch = make_shared<op::Parameter>(element::f32, data_batch_shape); auto data_batch = make_shared<ov::op::v0::Parameter>(ov::element::f32, data_batch_shape);
auto filters = make_shared<op::Parameter>(element::f32, filters_shape); auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, filters_shape);
auto conv = auto conv =
make_shared<op::v1::Convolution>(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad); make_shared<ov::op::v1::Convolution>(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad);
EXPECT_EQ(conv->get_output_partial_shape(0), (PartialShape{1, 1, 5, 5})); EXPECT_EQ(conv->get_output_partial_shape(0), (ov::PartialShape{1, 1, 5, 5}));
EXPECT_THAT(get_shape_labels(conv->get_output_partial_shape(0)), ElementsAre(10, 20, ov::no_label, ov::no_label)); EXPECT_THAT(get_shape_labels(conv->get_output_partial_shape(0)), ElementsAre(10, 20, ov::no_label, ov::no_label));
EXPECT_EQ(conv->get_pads_begin(), (CoordinateDiff{1, 1})); EXPECT_EQ(conv->get_pads_begin(), (ov::CoordinateDiff{1, 1}));
EXPECT_EQ(conv->get_pads_end(), (CoordinateDiff{1, 1})); EXPECT_EQ(conv->get_pads_end(), (ov::CoordinateDiff{1, 1}));
} }
TEST(type_prop, convolution_v1_partial_auto_padding_same_nc_dims_dynamic_same_lower) { TEST(type_prop, convolution_v1_partial_auto_padding_same_nc_dims_dynamic_same_lower) {
PartialShape data_batch_shape{Dimension::dynamic(), Dimension::dynamic(), 5, 5}; ov::PartialShape data_batch_shape{ov::Dimension::dynamic(), ov::Dimension::dynamic(), 5, 5};
PartialShape filters_shape{1, 1, 3, 3}; ov::PartialShape filters_shape{1, 1, 3, 3};
set_shape_labels(data_batch_shape, 10); set_shape_labels(data_batch_shape, 10);
set_shape_labels(filters_shape, 20); set_shape_labels(filters_shape, 20);
Strides strides{1, 1}; ov::Strides strides{1, 1};
CoordinateDiff pads_begin{0, 0}; ov::CoordinateDiff pads_begin{0, 0};
CoordinateDiff pads_end{0, 0}; ov::CoordinateDiff pads_end{0, 0};
Strides dilations{1, 1}; ov::Strides dilations{1, 1};
const auto auto_pad = op::PadType::SAME_LOWER; const auto auto_pad = ov::op::PadType::SAME_LOWER;
auto data_batch = make_shared<op::Parameter>(element::f32, data_batch_shape); auto data_batch = make_shared<ov::op::v0::Parameter>(ov::element::f32, data_batch_shape);
auto filters = make_shared<op::Parameter>(element::f32, filters_shape); auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, filters_shape);
auto conv = auto conv =
make_shared<op::v1::Convolution>(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad); make_shared<ov::op::v1::Convolution>(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad);
EXPECT_EQ(conv->get_output_partial_shape(0), PartialShape({Dimension::dynamic(), 1, 5, 5})); EXPECT_EQ(conv->get_output_partial_shape(0), ov::PartialShape({ov::Dimension::dynamic(), 1, 5, 5}));
EXPECT_THAT(get_shape_labels(conv->get_output_partial_shape(0)), ElementsAre(10, 20, ov::no_label, ov::no_label)); EXPECT_THAT(get_shape_labels(conv->get_output_partial_shape(0)), ElementsAre(10, 20, ov::no_label, ov::no_label));
EXPECT_EQ(conv->get_pads_begin(), (CoordinateDiff{1, 1})); EXPECT_EQ(conv->get_pads_begin(), (ov::CoordinateDiff{1, 1}));
EXPECT_EQ(conv->get_pads_end(), (CoordinateDiff{1, 1})); EXPECT_EQ(conv->get_pads_end(), (ov::CoordinateDiff{1, 1}));
} }
TEST(type_prop, convolution_v1_partial_auto_padding_same_nc_dims_dynamic_same_upper) { TEST(type_prop, convolution_v1_partial_auto_padding_same_nc_dims_dynamic_same_upper) {
const PartialShape data_batch_shape{Dimension::dynamic(), Dimension::dynamic(), 5, 5}; const ov::PartialShape data_batch_shape{ov::Dimension::dynamic(), ov::Dimension::dynamic(), 5, 5};
const PartialShape filters_shape{1, 1, 2, 2}; const ov::PartialShape filters_shape{1, 1, 2, 2};
Strides strides{1, 1}; ov::Strides strides{1, 1};
CoordinateDiff pads_begin{0, 0}; ov::CoordinateDiff pads_begin{0, 0};
CoordinateDiff pads_end{0, 0}; ov::CoordinateDiff pads_end{0, 0};
Strides dilations{1, 1}; ov::Strides dilations{1, 1};
const auto auto_pad = op::PadType::SAME_UPPER; const auto auto_pad = ov::op::PadType::SAME_UPPER;
auto data_batch = make_shared<op::Parameter>(element::f32, data_batch_shape); auto data_batch = make_shared<ov::op::v0::Parameter>(ov::element::f32, data_batch_shape);
auto filters = make_shared<op::Parameter>(element::f32, filters_shape); auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, filters_shape);
auto conv = auto conv =
make_shared<op::v1::Convolution>(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad); make_shared<ov::op::v1::Convolution>(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad);
ASSERT_EQ(conv->get_output_partial_shape(0), PartialShape({Dimension::dynamic(), 1, 5, 5})); ASSERT_EQ(conv->get_output_partial_shape(0), ov::PartialShape({ov::Dimension::dynamic(), 1, 5, 5}));
ASSERT_EQ(conv->get_pads_begin(), (CoordinateDiff{0, 0})); ASSERT_EQ(conv->get_pads_begin(), (ov::CoordinateDiff{0, 0}));
ASSERT_EQ(conv->get_pads_end(), (CoordinateDiff{1, 1})); ASSERT_EQ(conv->get_pads_end(), (ov::CoordinateDiff{1, 1}));
} }
TEST(type_prop, convolution_v1_partial_auto_padding_same_spatial_dims_dynamic) { TEST(type_prop, convolution_v1_partial_auto_padding_same_spatial_dims_dynamic) {
PartialShape data_batch_shape{1, 1, Dimension::dynamic(), {3, 5}}; ov::PartialShape data_batch_shape{1, 1, ov::Dimension::dynamic(), {3, 5}};
PartialShape filters_shape{1, 1, 3, 3}; ov::PartialShape filters_shape{1, 1, 3, 3};
set_shape_labels(data_batch_shape, 10); set_shape_labels(data_batch_shape, 10);
set_shape_labels(filters_shape, 20); set_shape_labels(filters_shape, 20);
Strides strides{2, 2}; ov::Strides strides{2, 2};
CoordinateDiff pads_begin{0, 0}; ov::CoordinateDiff pads_begin{0, 0};
CoordinateDiff pads_end{0, 0}; ov::CoordinateDiff pads_end{0, 0};
Strides dilations{1, 1}; ov::Strides dilations{1, 1};
const auto auto_pad = op::PadType::SAME_LOWER; const auto auto_pad = ov::op::PadType::SAME_LOWER;
auto data_batch = make_shared<op::Parameter>(element::f32, data_batch_shape); auto data_batch = make_shared<ov::op::v0::Parameter>(ov::element::f32, data_batch_shape);
auto filters = make_shared<op::Parameter>(element::f32, filters_shape); auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, filters_shape);
auto conv = auto conv =
make_shared<op::v1::Convolution>(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad); make_shared<ov::op::v1::Convolution>(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad);
EXPECT_EQ(conv->get_output_partial_shape(0), PartialShape({1, 1, Dimension::dynamic(), {2, 3}})); EXPECT_EQ(conv->get_output_partial_shape(0), ov::PartialShape({1, 1, ov::Dimension::dynamic(), {2, 3}}));
EXPECT_THAT(get_shape_labels(conv->get_output_partial_shape(0)), ElementsAre(10, 20, ov::no_label, ov::no_label)); EXPECT_THAT(get_shape_labels(conv->get_output_partial_shape(0)), ElementsAre(10, 20, ov::no_label, ov::no_label));
EXPECT_EQ(conv->get_pads_begin(), (CoordinateDiff{0, 0})); EXPECT_EQ(conv->get_pads_begin(), (ov::CoordinateDiff{0, 0}));
EXPECT_EQ(conv->get_pads_end(), (CoordinateDiff{0, 0})); EXPECT_EQ(conv->get_pads_end(), (ov::CoordinateDiff{0, 0}));
} }
TEST(type_prop, convolution_v1_partial_data_shape_dynamic) { TEST(type_prop, convolution_v1_partial_data_shape_dynamic) {
const PartialShape data_batch_shape{PartialShape::dynamic()}; const ov::PartialShape data_batch_shape{ov::PartialShape::dynamic()};
const PartialShape filters_shape{1, 1, 3, 3}; const ov::PartialShape filters_shape{1, 1, 3, 3};
Strides strides{1, 1}; ov::Strides strides{1, 1};
CoordinateDiff pads_begin{0, 0}; ov::CoordinateDiff pads_begin{0, 0};
CoordinateDiff pads_end{0, 0}; ov::CoordinateDiff pads_end{0, 0};
Strides dilations{1, 1}; ov::Strides dilations{1, 1};
const auto auto_pad = op::PadType::SAME_LOWER; const auto auto_pad = ov::op::PadType::SAME_LOWER;
auto data_batch = make_shared<op::Parameter>(element::f32, data_batch_shape); auto data_batch = make_shared<ov::op::v0::Parameter>(ov::element::f32, data_batch_shape);
auto filters = make_shared<op::Parameter>(element::f32, filters_shape); auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, filters_shape);
auto conv = auto conv =
make_shared<op::v1::Convolution>(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad); make_shared<ov::op::v1::Convolution>(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad);
EXPECT_EQ(conv->get_output_partial_shape(0), EXPECT_EQ(conv->get_output_partial_shape(0),
PartialShape({Dimension::dynamic(), 1, Dimension::dynamic(), Dimension::dynamic()})); ov::PartialShape({ov::Dimension::dynamic(), 1, ov::Dimension::dynamic(), ov::Dimension::dynamic()}));
EXPECT_EQ(conv->get_pads_begin(), (CoordinateDiff{0, 0})); EXPECT_EQ(conv->get_pads_begin(), (ov::CoordinateDiff{0, 0}));
EXPECT_EQ(conv->get_pads_end(), (CoordinateDiff{0, 0})); EXPECT_EQ(conv->get_pads_end(), (ov::CoordinateDiff{0, 0}));
} }
class TypePropConvolutionV1Test : public TypePropOpTest<op::v1::Convolution> { class TypePropConvolutionV1Test : public TypePropOpTest<ov::op::v1::Convolution> {
protected: protected:
CoordinateDiff empty_pad{}; ov::CoordinateDiff empty_pad{};
}; };
TEST_F(TypePropConvolutionV1Test, default_ctor) { TEST_F(TypePropConvolutionV1Test, default_ctor) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, 3, 5, 5}); const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{1, 3, 5, 5});
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 4, 4}); const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 4, 4});
const auto op = make_op(); const auto op = make_op();
op->set_arguments(OutputVector{data, filters}); op->set_arguments(ov::OutputVector{data, filters});
op->set_strides({1, 3}); op->set_strides({1, 3});
op->set_dilations({1, 2}); op->set_dilations({1, 2});
op->set_pads_begin({2, 2}); op->set_pads_begin({2, 2});
op->set_pads_end({2, 2}); op->set_pads_end({2, 2});
op->set_auto_pad(op::PadType::EXPLICIT); op->set_auto_pad(ov::op::PadType::EXPLICIT);
op->validate_and_infer_types(); op->validate_and_infer_types();
EXPECT_EQ(op->get_input_size(), 2); EXPECT_EQ(op->get_input_size(), 2);
EXPECT_EQ(op->get_output_size(), 1); EXPECT_EQ(op->get_output_size(), 1);
EXPECT_EQ(op->get_strides(), Strides({1, 3})); EXPECT_EQ(op->get_strides(), ov::Strides({1, 3}));
EXPECT_EQ(op->get_dilations(), Strides({1, 2})); EXPECT_EQ(op->get_dilations(), ov::Strides({1, 2}));
EXPECT_EQ(op->get_pads_begin(), CoordinateDiff({2, 2})); EXPECT_EQ(op->get_pads_begin(), ov::CoordinateDiff({2, 2}));
EXPECT_EQ(op->get_pads_end(), CoordinateDiff({2, 2})); EXPECT_EQ(op->get_pads_end(), ov::CoordinateDiff({2, 2}));
EXPECT_EQ(op->get_output_partial_shape(0), PartialShape({1, 2, 6, 1})); EXPECT_EQ(op->get_output_partial_shape(0), ov::PartialShape({1, 2, 6, 1}));
} }
TEST_F(TypePropConvolutionV1Test, data_dynamic_rank_filters_2d) { TEST_F(TypePropConvolutionV1Test, data_dynamic_rank_filters_2d) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape::dynamic()); const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape::dynamic());
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 4, 4}); const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 4, 4});
const auto strides = Strides{1, 1}; const auto strides = ov::Strides{1, 1};
const auto dilations = Strides{1, 1}; const auto dilations = ov::Strides{1, 1};
auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, op::PadType::SAME_UPPER); auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_UPPER);
EXPECT_THAT(op->get_pads_begin(), ElementsAre(0, 0)); EXPECT_THAT(op->get_pads_begin(), ElementsAre(0, 0));
EXPECT_THAT(op->get_pads_end(), ElementsAre(0, 0)); EXPECT_THAT(op->get_pads_end(), ElementsAre(0, 0));
EXPECT_EQ(op->get_output_partial_shape(0), PartialShape({-1, 2, -1, -1})); EXPECT_EQ(op->get_output_partial_shape(0), ov::PartialShape({-1, 2, -1, -1}));
} }
TEST_F(TypePropConvolutionV1Test, data_rank_to_low) { TEST_F(TypePropConvolutionV1Test, data_rank_to_low) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape{2, 3}); const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3});
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3}); const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3});
const auto strides = Strides{1, 1}; const auto strides = ov::Strides{1, 1};
const auto dilations = Strides{1, 1}; const auto dilations = ov::Strides{1, 1};
OV_EXPECT_THROW(auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, op::PadType::SAME_LOWER), OV_EXPECT_THROW(
NodeValidationFailure, auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER),
HasSubstr("Expected a 3D, 4D or 5D tensor for the input")); ov::NodeValidationFailure,
HasSubstr("Expected a 3D, 4D or 5D tensor for the input"));
} }
TEST_F(TypePropConvolutionV1Test, data_rank_to_high) { TEST_F(TypePropConvolutionV1Test, data_rank_to_high) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 5, 5, 5, 5}); const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 5, 5, 5, 5});
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 4, 4, 4, 4}); const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 4, 4, 4, 4});
const auto strides = Strides{1, 1}; const auto strides = ov::Strides{1, 1};
const auto dilations = Strides{1, 1}; const auto dilations = ov::Strides{1, 1};
OV_EXPECT_THROW(auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, op::PadType::SAME_LOWER), OV_EXPECT_THROW(
NodeValidationFailure, auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER),
HasSubstr("Expected a 3D, 4D or 5D tensor for the input")); ov::NodeValidationFailure,
HasSubstr("Expected a 3D, 4D or 5D tensor for the input"));
} }
TEST_F(TypePropConvolutionV1Test, data_and_filters_rank_not_compatible) { TEST_F(TypePropConvolutionV1Test, data_and_filters_rank_not_compatible) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 5, 5}); const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 5, 5});
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 4}); const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 4});
const auto strides = Strides{1, 1}; const auto strides = ov::Strides{1, 1};
const auto dilations = Strides{1, 1}; const auto dilations = ov::Strides{1, 1};
OV_EXPECT_THROW(auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, op::PadType::SAME_LOWER), OV_EXPECT_THROW(
NodeValidationFailure, auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER),
HasSubstr("Data batch and filters rank do not match")); ov::NodeValidationFailure,
HasSubstr("Data batch and filters rank do not match"));
} }
TEST_F(TypePropConvolutionV1Test, data_and_filters_channel_number_not_compatible) { TEST_F(TypePropConvolutionV1Test, data_and_filters_channel_number_not_compatible) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape{2, 2, 5, 5}); const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 2, 5, 5});
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 4, 4}); const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 4, 4});
const auto strides = Strides{1, 1}; const auto strides = ov::Strides{1, 1};
const auto dilations = Strides{1, 1}; const auto dilations = ov::Strides{1, 1};
OV_EXPECT_THROW(auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, op::PadType::SAME_LOWER), OV_EXPECT_THROW(
NodeValidationFailure, auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER),
HasSubstr("Data batch channel count (2) does not match filter input channel count (3)")); ov::NodeValidationFailure,
HasSubstr("Data batch channel count (2) does not match filter input channel count (3)"));
} }
TEST_F(TypePropConvolutionV1Test, strides_not_defined_only_for_spatial_dims) { TEST_F(TypePropConvolutionV1Test, strides_not_defined_only_for_spatial_dims) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 5, 5}); const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 5, 5});
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 4, 4}); const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 4, 4});
const auto strides = Strides{1, 1, 1}; const auto strides = ov::Strides{1, 1, 1};
const auto dilations = Strides{1, 1}; const auto dilations = ov::Strides{1, 1};
OV_EXPECT_THROW(auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, op::PadType::SAME_LOWER), OV_EXPECT_THROW(
NodeValidationFailure, auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER),
HasSubstr("Strides should be defined for all and only spatial dimensions.")); ov::NodeValidationFailure,
HasSubstr("Strides should be defined for all and only spatial dimensions."));
} }
TEST_F(TypePropConvolutionV1Test, dilations_not_defined_only_for_spatial_dims) { TEST_F(TypePropConvolutionV1Test, dilations_not_defined_only_for_spatial_dims) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 5, 5}); const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 5, 5});
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 4, 4}); const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 4, 4});
const auto strides = Strides{1, 1}; const auto strides = ov::Strides{1, 1};
const auto dilations = Strides{1}; const auto dilations = ov::Strides{1};
OV_EXPECT_THROW(auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, op::PadType::SAME_LOWER), OV_EXPECT_THROW(
NodeValidationFailure, auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER),
HasSubstr("Dilations should be defined for all and only spatial dimensions.")); ov::NodeValidationFailure,
HasSubstr("Dilations should be defined for all and only spatial dimensions."));
} }
TEST_F(TypePropConvolutionV1Test, strides_has_zeros) { TEST_F(TypePropConvolutionV1Test, strides_has_zeros) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 5, 5}); const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 5, 5});
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 4, 4}); const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 4, 4});
const auto strides = Strides{1, 0}; const auto strides = ov::Strides{1, 0};
const auto dilations = Strides{1, 1}; const auto dilations = ov::Strides{1, 1};
OV_EXPECT_THROW(auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, op::PadType::SAME_LOWER), OV_EXPECT_THROW(
NodeValidationFailure, auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER),
HasSubstr("Strides has zero dimension")); ov::NodeValidationFailure,
HasSubstr("Strides has zero dimension"));
} }
TEST_F(TypePropConvolutionV1Test, dilations_has_zeros) { TEST_F(TypePropConvolutionV1Test, dilations_has_zeros) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 5, 5}); const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 5, 5});
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 4, 4}); const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 4, 4});
const auto strides = Strides{1, 1}; const auto strides = ov::Strides{1, 1};
const auto dilations = Strides{0, 1}; const auto dilations = ov::Strides{0, 1};
OV_EXPECT_THROW(auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, op::PadType::SAME_LOWER), OV_EXPECT_THROW(
NodeValidationFailure, auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER),
HasSubstr("Filter dilations has zero dimension")); ov::NodeValidationFailure,
HasSubstr("Filter dilations has zero dimension"));
} }
TEST_F(TypePropConvolutionV1Test, pads_not_defined_for_spatial_only) { TEST_F(TypePropConvolutionV1Test, pads_not_defined_for_spatial_only) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 5, 5}); const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 5, 5});
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 4, 4}); const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 4, 4});
const auto strides = Strides{1, 1}; const auto strides = ov::Strides{1, 1};
const auto dilations = Strides{1, 1}; const auto dilations = ov::Strides{1, 1};
const auto pads_begin = CoordinateDiff{2, 2}; const auto pads_begin = ov::CoordinateDiff{2, 2};
const auto pads_end = CoordinateDiff{2, 2, 2}; const auto pads_end = ov::CoordinateDiff{2, 2, 2};
OV_EXPECT_THROW(auto op = make_op(data, filters, strides, pads_begin, pads_end, dilations), OV_EXPECT_THROW(auto op = make_op(data, filters, strides, pads_begin, pads_end, dilations),
NodeValidationFailure, ov::NodeValidationFailure,
HasSubstr("Pads begin and end should be defined for all and only spatial dimensions.")); HasSubstr("Pads begin and end should be defined for all and only spatial dimensions."));
} }

1115
src/core/tests/type_prop/convolution_backprop_data.cpp
View File

File diff suppressed because it is too large Load Diff

2
src/core/tests/type_prop/cos.cpp
View File

@ -4,6 +4,6 @@
#include "unary_ops.hpp" #include "unary_ops.hpp"
using Type = ::testing::Types<ngraph::op::Cos>; using Type = ::testing::Types<ov::op::v0::Cos>;
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_cos, UnaryOperator, Type); INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_cos, UnaryOperator, Type);

2
src/core/tests/type_prop/cosh.cpp
View File

@ -4,6 +4,6 @@
#include "unary_ops.hpp" #include "unary_ops.hpp"
using Type = ::testing::Types<ngraph::op::Cosh>; using Type = ::testing::Types<ov::op::v0::Cosh>;
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_cosh, UnaryOperator, Type); INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_cosh, UnaryOperator, Type);

92
src/core/tests/type_prop/ctc_greedy_decoder.cpp
View File

@ -2,13 +2,15 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include "openvino/op/ctc_greedy_decoder.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/core/dimension_tracker.hpp" #include "openvino/core/dimension_tracker.hpp"
using namespace std; using namespace std;
using namespace ngraph; using namespace ov;
using namespace testing; using namespace testing;
TEST(type_prop, ctc_greedy_decoder_default_constructor) { TEST(type_prop, ctc_greedy_decoder_default_constructor) {
@ -16,10 +18,10 @@ TEST(type_prop, ctc_greedy_decoder_default_constructor) {
PartialShape seq_mask_shape{100, 3}; PartialShape seq_mask_shape{100, 3};
PartialShape expected_shape{3, 100, 1, 1}; PartialShape expected_shape{3, 100, 1, 1};
auto op = make_shared<op::CTCGreedyDecoder>(); auto op = make_shared<ov::op::v0::CTCGreedyDecoder>();
auto data = make_shared<op::Parameter>(element::f32, data_shape); auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape); auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
op->set_arguments(OutputVector{data, seq_mask}); op->set_arguments(OutputVector{data, seq_mask});
op->set_ctc_merge_repeated(false); op->set_ctc_merge_repeated(false);
@ -38,9 +40,9 @@ TEST(type_prop, ctc_greedy_decoder_static_shapes) {
PartialShape logits_shape{100, 3, 1200}; PartialShape logits_shape{100, 3, 1200};
PartialShape seq_mask_shape{100, 3}; PartialShape seq_mask_shape{100, 3};
Shape out_shape{3, 100, 1, 1}; Shape out_shape{3, 100, 1, 1};
auto data = make_shared<op::Parameter>(element::f32, logits_shape); auto data = make_shared<ov::op::v0::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape); auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false); auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
EXPECT_EQ(op->get_element_type(), element::f32); EXPECT_EQ(op->get_element_type(), element::f32);
EXPECT_EQ(op->get_shape(), out_shape); EXPECT_EQ(op->get_shape(), out_shape);
} }
@ -53,9 +55,9 @@ TEST(type_prop, ctc_greedy_decoder_interval_labeled_dims_all) {
set_shape_labels(data_shape, 10); set_shape_labels(data_shape, 10);
set_shape_labels(seq_mask_shape, 20); set_shape_labels(seq_mask_shape, 20);
auto data = make_shared<op::Parameter>(element::f32, data_shape); auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape); auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false); auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
const auto& out_shape = op->get_output_partial_shape(0); const auto& out_shape = op->get_output_partial_shape(0);
EXPECT_EQ(op->get_element_type(), element::f32); EXPECT_EQ(op->get_element_type(), element::f32);
@ -70,9 +72,9 @@ TEST(type_prop, ctc_greedy_decoder_interval_labeled_dims_data) {
set_shape_labels(data_shape, 10); set_shape_labels(data_shape, 10);
auto data = make_shared<op::Parameter>(element::f32, data_shape); auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape); auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false); auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
const auto& out_shape = op->get_output_partial_shape(0); const auto& out_shape = op->get_output_partial_shape(0);
EXPECT_EQ(op->get_element_type(), element::f32); EXPECT_EQ(op->get_element_type(), element::f32);
@ -87,9 +89,9 @@ TEST(type_prop, ctc_greedy_decoder_interval_labeled_dims_mask) {
set_shape_labels(seq_mask_shape, 20); set_shape_labels(seq_mask_shape, 20);
auto data = make_shared<op::Parameter>(element::f32, data_shape); auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape); auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false); auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
const auto& out_shape = op->get_output_partial_shape(0); const auto& out_shape = op->get_output_partial_shape(0);
EXPECT_EQ(op->get_output_element_type(0), element::f32); EXPECT_EQ(op->get_output_element_type(0), element::f32);
@ -101,9 +103,9 @@ TEST(type_prop, ctc_greedy_decoder_output_static_shape1) {
PartialShape logits_shape{Dimension::dynamic(), 3, 1200}; PartialShape logits_shape{Dimension::dynamic(), 3, 1200};
PartialShape seq_mask_shape{100, 3}; PartialShape seq_mask_shape{100, 3};
Shape out_shape{3, 100, 1, 1}; Shape out_shape{3, 100, 1, 1};
auto data = make_shared<op::Parameter>(element::f32, logits_shape); auto data = make_shared<ov::op::v0::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape); auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false); auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
EXPECT_EQ(op->get_output_element_type(0), element::f32); EXPECT_EQ(op->get_output_element_type(0), element::f32);
EXPECT_EQ(op->get_shape(), out_shape); EXPECT_EQ(op->get_shape(), out_shape);
@ -113,9 +115,9 @@ TEST(type_prop, ctc_greedy_decoder_output_static_shape2) {
PartialShape logits_shape{Dimension::dynamic(), 3, 1200}; PartialShape logits_shape{Dimension::dynamic(), 3, 1200};
PartialShape seq_mask_shape{100, Dimension::dynamic()}; PartialShape seq_mask_shape{100, Dimension::dynamic()};
Shape out_shape{3, 100, 1, 1}; Shape out_shape{3, 100, 1, 1};
auto data = make_shared<op::Parameter>(element::f32, logits_shape); auto data = make_shared<ov::op::v0::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape); auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false); auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
EXPECT_EQ(op->get_element_type(), element::f32); EXPECT_EQ(op->get_element_type(), element::f32);
EXPECT_EQ(op->get_shape(), out_shape); EXPECT_EQ(op->get_shape(), out_shape);
} }
@ -124,9 +126,9 @@ TEST(type_prop, ctc_greedy_decoder_dynamic_shapes) {
PartialShape logits_shape{Dimension::dynamic(), Dimension::dynamic(), 1200}; PartialShape logits_shape{Dimension::dynamic(), Dimension::dynamic(), 1200};
PartialShape seq_mask_shape{Dimension::dynamic(), Dimension::dynamic()}; PartialShape seq_mask_shape{Dimension::dynamic(), Dimension::dynamic()};
PartialShape out_shape{Dimension::dynamic(), Dimension::dynamic(), 1, 1}; PartialShape out_shape{Dimension::dynamic(), Dimension::dynamic(), 1, 1};
auto data = make_shared<op::Parameter>(element::f32, logits_shape); auto data = make_shared<ov::op::v0::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape); auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false); auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
EXPECT_EQ(op->get_element_type(), element::f32); EXPECT_EQ(op->get_element_type(), element::f32);
ASSERT_TRUE(op->get_output_partial_shape(0).same_scheme(out_shape)); ASSERT_TRUE(op->get_output_partial_shape(0).same_scheme(out_shape));
} }
@ -135,9 +137,9 @@ TEST(type_prop, ctc_greedy_decoder_dynamic_ranks1) {
PartialShape logits_shape = PartialShape::dynamic(); PartialShape logits_shape = PartialShape::dynamic();
PartialShape seq_mask_shape{100, Dimension::dynamic()}; PartialShape seq_mask_shape{100, Dimension::dynamic()};
PartialShape out_shape{Dimension::dynamic(), 100, 1, 1}; PartialShape out_shape{Dimension::dynamic(), 100, 1, 1};
auto data = make_shared<op::Parameter>(element::f32, logits_shape); auto data = make_shared<ov::op::v0::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape); auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false); auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
EXPECT_EQ(op->get_element_type(), element::f32); EXPECT_EQ(op->get_element_type(), element::f32);
ASSERT_TRUE(op->get_output_partial_shape(0).same_scheme(out_shape)); ASSERT_TRUE(op->get_output_partial_shape(0).same_scheme(out_shape));
} }
@ -146,9 +148,9 @@ TEST(type_prop, ctc_greedy_decoder_dynamic_ranks2) {
PartialShape logits_shape = PartialShape::dynamic(); PartialShape logits_shape = PartialShape::dynamic();
PartialShape seq_mask_shape = PartialShape::dynamic(); PartialShape seq_mask_shape = PartialShape::dynamic();
PartialShape out_shape{Dimension::dynamic(), Dimension::dynamic(), 1, 1}; PartialShape out_shape{Dimension::dynamic(), Dimension::dynamic(), 1, 1};
auto data = make_shared<op::Parameter>(element::f32, logits_shape); auto data = make_shared<ov::op::v0::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape); auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false); auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
EXPECT_EQ(op->get_element_type(), element::f32); EXPECT_EQ(op->get_element_type(), element::f32);
ASSERT_TRUE(op->get_output_partial_shape(0).same_scheme(out_shape)); ASSERT_TRUE(op->get_output_partial_shape(0).same_scheme(out_shape));
} }
@ -156,11 +158,11 @@ TEST(type_prop, ctc_greedy_decoder_dynamic_ranks2) {
TEST(type_prop, ctc_greedy_decoder_incorrect_rank) { TEST(type_prop, ctc_greedy_decoder_incorrect_rank) {
PartialShape logits_shape{Dimension::dynamic(), 3, 1200, 5}; PartialShape logits_shape{Dimension::dynamic(), 3, 1200, 5};
PartialShape seq_mask_shape{100, 3}; PartialShape seq_mask_shape{100, 3};
auto data = make_shared<op::Parameter>(element::f32, logits_shape); auto data = make_shared<ov::op::v0::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape); auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
try { try {
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false); auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
// Should have thrown, so fail if it didn't // Should have thrown, so fail if it didn't
FAIL() << "Incorrect indices rank"; FAIL() << "Incorrect indices rank";
} catch (const NodeValidationFailure& error) { } catch (const NodeValidationFailure& error) {
@ -173,11 +175,11 @@ TEST(type_prop, ctc_greedy_decoder_incorrect_rank) {
TEST(type_prop, ctc_greedy_decoder_incorrect_rank2) { TEST(type_prop, ctc_greedy_decoder_incorrect_rank2) {
PartialShape logits_shape{Dimension::dynamic(), 3, 1200}; PartialShape logits_shape{Dimension::dynamic(), 3, 1200};
PartialShape seq_mask_shape{100, 3, 2}; PartialShape seq_mask_shape{100, 3, 2};
auto data = make_shared<op::Parameter>(element::f32, logits_shape); auto data = make_shared<ov::op::v0::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape); auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
try { try {
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false); auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
// Should have thrown, so fail if it didn't // Should have thrown, so fail if it didn't
FAIL() << "Incorrect indices rank"; FAIL() << "Incorrect indices rank";
} catch (const NodeValidationFailure& error) { } catch (const NodeValidationFailure& error) {
@ -190,11 +192,11 @@ TEST(type_prop, ctc_greedy_decoder_incorrect_rank2) {
TEST(type_prop, ctc_greedy_decoder_mismatched_dim1) { TEST(type_prop, ctc_greedy_decoder_mismatched_dim1) {
PartialShape logits_shape{100, 4, 1200}; PartialShape logits_shape{100, 4, 1200};
PartialShape seq_mask_shape{100, 3}; PartialShape seq_mask_shape{100, 3};
auto data = make_shared<op::Parameter>(element::f32, logits_shape); auto data = make_shared<ov::op::v0::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape); auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
try { try {
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false); auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
// Should have thrown, so fail if it didn't // Should have thrown, so fail if it didn't
FAIL() << "Incorrect indices rank"; FAIL() << "Incorrect indices rank";
} catch (const NodeValidationFailure& error) { } catch (const NodeValidationFailure& error) {
@ -207,11 +209,11 @@ TEST(type_prop, ctc_greedy_decoder_mismatched_dim1) {
TEST(type_prop, ctc_greedy_decoder_mismatched_dim2) { TEST(type_prop, ctc_greedy_decoder_mismatched_dim2) {
PartialShape logits_shape{101, 3, 1200}; PartialShape logits_shape{101, 3, 1200};
PartialShape seq_mask_shape{100, 3}; PartialShape seq_mask_shape{100, 3};
auto data = make_shared<op::Parameter>(element::f32, logits_shape); auto data = make_shared<ov::op::v0::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape); auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
try { try {
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false); auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
// Should have thrown, so fail if it didn't // Should have thrown, so fail if it didn't
FAIL() << "Incorrect indices rank"; FAIL() << "Incorrect indices rank";
} catch (const NodeValidationFailure& error) { } catch (const NodeValidationFailure& error) {

3
src/core/tests/type_prop/ctc_greedy_decoder_seq_len.cpp
View File

@ -2,8 +2,9 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "openvino/core/dimension_tracker.hpp" #include "openvino/core/dimension_tracker.hpp"
#include "openvino/op/ops.hpp" #include "openvino/op/ops.hpp"

3
src/core/tests/type_prop/ctc_loss.cpp
View File

@ -2,9 +2,10 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include <gtest/gtest.h>
#include "common_test_utils/test_assertions.hpp" #include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "openvino/opsets/opset10.hpp" #include "openvino/opsets/opset10.hpp"
using namespace std; using namespace std;

41
src/core/tests/type_prop/cum_sum.cpp
View File

@ -2,15 +2,18 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include "common_test_utils/type_prop.hpp" #include "openvino/op/cum_sum.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
using namespace ngraph; #include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp"
#include "openvino/op/constant.hpp"
using namespace ov;
TEST(type_prop, cum_sum_op_default_attributes_no_axis_input) { TEST(type_prop, cum_sum_op_default_attributes_no_axis_input) {
PartialShape data_shape{2, 4}; PartialShape data_shape{2, 4};
auto A = std::make_shared<op::Parameter>(element::f32, data_shape); auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto cum_sum = std::make_shared<op::v0::CumSum>(A); auto cum_sum = std::make_shared<op::v0::CumSum>(A);
EXPECT_EQ(cum_sum->is_exclusive(), false); EXPECT_EQ(cum_sum->is_exclusive(), false);
@ -22,8 +25,8 @@ TEST(type_prop, cum_sum_op_default_attributes_no_axis_input) {
TEST(type_prop, cum_sum_op_default_attributes_with_axis_param) { TEST(type_prop, cum_sum_op_default_attributes_with_axis_param) {
PartialShape data_shape{2, 4}; PartialShape data_shape{2, 4};
auto A = std::make_shared<op::Parameter>(element::f32, data_shape); auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto axis = std::make_shared<op::Parameter>(element::i32, PartialShape{}); auto axis = std::make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{});
auto cum_sum = std::make_shared<op::v0::CumSum>(A, axis); auto cum_sum = std::make_shared<op::v0::CumSum>(A, axis);
EXPECT_EQ(cum_sum->is_exclusive(), false); EXPECT_EQ(cum_sum->is_exclusive(), false);
@ -35,8 +38,8 @@ TEST(type_prop, cum_sum_op_default_attributes_with_axis_param) {
TEST(type_prop, cum_sum_op_default_attributes_with_axis_const) { TEST(type_prop, cum_sum_op_default_attributes_with_axis_const) {
PartialShape data_shape{2, 4}; PartialShape data_shape{2, 4};
auto A = std::make_shared<op::Parameter>(element::f32, data_shape); auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto axis = op::Constant::create(element::i32, Shape{}, {1}); auto axis = ov::op::v0::Constant::create(element::i32, Shape{}, {1});
auto cum_sum = std::make_shared<op::v0::CumSum>(A, axis); auto cum_sum = std::make_shared<op::v0::CumSum>(A, axis);
EXPECT_EQ(cum_sum->is_exclusive(), false); EXPECT_EQ(cum_sum->is_exclusive(), false);
@ -48,8 +51,8 @@ TEST(type_prop, cum_sum_op_default_attributes_with_axis_const) {
TEST(type_prop, cum_sum_op_custom_attributes) { TEST(type_prop, cum_sum_op_custom_attributes) {
PartialShape data_shape{2, 4}; PartialShape data_shape{2, 4};
auto A = std::make_shared<op::Parameter>(element::f32, data_shape); auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto axis = std::make_shared<op::Parameter>(element::i32, PartialShape{}); auto axis = std::make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{});
bool exclusive = true; bool exclusive = true;
bool reverse = true; bool reverse = true;
auto cum_sum = std::make_shared<op::v0::CumSum>(A, axis, exclusive, reverse); auto cum_sum = std::make_shared<op::v0::CumSum>(A, axis, exclusive, reverse);
@ -73,8 +76,8 @@ TEST(type_prop, cum_sum_op_data_shapes) {
for (auto& shape : input_shpes) { for (auto& shape : input_shpes) {
try { try {
auto axis = std::make_shared<op::Parameter>(element::i32, PartialShape{}); auto axis = std::make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{});
auto A = std::make_shared<op::Parameter>(element::f32, shape); auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, shape);
auto cum_sum = std::make_shared<op::v0::CumSum>(A, axis); auto cum_sum = std::make_shared<op::v0::CumSum>(A, axis);
EXPECT_EQ(cum_sum->get_output_partial_shape(0), shape); EXPECT_EQ(cum_sum->get_output_partial_shape(0), shape);
@ -89,8 +92,8 @@ TEST(type_prop, cum_sum_op_incorrect_axis_shapes) {
std::vector<PartialShape> incorrect_axis_shpes{{1}, {1, 1}, {2}}; std::vector<PartialShape> incorrect_axis_shpes{{1}, {1, 1}, {2}};
for (auto& shape : incorrect_axis_shpes) { for (auto& shape : incorrect_axis_shpes) {
try { try {
auto axis = std::make_shared<op::Parameter>(element::i32, shape); auto axis = std::make_shared<ov::op::v0::Parameter>(element::i32, shape);
auto A = std::make_shared<op::Parameter>(element::f32, data_shape); auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto cum_sum = std::make_shared<op::v0::CumSum>(A, axis); auto cum_sum = std::make_shared<op::v0::CumSum>(A, axis);
} catch (...) { } catch (...) {
FAIL() << "CumSum axis input shape validation shouldn't throw for backward compatibility"; FAIL() << "CumSum axis input shape validation shouldn't throw for backward compatibility";
@ -115,8 +118,8 @@ TEST(type_prop, cum_sum_op_element_types) {
for (auto& et : element_types) { for (auto& et : element_types) {
try { try {
auto axis = std::make_shared<op::Parameter>(element::i32, PartialShape{}); auto axis = std::make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{});
auto A = std::make_shared<op::Parameter>(et, data_shape); auto A = std::make_shared<ov::op::v0::Parameter>(et, data_shape);
EXPECT_NO_THROW(const auto unused = std::make_shared<op::v0::CumSum>(A, axis)); EXPECT_NO_THROW(const auto unused = std::make_shared<op::v0::CumSum>(A, axis));
} catch (...) { } catch (...) {
@ -132,8 +135,8 @@ TEST(type_prop, cum_sum_op_incorrect_axis_element_type) {
for (auto& et : element_types) { for (auto& et : element_types) {
try { try {
auto axis = std::make_shared<op::Parameter>(et, PartialShape{}); auto axis = std::make_shared<ov::op::v0::Parameter>(et, PartialShape{});
auto A = std::make_shared<op::Parameter>(element::f32, data_shape); auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto cum_sum = std::make_shared<op::v0::CumSum>(A, axis); auto cum_sum = std::make_shared<op::v0::CumSum>(A, axis);
FAIL() << "Invalid element type of axis input not detected"; FAIL() << "Invalid element type of axis input not detected";

219
src/core/tests/type_prop/deformable_convolution.cpp
View File

@ -2,12 +2,15 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include "openvino/op/deformable_convolution.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h" #include "openvino/core/coordinate_diff.hpp"
#include "ngraph/ngraph.hpp"
using namespace std; using namespace std;
using namespace ngraph; using namespace ov;
using namespace testing; using namespace testing;
TEST(type_prop, deformable_convolution_partial_auto_padding_same) { TEST(type_prop, deformable_convolution_partial_auto_padding_same) {
@ -27,9 +30,9 @@ TEST(type_prop, deformable_convolution_partial_auto_padding_same) {
const int64_t group = 4; const int64_t group = 4;
const int64_t deformable_group = 2; const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -62,9 +65,9 @@ TEST(type_prop, deformable_convolution_partial_auto_padding_same_lower_data_batc
const int64_t group = 4; const int64_t group = 4;
const int64_t deformable_group = 2; const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -95,9 +98,9 @@ TEST(type_prop, deformable_convolution_partial_auto_padding_same_upper_data_batc
const int64_t group = 4; const int64_t group = 4;
const int64_t deformable_group = 2; const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -128,9 +131,9 @@ TEST(type_prop, deformable_convolution_partial_auto_padding_same_spatial_dims_dy
const int64_t group = 4; const int64_t group = 4;
const int64_t deformable_group = 2; const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -159,9 +162,9 @@ TEST(type_prop, deformable_convolution_data_batch_dynamic) {
const int64_t group = 2; const int64_t group = 2;
const int64_t deformable_group = 2; const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -193,9 +196,9 @@ TEST(type_prop, deformable_convolution_offsets_dynamic) {
const int64_t group = 2; const int64_t group = 2;
const int64_t deformable_group = 2; const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -225,9 +228,9 @@ TEST(type_prop, deformable_convolution_auto_pad_same_filters_dynamic) {
const int64_t group = 2; const int64_t group = 2;
const int64_t deformable_group = 2; const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -257,9 +260,9 @@ TEST(type_prop, deformable_convolution_deformable_data_batch_and_filters_dynamic
const int64_t group = 2; const int64_t group = 2;
const int64_t deformable_group = 2; const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -287,9 +290,9 @@ TEST(type_prop, deformable_convolution_deformable_all_inputs_dynamic) {
const int64_t group = 2; const int64_t group = 2;
const int64_t deformable_group = 2; const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, dyn_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, dyn_pshape);
auto offsets = make_shared<op::Parameter>(et, dyn_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, dyn_pshape);
auto filters = make_shared<op::Parameter>(et, dyn_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, dyn_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -318,9 +321,9 @@ TEST(type_prop, deformable_convolution_invalid_et_inputs) {
element::Type_t boolean_et = element::boolean; element::Type_t boolean_et = element::boolean;
try { try {
auto data_batch = make_shared<op::Parameter>(element::f16, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(element::f16, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(float_et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(float_et, offsets_pshape);
auto filters = make_shared<op::Parameter>(float_et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(float_et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -339,9 +342,9 @@ TEST(type_prop, deformable_convolution_invalid_et_inputs) {
} }
try { try {
auto data_batch = make_shared<op::Parameter>(float_et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(float_et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(float_et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(float_et, offsets_pshape);
auto filters = make_shared<op::Parameter>(element::f16, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(element::f16, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -360,9 +363,9 @@ TEST(type_prop, deformable_convolution_invalid_et_inputs) {
} }
try { try {
auto data_batch = make_shared<op::Parameter>(float_et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(float_et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(element::f16, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(element::f16, offsets_pshape);
auto filters = make_shared<op::Parameter>(float_et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(float_et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -381,9 +384,9 @@ TEST(type_prop, deformable_convolution_invalid_et_inputs) {
} }
try { try {
auto data_batch = make_shared<op::Parameter>(boolean_et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(boolean_et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(boolean_et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(boolean_et, offsets_pshape);
auto filters = make_shared<op::Parameter>(boolean_et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(boolean_et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -410,9 +413,9 @@ TEST(type_prop, deformable_convolution_invalid_input_ranks) {
const PartialShape offsets_pshape{1, 4, 4, 4}; const PartialShape offsets_pshape{1, 4, 4, 4};
const PartialShape filters_pshape{4, 4, 3, 3}; const PartialShape filters_pshape{4, 4, 3, 3};
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -434,9 +437,9 @@ TEST(type_prop, deformable_convolution_invalid_input_ranks) {
const PartialShape offsets_pshape{1, 4, 4, 4, 4}; const PartialShape offsets_pshape{1, 4, 4, 4, 4};
const PartialShape filters_pshape{4, 4, 3, 3}; const PartialShape filters_pshape{4, 4, 3, 3};
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -458,9 +461,9 @@ TEST(type_prop, deformable_convolution_invalid_input_ranks) {
const PartialShape offsets_pshape{1, 4, 4, 4}; const PartialShape offsets_pshape{1, 4, 4, 4};
const PartialShape filters_pshape{4, 4, 3, 3, 3}; const PartialShape filters_pshape{4, 4, 3, 3, 3};
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -482,9 +485,9 @@ TEST(type_prop, deformable_convolution_invalid_input_ranks) {
const PartialShape offsets_pshape{1, 4, 4, 4, 4}; const PartialShape offsets_pshape{1, 4, 4, 4, 4};
const PartialShape filters_pshape{4, 4, 3, 3, 3}; const PartialShape filters_pshape{4, 4, 3, 3, 3};
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -506,9 +509,9 @@ TEST(type_prop, deformable_convolution_invalid_input_ranks) {
const PartialShape offsets_pshape{1, 4, 4}; const PartialShape offsets_pshape{1, 4, 4};
const PartialShape filters_pshape{4, 4, 3}; const PartialShape filters_pshape{4, 4, 3};
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -539,9 +542,9 @@ TEST(type_prop, deformable_convolution_invalid_groups) {
const int64_t group = 0; const int64_t group = 0;
const int64_t deformable_group = 2; const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
try { try {
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
@ -578,9 +581,9 @@ TEST(type_prop, deformable_convolution_invalid_deformable_groups) {
const int64_t group = 4; const int64_t group = 4;
const int64_t deformable_group = 0; const int64_t deformable_group = 0;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
try { try {
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
@ -618,9 +621,9 @@ TEST(type_prop, deformable_convolution_invalid_offsets_channels_dim) {
const int64_t group = 4; const int64_t group = 4;
const int64_t deformable_group = 2; const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -660,9 +663,9 @@ TEST(type_prop, deformable_convolution_invalid_offsets_channels_dim) {
const int64_t group = 4; const int64_t group = 4;
const int64_t deformable_group = 2; const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -698,9 +701,9 @@ TEST(type_prop, deformable_convolution_invalid_offsets_batch_dim) {
const int64_t group = 4; const int64_t group = 4;
const int64_t deformable_group = 2; const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
try { try {
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
@ -737,9 +740,9 @@ TEST(type_prop, deformable_convolution_invalid_data_batch_channels_dim_with_grou
const int64_t group = 4; const int64_t group = 4;
const int64_t deformable_group = 2; const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
try { try {
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
@ -776,9 +779,9 @@ TEST(type_prop, deformable_convolution_invalid_filters_channels_dim_with_group)
const int64_t group = 4; const int64_t group = 4;
const int64_t deformable_group = 2; const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
try { try {
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
@ -815,9 +818,9 @@ TEST(type_prop, deformable_convolution_incompatible_data_batch_and_filters_chann
const int64_t group = 4; const int64_t group = 4;
const int64_t deformable_group = 2; const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
try { try {
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
@ -856,9 +859,9 @@ TEST(type_prop, deformable_convolution_invalid_offsets_spatial_dims) {
const int64_t group = 4; const int64_t group = 4;
const int64_t deformable_group = 2; const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
try { try {
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
@ -893,9 +896,9 @@ TEST(type_prop, deformable_convolution_invalid_conv_param_spatial_dims) {
CoordinateDiff pads_begin{0, 0}; CoordinateDiff pads_begin{0, 0};
CoordinateDiff pads_end{0, 0}; CoordinateDiff pads_end{0, 0};
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, PartialShape::dynamic()); auto filters = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -915,9 +918,9 @@ TEST(type_prop, deformable_convolution_invalid_conv_param_spatial_dims) {
CoordinateDiff pads_begin{0, 0}; CoordinateDiff pads_begin{0, 0};
CoordinateDiff pads_end{0, 0}; CoordinateDiff pads_end{0, 0};
auto data_batch = make_shared<op::Parameter>(et, PartialShape::dynamic()); auto data_batch = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -939,9 +942,9 @@ TEST(type_prop, deformable_convolution_invalid_conv_param_spatial_dims) {
CoordinateDiff pads_begin{0, 0}; CoordinateDiff pads_begin{0, 0};
CoordinateDiff pads_end{0, 0}; CoordinateDiff pads_end{0, 0};
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, PartialShape::dynamic()); auto filters = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -961,9 +964,9 @@ TEST(type_prop, deformable_convolution_invalid_conv_param_spatial_dims) {
CoordinateDiff pads_begin{0, 0}; CoordinateDiff pads_begin{0, 0};
CoordinateDiff pads_end{0, 0}; CoordinateDiff pads_end{0, 0};
auto data_batch = make_shared<op::Parameter>(et, PartialShape::dynamic()); auto data_batch = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -985,9 +988,9 @@ TEST(type_prop, deformable_convolution_invalid_conv_param_spatial_dims) {
CoordinateDiff pads_begin{0, 0, 0}; CoordinateDiff pads_begin{0, 0, 0};
CoordinateDiff pads_end{0, 0}; CoordinateDiff pads_end{0, 0};
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, PartialShape::dynamic()); auto filters = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -1007,9 +1010,9 @@ TEST(type_prop, deformable_convolution_invalid_conv_param_spatial_dims) {
CoordinateDiff pads_begin{0, 0}; CoordinateDiff pads_begin{0, 0};
CoordinateDiff pads_end{0}; CoordinateDiff pads_end{0};
auto data_batch = make_shared<op::Parameter>(et, PartialShape::dynamic()); auto data_batch = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto offsets = make_shared<op::Parameter>(et, offsets_pshape); auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape); auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch, auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets, offsets,
filters, filters,
@ -1031,9 +1034,9 @@ protected:
}; };
TEST_F(TypePropDeformableConvolutionV1Test, default_ctor) { TEST_F(TypePropDeformableConvolutionV1Test, default_ctor) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, 4, 5, 5}); const auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, 4, 5, 5});
const auto offsets = make_shared<op::Parameter>(element::f32, PartialShape{1, 36, 7, 2}); const auto offsets = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, 36, 7, 2});
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{4, 1, 3, 3}); const auto filters = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{4, 1, 3, 3});
const auto op = make_op(); const auto op = make_op();
op->set_arguments(OutputVector{data, offsets, filters}); op->set_arguments(OutputVector{data, offsets, filters});
@ -1067,9 +1070,9 @@ TEST_F(TypePropDeformableConvolutionV1Test, interval_shapes) {
const element::Type_t et = element::f32; const element::Type_t et = element::f32;
const auto auto_pad = op::PadType::EXPLICIT; const auto auto_pad = op::PadType::EXPLICIT;
const auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape); const auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
const auto offsets = make_shared<op::Parameter>(et, offsets_shape); const auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_shape);
const auto filters = make_shared<op::Parameter>(et, filters_pshape); const auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
const auto op = make_op(data_batch, offsets, filters, Strides{}, empty_pad, empty_pad, Strides{}, auto_pad, 4, 2); const auto op = make_op(data_batch, offsets, filters, Strides{}, empty_pad, empty_pad, Strides{}, auto_pad, 4, 2);
EXPECT_THAT(get_shape_labels(op->get_output_partial_shape(0)), ElementsAre(10, 30, ov::no_label, ov::no_label)); EXPECT_THAT(get_shape_labels(op->get_output_partial_shape(0)), ElementsAre(10, 30, ov::no_label, ov::no_label));

6
src/core/tests/type_prop/deformable_convolution_opset8.cpp
View File

@ -2,13 +2,13 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/opsets/opset8.hpp" #include "openvino/opsets/opset8.hpp"
using namespace std; using namespace std;
using namespace ngraph; using namespace ov;
using namespace ov::opset8; using namespace ov::opset8;
using namespace testing; using namespace testing;

68
src/core/tests/type_prop/deformable_psroi_pooling.cpp
View File

@ -2,12 +2,14 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include "openvino/op/deformable_psroi_pooling.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
using namespace std; using namespace std;
using namespace ngraph; using namespace ov;
using namespace testing; using namespace testing;
TEST(type_prop, deformable_psroi_pooling_default_ctor) { TEST(type_prop, deformable_psroi_pooling_default_ctor) {
@ -16,8 +18,8 @@ TEST(type_prop, deformable_psroi_pooling_default_ctor) {
const auto rois_dim = 30; const auto rois_dim = 30;
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{2, 4, 64, 56}); auto input_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 4, 64, 56});
auto input_coords = make_shared<op::Parameter>(element::f32, PartialShape{rois_dim, 5}); auto input_coords = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{rois_dim, 5});
auto op = make_shared<op::v1::DeformablePSROIPooling>(); auto op = make_shared<op::v1::DeformablePSROIPooling>();
@ -38,11 +40,11 @@ TEST(type_prop, deformable_psroi_pooling_interval_labels) {
const auto rois_dim = Dimension(15, 30); const auto rois_dim = Dimension(15, 30);
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{2, 4, 64, 56}); auto input_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 4, 64, 56});
auto coords_shape = PartialShape{rois_dim, 5}; auto coords_shape = PartialShape{rois_dim, 5};
set_shape_labels(coords_shape, 20); set_shape_labels(coords_shape, 20);
auto input_coords = make_shared<op::Parameter>(element::f32, coords_shape); auto input_coords = make_shared<ov::op::v0::Parameter>(element::f32, coords_shape);
auto op = auto op =
make_shared<op::v1::DeformablePSROIPooling>(input_data, input_coords, output_dim, spatial_scale, group_size); make_shared<op::v1::DeformablePSROIPooling>(input_data, input_coords, output_dim, spatial_scale, group_size);
@ -60,8 +62,8 @@ TEST(type_prop, deformable_psroi_pooling_no_offsets_group_size_3) {
const auto rois_dim = 300; const auto rois_dim = 300;
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{2, 7938, 63, 38}); auto input_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
auto input_coords = make_shared<op::Parameter>(element::f32, PartialShape{rois_dim, 5}); auto input_coords = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{rois_dim, 5});
auto def_psroi_pool = auto def_psroi_pool =
make_shared<op::v1::DeformablePSROIPooling>(input_data, input_coords, output_dim, spatial_scale, group_size); make_shared<op::v1::DeformablePSROIPooling>(input_data, input_coords, output_dim, spatial_scale, group_size);
@ -79,9 +81,10 @@ TEST(type_prop, deformable_psroi_pooling_group_size_3) {
const auto rois_dim = 300; const auto rois_dim = 300;
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{2, 7938, 63, 38}); auto input_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
auto input_coords = make_shared<op::Parameter>(element::f32, PartialShape{rois_dim, 5}); auto input_coords = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{rois_dim, 5});
auto input_offsets = make_shared<op::Parameter>(element::f32, PartialShape{rois_dim, 2, part_size, part_size}); auto input_offsets =
make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{rois_dim, 2, part_size, part_size});
auto def_psroi_pool = make_shared<op::v1::DeformablePSROIPooling>(input_data, auto def_psroi_pool = make_shared<op::v1::DeformablePSROIPooling>(input_data,
input_coords, input_coords,
@ -108,9 +111,10 @@ TEST(type_prop, deformable_psroi_pooling_group_size_7) {
const auto rois_dim = 300; const auto rois_dim = 300;
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{2, 7938, 63, 38}); auto input_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
auto input_coords = make_shared<op::Parameter>(element::f32, PartialShape{rois_dim, 5}); auto input_coords = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{rois_dim, 5});
auto input_offsets = make_shared<op::Parameter>(element::f32, PartialShape{rois_dim, 2, part_size, part_size}); auto input_offsets =
make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{rois_dim, 2, part_size, part_size});
auto def_psroi_pool = make_shared<op::v1::DeformablePSROIPooling>(input_data, auto def_psroi_pool = make_shared<op::v1::DeformablePSROIPooling>(input_data,
input_coords, input_coords,
@ -135,8 +139,8 @@ TEST(type_prop, deformable_psroi_pooling_dynamic_rois) {
const auto rois_dim = Dimension(100, 200); const auto rois_dim = Dimension(100, 200);
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{2, 7938, 63, 38}); auto input_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
auto input_coords = make_shared<op::Parameter>(element::f32, PartialShape{rois_dim, 5}); auto input_coords = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{rois_dim, 5});
auto def_psroi_pool = auto def_psroi_pool =
make_shared<op::v1::DeformablePSROIPooling>(input_data, input_coords, output_dim, spatial_scale, group_size); make_shared<op::v1::DeformablePSROIPooling>(input_data, input_coords, output_dim, spatial_scale, group_size);
@ -152,8 +156,8 @@ TEST(type_prop, deformable_psroi_pooling_fully_dynamic) {
const auto rois_dim = Dimension::dynamic(); const auto rois_dim = Dimension::dynamic();
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape::dynamic()); auto input_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto input_coords = make_shared<op::Parameter>(element::f32, PartialShape::dynamic()); auto input_coords = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto def_psroi_pool = auto def_psroi_pool =
make_shared<op::v1::DeformablePSROIPooling>(input_data, input_coords, output_dim, spatial_scale, group_size); make_shared<op::v1::DeformablePSROIPooling>(input_data, input_coords, output_dim, spatial_scale, group_size);
@ -169,8 +173,8 @@ TEST(type_prop, deformable_psroi_pooling_invalid_group_size) {
try { try {
const int64_t group_size = 0; const int64_t group_size = 0;
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{2, 7938, 63, 38}); auto input_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
auto input_coords = make_shared<op::Parameter>(element::f32, PartialShape{rois_dim, 5}); auto input_coords = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{rois_dim, 5});
auto def_psroi_pool = make_shared<op::v1::DeformablePSROIPooling>(input_data, auto def_psroi_pool = make_shared<op::v1::DeformablePSROIPooling>(input_data,
input_coords, input_coords,
output_dim, output_dim,
@ -193,8 +197,8 @@ TEST(type_prop, deformable_psroi_pooling_invalid_output_dim) {
try { try {
const int64_t output_dim = -882; const int64_t output_dim = -882;
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{2, 7938, 63, 38}); auto input_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
auto input_coords = make_shared<op::Parameter>(element::f32, PartialShape{rois_dim, 5}); auto input_coords = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{rois_dim, 5});
auto def_psroi_pool = make_shared<op::v1::DeformablePSROIPooling>(input_data, auto def_psroi_pool = make_shared<op::v1::DeformablePSROIPooling>(input_data,
input_coords, input_coords,
output_dim, output_dim,
@ -218,9 +222,10 @@ TEST(type_prop, deformable_psroi_pooling_invalid_data_input_rank) {
const auto rois_dim = 300; const auto rois_dim = 300;
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{7938, 63, 38}); auto input_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{7938, 63, 38});
auto input_coords = make_shared<op::Parameter>(element::f32, PartialShape{rois_dim, 5}); auto input_coords = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{rois_dim, 5});
auto input_offsets = make_shared<op::Parameter>(element::f32, PartialShape{rois_dim, 2, part_size, part_size}); auto input_offsets =
make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{rois_dim, 2, part_size, part_size});
try { try {
auto def_psroi_pool = make_shared<op::v1::DeformablePSROIPooling>(input_data, auto def_psroi_pool = make_shared<op::v1::DeformablePSROIPooling>(input_data,
@ -251,8 +256,8 @@ TEST(type_prop, deformable_psroi_pooling_invalid_box_coordinates_rank) {
const auto rois_dim = 300; const auto rois_dim = 300;
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{2, 7938, 63, 38}); auto input_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
auto input_coords = make_shared<op::Parameter>(element::f32, PartialShape{2, rois_dim, 5}); auto input_coords = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, rois_dim, 5});
try { try {
auto def_psroi_pool = make_shared<op::v1::DeformablePSROIPooling>(input_data, auto def_psroi_pool = make_shared<op::v1::DeformablePSROIPooling>(input_data,
input_coords, input_coords,
@ -277,9 +282,10 @@ TEST(type_prop, deformable_psroi_pooling_invalid_offstes_rank) {
const auto rois_dim = 300; const auto rois_dim = 300;
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{2, 7938, 63, 38}); auto input_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
auto input_coords = make_shared<op::Parameter>(element::f32, PartialShape{rois_dim, 5}); auto input_coords = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{rois_dim, 5});
auto input_offsets = make_shared<op::Parameter>(element::f32, PartialShape{2, rois_dim, 2, part_size, part_size}); auto input_offsets =
make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, rois_dim, 2, part_size, part_size});
try { try {
auto def_psroi_pool = make_shared<op::v1::DeformablePSROIPooling>(input_data, auto def_psroi_pool = make_shared<op::v1::DeformablePSROIPooling>(input_data,
input_coords, input_coords,

91
src/core/tests/type_prop/depth_to_space.cpp
View File

@ -2,19 +2,23 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include "openvino/op/depth_to_space.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h" #include "ngraph/util.hpp"
#include "ngraph/ngraph.hpp"
using namespace std; using namespace std;
using namespace ngraph; using namespace ov;
using namespace testing; using namespace testing;
TEST(type_prop, depth_to_space_input_interval_shape_block_first_5D_when_depth_is_static) { TEST(type_prop, depth_to_space_input_interval_shape_block_first_5D_when_depth_is_static) {
auto a_shape = PartialShape{{2, 10}, 24, {3, 7}, {423, 3000}, {235, 1345}}; auto a_shape = PartialShape{{2, 10}, 24, {3, 7}, {423, 3000}, {235, 1345}};
set_shape_labels(a_shape, 10); set_shape_labels(a_shape, 10);
auto A = make_shared<op::Parameter>(element::f32, a_shape); auto A = make_shared<ov::op::v0::Parameter>(element::f32, a_shape);
auto depth_to_space = make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 2); auto depth_to_space =
make_shared<ov::op::v0::DepthToSpace>(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 2);
EXPECT_EQ(depth_to_space->get_output_element_type(0), element::f32); EXPECT_EQ(depth_to_space->get_output_element_type(0), element::f32);
EXPECT_EQ(depth_to_space->get_output_partial_shape(0), EXPECT_EQ(depth_to_space->get_output_partial_shape(0),
@ -26,8 +30,9 @@ TEST(type_prop, depth_to_space_input_interval_shape_block_first_5D_when_depth_is
TEST(type_prop, depth_to_space_input_interval_shape_default_block_size) { TEST(type_prop, depth_to_space_input_interval_shape_default_block_size) {
auto a_shape = PartialShape{{2, 10}, 24, {3, 7}, {423, 3000}, {235, 1345}}; auto a_shape = PartialShape{{2, 10}, 24, {3, 7}, {423, 3000}, {235, 1345}};
set_shape_labels(a_shape, 10); set_shape_labels(a_shape, 10);
auto A = make_shared<op::Parameter>(element::f32, a_shape); auto A = make_shared<ov::op::v0::Parameter>(element::f32, a_shape);
auto depth_to_space = make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST); auto depth_to_space =
make_shared<ov::op::v0::DepthToSpace>(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST);
EXPECT_EQ(depth_to_space->get_output_element_type(0), element::f32); EXPECT_EQ(depth_to_space->get_output_element_type(0), element::f32);
EXPECT_EQ(depth_to_space->get_output_partial_shape(0), a_shape); EXPECT_EQ(depth_to_space->get_output_partial_shape(0), a_shape);
@ -37,61 +42,71 @@ TEST(type_prop, depth_to_space_input_interval_shape_default_block_size) {
OPENVINO_SUPPRESS_DEPRECATED_START OPENVINO_SUPPRESS_DEPRECATED_START
TEST(type_prop, depth_to_space_output_dynamicshape_block_first_5D_when_depth_is_dynamic) { TEST(type_prop, depth_to_space_output_dynamicshape_block_first_5D_when_depth_is_dynamic) {
auto A = auto A = make_shared<ov::op::v0::Parameter>(element::f32,
make_shared<op::Parameter>(element::f32, PartialShape{{2, 10}, {81, 82}, {3, 7}, {423, 3000}, {235, 1345}}); PartialShape{{2, 10}, {81, 82}, {3, 7}, {423, 3000}, {235, 1345}});
auto depth_to_space = make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 3); auto depth_to_space =
make_shared<ov::op::v0::DepthToSpace>(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 3);
ASSERT_EQ( ASSERT_EQ(depth_to_space->get_output_partial_shape(0),
depth_to_space->get_output_partial_shape(0), (PartialShape{{2, 10},
(PartialShape{{2, 10}, {ceil_div(81, 27), 82 / 27}, {3 * 3, 7 * 3}, {423 * 3, 3000 * 3}, {235 * 3, 1345 * 3}})); {ngraph::ceil_div(81, 27), 82 / 27},
{3 * 3, 7 * 3},
{423 * 3, 3000 * 3},
{235 * 3, 1345 * 3}}));
} }
TEST(type_prop, depth_to_space_output_shape_block_first_4D) { TEST(type_prop, depth_to_space_output_shape_block_first_4D) {
auto A = make_shared<op::Parameter>(element::f32, Shape{1, 128, 8, 8}); auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 128, 8, 8});
auto depth_to_space = make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 8); auto depth_to_space =
make_shared<ov::op::v0::DepthToSpace>(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 8);
ASSERT_EQ(depth_to_space->get_element_type(), element::f32); ASSERT_EQ(depth_to_space->get_element_type(), element::f32);
ASSERT_EQ(depth_to_space->get_shape(), (Shape{1, 2, 64, 64})); ASSERT_EQ(depth_to_space->get_shape(), (Shape{1, 2, 64, 64}));
} }
TEST(type_prop, depth_to_space_output_shape_block_first_4D_2) { TEST(type_prop, depth_to_space_output_shape_block_first_4D_2) {
auto A = make_shared<op::Parameter>(element::f32, Shape{1, 12, 1080, 1616}); auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 12, 1080, 1616});
auto depth_to_space = make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 2); auto depth_to_space =
make_shared<ov::op::v0::DepthToSpace>(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 2);
ASSERT_EQ(depth_to_space->get_element_type(), element::f32); ASSERT_EQ(depth_to_space->get_element_type(), element::f32);
ASSERT_EQ(depth_to_space->get_shape(), (Shape{1, 3, 2 * 1080, 2 * 1616})); ASSERT_EQ(depth_to_space->get_shape(), (Shape{1, 3, 2 * 1080, 2 * 1616}));
} }
TEST(type_prop, depth_to_space_output_shape_block_first_5D) { TEST(type_prop, depth_to_space_output_shape_block_first_5D) {
auto A = make_shared<op::Parameter>(element::f32, Shape{1, 16, 3, 1080, 1616}); auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 16, 3, 1080, 1616});
auto depth_to_space = make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 2); auto depth_to_space =
make_shared<ov::op::v0::DepthToSpace>(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 2);
ASSERT_EQ(depth_to_space->get_element_type(), element::f32); ASSERT_EQ(depth_to_space->get_element_type(), element::f32);
ASSERT_EQ(depth_to_space->get_shape(), (Shape{1, 2, 2 * 3, 2 * 1080, 2 * 1616})); ASSERT_EQ(depth_to_space->get_shape(), (Shape{1, 2, 2 * 3, 2 * 1080, 2 * 1616}));
} }
TEST(type_prop, depth_to_space_output_shape_depth_first_4D) { TEST(type_prop, depth_to_space_output_shape_depth_first_4D) {
auto A = make_shared<op::Parameter>(element::f32, Shape{1, 12, 1080, 1616}); auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 12, 1080, 1616});
auto depth_to_space = make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2); auto depth_to_space =
make_shared<ov::op::v0::DepthToSpace>(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2);
ASSERT_EQ(depth_to_space->get_element_type(), element::f32); ASSERT_EQ(depth_to_space->get_element_type(), element::f32);
ASSERT_EQ(depth_to_space->get_shape(), (Shape{1, 3, 2 * 1080, 2 * 1616})); ASSERT_EQ(depth_to_space->get_shape(), (Shape{1, 3, 2 * 1080, 2 * 1616}));
} }
TEST(type_prop, depth_to_space_output_shape_depth_first_5D) { TEST(type_prop, depth_to_space_output_shape_depth_first_5D) {
auto A = make_shared<op::Parameter>(element::f32, Shape{1, 16, 3, 1080, 1616}); auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 16, 3, 1080, 1616});
auto depth_to_space = make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2); auto depth_to_space =
make_shared<ov::op::v0::DepthToSpace>(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2);
ASSERT_EQ(depth_to_space->get_element_type(), element::f32); ASSERT_EQ(depth_to_space->get_element_type(), element::f32);
ASSERT_EQ(depth_to_space->get_shape(), (Shape{1, 2, 2 * 3, 2 * 1080, 2 * 1616})); ASSERT_EQ(depth_to_space->get_shape(), (Shape{1, 2, 2 * 3, 2 * 1080, 2 * 1616}));
} }
TEST(type_prop, depth_to_space_input_rank_not_supported) { TEST(type_prop, depth_to_space_input_rank_not_supported) {
auto A = make_shared<op::Parameter>(element::f32, Shape{1, 8}); auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 8});
try { try {
auto depth_to_space = make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2); auto depth_to_space =
make_shared<ov::op::v0::DepthToSpace>(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2);
FAIL() << "Not supported input shape for DepthToSpace exception not thrown"; FAIL() << "Not supported input shape for DepthToSpace exception not thrown";
} catch (const ngraph_error& error) { } catch (const ov::Exception& error) {
EXPECT_HAS_SUBSTRING(error.what(), "The input tensor with rank lower than 3 is not supported (input rank: 2)"); EXPECT_HAS_SUBSTRING(error.what(), "The input tensor with rank lower than 3 is not supported (input rank: 2)");
} catch (...) { } catch (...) {
FAIL() << "DepthToSpace decomposition failed for unexpected reason"; FAIL() << "DepthToSpace decomposition failed for unexpected reason";
@ -99,11 +114,12 @@ TEST(type_prop, depth_to_space_input_rank_not_supported) {
} }
TEST(type_prop, depth_to_space_blocksize_not_matched) { TEST(type_prop, depth_to_space_blocksize_not_matched) {
auto A = make_shared<op::Parameter>(element::f32, Shape{1, 7, 4, 4}); auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 7, 4, 4});
try { try {
auto depth_to_space = make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2); auto depth_to_space =
make_shared<ov::op::v0::DepthToSpace>(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2);
FAIL() << "Not matched blocksize for DepthToSpace exception not thrown"; FAIL() << "Not matched blocksize for DepthToSpace exception not thrown";
} catch (const ngraph_error& error) { } catch (const ov::Exception& error) {
EXPECT_HAS_SUBSTRING(error.what(), "Dimension value: [ 7, 7] must be a multiple of divisor: 4"); EXPECT_HAS_SUBSTRING(error.what(), "Dimension value: [ 7, 7] must be a multiple of divisor: 4");
} catch (...) { } catch (...) {
FAIL() << "DepthToSpace decomposition failed for unexpected reason"; FAIL() << "DepthToSpace decomposition failed for unexpected reason";
@ -111,16 +127,17 @@ TEST(type_prop, depth_to_space_blocksize_not_matched) {
} }
TEST(type_prop, depth_to_space_dynamic_shape_static_rank) { TEST(type_prop, depth_to_space_dynamic_shape_static_rank) {
auto A = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(4)); auto A = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(4));
auto depth_to_space = make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2); auto depth_to_space =
make_shared<ov::op::v0::DepthToSpace>(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2);
ASSERT_EQ(depth_to_space->get_element_type(), element::f32); ASSERT_EQ(depth_to_space->get_element_type(), element::f32);
ASSERT_EQ(depth_to_space->get_output_partial_shape(0), PartialShape::dynamic(4)); ASSERT_EQ(depth_to_space->get_output_partial_shape(0), PartialShape::dynamic(4));
} }
TEST(type_prop, depth_to_space_dynamic_shape_dynamic_rank) { TEST(type_prop, depth_to_space_dynamic_shape_dynamic_rank) {
auto A = make_shared<op::Parameter>(element::f32, PartialShape::dynamic()); auto A = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto depth_to_space = make_shared<op::DepthToSpace>(A, "depth_first", 2); auto depth_to_space = make_shared<ov::op::v0::DepthToSpace>(A, "depth_first", 2);
ASSERT_EQ(depth_to_space->get_element_type(), element::f32); ASSERT_EQ(depth_to_space->get_element_type(), element::f32);
ASSERT_EQ(depth_to_space->get_output_partial_shape(0), PartialShape::dynamic()); ASSERT_EQ(depth_to_space->get_output_partial_shape(0), PartialShape::dynamic());
@ -128,16 +145,16 @@ TEST(type_prop, depth_to_space_dynamic_shape_dynamic_rank) {
TEST(type_prop, depth_to_space_default_ctor) { TEST(type_prop, depth_to_space_default_ctor) {
const auto a_shape = PartialShape{{2, 10}, 27, {0, 54}, {9, -1}}; const auto a_shape = PartialShape{{2, 10}, 27, {0, 54}, {9, -1}};
const auto A = make_shared<op::Parameter>(element::u32, a_shape); const auto A = make_shared<ov::op::v0::Parameter>(element::u32, a_shape);
const auto depth_to_space = make_shared<op::DepthToSpace>(); const auto depth_to_space = make_shared<ov::op::v0::DepthToSpace>();
depth_to_space->set_block_size(3); depth_to_space->set_block_size(3);
depth_to_space->set_mode(op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST); depth_to_space->set_mode(ov::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST);
depth_to_space->set_argument(0, A); depth_to_space->set_argument(0, A);
depth_to_space->validate_and_infer_types(); depth_to_space->validate_and_infer_types();
EXPECT_EQ(depth_to_space->get_block_size(), 3); EXPECT_EQ(depth_to_space->get_block_size(), 3);
EXPECT_EQ(depth_to_space->get_mode(), op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST); EXPECT_EQ(depth_to_space->get_mode(), ov::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST);
EXPECT_EQ(depth_to_space->get_input_size(), 1); EXPECT_EQ(depth_to_space->get_input_size(), 1);
EXPECT_EQ(depth_to_space->get_output_size(), 1); EXPECT_EQ(depth_to_space->get_output_size(), 1);
EXPECT_EQ(depth_to_space->get_output_element_type(0), element::u32); EXPECT_EQ(depth_to_space->get_output_element_type(0), element::u32);

173
src/core/tests/type_prop/detection_output.cpp
View File

@ -2,31 +2,31 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include "ngraph/op/detection_output.hpp" #include "openvino/op/detection_output.hpp"
#include <gtest/gtest.h>
#include <memory> #include <memory>
#include "common_test_utils/test_assertions.hpp" #include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/core/dimension_tracker.hpp" #include "openvino/core/dimension_tracker.hpp"
#include "openvino/util/common_util.hpp" #include "openvino/util/common_util.hpp"
using namespace std; using namespace std;
using namespace ngraph; using namespace ov;
using namespace testing; using namespace testing;
// ------------------------------ V0 ------------------------------ // ------------------------------ V0 ------------------------------
std::shared_ptr<op::DetectionOutput> create_detection_output(PartialShape box_logits_shape, std::shared_ptr<op::v0::DetectionOutput> create_detection_output(PartialShape box_logits_shape,
PartialShape class_preds_shape, PartialShape class_preds_shape,
PartialShape proposals_shape, PartialShape proposals_shape,
PartialShape aux_class_preds_shape, PartialShape aux_class_preds_shape,
PartialShape aux_box_preds_shape, PartialShape aux_box_preds_shape,
const op::DetectionOutputAttrs& attrs, const ov::op::v0::DetectionOutput::Attributes& attrs,
element::Type input_type, element::Type input_type,
element::Type proposals_type, element::Type proposals_type,
bool set_labels = false) { bool set_labels = false) {
if (set_labels) { if (set_labels) {
// The labels are set for all of the shapes, // The labels are set for all of the shapes,
// but the output dimension is always a product of multiplication, so labels are not preserved // but the output dimension is always a product of multiplication, so labels are not preserved
@ -37,25 +37,30 @@ std::shared_ptr<op::DetectionOutput> create_detection_output(PartialShape box_lo
set_shape_labels(aux_box_preds_shape, 50); set_shape_labels(aux_box_preds_shape, 50);
} }
auto box_logits = make_shared<op::Parameter>(input_type, box_logits_shape); auto box_logits = make_shared<ov::op::v0::Parameter>(input_type, box_logits_shape);
auto class_preds = make_shared<op::Parameter>(input_type, class_preds_shape); auto class_preds = make_shared<ov::op::v0::Parameter>(input_type, class_preds_shape);
auto proposals = make_shared<op::Parameter>(proposals_type, proposals_shape); auto proposals = make_shared<ov::op::v0::Parameter>(proposals_type, proposals_shape);
auto aux_class_preds = make_shared<op::Parameter>(input_type, aux_class_preds_shape); auto aux_class_preds = make_shared<ov::op::v0::Parameter>(input_type, aux_class_preds_shape);
auto aux_box_preds = make_shared<op::Parameter>(input_type, aux_box_preds_shape); auto aux_box_preds = make_shared<ov::op::v0::Parameter>(input_type, aux_box_preds_shape);
return make_shared<op::DetectionOutput>(box_logits, class_preds, proposals, aux_class_preds, aux_box_preds, attrs); return make_shared<ov::op::v0::DetectionOutput>(box_logits,
class_preds,
proposals,
aux_class_preds,
aux_box_preds,
attrs);
} }
TEST(type_prop_layers, detection_output_v0_default_ctor) { TEST(type_prop_layers, detection_output_v0_default_ctor) {
auto op = make_shared<op::v0::DetectionOutput>(); auto op = make_shared<op::v0::DetectionOutput>();
auto input_type = element::f32; auto input_type = element::f32;
auto box_logits = make_shared<op::Parameter>(input_type, PartialShape{4, 20}); auto box_logits = make_shared<ov::op::v0::Parameter>(input_type, PartialShape{4, 20});
auto class_preds = make_shared<op::Parameter>(input_type, PartialShape{4, 10}); auto class_preds = make_shared<ov::op::v0::Parameter>(input_type, PartialShape{4, 10});
auto proposals = make_shared<op::Parameter>(input_type, PartialShape{4, 2, 20}); auto proposals = make_shared<ov::op::v0::Parameter>(input_type, PartialShape{4, 2, 20});
auto ad_class_preds = make_shared<op::Parameter>(input_type, PartialShape{4, 10}); auto ad_class_preds = make_shared<ov::op::v0::Parameter>(input_type, PartialShape{4, 10});
auto ad_box_preds = make_shared<op::Parameter>(input_type, PartialShape{4, 20}); auto ad_box_preds = make_shared<ov::op::v0::Parameter>(input_type, PartialShape{4, 20});
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.top_k = 7; attrs.top_k = 7;
attrs.num_classes = 2; attrs.num_classes = 2;
@ -80,7 +85,7 @@ TEST(type_prop_layers, detection_output_v0_default_ctor) {
} }
TEST(type_prop_layers, detection_output_basic) { TEST(type_prop_layers, detection_output_basic) {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200}; attrs.keep_top_k = {200};
attrs.num_classes = 2; attrs.num_classes = 2;
attrs.normalized = true; attrs.normalized = true;
@ -97,7 +102,7 @@ TEST(type_prop_layers, detection_output_basic) {
} }
TEST(type_prop_layers, detection_output_interval_labeled_keep_top_k) { TEST(type_prop_layers, detection_output_interval_labeled_keep_top_k) {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {60}; attrs.keep_top_k = {60};
attrs.num_classes = 3; attrs.num_classes = 3;
attrs.normalized = true; attrs.normalized = true;
@ -118,7 +123,7 @@ TEST(type_prop_layers, detection_output_interval_labeled_keep_top_k) {
} }
TEST(type_prop_layers, detection_output_interval_labeled_top_k) { TEST(type_prop_layers, detection_output_interval_labeled_top_k) {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.top_k = 80; attrs.top_k = 80;
attrs.num_classes = 3; attrs.num_classes = 3;
@ -140,7 +145,7 @@ TEST(type_prop_layers, detection_output_interval_labeled_top_k) {
} }
TEST(type_prop_layers, detection_output_interval_labeled_negative_both_topk) { TEST(type_prop_layers, detection_output_interval_labeled_negative_both_topk) {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.top_k = -1; attrs.top_k = -1;
attrs.num_classes = 3; attrs.num_classes = 3;
@ -162,7 +167,7 @@ TEST(type_prop_layers, detection_output_interval_labeled_negative_both_topk) {
} }
TEST(type_prop_layers, detection_output_v0_f16) { TEST(type_prop_layers, detection_output_v0_f16) {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200}; attrs.keep_top_k = {200};
attrs.num_classes = 2; attrs.num_classes = 2;
attrs.normalized = true; attrs.normalized = true;
@ -179,7 +184,7 @@ TEST(type_prop_layers, detection_output_v0_f16) {
} }
TEST(type_prop_layers, detection_f16_with_proposals_f32) { TEST(type_prop_layers, detection_f16_with_proposals_f32) {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200}; attrs.keep_top_k = {200};
attrs.num_classes = 2; attrs.num_classes = 2;
attrs.normalized = true; attrs.normalized = true;
@ -196,7 +201,7 @@ TEST(type_prop_layers, detection_f16_with_proposals_f32) {
} }
TEST(type_prop_layers, detection_output_v0_not_normalized) { TEST(type_prop_layers, detection_output_v0_not_normalized) {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200}; attrs.keep_top_k = {200};
attrs.num_classes = 2; attrs.num_classes = 2;
attrs.normalized = false; attrs.normalized = false;
@ -213,7 +218,7 @@ TEST(type_prop_layers, detection_output_v0_not_normalized) {
} }
TEST(type_prop_layers, detection_output_v0_negative_keep_top_k) { TEST(type_prop_layers, detection_output_v0_negative_keep_top_k) {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.top_k = -1; attrs.top_k = -1;
attrs.normalized = true; attrs.normalized = true;
@ -231,7 +236,7 @@ TEST(type_prop_layers, detection_output_v0_negative_keep_top_k) {
} }
TEST(type_prop_layers, detection_output_v0_no_share_location) { TEST(type_prop_layers, detection_output_v0_no_share_location) {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.top_k = -1; attrs.top_k = -1;
attrs.normalized = true; attrs.normalized = true;
@ -250,7 +255,7 @@ TEST(type_prop_layers, detection_output_v0_no_share_location) {
} }
TEST(type_prop_layers, detection_output_v0_calculated_num_prior_boxes) { TEST(type_prop_layers, detection_output_v0_calculated_num_prior_boxes) {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.top_k = -1; attrs.top_k = -1;
attrs.normalized = true; attrs.normalized = true;
@ -269,7 +274,7 @@ TEST(type_prop_layers, detection_output_v0_calculated_num_prior_boxes) {
} }
TEST(type_prop_layers, detection_output_v0_top_k) { TEST(type_prop_layers, detection_output_v0_top_k) {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.top_k = 7; attrs.top_k = 7;
attrs.normalized = true; attrs.normalized = true;
@ -288,7 +293,7 @@ TEST(type_prop_layers, detection_output_v0_top_k) {
TEST(type_prop_layers, detection_output_v0_all_dynamic_shapes) { TEST(type_prop_layers, detection_output_v0_all_dynamic_shapes) {
PartialShape dyn_shape = PartialShape::dynamic(); PartialShape dyn_shape = PartialShape::dynamic();
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.num_classes = 1; attrs.num_classes = 1;
auto op = create_detection_output(dyn_shape, auto op = create_detection_output(dyn_shape,
@ -304,7 +309,7 @@ TEST(type_prop_layers, detection_output_v0_all_dynamic_shapes) {
} }
TEST(type_prop_layers, detection_output_v0_dynamic_batch) { TEST(type_prop_layers, detection_output_v0_dynamic_batch) {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200}; attrs.keep_top_k = {200};
attrs.num_classes = 2; attrs.num_classes = 2;
attrs.normalized = true; attrs.normalized = true;
@ -327,17 +332,21 @@ void detection_output_invalid_data_type_test(element::Type box_logits_et,
element::Type aux_box_preds_et, element::Type aux_box_preds_et,
const std::string& expected_msg) { const std::string& expected_msg) {
try { try {
auto box_logits = make_shared<op::Parameter>(box_logits_et, Shape{4, 20}); auto box_logits = make_shared<ov::op::v0::Parameter>(box_logits_et, Shape{4, 20});
auto class_preds = make_shared<op::Parameter>(class_preds_et, Shape{4, 10}); auto class_preds = make_shared<ov::op::v0::Parameter>(class_preds_et, Shape{4, 10});
auto proposals = make_shared<op::Parameter>(proposals_et, Shape{4, 2, 20}); auto proposals = make_shared<ov::op::v0::Parameter>(proposals_et, Shape{4, 2, 20});
auto aux_class_preds = make_shared<op::Parameter>(aux_class_preds_et, Shape{4, 10}); auto aux_class_preds = make_shared<ov::op::v0::Parameter>(aux_class_preds_et, Shape{4, 10});
auto aux_box_preds = make_shared<op::Parameter>(aux_box_preds_et, Shape{4, 20}); auto aux_box_preds = make_shared<ov::op::v0::Parameter>(aux_box_preds_et, Shape{4, 20});
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200}; attrs.keep_top_k = {200};
attrs.num_classes = 2; attrs.num_classes = 2;
attrs.normalized = true; attrs.normalized = true;
auto op = auto op = make_shared<ov::op::v0::DetectionOutput>(box_logits,
make_shared<op::DetectionOutput>(box_logits, class_preds, proposals, aux_class_preds, aux_box_preds, attrs); class_preds,
proposals,
aux_class_preds,
aux_box_preds,
attrs);
FAIL() << "Exception expected"; FAIL() << "Exception expected";
} catch (const NodeValidationFailure& error) { } catch (const NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), expected_msg); EXPECT_HAS_SUBSTRING(error.what(), expected_msg);
@ -385,7 +394,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_data_type) {
TEST(type_prop_layers, detection_output_v0_mismatched_batch_size) { TEST(type_prop_layers, detection_output_v0_mismatched_batch_size) {
{ {
try { try {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200}; attrs.keep_top_k = {200};
attrs.num_classes = 2; attrs.num_classes = 2;
attrs.normalized = true; attrs.normalized = true;
@ -407,7 +416,7 @@ TEST(type_prop_layers, detection_output_v0_mismatched_batch_size) {
} }
{ {
try { try {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200}; attrs.keep_top_k = {200};
attrs.num_classes = 2; attrs.num_classes = 2;
attrs.normalized = true; attrs.normalized = true;
@ -433,7 +442,7 @@ TEST(type_prop_layers, detection_output_v0_mismatched_batch_size) {
TEST(type_prop_layers, detection_output_v0_invalid_ranks) { TEST(type_prop_layers, detection_output_v0_invalid_ranks) {
{ {
try { try {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200}; attrs.keep_top_k = {200};
attrs.num_classes = 2; attrs.num_classes = 2;
attrs.normalized = true; attrs.normalized = true;
@ -454,7 +463,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_ranks) {
} }
{ {
try { try {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200}; attrs.keep_top_k = {200};
attrs.num_classes = 2; attrs.num_classes = 2;
attrs.normalized = true; attrs.normalized = true;
@ -475,7 +484,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_ranks) {
} }
{ {
try { try {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200}; attrs.keep_top_k = {200};
attrs.num_classes = 2; attrs.num_classes = 2;
attrs.normalized = true; attrs.normalized = true;
@ -500,7 +509,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_box_logits_shape) {
// share_location = true // share_location = true
{ {
try { try {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.num_classes = 3; attrs.num_classes = 3;
attrs.share_location = true; attrs.share_location = true;
@ -526,7 +535,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_box_logits_shape) {
// share_location = false // share_location = false
{ {
try { try {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.num_classes = 3; attrs.num_classes = 3;
attrs.share_location = false; attrs.share_location = false;
@ -553,7 +562,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_box_logits_shape) {
TEST(type_prop_layers, detection_output_v0_invalid_class_preds_shape) { TEST(type_prop_layers, detection_output_v0_invalid_class_preds_shape) {
try { try {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.num_classes = 3; attrs.num_classes = 3;
auto op = create_detection_output(Shape{4, 12}, auto op = create_detection_output(Shape{4, 12},
@ -578,7 +587,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_proposals_shape) {
// variance_encoded_in_target = false // variance_encoded_in_target = false
{ {
try { try {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.num_classes = 3; attrs.num_classes = 3;
attrs.share_location = true; attrs.share_location = true;
@ -604,7 +613,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_proposals_shape) {
// variance_encoded_in_target = true // variance_encoded_in_target = true
{ {
try { try {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.num_classes = 3; attrs.num_classes = 3;
attrs.share_location = true; attrs.share_location = true;
@ -630,7 +639,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_proposals_shape) {
// normalized = false // normalized = false
{ {
try { try {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.num_classes = 3; attrs.num_classes = 3;
attrs.share_location = true; attrs.share_location = true;
@ -656,7 +665,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_proposals_shape) {
// normalized = true // normalized = true
{ {
try { try {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.num_classes = 3; attrs.num_classes = 3;
attrs.share_location = true; attrs.share_location = true;
@ -685,7 +694,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_aux_class_preds) {
// invalid batch size // invalid batch size
{ {
try { try {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.num_classes = 3; attrs.num_classes = 3;
attrs.share_location = true; attrs.share_location = true;
@ -711,7 +720,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_aux_class_preds) {
// invalid 2nd dimension // invalid 2nd dimension
{ {
try { try {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.num_classes = 3; attrs.num_classes = 3;
attrs.share_location = true; attrs.share_location = true;
@ -741,7 +750,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_aux_box_preds) {
// invalid batch size // invalid batch size
{ {
try { try {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.num_classes = 3; attrs.num_classes = 3;
attrs.share_location = true; attrs.share_location = true;
@ -767,7 +776,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_aux_box_preds) {
// invalid 2nd dimension // invalid 2nd dimension
{ {
try { try {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.num_classes = 3; attrs.num_classes = 3;
attrs.share_location = true; attrs.share_location = true;
@ -808,9 +817,9 @@ std::shared_ptr<op::v8::DetectionOutput> create_detection_output_v8(PartialShape
set_shape_labels(proposals_shape, 30); set_shape_labels(proposals_shape, 30);
} }
auto box_logits = make_shared<op::Parameter>(input_type, box_logits_shape); auto box_logits = make_shared<ov::op::v0::Parameter>(input_type, box_logits_shape);
auto class_preds = make_shared<op::Parameter>(input_type, class_preds_shape); auto class_preds = make_shared<ov::op::v0::Parameter>(input_type, class_preds_shape);
auto proposals = make_shared<op::Parameter>(input_type, proposals_shape); auto proposals = make_shared<ov::op::v0::Parameter>(input_type, proposals_shape);
return make_shared<op::v8::DetectionOutput>(box_logits, class_preds, proposals, attrs); return make_shared<op::v8::DetectionOutput>(box_logits, class_preds, proposals, attrs);
} }
@ -832,11 +841,11 @@ std::shared_ptr<op::v8::DetectionOutput> create_detection_output2_v8(PartialShap
set_shape_labels(aux_box_preds_shape, 50); set_shape_labels(aux_box_preds_shape, 50);
} }
auto box_logits = make_shared<op::Parameter>(input_type, box_logits_shape); auto box_logits = make_shared<ov::op::v0::Parameter>(input_type, box_logits_shape);
auto class_preds = make_shared<op::Parameter>(input_type, class_preds_shape); auto class_preds = make_shared<ov::op::v0::Parameter>(input_type, class_preds_shape);
auto proposals = make_shared<op::Parameter>(input_type, proposals_shape); auto proposals = make_shared<ov::op::v0::Parameter>(input_type, proposals_shape);
auto aux_class_preds = make_shared<op::Parameter>(input_type, aux_class_preds_shape); auto aux_class_preds = make_shared<ov::op::v0::Parameter>(input_type, aux_class_preds_shape);
auto aux_box_preds = make_shared<op::Parameter>(input_type, aux_box_preds_shape); auto aux_box_preds = make_shared<ov::op::v0::Parameter>(input_type, aux_box_preds_shape);
return make_shared<op::v8::DetectionOutput>(box_logits, return make_shared<op::v8::DetectionOutput>(box_logits,
class_preds, class_preds,
proposals, proposals,
@ -1128,11 +1137,11 @@ TEST(type_prop_layers, detection_output_v8_default_ctor) {
compute_reference_output_shape(attrs.keep_top_k, attrs.top_k, N, num_classes, num_prior_boxes); compute_reference_output_shape(attrs.keep_top_k, attrs.top_k, N, num_classes, num_prior_boxes);
auto input_type = element::f32; auto input_type = element::f32;
auto box_logits = make_shared<op::Parameter>(input_type, box_logits_shape); auto box_logits = make_shared<ov::op::v0::Parameter>(input_type, box_logits_shape);
auto class_preds = make_shared<op::Parameter>(input_type, class_preds_shape); auto class_preds = make_shared<ov::op::v0::Parameter>(input_type, class_preds_shape);
auto proposals = make_shared<op::Parameter>(input_type, proposals_shape); auto proposals = make_shared<ov::op::v0::Parameter>(input_type, proposals_shape);
auto ad_class_preds = make_shared<op::Parameter>(input_type, ad_class_preds_shape); auto ad_class_preds = make_shared<ov::op::v0::Parameter>(input_type, ad_class_preds_shape);
auto ad_box_preds = make_shared<op::Parameter>(input_type, box_logits_shape); auto ad_box_preds = make_shared<ov::op::v0::Parameter>(input_type, box_logits_shape);
auto op = make_shared<op::v8::DetectionOutput>(); auto op = make_shared<op::v8::DetectionOutput>();
op->set_attrs(attrs); op->set_attrs(attrs);
@ -1146,7 +1155,7 @@ TEST(type_prop_layers, detection_output_v8_default_ctor) {
} }
TEST(type_prop_layers, detection_output_v8_incompatible_num_prior_boxes_normalized_true_shareloc_true) { TEST(type_prop_layers, detection_output_v8_incompatible_num_prior_boxes_normalized_true_shareloc_true) {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.normalized = true; // If true, prior_box_size = 4, otherwise prior_box_size = 5 attrs.normalized = true; // If true, prior_box_size = 4, otherwise prior_box_size = 5
attrs.share_location = true; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes attrs.share_location = true; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes
@ -1163,7 +1172,7 @@ TEST(type_prop_layers, detection_output_v8_incompatible_num_prior_boxes_normaliz
} }
TEST(type_prop_layers, detection_output_v8_incompatible_num_prior_boxes_normalized_false_shareloc_true) { TEST(type_prop_layers, detection_output_v8_incompatible_num_prior_boxes_normalized_false_shareloc_true) {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.normalized = false; // If true, prior_box_size = 4, otherwise prior_box_size = 5 attrs.normalized = false; // If true, prior_box_size = 4, otherwise prior_box_size = 5
attrs.share_location = true; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes attrs.share_location = true; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes
@ -1180,7 +1189,7 @@ TEST(type_prop_layers, detection_output_v8_incompatible_num_prior_boxes_normaliz
} }
TEST(type_prop_layers, detection_output_v8_incompatible_num_prior_boxes_normalized_false_shareloc_false) { TEST(type_prop_layers, detection_output_v8_incompatible_num_prior_boxes_normalized_false_shareloc_false) {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.normalized = false; // If true, prior_box_size = 4, otherwise prior_box_size = 5 attrs.normalized = false; // If true, prior_box_size = 4, otherwise prior_box_size = 5
attrs.share_location = false; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes attrs.share_location = false; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes
@ -1197,7 +1206,7 @@ TEST(type_prop_layers, detection_output_v8_incompatible_num_prior_boxes_normaliz
} }
TEST(type_prop_layers, detection_output_v8_incompatible_num_prior_boxes_normalized_true_shareloc_false) { TEST(type_prop_layers, detection_output_v8_incompatible_num_prior_boxes_normalized_true_shareloc_false) {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.normalized = true; // If true, prior_box_size = 4, otherwise prior_box_size = 5 attrs.normalized = true; // If true, prior_box_size = 4, otherwise prior_box_size = 5
attrs.share_location = false; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes attrs.share_location = false; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes
@ -1213,7 +1222,7 @@ TEST(type_prop_layers, detection_output_v8_incompatible_num_prior_boxes_normaliz
} }
TEST(type_prop_layers, detection_output_v8_incompatible_dynamic_num_prior_boxes_normalized_true_shareloc_true) { TEST(type_prop_layers, detection_output_v8_incompatible_dynamic_num_prior_boxes_normalized_true_shareloc_true) {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.normalized = true; // If true, prior_box_size = 4, otherwise prior_box_size = 5 attrs.normalized = true; // If true, prior_box_size = 4, otherwise prior_box_size = 5
attrs.share_location = true; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes attrs.share_location = true; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes
@ -1230,7 +1239,7 @@ TEST(type_prop_layers, detection_output_v8_incompatible_dynamic_num_prior_boxes_
} }
TEST(type_prop_layers, detection_output_v8_dynamic_range_num_prior_boxes_normalized_true_shareloc_true) { TEST(type_prop_layers, detection_output_v8_dynamic_range_num_prior_boxes_normalized_true_shareloc_true) {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.normalized = true; // If true, prior_box_size = 4, otherwise prior_box_size = 5 attrs.normalized = true; // If true, prior_box_size = 4, otherwise prior_box_size = 5
attrs.share_location = true; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes attrs.share_location = true; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes
@ -1245,7 +1254,7 @@ TEST(type_prop_layers, detection_output_v8_dynamic_range_num_prior_boxes_normali
} }
TEST(type_prop_layers, detection_output_v8_dynamic_num_prior_boxes_normalized_true_shareloc_true) { TEST(type_prop_layers, detection_output_v8_dynamic_num_prior_boxes_normalized_true_shareloc_true) {
op::DetectionOutputAttrs attrs; ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1}; attrs.keep_top_k = {-1};
attrs.normalized = true; // If true, prior_box_size = 4, otherwise prior_box_size = 5 attrs.normalized = true; // If true, prior_box_size = 4, otherwise prior_box_size = 5
attrs.share_location = true; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes attrs.share_location = true; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes

79
src/core/tests/type_prop/dft.cpp
View File

@ -1,24 +1,15 @@
//***************************************************************************** // Copyright (C) 2018-2023 Intel Corporation
// Copyright 2017-2022 Intel Corporation // SPDX-License-Identifier: Apache-2.0
// //
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License. #include "openvino/op/dft.hpp"
// You may obtain a copy of the License at
// #include <gtest/gtest.h>
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//*****************************************************************************
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h" #include "openvino/op/constant.hpp"
#include "ngraph/ngraph.hpp"
using namespace ngraph; using namespace ov;
struct ConstantAxesAndConstantSignalSizeTestParams { struct ConstantAxesAndConstantSignalSizeTestParams {
PartialShape input_shape; PartialShape input_shape;
@ -34,15 +25,15 @@ struct ConstantAxesAndConstantSignalSizeTest : ::testing::TestWithParam<Constant
TEST_P(ConstantAxesAndConstantSignalSizeTest, dft_constant_axes_and_signal_size) { TEST_P(ConstantAxesAndConstantSignalSizeTest, dft_constant_axes_and_signal_size) {
auto params = GetParam(); auto params = GetParam();
auto data = std::make_shared<op::Parameter>(element::f32, params.input_shape); auto data = std::make_shared<ov::op::v0::Parameter>(element::f32, params.input_shape);
auto axes_input = op::Constant::create<int64_t>(element::i64, params.axes_shape, params.axes); auto axes_input = ov::op::v0::Constant::create<int64_t>(element::i64, params.axes_shape, params.axes);
std::shared_ptr<op::v7::DFT> dft; std::shared_ptr<op::v7::DFT> dft;
if (params.signal_size.empty()) { if (params.signal_size.empty()) {
dft = std::make_shared<op::v7::DFT>(data, axes_input); dft = std::make_shared<op::v7::DFT>(data, axes_input);
} else { } else {
auto signal_size_input = auto signal_size_input =
op::Constant::create<int64_t>(element::i64, params.signal_size_shape, params.signal_size); ov::op::v0::Constant::create<int64_t>(element::i64, params.signal_size_shape, params.signal_size);
dft = std::make_shared<op::v7::DFT>(data, axes_input, signal_size_input); dft = std::make_shared<op::v7::DFT>(data, axes_input, signal_size_input);
} }
@ -187,8 +178,8 @@ TEST(type_prop, dft_dynamic_axes) {
const auto ref_output_shape = const auto ref_output_shape =
PartialShape{Dimension::dynamic(), Dimension::dynamic(), Dimension::dynamic(), Dimension(1, 18)}; PartialShape{Dimension::dynamic(), Dimension::dynamic(), Dimension::dynamic(), Dimension(1, 18)};
auto data = std::make_shared<op::Parameter>(element::f32, input_shape); auto data = std::make_shared<ov::op::v0::Parameter>(element::f32, input_shape);
auto axes_input = std::make_shared<op::Parameter>(element::i64, axes_shape); auto axes_input = std::make_shared<ov::op::v0::Parameter>(element::i64, axes_shape);
auto dft = std::make_shared<op::v7::DFT>(data, axes_input); auto dft = std::make_shared<op::v7::DFT>(data, axes_input);
EXPECT_EQ(dft->get_element_type(), element::f32); EXPECT_EQ(dft->get_element_type(), element::f32);
@ -206,8 +197,8 @@ struct NonConstantAxesTest : ::testing::TestWithParam<NonConstantAxesTestParams>
TEST_P(NonConstantAxesTest, dft_non_constant_axes) { TEST_P(NonConstantAxesTest, dft_non_constant_axes) {
auto params = GetParam(); auto params = GetParam();
auto data = std::make_shared<op::Parameter>(element::f32, params.input_shape); auto data = std::make_shared<ov::op::v0::Parameter>(element::f32, params.input_shape);
auto axes_input = std::make_shared<op::Parameter>(element::i64, params.axes_shape); auto axes_input = std::make_shared<ov::op::v0::Parameter>(element::i64, params.axes_shape);
auto dft = std::make_shared<op::v7::DFT>(data, axes_input); auto dft = std::make_shared<op::v7::DFT>(data, axes_input);
EXPECT_EQ(dft->get_element_type(), element::f32); EXPECT_EQ(dft->get_element_type(), element::f32);
@ -279,9 +270,9 @@ struct NonConstantSignalSizeTest : ::testing::TestWithParam<NonConstantSignalSiz
TEST_P(NonConstantSignalSizeTest, dft_non_constant_signal_size) { TEST_P(NonConstantSignalSizeTest, dft_non_constant_signal_size) {
auto params = GetParam(); auto params = GetParam();
auto data = std::make_shared<op::Parameter>(element::f32, params.input_shape); auto data = std::make_shared<ov::op::v0::Parameter>(element::f32, params.input_shape);
auto axes_input = op::Constant::create<int64_t>(element::i64, params.axes_shape, params.axes); auto axes_input = ov::op::v0::Constant::create<int64_t>(element::i64, params.axes_shape, params.axes);
auto signal_size_input = std::make_shared<op::Parameter>(element::i64, params.signal_size_shape); auto signal_size_input = std::make_shared<ov::op::v0::Parameter>(element::i64, params.signal_size_shape);
auto dft = std::make_shared<op::v7::DFT>(data, axes_input, signal_size_input); auto dft = std::make_shared<op::v7::DFT>(data, axes_input, signal_size_input);
EXPECT_EQ(dft->get_element_type(), element::f32); EXPECT_EQ(dft->get_element_type(), element::f32);
@ -310,10 +301,10 @@ INSTANTIATE_TEST_SUITE_P(
PrintToDummyParamName()); PrintToDummyParamName());
TEST(type_prop, dft_invalid_input) { TEST(type_prop, dft_invalid_input) {
auto axes = op::Constant::create(element::i64, Shape{2}, {0, 1}); auto axes = ov::op::v0::Constant::create(element::i64, Shape{2}, {0, 1});
try { try {
auto data = std::make_shared<op::Parameter>(element::f32, Shape{2}); auto data = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2});
auto dft = std::make_shared<op::v7::DFT>(data, axes); auto dft = std::make_shared<op::v7::DFT>(data, axes);
FAIL() << "DFT node was created with invalid input."; FAIL() << "DFT node was created with invalid input.";
} catch (const NodeValidationFailure& error) { } catch (const NodeValidationFailure& error) {
@ -321,7 +312,7 @@ TEST(type_prop, dft_invalid_input) {
} }
try { try {
auto data = std::make_shared<op::Parameter>(element::f32, Shape{4, 3}); auto data = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{4, 3});
auto dft = std::make_shared<op::v7::DFT>(data, axes); auto dft = std::make_shared<op::v7::DFT>(data, axes);
FAIL() << "DFT node was created with invalid input."; FAIL() << "DFT node was created with invalid input.";
} catch (const NodeValidationFailure& error) { } catch (const NodeValidationFailure& error) {
@ -329,7 +320,7 @@ TEST(type_prop, dft_invalid_input) {
} }
try { try {
auto data = std::make_shared<op::Parameter>(element::f32, Shape{4, 2}); auto data = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{4, 2});
auto dft = std::make_shared<op::v7::DFT>(data, axes); auto dft = std::make_shared<op::v7::DFT>(data, axes);
FAIL() << "DFT node was created with invalid input."; FAIL() << "DFT node was created with invalid input.";
} catch (const NodeValidationFailure& error) { } catch (const NodeValidationFailure& error) {
@ -338,10 +329,10 @@ TEST(type_prop, dft_invalid_input) {
} }
TEST(type_prop, dft_invalid_axes) { TEST(type_prop, dft_invalid_axes) {
auto data = std::make_shared<op::Parameter>(element::f32, Shape{4, 3, 2}); auto data = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{4, 3, 2});
try { try {
auto axes = op::Constant::create(element::i64, Shape{1}, {3}); auto axes = ov::op::v0::Constant::create(element::i64, Shape{1}, {3});
auto dft = std::make_shared<op::v7::DFT>(data, axes); auto dft = std::make_shared<op::v7::DFT>(data, axes);
FAIL() << "DFT node was created with invalid axes."; FAIL() << "DFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) { } catch (const NodeValidationFailure& error) {
@ -349,7 +340,7 @@ TEST(type_prop, dft_invalid_axes) {
} }
try { try {
auto axes = op::Constant::create(element::i64, Shape{1}, {-3}); auto axes = ov::op::v0::Constant::create(element::i64, Shape{1}, {-3});
auto dft = std::make_shared<op::v7::DFT>(data, axes); auto dft = std::make_shared<op::v7::DFT>(data, axes);
FAIL() << "DFT node was created with invalid axes."; FAIL() << "DFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) { } catch (const NodeValidationFailure& error) {
@ -357,7 +348,7 @@ TEST(type_prop, dft_invalid_axes) {
} }
try { try {
auto axes = op::Constant::create(element::i64, Shape{2}, {0, -2}); auto axes = ov::op::v0::Constant::create(element::i64, Shape{2}, {0, -2});
auto dft = std::make_shared<op::v7::DFT>(data, axes); auto dft = std::make_shared<op::v7::DFT>(data, axes);
FAIL() << "DFT node was created with invalid axes."; FAIL() << "DFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) { } catch (const NodeValidationFailure& error) {
@ -365,7 +356,7 @@ TEST(type_prop, dft_invalid_axes) {
} }
try { try {
auto axes = op::Constant::create(element::i64, Shape{1}, {2}); auto axes = ov::op::v0::Constant::create(element::i64, Shape{1}, {2});
auto dft = std::make_shared<op::v7::DFT>(data, axes); auto dft = std::make_shared<op::v7::DFT>(data, axes);
FAIL() << "DFT node was created with invalid axes."; FAIL() << "DFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) { } catch (const NodeValidationFailure& error) {
@ -373,7 +364,7 @@ TEST(type_prop, dft_invalid_axes) {
} }
try { try {
auto axes = op::Constant::create(element::i64, Shape{1, 2}, {0, 1}); auto axes = ov::op::v0::Constant::create(element::i64, Shape{1, 2}, {0, 1});
auto dft = std::make_shared<op::v7::DFT>(data, axes); auto dft = std::make_shared<op::v7::DFT>(data, axes);
FAIL() << "DFT node was created with invalid axes."; FAIL() << "DFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) { } catch (const NodeValidationFailure& error) {
@ -382,11 +373,11 @@ TEST(type_prop, dft_invalid_axes) {
} }
TEST(type_prop, dft_invalid_signal_size) { TEST(type_prop, dft_invalid_signal_size) {
auto data = std::make_shared<op::Parameter>(element::f32, Shape{4, 3, 2}); auto data = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{4, 3, 2});
auto axes = op::Constant::create(element::i64, Shape{1}, {0}); auto axes = ov::op::v0::Constant::create(element::i64, Shape{1}, {0});
try { try {
auto signal_size = op::Constant::create(element::i64, Shape{1, 2}, {0, 1}); auto signal_size = ov::op::v0::Constant::create(element::i64, Shape{1, 2}, {0, 1});
auto dft = std::make_shared<op::v7::DFT>(data, axes, signal_size); auto dft = std::make_shared<op::v7::DFT>(data, axes, signal_size);
FAIL() << "DFT node was created with invalid signal size."; FAIL() << "DFT node was created with invalid signal size.";
} catch (const NodeValidationFailure& error) { } catch (const NodeValidationFailure& error) {
@ -394,7 +385,7 @@ TEST(type_prop, dft_invalid_signal_size) {
} }
try { try {
auto signal_size = op::Constant::create(element::i64, Shape{2}, {0, 1}); auto signal_size = ov::op::v0::Constant::create(element::i64, Shape{2}, {0, 1});
auto dft = std::make_shared<op::v7::DFT>(data, axes, signal_size); auto dft = std::make_shared<op::v7::DFT>(data, axes, signal_size);
FAIL() << "DFT node was created with invalid signal size."; FAIL() << "DFT node was created with invalid signal size.";
} catch (const NodeValidationFailure& error) { } catch (const NodeValidationFailure& error) {
@ -408,9 +399,9 @@ TEST(type_prop, dft_dynamic_types) {
const auto signal_size_shape = PartialShape::dynamic(); const auto signal_size_shape = PartialShape::dynamic();
const auto ref_output_shape = PartialShape{Dimension::dynamic(), Dimension::dynamic(), Dimension::dynamic(), 2}; const auto ref_output_shape = PartialShape{Dimension::dynamic(), Dimension::dynamic(), Dimension::dynamic(), 2};
auto data = std::make_shared<op::Parameter>(element::dynamic, input_shape); auto data = std::make_shared<ov::op::v0::Parameter>(element::dynamic, input_shape);
auto axes_input = std::make_shared<op::Parameter>(element::dynamic, axes_shape); auto axes_input = std::make_shared<ov::op::v0::Parameter>(element::dynamic, axes_shape);
auto signal_size_input = std::make_shared<op::Parameter>(element::dynamic, signal_size_shape); auto signal_size_input = std::make_shared<ov::op::v0::Parameter>(element::dynamic, signal_size_shape);
auto dft = std::make_shared<op::v7::DFT>(data, axes_input, signal_size_input); auto dft = std::make_shared<op::v7::DFT>(data, axes_input, signal_size_input);
EXPECT_EQ(dft->get_element_type(), element::dynamic); EXPECT_EQ(dft->get_element_type(), element::dynamic);

18
src/core/tests/type_prop/dyn_reshape.cpp
View File

@ -2,27 +2,29 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h" #include "openvino/op/constant.hpp"
#include "ngraph/ngraph.hpp" #include "openvino/op/reshape.hpp"
using namespace std; using namespace std;
using namespace ngraph; using namespace ov;
TEST(type_prop, reshape_v1_arg_rank_static_pattern_zero) { TEST(type_prop, reshape_v1_arg_rank_static_pattern_zero) {
auto arg = make_shared<op::Parameter>(element::f32, Shape{2, 0, 2, 8}); auto arg = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 0, 2, 8});
auto pattern = op::Constant::create(element::i64, Shape{4}, {1, 2, 0, 32}); auto pattern = ov::op::v0::Constant::create(element::i64, Shape{4}, {1, 2, 0, 32});
auto reshape_v1_static = make_shared<op::v1::Reshape>(arg, pattern, true); auto reshape_v1_static = make_shared<op::v1::Reshape>(arg, pattern, true);
EXPECT_EQ(reshape_v1_static->get_output_shape(0), Shape({1, 2, 2, 32})); EXPECT_EQ(reshape_v1_static->get_output_shape(0), Shape({1, 2, 2, 32}));
auto dynamic_arg = make_shared<op::Parameter>(element::f32, PartialShape::dynamic()); auto dynamic_arg = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto reshape_v1_dynamic = make_shared<op::v1::Reshape>(dynamic_arg, pattern, true); auto reshape_v1_dynamic = make_shared<op::v1::Reshape>(dynamic_arg, pattern, true);
EXPECT_TRUE( EXPECT_TRUE(
reshape_v1_dynamic->get_output_partial_shape(0).same_scheme(PartialShape{1, 2, Dimension::dynamic(), 32})); reshape_v1_dynamic->get_output_partial_shape(0).same_scheme(PartialShape{1, 2, Dimension::dynamic(), 32}));
try { try {
auto static_shape_parameter = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4}); auto static_shape_parameter = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto reshape_output_pattern = op::Constant::create(element::i64, Shape{4}, {2, 2, 3, 4}); auto reshape_output_pattern = ov::op::v0::Constant::create(element::i64, Shape{4}, {2, 2, 3, 4});
auto reshape = make_shared<op::v1::Reshape>(static_shape_parameter, reshape_output_pattern, true); auto reshape = make_shared<op::v1::Reshape>(static_shape_parameter, reshape_output_pattern, true);
FAIL() << "Expected failure on reshape construction"; FAIL() << "Expected failure on reshape construction";
} catch (const NodeValidationFailure& error) { } catch (const NodeValidationFailure& error) {

30
src/core/tests/type_prop/einsum.cpp
View File

@ -2,29 +2,31 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include "openvino/op/einsum.hpp"
#include <gmock/gmock.h>
#include "common_test_utils/test_assertions.hpp" #include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gmock/gmock.h"
#include "ngraph/ngraph.hpp"
#include "openvino/core/dimension_tracker.hpp" #include "openvino/core/dimension_tracker.hpp"
#include "openvino/pass/graph_rewrite.hpp" #include "openvino/pass/graph_rewrite.hpp"
using namespace std; using namespace std;
using namespace ngraph; using namespace ov;
using namespace testing; using namespace testing;
namespace { namespace {
constexpr size_t exp_einsum_outputs_count = 1; constexpr size_t exp_einsum_outputs_count = 1;
} }
class TypePropEinsumTest : public TypePropOpTest<op::v7::Einsum> { class TypePropEinsumTest : public TypePropOpTest<ov::op::v7::Einsum> {
protected: protected:
template <class ShapeContainer> template <class ShapeContainer>
OutputVector make_inputs(const element::Type dtype, ShapeContainer&& input_shapes) const { OutputVector make_inputs(const element::Type dtype, ShapeContainer&& input_shapes) const {
OutputVector inputs; OutputVector inputs;
inputs.reserve(input_shapes.size()); inputs.reserve(input_shapes.size());
for (auto&& shape : input_shapes) { for (auto&& shape : input_shapes) {
inputs.push_back(std::make_shared<op::Parameter>(dtype, shape)); inputs.push_back(std::make_shared<ov::op::v0::Parameter>(dtype, shape));
} }
return inputs; return inputs;
} }
@ -58,7 +60,7 @@ TEST_F(TypePropEinsumTest, static_shape_trace) {
const std::string equation = "kii->k"; const std::string equation = "kii->k";
constexpr auto et = element::f32; constexpr auto et = element::f32;
const auto input = make_shared<op::Parameter>(et, Shape{2, 3, 3}); const auto input = make_shared<ov::op::v0::Parameter>(et, Shape{2, 3, 3});
const auto o = make_op(OutputVector{input}, equation); const auto o = make_op(OutputVector{input}, equation);
EXPECT_EQ(o->get_equation(), equation); EXPECT_EQ(o->get_equation(), equation);
@ -71,7 +73,7 @@ TEST_F(TypePropEinsumTest, static_shape_diag_extraction) {
const std::string equation = "kii->ki"; const std::string equation = "kii->ki";
constexpr auto et = element::f32; constexpr auto et = element::f32;
const auto input = make_shared<op::Parameter>(et, Shape{2, 3, 3}); const auto input = make_shared<ov::op::v0::Parameter>(et, Shape{2, 3, 3});
const auto o = make_op(OutputVector{input}, equation); const auto o = make_op(OutputVector{input}, equation);
EXPECT_EQ(o->get_equation(), equation); EXPECT_EQ(o->get_equation(), equation);
@ -84,7 +86,7 @@ TEST_F(TypePropEinsumTest, static_shape_transpose) {
const std::string equation = "ijk->kij"; const std::string equation = "ijk->kij";
constexpr auto et = element::f32; constexpr auto et = element::f32;
const auto input = make_shared<op::Parameter>(et, Shape{1, 2, 3}); const auto input = make_shared<ov::op::v0::Parameter>(et, Shape{1, 2, 3});
const auto o = make_op(OutputVector{input}, equation); const auto o = make_op(OutputVector{input}, equation);
EXPECT_EQ(o->get_equation(), equation); EXPECT_EQ(o->get_equation(), equation);
@ -109,7 +111,7 @@ TEST_F(TypePropEinsumTest, static_shape_ellipsis_one_input) {
const std::string equation = "a...->..."; const std::string equation = "a...->...";
constexpr auto et = element::f32; constexpr auto et = element::f32;
const auto input = make_shared<op::Parameter>(et, Shape{5, 3}); const auto input = make_shared<ov::op::v0::Parameter>(et, Shape{5, 3});
const auto o = make_op(OutputVector{input}, equation); const auto o = make_op(OutputVector{input}, equation);
EXPECT_EQ(o->get_equation(), equation); EXPECT_EQ(o->get_equation(), equation);
@ -167,7 +169,7 @@ TEST_F(TypePropEinsumTest, dynamic_shape_diag_extraction) {
auto input_shape = PartialShape{{2, 7}, {1, 5}, 4, {3, 5}, 3}; auto input_shape = PartialShape{{2, 7}, {1, 5}, 4, {3, 5}, 3};
set_shape_labels(input_shape, 10); set_shape_labels(input_shape, 10);
const auto input = make_shared<op::Parameter>(et, input_shape); const auto input = make_shared<ov::op::v0::Parameter>(et, input_shape);
const auto o = make_op(OutputVector{input}, equation); const auto o = make_op(OutputVector{input}, equation);
EXPECT_EQ(o->get_equation(), equation); EXPECT_EQ(o->get_equation(), equation);
@ -201,7 +203,7 @@ TEST_F(TypePropEinsumTest, implicit_mode_mixed_case_letters) {
auto input_shape = PartialShape{1, {2, 3}, {4, 5}}; auto input_shape = PartialShape{1, {2, 3}, {4, 5}};
set_shape_labels(input_shape, 10); set_shape_labels(input_shape, 10);
const auto input = make_shared<op::Parameter>(et, input_shape); const auto input = make_shared<ov::op::v0::Parameter>(et, input_shape);
const auto o = make_op(OutputVector{input}, equation); const auto o = make_op(OutputVector{input}, equation);
EXPECT_EQ(o->get_equation(), equation); EXPECT_EQ(o->get_equation(), equation);
@ -337,7 +339,7 @@ TEST_F(TypePropEinsumTest, incorrect_equation_invalid_labels) {
const auto inputs = make_inputs(element::f32, input_shapes); const auto inputs = make_inputs(element::f32, input_shapes);
OV_EXPECT_THROW(auto o = make_op(inputs, equation), OV_EXPECT_THROW(auto o = make_op(inputs, equation),
CheckFailure, AssertFailure,
HasSubstr("Input subscript of Einsum equation must consist of either only alphabetic " HasSubstr("Input subscript of Einsum equation must consist of either only alphabetic "
"letters or alphabetic letters with one ellipsis.")); "letters or alphabetic letters with one ellipsis."));
} }
@ -349,7 +351,7 @@ TEST_F(TypePropEinsumTest, incorrect_equation_incompatible_shapes) {
const auto inputs = make_inputs(element::f32, input_shapes); const auto inputs = make_inputs(element::f32, input_shapes);
OV_EXPECT_THROW(auto o = make_op(inputs, equation), OV_EXPECT_THROW(auto o = make_op(inputs, equation),
CheckFailure, AssertFailure,
HasSubstr("Different input dimensions indicated by the same labels " HasSubstr("Different input dimensions indicated by the same labels "
"for Einsum must be compatible.")); "for Einsum must be compatible."));
} }
@ -372,7 +374,7 @@ TEST_F(TypePropEinsumTest, incorrect_equation_missed_ellipsis) {
const auto inputs = make_inputs(element::f32, input_shapes); const auto inputs = make_inputs(element::f32, input_shapes);
OV_EXPECT_THROW(auto o = make_op(inputs, equation), OV_EXPECT_THROW(auto o = make_op(inputs, equation),
CheckFailure, AssertFailure,
HasSubstr("Output subscript of Einsum equation must contain one " HasSubstr("Output subscript of Einsum equation must contain one "
"ellipsis if ellipsis is met in any input subscript.")); "ellipsis if ellipsis is met in any input subscript."));
} }

15
src/core/tests/type_prop/elu.cpp
View File

@ -2,17 +2,18 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include "openvino/op/elu.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
using namespace std; using namespace std;
using namespace ngraph;
TEST(type_prop, elu) { TEST(type_prop, elu) {
Shape data_shape{2, 4}; ov::Shape data_shape{2, 4};
auto data = make_shared<op::Parameter>(element::f32, data_shape); auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, data_shape);
auto elu = make_shared<op::Elu>(data, 1); auto elu = make_shared<ov::op::v0::Elu>(data, 1);
ASSERT_EQ(elu->get_element_type(), element::f32); ASSERT_EQ(elu->get_element_type(), ov::element::f32);
ASSERT_EQ(elu->get_shape(), data_shape); ASSERT_EQ(elu->get_shape(), data_shape);
} }

261
src/core/tests/type_prop/embedding_segments_sum.cpp
View File

@ -2,24 +2,27 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include "openvino/op/embedding_segments_sum.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/test_assertions.hpp" #include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h" #include "openvino/op/constant.hpp"
#include "ngraph/ngraph.hpp" #include "openvino/op/shape_of.hpp"
#include "ngraph/op/constant.hpp" #include "openvino/op/squeeze.hpp"
#include "ngraph/opsets/opset3.hpp"
using namespace std; using namespace std;
using namespace ngraph; using namespace ov;
using namespace testing; using namespace testing;
TEST(type_prop, ess_default_ctor) { TEST(type_prop, ess_default_ctor) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2, 6}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2, 6});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{}); auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto op = make_shared<op::v3::EmbeddingSegmentsSum>(); auto op = make_shared<op::v3::EmbeddingSegmentsSum>();
op->set_arguments(OutputVector{emb_table, indices, segment_ids, num_segments, default_index, per_sample_weights}); op->set_arguments(OutputVector{emb_table, indices, segment_ids, num_segments, default_index, per_sample_weights});
@ -30,12 +33,12 @@ TEST(type_prop, ess_default_ctor) {
} }
TEST(type_prop, ess) { TEST(type_prop, ess) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{}); auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table,
indices, indices,
@ -51,12 +54,12 @@ TEST(type_prop, ess) {
} }
TEST(type_prop, ess_dynamic_emb_table_number_segment) { TEST(type_prop, ess_dynamic_emb_table_number_segment) {
auto emb_table = make_shared<op::Parameter>(element::f32, PartialShape{5, Dimension::dynamic()}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{5, Dimension::dynamic()});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{}); auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table,
indices, indices,
@ -69,12 +72,12 @@ TEST(type_prop, ess_dynamic_emb_table_number_segment) {
} }
TEST(type_prop, ess_fail_indices_element_type) { TEST(type_prop, ess_fail_indices_element_type) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::f32, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{}); auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try { try {
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table,
@ -92,12 +95,12 @@ TEST(type_prop, ess_fail_indices_element_type) {
} }
TEST(type_prop, ess_fail_segment_ids_element_type) { TEST(type_prop, ess_fail_segment_ids_element_type) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::f32, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{}); auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try { try {
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table,
@ -115,12 +118,12 @@ TEST(type_prop, ess_fail_segment_ids_element_type) {
} }
TEST(type_prop, ess_fail_number_segments_element_type) { TEST(type_prop, ess_fail_number_segments_element_type) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::f32, Shape{}); auto num_segments = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try { try {
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table,
@ -138,12 +141,12 @@ TEST(type_prop, ess_fail_number_segments_element_type) {
} }
TEST(type_prop, ess_fail_default_index_element_type) { TEST(type_prop, ess_fail_default_index_element_type) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{}); auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::f32, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
try { try {
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table,
@ -161,12 +164,12 @@ TEST(type_prop, ess_fail_default_index_element_type) {
} }
TEST(type_prop, ess_fail_mismatch_element_type) { TEST(type_prop, ess_fail_mismatch_element_type) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i32, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i32, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{}); auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try { try {
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table,
@ -185,12 +188,12 @@ TEST(type_prop, ess_fail_mismatch_element_type) {
} }
TEST(type_prop, ess_fail_mismatch_element_type_1) { TEST(type_prop, ess_fail_mismatch_element_type_1) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{}); auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i32, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i32, Shape{});
try { try {
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table,
@ -209,12 +212,12 @@ TEST(type_prop, ess_fail_mismatch_element_type_1) {
} }
TEST(type_prop, ess_fail_mismatch_element_type_2) { TEST(type_prop, ess_fail_mismatch_element_type_2) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{}); auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::i64, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try { try {
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table,
@ -234,12 +237,12 @@ TEST(type_prop, ess_fail_mismatch_element_type_2) {
} }
TEST(type_prop, ess_fail_mismatch_element_type_3) { TEST(type_prop, ess_fail_mismatch_element_type_3) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i32, Shape{}); auto num_segments = make_shared<ov::op::v0::Parameter>(element::i32, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try { try {
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table,
@ -258,12 +261,12 @@ TEST(type_prop, ess_fail_mismatch_element_type_3) {
} }
TEST(type_prop, ess_fail_mismatch_shape) { TEST(type_prop, ess_fail_mismatch_shape) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{}); auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{3}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try { try {
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table,
@ -281,12 +284,12 @@ TEST(type_prop, ess_fail_mismatch_shape) {
} }
TEST(type_prop, ess_fail_num_segments_scalar) { TEST(type_prop, ess_fail_num_segments_scalar) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{2}); auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{2});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try { try {
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table,
@ -304,12 +307,12 @@ TEST(type_prop, ess_fail_num_segments_scalar) {
} }
TEST(type_prop, ess_fail_default_index_scalar) { TEST(type_prop, ess_fail_default_index_scalar) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{}); auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{2}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{2});
try { try {
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table,
@ -327,12 +330,12 @@ TEST(type_prop, ess_fail_default_index_scalar) {
} }
TEST(type_prop, ess_fail_indices_1d) { TEST(type_prop, ess_fail_indices_1d) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4, 2}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4, 2});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{}); auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try { try {
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table,
@ -350,12 +353,12 @@ TEST(type_prop, ess_fail_indices_1d) {
} }
TEST(type_prop, ess_fail_segment_ids_1d) { TEST(type_prop, ess_fail_segment_ids_1d) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{3, 2}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3, 2});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{}); auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try { try {
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table,
@ -373,12 +376,12 @@ TEST(type_prop, ess_fail_segment_ids_1d) {
} }
TEST(type_prop, ess_fail_per_sample_weights_1d) { TEST(type_prop, ess_fail_per_sample_weights_1d) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{}); auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4, 2}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4, 2});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try { try {
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table,
@ -396,12 +399,12 @@ TEST(type_prop, ess_fail_per_sample_weights_1d) {
} }
TEST(type_prop, ess_fail_emb_table_0d) { TEST(type_prop, ess_fail_emb_table_0d) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{}); auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
OV_EXPECT_THROW(auto op = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, OV_EXPECT_THROW(auto op = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table,
indices, indices,
@ -414,10 +417,10 @@ TEST(type_prop, ess_fail_emb_table_0d) {
} }
TEST(type_prop, ess_4_args_api) { TEST(type_prop, ess_4_args_api) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{}); auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, indices, segment_ids, num_segments); auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, indices, segment_ids, num_segments);
EXPECT_TRUE(ess->get_output_partial_shape(0).same_scheme(PartialShape{Dimension::dynamic(), 2})); EXPECT_TRUE(ess->get_output_partial_shape(0).same_scheme(PartialShape{Dimension::dynamic(), 2}));
@ -427,10 +430,10 @@ TEST(type_prop, ess_4_args_api) {
} }
TEST(type_prop, ess_fail_indices_element_type_4_args_api) { TEST(type_prop, ess_fail_indices_element_type_4_args_api) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::f32, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{}); auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try { try {
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, indices, segment_ids, num_segments); auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, indices, segment_ids, num_segments);
@ -443,10 +446,10 @@ TEST(type_prop, ess_fail_indices_element_type_4_args_api) {
} }
TEST(type_prop, ess_num_segment_const) { TEST(type_prop, ess_num_segment_const) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = opset3::Constant::create(element::i64, Shape{}, {3}); auto num_segments = ov::op::v0::Constant::create(element::i64, Shape{}, {3});
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, indices, segment_ids, num_segments); auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, indices, segment_ids, num_segments);
EXPECT_TRUE(ess->get_output_partial_shape(0).same_scheme(PartialShape{3, 2})); EXPECT_TRUE(ess->get_output_partial_shape(0).same_scheme(PartialShape{3, 2}));
@ -461,13 +464,13 @@ TEST(type_prop, ess_num_segment_interval_label_propagation) {
auto num_segm_shape = PartialShape{{6, 8}}; auto num_segm_shape = PartialShape{{6, 8}};
set_shape_labels(num_segm_shape, 20); set_shape_labels(num_segm_shape, 20);
auto num_segments = make_shared<op::Parameter>(element::i64, num_segm_shape); auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, num_segm_shape);
auto shape_of = make_shared<op::v3::ShapeOf>(num_segments); auto shape_of = make_shared<op::v3::ShapeOf>(num_segments);
auto num_segm_squeeze = make_shared<op::v0::Squeeze>(shape_of); auto num_segm_squeeze = make_shared<op::v0::Squeeze>(shape_of);
auto emb_table = make_shared<op::Parameter>(element::f32, emb_shape); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, emb_shape);
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4}); auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto op = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, indices, segment_ids, num_segm_squeeze); auto op = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table, indices, segment_ids, num_segm_squeeze);
EXPECT_EQ(op->get_output_element_type(0), element::f32); EXPECT_EQ(op->get_output_element_type(0), element::f32);

199
src/core/tests/type_prop/embeddingbag_offsetssum.cpp
View File

@ -2,21 +2,22 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include <gtest/gtest.h>
#include "common_test_utils/test_assertions.hpp" #include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h" #include "openvino/op/embeddingbag_offsets_sum.hpp"
#include "ngraph/ngraph.hpp"
using namespace std; using namespace std;
using namespace ngraph; using namespace ov;
using namespace testing; using namespace testing;
TEST(type_prop, ebos_default_ctor) { TEST(type_prop, ebos_default_ctor) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2, 6}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2, 6});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3}); auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto op = make_shared<op::v3::EmbeddingBagOffsetsSum>(); auto op = make_shared<op::v3::EmbeddingBagOffsetsSum>();
op->set_arguments(OutputVector{emb_table, indices, offsets, default_index, per_sample_weights}); op->set_arguments(OutputVector{emb_table, indices, offsets, default_index, per_sample_weights});
@ -32,11 +33,11 @@ TEST(type_prop, ebos_labeled_interval_dims) {
auto off_shape = PartialShape{{6, 8}}; auto off_shape = PartialShape{{6, 8}};
set_shape_labels(off_shape, 20); set_shape_labels(off_shape, 20);
auto emb_table = make_shared<op::Parameter>(element::f32, emb_shape); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, emb_shape);
auto indices = make_shared<op::Parameter>(element::i64, PartialShape{{3, 4}}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, PartialShape{{3, 4}});
auto offsets = make_shared<op::Parameter>(element::i64, off_shape); auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, off_shape);
auto per_sample_weights = make_shared<op::Parameter>(element::f32, PartialShape{{3, 4}}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{{3, 4}});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto op = auto op =
make_shared<op::v3::EmbeddingBagOffsetsSum>(emb_table, indices, offsets, default_index, per_sample_weights); make_shared<op::v3::EmbeddingBagOffsetsSum>(emb_table, indices, offsets, default_index, per_sample_weights);
@ -46,11 +47,11 @@ TEST(type_prop, ebos_labeled_interval_dims) {
} }
TEST(type_prop, ebos) { TEST(type_prop, ebos) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3}); auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto ebos = auto ebos =
make_shared<op::v3::EmbeddingBagOffsetsSum>(emb_table, indices, offsets, default_index, per_sample_weights); make_shared<op::v3::EmbeddingBagOffsetsSum>(emb_table, indices, offsets, default_index, per_sample_weights);
@ -62,11 +63,11 @@ TEST(type_prop, ebos) {
} }
TEST(type_prop, ebos_dynamic_emb_table) { TEST(type_prop, ebos_dynamic_emb_table) {
auto emb_table = make_shared<op::Parameter>(element::f32, PartialShape{5, Dimension::dynamic()}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{5, Dimension::dynamic()});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3}); auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto ebos = auto ebos =
make_shared<op::v3::EmbeddingBagOffsetsSum>(emb_table, indices, offsets, default_index, per_sample_weights); make_shared<op::v3::EmbeddingBagOffsetsSum>(emb_table, indices, offsets, default_index, per_sample_weights);
@ -75,11 +76,11 @@ TEST(type_prop, ebos_dynamic_emb_table) {
} }
TEST(type_prop, ebos_dynamic_offsets) { TEST(type_prop, ebos_dynamic_offsets) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, PartialShape{Dimension::dynamic()}); auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, PartialShape{Dimension::dynamic()});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto ebos = auto ebos =
make_shared<op::v3::EmbeddingBagOffsetsSum>(emb_table, indices, offsets, default_index, per_sample_weights); make_shared<op::v3::EmbeddingBagOffsetsSum>(emb_table, indices, offsets, default_index, per_sample_weights);
@ -88,11 +89,11 @@ TEST(type_prop, ebos_dynamic_offsets) {
} }
TEST(type_prop, ebos_dynamic_emb_table_offsets) { TEST(type_prop, ebos_dynamic_emb_table_offsets) {
auto emb_table = make_shared<op::Parameter>(element::f32, PartialShape{5, Dimension::dynamic()}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{5, Dimension::dynamic()});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, PartialShape{Dimension::dynamic()}); auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, PartialShape{Dimension::dynamic()});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto ebos = auto ebos =
make_shared<op::v3::EmbeddingBagOffsetsSum>(emb_table, indices, offsets, default_index, per_sample_weights); make_shared<op::v3::EmbeddingBagOffsetsSum>(emb_table, indices, offsets, default_index, per_sample_weights);
@ -102,11 +103,11 @@ TEST(type_prop, ebos_dynamic_emb_table_offsets) {
} }
TEST(type_prop, ebos_fail_indices_element_type) { TEST(type_prop, ebos_fail_indices_element_type) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::f32, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3}); auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try { try {
auto ebos = auto ebos =
@ -120,11 +121,11 @@ TEST(type_prop, ebos_fail_indices_element_type) {
} }
TEST(type_prop, ebos_fail_offsets_element_type) { TEST(type_prop, ebos_fail_offsets_element_type) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::f32, Shape{3}); auto offsets = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try { try {
auto ebos = auto ebos =
@ -138,11 +139,11 @@ TEST(type_prop, ebos_fail_offsets_element_type) {
} }
TEST(type_prop, ebos_fail_default_index_element_type) { TEST(type_prop, ebos_fail_default_index_element_type) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3}); auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::f32, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
try { try {
auto ebos = auto ebos =
@ -156,11 +157,11 @@ TEST(type_prop, ebos_fail_default_index_element_type) {
} }
TEST(type_prop, ebos_fail_mismatch_element_type) { TEST(type_prop, ebos_fail_mismatch_element_type) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i32, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i32, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3}); auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try { try {
auto ebos = auto ebos =
@ -175,11 +176,11 @@ TEST(type_prop, ebos_fail_mismatch_element_type) {
} }
TEST(type_prop, ebos_fail_mismatch_element_type_1) { TEST(type_prop, ebos_fail_mismatch_element_type_1) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3}); auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i32, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i32, Shape{});
try { try {
auto ebos = auto ebos =
@ -194,11 +195,11 @@ TEST(type_prop, ebos_fail_mismatch_element_type_1) {
} }
TEST(type_prop, ebos_fail_mismatch_element_type_2) { TEST(type_prop, ebos_fail_mismatch_element_type_2) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3}); auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::i64, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try { try {
auto ebos = auto ebos =
@ -214,11 +215,11 @@ TEST(type_prop, ebos_fail_mismatch_element_type_2) {
} }
TEST(type_prop, ebos_fail_mismatch_shape) { TEST(type_prop, ebos_fail_mismatch_shape) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3}); auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{3}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try { try {
auto ebos = auto ebos =
@ -232,11 +233,11 @@ TEST(type_prop, ebos_fail_mismatch_shape) {
} }
TEST(type_prop, ebos_fail_default_index_scalar) { TEST(type_prop, ebos_fail_default_index_scalar) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3}); auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{2}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{2});
try { try {
auto ebos = auto ebos =
@ -250,11 +251,11 @@ TEST(type_prop, ebos_fail_default_index_scalar) {
} }
TEST(type_prop, ebos_fail_indices_1d) { TEST(type_prop, ebos_fail_indices_1d) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4, 2}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4, 2});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3}); auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try { try {
auto ebos = auto ebos =
@ -268,11 +269,11 @@ TEST(type_prop, ebos_fail_indices_1d) {
} }
TEST(type_prop, ebos_fail_emb_table_0d) { TEST(type_prop, ebos_fail_emb_table_0d) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3}); auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
OV_EXPECT_THROW( OV_EXPECT_THROW(
auto op = auto op =
@ -282,11 +283,11 @@ TEST(type_prop, ebos_fail_emb_table_0d) {
} }
TEST(type_prop, ebos_fail_offsets_1d) { TEST(type_prop, ebos_fail_offsets_1d) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3, 2}); auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3, 2});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try { try {
auto ebos = auto ebos =
@ -300,11 +301,11 @@ TEST(type_prop, ebos_fail_offsets_1d) {
} }
TEST(type_prop, ebos_fail_per_sample_weights_1d) { TEST(type_prop, ebos_fail_per_sample_weights_1d) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3}); auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4, 2}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4, 2});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try { try {
auto ebos = auto ebos =
@ -318,9 +319,9 @@ TEST(type_prop, ebos_fail_per_sample_weights_1d) {
} }
TEST(type_prop, ebos_3_args_api) { TEST(type_prop, ebos_3_args_api) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3}); auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto ebos = make_shared<op::v3::EmbeddingBagOffsetsSum>(emb_table, indices, offsets); auto ebos = make_shared<op::v3::EmbeddingBagOffsetsSum>(emb_table, indices, offsets);
EXPECT_TRUE(ebos->get_output_partial_shape(0).same_scheme(PartialShape{3, 2})); EXPECT_TRUE(ebos->get_output_partial_shape(0).same_scheme(PartialShape{3, 2}));
@ -330,9 +331,9 @@ TEST(type_prop, ebos_3_args_api) {
} }
TEST(type_prop, ebos_fail_indices_element_type_3_args_api) { TEST(type_prop, ebos_fail_indices_element_type_3_args_api) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::f32, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3}); auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
try { try {
auto ebos = make_shared<op::v3::EmbeddingBagOffsetsSum>(emb_table, indices, offsets); auto ebos = make_shared<op::v3::EmbeddingBagOffsetsSum>(emb_table, indices, offsets);

94
src/core/tests/type_prop/embeddingbag_packedsum.cpp
View File

@ -2,19 +2,21 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include "openvino/op/embeddingbag_packedsum.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/test_assertions.hpp" #include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
using namespace std; using namespace std;
using namespace ngraph; using namespace ov;
using namespace testing; using namespace testing;
TEST(type_prop, ebps_default_ctor) { TEST(type_prop, ebps_default_ctor) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2, 6}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2, 6});
auto indices = make_shared<op::Parameter>(element::i64, Shape{3, 4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3, 4});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{3, 4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 4});
auto op = make_shared<op::v3::EmbeddingBagPackedSum>(); auto op = make_shared<op::v3::EmbeddingBagPackedSum>();
op->set_arguments(OutputVector{emb_table, indices, per_sample_weights}); op->set_arguments(OutputVector{emb_table, indices, per_sample_weights});
@ -30,8 +32,8 @@ TEST(type_prop, ebps_labeled_interval_dims_2in) {
auto ind_shape = PartialShape{{6, 8}, 4}; auto ind_shape = PartialShape{{6, 8}, 4};
set_shape_labels(ind_shape, 20); set_shape_labels(ind_shape, 20);
auto emb_table = make_shared<op::Parameter>(element::f32, emb_shape); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, emb_shape);
auto indices = make_shared<op::Parameter>(element::i64, ind_shape); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, ind_shape);
auto op = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices); auto op = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices);
EXPECT_EQ(op->get_output_element_type(0), element::f32); EXPECT_EQ(op->get_output_element_type(0), element::f32);
@ -47,9 +49,9 @@ TEST(type_prop, ebps_labeled_interval_dims_3in) {
auto sample_shape = PartialShape{{4, 8}, 4}; auto sample_shape = PartialShape{{4, 8}, 4};
set_shape_labels(sample_shape, 30); set_shape_labels(sample_shape, 30);
auto emb_table = make_shared<op::Parameter>(element::f32, emb_shape); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, emb_shape);
auto indices = make_shared<op::Parameter>(element::i64, ind_shape); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, ind_shape);
auto per_sample_weights = make_shared<op::Parameter>(element::f32, sample_shape); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, sample_shape);
auto op = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights); auto op = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights);
EXPECT_EQ(op->get_output_element_type(0), element::f32); EXPECT_EQ(op->get_output_element_type(0), element::f32);
@ -58,9 +60,9 @@ TEST(type_prop, ebps_labeled_interval_dims_3in) {
} }
TEST(type_prop, ebps) { TEST(type_prop, ebps) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{3, 4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3, 4});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{3, 4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 4});
auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights); auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights);
EXPECT_TRUE(ebps->get_output_partial_shape(0).same_scheme(PartialShape{3, 2})); EXPECT_TRUE(ebps->get_output_partial_shape(0).same_scheme(PartialShape{3, 2}));
@ -70,10 +72,10 @@ TEST(type_prop, ebps) {
} }
TEST(type_prop, ebps_dynamic_emb_table) { TEST(type_prop, ebps_dynamic_emb_table) {
auto emb_table = make_shared<op::Parameter>(element::f32, PartialShape{5, Dimension::dynamic()}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{5, Dimension::dynamic()});
auto indices = make_shared<op::Parameter>(element::i64, Shape{3, 4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3, 4});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{3, 4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{}); auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights); auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights);
@ -81,9 +83,9 @@ TEST(type_prop, ebps_dynamic_emb_table) {
} }
TEST(type_prop, ebps_dynamic_indices) { TEST(type_prop, ebps_dynamic_indices) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, PartialShape{Dimension::dynamic(), 4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, PartialShape{Dimension::dynamic(), 4});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 4});
auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights); auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights);
@ -91,9 +93,9 @@ TEST(type_prop, ebps_dynamic_indices) {
} }
TEST(type_prop, ebps_dynamic_emb_table_indices) { TEST(type_prop, ebps_dynamic_emb_table_indices) {
auto emb_table = make_shared<op::Parameter>(element::f32, PartialShape{5, Dimension::dynamic()}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{5, Dimension::dynamic()});
auto indices = make_shared<op::Parameter>(element::i64, PartialShape{Dimension::dynamic(), 4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, PartialShape{Dimension::dynamic(), 4});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 4});
auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights); auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights);
@ -102,9 +104,9 @@ TEST(type_prop, ebps_dynamic_emb_table_indices) {
} }
TEST(type_prop, ebps_fail_indices_element_type) { TEST(type_prop, ebps_fail_indices_element_type) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::f32, Shape{3, 4}); auto indices = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 4});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{3, 4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 4});
try { try {
auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights); auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights);
@ -117,9 +119,9 @@ TEST(type_prop, ebps_fail_indices_element_type) {
} }
TEST(type_prop, ebps_fail_mismatch_element_type) { TEST(type_prop, ebps_fail_mismatch_element_type) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{3, 4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3, 4});
auto per_sample_weights = make_shared<op::Parameter>(element::i64, Shape{3, 4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3, 4});
try { try {
auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights); auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights);
@ -134,9 +136,9 @@ TEST(type_prop, ebps_fail_mismatch_element_type) {
} }
TEST(type_prop, ebps_fail_mismatch_shape) { TEST(type_prop, ebps_fail_mismatch_shape) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{3, 4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3, 4});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4, 3}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4, 3});
try { try {
auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights); auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights);
@ -149,9 +151,9 @@ TEST(type_prop, ebps_fail_mismatch_shape) {
} }
TEST(type_prop, ebps_fail_indices_1d) { TEST(type_prop, ebps_fail_indices_1d) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{3, 4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 4});
try { try {
auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights); auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights);
@ -164,9 +166,9 @@ TEST(type_prop, ebps_fail_indices_1d) {
} }
TEST(type_prop, ebps_fail_emb_table_0d) { TEST(type_prop, ebps_fail_emb_table_0d) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto indices = make_shared<op::Parameter>(element::i64, Shape{3, 4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3, 4});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{3, 4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 4});
OV_EXPECT_THROW(auto op = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights), OV_EXPECT_THROW(auto op = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights),
NodeValidationFailure, NodeValidationFailure,
@ -174,9 +176,9 @@ TEST(type_prop, ebps_fail_emb_table_0d) {
} }
TEST(type_prop, ebps_fail_per_sample_weights_1d) { TEST(type_prop, ebps_fail_per_sample_weights_1d) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{3, 4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3, 4});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4}); auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
try { try {
auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights); auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights);
@ -189,8 +191,8 @@ TEST(type_prop, ebps_fail_per_sample_weights_1d) {
} }
TEST(type_prop, ebps_2_args_api) { TEST(type_prop, ebps_2_args_api) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{3, 4}); auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3, 4});
auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices); auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices);
EXPECT_TRUE(ebps->get_output_partial_shape(0).same_scheme(PartialShape{3, 2})); EXPECT_TRUE(ebps->get_output_partial_shape(0).same_scheme(PartialShape{3, 2}));
@ -199,8 +201,8 @@ TEST(type_prop, ebps_2_args_api) {
} }
TEST(type_prop, ebps_fail_indices_element_type_2_args_api) { TEST(type_prop, ebps_fail_indices_element_type_2_args_api) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2}); auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::f32, Shape{3, 4}); auto indices = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 4});
try { try {
auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices); auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices);

2
src/core/tests/type_prop/erf.cpp
View File

@ -4,6 +4,6 @@
#include "unary_ops.hpp" #include "unary_ops.hpp"
using Type = ::testing::Types<ngraph::op::Erf>; using Type = ::testing::Types<ov::op::v0::Erf>;
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_erf, UnaryOperator, Type); INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_erf, UnaryOperator, Type);

2
src/core/tests/type_prop/exp.cpp
View File

@ -4,6 +4,6 @@
#include "unary_ops.hpp" #include "unary_ops.hpp"
using Type = ::testing::Types<ngraph::op::Exp>; using Type = ::testing::Types<ov::op::v0::Exp>;
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_exp, UnaryOperator, Type); INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_exp, UnaryOperator, Type);

3
src/core/tests/type_prop/experimental_detectron_detection_output.cpp
View File

@ -2,9 +2,10 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include <gmock/gmock.h>
#include "common_test_utils/test_assertions.hpp" #include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gmock/gmock.h"
#include "openvino/opsets/opset11.hpp" #include "openvino/opsets/opset11.hpp"
using namespace ov; using namespace ov;

3
src/core/tests/type_prop/experimental_detectron_generate_proposals.cpp
View File

@ -2,11 +2,12 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include <gmock/gmock.h>
#include <vector> #include <vector>
#include "common_test_utils/test_assertions.hpp" #include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gmock/gmock.h"
#include "openvino/opsets/opset11.hpp" #include "openvino/opsets/opset11.hpp"
using namespace ov; using namespace ov;

3
src/core/tests/type_prop/experimental_detectron_prior_grid_generator.cpp
View File

@ -2,9 +2,10 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include <gmock/gmock.h>
#include "common_test_utils/test_assertions.hpp" #include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gmock/gmock.h"
#include "openvino/opsets/opset11.hpp" #include "openvino/opsets/opset11.hpp"
using namespace ov; using namespace ov;

3
src/core/tests/type_prop/experimental_detectron_roi_feature_extractor.cpp
View File

@ -2,11 +2,12 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include <gmock/gmock.h>
#include <array> #include <array>
#include "common_test_utils/test_assertions.hpp" #include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gmock/gmock.h"
#include "openvino/opsets/opset11.hpp" #include "openvino/opsets/opset11.hpp"
using namespace ov; using namespace ov;

3
src/core/tests/type_prop/experimental_detectron_topkrois.cpp
View File

@ -2,9 +2,10 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include <gtest/gtest.h>
#include "common_test_utils/test_assertions.hpp" #include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "openvino/opsets/opset11.hpp" #include "openvino/opsets/opset11.hpp"
using namespace ov; using namespace ov;

3
src/core/tests/type_prop/eye.cpp
View File

@ -2,10 +2,11 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include <gtest/gtest.h>
#include "common_test_utils/test_assertions.hpp" #include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "eye_shape_inference.hpp" #include "eye_shape_inference.hpp"
#include "gtest/gtest.h"
#include "openvino/core/dimension_tracker.hpp" #include "openvino/core/dimension_tracker.hpp"
#include "openvino/opsets/opset10.hpp" #include "openvino/opsets/opset10.hpp"

44
src/core/tests/type_prop/fake_quantize.cpp
View File

@ -2,52 +2,54 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
// //
#include "openvino/op/fake_quantize.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp" #include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
using namespace std; using namespace std;
using namespace ngraph; using namespace ov;
TEST(type_prop, fake_quantize) { TEST(type_prop, fake_quantize) {
const auto data = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4}); const auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
const auto input_low = make_shared<op::Parameter>(element::f32, Shape{}); const auto input_low = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
const auto input_high = make_shared<op::Parameter>(element::f32, Shape{}); const auto input_high = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
const auto output_low = make_shared<op::Parameter>(element::f32, Shape{}); const auto output_low = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
const auto output_high = make_shared<op::Parameter>(element::f32, Shape{}); const auto output_high = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
const size_t levels = 5; const size_t levels = 5;
const auto fake_quantize = const auto fake_quantize =
make_shared<op::FakeQuantize>(data, input_low, input_high, output_low, output_high, levels); make_shared<op::v0::FakeQuantize>(data, input_low, input_high, output_low, output_high, levels);
EXPECT_EQ(fake_quantize->get_element_type(), element::f32); EXPECT_EQ(fake_quantize->get_element_type(), element::f32);
EXPECT_EQ(fake_quantize->get_shape(), (Shape{1, 2, 3, 4})); EXPECT_EQ(fake_quantize->get_shape(), (Shape{1, 2, 3, 4}));
} }
TEST(type_prop, fake_quantize_autob) { TEST(type_prop, fake_quantize_autob) {
const auto data = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4}); const auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
const auto input_low = make_shared<op::Parameter>(element::f32, Shape{3, 1}); const auto input_low = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 1});
const auto input_high = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4}); const auto input_high = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
const auto output_low = make_shared<op::Parameter>(element::f32, Shape{4}); const auto output_low = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
const auto output_high = make_shared<op::Parameter>(element::f32, Shape{}); const auto output_high = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
const size_t levels = 5; const size_t levels = 5;
const auto fake_quantize = const auto fake_quantize =
make_shared<op::FakeQuantize>(data, input_low, input_high, output_low, output_high, levels); make_shared<op::v0::FakeQuantize>(data, input_low, input_high, output_low, output_high, levels);
EXPECT_EQ(fake_quantize->get_element_type(), element::f32); EXPECT_EQ(fake_quantize->get_element_type(), element::f32);
EXPECT_EQ(fake_quantize->get_shape(), (Shape{1, 2, 3, 4})); EXPECT_EQ(fake_quantize->get_shape(), (Shape{1, 2, 3, 4}));
} }
TEST(type_prop, fake_quantize_invalid_autob) { TEST(type_prop, fake_quantize_invalid_autob) {
const auto data = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4}); const auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto input_low = make_shared<op::Parameter>(element::f32, Shape{3}); auto input_low = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
auto input_high = make_shared<op::Parameter>(element::f32, Shape{}); auto input_high = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto output_low = make_shared<op::Parameter>(element::f32, Shape{}); auto output_low = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto output_high = make_shared<op::Parameter>(element::f32, Shape{}); auto output_high = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
const size_t levels = 5; const size_t levels = 5;
try { try {
const auto fake_quantize = const auto fake_quantize =
make_shared<op::FakeQuantize>(data, input_low, input_high, output_low, output_high, levels); make_shared<op::v0::FakeQuantize>(data, input_low, input_high, output_low, output_high, levels);
EXPECT_FALSE(fake_quantize.get()) EXPECT_FALSE(fake_quantize.get())
<< "FakeQuantize validation did not work. Op node was created with incorrect params."; << "FakeQuantize validation did not work. Op node was created with incorrect params.";
} catch (const NodeValidationFailure& error) { } catch (const NodeValidationFailure& error) {

2
src/core/tests/type_prop/floor.cpp
View File

@ -4,6 +4,6 @@
#include "unary_ops.hpp" #include "unary_ops.hpp"
using Type = ::testing::Types<ngraph::op::Floor>; using Type = ::testing::Types<ov::op::v0::Floor>;
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_floor, UnaryOperator, Type); INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_floor, UnaryOperator, Type);