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"
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);

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

@ -2,74 +2,82 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/clamp.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/gather.hpp"
#include "openvino/op/reshape.hpp"
#include "openvino/op/shape_of.hpp"
using namespace std;
using namespace ngraph;
TEST(type_prop, clamp_basic_f32) {
auto data = make_shared<op::Parameter>(element::f32, Shape{1, 32, 32});
auto clamp = make_shared<op::Clamp>(data, 0.0, 2.1);
auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 32, 32});
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_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) {
auto data = make_shared<op::Parameter>(element::i32, Shape{1, 32, 32});
auto clamp = make_shared<op::Clamp>(data, 0.0, 2.1);
auto data = make_shared<ov::op::v0::Parameter>(ov::element::i32, ov::Shape{1, 32, 32});
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_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) {
auto data = make_shared<op::Parameter>(element::f16, PartialShape{Dimension::dynamic(), Dimension::dynamic(), 32});
auto clamp = make_shared<op::Clamp>(data, -2.1, 2.1);
auto data =
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_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) {
auto data = make_shared<op::Parameter>(element::u16, PartialShape::dynamic());
auto clamp = make_shared<op::Clamp>(data, 1.5, 15.0);
auto data = make_shared<ov::op::v0::Parameter>(ov::element::u16, ov::PartialShape::dynamic());
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_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) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{Dimension(1, 8), 2, 3});
auto shape_of = make_shared<op::v3::ShapeOf>(param);
auto gather = make_shared<op::v1::Gather>(shape_of,
op::Constant::create(element::i64, {3}, {2, 1, 0}),
op::Constant::create(element::i64, {}, {0}));
auto clamp = make_shared<op::Clamp>(gather, 0, 5);
auto r = make_shared<op::v1::Reshape>(param, clamp, false);
auto param = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{ov::Dimension(1, 8), 2, 3});
auto shape_of = make_shared<ov::op::v3::ShapeOf>(param);
auto gather = make_shared<ov::op::v1::Gather>(shape_of,
ov::op::v0::Constant::create(ov::element::i64, {3}, {2, 1, 0}),
ov::op::v0::Constant::create(ov::element::i64, {}, {0}));
auto clamp = make_shared<ov::op::v0::Clamp>(gather, 0, 5);
auto r = make_shared<ov::op::v1::Reshape>(param, clamp, false);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), PartialShape({3, 2, Dimension(1, 5)}));
ASSERT_EQ(r->get_element_type(), ov::element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), ov::PartialShape({3, 2, ov::Dimension(1, 5)}));
}
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 {
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
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");
} catch (...) {
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) {
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);
ASSERT_EQ(clamp->get_element_type(), element::f64);
auto clamp = make_shared<ov::op::v0::Clamp>(data, 1.0, 1.0);
ASSERT_EQ(clamp->get_element_type(), ov::element::f64);
ASSERT_EQ(clamp->get_min(), 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) {
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 {
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'
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'");
} catch (...) {
FAIL() << "'min' and 'max' attributes node validation check failed for unexpected reason";

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

@ -2,39 +2,43 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/concat.hpp"
#include <gmock/gmock.h>
#include "common_test_utils/type_prop.hpp"
#include "gmock/gmock.h"
#include "ngraph/ngraph.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"
using namespace std;
using namespace ngraph;
using namespace testing;
TEST(type_prop, concat_deduce) {
// Deduce type
auto param0 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{2, 7, 4});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 2, 4});
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2}, 1);
EXPECT_EQ(c->get_element_type(), element::f32);
ASSERT_EQ(c->get_shape(), (Shape{2, 12, 4}));
auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4});
auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 7, 4});
auto param2 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2, 4});
auto c = make_shared<ov::op::v0::Concat>(ov::NodeVector{param0, param1, param2}, 1);
EXPECT_EQ(c->get_element_type(), ov::element::f32);
ASSERT_EQ(c->get_shape(), (ov::Shape{2, 12, 4}));
}
TEST(type_prop, concat_deduce_wrong_rank) {
auto param0 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{2, 7, 4});
auto param2 = make_shared<op::Parameter>(element::f32,
Shape{
auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4});
auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 7, 4});
auto param2 = make_shared<ov::op::v0::Parameter>(ov::element::f32,
ov::Shape{
2,
2,
});
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
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 shapes are inconsistent; they must have the same rank, and must "
"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) {
auto param0 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{2, 7, 4});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 2, 5});
auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4});
auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 7, 4});
auto param2 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2, 5});
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
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 shapes are inconsistent; they must have the same rank, and must "
"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) {
auto param0 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{2, 7, 4});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 2, 5});
auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4});
auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 7, 4});
auto param2 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2, 5});
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
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"));
} catch (...) {
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) {
// Deduce type
auto param0 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 8});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 12});
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2}, 2);
EXPECT_EQ(c->get_element_type(), element::f32);
ASSERT_EQ(c->get_shape(), (Shape{2, 3, 24}));
auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4});
auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 8});
auto param2 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 12});
auto c = make_shared<ov::op::v0::Concat>(ov::NodeVector{param0, param1, param2}, 2);
EXPECT_EQ(c->get_element_type(), ov::element::f32);
ASSERT_EQ(c->get_shape(), (ov::Shape{2, 3, 24}));
}
TEST(type_prop, concat_deduce_elem_type_mismatch) {
auto param0 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4});
auto param1 = make_shared<op::Parameter>(element::i32, Shape{2, 7, 4});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 2, 4});
auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4});
auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::i32, ov::Shape{2, 7, 4});
auto param2 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2, 4});
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
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"));
} catch (...) {
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) {
auto param0 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4});
auto param1 = make_shared<op::Parameter>(element::dynamic, Shape{2, 7, 4});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 2, 4});
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2}, 1);
auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4});
auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::dynamic, ov::Shape{2, 7, 4});
auto param2 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2, 4});
auto c = make_shared<ov::op::v0::Concat>(ov::NodeVector{param0, param1, param2}, 1);
EXPECT_EQ(c->get_element_type(), element::f32);
ASSERT_EQ(c->get_shape(), (Shape{2, 12, 4}));
EXPECT_EQ(c->get_element_type(), ov::element::f32);
ASSERT_EQ(c->get_shape(), (ov::Shape{2, 12, 4}));
}
TEST(type_prop, concat_partial_et_inconsistent) {
auto param0 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4});
auto param1 = make_shared<op::Parameter>(element::dynamic, Shape{2, 7, 4});
auto param2 = make_shared<op::Parameter>(element::i32, Shape{2, 2, 4});
auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4});
auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::dynamic, ov::Shape{2, 7, 4});
auto param2 = make_shared<ov::op::v0::Parameter>(ov::element::i32, ov::Shape{2, 2, 4});
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
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"));
} catch (...) {
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) {
auto param0 = make_shared<op::Parameter>(element::f32, PartialShape{2, Dimension::dynamic(), 3});
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto param2 = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, Dimension::dynamic(), 4});
auto param0 =
make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, ov::Dimension::dynamic(), 3});
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 {
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
FAIL() << "Inconsistent ranks not detected (some args rank-dynamic, some args rank-static "
"dynamic)";
} catch (const NodeValidationFailure& error) {
} catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Argument shapes are inconsistent; they must have the same rank, and must "
"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) {
auto param0 = make_shared<op::Parameter>(element::f32, PartialShape{2, Dimension::dynamic(), 3});
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto param2 = make_shared<op::Parameter>(element::f32, PartialShape{3, 3, Dimension::dynamic()});
auto param0 =
make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, ov::Dimension::dynamic(), 3});
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 {
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
FAIL() << "Inconsistent dimensions not detected (some args rank-dynamic, some args "
"rank-static dynamic)";
} catch (const NodeValidationFailure& error) {
} catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Argument shapes are inconsistent; they must have the same rank, and must "
"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) {
auto param0 = make_shared<op::Parameter>(element::f32, PartialShape{2, Dimension::dynamic(), 3});
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto param2 = make_shared<op::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 3, Dimension::dynamic()});
auto param3 = make_shared<op::Parameter>(element::f32, PartialShape{3, 3, Dimension::dynamic()});
auto param0 =
make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, ov::Dimension::dynamic(), 3});
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{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 {
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
FAIL() << "Inconsistent dimensions not detected (some args rank-dynamic, some args "
"rank-static dynamic)";
} catch (const NodeValidationFailure& error) {
} catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Argument shapes are inconsistent; they must have the same rank, and must "
"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) {
auto param0 = make_shared<op::Parameter>(element::f32, PartialShape{2, 2, 3});
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto param2 = make_shared<op::Parameter>(element::f32, PartialShape{3, 3, Dimension::dynamic()});
auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 2, 3});
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 {
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
FAIL() << "Inconsistent dimensions not detected (some args rank-dynamic, some args "
"rank-static dynamic)";
} catch (const NodeValidationFailure& error) {
} catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Argument shapes are inconsistent; they must have the same rank, and must "
"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) {
auto param0 = make_shared<op::Parameter>(element::f32, PartialShape{2, 2, 3});
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 4, 3});
auto param2 = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, Dimension::dynamic()});
auto c = make_shared<op::Concat>(NodeVector{param0, param1, param2}, 1);
auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 2, 3});
auto param1 =
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{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) {
auto param0 = make_shared<op::Parameter>(element::f32, PartialShape{2, 2, 3});
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 4, 3});
auto param2 = make_shared<op::Parameter>(element::f32, PartialShape{3, 3, Dimension::dynamic()});
auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 2, 3});
auto param1 =
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 {
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
FAIL() << "Inconsistent dimensions not detected (some args rank-dynamic, some args "
"rank-static dynamic)";
} catch (const NodeValidationFailure& error) {
} catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Argument shapes are inconsistent; they must have the same rank, and must "
"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) {
auto param0 = make_shared<op::Parameter>(element::f32, Shape{3, 2, 4});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{7, 2, 4});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 2, 4});
auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{3, 2, 4});
auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{7, 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);
ASSERT_EQ(c->get_shape(), (Shape{12, 2, 4}));
EXPECT_EQ(c->get_element_type(), ov::element::f32);
ASSERT_EQ(c->get_shape(), (ov::Shape{12, 2, 4}));
}
TEST(type_prop, concat_partial_negative_axis_incorrect) {
auto param0 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{2, 7, 4});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 2, 4});
auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4});
auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 7, 4});
auto param2 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2, 4});
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
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"));
} catch (...) {
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. */
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);
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);
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_0 = make_shared<op::Parameter>(element::f32, target_0);
auto shape_0 = make_shared<op::ShapeOf>(param_0);
auto param = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1});
auto param_0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, target_0);
auto shape_0 = make_shared<ov::op::v0::ShapeOf>(param_0);
auto param_1 = make_shared<op::Parameter>(element::f32, target_1);
auto shape_1 = make_shared<op::ShapeOf>(param_1);
auto param_1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, target_1);
auto shape_1 = make_shared<ov::op::v0::ShapeOf>(param_1);
auto five = op::Constant::create(element::i64, {1}, {5});
auto target_shape = std::make_shared<op::Concat>(OutputVector{shape_0, five, shape_1}, 0);
auto five = ov::op::v0::Constant::create(ov::element::i64, {1}, {5});
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);
EXPECT_EQ(bc->get_shape(), (Shape{3, 4, 5, 4, 5, 9}));
auto bc = make_shared<ov::op::v1::Broadcast>(param, target_shape);
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 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. */
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);
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);
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_0 = make_shared<op::Parameter>(element::f32, target_0);
auto shape_0 = make_shared<op::ShapeOf>(param_0);
auto convert_0 = make_shared<op::Convert>(shape_0, element::i8);
auto param = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1});
auto param_0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, target_0);
auto shape_0 = make_shared<ov::op::v0::ShapeOf>(param_0);
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 shape_1 = make_shared<op::ShapeOf>(param_1);
auto convert_1 = make_shared<op::Convert>(shape_1, element::i8);
auto param_1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, target_1);
auto shape_1 = make_shared<ov::op::v0::ShapeOf>(param_1);
auto convert_1 = make_shared<ov::op::v0::Convert>(shape_1, ov::element::i8);
auto five = op::Constant::create(element::i8, {1}, {5});
auto target_shape = std::make_shared<op::Concat>(OutputVector{convert_0, five, convert_1}, 0);
auto five = ov::op::v0::Constant::create(ov::element::i8, {1}, {5});
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);
EXPECT_EQ(bc->get_shape(), (Shape{3, 4, 5, 4, 5, 9}));
auto bc = make_shared<ov::op::v1::Broadcast>(param, target_shape);
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 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) {
auto param0 = make_shared<op::Parameter>(element::f32, Shape{3, 2, 4});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{7, 2, 4});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 2, 4});
auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{3, 2, 4});
auto param1 = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{7, 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);
ASSERT_EQ(c->get_shape(), (Shape{12, 2, 4}));
EXPECT_EQ(c->get_element_type(), ov::element::f32);
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
std::tuple<int64_t, // concatenation axis
PartialShape // expected shape
ov::PartialShape // expected shape
>>;
class ConcatTest : public TestWithParam<ConcatTestParams> {
@ -340,73 +357,75 @@ protected:
std::forward_as_tuple(input_shapes, std::tie(axis, exp_shape)) = GetParam();
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;
std::shared_ptr<op::Concat> c;
ov::PartialShape exp_shape;
std::shared_ptr<ov::op::v0::Concat> c;
};
const auto shapes_with_interval_dim = Values(PartialShapeVector{(PartialShape::dynamic()),
{2, Dimension(2, 5), 3, 1},
{2, 4, 3, Dimension(1, 4)},
const auto shapes_with_interval_dim = Values(PartialShapeVector{(ov::PartialShape::dynamic()),
{2, ov::Dimension(2, 5), 3, 1},
{2, 4, 3, ov::Dimension(1, 4)},
{2, 4, 3, 1}});
INSTANTIATE_TEST_SUITE_P(type_prop_interval_dim_mixed_ranks,
INSTANTIATE_TEST_SUITE_P(
type_prop_interval_dim_mixed_ranks,
ConcatTest,
Combine(shapes_with_interval_dim,
Values(std::make_tuple(1, PartialShape({2, Dimension(10, -1), 3, 1})), // axis 1
std::make_tuple(-1, PartialShape({2, 4, 3, Dimension(3, -1)})), // axis 2
std::make_tuple(2, PartialShape({2, 4, Dimension(9, -1), 1})) // axis 3
Values(std::make_tuple(1, ov::PartialShape({2, ov::Dimension(10, -1), 3, 1})), // axis 1
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());
const auto shapes_all_dynamic_ranks = Values(PartialShapeVector{(PartialShape::dynamic()),
(PartialShape::dynamic()),
(PartialShape::dynamic()),
(PartialShape::dynamic())});
const auto shapes_all_dynamic_ranks = Values(PartialShapeVector{(ov::PartialShape::dynamic()),
(ov::PartialShape::dynamic()),
(ov::PartialShape::dynamic()),
(ov::PartialShape::dynamic())});
INSTANTIATE_TEST_SUITE_P(type_prop_dynamic_ranks_against_axis_range,
ConcatTest,
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());
const auto shapes_static_dynamic_ranks =
Values(PartialShapeVector{PartialShape({4, 2, Dimension::dynamic(), 3}),
PartialShape::dynamic(),
PartialShape({4, 2, Dimension::dynamic(), Dimension::dynamic()})});
Values(PartialShapeVector{ov::PartialShape({4, 2, ov::Dimension::dynamic(), 3}),
ov::PartialShape::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(
type_prop_mixed_ranks_and_dims,
ConcatTest,
Combine(shapes_static_dynamic_ranks,
Values(
// concat all dynamic dims
std::make_tuple(2, PartialShape({4, 2, Dimension::dynamic(), 3})),
std::make_tuple(2, ov::PartialShape({4, 2, ov::Dimension::dynamic(), 3})),
// concat dynamic and interval dim
std::make_tuple(1, PartialShape({4, Dimension(4, -1), Dimension::dynamic(), 3})))),
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(
type_prop_1d_shapes,
ConcatTest,
Values(
// concat all dynamic dims
std::make_tuple(PartialShapeVector{{-1}, {-1}, {-1}},
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
std::make_tuple(PartialShapeVector{{3}, PartialShape::dynamic(), {2}},
std::make_tuple(0, PartialShape({Dimension(5, -1)}))),
std::make_tuple(PartialShapeVector{{3}, ov::PartialShape::dynamic(), {2}},
std::make_tuple(0, ov::PartialShape({ov::Dimension(5, -1)}))),
// 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
std::make_tuple(PartialShapeVector{{3}, {Dimension::dynamic()}, {Dimension(3, 4)}},
std::make_tuple(0, PartialShape({Dimension(6, -1)})))),
std::make_tuple(PartialShapeVector{{3}, {ov::Dimension::dynamic()}, {ov::Dimension(3, 4)}},
std::make_tuple(0, ov::PartialShape({ov::Dimension(6, -1)})))),
PrintToStringParamName());
/** \brief Shape propagation no exception. */
/** \brief ov::Shape propagation no exception. */
TEST_P(ConcatTest, partial_shape_propagation) {
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
//
#include "openvino/op/constant.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
using namespace std;
using namespace ngraph;
TEST(type_prop, scalar_constant_deduce_float32) {
auto c = op::Constant::create(element::f32, Shape{}, {208});
ASSERT_EQ(c->get_element_type(), element::f32);
ASSERT_EQ(c->get_shape(), (Shape{}));
auto c = ov::op::v0::Constant::create(ov::element::f32, ov::Shape{}, {208});
ASSERT_EQ(c->get_element_type(), ov::element::f32);
ASSERT_EQ(c->get_shape(), (ov::Shape{}));
}
TEST(type_prop, scalar_constant_deduce_bool) {
auto c = op::Constant::create(element::boolean, Shape{}, {1});
ASSERT_EQ(c->get_element_type(), element::boolean);
ASSERT_EQ(c->get_shape(), (Shape{}));
auto c = ov::op::v0::Constant::create(ov::element::boolean, ov::Shape{}, {1});
ASSERT_EQ(c->get_element_type(), ov::element::boolean);
ASSERT_EQ(c->get_shape(), (ov::Shape{}));
}
TEST(type_prop, tensor_constant_deduce_float32) {
auto c = op::Constant::create(element::f32, Shape{2, 2}, {208, 208, 208, 208});
ASSERT_EQ(c->get_element_type(), element::f32);
ASSERT_EQ(c->get_shape(), (Shape{2, 2}));
auto c = ov::op::v0::Constant::create(ov::element::f32, ov::Shape{2, 2}, {208, 208, 208, 208});
ASSERT_EQ(c->get_element_type(), ov::element::f32);
ASSERT_EQ(c->get_shape(), (ov::Shape{2, 2}));
}
TEST(type_prop, tensor_constant_deduce_bool) {
auto c = op::Constant::create(element::boolean, Shape{2, 2}, {1, 1, 1, 1});
ASSERT_EQ(c->get_element_type(), element::boolean);
ASSERT_EQ(c->get_shape(), (Shape{2, 2}));
auto c = ov::op::v0::Constant::create(ov::element::boolean, ov::Shape{2, 2}, {1, 1, 1, 1});
ASSERT_EQ(c->get_element_type(), ov::element::boolean);
ASSERT_EQ(c->get_shape(), (ov::Shape{2, 2}));
}
TEST(type_prop, tensor_constant_bad_count) {
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
FAIL() << "Incorrect number of literals not detected";
} catch (const NodeValidationFailure& error) {
} catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Did not get the expected number of literals for a "
"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) {
auto c = make_shared<op::Constant>(element::i64, Shape{2, 0, 2, 2}, std::vector<std::string>{"42"});
ASSERT_EQ(c->get_element_type(), element::i64);
ASSERT_EQ(c->get_shape(), (Shape{2, 0, 2, 2}));
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(), ov::element::i64);
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
//
#include "openvino/op/convert.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/core/dimension_tracker.hpp"
#include "openvino/op/broadcast.hpp"
#include "openvino/op/shape_of.hpp"
using namespace std;
using namespace ngraph;
TEST(type_prop, convert_deduce) {
// Deduce type
auto param = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4});
auto c = make_shared<op::Convert>(param, element::i32);
ASSERT_EQ(c->get_element_type(), element::i32);
ASSERT_EQ(c->get_shape(), (Shape{2, 3, 4}));
auto param = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4});
auto c = make_shared<ov::op::v0::Convert>(param, ov::element::i32);
ASSERT_EQ(c->get_element_type(), ov::element::i32);
ASSERT_EQ(c->get_shape(), (ov::Shape{2, 3, 4}));
}
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);
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_0 = make_shared<op::Parameter>(element::f32, target_0);
auto shape_0 = make_shared<op::ShapeOf>(param_0);
auto param = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1});
auto param_0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, target_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_1 = make_shared<op::Convert>(convert_0, element::i64);
auto convert_0 = make_shared<ov::op::v0::Convert>(shape_0, ov::element::i8);
auto convert_1 = make_shared<ov::op::v0::Convert>(convert_0, ov::element::i64);
auto bc = make_shared<op::v1::Broadcast>(param, convert_1);
ASSERT_EQ(bc->get_shape(), (Shape{3, 4}));
auto bc = make_shared<ov::op::v1::Broadcast>(param, convert_1);
ASSERT_EQ(bc->get_shape(), (ov::Shape{3, 4}));
const auto& output_shape = bc->get_output_partial_shape(0);
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
//
#include <gtest/gtest.h>
#include <vector>
#include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "openvino/op/op.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
//
#include <gtest/gtest.h>
#include <vector>
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "openvino/op/op.hpp"
#include "openvino/opsets/opset8.hpp"

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

@ -2,284 +2,291 @@
// SPDX-License-Identifier: Apache-2.0
//
#include <gtest/gtest.h>
#include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp"
#include "convolution_shape_inference.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
using namespace std;
using namespace ngraph;
using namespace testing;
TEST(type_prop, convolution_v1_partial_rank) {
PartialShape data_batch_shape{PartialShape::dynamic()};
PartialShape filters_shape{PartialShape::dynamic()};
Strides window_movement_strides{1, 1};
Strides window_dilation_strides{1, 1};
CoordinateDiff padding_below{0, 0};
CoordinateDiff padding_above{0, 0};
ov::PartialShape data_batch_shape{ov::PartialShape::dynamic()};
ov::PartialShape filters_shape{ov::PartialShape::dynamic()};
ov::Strides window_movement_strides{1, 1};
ov::Strides window_dilation_strides{1, 1};
ov::CoordinateDiff padding_below{0, 0};
ov::CoordinateDiff padding_above{0, 0};
auto param0 = make_shared<op::Parameter>(element::f32, data_batch_shape);
auto param1 = make_shared<op::Parameter>(element::f32, filters_shape);
auto param0 = make_shared<ov::op::v0::Parameter>(ov::element::f32, data_batch_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,
window_movement_strides,
padding_below,
padding_above,
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) {
PartialShape data_batch_shape{1, 1, 5, 5};
PartialShape filters_shape{1, 1, 3, 3};
ov::PartialShape data_batch_shape{1, 1, 5, 5};
ov::PartialShape filters_shape{1, 1, 3, 3};
set_shape_labels(data_batch_shape, 10);
set_shape_labels(filters_shape, 20);
Strides strides{1, 1};
CoordinateDiff pads_begin{0, 0};
CoordinateDiff pads_end{0, 0};
Strides dilations{1, 1};
const auto auto_pad = op::PadType::SAME_LOWER;
ov::Strides strides{1, 1};
ov::CoordinateDiff pads_begin{0, 0};
ov::CoordinateDiff pads_end{0, 0};
ov::Strides dilations{1, 1};
const auto auto_pad = ov::op::PadType::SAME_LOWER;
auto data_batch = make_shared<op::Parameter>(element::f32, data_batch_shape);
auto filters = make_shared<op::Parameter>(element::f32, filters_shape);
auto data_batch = make_shared<ov::op::v0::Parameter>(ov::element::f32, data_batch_shape);
auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, filters_shape);
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_EQ(conv->get_pads_begin(), (CoordinateDiff{1, 1}));
EXPECT_EQ(conv->get_pads_end(), (CoordinateDiff{1, 1}));
EXPECT_EQ(conv->get_pads_begin(), (ov::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) {
PartialShape data_batch_shape{Dimension::dynamic(), Dimension::dynamic(), 5, 5};
PartialShape filters_shape{1, 1, 3, 3};
ov::PartialShape data_batch_shape{ov::Dimension::dynamic(), ov::Dimension::dynamic(), 5, 5};
ov::PartialShape filters_shape{1, 1, 3, 3};
set_shape_labels(data_batch_shape, 10);
set_shape_labels(filters_shape, 20);
Strides strides{1, 1};
CoordinateDiff pads_begin{0, 0};
CoordinateDiff pads_end{0, 0};
Strides dilations{1, 1};
const auto auto_pad = op::PadType::SAME_LOWER;
ov::Strides strides{1, 1};
ov::CoordinateDiff pads_begin{0, 0};
ov::CoordinateDiff pads_end{0, 0};
ov::Strides dilations{1, 1};
const auto auto_pad = ov::op::PadType::SAME_LOWER;
auto data_batch = make_shared<op::Parameter>(element::f32, data_batch_shape);
auto filters = make_shared<op::Parameter>(element::f32, filters_shape);
auto data_batch = make_shared<ov::op::v0::Parameter>(ov::element::f32, data_batch_shape);
auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, filters_shape);
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_EQ(conv->get_pads_begin(), (CoordinateDiff{1, 1}));
EXPECT_EQ(conv->get_pads_end(), (CoordinateDiff{1, 1}));
EXPECT_EQ(conv->get_pads_begin(), (ov::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) {
const PartialShape data_batch_shape{Dimension::dynamic(), Dimension::dynamic(), 5, 5};
const PartialShape filters_shape{1, 1, 2, 2};
Strides strides{1, 1};
CoordinateDiff pads_begin{0, 0};
CoordinateDiff pads_end{0, 0};
Strides dilations{1, 1};
const auto auto_pad = op::PadType::SAME_UPPER;
const ov::PartialShape data_batch_shape{ov::Dimension::dynamic(), ov::Dimension::dynamic(), 5, 5};
const ov::PartialShape filters_shape{1, 1, 2, 2};
ov::Strides strides{1, 1};
ov::CoordinateDiff pads_begin{0, 0};
ov::CoordinateDiff pads_end{0, 0};
ov::Strides dilations{1, 1};
const auto auto_pad = ov::op::PadType::SAME_UPPER;
auto data_batch = make_shared<op::Parameter>(element::f32, data_batch_shape);
auto filters = make_shared<op::Parameter>(element::f32, filters_shape);
auto data_batch = make_shared<ov::op::v0::Parameter>(ov::element::f32, data_batch_shape);
auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, filters_shape);
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_pads_begin(), (CoordinateDiff{0, 0}));
ASSERT_EQ(conv->get_pads_end(), (CoordinateDiff{1, 1}));
ASSERT_EQ(conv->get_output_partial_shape(0), ov::PartialShape({ov::Dimension::dynamic(), 1, 5, 5}));
ASSERT_EQ(conv->get_pads_begin(), (ov::CoordinateDiff{0, 0}));
ASSERT_EQ(conv->get_pads_end(), (ov::CoordinateDiff{1, 1}));
}
TEST(type_prop, convolution_v1_partial_auto_padding_same_spatial_dims_dynamic) {
PartialShape data_batch_shape{1, 1, Dimension::dynamic(), {3, 5}};
PartialShape filters_shape{1, 1, 3, 3};
ov::PartialShape data_batch_shape{1, 1, ov::Dimension::dynamic(), {3, 5}};
ov::PartialShape filters_shape{1, 1, 3, 3};
set_shape_labels(data_batch_shape, 10);
set_shape_labels(filters_shape, 20);
Strides strides{2, 2};
CoordinateDiff pads_begin{0, 0};
CoordinateDiff pads_end{0, 0};
Strides dilations{1, 1};
const auto auto_pad = op::PadType::SAME_LOWER;
ov::Strides strides{2, 2};
ov::CoordinateDiff pads_begin{0, 0};
ov::CoordinateDiff pads_end{0, 0};
ov::Strides dilations{1, 1};
const auto auto_pad = ov::op::PadType::SAME_LOWER;
auto data_batch = make_shared<op::Parameter>(element::f32, data_batch_shape);
auto filters = make_shared<op::Parameter>(element::f32, filters_shape);
auto data_batch = make_shared<ov::op::v0::Parameter>(ov::element::f32, data_batch_shape);
auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, filters_shape);
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_EQ(conv->get_pads_begin(), (CoordinateDiff{0, 0}));
EXPECT_EQ(conv->get_pads_end(), (CoordinateDiff{0, 0}));
EXPECT_EQ(conv->get_pads_begin(), (ov::CoordinateDiff{0, 0}));
EXPECT_EQ(conv->get_pads_end(), (ov::CoordinateDiff{0, 0}));
}
TEST(type_prop, convolution_v1_partial_data_shape_dynamic) {
const PartialShape data_batch_shape{PartialShape::dynamic()};
const PartialShape filters_shape{1, 1, 3, 3};
Strides strides{1, 1};
CoordinateDiff pads_begin{0, 0};
CoordinateDiff pads_end{0, 0};
Strides dilations{1, 1};
const auto auto_pad = op::PadType::SAME_LOWER;
const ov::PartialShape data_batch_shape{ov::PartialShape::dynamic()};
const ov::PartialShape filters_shape{1, 1, 3, 3};
ov::Strides strides{1, 1};
ov::CoordinateDiff pads_begin{0, 0};
ov::CoordinateDiff pads_end{0, 0};
ov::Strides dilations{1, 1};
const auto auto_pad = ov::op::PadType::SAME_LOWER;
auto data_batch = make_shared<op::Parameter>(element::f32, data_batch_shape);
auto filters = make_shared<op::Parameter>(element::f32, filters_shape);
auto data_batch = make_shared<ov::op::v0::Parameter>(ov::element::f32, data_batch_shape);
auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, filters_shape);
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, Dimension::dynamic(), Dimension::dynamic()}));
EXPECT_EQ(conv->get_pads_begin(), (CoordinateDiff{0, 0}));
EXPECT_EQ(conv->get_pads_end(), (CoordinateDiff{0, 0}));
ov::PartialShape({ov::Dimension::dynamic(), 1, ov::Dimension::dynamic(), ov::Dimension::dynamic()}));
EXPECT_EQ(conv->get_pads_begin(), (ov::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:
CoordinateDiff empty_pad{};
ov::CoordinateDiff empty_pad{};
};
TEST_F(TypePropConvolutionV1Test, default_ctor) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, 3, 5, 5});
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 4, 4});
const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{1, 3, 5, 5});
const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 4, 4});
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_dilations({1, 2});
op->set_pads_begin({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();
EXPECT_EQ(op->get_input_size(), 2);
EXPECT_EQ(op->get_output_size(), 1);
EXPECT_EQ(op->get_strides(), Strides({1, 3}));
EXPECT_EQ(op->get_dilations(), Strides({1, 2}));
EXPECT_EQ(op->get_pads_begin(), CoordinateDiff({2, 2}));
EXPECT_EQ(op->get_pads_end(), CoordinateDiff({2, 2}));
EXPECT_EQ(op->get_output_partial_shape(0), PartialShape({1, 2, 6, 1}));
EXPECT_EQ(op->get_strides(), ov::Strides({1, 3}));
EXPECT_EQ(op->get_dilations(), ov::Strides({1, 2}));
EXPECT_EQ(op->get_pads_begin(), ov::CoordinateDiff({2, 2}));
EXPECT_EQ(op->get_pads_end(), ov::CoordinateDiff({2, 2}));
EXPECT_EQ(op->get_output_partial_shape(0), ov::PartialShape({1, 2, 6, 1}));
}
TEST_F(TypePropConvolutionV1Test, data_dynamic_rank_filters_2d) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 4, 4});
const auto strides = Strides{1, 1};
const auto dilations = Strides{1, 1};
const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape::dynamic());
const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 4, 4});
const auto strides = ov::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_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) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape{2, 3});
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3});
const auto strides = Strides{1, 1};
const auto dilations = Strides{1, 1};
const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3});
const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3});
const auto strides = ov::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),
NodeValidationFailure,
OV_EXPECT_THROW(
auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER),
ov::NodeValidationFailure,
HasSubstr("Expected a 3D, 4D or 5D tensor for the input"));
}
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 filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 4, 4, 4, 4});
const auto strides = Strides{1, 1};
const auto dilations = Strides{1, 1};
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<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 4, 4, 4, 4});
const auto strides = ov::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),
NodeValidationFailure,
OV_EXPECT_THROW(
auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER),
ov::NodeValidationFailure,
HasSubstr("Expected a 3D, 4D or 5D tensor for the input"));
}
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 filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 4});
const auto strides = Strides{1, 1};
const auto dilations = Strides{1, 1};
const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 5, 5});
const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 4});
const auto strides = ov::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),
NodeValidationFailure,
OV_EXPECT_THROW(
auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER),
ov::NodeValidationFailure,
HasSubstr("Data batch and filters rank do not match"));
}
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 filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 4, 4});
const auto strides = Strides{1, 1};
const auto dilations = Strides{1, 1};
const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 2, 5, 5});
const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 4, 4});
const auto strides = ov::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),
NodeValidationFailure,
OV_EXPECT_THROW(
auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER),
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) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 5, 5});
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 4, 4});
const auto strides = Strides{1, 1, 1};
const auto dilations = Strides{1, 1};
const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 5, 5});
const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 4, 4});
const auto strides = ov::Strides{1, 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),
NodeValidationFailure,
OV_EXPECT_THROW(
auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER),
ov::NodeValidationFailure,
HasSubstr("Strides should be defined for all and only spatial dimensions."));
}
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 filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 4, 4});
const auto strides = Strides{1, 1};
const auto dilations = Strides{1};
const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 5, 5});
const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 4, 4});
const auto strides = ov::Strides{1, 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),
NodeValidationFailure,
OV_EXPECT_THROW(
auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER),
ov::NodeValidationFailure,
HasSubstr("Dilations should be defined for all and only spatial dimensions."));
}
TEST_F(TypePropConvolutionV1Test, strides_has_zeros) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 5, 5});
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 4, 4});
const auto strides = Strides{1, 0};
const auto dilations = Strides{1, 1};
const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 5, 5});
const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 4, 4});
const auto strides = ov::Strides{1, 0};
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),
NodeValidationFailure,
OV_EXPECT_THROW(
auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER),
ov::NodeValidationFailure,
HasSubstr("Strides has zero dimension"));
}
TEST_F(TypePropConvolutionV1Test, dilations_has_zeros) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 5, 5});
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 4, 4});
const auto strides = Strides{1, 1};
const auto dilations = Strides{0, 1};
const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 5, 5});
const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 4, 4});
const auto strides = ov::Strides{1, 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),
NodeValidationFailure,
OV_EXPECT_THROW(
auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER),
ov::NodeValidationFailure,
HasSubstr("Filter dilations has zero dimension"));
}
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 filters = make_shared<op::Parameter>(element::f32, PartialShape{2, 3, 4, 4});
const auto strides = Strides{1, 1};
const auto dilations = Strides{1, 1};
const auto pads_begin = CoordinateDiff{2, 2};
const auto pads_end = CoordinateDiff{2, 2, 2};
const auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 5, 5});
const auto filters = make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{2, 3, 4, 4});
const auto strides = ov::Strides{1, 1};
const auto dilations = ov::Strides{1, 1};
const auto pads_begin = ov::CoordinateDiff{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),
NodeValidationFailure,
ov::NodeValidationFailure,
HasSubstr("Pads begin and end should be defined for all and only spatial dimensions."));
}

983
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"
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);

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

@ -4,6 +4,6 @@
#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);

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

@ -2,13 +2,15 @@
// 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 "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/core/dimension_tracker.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace testing;
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 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 seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape);
auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
op->set_arguments(OutputVector{data, seq_mask});
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 seq_mask_shape{100, 3};
Shape out_shape{3, 100, 1, 1};
auto data = make_shared<op::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false);
auto data = make_shared<ov::op::v0::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
EXPECT_EQ(op->get_element_type(), element::f32);
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(seq_mask_shape, 20);
auto data = make_shared<op::Parameter>(element::f32, data_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false);
auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
const auto& out_shape = op->get_output_partial_shape(0);
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);
auto data = make_shared<op::Parameter>(element::f32, data_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false);
auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
const auto& out_shape = op->get_output_partial_shape(0);
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);
auto data = make_shared<op::Parameter>(element::f32, data_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false);
auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
const auto& out_shape = op->get_output_partial_shape(0);
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 seq_mask_shape{100, 3};
Shape out_shape{3, 100, 1, 1};
auto data = make_shared<op::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false);
auto data = make_shared<ov::op::v0::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
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_shape(), out_shape);
@ -113,9 +115,9 @@ TEST(type_prop, ctc_greedy_decoder_output_static_shape2) {
PartialShape logits_shape{Dimension::dynamic(), 3, 1200};
PartialShape seq_mask_shape{100, Dimension::dynamic()};
Shape out_shape{3, 100, 1, 1};
auto data = make_shared<op::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false);
auto data = make_shared<ov::op::v0::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
EXPECT_EQ(op->get_element_type(), element::f32);
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 seq_mask_shape{Dimension::dynamic(), Dimension::dynamic()};
PartialShape out_shape{Dimension::dynamic(), Dimension::dynamic(), 1, 1};
auto data = make_shared<op::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false);
auto data = make_shared<ov::op::v0::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
EXPECT_EQ(op->get_element_type(), element::f32);
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 seq_mask_shape{100, Dimension::dynamic()};
PartialShape out_shape{Dimension::dynamic(), 100, 1, 1};
auto data = make_shared<op::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false);
auto data = make_shared<ov::op::v0::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
EXPECT_EQ(op->get_element_type(), element::f32);
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 seq_mask_shape = PartialShape::dynamic();
PartialShape out_shape{Dimension::dynamic(), Dimension::dynamic(), 1, 1};
auto data = make_shared<op::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::CTCGreedyDecoder>(data, seq_mask, false);
auto data = make_shared<ov::op::v0::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
auto op = make_shared<op::v0::CTCGreedyDecoder>(data, seq_mask, false);
EXPECT_EQ(op->get_element_type(), element::f32);
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) {
PartialShape logits_shape{Dimension::dynamic(), 3, 1200, 5};
PartialShape seq_mask_shape{100, 3};
auto data = make_shared<op::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape);
auto data = make_shared<ov::op::v0::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
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
FAIL() << "Incorrect indices rank";
} catch (const NodeValidationFailure& error) {
@ -173,11 +175,11 @@ TEST(type_prop, ctc_greedy_decoder_incorrect_rank) {
TEST(type_prop, ctc_greedy_decoder_incorrect_rank2) {
PartialShape logits_shape{Dimension::dynamic(), 3, 1200};
PartialShape seq_mask_shape{100, 3, 2};
auto data = make_shared<op::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape);
auto data = make_shared<ov::op::v0::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
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
FAIL() << "Incorrect indices rank";
} catch (const NodeValidationFailure& error) {
@ -190,11 +192,11 @@ TEST(type_prop, ctc_greedy_decoder_incorrect_rank2) {
TEST(type_prop, ctc_greedy_decoder_mismatched_dim1) {
PartialShape logits_shape{100, 4, 1200};
PartialShape seq_mask_shape{100, 3};
auto data = make_shared<op::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape);
auto data = make_shared<ov::op::v0::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
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
FAIL() << "Incorrect indices rank";
} catch (const NodeValidationFailure& error) {
@ -207,11 +209,11 @@ TEST(type_prop, ctc_greedy_decoder_mismatched_dim1) {
TEST(type_prop, ctc_greedy_decoder_mismatched_dim2) {
PartialShape logits_shape{101, 3, 1200};
PartialShape seq_mask_shape{100, 3};
auto data = make_shared<op::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<op::Parameter>(element::f32, seq_mask_shape);
auto data = make_shared<ov::op::v0::Parameter>(element::f32, logits_shape);
auto seq_mask = make_shared<ov::op::v0::Parameter>(element::f32, seq_mask_shape);
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
FAIL() << "Incorrect indices rank";
} 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
//
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "openvino/core/dimension_tracker.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
//
#include <gtest/gtest.h>
#include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "openvino/opsets/opset10.hpp"
using namespace std;

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

@ -2,15 +2,18 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/op/cum_sum.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) {
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);
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) {
PartialShape data_shape{2, 4};
auto A = std::make_shared<op::Parameter>(element::f32, data_shape);
auto axis = std::make_shared<op::Parameter>(element::i32, PartialShape{});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto axis = std::make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{});
auto cum_sum = std::make_shared<op::v0::CumSum>(A, axis);
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) {
PartialShape data_shape{2, 4};
auto A = std::make_shared<op::Parameter>(element::f32, data_shape);
auto axis = op::Constant::create(element::i32, Shape{}, {1});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto axis = ov::op::v0::Constant::create(element::i32, Shape{}, {1});
auto cum_sum = std::make_shared<op::v0::CumSum>(A, axis);
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) {
PartialShape data_shape{2, 4};
auto A = std::make_shared<op::Parameter>(element::f32, data_shape);
auto axis = std::make_shared<op::Parameter>(element::i32, PartialShape{});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto axis = std::make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{});
bool exclusive = true;
bool reverse = true;
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) {
try {
auto axis = std::make_shared<op::Parameter>(element::i32, PartialShape{});
auto A = std::make_shared<op::Parameter>(element::f32, shape);
auto axis = std::make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, shape);
auto cum_sum = std::make_shared<op::v0::CumSum>(A, axis);
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}};
for (auto& shape : incorrect_axis_shpes) {
try {
auto axis = std::make_shared<op::Parameter>(element::i32, shape);
auto A = std::make_shared<op::Parameter>(element::f32, data_shape);
auto axis = std::make_shared<ov::op::v0::Parameter>(element::i32, 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);
} catch (...) {
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) {
try {
auto axis = std::make_shared<op::Parameter>(element::i32, PartialShape{});
auto A = std::make_shared<op::Parameter>(et, data_shape);
auto axis = std::make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{});
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));
} catch (...) {
@ -132,8 +135,8 @@ TEST(type_prop, cum_sum_op_incorrect_axis_element_type) {
for (auto& et : element_types) {
try {
auto axis = std::make_shared<op::Parameter>(et, PartialShape{});
auto A = std::make_shared<op::Parameter>(element::f32, data_shape);
auto axis = std::make_shared<ov::op::v0::Parameter>(et, PartialShape{});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto cum_sum = std::make_shared<op::v0::CumSum>(A, axis);
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
//
#include "openvino/op/deformable_convolution.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/core/coordinate_diff.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace testing;
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 deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
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 deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
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 deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
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 deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -159,9 +162,9 @@ TEST(type_prop, deformable_convolution_data_batch_dynamic) {
const int64_t group = 2;
const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -193,9 +196,9 @@ TEST(type_prop, deformable_convolution_offsets_dynamic) {
const int64_t group = 2;
const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -225,9 +228,9 @@ TEST(type_prop, deformable_convolution_auto_pad_same_filters_dynamic) {
const int64_t group = 2;
const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -257,9 +260,9 @@ TEST(type_prop, deformable_convolution_deformable_data_batch_and_filters_dynamic
const int64_t group = 2;
const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -287,9 +290,9 @@ TEST(type_prop, deformable_convolution_deformable_all_inputs_dynamic) {
const int64_t group = 2;
const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, dyn_pshape);
auto offsets = make_shared<op::Parameter>(et, dyn_pshape);
auto filters = make_shared<op::Parameter>(et, dyn_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, dyn_pshape);
auto offsets = make_shared<ov::op::v0::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,
offsets,
filters,
@ -318,9 +321,9 @@ TEST(type_prop, deformable_convolution_invalid_et_inputs) {
element::Type_t boolean_et = element::boolean;
try {
auto data_batch = make_shared<op::Parameter>(element::f16, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(float_et, offsets_pshape);
auto filters = make_shared<op::Parameter>(float_et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(element::f16, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(float_et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(float_et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -339,9 +342,9 @@ TEST(type_prop, deformable_convolution_invalid_et_inputs) {
}
try {
auto data_batch = make_shared<op::Parameter>(float_et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(float_et, offsets_pshape);
auto filters = make_shared<op::Parameter>(element::f16, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(float_et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(float_et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(element::f16, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -360,9 +363,9 @@ TEST(type_prop, deformable_convolution_invalid_et_inputs) {
}
try {
auto data_batch = make_shared<op::Parameter>(float_et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(element::f16, offsets_pshape);
auto filters = make_shared<op::Parameter>(float_et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(float_et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(element::f16, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(float_et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -381,9 +384,9 @@ TEST(type_prop, deformable_convolution_invalid_et_inputs) {
}
try {
auto data_batch = make_shared<op::Parameter>(boolean_et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(boolean_et, offsets_pshape);
auto filters = make_shared<op::Parameter>(boolean_et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(boolean_et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(boolean_et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(boolean_et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -410,9 +413,9 @@ TEST(type_prop, deformable_convolution_invalid_input_ranks) {
const PartialShape offsets_pshape{1, 4, 4, 4};
const PartialShape filters_pshape{4, 4, 3, 3};
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -434,9 +437,9 @@ TEST(type_prop, deformable_convolution_invalid_input_ranks) {
const PartialShape offsets_pshape{1, 4, 4, 4, 4};
const PartialShape filters_pshape{4, 4, 3, 3};
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -458,9 +461,9 @@ TEST(type_prop, deformable_convolution_invalid_input_ranks) {
const PartialShape offsets_pshape{1, 4, 4, 4};
const PartialShape filters_pshape{4, 4, 3, 3, 3};
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -482,9 +485,9 @@ TEST(type_prop, deformable_convolution_invalid_input_ranks) {
const PartialShape offsets_pshape{1, 4, 4, 4, 4};
const PartialShape filters_pshape{4, 4, 3, 3, 3};
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -506,9 +509,9 @@ TEST(type_prop, deformable_convolution_invalid_input_ranks) {
const PartialShape offsets_pshape{1, 4, 4};
const PartialShape filters_pshape{4, 4, 3};
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -539,9 +542,9 @@ TEST(type_prop, deformable_convolution_invalid_groups) {
const int64_t group = 0;
const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
try {
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 deformable_group = 0;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
try {
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 deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -660,9 +663,9 @@ TEST(type_prop, deformable_convolution_invalid_offsets_channels_dim) {
const int64_t group = 4;
const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -698,9 +701,9 @@ TEST(type_prop, deformable_convolution_invalid_offsets_batch_dim) {
const int64_t group = 4;
const int64_t deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
try {
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 deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
try {
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 deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
try {
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 deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
try {
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 deformable_group = 2;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
try {
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_end{0, 0};
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, PartialShape::dynamic());
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -915,9 +918,9 @@ TEST(type_prop, deformable_convolution_invalid_conv_param_spatial_dims) {
CoordinateDiff pads_begin{0, 0};
CoordinateDiff pads_end{0, 0};
auto data_batch = make_shared<op::Parameter>(et, PartialShape::dynamic());
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -939,9 +942,9 @@ TEST(type_prop, deformable_convolution_invalid_conv_param_spatial_dims) {
CoordinateDiff pads_begin{0, 0};
CoordinateDiff pads_end{0, 0};
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, PartialShape::dynamic());
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -961,9 +964,9 @@ TEST(type_prop, deformable_convolution_invalid_conv_param_spatial_dims) {
CoordinateDiff pads_begin{0, 0};
CoordinateDiff pads_end{0, 0};
auto data_batch = make_shared<op::Parameter>(et, PartialShape::dynamic());
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -985,9 +988,9 @@ TEST(type_prop, deformable_convolution_invalid_conv_param_spatial_dims) {
CoordinateDiff pads_begin{0, 0, 0};
CoordinateDiff pads_end{0, 0};
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, PartialShape::dynamic());
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -1007,9 +1010,9 @@ TEST(type_prop, deformable_convolution_invalid_conv_param_spatial_dims) {
CoordinateDiff pads_begin{0, 0};
CoordinateDiff pads_end{0};
auto data_batch = make_shared<op::Parameter>(et, PartialShape::dynamic());
auto offsets = make_shared<op::Parameter>(et, offsets_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto deformable_conv = make_shared<op::v1::DeformableConvolution>(data_batch,
offsets,
filters,
@ -1031,9 +1034,9 @@ protected:
};
TEST_F(TypePropDeformableConvolutionV1Test, default_ctor) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, 4, 5, 5});
const auto offsets = make_shared<op::Parameter>(element::f32, PartialShape{1, 36, 7, 2});
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{4, 1, 3, 3});
const auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, 4, 5, 5});
const auto offsets = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, 36, 7, 2});
const auto filters = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{4, 1, 3, 3});
const auto op = make_op();
op->set_arguments(OutputVector{data, offsets, filters});
@ -1067,9 +1070,9 @@ TEST_F(TypePropDeformableConvolutionV1Test, interval_shapes) {
const element::Type_t et = element::f32;
const auto auto_pad = op::PadType::EXPLICIT;
const auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
const auto offsets = make_shared<op::Parameter>(et, offsets_shape);
const auto filters = make_shared<op::Parameter>(et, filters_pshape);
const auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
const auto offsets = make_shared<ov::op::v0::Parameter>(et, offsets_shape);
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);
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
//
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/opsets/opset8.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace ov::opset8;
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
//
#include "openvino/op/deformable_psroi_pooling.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace testing;
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;
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{2, 4, 64, 56});
auto input_coords = make_shared<op::Parameter>(element::f32, PartialShape{rois_dim, 5});
auto input_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 4, 64, 56});
auto input_coords = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{rois_dim, 5});
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);
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};
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 =
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;
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
auto input_coords = make_shared<op::Parameter>(element::f32, PartialShape{rois_dim, 5});
auto input_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
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, 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;
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
auto input_coords = make_shared<op::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_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
auto input_coords = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{rois_dim, 5});
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,
input_coords,
@ -108,9 +111,10 @@ TEST(type_prop, deformable_psroi_pooling_group_size_7) {
const auto rois_dim = 300;
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
auto input_coords = make_shared<op::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_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
auto input_coords = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{rois_dim, 5});
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,
input_coords,
@ -135,8 +139,8 @@ TEST(type_prop, deformable_psroi_pooling_dynamic_rois) {
const auto rois_dim = Dimension(100, 200);
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
auto input_coords = make_shared<op::Parameter>(element::f32, PartialShape{rois_dim, 5});
auto input_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
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, 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();
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto input_coords = 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<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto def_psroi_pool =
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 {
const int64_t group_size = 0;
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
auto input_coords = make_shared<op::Parameter>(element::f32, PartialShape{rois_dim, 5});
auto input_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
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,
input_coords,
output_dim,
@ -193,8 +197,8 @@ TEST(type_prop, deformable_psroi_pooling_invalid_output_dim) {
try {
const int64_t output_dim = -882;
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
auto input_coords = make_shared<op::Parameter>(element::f32, PartialShape{rois_dim, 5});
auto input_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
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,
input_coords,
output_dim,
@ -218,9 +222,10 @@ TEST(type_prop, deformable_psroi_pooling_invalid_data_input_rank) {
const auto rois_dim = 300;
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{7938, 63, 38});
auto input_coords = make_shared<op::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_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{7938, 63, 38});
auto input_coords = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{rois_dim, 5});
auto input_offsets =
make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{rois_dim, 2, part_size, part_size});
try {
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;
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
auto input_coords = make_shared<op::Parameter>(element::f32, PartialShape{2, rois_dim, 5});
auto input_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
auto input_coords = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, rois_dim, 5});
try {
auto def_psroi_pool = make_shared<op::v1::DeformablePSROIPooling>(input_data,
input_coords,
@ -277,9 +282,10 @@ TEST(type_prop, deformable_psroi_pooling_invalid_offstes_rank) {
const auto rois_dim = 300;
auto input_data = make_shared<op::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
auto input_coords = make_shared<op::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_data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 7938, 63, 38});
auto input_coords = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{rois_dim, 5});
auto input_offsets =
make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, rois_dim, 2, part_size, part_size});
try {
auto def_psroi_pool = make_shared<op::v1::DeformablePSROIPooling>(input_data,
input_coords,

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

@ -2,19 +2,23 @@
// 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 "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "ngraph/util.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace testing;
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}};
set_shape_labels(a_shape, 10);
auto A = make_shared<op::Parameter>(element::f32, a_shape);
auto depth_to_space = make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 2);
auto A = make_shared<ov::op::v0::Parameter>(element::f32, a_shape);
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_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) {
auto a_shape = PartialShape{{2, 10}, 24, {3, 7}, {423, 3000}, {235, 1345}};
set_shape_labels(a_shape, 10);
auto A = make_shared<op::Parameter>(element::f32, a_shape);
auto depth_to_space = make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST);
auto A = make_shared<ov::op::v0::Parameter>(element::f32, a_shape);
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_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
TEST(type_prop, depth_to_space_output_dynamicshape_block_first_5D_when_depth_is_dynamic) {
auto A =
make_shared<op::Parameter>(element::f32, 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 A = make_shared<ov::op::v0::Parameter>(element::f32,
PartialShape{{2, 10}, {81, 82}, {3, 7}, {423, 3000}, {235, 1345}});
auto depth_to_space =
make_shared<ov::op::v0::DepthToSpace>(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 3);
ASSERT_EQ(
depth_to_space->get_output_partial_shape(0),
(PartialShape{{2, 10}, {ceil_div(81, 27), 82 / 27}, {3 * 3, 7 * 3}, {423 * 3, 3000 * 3}, {235 * 3, 1345 * 3}}));
ASSERT_EQ(depth_to_space->get_output_partial_shape(0),
(PartialShape{{2, 10},
{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) {
auto A = make_shared<op::Parameter>(element::f32, Shape{1, 128, 8, 8});
auto depth_to_space = make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 8);
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 128, 8, 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_shape(), (Shape{1, 2, 64, 64}));
}
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 depth_to_space = make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 2);
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 12, 1080, 1616});
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_shape(), (Shape{1, 3, 2 * 1080, 2 * 1616}));
}
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 depth_to_space = make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 2);
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 16, 3, 1080, 1616});
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_shape(), (Shape{1, 2, 2 * 3, 2 * 1080, 2 * 1616}));
}
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 depth_to_space = make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2);
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 12, 1080, 1616});
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_shape(), (Shape{1, 3, 2 * 1080, 2 * 1616}));
}
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 depth_to_space = make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2);
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 16, 3, 1080, 1616});
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_shape(), (Shape{1, 2, 2 * 3, 2 * 1080, 2 * 1616}));
}
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 {
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";
} 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)");
} catch (...) {
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) {
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 {
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";
} 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");
} catch (...) {
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) {
auto A = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(4));
auto depth_to_space = make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2);
auto A = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(4));
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_output_partial_shape(0), PartialShape::dynamic(4));
}
TEST(type_prop, depth_to_space_dynamic_shape_dynamic_rank) {
auto A = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto depth_to_space = make_shared<op::DepthToSpace>(A, "depth_first", 2);
auto A = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
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_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) {
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_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->validate_and_infer_types();
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_output_size(), 1);
EXPECT_EQ(depth_to_space->get_output_element_type(0), element::u32);

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

@ -2,28 +2,28 @@
// 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 "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/core/dimension_tracker.hpp"
#include "openvino/util/common_util.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace testing;
// ------------------------------ 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 proposals_shape,
PartialShape aux_class_preds_shape,
PartialShape aux_box_preds_shape,
const op::DetectionOutputAttrs& attrs,
const ov::op::v0::DetectionOutput::Attributes& attrs,
element::Type input_type,
element::Type proposals_type,
bool set_labels = false) {
@ -37,25 +37,30 @@ std::shared_ptr<op::DetectionOutput> create_detection_output(PartialShape box_lo
set_shape_labels(aux_box_preds_shape, 50);
}
auto box_logits = make_shared<op::Parameter>(input_type, box_logits_shape);
auto class_preds = make_shared<op::Parameter>(input_type, class_preds_shape);
auto proposals = make_shared<op::Parameter>(proposals_type, proposals_shape);
auto aux_class_preds = make_shared<op::Parameter>(input_type, aux_class_preds_shape);
auto aux_box_preds = make_shared<op::Parameter>(input_type, aux_box_preds_shape);
return make_shared<op::DetectionOutput>(box_logits, class_preds, proposals, aux_class_preds, aux_box_preds, attrs);
auto box_logits = make_shared<ov::op::v0::Parameter>(input_type, box_logits_shape);
auto class_preds = make_shared<ov::op::v0::Parameter>(input_type, class_preds_shape);
auto proposals = make_shared<ov::op::v0::Parameter>(proposals_type, proposals_shape);
auto aux_class_preds = make_shared<ov::op::v0::Parameter>(input_type, aux_class_preds_shape);
auto aux_box_preds = make_shared<ov::op::v0::Parameter>(input_type, aux_box_preds_shape);
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) {
auto op = make_shared<op::v0::DetectionOutput>();
auto input_type = element::f32;
auto box_logits = make_shared<op::Parameter>(input_type, PartialShape{4, 20});
auto class_preds = make_shared<op::Parameter>(input_type, PartialShape{4, 10});
auto proposals = make_shared<op::Parameter>(input_type, PartialShape{4, 2, 20});
auto ad_class_preds = make_shared<op::Parameter>(input_type, PartialShape{4, 10});
auto ad_box_preds = 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<ov::op::v0::Parameter>(input_type, PartialShape{4, 10});
auto proposals = make_shared<ov::op::v0::Parameter>(input_type, PartialShape{4, 2, 20});
auto ad_class_preds = make_shared<ov::op::v0::Parameter>(input_type, PartialShape{4, 10});
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.top_k = 7;
attrs.num_classes = 2;
@ -80,7 +85,7 @@ TEST(type_prop_layers, detection_output_v0_default_ctor) {
}
TEST(type_prop_layers, detection_output_basic) {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200};
attrs.num_classes = 2;
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) {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {60};
attrs.num_classes = 3;
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) {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
attrs.top_k = 80;
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) {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
attrs.top_k = -1;
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) {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200};
attrs.num_classes = 2;
attrs.normalized = true;
@ -179,7 +184,7 @@ TEST(type_prop_layers, detection_output_v0_f16) {
}
TEST(type_prop_layers, detection_f16_with_proposals_f32) {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200};
attrs.num_classes = 2;
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) {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200};
attrs.num_classes = 2;
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) {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
attrs.top_k = -1;
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) {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
attrs.top_k = -1;
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) {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
attrs.top_k = -1;
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) {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
attrs.top_k = 7;
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) {
PartialShape dyn_shape = PartialShape::dynamic();
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
attrs.num_classes = 1;
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) {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200};
attrs.num_classes = 2;
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,
const std::string& expected_msg) {
try {
auto box_logits = make_shared<op::Parameter>(box_logits_et, Shape{4, 20});
auto class_preds = make_shared<op::Parameter>(class_preds_et, Shape{4, 10});
auto proposals = make_shared<op::Parameter>(proposals_et, Shape{4, 2, 20});
auto aux_class_preds = make_shared<op::Parameter>(aux_class_preds_et, Shape{4, 10});
auto aux_box_preds = make_shared<op::Parameter>(aux_box_preds_et, Shape{4, 20});
op::DetectionOutputAttrs attrs;
auto box_logits = make_shared<ov::op::v0::Parameter>(box_logits_et, Shape{4, 20});
auto class_preds = make_shared<ov::op::v0::Parameter>(class_preds_et, Shape{4, 10});
auto proposals = make_shared<ov::op::v0::Parameter>(proposals_et, Shape{4, 2, 20});
auto aux_class_preds = make_shared<ov::op::v0::Parameter>(aux_class_preds_et, Shape{4, 10});
auto aux_box_preds = make_shared<ov::op::v0::Parameter>(aux_box_preds_et, Shape{4, 20});
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200};
attrs.num_classes = 2;
attrs.normalized = true;
auto op =
make_shared<op::DetectionOutput>(box_logits, class_preds, proposals, aux_class_preds, aux_box_preds, attrs);
auto op = make_shared<ov::op::v0::DetectionOutput>(box_logits,
class_preds,
proposals,
aux_class_preds,
aux_box_preds,
attrs);
FAIL() << "Exception expected";
} catch (const NodeValidationFailure& error) {
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) {
{
try {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200};
attrs.num_classes = 2;
attrs.normalized = true;
@ -407,7 +416,7 @@ TEST(type_prop_layers, detection_output_v0_mismatched_batch_size) {
}
{
try {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200};
attrs.num_classes = 2;
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) {
{
try {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200};
attrs.num_classes = 2;
attrs.normalized = true;
@ -454,7 +463,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_ranks) {
}
{
try {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200};
attrs.num_classes = 2;
attrs.normalized = true;
@ -475,7 +484,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_ranks) {
}
{
try {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {200};
attrs.num_classes = 2;
attrs.normalized = true;
@ -500,7 +509,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_box_logits_shape) {
// share_location = true
{
try {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
attrs.num_classes = 3;
attrs.share_location = true;
@ -526,7 +535,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_box_logits_shape) {
// share_location = false
{
try {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
attrs.num_classes = 3;
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) {
try {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
attrs.num_classes = 3;
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
{
try {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
attrs.num_classes = 3;
attrs.share_location = true;
@ -604,7 +613,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_proposals_shape) {
// variance_encoded_in_target = true
{
try {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
attrs.num_classes = 3;
attrs.share_location = true;
@ -630,7 +639,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_proposals_shape) {
// normalized = false
{
try {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
attrs.num_classes = 3;
attrs.share_location = true;
@ -656,7 +665,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_proposals_shape) {
// normalized = true
{
try {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
attrs.num_classes = 3;
attrs.share_location = true;
@ -685,7 +694,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_aux_class_preds) {
// invalid batch size
{
try {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
attrs.num_classes = 3;
attrs.share_location = true;
@ -711,7 +720,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_aux_class_preds) {
// invalid 2nd dimension
{
try {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
attrs.num_classes = 3;
attrs.share_location = true;
@ -741,7 +750,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_aux_box_preds) {
// invalid batch size
{
try {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
attrs.num_classes = 3;
attrs.share_location = true;
@ -767,7 +776,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_aux_box_preds) {
// invalid 2nd dimension
{
try {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
attrs.num_classes = 3;
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);
}
auto box_logits = make_shared<op::Parameter>(input_type, box_logits_shape);
auto class_preds = make_shared<op::Parameter>(input_type, class_preds_shape);
auto proposals = make_shared<op::Parameter>(input_type, proposals_shape);
auto box_logits = make_shared<ov::op::v0::Parameter>(input_type, box_logits_shape);
auto class_preds = make_shared<ov::op::v0::Parameter>(input_type, class_preds_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);
}
@ -832,11 +841,11 @@ std::shared_ptr<op::v8::DetectionOutput> create_detection_output2_v8(PartialShap
set_shape_labels(aux_box_preds_shape, 50);
}
auto box_logits = make_shared<op::Parameter>(input_type, box_logits_shape);
auto class_preds = make_shared<op::Parameter>(input_type, class_preds_shape);
auto proposals = make_shared<op::Parameter>(input_type, proposals_shape);
auto aux_class_preds = make_shared<op::Parameter>(input_type, aux_class_preds_shape);
auto aux_box_preds = make_shared<op::Parameter>(input_type, aux_box_preds_shape);
auto box_logits = make_shared<ov::op::v0::Parameter>(input_type, box_logits_shape);
auto class_preds = make_shared<ov::op::v0::Parameter>(input_type, class_preds_shape);
auto proposals = make_shared<ov::op::v0::Parameter>(input_type, proposals_shape);
auto aux_class_preds = make_shared<ov::op::v0::Parameter>(input_type, aux_class_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,
class_preds,
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);
auto input_type = element::f32;
auto box_logits = make_shared<op::Parameter>(input_type, box_logits_shape);
auto class_preds = make_shared<op::Parameter>(input_type, class_preds_shape);
auto proposals = make_shared<op::Parameter>(input_type, proposals_shape);
auto ad_class_preds = make_shared<op::Parameter>(input_type, ad_class_preds_shape);
auto ad_box_preds = 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<ov::op::v0::Parameter>(input_type, class_preds_shape);
auto proposals = make_shared<ov::op::v0::Parameter>(input_type, proposals_shape);
auto ad_class_preds = make_shared<ov::op::v0::Parameter>(input_type, ad_class_preds_shape);
auto ad_box_preds = make_shared<ov::op::v0::Parameter>(input_type, box_logits_shape);
auto op = make_shared<op::v8::DetectionOutput>();
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) {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
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
@ -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) {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
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
@ -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) {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
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
@ -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) {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
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
@ -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) {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
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
@ -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) {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
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
@ -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) {
op::DetectionOutputAttrs attrs;
ov::op::v0::DetectionOutput::Attributes attrs;
attrs.keep_top_k = {-1};
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

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

@ -1,24 +1,15 @@
//*****************************************************************************
// Copyright 2017-2022 Intel Corporation
// Copyright (C) 2018-2023 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.
// You may obtain a copy of the License at
//
// 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 "openvino/op/dft.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/op/constant.hpp"
using namespace ngraph;
using namespace ov;
struct ConstantAxesAndConstantSignalSizeTestParams {
PartialShape input_shape;
@ -34,15 +25,15 @@ struct ConstantAxesAndConstantSignalSizeTest : ::testing::TestWithParam<Constant
TEST_P(ConstantAxesAndConstantSignalSizeTest, dft_constant_axes_and_signal_size) {
auto params = GetParam();
auto data = std::make_shared<op::Parameter>(element::f32, params.input_shape);
auto axes_input = op::Constant::create<int64_t>(element::i64, params.axes_shape, params.axes);
auto data = std::make_shared<ov::op::v0::Parameter>(element::f32, params.input_shape);
auto axes_input = ov::op::v0::Constant::create<int64_t>(element::i64, params.axes_shape, params.axes);
std::shared_ptr<op::v7::DFT> dft;
if (params.signal_size.empty()) {
dft = std::make_shared<op::v7::DFT>(data, axes_input);
} else {
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);
}
@ -187,8 +178,8 @@ TEST(type_prop, dft_dynamic_axes) {
const auto ref_output_shape =
PartialShape{Dimension::dynamic(), Dimension::dynamic(), Dimension::dynamic(), Dimension(1, 18)};
auto data = std::make_shared<op::Parameter>(element::f32, input_shape);
auto axes_input = std::make_shared<op::Parameter>(element::i64, axes_shape);
auto data = std::make_shared<ov::op::v0::Parameter>(element::f32, input_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);
EXPECT_EQ(dft->get_element_type(), element::f32);
@ -206,8 +197,8 @@ struct NonConstantAxesTest : ::testing::TestWithParam<NonConstantAxesTestParams>
TEST_P(NonConstantAxesTest, dft_non_constant_axes) {
auto params = GetParam();
auto data = std::make_shared<op::Parameter>(element::f32, params.input_shape);
auto axes_input = std::make_shared<op::Parameter>(element::i64, params.axes_shape);
auto data = std::make_shared<ov::op::v0::Parameter>(element::f32, params.input_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);
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) {
auto params = GetParam();
auto data = std::make_shared<op::Parameter>(element::f32, params.input_shape);
auto axes_input = op::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 data = std::make_shared<ov::op::v0::Parameter>(element::f32, params.input_shape);
auto axes_input = ov::op::v0::Constant::create<int64_t>(element::i64, params.axes_shape, params.axes);
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);
EXPECT_EQ(dft->get_element_type(), element::f32);
@ -310,10 +301,10 @@ INSTANTIATE_TEST_SUITE_P(
PrintToDummyParamName());
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 {
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);
FAIL() << "DFT node was created with invalid input.";
} catch (const NodeValidationFailure& error) {
@ -321,7 +312,7 @@ TEST(type_prop, dft_invalid_input) {
}
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);
FAIL() << "DFT node was created with invalid input.";
} catch (const NodeValidationFailure& error) {
@ -329,7 +320,7 @@ TEST(type_prop, dft_invalid_input) {
}
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);
FAIL() << "DFT node was created with invalid input.";
} catch (const NodeValidationFailure& error) {
@ -338,10 +329,10 @@ TEST(type_prop, dft_invalid_input) {
}
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 {
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);
FAIL() << "DFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) {
@ -349,7 +340,7 @@ TEST(type_prop, dft_invalid_axes) {
}
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);
FAIL() << "DFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) {
@ -357,7 +348,7 @@ TEST(type_prop, dft_invalid_axes) {
}
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);
FAIL() << "DFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) {
@ -365,7 +356,7 @@ TEST(type_prop, dft_invalid_axes) {
}
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);
FAIL() << "DFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) {
@ -373,7 +364,7 @@ TEST(type_prop, dft_invalid_axes) {
}
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);
FAIL() << "DFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) {
@ -382,11 +373,11 @@ TEST(type_prop, dft_invalid_axes) {
}
TEST(type_prop, dft_invalid_signal_size) {
auto data = std::make_shared<op::Parameter>(element::f32, Shape{4, 3, 2});
auto axes = op::Constant::create(element::i64, Shape{1}, {0});
auto data = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{4, 3, 2});
auto axes = ov::op::v0::Constant::create(element::i64, Shape{1}, {0});
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);
FAIL() << "DFT node was created with invalid signal size.";
} catch (const NodeValidationFailure& error) {
@ -394,7 +385,7 @@ TEST(type_prop, dft_invalid_signal_size) {
}
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);
FAIL() << "DFT node was created with invalid signal size.";
} catch (const NodeValidationFailure& error) {
@ -408,9 +399,9 @@ TEST(type_prop, dft_dynamic_types) {
const auto signal_size_shape = PartialShape::dynamic();
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 axes_input = std::make_shared<op::Parameter>(element::dynamic, axes_shape);
auto signal_size_input = std::make_shared<op::Parameter>(element::dynamic, signal_size_shape);
auto data = std::make_shared<ov::op::v0::Parameter>(element::dynamic, input_shape);
auto axes_input = std::make_shared<ov::op::v0::Parameter>(element::dynamic, axes_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);
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
//
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/reshape.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
TEST(type_prop, reshape_v1_arg_rank_static_pattern_zero) {
auto arg = make_shared<op::Parameter>(element::f32, Shape{2, 0, 2, 8});
auto pattern = op::Constant::create(element::i64, Shape{4}, {1, 2, 0, 32});
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 0, 2, 8});
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);
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);
EXPECT_TRUE(
reshape_v1_dynamic->get_output_partial_shape(0).same_scheme(PartialShape{1, 2, Dimension::dynamic(), 32}));
try {
auto static_shape_parameter = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto reshape_output_pattern = op::Constant::create(element::i64, Shape{4}, {2, 2, 3, 4});
auto static_shape_parameter = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 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);
FAIL() << "Expected failure on reshape construction";
} catch (const NodeValidationFailure& error) {

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

@ -2,29 +2,31 @@
// 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/type_prop.hpp"
#include "gmock/gmock.h"
#include "ngraph/ngraph.hpp"
#include "openvino/core/dimension_tracker.hpp"
#include "openvino/pass/graph_rewrite.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace testing;
namespace {
constexpr size_t exp_einsum_outputs_count = 1;
}
class TypePropEinsumTest : public TypePropOpTest<op::v7::Einsum> {
class TypePropEinsumTest : public TypePropOpTest<ov::op::v7::Einsum> {
protected:
template <class ShapeContainer>
OutputVector make_inputs(const element::Type dtype, ShapeContainer&& input_shapes) const {
OutputVector inputs;
inputs.reserve(input_shapes.size());
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;
}
@ -58,7 +60,7 @@ TEST_F(TypePropEinsumTest, static_shape_trace) {
const std::string equation = "kii->k";
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);
EXPECT_EQ(o->get_equation(), equation);
@ -71,7 +73,7 @@ TEST_F(TypePropEinsumTest, static_shape_diag_extraction) {
const std::string equation = "kii->ki";
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);
EXPECT_EQ(o->get_equation(), equation);
@ -84,7 +86,7 @@ TEST_F(TypePropEinsumTest, static_shape_transpose) {
const std::string equation = "ijk->kij";
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);
EXPECT_EQ(o->get_equation(), equation);
@ -109,7 +111,7 @@ TEST_F(TypePropEinsumTest, static_shape_ellipsis_one_input) {
const std::string equation = "a...->...";
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);
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};
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);
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}};
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);
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);
OV_EXPECT_THROW(auto o = make_op(inputs, equation),
CheckFailure,
AssertFailure,
HasSubstr("Input subscript of Einsum equation must consist of either only alphabetic "
"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);
OV_EXPECT_THROW(auto o = make_op(inputs, equation),
CheckFailure,
AssertFailure,
HasSubstr("Different input dimensions indicated by the same labels "
"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);
OV_EXPECT_THROW(auto o = make_op(inputs, equation),
CheckFailure,
AssertFailure,
HasSubstr("Output subscript of Einsum equation must contain one "
"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
//
#include "openvino/op/elu.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
using namespace std;
using namespace ngraph;
TEST(type_prop, elu) {
Shape data_shape{2, 4};
auto data = make_shared<op::Parameter>(element::f32, data_shape);
auto elu = make_shared<op::Elu>(data, 1);
ASSERT_EQ(elu->get_element_type(), element::f32);
ov::Shape data_shape{2, 4};
auto data = make_shared<ov::op::v0::Parameter>(ov::element::f32, data_shape);
auto elu = make_shared<ov::op::v0::Elu>(data, 1);
ASSERT_EQ(elu->get_element_type(), ov::element::f32);
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
//
#include "openvino/op/embedding_segments_sum.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/opsets/opset3.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/shape_of.hpp"
#include "openvino/op/squeeze.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace testing;
TEST(type_prop, ess_default_ctor) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2, 6});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2, 6});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto op = make_shared<op::v3::EmbeddingSegmentsSum>();
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table,
indices,
@ -51,12 +54,12 @@ TEST(type_prop, ess) {
}
TEST(type_prop, ess_dynamic_emb_table_number_segment) {
auto emb_table = make_shared<op::Parameter>(element::f32, PartialShape{5, Dimension::dynamic()});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{5, Dimension::dynamic()});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto ess = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table,
indices,
@ -69,12 +72,12 @@ TEST(type_prop, ess_dynamic_emb_table_number_segment) {
}
TEST(type_prop, ess_fail_indices_element_type) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::f32, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try {
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::f32, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try {
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::f32, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try {
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::f32, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
try {
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i32, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i32, Shape{4});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try {
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i32, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i32, Shape{});
try {
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::i64, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try {
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i32, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<ov::op::v0::Parameter>(element::i32, Shape{});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try {
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{3});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try {
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{2});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{2});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try {
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{2});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{2});
try {
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4, 2});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4, 2});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try {
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{3, 2});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3, 2});
auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try {
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4, 2});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4, 2});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try {
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
OV_EXPECT_THROW(auto op = make_shared<op::v3::EmbeddingSegmentsSum>(emb_table,
indices,
@ -414,10 +417,10 @@ TEST(type_prop, ess_fail_emb_table_0d) {
}
TEST(type_prop, ess_4_args_api) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
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);
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::f32, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto num_segments = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try {
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4});
auto num_segments = opset3::Constant::create(element::i64, Shape{}, {3});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
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);
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}};
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 num_segm_squeeze = make_shared<op::v0::Squeeze>(shape_of);
auto emb_table = make_shared<op::Parameter>(element::f32, emb_shape);
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto segment_ids = make_shared<op::Parameter>(element::i64, Shape{4});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, emb_shape);
auto indices = make_shared<ov::op::v0::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);
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
//
#include <gtest/gtest.h>
#include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/op/embeddingbag_offsets_sum.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace testing;
TEST(type_prop, ebos_default_ctor) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2, 6});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2, 6});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto op = make_shared<op::v3::EmbeddingBagOffsetsSum>();
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}};
set_shape_labels(off_shape, 20);
auto emb_table = make_shared<op::Parameter>(element::f32, emb_shape);
auto indices = make_shared<op::Parameter>(element::i64, PartialShape{{3, 4}});
auto offsets = make_shared<op::Parameter>(element::i64, off_shape);
auto per_sample_weights = make_shared<op::Parameter>(element::f32, PartialShape{{3, 4}});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, emb_shape);
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, PartialShape{{3, 4}});
auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, off_shape);
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{{3, 4}});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto op =
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto ebos =
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, PartialShape{5, Dimension::dynamic()});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{5, Dimension::dynamic()});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto ebos =
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, PartialShape{Dimension::dynamic()});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, PartialShape{Dimension::dynamic()});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto ebos =
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, PartialShape{5, Dimension::dynamic()});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, PartialShape{Dimension::dynamic()});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{5, Dimension::dynamic()});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, PartialShape{Dimension::dynamic()});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto ebos =
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::f32, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try {
auto ebos =
@ -120,11 +121,11 @@ TEST(type_prop, ebos_fail_indices_element_type) {
}
TEST(type_prop, ebos_fail_offsets_element_type) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::f32, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try {
auto ebos =
@ -138,11 +139,11 @@ TEST(type_prop, ebos_fail_offsets_element_type) {
}
TEST(type_prop, ebos_fail_default_index_element_type) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::f32, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
try {
auto ebos =
@ -156,11 +157,11 @@ TEST(type_prop, ebos_fail_default_index_element_type) {
}
TEST(type_prop, ebos_fail_mismatch_element_type) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i32, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i32, Shape{4});
auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try {
auto ebos =
@ -175,11 +176,11 @@ TEST(type_prop, ebos_fail_mismatch_element_type) {
}
TEST(type_prop, ebos_fail_mismatch_element_type_1) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i32, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i32, Shape{});
try {
auto ebos =
@ -194,11 +195,11 @@ TEST(type_prop, ebos_fail_mismatch_element_type_1) {
}
TEST(type_prop, ebos_fail_mismatch_element_type_2) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::i64, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try {
auto ebos =
@ -214,11 +215,11 @@ TEST(type_prop, ebos_fail_mismatch_element_type_2) {
}
TEST(type_prop, ebos_fail_mismatch_shape) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{3});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try {
auto ebos =
@ -232,11 +233,11 @@ TEST(type_prop, ebos_fail_mismatch_shape) {
}
TEST(type_prop, ebos_fail_default_index_scalar) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{2});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{2});
try {
auto ebos =
@ -250,11 +251,11 @@ TEST(type_prop, ebos_fail_default_index_scalar) {
}
TEST(type_prop, ebos_fail_indices_1d) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4, 2});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4, 2});
auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try {
auto ebos =
@ -268,11 +269,11 @@ TEST(type_prop, ebos_fail_indices_1d) {
}
TEST(type_prop, ebos_fail_emb_table_0d) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
OV_EXPECT_THROW(
auto op =
@ -282,11 +283,11 @@ TEST(type_prop, ebos_fail_emb_table_0d) {
}
TEST(type_prop, ebos_fail_offsets_1d) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3, 2});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3, 2});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try {
auto ebos =
@ -300,11 +301,11 @@ TEST(type_prop, ebos_fail_offsets_1d) {
}
TEST(type_prop, ebos_fail_per_sample_weights_1d) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4, 2});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4, 2});
auto default_index = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
try {
auto ebos =
@ -318,9 +319,9 @@ TEST(type_prop, ebos_fail_per_sample_weights_1d) {
}
TEST(type_prop, ebos_3_args_api) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto ebos = make_shared<op::v3::EmbeddingBagOffsetsSum>(emb_table, indices, offsets);
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::f32, Shape{4});
auto offsets = make_shared<op::Parameter>(element::i64, Shape{3});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto offsets = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
try {
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
//
#include "openvino/op/embeddingbag_packedsum.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace testing;
TEST(type_prop, ebps_default_ctor) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2, 6});
auto indices = make_shared<op::Parameter>(element::i64, Shape{3, 4});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{3, 4});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2, 6});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, 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>();
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};
set_shape_labels(ind_shape, 20);
auto emb_table = make_shared<op::Parameter>(element::f32, emb_shape);
auto indices = make_shared<op::Parameter>(element::i64, ind_shape);
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, emb_shape);
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, ind_shape);
auto op = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices);
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};
set_shape_labels(sample_shape, 30);
auto emb_table = make_shared<op::Parameter>(element::f32, emb_shape);
auto indices = make_shared<op::Parameter>(element::i64, ind_shape);
auto per_sample_weights = make_shared<op::Parameter>(element::f32, sample_shape);
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, emb_shape);
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, ind_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);
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{3, 4});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{3, 4});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, 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);
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, PartialShape{5, Dimension::dynamic()});
auto indices = make_shared<op::Parameter>(element::i64, Shape{3, 4});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{3, 4});
auto default_index = make_shared<op::Parameter>(element::i64, Shape{});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{5, Dimension::dynamic()});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3, 4});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 4});
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);
@ -81,9 +83,9 @@ TEST(type_prop, ebps_dynamic_emb_table) {
}
TEST(type_prop, ebps_dynamic_indices) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, PartialShape{Dimension::dynamic(), 4});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 4});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, 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);
@ -91,9 +93,9 @@ TEST(type_prop, ebps_dynamic_indices) {
}
TEST(type_prop, ebps_dynamic_emb_table_indices) {
auto emb_table = make_shared<op::Parameter>(element::f32, PartialShape{5, Dimension::dynamic()});
auto indices = make_shared<op::Parameter>(element::i64, PartialShape{Dimension::dynamic(), 4});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 4});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{5, Dimension::dynamic()});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, 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);
@ -102,9 +104,9 @@ TEST(type_prop, ebps_dynamic_emb_table_indices) {
}
TEST(type_prop, ebps_fail_indices_element_type) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::f32, Shape{3, 4});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{3, 4});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 4});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 4});
try {
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{3, 4});
auto per_sample_weights = make_shared<op::Parameter>(element::i64, Shape{3, 4});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3, 4});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3, 4});
try {
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{3, 4});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4, 3});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3, 4});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4, 3});
try {
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{3, 4});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 4});
try {
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{});
auto indices = make_shared<op::Parameter>(element::i64, Shape{3, 4});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{3, 4});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, 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),
NodeValidationFailure,
@ -174,9 +176,9 @@ TEST(type_prop, ebps_fail_emb_table_0d) {
}
TEST(type_prop, ebps_fail_per_sample_weights_1d) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{3, 4});
auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{4});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3, 4});
auto per_sample_weights = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
try {
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::i64, Shape{3, 4});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3, 4});
auto ebps = make_shared<op::v3::EmbeddingBagPackedSum>(emb_table, indices);
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) {
auto emb_table = make_shared<op::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<op::Parameter>(element::f32, Shape{3, 4});
auto emb_table = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 2});
auto indices = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 4});
try {
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"
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);

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

@ -4,6 +4,6 @@
#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);

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

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

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

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

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

@ -4,6 +4,6 @@
#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);