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

Moved type prop tests to new API from g to z (#19353)

Browse Source 
* Moved type prop tests to new API from g to z

* Fixed build
This commit is contained in:
Ilya Churaev 2023-08-24 12:59:49 +04:00 committed by GitHub
parent ce47522165
commit 6deca48413
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
116 changed files with 3844 additions and 3604 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -2,6 +2,8 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/abs.hpp"
#include "unary_ops.hpp"
using Type = ::testing::Types<ov::op::v0::Abs>;

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

@ -2,6 +2,8 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/acos.hpp"
#include "unary_ops.hpp"
using Type = ::testing::Types<ov::op::v0::Acos>;

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

@ -2,6 +2,8 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/acosh.hpp"
#include "unary_ops.hpp"
using Type = ::testing::Types<ov::op::v3::Acosh>;

382
src/core/tests/type_prop/arithmetic_ops.hpp
View File

@ -21,6 +21,7 @@
#include "openvino/core/dimension_tracker.hpp"
#include "openvino/op/util/attr_types.hpp"
using namespace ov;
using namespace testing;
template <class T>
@ -29,12 +30,10 @@ class ArithmeticOperator : public testing::Test {};
TYPED_TEST_SUITE_P(ArithmeticOperator);
TYPED_TEST_P(ArithmeticOperator, default_constructor) {
auto A = std::make_shared<ov::op::v0::Parameter>(
ov::element::f32,
ov::PartialShape{-1, 4, 1, 6, ov::Dimension(1, 6), ov::Dimension(2, 6)});
auto B = std::make_shared<ov::op::v0::Parameter>(
ov::element::f32,
ov::PartialShape{-1, 1, 5, 6, ov::Dimension(5, 8), ov::Dimension(5, 8)});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32,
PartialShape{-1, 4, 1, 6, Dimension(1, 6), Dimension(2, 6)});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32,
PartialShape{-1, 1, 5, 6, Dimension(5, 8), Dimension(5, 8)});
const auto op = std::make_shared<TypeParam>();
@ -58,8 +57,8 @@ TYPED_TEST_P(ArithmeticOperator, default_constructor) {
}
TYPED_TEST_P(ArithmeticOperator, shape_inference_2D) {
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2});
const auto op = std::make_shared<TypeParam>(A, B);
@ -68,8 +67,8 @@ TYPED_TEST_P(ArithmeticOperator, shape_inference_2D) {
}
TYPED_TEST_P(ArithmeticOperator, shape_inference_4D) {
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2, 3, 3});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2, 3, 3});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2, 3, 3});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2, 3, 3});
const auto op = std::make_shared<TypeParam>(A, B);
@ -78,8 +77,8 @@ TYPED_TEST_P(ArithmeticOperator, shape_inference_4D) {
}
TYPED_TEST_P(ArithmeticOperator, default_autobroadcast) {
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2});
const auto op = std::make_shared<TypeParam>(A, B);
@ -89,8 +88,8 @@ TYPED_TEST_P(ArithmeticOperator, default_autobroadcast) {
}
TYPED_TEST_P(ArithmeticOperator, no_autobroadcast) {
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2});
const auto op = std::make_shared<TypeParam>(A, B, ov::op::AutoBroadcastType::NONE);
@ -100,8 +99,8 @@ TYPED_TEST_P(ArithmeticOperator, no_autobroadcast) {
}
TYPED_TEST_P(ArithmeticOperator, shape_inference_4D_x_scalar_numpy_broadcast) {
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 3, 4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
const auto op = std::make_shared<TypeParam>(A, B);
@ -110,8 +109,8 @@ TYPED_TEST_P(ArithmeticOperator, shape_inference_4D_x_scalar_numpy_broadcast) {
}
TYPED_TEST_P(ArithmeticOperator, shape_inference_4D_x_1D_numpy_broadcast) {
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{5});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 3, 4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{5});
const auto op = std::make_shared<TypeParam>(A, B);
@ -120,8 +119,8 @@ TYPED_TEST_P(ArithmeticOperator, shape_inference_4D_x_1D_numpy_broadcast) {
}
TYPED_TEST_P(ArithmeticOperator, shape_inference_2D_x_4D_numpy_broadcast) {
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4, 5});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 3, 4, 5});
const auto op = std::make_shared<TypeParam>(A, B);
@ -130,8 +129,8 @@ TYPED_TEST_P(ArithmeticOperator, shape_inference_2D_x_4D_numpy_broadcast) {
}
TYPED_TEST_P(ArithmeticOperator, shape_inference_3D_x_4D_numpy_broadcast) {
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 1, 1});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 3, 1, 1});
const auto op = std::make_shared<TypeParam>(A, B);
@ -140,8 +139,8 @@ TYPED_TEST_P(ArithmeticOperator, shape_inference_3D_x_4D_numpy_broadcast) {
}
TYPED_TEST_P(ArithmeticOperator, shape_inference_4D_x_3D_numpy_broadcast) {
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{8, 1, 6, 1});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{7, 1, 5});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{8, 1, 6, 1});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{7, 1, 5});
const auto op = std::make_shared<TypeParam>(A, B);
@ -152,8 +151,8 @@ TYPED_TEST_P(ArithmeticOperator, shape_inference_4D_x_3D_numpy_broadcast) {
TYPED_TEST_P(ArithmeticOperator, static_shape_pdpd_doc_examples) {
{
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{3, 4});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 3, 4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 4});
const auto autob = ov::op::AutoBroadcastSpec(ov::op::AutoBroadcastType::PDPD, 1);
const auto op = std::make_shared<TypeParam>(A, B, autob);
@ -163,8 +162,8 @@ TYPED_TEST_P(ArithmeticOperator, static_shape_pdpd_doc_examples) {
EXPECT_EQ(op->get_autob().m_type, ov::op::AutoBroadcastType::PDPD);
}
{
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{3, 1});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 3, 4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 1});
const auto autob = ov::op::AutoBroadcastSpec(ov::op::AutoBroadcastType::PDPD, 1);
const auto op = std::make_shared<TypeParam>(A, B, autob);
@ -174,8 +173,8 @@ TYPED_TEST_P(ArithmeticOperator, static_shape_pdpd_doc_examples) {
EXPECT_EQ(op->get_autob().m_type, ov::op::AutoBroadcastType::PDPD);
}
{
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 3, 4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
const auto autob = ov::op::AutoBroadcastSpec(ov::op::AutoBroadcastType::PDPD);
const auto op = std::make_shared<TypeParam>(A, B, autob);
@ -185,8 +184,8 @@ TYPED_TEST_P(ArithmeticOperator, static_shape_pdpd_doc_examples) {
EXPECT_EQ(op->get_autob().m_type, ov::op::AutoBroadcastType::PDPD);
}
{
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{5});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 3, 4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{5});
const auto autob = ov::op::AutoBroadcastSpec(ov::op::AutoBroadcastType::PDPD, 3);
const auto op = std::make_shared<TypeParam>(A, B, autob);
@ -196,8 +195,8 @@ TYPED_TEST_P(ArithmeticOperator, static_shape_pdpd_doc_examples) {
EXPECT_EQ(op->get_autob().m_type, ov::op::AutoBroadcastType::PDPD);
}
{
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 3});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 3, 4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3});
const auto autob = ov::op::AutoBroadcastSpec(ov::op::AutoBroadcastType::PDPD, 0);
const auto op = std::make_shared<TypeParam>(A, B, autob);
@ -207,8 +206,8 @@ TYPED_TEST_P(ArithmeticOperator, static_shape_pdpd_doc_examples) {
EXPECT_EQ(op->get_autob().m_type, ov::op::AutoBroadcastType::PDPD);
}
{
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{3, 1, 5});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 3, 4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 1, 5});
const auto autob = ov::op::AutoBroadcastSpec(ov::op::AutoBroadcastType::PDPD, 1);
const auto op = std::make_shared<TypeParam>(A, B, autob);
@ -221,8 +220,8 @@ TYPED_TEST_P(ArithmeticOperator, static_shape_pdpd_doc_examples) {
TYPED_TEST_P(ArithmeticOperator, static_shape_inference_4D_x_4D_pdpd_broadcast) {
{
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{8, 1, 6, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{8, 1, 6, 5});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{8, 1, 6, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{8, 1, 6, 5});
const auto autob = ov::op::AutoBroadcastSpec(ov::op::AutoBroadcastType::PDPD);
const auto op = std::make_shared<TypeParam>(A, B, autob);
@ -232,8 +231,8 @@ TYPED_TEST_P(ArithmeticOperator, static_shape_inference_4D_x_4D_pdpd_broadcast)
EXPECT_EQ(op->get_autob().m_type, ov::op::AutoBroadcastType::PDPD);
}
{
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{8, 7, 6, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{8, 1, 6, 5});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{8, 7, 6, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{8, 1, 6, 5});
const auto autob = ov::op::AutoBroadcastSpec(ov::op::AutoBroadcastType::PDPD);
const auto op = std::make_shared<TypeParam>(A, B, autob);
@ -245,8 +244,8 @@ TYPED_TEST_P(ArithmeticOperator, static_shape_inference_4D_x_4D_pdpd_broadcast)
}
TYPED_TEST_P(ArithmeticOperator, static_shape_inference_4D_x_3D_ax_default_pdpd_broadcast) {
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{8, 7, 6, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{7, 1, 5});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{8, 7, 6, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{7, 1, 5});
const auto op = std::make_shared<TypeParam>(A, B, ov::op::AutoBroadcastType::PDPD);
@ -256,43 +255,43 @@ TYPED_TEST_P(ArithmeticOperator, static_shape_inference_4D_x_3D_ax_default_pdpd_
}
TYPED_TEST_P(ArithmeticOperator, incompatible_element_types) {
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 2, 3, 3});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::i32, ov::Shape{2, 2, 3, 3});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2, 3, 3});
auto B = std::make_shared<ov::op::v0::Parameter>(element::i32, Shape{2, 2, 3, 3});
ASSERT_THROW(const auto unused = std::make_shared<TypeParam>(A, B), ov::NodeValidationFailure);
}
TYPED_TEST_P(ArithmeticOperator, incompatible_boolean_type) {
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::boolean, ov::Shape{2, 2, 3, 3});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::boolean, ov::Shape{2, 2, 3, 3});
auto A = std::make_shared<ov::op::v0::Parameter>(element::boolean, Shape{2, 2, 3, 3});
auto B = std::make_shared<ov::op::v0::Parameter>(element::boolean, Shape{2, 2, 3, 3});
ASSERT_THROW(const auto unused = std::make_shared<TypeParam>(A, B), ov::NodeValidationFailure);
}
TYPED_TEST_P(ArithmeticOperator, shape_inference_1D_x_1D_incompatible) {
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{3});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{4});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
ASSERT_THROW(const auto unused = std::make_shared<TypeParam>(A, B), ov::NodeValidationFailure);
}
TYPED_TEST_P(ArithmeticOperator, shape_inference_3D_x_3D_incompatible) {
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{3, 5, 6});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{4, 10, 12});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 5, 6});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{4, 10, 12});
ASSERT_THROW(const auto unused = std::make_shared<TypeParam>(A, B), ov::NodeValidationFailure);
}
TYPED_TEST_P(ArithmeticOperator, shape_inference_5D_x_5D_incompatible) {
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{389, 112, 12});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{389, 112, 19});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{389, 112, 12});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{389, 112, 19});
ASSERT_THROW(const auto unused = std::make_shared<TypeParam>(A, B), ov::NodeValidationFailure);
}
TYPED_TEST_P(ArithmeticOperator, shape_inference_axis_less_than_negative_1_pdpd_incompatible) {
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{3, 1});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 3, 4, 5});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 1});
const auto autob = ov::op::AutoBroadcastSpec(ov::op::AutoBroadcastType::PDPD, -2);
@ -300,8 +299,8 @@ TYPED_TEST_P(ArithmeticOperator, shape_inference_axis_less_than_negative_1_pdpd_
}
TYPED_TEST_P(ArithmeticOperator, shape_inference_dst_smaller_than_src_pdpd_broadcast) {
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4, 1});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 4, 5});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 3, 4, 1});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 3, 4, 5});
const auto autob = ov::op::AutoBroadcastSpec(ov::op::AutoBroadcastType::PDPD);
@ -309,33 +308,36 @@ TYPED_TEST_P(ArithmeticOperator, shape_inference_dst_smaller_than_src_pdpd_broad
}
TYPED_TEST_P(ArithmeticOperator, fully_dynamic_shape_broadcast_numpy) {
auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape::dynamic());
const auto autob = ov::op::AutoBroadcastSpec(ov::op::AutoBroadcastType::NUMPY);
auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
const auto autob = op::AutoBroadcastSpec(op::AutoBroadcastType::NUMPY);
const auto op = std::make_shared<TypeParam>(param, param, autob);
EXPECT_EQ(op->get_element_type(), ov::element::f32);
EXPECT_EQ(op->get_output_partial_shape(0), ov::PartialShape::dynamic());
}
TYPED_TEST_P(ArithmeticOperator, fully_dynamic_shape_broadcast_none) {
auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape::dynamic());
const auto autob = ov::op::AutoBroadcastSpec(ov::op::AutoBroadcastType::NONE);
auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
const auto autob = op::AutoBroadcastSpec(op::AutoBroadcastType::NONE);
const auto op = std::make_shared<TypeParam>(param, param, autob);
EXPECT_EQ(op->get_element_type(), ov::element::f32);
EXPECT_EQ(op->get_output_partial_shape(0), ov::PartialShape::dynamic());
}
TYPED_TEST_P(ArithmeticOperator, fully_dynamic_shape_broadcast_pdpd) {
auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape::dynamic());
const auto autob = ov::op::AutoBroadcastSpec(ov::op::AutoBroadcastType::PDPD);
auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
const auto autob = op::AutoBroadcastSpec(op::AutoBroadcastType::PDPD);
const auto op = std::make_shared<TypeParam>(param, param, autob);
EXPECT_EQ(op->get_element_type(), ov::element::f32);
EXPECT_EQ(op->get_output_partial_shape(0), ov::PartialShape::dynamic());
}
TYPED_TEST_P(ArithmeticOperator, dynamic_shape_3D) {
ov::Dimension dynamic = ov::Dimension::dynamic();
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{dynamic, dynamic, 6});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{dynamic, dynamic, 6});
Dimension dynamic = Dimension::dynamic();
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{dynamic, dynamic, 6});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{dynamic, dynamic, 6});
const auto op = std::make_shared<TypeParam>(A, B);
@ -344,11 +346,9 @@ TYPED_TEST_P(ArithmeticOperator, dynamic_shape_3D) {
}
TYPED_TEST_P(ArithmeticOperator, dynamic_shape_5D) {
ov::Dimension dynamic = ov::Dimension::dynamic();
auto A =
std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{dynamic, 4, dynamic, dynamic, 6});
auto B =
std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{dynamic, 4, dynamic, dynamic, 6});
Dimension dynamic = Dimension::dynamic();
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{dynamic, 4, dynamic, dynamic, 6});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{dynamic, 4, dynamic, dynamic, 6});
const auto op = std::make_shared<TypeParam>(A, B);
@ -358,11 +358,11 @@ TYPED_TEST_P(ArithmeticOperator, dynamic_shape_5D) {
TYPED_TEST_P(ArithmeticOperator, dynamic_shape_intervals_broadcast_none) {
auto A = std::make_shared<ov::op::v0::Parameter>(
ov::element::f32,
ov::PartialShape{ov::Dimension(1, 3), ov::Dimension(2, 7), ov::Dimension(6, -1), ov::Dimension(-1, 6), -1, 8});
element::f32,
PartialShape{Dimension(1, 3), Dimension(2, 7), Dimension(6, -1), Dimension(-1, 6), -1, 8});
auto B = std::make_shared<ov::op::v0::Parameter>(
ov::element::f32,
ov::PartialShape{ov::Dimension(1, 3), ov::Dimension(2, 7), ov::Dimension(6, -1), ov::Dimension(-1, 6), -1, 8});
element::f32,
PartialShape{Dimension(1, 3), Dimension(2, 7), Dimension(6, -1), Dimension(-1, 6), -1, 8});
const auto op = std::make_shared<TypeParam>(A, B, ov::op::AutoBroadcastType::NONE);
@ -378,26 +378,12 @@ TYPED_TEST_P(ArithmeticOperator, dynamic_shape_intervals_broadcast_none) {
TYPED_TEST_P(ArithmeticOperator, dynamic_shape_intervals_equal_rank_broadcast_numpy) {
// Equal rank
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32,
ov::PartialShape{ov::Dimension(1, 3),
ov::Dimension(1, 3),
ov::Dimension(1, 3),
ov::Dimension(4, 8),
-1,
1,
-1,
1,
3});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32,
ov::PartialShape{ov::Dimension(1, 3),
ov::Dimension(2, 7),
-1,
1,
ov::Dimension(1, 3),
ov::Dimension(4, 8),
-1,
1,
3});
auto A = std::make_shared<ov::op::v0::Parameter>(
element::f32,
PartialShape{Dimension(1, 3), Dimension(1, 3), Dimension(1, 3), Dimension(4, 8), -1, 1, -1, 1, 3});
auto B = std::make_shared<ov::op::v0::Parameter>(
element::f32,
PartialShape{Dimension(1, 3), Dimension(2, 7), -1, 1, Dimension(1, 3), Dimension(4, 8), -1, 1, 3});
const auto op = std::make_shared<TypeParam>(A, B);
@ -416,19 +402,11 @@ TYPED_TEST_P(ArithmeticOperator, dynamic_shape_intervals_equal_rank_broadcast_nu
TYPED_TEST_P(ArithmeticOperator, dynamic_shape_intervals_a_rank_smaller_broadcast_numpy) {
// `A` rank smaller
auto A = std::make_shared<ov::op::v0::Parameter>(
ov::element::f32,
ov::PartialShape{ov::Dimension(1, 3), ov::Dimension(4, 8), -1, 1, -1, 1, 3});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32,
ov::PartialShape{ov::Dimension(1, 3),
ov::Dimension(2, 7),
-1,
1,
ov::Dimension(1, 3),
ov::Dimension(4, 8),
-1,
1,
3});
auto A = std::make_shared<ov::op::v0::Parameter>(element::f32,
PartialShape{Dimension(1, 3), Dimension(4, 8), -1, 1, -1, 1, 3});
auto B = std::make_shared<ov::op::v0::Parameter>(
element::f32,
PartialShape{Dimension(1, 3), Dimension(2, 7), -1, 1, Dimension(1, 3), Dimension(4, 8), -1, 1, 3});
const auto op = std::make_shared<TypeParam>(A, B);
@ -447,19 +425,11 @@ TYPED_TEST_P(ArithmeticOperator, dynamic_shape_intervals_a_rank_smaller_broadcas
TYPED_TEST_P(ArithmeticOperator, dynamic_shape_intervals_b_rank_smaller_broadcast_numpy) {
// `B` rank smaller
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32,
ov::PartialShape{ov::Dimension(1, 3),
ov::Dimension(2, 7),
-1,
1,
ov::Dimension(1, 3),
ov::Dimension(4, 8),
-1,
1,
3});
auto B = std::make_shared<ov::op::v0::Parameter>(
ov::element::f32,
ov::PartialShape{ov::Dimension(1, 3), ov::Dimension(4, 8), -1, 1, -1, 1, 3});
auto A = std::make_shared<ov::op::v0::Parameter>(
element::f32,
PartialShape{Dimension(1, 3), Dimension(2, 7), -1, 1, Dimension(1, 3), Dimension(4, 8), -1, 1, 3});
auto B = std::make_shared<ov::op::v0::Parameter>(element::f32,
PartialShape{Dimension(1, 3), Dimension(4, 8), -1, 1, -1, 1, 3});
const auto op = std::make_shared<TypeParam>(A, B);
@ -478,19 +448,16 @@ TYPED_TEST_P(ArithmeticOperator, dynamic_shape_intervals_b_rank_smaller_broadcas
TYPED_TEST_P(ArithmeticOperator, dynamic_shape_intervals_broadcast_pdpd) {
{ // Equal rank
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32,
ov::PartialShape{ov::Dimension(1, 3),
ov::Dimension(2, 7),
ov::Dimension(1, 6),
/* Dimension(6, -1), */ -1,
8});
auto B = std::make_shared<ov::op::v0::Parameter>(
ov::element::f32,
ov::PartialShape{ov::Dimension(1, 3), ov::Dimension(2, 7), 1, /* 1, */ -1, 8});
auto A = std::make_shared<ov::op::v0::Parameter>(
element::f32,
PartialShape{Dimension(1, 3), Dimension(2, 7), Dimension(1, 6), /* Dimension(6, -1), */ -1, 8});
auto B =
std::make_shared<ov::op::v0::Parameter>(element::f32,
PartialShape{Dimension(1, 3), Dimension(2, 7), 1, /* 1, */ -1, 8});
const auto op = std::make_shared<TypeParam>(A, B, ov::op::AutoBroadcastType::PDPD);
const auto op = std::make_shared<TypeParam>(A, B, op::AutoBroadcastType::PDPD);
EXPECT_EQ(op->get_element_type(), ov::element::f32);
EXPECT_EQ(op->get_element_type(), element::f32);
EXPECT_EQ(op->get_output_partial_shape(0),
(ov::PartialShape{ov::Dimension(1, 3),
ov::Dimension(2, 7),
@ -499,28 +466,14 @@ TYPED_TEST_P(ArithmeticOperator, dynamic_shape_intervals_broadcast_pdpd) {
8}));
}
{ // `A` rank smaller
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32,
ov::PartialShape{ov::Dimension(1, 3),
ov::Dimension(1, 3),
ov::Dimension(1, 3),
ov::Dimension(4, 8),
-1,
1,
-1,
1,
3});
auto B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32,
ov::PartialShape{ov::Dimension(1, 3),
ov::Dimension(2, 7),
-1,
1,
ov::Dimension(1, 3),
ov::Dimension(4, 8),
-1,
1,
3});
auto A = std::make_shared<ov::op::v0::Parameter>(
element::f32,
PartialShape{Dimension(1, 3), Dimension(1, 3), Dimension(1, 3), Dimension(4, 8), -1, 1, -1, 1, 3});
auto B = std::make_shared<ov::op::v0::Parameter>(
element::f32,
PartialShape{Dimension(1, 3), Dimension(2, 7), -1, 1, Dimension(1, 3), Dimension(4, 8), -1, 1, 3});
const auto autob = ov::op::AutoBroadcastSpec(ov::op::AutoBroadcastType::PDPD, 0);
const auto autob = op::AutoBroadcastSpec(op::AutoBroadcastType::PDPD, 0);
const auto op = std::make_shared<TypeParam>(A, B, autob);
EXPECT_EQ(op->get_element_type(), ov::element::f32);
@ -536,19 +489,12 @@ TYPED_TEST_P(ArithmeticOperator, dynamic_shape_intervals_broadcast_pdpd) {
3}));
}
{ // `B` rank smaller
auto A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32,
ov::PartialShape{ov::Dimension(1, 3),
ov::Dimension(2, 7),
-1,
1,
ov::Dimension(1, 3),
ov::Dimension(4, 8),
-1,
1,
3});
auto B = std::make_shared<ov::op::v0::Parameter>(
ov::element::f32,
ov::PartialShape{ov::Dimension(1, 3), ov::Dimension(4, 8), -1, 1, -1, 1, 3});
auto A = std::make_shared<ov::op::v0::Parameter>(
element::f32,
PartialShape{Dimension(1, 3), Dimension(2, 7), -1, 1, Dimension(1, 3), Dimension(4, 8), -1, 1, 3});
auto B =
std::make_shared<ov::op::v0::Parameter>(element::f32,
PartialShape{Dimension(1, 3), Dimension(4, 8), -1, 1, -1, 1, 3});
const auto op = std::make_shared<TypeParam>(A, B);
@ -576,8 +522,9 @@ TYPED_TEST_P(ArithmeticOperator, labels_a_dynamic_mixed_dims_broadcast_numpy) {
set_shape_labels(pshape_A, {10, 11, 12, 13});
set_shape_labels(expected_shape, {10, 11, 0, 13});
auto param_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_B);
auto param_A = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B);
const auto out_shape = op->get_output_partial_shape(0);
@ -596,8 +543,9 @@ TYPED_TEST_P(ArithmeticOperator, labels_b_dynamic_mixed_dims_broadcast_numpy) {
set_shape_labels(pshape_B, {20, 21, 22, 23});
set_shape_labels(expected_shape, {20, 21, 22, 0});
auto param_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_B);
auto param_A = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B);
const auto out_shape = op->get_output_partial_shape(0);
@ -617,8 +565,9 @@ TYPED_TEST_P(ArithmeticOperator, labels_different_interval_mixed_dims_broadcast_
set_shape_labels(pshape_B, {20, 21, 22, 23});
set_shape_labels(expected_shape, {0, 21, 22, 13});
auto param_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_B);
auto param_A = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B);
const auto out_shape = op->get_output_partial_shape(0);
@ -639,8 +588,9 @@ TYPED_TEST_P(ArithmeticOperator, labels_different_interval_b_and_fully_dyn_a_bro
ov::PartialShape expected_shape = {ov::Dimension(2, 4), 3, 224, 224};
ov::TensorLabel expected_labels{20, 0, 0, 0};
auto param_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_B);
auto param_A = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B);
const auto out_shape = op->get_output_partial_shape(0);
@ -661,8 +611,9 @@ TYPED_TEST_P(ArithmeticOperator, labels_different_interval_a_and_fully_dyn_b_bro
ov::PartialShape expected_shape = {ov::Dimension(2, 4), 3, 224, 224};
ov::TensorLabel expected_labels{10, 0, 0, 0};
auto param_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_B);
auto param_A = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B);
const auto out_shape = op->get_output_partial_shape(0);
@ -682,8 +633,9 @@ TYPED_TEST_P(ArithmeticOperator, labels_equal_interval_dims_without_one_broadcas
set_shape_labels(pshape_B, {10, 11, 12, 13});
set_shape_labels(expected_shape, {10, 11, 12, 13});
auto param_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_B);
auto param_A = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B);
const auto out_shape = op->get_output_partial_shape(0);
@ -703,8 +655,9 @@ TYPED_TEST_P(ArithmeticOperator, labels_different_interval_dims_without_one_broa
set_shape_labels(pshape_A, {10, 11, 12, 13});
set_shape_labels(pshape_B, {20, 21, 22, 23});
auto param_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_B);
auto param_A = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B);
const auto out_shape = op->get_output_partial_shape(0);
@ -726,8 +679,9 @@ TYPED_TEST_P(ArithmeticOperator, labels_different_interval_batch_without_one_equ
ov::PartialShape pshape_A = {dim_0_A, 3, 224, 1}, pshape_B = {dim_0_B, 3, 1, 224};
auto param_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_B);
auto param_A = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B);
const auto out_shape = op->get_output_partial_shape(0);
@ -755,8 +709,9 @@ TYPED_TEST_P(ArithmeticOperator, labels_different_fully_dynamic_batch_broadcast_
ov::PartialShape expected_shape = {-1, 3, 224, 224};
ov::TensorLabel expected_labels{0, 0, 0, 0};
auto param_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_B);
auto param_A = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B);
const auto out_shape = op->get_output_partial_shape(0);
@ -777,8 +732,9 @@ TYPED_TEST_P(ArithmeticOperator, labels_equal_fully_dynamic_batch_broadcast_nump
ov::PartialShape expected_shape = {-1, 3, 224, 224};
ov::TensorLabel expected_labels{10, 0, 0, 0};
auto param_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_B);
auto param_A = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B);
const auto out_shape = op->get_output_partial_shape(0);
@ -795,8 +751,9 @@ TYPED_TEST_P(ArithmeticOperator, labels_dyn_batch_a_broadcast_numpy) {
ov::TensorLabel expected_labels{10, 0, 0, 0};
auto param_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f64, A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f64, B);
auto param_A = std::make_shared<ov::op::v0::Parameter>(element::f64, A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(element::f64, B);
const auto op = std::make_shared<TypeParam>(param_A, param_B);
const auto out_shape = op->get_output_partial_shape(0);
@ -813,8 +770,9 @@ TYPED_TEST_P(ArithmeticOperator, labels_dyn_batch_b_broadcast_numpy) {
ov::TensorLabel expected_labels{10, 0, 0, 0};
auto param_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f64, A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f64, B);
auto param_A = std::make_shared<ov::op::v0::Parameter>(element::f64, A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(element::f64, B);
const auto op = std::make_shared<TypeParam>(param_A, param_B);
const auto out_shape = op->get_output_partial_shape(0);
@ -833,8 +791,9 @@ TYPED_TEST_P(ArithmeticOperator, labels_dyn_batch_and_higher_rank_a_broadcast_nu
ov::TensorLabel expected_labels{10, 0, 0, 0};
auto param_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f64, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f64, pshape_B);
auto param_A = std::make_shared<ov::op::v0::Parameter>(element::f64, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(element::f64, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B);
const auto out_shape = op->get_output_partial_shape(0);
@ -853,8 +812,9 @@ TYPED_TEST_P(ArithmeticOperator, labels_dyn_batch_and_higher_rank_b_broadcast_nu
ov::TensorLabel expected_labels{10, 0, 0, 0};
auto param_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f64, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f64, pshape_B);
auto param_A = std::make_shared<ov::op::v0::Parameter>(element::f64, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(element::f64, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B);
const auto out_shape = op->get_output_partial_shape(0);
@ -874,9 +834,9 @@ TYPED_TEST_P(ArithmeticOperator, labels_different_static_shape_broadcast_numpy)
set_shape_labels(pshape_B, {20, 21, 22, 23});
set_shape_labels(expected_shape, {20, 21, 12, 23});
auto param_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B, ov::op::AutoBroadcastType::NUMPY);
auto param_A = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B, op::AutoBroadcastType::NUMPY);
const auto out_shape = op->get_output_partial_shape(0);
@ -895,9 +855,9 @@ TYPED_TEST_P(ArithmeticOperator, labels_equal_static_shape_broadcast_numpy) {
set_shape_labels(pshape_B, {30, 31, 32, 33});
set_shape_labels(expected_shape, {30, 31, 32, 33});
auto param_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B, ov::op::AutoBroadcastType::NUMPY);
auto param_A = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B, op::AutoBroadcastType::NUMPY);
const auto out_shape = op->get_output_partial_shape(0);
@ -916,9 +876,9 @@ TYPED_TEST_P(ArithmeticOperator, labels_different_static_shape_broadcast_none) {
set_shape_labels(pshape_B, {20, 21, 22, 23});
set_shape_labels(expected_shape, {20, 21, 22, 23});
auto param_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B, ov::op::AutoBroadcastType::NONE);
auto param_A = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B, op::AutoBroadcastType::NONE);
auto out_shape = op->get_output_partial_shape(0);
@ -937,9 +897,9 @@ TYPED_TEST_P(ArithmeticOperator, labels_equal_static_shape_broadcast_none) {
set_shape_labels(pshape_B, {30, 31, 32, 33});
set_shape_labels(expected_shape, {30, 31, 32, 33});
auto param_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B, ov::op::AutoBroadcastType::NONE);
auto param_A = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B, op::AutoBroadcastType::NONE);
auto out_shape = op->get_output_partial_shape(0);
@ -958,9 +918,9 @@ TYPED_TEST_P(ArithmeticOperator, labels_different_dynamic_shape_broadcast_none)
set_shape_labels(pshape_B, {20, 21, 22, 23});
set_shape_labels(expected_shape, {20, 21, 22, 23});
auto param_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B, ov::op::AutoBroadcastType::NONE);
auto param_A = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B, op::AutoBroadcastType::NONE);
const auto out_shape = op->get_output_partial_shape(0);
@ -979,9 +939,9 @@ TYPED_TEST_P(ArithmeticOperator, labels_equal_dynamic_shape_broadcast_none) {
set_shape_labels(pshape_B, {30, 31, 32, 33});
set_shape_labels(expected_shape, {30, 31, 32, 33});
auto param_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B, ov::op::AutoBroadcastType::NONE);
auto param_A = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_A);
auto param_B = std::make_shared<ov::op::v0::Parameter>(element::f32, pshape_B);
const auto op = std::make_shared<TypeParam>(param_A, param_B, op::AutoBroadcastType::NONE);
const auto out_shape = op->get_output_partial_shape(0);

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

@ -2,6 +2,8 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/asin.hpp"
#include "unary_ops.hpp"
using Type = ::testing::Types<ov::op::v0::Asin>;

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

@ -2,6 +2,8 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/asinh.hpp"
#include "unary_ops.hpp"
using Type = ::testing::Types<ov::op::v3::Asinh>;

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

@ -2,6 +2,8 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/atan.hpp"
#include "unary_ops.hpp"
using Type = ::testing::Types<ov::op::v0::Atan>;

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

@ -2,6 +2,8 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/atanh.hpp"
#include "unary_ops.hpp"
using Type = ::testing::Types<ov::op::v3::Atanh>;

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

@ -2,6 +2,8 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/ceiling.hpp"
#include "unary_ops.hpp"
using Type = ::testing::Types<ov::op::v0::Ceiling>;

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

@ -2,6 +2,8 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/cos.hpp"
#include "unary_ops.hpp"
using Type = ::testing::Types<ov::op::v0::Cos>;

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

@ -2,6 +2,8 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/cosh.hpp"
#include "unary_ops.hpp"
using Type = ::testing::Types<ov::op::v0::Cosh>;

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

@ -2,6 +2,8 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/erf.hpp"
#include "unary_ops.hpp"
using Type = ::testing::Types<ov::op::v0::Erf>;

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

@ -2,6 +2,8 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/exp.hpp"
#include "unary_ops.hpp"
using Type = ::testing::Types<ov::op::v0::Exp>;

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

@ -2,6 +2,8 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/floor.hpp"
#include "unary_ops.hpp"
using Type = ::testing::Types<ov::op::v0::Floor>;

332
src/core/tests/type_prop/gather.cpp
View File

@ -2,15 +2,19 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/gather.hpp"
#include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp"
#include "ngraph/ngraph.hpp"
#include "openvino/core/dimension_tracker.hpp"
NGRAPH_SUPPRESS_DEPRECATED_START
#include "openvino/op/add.hpp"
#include "openvino/op/broadcast.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/range.hpp"
#include "openvino/op/shape_of.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace testing;
// ------------------------------ V1 ------------------------------
@ -19,9 +23,9 @@ TEST(type_prop, gather_v1_axis_0) {
Shape params_shape{3, 2};
Shape indices_shape{2, 2};
Shape out_shape{2, 2, 2};
auto P = make_shared<op::Parameter>(element::f32, params_shape);
auto I = make_shared<op::Parameter>(element::i32, indices_shape);
auto A = op::Constant::create(element::i64, Shape{}, {0});
auto P = make_shared<ov::op::v0::Parameter>(element::f32, params_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i32, indices_shape);
auto A = ov::op::v0::Constant::create(element::i64, Shape{}, {0});
auto G = make_shared<op::v1::Gather>(P, I, A);
EXPECT_EQ(G->get_element_type(), element::f32);
EXPECT_EQ(G->get_shape(), out_shape);
@ -34,9 +38,9 @@ TEST(type_prop, gather_v1_uint8) {
PartialShape indices_shape{2, 2};
PartialShape out_shape{2, 2, 2};
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::u8, indices_shape);
auto A = op::Constant::create(element::i64, Shape{}, {0});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::u8, indices_shape);
auto A = ov::op::v0::Constant::create(element::i64, Shape{}, {0});
auto G = make_shared<op::v1::Gather>(D, I, A);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -50,9 +54,9 @@ TEST(type_prop, gather_v1_float32) {
PartialShape indices_shape{2, 2};
PartialShape out_shape{2, 2, 2};
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::f32, indices_shape);
auto A = op::Constant::create(element::i64, Shape{}, {0});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::f32, indices_shape);
auto A = ov::op::v0::Constant::create(element::i64, Shape{}, {0});
auto G = make_shared<op::v1::Gather>(D, I, A);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -64,9 +68,9 @@ TEST(type_prop, gather_axis_1) {
Shape params_shape{3, 3};
Shape indices_shape{1, 2};
Shape out_shape{3, 1, 2};
auto P = make_shared<op::Parameter>(element::f32, params_shape);
auto I = make_shared<op::Parameter>(element::i32, indices_shape);
auto A = op::Constant::create(element::i64, Shape{}, {1});
auto P = make_shared<ov::op::v0::Parameter>(element::f32, params_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i32, indices_shape);
auto A = ov::op::v0::Constant::create(element::i64, Shape{}, {1});
auto G = make_shared<op::v1::Gather>(P, I, A);
EXPECT_EQ(G->get_element_type(), element::f32);
EXPECT_EQ(G->get_shape(), out_shape);
@ -74,9 +78,9 @@ TEST(type_prop, gather_axis_1) {
}
TEST(type_prop, gather_v1_incorrect_axis_shape) {
auto params = make_shared<op::Parameter>(element::f32, Shape{5, 6});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto axis = make_shared<op::Parameter>(element::i64, Shape{2});
auto params = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 6});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto axis = make_shared<ov::op::v0::Parameter>(element::i64, Shape{2});
OV_EXPECT_THROW(auto g = make_shared<op::v1::Gather>(params, indices, axis),
NodeValidationFailure,
@ -84,9 +88,9 @@ TEST(type_prop, gather_v1_incorrect_axis_shape) {
}
TEST(type_prop, gather_v1_axis_out_of_input_rank) {
auto params = make_shared<op::Parameter>(element::f32, Shape{5, 6});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto axis = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{2});
auto params = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 6});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto axis = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{2});
OV_EXPECT_THROW(auto g = make_shared<op::v1::Gather>(params, indices, axis),
ov::AssertFailure,
@ -94,10 +98,10 @@ TEST(type_prop, gather_v1_axis_out_of_input_rank) {
}
TEST(type_prop, gather_v1_negative_axis) {
auto params = make_shared<op::Parameter>(element::f32, Shape{5, 6, 7});
auto indices = make_shared<op::Parameter>(element::i64, Shape{4});
auto params = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 6, 7});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
int64_t axis = -2;
auto axis_node = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto axis_node = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto gather_v1 = make_shared<op::v1::Gather>(params, indices, axis_node);
EXPECT_EQ(gather_v1->get_axis(), 1);
}
@ -107,9 +111,9 @@ TEST(type_prop, gather_1_dynamic_value_and_label_propagation) {
ov::DimensionTracker::set_label(marked_0, 10);
PartialShape target_0 = PartialShape{marked_0, 4};
auto param = std::make_shared<op::Parameter>(element::f32, Shape{1});
auto param_0 = std::make_shared<op::Parameter>(element::f32, target_0);
auto shape_0 = std::make_shared<op::ShapeOf>(param_0);
auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
auto param_0 = std::make_shared<ov::op::v0::Parameter>(element::f32, target_0);
auto shape_0 = std::make_shared<op::v0::ShapeOf>(param_0);
const auto& et = element::i64;
std::vector<int64_t> zero{0};
@ -125,21 +129,21 @@ TEST(type_prop, gather_1_dynamic_value_and_label_propagation) {
}
TEST(type_prop, dynamic_value_propagation) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{-1, 3, -1, -1});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{-1, 3, -1, -1});
auto shape_of = std::make_shared<op::v3::ShapeOf>(param, element::i32);
auto indices = op::Constant::create(element::i32, {}, {1});
auto axis = op::Constant::create(element::i32, {}, {0});
auto indices = ov::op::v0::Constant::create(element::i32, {}, {1});
auto axis = ov::op::v0::Constant::create(element::i32, {}, {0});
auto gather = std::make_shared<op::v1::Gather>(shape_of, indices, axis);
auto add = std::make_shared<op::v1::Add>(gather, op::Constant::create(element::i32, {}, {0}));
auto add = std::make_shared<op::v1::Add>(gather, ov::op::v0::Constant::create(element::i32, {}, {0}));
auto range = std::make_shared<op::v4::Range>(op::Constant::create(element::i32, {}, {0}),
auto range = std::make_shared<op::v4::Range>(ov::op::v0::Constant::create(element::i32, {}, {0}),
add,
op::Constant::create(element::i32, {}, {1}),
ov::op::v0::Constant::create(element::i32, {}, {1}),
element::i64);
auto RIC = std::make_shared<op::v1::Gather>(param, range, op::Constant::create(element::i32, {}, {1}));
auto RIC = std::make_shared<op::v1::Gather>(param, range, ov::op::v0::Constant::create(element::i32, {}, {1}));
EXPECT_EQ(RIC->get_element_type(), element::f32);
EXPECT_EQ(RIC->get_output_partial_shape(0), (PartialShape{-1, 3, -1, -1}));
@ -153,9 +157,9 @@ TEST(type_prop, gather_7_axis_0) {
PartialShape out_shape{2, 2, 2};
int64_t batch_dims = 0;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i32, indices_shape);
auto A = op::Constant::create(element::i64, Shape{}, {0});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i32, indices_shape);
auto A = ov::op::v0::Constant::create(element::i64, Shape{}, {0});
auto G = make_shared<op::v7::Gather>(D, I, A, batch_dims);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -169,9 +173,9 @@ TEST(type_prop, gather_7_axis_1) {
PartialShape out_shape{3, 1, 2};
int64_t axis = 1;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i32, indices_shape);
auto A = op::Constant::create(element::i64, Shape{}, {axis});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i32, indices_shape);
auto A = ov::op::v0::Constant::create(element::i64, Shape{}, {axis});
auto G = make_shared<op::v7::Gather>(D, I, A);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -185,9 +189,9 @@ TEST(type_prop, gather_7_negative_axis) {
PartialShape out_shape{5, 4, 7};
int64_t axis = -2;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto G = make_shared<op::v7::Gather>(D, I, A);
EXPECT_EQ(G->get_axis(), 1);
@ -201,9 +205,9 @@ TEST(type_prop, gather_7_dynamic_pshape_batch_dims_1_axis_1) {
int64_t axis = 1;
int64_t batch_dims = 1;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto G = make_shared<op::v7::Gather>(D, I, A, batch_dims);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -217,9 +221,9 @@ TEST(type_prop, gather_7_dynamic_pshape_batch_dims_1_axis_3) {
int64_t axis = 3;
int64_t batch_dims = 1;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto G = make_shared<op::v7::Gather>(D, I, A, batch_dims);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -233,9 +237,9 @@ TEST(type_prop, gather_7_dynamic_2d_pshape_batch_dim) {
int64_t axis = 2;
int64_t batch_dims = 2;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto G = make_shared<op::v7::Gather>(D, I, A, batch_dims);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -249,9 +253,9 @@ TEST(type_prop, gather_7_dynamic_2d_pshape_batch_dim_axis_3) {
int64_t axis = 3;
int64_t batch_dims = 2;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto G = make_shared<op::v7::Gather>(D, I, A, batch_dims);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -265,9 +269,9 @@ TEST(type_prop, gather_7_dynamic_rank) {
int64_t axis = 3;
int64_t batch_dims = 2;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto G = make_shared<op::v7::Gather>(D, I, A, batch_dims);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -281,9 +285,9 @@ TEST(type_prop, gather_7_axis_boundcheck_for_dynamic_data_rank) {
int64_t axis = 3;
int64_t batch_dims = 2;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto G = make_shared<op::v7::Gather>(D, I, A, batch_dims);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -297,9 +301,9 @@ TEST(type_prop, gather_7_dynamic_rank_negative_batch_dims) {
int64_t axis = 3;
int64_t batch_dims = -2;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto G = make_shared<op::v7::Gather>(D, I, A, batch_dims);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -312,9 +316,9 @@ TEST(type_prop, gather_7_axis_not_set) {
// default batch_dims = 0
PartialShape out_shape = PartialShape::dynamic(5); // out_rank = data_rank + indices_rank - 1 - batch_dims
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Parameter>(element::i32, Shape{1});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Parameter>(element::i32, Shape{1});
auto G = make_shared<op::v7::Gather>(D, I, A);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -327,9 +331,9 @@ TEST(type_prop, gather_7_axis_not_set_positive_batch_dims) {
int64_t batch_dims = 1;
PartialShape out_shape = PartialShape({2, Dimension::dynamic(), Dimension::dynamic(), Dimension::dynamic()});
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Parameter>(element::i32, Shape{1});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Parameter>(element::i32, Shape{1});
auto G = make_shared<op::v7::Gather>(D, I, A, batch_dims);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -341,9 +345,9 @@ TEST(type_prop, gather_7_dynamic_value_and_label_propagation) {
ov::DimensionTracker::set_label(marked_0, 10);
PartialShape target_0 = PartialShape{marked_0, 4};
auto param = std::make_shared<op::Parameter>(element::f32, Shape{1});
auto param_0 = std::make_shared<op::Parameter>(element::f32, target_0);
auto shape_0 = std::make_shared<op::ShapeOf>(param_0);
auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
auto param_0 = std::make_shared<ov::op::v0::Parameter>(element::f32, target_0);
auto shape_0 = std::make_shared<op::v0::ShapeOf>(param_0);
const auto& et = element::i64;
std::vector<int64_t> zero{0};
@ -361,9 +365,9 @@ TEST(type_prop, gather_7_dynamic_value_and_label_propagation) {
// --------------------- V7 Negative tests ------------------------------
TEST(type_prop, gather_7_incorrect_axis_shape) {
auto D = make_shared<op::Parameter>(element::f32, Shape{5, 6});
auto I = make_shared<op::Parameter>(element::i64, Shape{4});
auto A = make_shared<op::Parameter>(element::i64, Shape{2});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 6});
auto I = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto A = make_shared<ov::op::v0::Parameter>(element::i64, Shape{2});
OV_EXPECT_THROW(auto g = make_shared<op::v7::Gather>(D, I, A),
NodeValidationFailure,
@ -371,9 +375,9 @@ TEST(type_prop, gather_7_incorrect_axis_shape) {
}
TEST(type_prop, gather_7_axis_out_of_input_rank) {
auto D = make_shared<op::Parameter>(element::f32, Shape{5, 6});
auto I = make_shared<op::Parameter>(element::i64, Shape{4});
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{2});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 6});
auto I = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{2});
int64_t batch_dims = 0;
OV_EXPECT_THROW(auto g = make_shared<op::v7::Gather>(D, I, A, batch_dims),
@ -385,10 +389,10 @@ TEST(type_prop, gather_7_dynamic_batch_dims_inconsistent) {
PartialShape data_shape{Dimension(1, 7), 20, 20};
PartialShape indices_shape{Dimension(8, 10), 3, 8};
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
int64_t axis = 1;
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
int64_t batch_dims = 1;
OV_EXPECT_THROW(auto g = make_shared<op::v7::Gather>(D, I, A, batch_dims),
@ -400,10 +404,10 @@ TEST(type_prop, gather_7_batch_dims_less_check) {
PartialShape data_shape{1, 3, 20};
PartialShape indices_shape{1, 3, 8};
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
int64_t axis = 1;
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
int64_t batch_dims = 2;
OV_EXPECT_THROW(auto g = make_shared<op::v7::Gather>(D, I, A, batch_dims),
@ -415,10 +419,10 @@ TEST(type_prop, gather_7_batch_dims_less_indices_rank_check) {
PartialShape data_shape{1, 20, 20, 22, 22};
PartialShape indices_shape{1, 3};
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
int64_t axis = 4;
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
int64_t batch_dims = 3;
OV_EXPECT_THROW(auto g = make_shared<op::v7::Gather>(D, I, A, batch_dims),
@ -430,10 +434,10 @@ TEST(type_prop, gather_7_indices_type_check) {
PartialShape data_shape{1, 20, 20, 22, 22};
PartialShape indices_shape{1, 3};
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::f32, indices_shape);
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::f32, indices_shape);
int64_t axis = 4;
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
int64_t batch_dims = 0;
OV_EXPECT_THROW(auto g = make_shared<op::v7::Gather>(D, I, A, batch_dims),
@ -445,10 +449,10 @@ TEST(type_prop, gather_7_axis_type_check) {
PartialShape data_shape{1, 20, 20, 22, 22};
PartialShape indices_shape{1, 3};
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i32, indices_shape);
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i32, indices_shape);
int64_t axis = 4;
auto A = make_shared<op::Constant>(element::f32, Shape{1}, vector<int64_t>{axis});
auto A = make_shared<ov::op::v0::Constant>(element::f32, Shape{1}, vector<int64_t>{axis});
int64_t batch_dims = 0;
OV_EXPECT_THROW(auto g = make_shared<op::v7::Gather>(D, I, A, batch_dims),
@ -464,9 +468,9 @@ TEST(type_prop, gather_v8_axis_0) {
PartialShape out_shape{2, 2, 2};
int64_t batch_dims = 0;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i32, indices_shape);
auto A = op::Constant::create(element::i64, Shape{}, {0});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i32, indices_shape);
auto A = ov::op::v0::Constant::create(element::i64, Shape{}, {0});
auto G = make_shared<op::v8::Gather>(D, I, A, batch_dims);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -480,9 +484,9 @@ TEST(type_prop, gather_v8_axis_1) {
PartialShape out_shape{3, 1, 2};
int64_t axis = 1;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i32, indices_shape);
auto A = op::Constant::create(element::i64, Shape{}, {axis});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i32, indices_shape);
auto A = ov::op::v0::Constant::create(element::i64, Shape{}, {axis});
auto G = make_shared<op::v8::Gather>(D, I, A);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -496,9 +500,9 @@ TEST(type_prop, gather_v8_negative_axis) {
PartialShape out_shape{5, 4, 7};
int64_t axis = -2;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto G = make_shared<op::v8::Gather>(D, I, A);
EXPECT_EQ(G->get_axis(), 1);
@ -512,9 +516,9 @@ TEST(type_prop, gather_v8_dynamic_pshape_batch_dims_1_axis_1) {
int64_t axis = 1;
int64_t batch_dims = 1;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto G = make_shared<op::v8::Gather>(D, I, A, batch_dims);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -528,9 +532,9 @@ TEST(type_prop, gather_v8_dynamic_pshape_batch_dims_1_axis_3) {
int64_t axis = 3;
int64_t batch_dims = 1;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto G = make_shared<op::v8::Gather>(D, I, A, batch_dims);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -544,9 +548,9 @@ TEST(type_prop, gather_v8_dim_no_bound_pshape_batch_dims_1_axis_3) {
int64_t axis = 3;
int64_t batch_dims = 1;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto G = make_shared<op::v8::Gather>(D, I, A, batch_dims);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -560,9 +564,9 @@ TEST(type_prop, gather_v8_dynamic_2d_pshape_batch_dim) {
int64_t axis = 2;
int64_t batch_dims = 2;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto G = make_shared<op::v8::Gather>(D, I, A, batch_dims);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -576,9 +580,9 @@ TEST(type_prop, gather_v8_dynamic_2d_pshape_batch_dim_axis_3) {
int64_t axis = 3;
int64_t batch_dims = 2;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto G = make_shared<op::v8::Gather>(D, I, A, batch_dims);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -592,9 +596,9 @@ TEST(type_prop, gather_v8_dynamic_rank) {
int64_t axis = 3;
int64_t batch_dims = 2;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto G = make_shared<op::v8::Gather>(D, I, A, batch_dims);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -608,9 +612,9 @@ TEST(type_prop, gather_v8_axis_boundcheck_for_dynamic_data_rank) {
int64_t axis = 3;
int64_t batch_dims = 2;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto G = make_shared<op::v8::Gather>(D, I, A, batch_dims);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -624,9 +628,9 @@ TEST(type_prop, gather_v8_dynamic_rank_negative_batch_dims) {
int64_t axis = 3;
int64_t batch_dims = -2;
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto G = make_shared<op::v8::Gather>(D, I, A, batch_dims);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -639,9 +643,9 @@ TEST(type_prop, gather_v8_axis_not_set) {
// default batch_dims = 0
PartialShape out_shape = PartialShape::dynamic(5); // out_rank = data_rank + indices_rank - 1 - batch_dims
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Parameter>(element::i32, Shape{1});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Parameter>(element::i32, Shape{1});
auto G = make_shared<op::v8::Gather>(D, I, A);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -654,9 +658,9 @@ TEST(type_prop, gather_v8_axis_not_set_positive_batch_dims) {
int64_t batch_dims = 1;
PartialShape out_shape = PartialShape({2, Dimension::dynamic(), Dimension::dynamic(), Dimension::dynamic()});
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto A = make_shared<op::Parameter>(element::i32, Shape{1});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
auto A = make_shared<ov::op::v0::Parameter>(element::i32, Shape{1});
auto G = make_shared<op::v8::Gather>(D, I, A, batch_dims);
EXPECT_EQ(G->get_element_type(), element::f32);
@ -669,9 +673,9 @@ TEST(type_prop, gather_v8_dynamic_value_and_label_propagation) {
ov::DimensionTracker::set_label(marked_0, 10);
PartialShape target_0 = PartialShape{marked_0, 4};
auto param = std::make_shared<op::Parameter>(element::f32, Shape{1});
auto param_0 = std::make_shared<op::Parameter>(element::f32, target_0);
auto shape_0 = std::make_shared<op::ShapeOf>(param_0);
auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
auto param_0 = std::make_shared<ov::op::v0::Parameter>(element::f32, target_0);
auto shape_0 = std::make_shared<op::v0::ShapeOf>(param_0);
const auto& et = element::i64;
std::vector<int64_t> zero{0};
@ -692,9 +696,9 @@ TEST(type_prop, gather_v8_dynamic_value_and_label_propagation_interval_dim) {
ov::DimensionTracker::set_label(marked_0, 10);
PartialShape target_0 = PartialShape{marked_0, 4};
auto param = std::make_shared<op::Parameter>(element::f32, Shape{1});
auto param_0 = std::make_shared<op::Parameter>(element::f32, target_0);
auto shape_0 = std::make_shared<op::ShapeOf>(param_0);
auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
auto param_0 = std::make_shared<ov::op::v0::Parameter>(element::f32, target_0);
auto shape_0 = std::make_shared<op::v0::ShapeOf>(param_0);
const auto& et = element::i64;
std::vector<int64_t> zero{0};
@ -710,9 +714,9 @@ TEST(type_prop, gather_v8_dynamic_value_and_label_propagation_interval_dim) {
}
TEST(type_prop, gather_v8_use_default_ctor) {
auto D = make_shared<op::Parameter>(element::f32, PartialShape{2, 1, 200, 400});
auto I = make_shared<op::Parameter>(element::i64, PartialShape{2, 2});
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{-1});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 1, 200, 400});
auto I = make_shared<ov::op::v0::Parameter>(element::i64, PartialShape{2, 2});
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{-1});
constexpr int64_t batch_dims = 1;
auto G = make_shared<op::v8::Gather>();
@ -729,9 +733,9 @@ TEST(type_prop, gather_v8_use_default_ctor) {
// --------------------- V8 Negative tests ------------------------------
TEST(type_prop, gather_v8_incorrect_axis_shape) {
auto D = make_shared<op::Parameter>(element::f32, Shape{5, 6});
auto I = make_shared<op::Parameter>(element::i64, Shape{4});
auto A = make_shared<op::Parameter>(element::i64, Shape{2});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 6});
auto I = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto A = make_shared<ov::op::v0::Parameter>(element::i64, Shape{2});
OV_EXPECT_THROW(auto g = make_shared<op::v7::Gather>(D, I, A),
NodeValidationFailure,
@ -739,9 +743,9 @@ TEST(type_prop, gather_v8_incorrect_axis_shape) {
}
TEST(type_prop, gather_v8_axis_out_of_input_rank) {
auto D = make_shared<op::Parameter>(element::f32, Shape{5, 6});
auto I = make_shared<op::Parameter>(element::i64, Shape{4});
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{2});
auto D = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 6});
auto I = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{2});
int64_t batch_dims = 0;
OV_EXPECT_THROW(auto g = make_shared<op::v8::Gather>(D, I, A, batch_dims),
@ -753,10 +757,10 @@ TEST(type_prop, gather_v8_dynamic_batch_dims_inconsistent) {
PartialShape data_shape{Dimension(1, 7), 20, 20};
PartialShape indices_shape{Dimension(8, 10), 3, 8};
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
int64_t axis = 1;
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
int64_t batch_dims = 1;
OV_EXPECT_THROW(auto g = make_shared<op::v7::Gather>(D, I, A, batch_dims),
@ -768,10 +772,10 @@ TEST(type_prop, gather_v8_batch_dims_less_check) {
PartialShape data_shape{1, 3, 20};
PartialShape indices_shape{1, 3, 8};
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
int64_t axis = 1;
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
int64_t batch_dims = 2;
OV_EXPECT_THROW(auto g = make_shared<op::v7::Gather>(D, I, A, batch_dims),
@ -783,10 +787,10 @@ TEST(type_prop, gather_v8_batch_dims_less_indices_rank_check) {
PartialShape data_shape{1, 20, 20, 22, 22};
PartialShape indices_shape{1, 3};
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i64, indices_shape);
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i64, indices_shape);
int64_t axis = 4;
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
int64_t batch_dims = 3;
OV_EXPECT_THROW(auto g = make_shared<op::v7::Gather>(D, I, A, batch_dims),
@ -798,10 +802,10 @@ TEST(type_prop, gather_v8_indices_type_check) {
PartialShape data_shape{1, 20, 20, 22, 22};
PartialShape indices_shape{1, 3};
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::f32, indices_shape);
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::f32, indices_shape);
int64_t axis = 4;
auto A = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
auto A = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, vector<int64_t>{axis});
int64_t batch_dims = 0;
OV_EXPECT_THROW(auto g = make_shared<op::v7::Gather>(D, I, A, batch_dims),
@ -813,10 +817,10 @@ TEST(type_prop, gather_v8_axis_type_check) {
PartialShape data_shape{1, 20, 20, 22, 22};
PartialShape indices_shape{1, 3};
auto D = make_shared<op::Parameter>(element::f32, data_shape);
auto I = make_shared<op::Parameter>(element::i32, indices_shape);
auto D = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i32, indices_shape);
int64_t axis = 4;
auto A = make_shared<op::Constant>(element::f32, Shape{1}, vector<int64_t>{axis});
auto A = make_shared<ov::op::v0::Constant>(element::f32, Shape{1}, vector<int64_t>{axis});
int64_t batch_dims = 0;
OV_EXPECT_THROW(auto g = make_shared<op::v7::Gather>(D, I, A, batch_dims),

3
src/core/tests/type_prop/gather_elements.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/gather_nd.cpp
View File

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

24
src/core/tests/type_prop/gather_tree.cpp
View File

@ -2,17 +2,17 @@
// SPDX-License-Identifier: Apache-2.0
//
#include <gtest/gtest.h>
#include <array>
#include <utility>
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/core/dimension_tracker.hpp"
#include "openvino/op/ops.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace testing;
namespace {
@ -32,12 +32,14 @@ std::shared_ptr<Node> makeGatherTreeOp(const GatherTreeInputParams& p) {
if (p.size() != gather_tree_required_inputs) {
throw runtime_error("GatherTree requires 4 inputs");
}
auto step_ids = make_shared<op::Parameter>(p.at(step_ids_input_idx).in_et, p.at(step_ids_input_idx).in_pshape);
auto step_ids =
make_shared<ov::op::v0::Parameter>(p.at(step_ids_input_idx).in_et, p.at(step_ids_input_idx).in_pshape);
auto parent_idx =
make_shared<op::Parameter>(p.at(parent_idx_input_idx).in_et, p.at(parent_idx_input_idx).in_pshape);
make_shared<ov::op::v0::Parameter>(p.at(parent_idx_input_idx).in_et, p.at(parent_idx_input_idx).in_pshape);
auto max_seq_len =
make_shared<op::Parameter>(p.at(max_seq_len_input_idx).in_et, p.at(max_seq_len_input_idx).in_pshape);
auto end_token = make_shared<op::Parameter>(p.at(end_token_input_idx).in_et, p.at(end_token_input_idx).in_pshape);
make_shared<ov::op::v0::Parameter>(p.at(max_seq_len_input_idx).in_et, p.at(max_seq_len_input_idx).in_pshape);
auto end_token =
make_shared<ov::op::v0::Parameter>(p.at(end_token_input_idx).in_et, p.at(end_token_input_idx).in_pshape);
return make_shared<op::v1::GatherTree>(step_ids, parent_idx, max_seq_len, end_token);
}
} // namespace
@ -45,10 +47,10 @@ std::shared_ptr<Node> makeGatherTreeOp(const GatherTreeInputParams& p) {
TEST(type_prop, gather_tree_default_constructor) {
auto op = std::make_shared<op::v1::GatherTree>();
auto step_ids = std::make_shared<op::Parameter>(element::i32, PartialShape{2, 4, 3});
auto parent_idx = std::make_shared<op::Parameter>(element::i32, PartialShape{2, 4, 3});
auto max_seq_len = std::make_shared<op::Parameter>(element::i32, PartialShape{4});
auto end_token = std::make_shared<op::Parameter>(element::i32, PartialShape{});
auto step_ids = std::make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{2, 4, 3});
auto parent_idx = std::make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{2, 4, 3});
auto max_seq_len = std::make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{4});
auto end_token = std::make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{});
op->set_argument(0, step_ids);
op->set_argument(1, parent_idx);

40
src/core/tests/type_prop/gelu.cpp
View File

@ -2,17 +2,19 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/gelu.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;
// ------------------------------ V0 ------------------------------
TEST(type_prop, gelu_v0) {
const PartialShape param_shape{64, Dimension::dynamic(), 256, Dimension(4, 8)};
const auto param = std::make_shared<op::Parameter>(element::f32, param_shape);
const auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, param_shape);
const auto op = std::make_shared<op::v0::Gelu>(param);
ASSERT_EQ(op->get_element_type(), element::f32);
ASSERT_EQ(op->get_output_partial_shape(0), param_shape);
@ -20,7 +22,7 @@ TEST(type_prop, gelu_v0) {
// ------------------------------ V7 ------------------------------
TEST(type_prop, gelu_default_mode_inference_f32) {
auto param = make_shared<op::Parameter>(element::f32, Shape{1, 32, 32});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 32, 32});
auto gelu = make_shared<op::v7::Gelu>(param);
ASSERT_EQ(gelu->get_element_type(), element::f32);
@ -29,7 +31,7 @@ TEST(type_prop, gelu_default_mode_inference_f32) {
}
TEST(type_prop, gelu_default_mode_inference_f16) {
auto param = make_shared<op::Parameter>(element::f16, Shape{1, 32, 32});
auto param = make_shared<ov::op::v0::Parameter>(element::f16, Shape{1, 32, 32});
auto gelu = make_shared<op::v7::Gelu>(param);
ASSERT_EQ(gelu->get_element_type(), element::f16);
@ -38,7 +40,7 @@ TEST(type_prop, gelu_default_mode_inference_f16) {
}
TEST(type_prop, gelu_tanh_mode_inference_f32) {
auto param = make_shared<op::Parameter>(element::f32, Shape{1, 32, 32});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 32, 32});
auto gelu = make_shared<op::v7::Gelu>(param, op::GeluApproximationMode::TANH);
ASSERT_EQ(gelu->get_element_type(), element::f32);
@ -47,7 +49,7 @@ TEST(type_prop, gelu_tanh_mode_inference_f32) {
}
TEST(type_prop, gelu_tanh_mode_inference_f16) {
auto param = make_shared<op::Parameter>(element::f16, Shape{1, 32, 32});
auto param = make_shared<ov::op::v0::Parameter>(element::f16, Shape{1, 32, 32});
auto gelu = make_shared<op::v7::Gelu>(param, op::GeluApproximationMode::TANH);
ASSERT_EQ(gelu->get_element_type(), element::f16);
@ -56,41 +58,41 @@ TEST(type_prop, gelu_tanh_mode_inference_f16) {
}
TEST(type_prop, gelu_incompatible_input_type_boolean) {
auto param = make_shared<op::Parameter>(element::boolean, Shape{1, 32, 32});
ASSERT_THROW(const auto unused = std::make_shared<op::v7::Gelu>(param), ngraph::NodeValidationFailure);
auto param = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{1, 32, 32});
ASSERT_THROW(const auto unused = std::make_shared<op::v7::Gelu>(param), ov::NodeValidationFailure);
}
TEST(type_prop, gelu_incompatible_input_type_u16) {
auto param = make_shared<op::Parameter>(element::u16, Shape{1, 32, 32});
ASSERT_THROW(const auto unused = std::make_shared<op::v7::Gelu>(param), ngraph::NodeValidationFailure);
auto param = make_shared<ov::op::v0::Parameter>(element::u16, Shape{1, 32, 32});
ASSERT_THROW(const auto unused = std::make_shared<op::v7::Gelu>(param), ov::NodeValidationFailure);
}
TEST(type_prop, gelu_incompatible_input_type_i32) {
auto param = make_shared<op::Parameter>(element::i32, Shape{1, 32, 32});
ASSERT_THROW(const auto unused = std::make_shared<op::v7::Gelu>(param), ngraph::NodeValidationFailure);
auto param = make_shared<ov::op::v0::Parameter>(element::i32, Shape{1, 32, 32});
ASSERT_THROW(const auto unused = std::make_shared<op::v7::Gelu>(param), ov::NodeValidationFailure);
}
TEST(type_prop, gelu_incompatible_input_type_i16) {
auto param = make_shared<op::Parameter>(element::i16, Shape{1, 32, 32});
ASSERT_THROW(const auto unused = std::make_shared<op::v7::Gelu>(param), ngraph::NodeValidationFailure);
auto param = make_shared<ov::op::v0::Parameter>(element::i16, Shape{1, 32, 32});
ASSERT_THROW(const auto unused = std::make_shared<op::v7::Gelu>(param), ov::NodeValidationFailure);
}
TEST(type_prop, gelu_dynamic_rank_input_shape_2D) {
const PartialShape param_shape{Dimension::dynamic(), 10};
const auto param = std::make_shared<op::Parameter>(element::f32, param_shape);
const auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, param_shape);
const auto op = std::make_shared<op::v7::Gelu>(param);
ASSERT_TRUE(op->get_output_partial_shape(0).same_scheme(PartialShape{Dimension(), 10}));
}
TEST(type_prop, gelu_dynamic_rank_input_shape_3D) {
const PartialShape param_shape{100, Dimension::dynamic(), 58};
const auto param = std::make_shared<op::Parameter>(element::f32, param_shape);
const auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, param_shape);
const auto op = std::make_shared<op::v7::Gelu>(param);
ASSERT_TRUE(op->get_output_partial_shape(0).same_scheme(PartialShape{100, Dimension(), 58}));
}
TEST(type_prop, gelu_dynamic_rank_input_shape_full) {
const auto param = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
const auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
const auto op = std::make_shared<op::v7::Gelu>(param);
ASSERT_TRUE(op->get_output_partial_shape(0).same_scheme(PartialShape::dynamic()));
}

80
src/core/tests/type_prop/generate_proposals.cpp
View File

@ -2,13 +2,15 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/generate_proposals.hpp"
#include <gtest/gtest.h>
#include <vector>
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
using namespace ngraph;
using namespace ov;
using namespace testing;
using GenerateProposals = op::v9::GenerateProposals;
@ -37,10 +39,10 @@ TEST(type_prop, generate_proposals_default_ctor) {
attrs.post_nms_count = static_cast<int64_t>(s.post_nms_count);
attrs.pre_nms_count = 1000;
auto im_info = std::make_shared<op::Parameter>(element::f32, s.im_info_shape);
auto anchors = std::make_shared<op::Parameter>(element::f32, s.anchors_shape);
auto deltas = std::make_shared<op::Parameter>(element::f32, s.deltas_shape);
auto scores = std::make_shared<op::Parameter>(element::f32, s.scores_shape);
auto im_info = std::make_shared<ov::op::v0::Parameter>(element::f32, s.im_info_shape);
auto anchors = std::make_shared<ov::op::v0::Parameter>(element::f32, s.anchors_shape);
auto deltas = std::make_shared<ov::op::v0::Parameter>(element::f32, s.deltas_shape);
auto scores = std::make_shared<ov::op::v0::Parameter>(element::f32, s.scores_shape);
auto proposals = std::make_shared<GenerateProposals>();
proposals->set_arguments(OutputVector{im_info, anchors, deltas, scores});
@ -65,10 +67,10 @@ TEST(type_prop, generate_proposals) {
const auto dyn_dim = Dimension::dynamic();
auto im_info = std::make_shared<op::Parameter>(element::f32, Shape{1, 4});
auto anchors = std::make_shared<op::Parameter>(element::f32, Shape{200, 336, 3, 4});
auto deltas = std::make_shared<op::Parameter>(element::f32, Shape{1, 12, 200, 336});
auto scores = std::make_shared<op::Parameter>(element::f32, Shape{1, 3, 200, 336});
auto im_info = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4});
auto anchors = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{200, 336, 3, 4});
auto deltas = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 12, 200, 336});
auto scores = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 200, 336});
auto proposals = std::make_shared<GenerateProposals>(im_info, anchors, deltas, scores, attrs);
@ -79,10 +81,10 @@ TEST(type_prop, generate_proposals) {
EXPECT_EQ(proposals->get_output_partial_shape(1), (PartialShape{{0, 1000}}));
EXPECT_EQ(proposals->get_output_partial_shape(2), (PartialShape{1}));
im_info = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic(2));
anchors = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic(4));
deltas = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic(4));
scores = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic(4));
im_info = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(2));
anchors = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(4));
deltas = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(4));
scores = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(4));
proposals = std::make_shared<GenerateProposals>(im_info, anchors, deltas, scores, attrs, element::i32);
@ -94,46 +96,46 @@ TEST(type_prop, generate_proposals) {
EXPECT_EQ(proposals->get_output_partial_shape(2), (PartialShape{dyn_dim}));
// assert throw
im_info = std::make_shared<op::Parameter>(element::f32, Shape{1, 4});
anchors = std::make_shared<op::Parameter>(element::f32, Shape{100, 336, 3, 4});
deltas = std::make_shared<op::Parameter>(element::f32, Shape{1, 12, 200, 336});
scores = std::make_shared<op::Parameter>(element::f32, Shape{1, 3, 200, 336});
im_info = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4});
anchors = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{100, 336, 3, 4});
deltas = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 12, 200, 336});
scores = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 200, 336});
ASSERT_THROW(proposals = std::make_shared<GenerateProposals>(im_info, anchors, deltas, scores, attrs, element::i32),
ngraph::CheckFailure)
<< "GenerateProposals node was created with invalid data.";
im_info = std::make_shared<op::Parameter>(element::f32, Shape{1, 4});
anchors = std::make_shared<op::Parameter>(element::f32, Shape{200, 336, 3, 4});
deltas = std::make_shared<op::Parameter>(element::f32, Shape{1, 12, 200, 300});
scores = std::make_shared<op::Parameter>(element::f32, Shape{1, 3, 200, 336});
im_info = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4});
anchors = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{200, 336, 3, 4});
deltas = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 12, 200, 300});
scores = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 200, 336});
ASSERT_THROW(proposals = std::make_shared<GenerateProposals>(im_info, anchors, deltas, scores, attrs, element::i32),
ngraph::CheckFailure)
<< "GenerateProposals node was created with invalid data.";
im_info = std::make_shared<op::Parameter>(element::f32, Shape{1, 4});
anchors = std::make_shared<op::Parameter>(element::f32, Shape{200, 336, 3, 4});
deltas = std::make_shared<op::Parameter>(element::f32, Shape{1, 12, 200, 336});
scores = std::make_shared<op::Parameter>(element::f32, Shape{1, 4, 200, 336});
im_info = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4});
anchors = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{200, 336, 3, 4});
deltas = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 12, 200, 336});
scores = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4, 200, 336});
ASSERT_THROW(proposals = std::make_shared<GenerateProposals>(im_info, anchors, deltas, scores, attrs, element::i32),
ngraph::CheckFailure)
<< "GenerateProposals node was created with invalid data.";
im_info = std::make_shared<op::Parameter>(element::f32, Shape{1, 2});
anchors = std::make_shared<op::Parameter>(element::f32, Shape{200, 336, 3, 4});
deltas = std::make_shared<op::Parameter>(element::f32, Shape{1, 12, 200, 336});
scores = std::make_shared<op::Parameter>(element::f32, Shape{1, 4, 200, 336});
im_info = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2});
anchors = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{200, 336, 3, 4});
deltas = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 12, 200, 336});
scores = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4, 200, 336});
ASSERT_THROW(proposals = std::make_shared<GenerateProposals>(im_info, anchors, deltas, scores, attrs, element::i32),
ngraph::CheckFailure)
<< "GenerateProposals node was created with invalid data.";
im_info = std::make_shared<op::Parameter>(element::f32, Shape{2, 4});
anchors = std::make_shared<op::Parameter>(element::f32, Shape{200, 336, 3, 4});
deltas = std::make_shared<op::Parameter>(element::f32, Shape{1, 12, 200, 336});
scores = std::make_shared<op::Parameter>(element::f32, Shape{1, 4, 200, 336});
im_info = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
anchors = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{200, 336, 3, 4});
deltas = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 12, 200, 336});
scores = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4, 200, 336});
ASSERT_THROW(proposals = std::make_shared<GenerateProposals>(im_info, anchors, deltas, scores, attrs, element::i32),
ngraph::CheckFailure)
@ -285,10 +287,10 @@ TEST(type_prop, generate_proposals_dynamic) {
? 10
: s.deltas_shape.rank().is_static() ? 30 : s.scores_shape.rank().is_static() ? 40 : ov::no_label;
auto im_info = std::make_shared<op::Parameter>(element::f32, s.im_info_shape);
auto anchors = std::make_shared<op::Parameter>(element::f32, s.anchors_shape);
auto deltas = std::make_shared<op::Parameter>(element::f32, s.deltas_shape);
auto scores = std::make_shared<op::Parameter>(element::f32, s.scores_shape);
auto im_info = std::make_shared<ov::op::v0::Parameter>(element::f32, s.im_info_shape);
auto anchors = std::make_shared<ov::op::v0::Parameter>(element::f32, s.anchors_shape);
auto deltas = std::make_shared<ov::op::v0::Parameter>(element::f32, s.deltas_shape);
auto scores = std::make_shared<ov::op::v0::Parameter>(element::f32, s.scores_shape);
auto proposals = std::make_shared<GenerateProposals>(im_info, anchors, deltas, scores, attrs);

3
src/core/tests/type_prop/grid_sample.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/util/attr_types.hpp"
#include "openvino/opsets/opset9.hpp"

16
src/core/tests/type_prop/grn.cpp
View File

@ -2,17 +2,19 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/grn.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, grn) {
float bias = 1.25f;
Shape data_shape{2, 3, 4, 5};
auto A = make_shared<op::Parameter>(element::f32, data_shape);
auto A = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto grn = make_shared<op::v0::GRN>(A, bias);
EXPECT_EQ(grn->get_element_type(), element::f32);
@ -22,7 +24,7 @@ TEST(type_prop, grn) {
TEST(type_prop, grn_dynamic) {
float bias = 1.25f;
PartialShape data_shape{2, Dimension::dynamic(), 3, Dimension(4, 6)};
auto A = make_shared<op::Parameter>(element::f32, data_shape);
auto A = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto grn = make_shared<op::v0::GRN>(A, bias);
EXPECT_EQ(grn->get_element_type(), element::f32);
@ -31,7 +33,7 @@ TEST(type_prop, grn_dynamic) {
TEST(type_prop, grn_invalid_data_rank) {
float bias = 1.25f;
auto A = make_shared<op::Parameter>(element::f32, Shape{4});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
try {
auto grn = make_shared<op::v0::GRN>(A, bias);
@ -43,7 +45,7 @@ TEST(type_prop, grn_invalid_data_rank) {
FAIL() << "Deduced type check failed for unexpected reason";
}
A = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4, 5});
A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4, 5});
try {
auto grn = make_shared<op::v0::GRN>(A, bias);

112
src/core/tests/type_prop/group_convolution.cpp
View File

@ -2,13 +2,15 @@
// 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/core/coordinate_diff.hpp"
#include "openvino/op/group_conv.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace testing;
TEST(type_prop, group_convolution_auto_padding_same_lower) {
@ -23,8 +25,8 @@ TEST(type_prop, group_convolution_auto_padding_same_lower) {
Strides dilations{1, 1};
const auto auto_pad = op::PadType::SAME_LOWER;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto groupConv =
make_shared<op::v1::GroupConvolution>(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad);
@ -46,8 +48,8 @@ TEST(type_prop, group_convolution_auto_padding_same_upper) {
Strides dilations{1, 1};
const auto auto_pad = op::PadType::SAME_UPPER;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto conv =
make_shared<op::v1::GroupConvolution>(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad);
@ -63,8 +65,8 @@ TEST(type_prop, group_convolution_auto_padding_same_lower_spatial_dims_static) {
const element::Type_t et = element::f32;
const auto auto_pad = op::PadType::SAME_LOWER;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto groupConv = make_shared<op::v1::GroupConvolution>(data_batch,
filters,
Strides{},
@ -86,8 +88,8 @@ TEST(type_prop, group_convolution_auto_padding_same_upper_spatial_dims_static) {
const element::Type_t et = element::f32;
const auto auto_pad = op::PadType::SAME_UPPER;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto groupConv = make_shared<op::v1::GroupConvolution>(data_batch,
filters,
Strides{},
@ -112,8 +114,8 @@ TEST(type_prop, group_convolution_static_ranks_filters_groups_dyn) {
const element::Type_t et = element::f32;
const auto auto_pad = op::PadType::SAME_LOWER;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto groupConv = make_shared<op::v1::GroupConvolution>(data_batch,
filters,
Strides{},
@ -134,8 +136,8 @@ TEST(type_prop, group_convolution_static_ranks_filters_groups_cout_dyn) {
const element::Type_t et = element::f32;
const auto auto_pad = op::PadType::SAME_LOWER;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto groupConv = make_shared<op::v1::GroupConvolution>(data_batch,
filters,
Strides{},
@ -155,8 +157,8 @@ TEST(type_prop, group_convolution_static_ranks_data_cin_filters_group_dyn) {
const element::Type_t et = element::f32;
const auto auto_pad = op::PadType::SAME_LOWER;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto groupConv = make_shared<op::v1::GroupConvolution>(data_batch,
filters,
Strides{},
@ -176,8 +178,8 @@ TEST(type_prop, group_convolution_auto_padding_same_spatial_dims_dynamic) {
const element::Type_t et = element::f32;
const auto auto_pad = op::PadType::SAME_LOWER;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto groupConv = make_shared<op::v1::GroupConvolution>(data_batch,
filters,
Strides{},
@ -196,8 +198,8 @@ TEST(type_prop, group_convolution_data_batch_dynamic) {
const PartialShape filters_pshape{2, 1, 2, 3, 3};
const element::Type_t et = element::f32;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto groupConv = make_shared<op::v1::GroupConvolution>(data_batch,
filters,
Strides{},
@ -219,8 +221,8 @@ TEST(type_prop, group_convolution_filters_dynamic_auto_pad_explicit) {
const PartialShape filters_pshape{PartialShape::dynamic()};
const element::Type_t et = element::f16;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto groupConv = make_shared<op::v1::GroupConvolution>(data_batch,
filters,
Strides{},
@ -243,8 +245,8 @@ TEST(type_prop, group_convolution_filters_dynamic_auto_pad_same) {
const element::Type_t et = element::f16;
const auto auto_pad = op::PadType::SAME_LOWER;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto groupConv = make_shared<op::v1::GroupConvolution>(data_batch,
filters,
Strides{},
@ -264,8 +266,8 @@ TEST(type_prop, group_convolution_data_batch_and_filters_dynamic) {
const PartialShape dyn_pshape{PartialShape::dynamic()};
const element::Type_t et = element::f32;
auto data_batch = 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 filters = make_shared<ov::op::v0::Parameter>(et, dyn_pshape);
auto groupConv = make_shared<op::v1::GroupConvolution>(data_batch,
filters,
Strides{},
@ -281,8 +283,8 @@ TEST(type_prop, group_convolution_invalid_et_inputs) {
const PartialShape filters_pshape{2, 1, 2, 3, 3};
try {
auto data_batch = make_shared<op::Parameter>(element::f16, data_batch_pshape);
auto filters = make_shared<op::Parameter>(element::f32, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(element::f16, data_batch_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(element::f32, filters_pshape);
auto groupConv = make_shared<op::v1::GroupConvolution>(data_batch,
filters,
Strides{},
@ -300,8 +302,8 @@ TEST(type_prop, group_convolution_invalid_et_inputs) {
try {
const element::Type boolean_et = element::boolean;
auto data_batch = make_shared<op::Parameter>(boolean_et, data_batch_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 filters = make_shared<ov::op::v0::Parameter>(boolean_et, filters_pshape);
auto groupConv = make_shared<op::v1::GroupConvolution>(data_batch,
filters,
Strides{},
@ -324,8 +326,8 @@ TEST(type_prop, group_convolution_invalid_input_ranks) {
// data partial shape provided is rank 4 (Conv2D)
// filter partial shape provided is rank 6 (Conv3D)
try {
auto filters = make_shared<op::Parameter>(et, PartialShape{2, 8, 2, 3, 3, Dimension::dynamic()});
auto data = make_shared<op::Parameter>(et, PartialShape{1, 16, 6, 6});
auto filters = make_shared<ov::op::v0::Parameter>(et, PartialShape{2, 8, 2, 3, 3, Dimension::dynamic()});
auto data = make_shared<ov::op::v0::Parameter>(et, PartialShape{1, 16, 6, 6});
auto groupConv = make_shared<op::v1::GroupConvolution>(data,
filters,
Strides{},
@ -343,8 +345,8 @@ TEST(type_prop, group_convolution_invalid_input_ranks) {
// data partial shape provided is rank 5 (Conv3D)
// filter partial shape provided is rank 5 (Conv2D)
try {
const auto filters = make_shared<op::Parameter>(et, PartialShape{2, 8, 2, 3, 3});
const auto data = make_shared<op::Parameter>(et, PartialShape{1, Dimension::dynamic(), 16, 6, 6});
const auto filters = make_shared<ov::op::v0::Parameter>(et, PartialShape{2, 8, 2, 3, 3});
const auto data = make_shared<ov::op::v0::Parameter>(et, PartialShape{1, Dimension::dynamic(), 16, 6, 6});
const auto groupConv = make_shared<op::v1::GroupConvolution>(data,
filters,
Strides{},
@ -367,8 +369,8 @@ TEST(type_prop, group_convolution_invalid_input_channel_dims) {
const PartialShape data_batch_pshape{1, 6, 5, 5};
const PartialShape filters_pshape{1, 1, 3, 3, 3};
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
OV_EXPECT_THROW(
const auto op = make_shared<op::v1::GroupConvolution>(data_batch,
@ -386,8 +388,8 @@ TEST(type_prop, group_convolution_invalid_input_channel_dims) {
const PartialShape data_batch_pshape{1, 3, 5, 5};
const PartialShape filters_pshape{-1, 1, 2, 3, 3};
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
OV_EXPECT_THROW(
const auto op = make_shared<op::v1::GroupConvolution>(data_batch,
@ -413,8 +415,8 @@ TEST(type_prop, group_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 filters = make_shared<op::Parameter>(et, PartialShape::dynamic());
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto groupConv =
make_shared<op::v1::GroupConvolution>(data_batch, filters, strides, pads_begin, pads_end, dilations);
FAIL() << "Invalid strides spatial dimensions not detected";
@ -429,8 +431,8 @@ TEST(type_prop, group_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 filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto groupConv =
make_shared<op::v1::GroupConvolution>(data_batch, filters, strides, pads_begin, pads_end, dilations);
FAIL() << "Invalid strides spatial dimensions not detected";
@ -447,8 +449,8 @@ TEST(type_prop, group_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 filters = make_shared<op::Parameter>(et, PartialShape::dynamic());
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto groupConv =
make_shared<op::v1::GroupConvolution>(data_batch, filters, strides, pads_begin, pads_end, dilations);
FAIL() << "Invalid dilations spatial dimensions not detected";
@ -463,8 +465,8 @@ TEST(type_prop, group_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 filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto groupConv =
make_shared<op::v1::GroupConvolution>(data_batch, filters, strides, pads_begin, pads_end, dilations);
FAIL() << "Invalid dilations spatial dimensions not detected";
@ -481,8 +483,8 @@ TEST(type_prop, group_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, PartialShape::dynamic());
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
OV_EXPECT_THROW(
auto op =
@ -497,8 +499,8 @@ TEST(type_prop, group_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 filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
OV_EXPECT_THROW(
auto op =
@ -517,8 +519,8 @@ TEST(type_prop, group_convolution_interval_shapes) {
const element::Type_t et = element::f32;
const auto auto_pad = op::PadType::EXPLICIT;
auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto groupConv = make_shared<op::v1::GroupConvolution>(data_batch,
filters,
Strides{},
@ -534,8 +536,8 @@ TEST(type_prop, group_convolution_interval_shapes) {
}
TEST(type_prop, group_convolution_default_constructed) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{1, 1, 1, 3, 3});
const auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
const auto filters = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, 1, 1, 3, 3});
const auto op = make_shared<op::v1::GroupConvolution>();
op->set_arguments(OutputVector{data, filters});

203
src/core/tests/type_prop/group_convolution_backprop_data.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 "convolution_shape_inference.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace testing;
TEST(type_prop, group_convolution_backprop_data_shape_infer) {
@ -16,8 +16,8 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer) {
const PartialShape filters_pshape{2, 8, 2, 3, 3}; // [GROUPS, C_IN, C_OUT, kH, kW]
const element::Type_t et = element::f32;
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
Strides{},
@ -40,9 +40,9 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_with_output_shape_as
const PartialShape filters_pshape{1, 16, 2, 3, 3}; // [GROUPS, C_IN, C_OUT, kH, kW]
const element::Type_t et = element::f32;
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto output_shape = op::Constant::create(element::i64, Shape{2}, {3, 3});
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto output_shape = ov::op::v0::Constant::create(element::i64, Shape{2}, {3, 3});
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
output_shape,
@ -65,9 +65,9 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_with_output_shape_as
const PartialShape filters_pshape{1, 16, 2, 3, 3}; // [GROUPS, C_IN, C_OUT, kH, kW]
const element::Type_t et = element::f32;
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto output_shape = make_shared<op::Parameter>(element::i64, Shape{2});
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto output_shape = make_shared<ov::op::v0::Parameter>(element::i64, Shape{2});
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
output_shape,
@ -85,9 +85,9 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_with_output_shape_st
const PartialShape filters_pshape{1, 16, 2, 3, 3}; // [GROUPS, C_IN, C_OUT, kH, kW]
const element::Type_t et = element::f32;
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto output_shape = op::Constant::create(element::i64, Shape{2}, {3, 3});
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto output_shape = ov::op::v0::Constant::create(element::i64, Shape{2}, {3, 3});
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
output_shape,
@ -103,9 +103,9 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_with_output_shape_st
const PartialShape filters_pshape{Dimension::dynamic(), 16, 2, 3, 3}; // [GROUPS, C_IN, C_OUT, kH, kW]
const element::Type_t et = element::f32;
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto output_shape = op::Constant::create(element::i64, Shape{2}, {3, 3});
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto output_shape = ov::op::v0::Constant::create(element::i64, Shape{2}, {3, 3});
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
output_shape,
@ -125,9 +125,9 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_with_output_shape_st
3}; // [GROUPS, C_IN, C_OUT, kH, kW]
const element::Type_t et = element::f32;
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto output_shape = op::Constant::create(element::i64, Shape{2}, {3, 3});
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto output_shape = ov::op::v0::Constant::create(element::i64, Shape{2}, {3, 3});
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
output_shape,
@ -143,9 +143,9 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_with_output_shape_st
const PartialShape filters_pshape{Dimension::dynamic(), 16, 2, 3, 3}; // [GROUPS, C_IN, C_OUT, kH, kW]
const element::Type_t et = element::f32;
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto output_shape = op::Constant::create(element::i64, Shape{2}, {3, 3});
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto output_shape = ov::op::v0::Constant::create(element::i64, Shape{2}, {3, 3});
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
output_shape,
@ -163,9 +163,9 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_with_output_shape_st
set_shape_labels(filters_pshape, 20);
const element::Type_t et = element::f32;
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto output_shape = op::Constant::create(element::i64, Shape{2}, {3, 3});
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto output_shape = ov::op::v0::Constant::create(element::i64, Shape{2}, {3, 3});
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
output_shape,
@ -187,8 +187,8 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_static_ranks_data_nc
const CoordinateDiff padding_begin{1, 1};
const CoordinateDiff padding_end{1, 1};
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
strides,
@ -209,8 +209,8 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_static_ranks_filters
const CoordinateDiff padding_begin{1, 1};
const CoordinateDiff padding_end{1, 1};
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
strides,
@ -235,8 +235,8 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_static_ranks_filters
const CoordinateDiff padding_begin{1, 1};
const CoordinateDiff padding_end{1, 1};
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
strides,
@ -257,8 +257,8 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_static_ranks_data_ci
const CoordinateDiff padding_begin{1, 1};
const CoordinateDiff padding_end{1, 1};
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
strides,
@ -281,8 +281,8 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_static_ranks_filters
const CoordinateDiff padding_begin{1, 1};
const CoordinateDiff padding_end{1, 1};
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
strides,
@ -304,8 +304,8 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_static_ranks_data_sp
const CoordinateDiff padding_begin{1, 1};
const CoordinateDiff padding_end{1, 1};
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
strides,
@ -328,8 +328,8 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_static_ranks_filters
const CoordinateDiff padding_begin{1, 1};
const CoordinateDiff padding_end{1, 1};
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
strides,
@ -347,9 +347,9 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_with_output_shape_da
const PartialShape filters_pshape{1, 16, 2, 3, 3}; // [GROUPS, C_IN, C_OUT, kH, kW]
const element::Type_t et = element::f32;
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto output_shape = op::Constant::create(element::i64, Shape{2}, {3, 3});
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto output_shape = ov::op::v0::Constant::create(element::i64, Shape{2}, {3, 3});
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
output_shape,
@ -365,8 +365,8 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_data_dyn) {
const PartialShape filters_pshape{4, 5, 2, 3, 3}; // [GROUPS, C_IN, C_OUT, kH, kW]
const element::Type_t et = element::f32;
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
Strides{},
@ -383,9 +383,9 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_with_output_shape_fi
const PartialShape filters_pshape{PartialShape::dynamic()};
const element::Type_t et = element::f32;
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto output_shape = op::Constant::create(element::i64, Shape{2}, {3, 3});
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto output_shape = ov::op::v0::Constant::create(element::i64, Shape{2}, {3, 3});
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
output_shape,
@ -401,8 +401,8 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_filters_dyn) {
const PartialShape filters_pshape{PartialShape::dynamic()};
const element::Type_t et = element::f32;
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
Strides{},
@ -419,9 +419,9 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_with_output_shape_as
const PartialShape filters_pshape{PartialShape::dynamic()};
const element::Type_t et = element::f32;
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto output_shape = op::Constant::create(element::i64, Shape{3}, {3, 3, 3});
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto output_shape = ov::op::v0::Constant::create(element::i64, Shape{3}, {3, 3, 3});
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
output_shape,
@ -437,9 +437,9 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_with_output_shape_as
const PartialShape filters_pshape{PartialShape::dynamic()};
const element::Type_t et = element::f32;
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto output_shape = make_shared<op::Parameter>(element::i64, Shape{3});
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto output_shape = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
output_shape,
@ -455,8 +455,8 @@ TEST(type_prop, group_convolution_backprop_data_shape_infer_data_and_filters_dyn
const PartialShape filters_pshape{PartialShape::dynamic()};
const element::Type_t et = element::f32;
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
Strides{},
@ -475,8 +475,8 @@ TEST(type_prop, group_convolution_backprop_data_invalid_et_inputs) {
const element::Type_t data_et = element::f16;
const element::Type_t filters_et = element::f32;
auto data = make_shared<op::Parameter>(data_et, data_pshape);
auto filters = make_shared<op::Parameter>(filters_et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(data_et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(filters_et, filters_pshape);
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
Strides{},
@ -497,8 +497,8 @@ TEST(type_prop, group_convolution_backprop_data_invalid_et_inputs) {
const element::Type boolean_et = element::boolean;
auto data = make_shared<op::Parameter>(boolean_et, data_pshape);
auto filters = make_shared<op::Parameter>(boolean_et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(boolean_et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(boolean_et, filters_pshape);
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
Strides{},
@ -520,9 +520,9 @@ TEST(type_prop, group_convolution_backprop_data_invalid_et_inputs) {
const element::Type_t inputs_et = element::f32;
auto data = make_shared<op::Parameter>(inputs_et, data_pshape);
auto filters = make_shared<op::Parameter>(inputs_et, filters_pshape);
auto output_shape = op::Constant::create(inputs_et, Shape{2}, {3, 3});
auto data = make_shared<ov::op::v0::Parameter>(inputs_et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(inputs_et, filters_pshape);
auto output_shape = ov::op::v0::Constant::create(inputs_et, Shape{2}, {3, 3});
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
output_shape,
@ -547,8 +547,8 @@ TEST(type_prop, group_convolution_backprop_data_invalid_input_ranks) {
const element::Type_t inputs_et = element::f32;
auto data = make_shared<op::Parameter>(inputs_et, data_pshape);
auto filters = make_shared<op::Parameter>(inputs_et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(inputs_et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(inputs_et, filters_pshape);
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
Strides{},
@ -571,8 +571,8 @@ TEST(type_prop, group_convolution_backprop_data_invalid_input_ranks) {
const element::Type_t inputs_et = element::f32;
auto data = make_shared<op::Parameter>(inputs_et, data_pshape);
auto filters = make_shared<op::Parameter>(inputs_et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(inputs_et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(inputs_et, filters_pshape);
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
Strides{},
@ -593,9 +593,9 @@ TEST(type_prop, group_convolution_backprop_data_invalid_input_ranks) {
const element::Type_t inputs_et = element::f32;
auto data = make_shared<op::Parameter>(inputs_et, data_pshape);
auto filters = make_shared<op::Parameter>(inputs_et, filters_pshape);
auto output_shape = op::Constant::create(element::i64, Shape{2, 1}, {3, 3});
auto data = make_shared<ov::op::v0::Parameter>(inputs_et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(inputs_et, filters_pshape);
auto output_shape = ov::op::v0::Constant::create(element::i64, Shape{2, 1}, {3, 3});
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
output_shape,
@ -621,8 +621,8 @@ TEST(type_prop, group_convolution_backprop_data_invalid_input_channel_dims) {
const PartialShape data_pshape{1, 16, 5, 5}; // [N, C_IN * GROUPS, H, W]
const PartialShape filters_pshape{21, 16, 20, 3, 3}; // [GROUPS, C_IN, C_OUT, kH, kW]
auto data = make_shared<op::Parameter>(inputs_et, data_pshape);
auto filters = make_shared<op::Parameter>(inputs_et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(inputs_et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(inputs_et, filters_pshape);
auto gcbd =
make_shared<op::v1::GroupConvolutionBackpropData>(data, filters, strides, padding, padding, dilations);
// data batch shape does not have correct dimension C_IN * GROUPS
@ -640,8 +640,8 @@ TEST(type_prop, group_convolution_backprop_data_invalid_input_channel_dims) {
const PartialShape data_pshape{1, 16, 5, 5}; // [N, C_IN * GROUPS, H, W]
const PartialShape filters_pshape{4, 16, 20, 3, 3}; // [GROUPS, C_IN, C_OUT, kH, kW]
auto data = make_shared<op::Parameter>(inputs_et, data_pshape);
auto filters = make_shared<op::Parameter>(inputs_et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(inputs_et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(inputs_et, filters_pshape);
auto gcbd =
make_shared<op::v1::GroupConvolutionBackpropData>(data, filters, strides, padding, padding, dilations);
// filter shape specifies GROUPS = 4 and C_IN = 16, while data batch shape specifies
@ -663,9 +663,9 @@ TEST(type_prop, group_convolution_backprop_data_invalid_output_shape_spatial_dim
const element::Type_t inputs_et = element::f32;
try {
auto data = make_shared<op::Parameter>(inputs_et, data_pshape);
auto filters = make_shared<op::Parameter>(inputs_et, filters_shape);
auto output_shape = op::Constant::create(element::i64, Shape{3}, {3, 3, 3});
auto data = make_shared<ov::op::v0::Parameter>(inputs_et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(inputs_et, filters_shape);
auto output_shape = ov::op::v0::Constant::create(element::i64, Shape{3}, {3, 3, 3});
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
output_shape,
@ -694,8 +694,8 @@ TEST(type_prop, group_convolution_backprop_data_invalid_conv_param_spatial_dims)
const CoordinateDiff pads_begin{0, 0};
const CoordinateDiff pads_end{0, 0};
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, PartialShape::dynamic());
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto gcbd =
make_shared<op::v1::GroupConvolutionBackpropData>(data, filters, strides, pads_begin, pads_end, dilations);
FAIL() << "Invalid strides spatial dimensions not detected";
@ -710,8 +710,8 @@ TEST(type_prop, group_convolution_backprop_data_invalid_conv_param_spatial_dims)
const CoordinateDiff pads_begin{0, 0};
const CoordinateDiff pads_end{0, 0};
auto data = make_shared<op::Parameter>(et, PartialShape::dynamic());
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto gcbd =
make_shared<op::v1::GroupConvolutionBackpropData>(data, filters, strides, pads_begin, pads_end, dilations);
FAIL() << "Invalid strides spatial dimensions not detected";
@ -728,8 +728,8 @@ TEST(type_prop, group_convolution_backprop_data_invalid_conv_param_spatial_dims)
const CoordinateDiff pads_begin{0, 0};
const CoordinateDiff pads_end{0, 0};
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, PartialShape::dynamic());
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto gcbd =
make_shared<op::v1::GroupConvolutionBackpropData>(data, filters, strides, pads_begin, pads_end, dilations);
FAIL() << "Invalid dilations spatial dimensions not detected";
@ -744,8 +744,8 @@ TEST(type_prop, group_convolution_backprop_data_invalid_conv_param_spatial_dims)
const CoordinateDiff pads_begin{0, 0};
const CoordinateDiff pads_end{0, 0};
auto data = make_shared<op::Parameter>(et, PartialShape::dynamic());
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto gcbd =
make_shared<op::v1::GroupConvolutionBackpropData>(data, filters, strides, pads_begin, pads_end, dilations);
FAIL() << "Invalid dilations spatial dimensions not detected";
@ -762,8 +762,8 @@ TEST(type_prop, group_convolution_backprop_data_invalid_conv_param_spatial_dims)
const CoordinateDiff pads_begin{0, 0, 0};
const CoordinateDiff pads_end{0, 0};
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, PartialShape::dynamic());
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto gcbd =
make_shared<op::v1::GroupConvolutionBackpropData>(data, filters, strides, pads_begin, pads_end, dilations);
FAIL() << "Invalid padding spatial dimensions not detected";
@ -778,8 +778,8 @@ TEST(type_prop, group_convolution_backprop_data_invalid_conv_param_spatial_dims)
const CoordinateDiff pads_begin{0, 0};
const CoordinateDiff pads_end{0};
auto data = make_shared<op::Parameter>(et, PartialShape::dynamic());
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto gcbd =
make_shared<op::v1::GroupConvolutionBackpropData>(data, filters, strides, pads_begin, pads_end, dilations);
FAIL() << "Invalid padding spatial dimensions not detected";
@ -798,8 +798,8 @@ TEST(type_prop, group_convolution_backprop_data_invalid_conv_param_spatial_dims)
const CoordinateDiff output_padding{0, 0, 0};
const op::PadType auto_pad = op::PadType::EXPLICIT;
auto data = make_shared<op::Parameter>(et, data_pshape);
auto filters = make_shared<op::Parameter>(et, PartialShape::dynamic());
auto data = make_shared<ov::op::v0::Parameter>(et, data_pshape);
auto filters = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
strides,
@ -822,8 +822,8 @@ TEST(type_prop, group_convolution_backprop_data_invalid_conv_param_spatial_dims)
const CoordinateDiff output_padding{0};
const op::PadType auto_pad = op::PadType::EXPLICIT;
auto data = make_shared<op::Parameter>(et, PartialShape::dynamic());
auto filters = make_shared<op::Parameter>(et, filters_pshape);
auto data = make_shared<ov::op::v0::Parameter>(et, PartialShape::dynamic());
auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
auto gcbd = make_shared<op::v1::GroupConvolutionBackpropData>(data,
filters,
strides,
@ -841,9 +841,9 @@ TEST(type_prop, group_convolution_backprop_data_invalid_conv_param_spatial_dims)
}
TEST(type_prop, group_convolution_backprop_data_default_constructed) {
const auto data = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
const auto filters = make_shared<op::Parameter>(element::f32, PartialShape{1, 1, 1, 3, 3, 3});
const auto out_spatial = op::Constant::create(element::i32, Shape{3}, {5, 4, 10});
const auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
const auto filters = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, 1, 1, 3, 3, 3});
const auto out_spatial = ov::op::v0::Constant::create(element::i32, Shape{3}, {5, 4, 10});
const auto op = make_shared<op::v1::GroupConvolutionBackpropData>();
op->set_arguments(OutputVector{data, filters, out_spatial});
@ -874,9 +874,10 @@ TEST(type_prop, group_convolution_backprop_data_interval_shapes) {
const element::Type_t et = element::f32;
const auto auto_pad = op::PadType::SAME_LOWER;
const auto data_batch = make_shared<op::Parameter>(et, data_batch_pshape);
const auto filters = make_shared<op::Parameter>(et, filters_pshape);
const auto out_spatial_shape_of = make_shared<op::v0::ShapeOf>(make_shared<op::Parameter>(et, out_spatial_pshape));
const auto data_batch = make_shared<ov::op::v0::Parameter>(et, data_batch_pshape);
const auto filters = make_shared<ov::op::v0::Parameter>(et, filters_pshape);
const auto out_spatial_shape_of =
make_shared<op::v0::ShapeOf>(make_shared<ov::op::v0::Parameter>(et, out_spatial_pshape));
const auto op = make_shared<op::v1::GroupConvolutionBackpropData>(data_batch,
filters,
out_spatial_shape_of,

3
src/core/tests/type_prop/group_normalization.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/openvino.hpp"
#include "openvino/opsets/opset12.hpp"

217
src/core/tests/type_prop/gru_cell.cpp
View File

@ -2,14 +2,15 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/gru_cell.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/opsets/opset4.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace testing;
TEST(type_prop, gru_cell) {
@ -18,12 +19,12 @@ TEST(type_prop, gru_cell) {
const size_t hidden_size = 3;
const size_t gates_count = 3;
const auto X = make_shared<op::Parameter>(element::f32, Shape{batch_size, input_size});
const auto W = make_shared<op::Parameter>(element::f32, Shape{gates_count * hidden_size, input_size});
const auto R = make_shared<op::Parameter>(element::f32, Shape{gates_count * hidden_size, hidden_size});
const auto H_t = make_shared<op::Parameter>(element::f32, Shape{batch_size, hidden_size});
const auto X = make_shared<ov::op::v0::Parameter>(element::f32, Shape{batch_size, input_size});
const auto W = make_shared<ov::op::v0::Parameter>(element::f32, Shape{gates_count * hidden_size, input_size});
const auto R = make_shared<ov::op::v0::Parameter>(element::f32, Shape{gates_count * hidden_size, hidden_size});
const auto H_t = make_shared<ov::op::v0::Parameter>(element::f32, Shape{batch_size, hidden_size});
const auto gru_cell = make_shared<opset4::GRUCell>(X, H_t, W, R, hidden_size);
const auto gru_cell = make_shared<ov::op::v3::GRUCell>(X, H_t, W, R, hidden_size);
EXPECT_EQ(gru_cell->get_output_element_type(0), element::f32);
EXPECT_EQ(gru_cell->get_output_shape(0), (Shape{batch_size, hidden_size}));
}
@ -34,13 +35,13 @@ TEST(type_prop, gru_cell_with_bias) {
const size_t hidden_size = 3;
const size_t gates_count = 3;
const auto X = make_shared<op::Parameter>(element::f32, Shape{batch_size, input_size});
const auto H_t = make_shared<op::Parameter>(element::f32, Shape{batch_size, hidden_size});
const auto W = make_shared<op::Parameter>(element::f32, Shape{gates_count * hidden_size, input_size});
const auto R = make_shared<op::Parameter>(element::f32, Shape{gates_count * hidden_size, hidden_size});
const auto B = make_shared<op::Parameter>(element::f32, Shape{gates_count * hidden_size});
const auto X = make_shared<ov::op::v0::Parameter>(element::f32, Shape{batch_size, input_size});
const auto H_t = make_shared<ov::op::v0::Parameter>(element::f32, Shape{batch_size, hidden_size});
const auto W = make_shared<ov::op::v0::Parameter>(element::f32, Shape{gates_count * hidden_size, input_size});
const auto R = make_shared<ov::op::v0::Parameter>(element::f32, Shape{gates_count * hidden_size, hidden_size});
const auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{gates_count * hidden_size});
const auto gru_cell = make_shared<opset4::GRUCell>(X, H_t, W, R, B, hidden_size);
const auto gru_cell = make_shared<ov::op::v3::GRUCell>(X, H_t, W, R, B, hidden_size);
EXPECT_EQ(gru_cell->get_output_element_type(0), element::f32);
EXPECT_EQ(gru_cell->get_output_shape(0), (Shape{batch_size, hidden_size}));
}
@ -51,23 +52,23 @@ TEST(type_prop, gru_cell_with_bias_linear_before) {
const size_t hidden_size = 3;
const size_t gates_count = 3;
const auto X = make_shared<op::Parameter>(element::f32, Shape{batch_size, input_size});
const auto H_t = make_shared<op::Parameter>(element::f32, Shape{batch_size, hidden_size});
const auto W = make_shared<op::Parameter>(element::f32, Shape{gates_count * hidden_size, input_size});
const auto R = make_shared<op::Parameter>(element::f32, Shape{gates_count * hidden_size, hidden_size});
const auto B = make_shared<op::Parameter>(element::f32, Shape{(gates_count + 1) * hidden_size});
const auto X = make_shared<ov::op::v0::Parameter>(element::f32, Shape{batch_size, input_size});
const auto H_t = make_shared<ov::op::v0::Parameter>(element::f32, Shape{batch_size, hidden_size});
const auto W = make_shared<ov::op::v0::Parameter>(element::f32, Shape{gates_count * hidden_size, input_size});
const auto R = make_shared<ov::op::v0::Parameter>(element::f32, Shape{gates_count * hidden_size, hidden_size});
const auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{(gates_count + 1) * hidden_size});
const auto gru_cell = make_shared<opset4::GRUCell>(X,
H_t,
W,
R,
B,
hidden_size,
std::vector<string>{"sigmoid", "tanh"},
std::vector<float>{},
std::vector<float>{},
0.f,
true);
const auto gru_cell = make_shared<ov::op::v3::GRUCell>(X,
H_t,
W,
R,
B,
hidden_size,
std::vector<string>{"sigmoid", "tanh"},
std::vector<float>{},
std::vector<float>{},
0.f,
true);
EXPECT_EQ(gru_cell->get_output_element_type(0), element::f32);
EXPECT_EQ(gru_cell->get_output_shape(0), (Shape{batch_size, hidden_size}));
@ -79,13 +80,13 @@ TEST(type_prop, gru_cell_default_ctor_linear_before) {
const size_t hidden_size = 3;
const size_t gates_count = 3;
const auto X = make_shared<op::Parameter>(element::f32, Shape{batch_size, input_size});
const auto H_t = make_shared<op::Parameter>(element::f32, Shape{batch_size, hidden_size});
const auto W = make_shared<op::Parameter>(element::f32, Shape{gates_count * hidden_size, input_size});
const auto R = make_shared<op::Parameter>(element::f32, Shape{gates_count * hidden_size, hidden_size});
const auto B = make_shared<op::Parameter>(element::f32, Shape{(gates_count + 1) * hidden_size});
const auto X = make_shared<ov::op::v0::Parameter>(element::f32, Shape{batch_size, input_size});
const auto H_t = make_shared<ov::op::v0::Parameter>(element::f32, Shape{batch_size, hidden_size});
const auto W = make_shared<ov::op::v0::Parameter>(element::f32, Shape{gates_count * hidden_size, input_size});
const auto R = make_shared<ov::op::v0::Parameter>(element::f32, Shape{gates_count * hidden_size, hidden_size});
const auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{(gates_count + 1) * hidden_size});
const auto gru_cell = make_shared<opset4::GRUCell>();
const auto gru_cell = make_shared<ov::op::v3::GRUCell>();
gru_cell->set_linear_before_reset(true);
gru_cell->set_arguments(OutputVector{X, H_t, W, R, B});
gru_cell->validate_and_infer_types();
@ -100,34 +101,34 @@ TEST(type_prop, gru_cell_invalid_input) {
const size_t hidden_size = 3;
const size_t gates_count = 3;
const auto X = make_shared<op::Parameter>(element::f32, Shape{batch_size, input_size});
auto R = make_shared<op::Parameter>(element::f32, Shape{gates_count * hidden_size, hidden_size});
auto H_t = make_shared<op::Parameter>(element::f32, Shape{batch_size, hidden_size});
const auto X = make_shared<ov::op::v0::Parameter>(element::f32, Shape{batch_size, input_size});
auto R = make_shared<ov::op::v0::Parameter>(element::f32, Shape{gates_count * hidden_size, hidden_size});
auto H_t = make_shared<ov::op::v0::Parameter>(element::f32, Shape{batch_size, hidden_size});
// Invalid W tensor shape.
auto W = make_shared<op::Parameter>(element::f32, Shape{hidden_size, input_size});
OV_EXPECT_THROW(auto op = make_shared<opset4::GRUCell>(X, H_t, W, R, hidden_size),
auto W = make_shared<ov::op::v0::Parameter>(element::f32, Shape{hidden_size, input_size});
OV_EXPECT_THROW(auto op = make_shared<ov::op::v3::GRUCell>(X, H_t, W, R, hidden_size),
ov::NodeValidationFailure,
HasSubstr("First dimension of W input shape is required to be compatible"));
// Invalid R tensor shape.
W = make_shared<op::Parameter>(element::f32, Shape{gates_count * hidden_size, input_size});
R = make_shared<op::Parameter>(element::f32, Shape{hidden_size, 1});
OV_EXPECT_THROW(auto op = make_shared<opset4::GRUCell>(X, H_t, W, R, hidden_size),
W = make_shared<ov::op::v0::Parameter>(element::f32, Shape{gates_count * hidden_size, input_size});
R = make_shared<ov::op::v0::Parameter>(element::f32, Shape{hidden_size, 1});
OV_EXPECT_THROW(auto op = make_shared<ov::op::v3::GRUCell>(X, H_t, W, R, hidden_size),
ov::NodeValidationFailure,
HasSubstr("Dimension `hidden_size` is not matched between inputs"));
// Invalid H_t tensor shape.
R = make_shared<op::Parameter>(element::f32, Shape{gates_count * hidden_size, hidden_size});
H_t = make_shared<op::Parameter>(element::f32, Shape{4, hidden_size});
OV_EXPECT_THROW(auto op = make_shared<opset4::GRUCell>(X, H_t, W, R, hidden_size),
R = make_shared<ov::op::v0::Parameter>(element::f32, Shape{gates_count * hidden_size, hidden_size});
H_t = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4, hidden_size});
OV_EXPECT_THROW(auto op = make_shared<ov::op::v3::GRUCell>(X, H_t, W, R, hidden_size),
ov::NodeValidationFailure,
HasSubstr("Dimension `batch_size` is not matched between inputs"));
// Invalid B tensor shape.
H_t = make_shared<op::Parameter>(element::f32, Shape{batch_size, hidden_size});
auto B = make_shared<op::Parameter>(element::f32, Shape{hidden_size});
OV_EXPECT_THROW(auto op = make_shared<opset4::GRUCell>(X, H_t, W, R, B, hidden_size),
H_t = make_shared<ov::op::v0::Parameter>(element::f32, Shape{batch_size, hidden_size});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{hidden_size});
OV_EXPECT_THROW(auto op = make_shared<ov::op::v3::GRUCell>(X, H_t, W, R, B, hidden_size),
ov::NodeValidationFailure,
HasSubstr("First dimension of B input shape is required to be compatible"));
}
@ -138,12 +139,14 @@ TEST(type_prop, gru_cell_dynamic_batch_size) {
const size_t hidden_size = 3;
const size_t gates_count = 3;
const auto X = make_shared<op::Parameter>(element::f32, PartialShape{batch_size, input_size});
const auto W = make_shared<op::Parameter>(element::f32, PartialShape{gates_count * hidden_size, input_size});
const auto R = make_shared<op::Parameter>(element::f32, PartialShape{gates_count * hidden_size, hidden_size});
const auto H_t = make_shared<op::Parameter>(element::f32, PartialShape{batch_size, hidden_size});
const auto X = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{batch_size, input_size});
const auto W =
make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{gates_count * hidden_size, input_size});
const auto R =
make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{gates_count * hidden_size, hidden_size});
const auto H_t = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{batch_size, hidden_size});
const auto gru_cell = make_shared<opset4::GRUCell>(X, H_t, W, R, hidden_size);
const auto gru_cell = make_shared<ov::op::v3::GRUCell>(X, H_t, W, R, hidden_size);
EXPECT_EQ(gru_cell->get_output_element_type(0), element::f32);
EXPECT_EQ(gru_cell->get_output_partial_shape(0), (PartialShape{batch_size, hidden_size}));
}
@ -154,12 +157,14 @@ TEST(type_prop, gru_cell_dynamic_hidden_size) {
const auto hidden_size = Dimension::dynamic();
const size_t gates_count = 3;
const auto X = make_shared<op::Parameter>(element::f32, PartialShape{batch_size, input_size});
const auto W = make_shared<op::Parameter>(element::f32, PartialShape{hidden_size * gates_count, input_size});
const auto R = make_shared<op::Parameter>(element::f32, PartialShape{hidden_size * gates_count, hidden_size});
const auto H_t = make_shared<op::Parameter>(element::f32, PartialShape{batch_size, hidden_size});
const auto X = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{batch_size, input_size});
const auto W =
make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{hidden_size * gates_count, input_size});
const auto R =
make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{hidden_size * gates_count, hidden_size});
const auto H_t = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{batch_size, hidden_size});
const auto gru_cell = make_shared<opset4::GRUCell>(X, H_t, W, R, 3);
const auto gru_cell = make_shared<ov::op::v3::GRUCell>(X, H_t, W, R, 3);
EXPECT_EQ(gru_cell->get_output_element_type(0), element::f32);
EXPECT_EQ(gru_cell->get_output_partial_shape(0), (PartialShape{batch_size, hidden_size}));
}
@ -169,12 +174,12 @@ TEST(type_prop, gru_cell_dynamic_inputs) {
const auto input_size = Dimension::dynamic();
const auto hidden_size = Dimension::dynamic();
const auto X = make_shared<op::Parameter>(element::f32, PartialShape{batch_size, input_size});
const auto W = make_shared<op::Parameter>(element::f32, PartialShape{hidden_size, input_size});
const auto R = make_shared<op::Parameter>(element::f32, PartialShape{hidden_size, hidden_size});
const auto H_t = make_shared<op::Parameter>(element::f32, PartialShape{batch_size, hidden_size});
const auto X = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{batch_size, input_size});
const auto W = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{hidden_size, input_size});
const auto R = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{hidden_size, hidden_size});
const auto H_t = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{batch_size, hidden_size});
const auto gru_cell = make_shared<opset4::GRUCell>(X, H_t, W, R, 2);
const auto gru_cell = make_shared<ov::op::v3::GRUCell>(X, H_t, W, R, 2);
EXPECT_EQ(gru_cell->get_output_partial_shape(0), (PartialShape{batch_size, hidden_size}));
EXPECT_EQ(gru_cell->get_output_element_type(0), element::f32);
@ -186,42 +191,42 @@ TEST(type_prop, gru_cell_invalid_input_rank0) {
const size_t hidden_size = 3;
const size_t gates_count = 3;
auto X = make_shared<op::Parameter>(element::f32, PartialShape{batch_size, input_size});
auto R = make_shared<op::Parameter>(element::f32, PartialShape{gates_count * hidden_size, hidden_size});
auto H_t = make_shared<op::Parameter>(element::f32, PartialShape{batch_size, hidden_size});
auto X = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{batch_size, input_size});
auto R = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{gates_count * hidden_size, hidden_size});
auto H_t = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{batch_size, hidden_size});
// Invalid rank0 for W tensor.
auto W = make_shared<op::Parameter>(element::f32, PartialShape{});
ASSERT_THROW(const auto unused = make_shared<opset4::GRUCell>(X, H_t, W, R, hidden_size),
ngraph::NodeValidationFailure)
auto W = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{});
ASSERT_THROW(const auto unused = make_shared<ov::op::v3::GRUCell>(X, H_t, W, R, hidden_size),
ov::NodeValidationFailure)
<< "GRUCell node was created with invalid data.";
// Invalid rank0 for X tensor.
W = make_shared<op::Parameter>(element::f32, PartialShape{gates_count * hidden_size, input_size});
X = make_shared<op::Parameter>(element::f32, PartialShape{});
ASSERT_THROW(const auto unused = make_shared<opset4::GRUCell>(X, H_t, W, R, hidden_size),
ngraph::NodeValidationFailure)
W = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{gates_count * hidden_size, input_size});
X = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{});
ASSERT_THROW(const auto unused = make_shared<ov::op::v3::GRUCell>(X, H_t, W, R, hidden_size),
ov::NodeValidationFailure)
<< "GRUCell node was created with invalid data.";
// Invalid rank0 for H_t tensor.
X = make_shared<op::Parameter>(element::f32, PartialShape{batch_size, input_size});
H_t = make_shared<op::Parameter>(element::f32, PartialShape{});
ASSERT_THROW(const auto unused = make_shared<opset4::GRUCell>(X, H_t, W, R, hidden_size),
ngraph::NodeValidationFailure)
X = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{batch_size, input_size});
H_t = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{});
ASSERT_THROW(const auto unused = make_shared<ov::op::v3::GRUCell>(X, H_t, W, R, hidden_size),
ov::NodeValidationFailure)
<< "GRUCell node was created with invalid data.";
// Invalid rank0 for R tensor.
H_t = make_shared<op::Parameter>(element::f32, PartialShape{batch_size, hidden_size});
R = make_shared<op::Parameter>(element::f32, PartialShape{});
ASSERT_THROW(const auto unused = make_shared<opset4::GRUCell>(X, H_t, W, R, hidden_size),
ngraph::NodeValidationFailure)
H_t = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{batch_size, hidden_size});
R = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{});
ASSERT_THROW(const auto unused = make_shared<ov::op::v3::GRUCell>(X, H_t, W, R, hidden_size),
ov::NodeValidationFailure)
<< "GRUCell node was created with invalid data.";
// Invalid rank0 for B tensor.
R = make_shared<op::Parameter>(element::f32, PartialShape{gates_count * hidden_size, input_size});
auto B = make_shared<op::Parameter>(element::f32, PartialShape{});
ASSERT_THROW(const auto unused = make_shared<opset4::GRUCell>(X, H_t, W, R, B, hidden_size),
ngraph::NodeValidationFailure)
R = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{gates_count * hidden_size, input_size});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{});
ASSERT_THROW(const auto unused = make_shared<ov::op::v3::GRUCell>(X, H_t, W, R, B, hidden_size),
ov::NodeValidationFailure)
<< "GRUCell node was created with invalid data.";
}
@ -231,41 +236,41 @@ TEST(type_prop, gru_cell_input_dynamic_rank) {
int64_t hidden_size = 3;
int64_t gates_count = 3;
auto X = make_shared<op::Parameter>(element::f32, PartialShape{batch_size, input_size});
auto R = make_shared<op::Parameter>(element::f32, PartialShape{gates_count * hidden_size, hidden_size});
auto H_t = make_shared<op::Parameter>(element::f32, PartialShape{batch_size, hidden_size});
auto X = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{batch_size, input_size});
auto R = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{gates_count * hidden_size, hidden_size});
auto H_t = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{batch_size, hidden_size});
auto check_dynamic_gru = [&](const shared_ptr<opset4::GRUCell>& gru) -> bool {
auto check_dynamic_gru = [&](const shared_ptr<ov::op::v3::GRUCell>& gru) -> bool {
return gru->output(0).get_partial_shape() == PartialShape{batch_size, hidden_size} &&
gru->output(0).get_element_type() == gru->input(0).get_element_type();
};
// Dynamic rank for W tensor.
auto W = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(Rank::dynamic()));
auto gru_w = make_shared<opset4::GRUCell>(X, H_t, W, R, hidden_size);
auto W = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(Rank::dynamic()));
auto gru_w = make_shared<ov::op::v3::GRUCell>(X, H_t, W, R, hidden_size);
EXPECT_EQ(check_dynamic_gru(gru_w), true);
// Dynamic rank for X tensor.
W = make_shared<op::Parameter>(element::f32, PartialShape{gates_count * hidden_size, input_size});
X = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(Rank::dynamic()));
auto gru_x = make_shared<opset4::GRUCell>(X, H_t, W, R, hidden_size);
W = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{gates_count * hidden_size, input_size});
X = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(Rank::dynamic()));
auto gru_x = make_shared<ov::op::v3::GRUCell>(X, H_t, W, R, hidden_size);
EXPECT_EQ(check_dynamic_gru(gru_x), true);
// Dynamic rank for H_t tensor.
X = make_shared<op::Parameter>(element::f32, PartialShape{batch_size, input_size});
H_t = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(Rank::dynamic()));
auto gru_h = make_shared<opset4::GRUCell>(X, H_t, W, R, hidden_size);
X = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{batch_size, input_size});
H_t = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(Rank::dynamic()));
auto gru_h = make_shared<ov::op::v3::GRUCell>(X, H_t, W, R, hidden_size);
EXPECT_EQ(check_dynamic_gru(gru_h), true);
// Dynamic rank for R tensor.
H_t = make_shared<op::Parameter>(element::f32, PartialShape{batch_size, hidden_size});
R = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(Rank::dynamic()));
auto gru_r = make_shared<opset4::GRUCell>(X, H_t, W, R, hidden_size);
H_t = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{batch_size, hidden_size});
R = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(Rank::dynamic()));
auto gru_r = make_shared<ov::op::v3::GRUCell>(X, H_t, W, R, hidden_size);
EXPECT_EQ(check_dynamic_gru(gru_r), true);
// Dynamic rank for B tensor.
R = make_shared<op::Parameter>(element::f32, PartialShape{gates_count * hidden_size, hidden_size});
auto B = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(Rank::dynamic()));
auto gru_b = make_shared<opset4::GRUCell>(X, H_t, W, R, B, hidden_size);
R = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{gates_count * hidden_size, hidden_size});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(Rank::dynamic()));
auto gru_b = make_shared<ov::op::v3::GRUCell>(X, H_t, W, R, B, hidden_size);
EXPECT_EQ(check_dynamic_gru(gru_b), true);
}

151
src/core/tests/type_prop/gru_sequence.cpp
View File

@ -2,13 +2,15 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/gru_sequence.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "ngraph/opsets/opset5.hpp"
#include "openvino/op/parameter.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
struct gru_sequence_parameters {
Dimension batch_size = 8;
@ -16,10 +18,10 @@ struct gru_sequence_parameters {
Dimension seq_length = 6;
Dimension input_size = 4;
Dimension hidden_size = 128;
ngraph::element::Type et = element::f32;
ov::element::Type et = element::f32;
};
shared_ptr<opset5::GRUSequence> gru_seq_tensor_initialization(const gru_sequence_parameters& param) {
shared_ptr<ov::op::v5::GRUSequence> gru_seq_tensor_initialization(const gru_sequence_parameters& param) {
auto batch_size = param.batch_size;
auto seq_length = param.seq_length;
auto input_size = param.input_size;
@ -27,15 +29,15 @@ shared_ptr<opset5::GRUSequence> gru_seq_tensor_initialization(const gru_sequence
auto hidden_size = param.hidden_size;
auto et = param.et;
const auto X = make_shared<opset5::Parameter>(et, PartialShape{batch_size, seq_length, input_size});
const auto X = make_shared<ov::op::v0::Parameter>(et, PartialShape{batch_size, seq_length, input_size});
const auto initial_hidden_state =
make_shared<opset5::Parameter>(et, PartialShape{batch_size, num_directions, hidden_size});
const auto sequence_lengths = make_shared<opset5::Parameter>(et, PartialShape{batch_size});
const auto W = make_shared<opset5::Parameter>(et, PartialShape{num_directions, hidden_size * 3, input_size});
const auto R = make_shared<opset5::Parameter>(et, PartialShape{num_directions, hidden_size * 3, hidden_size});
const auto B = make_shared<opset5::Parameter>(et, PartialShape{num_directions, hidden_size * 3});
make_shared<ov::op::v0::Parameter>(et, PartialShape{batch_size, num_directions, hidden_size});
const auto sequence_lengths = make_shared<ov::op::v0::Parameter>(et, PartialShape{batch_size});
const auto W = make_shared<ov::op::v0::Parameter>(et, PartialShape{num_directions, hidden_size * 3, input_size});
const auto R = make_shared<ov::op::v0::Parameter>(et, PartialShape{num_directions, hidden_size * 3, hidden_size});
const auto B = make_shared<ov::op::v0::Parameter>(et, PartialShape{num_directions, hidden_size * 3});
const auto gru_sequence = make_shared<opset5::GRUSequence>();
const auto gru_sequence = make_shared<ov::op::v5::GRUSequence>();
gru_sequence->set_argument(0, X);
gru_sequence->set_argument(1, initial_hidden_state);
@ -47,8 +49,8 @@ shared_ptr<opset5::GRUSequence> gru_seq_tensor_initialization(const gru_sequence
return gru_sequence;
}
shared_ptr<opset5::GRUSequence> gru_seq_direction_initialization(const gru_sequence_parameters& param,
op::RecurrentSequenceDirection direction) {
shared_ptr<ov::op::v5::GRUSequence> gru_seq_direction_initialization(const gru_sequence_parameters& param,
op::RecurrentSequenceDirection direction) {
auto batch_size = param.batch_size;
auto seq_length = param.seq_length;
auto input_size = param.input_size;
@ -57,22 +59,22 @@ shared_ptr<opset5::GRUSequence> gru_seq_direction_initialization(const gru_seque
auto hidden_size_value = hidden_size.is_dynamic() ? 0 : hidden_size.get_length();
auto et = param.et;
const auto X = make_shared<opset5::Parameter>(et, PartialShape{batch_size, seq_length, input_size});
const auto X = make_shared<ov::op::v0::Parameter>(et, PartialShape{batch_size, seq_length, input_size});
const auto initial_hidden_state =
make_shared<opset5::Parameter>(et, PartialShape{batch_size, num_directions, hidden_size});
const auto sequence_lengths = make_shared<opset5::Parameter>(et, PartialShape{batch_size});
const auto W = make_shared<opset5::Parameter>(et, PartialShape{num_directions, hidden_size * 3, input_size});
const auto R = make_shared<opset5::Parameter>(et, PartialShape{num_directions, hidden_size * 3, hidden_size});
const auto B = make_shared<opset5::Parameter>(et, PartialShape{num_directions, hidden_size * 3});
make_shared<ov::op::v0::Parameter>(et, PartialShape{batch_size, num_directions, hidden_size});
const auto sequence_lengths = make_shared<ov::op::v0::Parameter>(et, PartialShape{batch_size});
const auto W = make_shared<ov::op::v0::Parameter>(et, PartialShape{num_directions, hidden_size * 3, input_size});
const auto R = make_shared<ov::op::v0::Parameter>(et, PartialShape{num_directions, hidden_size * 3, hidden_size});
const auto B = make_shared<ov::op::v0::Parameter>(et, PartialShape{num_directions, hidden_size * 3});
auto gru_sequence = make_shared<opset5::GRUSequence>(X,
initial_hidden_state,
sequence_lengths,
W,
R,
B,
hidden_size_value,
direction);
auto gru_sequence = make_shared<ov::op::v5::GRUSequence>(X,
initial_hidden_state,
sequence_lengths,
W,
R,
B,
hidden_size_value,
direction);
return gru_sequence;
}
@ -84,18 +86,25 @@ TEST(type_prop, gru_sequence_forward) {
const size_t input_size = 4;
const size_t hidden_size = 128;
const auto X = make_shared<opset5::Parameter>(element::f32, Shape{batch_size, seq_length, input_size});
const auto X = make_shared<ov::op::v0::Parameter>(element::f32, Shape{batch_size, seq_length, input_size});
const auto initial_hidden_state =
make_shared<opset5::Parameter>(element::f32, Shape{batch_size, num_directions, hidden_size});
const auto sequence_lengths = make_shared<op::Parameter>(element::i32, Shape{batch_size});
const auto W = make_shared<opset5::Parameter>(element::f32, Shape{num_directions, 3 * hidden_size, input_size});
const auto R = make_shared<opset5::Parameter>(element::f32, Shape{num_directions, 3 * hidden_size, hidden_size});
const auto B = make_shared<opset5::Parameter>(element::f32, Shape{num_directions, 3 * hidden_size});
make_shared<ov::op::v0::Parameter>(element::f32, Shape{batch_size, num_directions, hidden_size});
const auto sequence_lengths = make_shared<op::v0::Parameter>(element::i32, Shape{batch_size});
const auto W = make_shared<ov::op::v0::Parameter>(element::f32, Shape{num_directions, 3 * hidden_size, input_size});
const auto R =
make_shared<ov::op::v0::Parameter>(element::f32, Shape{num_directions, 3 * hidden_size, hidden_size});
const auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{num_directions, 3 * hidden_size});
const auto direction = op::RecurrentSequenceDirection::FORWARD;
const auto sequence =
make_shared<opset5::GRUSequence>(X, initial_hidden_state, sequence_lengths, W, R, B, hidden_size, direction);
const auto sequence = make_shared<ov::op::v5::GRUSequence>(X,
initial_hidden_state,
sequence_lengths,
W,
R,
B,
hidden_size,
direction);
EXPECT_EQ(sequence->get_hidden_size(), hidden_size);
EXPECT_EQ(sequence->get_direction(), op::RecurrentSequenceDirection::FORWARD);
@ -119,30 +128,31 @@ TEST(type_prop, gru_sequence_bidirectional) {
const size_t input_size = 4;
const size_t hidden_size = 128;
const auto X = make_shared<opset5::Parameter>(element::f32, Shape{batch_size, seq_length, input_size});
const auto X = make_shared<ov::op::v0::Parameter>(element::f32, Shape{batch_size, seq_length, input_size});
const auto initial_hidden_state =
make_shared<opset5::Parameter>(element::f32, Shape{batch_size, num_directions, hidden_size});
const auto sequence_lengths = make_shared<op::Parameter>(element::i32, Shape{batch_size});
const auto W = make_shared<opset5::Parameter>(element::f32, Shape{num_directions, 3 * hidden_size, input_size});
const auto R = make_shared<opset5::Parameter>(element::f32, Shape{num_directions, 3 * hidden_size, hidden_size});
const auto B = make_shared<opset5::Parameter>(element::f32, Shape{num_directions, 3 * hidden_size});
make_shared<ov::op::v0::Parameter>(element::f32, Shape{batch_size, num_directions, hidden_size});
const auto sequence_lengths = make_shared<op::v0::Parameter>(element::i32, Shape{batch_size});
const auto W = make_shared<ov::op::v0::Parameter>(element::f32, Shape{num_directions, 3 * hidden_size, input_size});
const auto R =
make_shared<ov::op::v0::Parameter>(element::f32, Shape{num_directions, 3 * hidden_size, hidden_size});
const auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{num_directions, 3 * hidden_size});
const auto direction = op::RecurrentSequenceDirection::BIDIRECTIONAL;
const std::vector<float> activations_alpha = {2.7f, 7.0f, 32.367f};
const std::vector<float> activations_beta = {0.0f, 5.49f, 6.0f};
const std::vector<std::string> activations = {"tanh", "sigmoid"};
const auto sequence = make_shared<opset5::GRUSequence>(X,
initial_hidden_state,
sequence_lengths,
W,
R,
B,
hidden_size,
direction,
activations,
activations_alpha,
activations_beta);
const auto sequence = make_shared<ov::op::v5::GRUSequence>(X,
initial_hidden_state,
sequence_lengths,
W,
R,
B,
hidden_size,
direction,
activations,
activations_alpha,
activations_beta);
EXPECT_EQ(sequence->get_hidden_size(), hidden_size);
EXPECT_EQ(sequence->get_direction(), op::RecurrentSequenceDirection::BIDIRECTIONAL);
@ -249,7 +259,7 @@ TEST(type_prop, gru_sequence_invalid_input_dimension) {
param.et = element::f32;
auto gru_sequence = gru_seq_tensor_initialization(param);
auto invalid_rank0_tensor = make_shared<opset5::Parameter>(param.et, PartialShape{});
auto invalid_rank0_tensor = make_shared<ov::op::v0::Parameter>(param.et, PartialShape{});
// Validate invalid rank0 tensor for all inputs: X, initial_hidden_state, W, R, B
for (size_t i = 0; i < gru_sequence->get_input_size(); i++) {
@ -291,7 +301,7 @@ TEST(type_prop, gru_sequence_input_dynamic_rank) {
param.et = element::f32;
auto gru_sequence = gru_seq_tensor_initialization(param);
auto dynamic_tensor = make_shared<opset5::Parameter>(param.et, PartialShape::dynamic(Rank::dynamic()));
auto dynamic_tensor = make_shared<ov::op::v0::Parameter>(param.et, PartialShape::dynamic(Rank::dynamic()));
for (size_t i = 0; i < gru_sequence->get_input_size(); i++) {
gru_sequence = gru_seq_tensor_initialization(param);
@ -321,21 +331,22 @@ TEST(type_prop, gru_sequence_all_inputs_dynamic_rank) {
param.hidden_size = 128;
param.et = element::f32;
const auto X = make_shared<opset5::Parameter>(param.et, PartialShape::dynamic(Rank::dynamic()));
const auto initial_hidden_state = make_shared<opset5::Parameter>(param.et, PartialShape::dynamic(Rank::dynamic()));
const auto sequence_lengths = make_shared<opset5::Parameter>(param.et, PartialShape::dynamic(Rank::dynamic()));
const auto W = make_shared<opset5::Parameter>(param.et, PartialShape::dynamic(Rank::dynamic()));
const auto R = make_shared<opset5::Parameter>(param.et, PartialShape::dynamic(Rank::dynamic()));
const auto B = make_shared<opset5::Parameter>(param.et, PartialShape::dynamic(Rank::dynamic()));
const auto X = make_shared<ov::op::v0::Parameter>(param.et, PartialShape::dynamic(Rank::dynamic()));
const auto initial_hidden_state =
make_shared<ov::op::v0::Parameter>(param.et, PartialShape::dynamic(Rank::dynamic()));
const auto sequence_lengths = make_shared<ov::op::v0::Parameter>(param.et, PartialShape::dynamic(Rank::dynamic()));
const auto W = make_shared<ov::op::v0::Parameter>(param.et, PartialShape::dynamic(Rank::dynamic()));
const auto R = make_shared<ov::op::v0::Parameter>(param.et, PartialShape::dynamic(Rank::dynamic()));
const auto B = make_shared<ov::op::v0::Parameter>(param.et, PartialShape::dynamic(Rank::dynamic()));
const auto gru_sequence = make_shared<opset5::GRUSequence>(X,
initial_hidden_state,
sequence_lengths,
W,
R,
B,
param.hidden_size.get_length(),
op::RecurrentSequenceDirection::FORWARD);
const auto gru_sequence = make_shared<ov::op::v5::GRUSequence>(X,
initial_hidden_state,
sequence_lengths,
W,
R,
B,
param.hidden_size.get_length(),
op::RecurrentSequenceDirection::FORWARD);
EXPECT_EQ(gru_sequence->get_output_partial_shape(0), (PartialShape{-1, 1, -1, -1}));
EXPECT_EQ(gru_sequence->get_output_partial_shape(1), (PartialShape{-1, 1, -1}));
EXPECT_EQ(gru_sequence->get_output_element_type(0), param.et);

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

@ -2,20 +2,24 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/hard_sigmoid.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/parameter.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
TEST(type_prop, hardsigmoid) {
const Shape data_shape{3, 5};
const auto P = make_shared<op::Parameter>(element::f32, data_shape);
const auto alpha = op::Constant::create<float>(P->get_element_type(), Shape{}, {0.1f});
const auto beta = op::Constant::create<float>(P->get_element_type(), Shape{}, {1.2f});
const auto H = make_shared<op::HardSigmoid>(P, alpha, beta);
const auto P = make_shared<op::v0::Parameter>(element::f32, data_shape);
const auto alpha = op::v0::Constant::create<float>(P->get_element_type(), Shape{}, {0.1f});
const auto beta = op::v0::Constant::create<float>(P->get_element_type(), Shape{}, {1.2f});
const auto H = make_shared<op::v0::HardSigmoid>(P, alpha, beta);
ASSERT_EQ(H->get_element_type(), element::f32);
ASSERT_EQ(H->get_shape(), data_shape);
}

16
src/core/tests/type_prop/hsigmoid.cpp
View File

@ -2,34 +2,36 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/hsigmoid.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, hsigmoid) {
auto data = make_shared<op::Parameter>(element::f32, Shape{1, 3, 6});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 6});
auto hsigmoid_func = make_shared<op::v5::HSigmoid>(data);
EXPECT_EQ(hsigmoid_func->get_element_type(), element::f32);
EXPECT_EQ(hsigmoid_func->get_shape(), data->get_output_shape(0));
}
TEST(type_prop, hsigmoid_partial) {
auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto hsigmoid_func = make_shared<op::v5::HSigmoid>(data);
EXPECT_EQ(hsigmoid_func->get_element_type(), element::f32);
ASSERT_TRUE(hsigmoid_func->get_output_partial_shape(0).same_scheme(data->get_output_partial_shape(0)));
// rank unknown
auto hsigmoid_partial =
make_shared<op::v5::HSigmoid>(make_shared<op::Parameter>(element::f32, PartialShape::dynamic()));
make_shared<op::v5::HSigmoid>(make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic()));
ASSERT_TRUE(hsigmoid_partial->get_output_partial_shape(0).same_scheme(PartialShape::dynamic()));
}
TEST(type_prop, hsigmoid_partial_static_rank) {
auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto hsigmoid_func = make_shared<op::v5::HSigmoid>(data);
EXPECT_EQ(hsigmoid_func->get_element_type(), element::f32);
ASSERT_TRUE(hsigmoid_func->get_output_partial_shape(0).same_scheme(data->get_output_partial_shape(0)));

16
src/core/tests/type_prop/hswish.cpp
View File

@ -2,34 +2,36 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/hswish.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, hswish) {
auto data = make_shared<op::Parameter>(element::f32, Shape{1, 3, 6});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 6});
auto hswish_func = make_shared<op::v4::HSwish>(data);
EXPECT_EQ(hswish_func->get_element_type(), element::f32);
EXPECT_EQ(hswish_func->get_shape(), data->get_output_shape(0));
}
TEST(type_prop, hswish_partial) {
auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto hswish_func = make_shared<op::v4::HSwish>(data);
EXPECT_EQ(hswish_func->get_element_type(), element::f32);
ASSERT_TRUE(hswish_func->get_output_partial_shape(0).same_scheme(data->get_output_partial_shape(0)));
// rank unknown
auto hswish_partial =
make_shared<op::v4::HSwish>(make_shared<op::Parameter>(element::f32, PartialShape::dynamic()));
make_shared<op::v4::HSwish>(make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic()));
ASSERT_TRUE(hswish_partial->get_output_partial_shape(0).same_scheme(PartialShape::dynamic()));
}
TEST(type_prop, hswish_partial_static_rank) {
auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto hswish_func = make_shared<op::v4::HSwish>(data);
EXPECT_EQ(hswish_func->get_element_type(), element::f32);
ASSERT_TRUE(hswish_func->get_output_partial_shape(0).same_scheme(data->get_output_partial_shape(0)));

66
src/core/tests/type_prop/idft.cpp
View File

@ -2,11 +2,15 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/op/idft.hpp"
using namespace ngraph;
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/parameter.hpp"
using namespace ov;
struct ConstantAxesAndConstantSignalSizeTestParams {
PartialShape input_shape;
@ -22,15 +26,15 @@ struct ConstantAxesAndConstantSignalSizeTest : ::testing::TestWithParam<Constant
TEST_P(ConstantAxesAndConstantSignalSizeTest, idft_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::IDFT> idft;
if (params.signal_size.empty()) {
idft = std::make_shared<op::v7::IDFT>(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);
idft = std::make_shared<op::v7::IDFT>(data, axes_input, signal_size_input);
}
@ -175,8 +179,8 @@ TEST(type_prop, idft_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 idft = std::make_shared<op::v7::IDFT>(data, axes_input);
EXPECT_EQ(idft->get_element_type(), element::f32);
@ -194,8 +198,8 @@ struct NonConstantAxesTest : ::testing::TestWithParam<NonConstantAxesTestParams>
TEST_P(NonConstantAxesTest, idft_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 idft = std::make_shared<op::v7::IDFT>(data, axes_input);
EXPECT_EQ(idft->get_element_type(), element::f32);
@ -267,9 +271,9 @@ struct NonConstantSignalSizeTest : ::testing::TestWithParam<NonConstantSignalSiz
TEST_P(NonConstantSignalSizeTest, idft_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 idft = std::make_shared<op::v7::IDFT>(data, axes_input, signal_size_input);
EXPECT_EQ(idft->get_element_type(), element::f32);
@ -298,10 +302,10 @@ INSTANTIATE_TEST_SUITE_P(
PrintToDummyParamName());
TEST(type_prop, idft_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 idft = std::make_shared<op::v7::IDFT>(data, axes);
FAIL() << "IDFT node was created with invalid input.";
} catch (const NodeValidationFailure& error) {
@ -309,7 +313,7 @@ TEST(type_prop, idft_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 idft = std::make_shared<op::v7::IDFT>(data, axes);
FAIL() << "IDFT node was created with invalid input.";
} catch (const NodeValidationFailure& error) {
@ -317,7 +321,7 @@ TEST(type_prop, idft_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 idft = std::make_shared<op::v7::IDFT>(data, axes);
FAIL() << "IDFT node was created with invalid input.";
} catch (const NodeValidationFailure& error) {
@ -326,10 +330,10 @@ TEST(type_prop, idft_invalid_input) {
}
TEST(type_prop, idft_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 idft = std::make_shared<op::v7::IDFT>(data, axes);
FAIL() << "IDFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) {
@ -337,7 +341,7 @@ TEST(type_prop, idft_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 idft = std::make_shared<op::v7::IDFT>(data, axes);
FAIL() << "IDFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) {
@ -345,7 +349,7 @@ TEST(type_prop, idft_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 idft = std::make_shared<op::v7::IDFT>(data, axes);
FAIL() << "IDFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) {
@ -353,7 +357,7 @@ TEST(type_prop, idft_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 idft = std::make_shared<op::v7::IDFT>(data, axes);
FAIL() << "IDFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) {
@ -361,7 +365,7 @@ TEST(type_prop, idft_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 idft = std::make_shared<op::v7::IDFT>(data, axes);
FAIL() << "IDFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) {
@ -370,11 +374,11 @@ TEST(type_prop, idft_invalid_axes) {
}
TEST(type_prop, idft_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 idft = std::make_shared<op::v7::IDFT>(data, axes, signal_size);
FAIL() << "IDFT node was created with invalid signal size.";
} catch (const NodeValidationFailure& error) {
@ -382,7 +386,7 @@ TEST(type_prop, idft_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 idft = std::make_shared<op::v7::IDFT>(data, axes, signal_size);
FAIL() << "IDFT node was created with invalid signal size.";
} catch (const NodeValidationFailure& error) {
@ -396,9 +400,9 @@ TEST(type_prop, idft_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 idft = std::make_shared<op::v7::IDFT>(data, axes_input, signal_size_input);
EXPECT_EQ(idft->get_element_type(), element::dynamic);

246
src/core/tests/type_prop/if.cpp
View File

@ -2,37 +2,44 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/if.hpp"
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/builder/reshape.hpp"
#include "ngraph/ngraph.hpp"
#include "ngraph/opsets/opset5.hpp"
#include "openvino/op/add.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/convert.hpp"
#include "openvino/op/maximum.hpp"
#include "openvino/op/multiply.hpp"
#include "openvino/op/reduce_mean.hpp"
#include "openvino/op/result.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
TEST(type_prop, if_simple_test) {
// That which we iterate over
auto X = make_shared<op::Parameter>(element::f32, Shape{32, 40, 10});
auto Y = make_shared<op::Parameter>(element::f32, Shape{32, 40, 10});
auto cond = std::make_shared<ngraph::opset5::Constant>(ngraph::element::boolean, ngraph::Shape{1}, true);
auto X = make_shared<ov::op::v0::Parameter>(element::f32, Shape{32, 40, 10});
auto Y = make_shared<ov::op::v0::Parameter>(element::f32, Shape{32, 40, 10});
auto cond = std::make_shared<ov::op::v0::Constant>(ngraph::element::boolean, ngraph::Shape{1}, true);
// Set up the cell body, a function from (Xi, Yi) -> (Zo)
// Body parameters
auto Xt = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Yt = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Xe = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Ye = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Xt = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Yt = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Xe = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Ye = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
// Body
auto then_op = std::make_shared<op::v1::Add>(Xt, Yt);
auto convert_then_op = std::make_shared<op::v0::Convert>(then_op, element::f32);
auto then_op_res = std::make_shared<op::Result>(convert_then_op);
auto then_op_res = std::make_shared<op::v0::Result>(convert_then_op);
auto then_body = make_shared<ngraph::Function>(OutputVector{then_op_res}, ParameterVector{Xt, Yt});
auto else_op = std::make_shared<op::v1::Maximum>(Xe, Ye);
auto convert_else_op = std::make_shared<op::v0::Convert>(else_op, element::f32);
auto else_op_res = std::make_shared<op::Result>(convert_else_op);
auto else_op_res = std::make_shared<ov::op::v0::Result>(convert_else_op);
auto else_body = make_shared<ngraph::Function>(OutputVector{else_op_res}, ParameterVector{Xe, Ye});
auto if_op = make_shared<op::v8::If>(cond);
if_op->set_then_body(then_body);
@ -40,7 +47,7 @@ TEST(type_prop, if_simple_test) {
if_op->set_input(X, Xt, Xe);
if_op->set_input(Y, Yt, Ye);
auto res = if_op->set_output(then_op_res, else_op_res);
auto result0 = make_shared<op::Result>(res);
auto result0 = make_shared<op::v0::Result>(res);
Shape out0_shape{32, 40, 10};
auto sh = result0->get_output_shape(0);
EXPECT_EQ(sh, out0_shape);
@ -54,23 +61,23 @@ TEST(type_prop, if_simple_test) {
TEST(type_prop, if_non_const_condition_test) {
// That which we iterate over
auto X = make_shared<op::Parameter>(element::f32, Shape{32, 40, 10});
auto Y = make_shared<op::Parameter>(element::f32, Shape{32, 40, 10});
auto cond = make_shared<op::Parameter>(element::boolean, Shape{1});
auto X = make_shared<ov::op::v0::Parameter>(element::f32, Shape{32, 40, 10});
auto Y = make_shared<ov::op::v0::Parameter>(element::f32, Shape{32, 40, 10});
auto cond = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{1});
// Set up the cell body, a function from (Xi, Yi) -> (Zo)
// Body parameters
auto Xt = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Yt = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Xe = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Ye = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Xt = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Yt = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Xe = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Ye = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
// Body
auto then_op = std::make_shared<op::v1::Add>(Xt, Yt);
auto then_body_res = make_shared<op::Result>(then_op);
auto then_body_res = make_shared<ov::op::v0::Result>(then_op);
auto then_body = make_shared<ngraph::Function>(OutputVector{then_body_res}, ParameterVector{Xt, Yt});
auto else_op = std::make_shared<op::v1::Maximum>(Xe, Ye);
auto else_body_res = make_shared<op::Result>(else_op);
auto else_body_res = make_shared<ov::op::v0::Result>(else_op);
auto else_body = make_shared<ngraph::Function>(OutputVector{else_body_res}, ParameterVector{Xe, Ye});
auto if_op = make_shared<op::v8::If>(cond);
@ -79,31 +86,31 @@ TEST(type_prop, if_non_const_condition_test) {
if_op->set_input(X, Xt, Xe);
if_op->set_input(Y, Yt, Ye);
auto res = if_op->set_output(then_body_res, else_body_res);
auto result0 = make_shared<op::Result>(res);
auto result0 = make_shared<ov::op::v0::Result>(res);
Shape out0_shape{32, 40, 10};
auto sh = result0->get_output_shape(0);
EXPECT_EQ(sh, out0_shape);
}
TEST(type_prop, if_clone_test) {
auto X = make_shared<op::Parameter>(element::f32, Shape{32, 40, 10});
auto Y = make_shared<op::Parameter>(element::f32, Shape{32, 40, 10});
auto cond = make_shared<op::Parameter>(element::boolean, Shape{1});
auto X = make_shared<ov::op::v0::Parameter>(element::f32, Shape{32, 40, 10});
auto Y = make_shared<ov::op::v0::Parameter>(element::f32, Shape{32, 40, 10});
auto cond = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{1});
// Set up the cell body, a function from (Xi, Yi) -> (Zo)
// Body parameters
auto Xt = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Yt = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Xe = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Ye = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Xnew = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Ynew = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Xt = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Yt = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Xe = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Ye = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Xnew = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Ynew = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
// Body
auto then_op = std::make_shared<op::v1::Add>(Xt, Yt);
auto then_body_res = make_shared<op::Result>(then_op);
auto then_body_res = make_shared<ov::op::v0::Result>(then_op);
auto then_body = make_shared<ngraph::Function>(OutputVector{then_body_res}, ParameterVector{Xt, Yt});
auto else_op = std::make_shared<op::v1::Maximum>(Xe, Ye);
auto else_body_res = make_shared<op::Result>(else_op);
auto else_body_res = make_shared<ov::op::v0::Result>(else_op);
auto else_body = make_shared<ngraph::Function>(OutputVector{else_body_res}, ParameterVector{Xe, Ye});
auto if_op = make_shared<op::v8::If>(cond);
if_op->set_then_body(then_body);
@ -116,30 +123,29 @@ TEST(type_prop, if_clone_test) {
}
TEST(type_prop, if_multiple_outputs) {
auto X = make_shared<op::Parameter>(element::f32, Shape{32, 40, 10});
auto Y = make_shared<op::Parameter>(element::f32, Shape{32, 40, 10});
auto cond = make_shared<op::Parameter>(element::boolean, Shape{1});
auto X = make_shared<ov::op::v0::Parameter>(element::f32, Shape{32, 40, 10});
auto Y = make_shared<ov::op::v0::Parameter>(element::f32, Shape{32, 40, 10});
auto cond = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{1});
// Set up the cell body, a function from (Xi, Yi) -> (Zo)
// Body parameters
auto Xt = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Yt = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Xe = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Ye = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Xnew = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Ynew = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Xt = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Yt = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Xe = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Ye = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Xnew = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Ynew = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
// Body
auto then_op = std::make_shared<op::v1::Add>(Xt, Yt);
auto then_body_res_1 = make_shared<op::Result>(then_op);
auto then_body_res_2 = make_shared<op::Result>(Xt);
auto then_body_res_1 = make_shared<ov::op::v0::Result>(then_op);
auto then_body_res_2 = make_shared<ov::op::v0::Result>(Xt);
auto then_body =
make_shared<ngraph::Function>(OutputVector{then_body_res_1, then_body_res_2}, ParameterVector{Xt, Yt});
auto else_op = std::make_shared<op::v1::Maximum>(Xe, Ye);
auto else_const = std::make_shared<ngraph::opset5::Constant>(ngraph::element::f32,
ngraph::Shape{1, 1, 1},
std::vector<float>{0.5f});
auto else_body_res_1 = make_shared<op::Result>(else_op);
auto else_body_res_2 = make_shared<op::Result>(else_const);
auto else_const =
std::make_shared<ov::op::v0::Constant>(ngraph::element::f32, ngraph::Shape{1, 1, 1}, std::vector<float>{0.5f});
auto else_body_res_1 = make_shared<ov::op::v0::Result>(else_op);
auto else_body_res_2 = make_shared<ov::op::v0::Result>(else_const);
auto else_body =
make_shared<ngraph::Function>(OutputVector{else_body_res_1, else_body_res_2}, ParameterVector{Xe, Ye});
@ -150,8 +156,8 @@ TEST(type_prop, if_multiple_outputs) {
if_op->set_input(Y, Yt, Ye);
auto res1 = if_op->set_output(then_body_res_1, else_body_res_1);
auto res2 = if_op->set_output(then_body_res_2, else_body_res_2);
auto result1 = make_shared<op::Result>(res1);
auto result2 = make_shared<op::Result>(res2);
auto result1 = make_shared<ov::op::v0::Result>(res1);
auto result2 = make_shared<ov::op::v0::Result>(res2);
Shape out0_shape{32, 40, 10};
auto sh = result1->get_output_shape(0);
auto is_dynamic = result2->is_dynamic();
@ -161,23 +167,23 @@ TEST(type_prop, if_multiple_outputs) {
TEST(type_prop, if_scalar_condition) {
// That which we iterate over
auto X = make_shared<op::Parameter>(element::f32, Shape{32, 40, 10});
auto Y = make_shared<op::Parameter>(element::f32, Shape{32, 40, 10});
auto cond = make_shared<op::Parameter>(element::boolean, Shape{});
auto X = make_shared<ov::op::v0::Parameter>(element::f32, Shape{32, 40, 10});
auto Y = make_shared<ov::op::v0::Parameter>(element::f32, Shape{32, 40, 10});
auto cond = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{});
// Set up the cell body, a function from (Xi, Yi) -> (Zo)
// Body parameters
auto Xt = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Yt = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Xe = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Ye = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Xt = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Yt = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Xe = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Ye = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
// Body
auto then_op = std::make_shared<op::v1::Add>(Xt, Yt);
auto then_body_res = make_shared<op::Result>(then_op);
auto then_body_res = make_shared<ov::op::v0::Result>(then_op);
auto then_body = make_shared<ngraph::Function>(OutputVector{then_body_res}, ParameterVector{Xt, Yt});
auto else_op = std::make_shared<op::v1::Maximum>(Xe, Ye);
auto else_body_res = make_shared<op::Result>(else_op);
auto else_body_res = make_shared<ov::op::v0::Result>(else_op);
auto else_body = make_shared<ngraph::Function>(OutputVector{else_body_res}, ParameterVector{Xe, Ye});
auto if_op = make_shared<op::v8::If>(cond);
@ -186,7 +192,7 @@ TEST(type_prop, if_scalar_condition) {
if_op->set_input(X, Xt, Xe);
if_op->set_input(Y, Yt, Ye);
auto res = if_op->set_output(then_body_res, else_body_res);
auto result0 = make_shared<op::Result>(res);
auto result0 = make_shared<ov::op::v0::Result>(res);
Shape out0_shape{32, 40, 10};
auto sh = result0->get_output_shape(0);
EXPECT_EQ(sh, out0_shape);
@ -196,21 +202,21 @@ TEST(type_prop, if_dynamic_output) {
// That which we iterate over
auto X_shape = Shape{1, 20, 5, 30};
auto Y_shape = Shape{18, 16, 14, 12};
auto X = make_shared<op::Parameter>(element::f32, X_shape);
auto Y = make_shared<op::Parameter>(element::f32, Y_shape);
auto cond = make_shared<op::Parameter>(element::boolean, Shape{1});
auto X = make_shared<ov::op::v0::Parameter>(element::f32, X_shape);
auto Y = make_shared<ov::op::v0::Parameter>(element::f32, Y_shape);
auto cond = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{1});
// Set up the cell body, a function from (Xi, Yi) -> (Zo)
// Body parameters
auto Xt = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Ye = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Xt = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Ye = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
// Body
auto then_op = std::make_shared<op::v1::Add>(Xt, Xt);
auto then_body_res = make_shared<op::Result>(then_op);
auto then_body_res = make_shared<ov::op::v0::Result>(then_op);
auto then_body = make_shared<ngraph::Function>(OutputVector{then_body_res}, ParameterVector{Xt});
auto else_op = std::make_shared<op::v1::Maximum>(Ye, Ye);
auto else_body_res = make_shared<op::Result>(else_op);
auto else_body_res = make_shared<ov::op::v0::Result>(else_op);
auto else_body = make_shared<ngraph::Function>(OutputVector{else_body_res}, ParameterVector{Ye});
auto if_op = make_shared<op::v8::If>(cond);
@ -219,7 +225,7 @@ TEST(type_prop, if_dynamic_output) {
if_op->set_input(X, Xt, nullptr);
if_op->set_input(Y, nullptr, Ye);
auto res = if_op->set_output(then_body_res, else_body_res);
auto result0 = make_shared<op::Result>(res);
auto result0 = make_shared<ov::op::v0::Result>(res);
auto dynamic_shape = result0->get_output_partial_shape(0);
EXPECT_EQ(X_shape.size(), dynamic_shape.rank().get_length());
@ -240,23 +246,23 @@ TEST(type_prop, if_dynamic_inputs) {
auto X_shape = PartialShape{Dimension::dynamic(), Dimension::dynamic(), Dimension::dynamic()};
auto Y_shape = PartialShape{Dimension::dynamic(), 20, 30};
;
auto X = make_shared<op::Parameter>(element::f32, X_shape);
auto Y = make_shared<op::Parameter>(element::f32, Y_shape);
auto cond = make_shared<op::Parameter>(element::boolean, Shape{1});
auto X = make_shared<ov::op::v0::Parameter>(element::f32, X_shape);
auto Y = make_shared<ov::op::v0::Parameter>(element::f32, Y_shape);
auto cond = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{1});
// Set up the cell body, a function from (Xi, Yi) -> (Zo)
// Body parameters
auto Xt = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Yt = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Xe = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Ye = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Xt = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Yt = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Xe = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Ye = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
// Body
auto then_op = std::make_shared<op::v1::Add>(Xt, Yt);
auto then_body_res = make_shared<op::Result>(then_op);
auto then_body_res = make_shared<ov::op::v0::Result>(then_op);
auto then_body = make_shared<ngraph::Function>(OutputVector{then_body_res}, ParameterVector{Xt, Yt});
auto else_op = std::make_shared<op::v1::Multiply>(Xe, Ye);
auto else_body_res = make_shared<op::Result>(else_op);
auto else_body_res = make_shared<ov::op::v0::Result>(else_op);
auto else_body = make_shared<ngraph::Function>(OutputVector{else_body_res}, ParameterVector{Xe, Ye});
auto if_op = make_shared<op::v8::If>(cond);
@ -265,7 +271,7 @@ TEST(type_prop, if_dynamic_inputs) {
if_op->set_input(X, Xt, Xe);
if_op->set_input(Y, Yt, Ye);
auto res = if_op->set_output(then_body_res, else_body_res);
auto result0 = make_shared<op::Result>(res);
auto result0 = make_shared<ov::op::v0::Result>(res);
auto dynamic_shape = result0->get_output_partial_shape(0);
auto expected_result = PartialShape{Dimension::dynamic(), 20, 30};
EXPECT_EQ(3, dynamic_shape.rank().get_length());
@ -278,20 +284,20 @@ TEST(type_prop, if_dynamic_inputs) {
TEST(type_prop, if_scalar_and_1d_union) {
// That which we iterate over
auto X = make_shared<op::Parameter>(element::f32, Shape{});
auto Y = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(1));
auto cond = make_shared<op::Parameter>(element::boolean, Shape{});
auto X = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto Y = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(1));
auto cond = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{});
// Body parameters
auto Xt = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Ye = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Xt = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Ye = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
// Body
auto then_op = std::make_shared<op::v1::Add>(Xt, Xt);
auto then_body_res = make_shared<op::Result>(then_op);
auto then_body_res = make_shared<ov::op::v0::Result>(then_op);
auto then_body = make_shared<ngraph::Function>(OutputVector{then_body_res}, ParameterVector{Xt});
auto else_op = std::make_shared<op::v1::Maximum>(Ye, Ye);
auto else_body_res = make_shared<op::Result>(else_op);
auto else_body_res = make_shared<ov::op::v0::Result>(else_op);
auto else_body = make_shared<ngraph::Function>(OutputVector{else_body_res}, ParameterVector{Ye});
auto if_op = make_shared<op::v8::If>(cond);
@ -300,7 +306,7 @@ TEST(type_prop, if_scalar_and_1d_union) {
if_op->set_input(X, Xt, nullptr);
if_op->set_input(Y, nullptr, Ye);
auto res = if_op->set_output(then_body_res, else_body_res);
auto result0 = make_shared<op::Result>(res);
auto result0 = make_shared<ov::op::v0::Result>(res);
PartialShape out_shape{PartialShape::dynamic(1)};
auto sh = result0->get_output_partial_shape(0);
EXPECT_EQ(sh, out_shape);
@ -308,20 +314,20 @@ TEST(type_prop, if_scalar_and_1d_union) {
TEST(type_prop, if_scalar_and_1d_static_union) {
// That which we iterate over
auto X = make_shared<op::Parameter>(element::f32, Shape{});
auto Y = make_shared<op::Parameter>(element::f32, PartialShape{8});
auto cond = make_shared<op::Parameter>(element::boolean, Shape{});
auto X = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto Y = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{8});
auto cond = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{});
// Body parameters
auto Xt = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Ye = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto Xt = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto Ye = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
// Body
auto then_op = std::make_shared<op::v1::Add>(Xt, Xt);
auto then_body_res = make_shared<op::Result>(then_op);
auto then_body_res = make_shared<ov::op::v0::Result>(then_op);
auto then_body = make_shared<ngraph::Function>(OutputVector{then_body_res}, ParameterVector{Xt});
auto else_op = std::make_shared<op::v1::Maximum>(Ye, Ye);
auto else_body_res = make_shared<op::Result>(else_op);
auto else_body_res = make_shared<ov::op::v0::Result>(else_op);
auto else_body = make_shared<ngraph::Function>(OutputVector{else_body_res}, ParameterVector{Ye});
auto if_op = make_shared<op::v8::If>(cond);
@ -330,7 +336,7 @@ TEST(type_prop, if_scalar_and_1d_static_union) {
if_op->set_input(X, Xt, nullptr);
if_op->set_input(Y, nullptr, Ye);
auto res = if_op->set_output(then_body_res, else_body_res);
auto result0 = make_shared<op::Result>(res);
auto result0 = make_shared<ov::op::v0::Result>(res);
PartialShape out_shape{PartialShape::dynamic(1)};
auto sh = result0->get_output_partial_shape(0);
EXPECT_EQ(sh, out_shape);
@ -338,24 +344,24 @@ TEST(type_prop, if_scalar_and_1d_static_union) {
TEST(type_prop, if_element_type_dynamic) {
// That which we iterate over
auto X = make_shared<op::Parameter>(element::f16, Shape{32, 40, 10});
auto Y = make_shared<op::Parameter>(element::f16, Shape{32, 40, 10});
auto cond = std::make_shared<ngraph::opset5::Constant>(ngraph::element::boolean, ngraph::Shape{1}, false);
auto X = make_shared<ov::op::v0::Parameter>(element::f16, Shape{32, 40, 10});
auto Y = make_shared<ov::op::v0::Parameter>(element::f16, Shape{32, 40, 10});
auto cond = std::make_shared<ov::op::v0::Constant>(ngraph::element::boolean, ngraph::Shape{1}, false);
// Set up the cell body, a function from (Xi, Yi) -> (Zo)
// Body parameters
auto Xt = make_shared<op::Parameter>(element::dynamic, PartialShape::dynamic());
auto Yt = make_shared<op::Parameter>(element::dynamic, PartialShape::dynamic());
auto Xe = make_shared<op::Parameter>(element::dynamic, PartialShape::dynamic());
auto Ye = make_shared<op::Parameter>(element::dynamic, PartialShape::dynamic());
auto Xt = make_shared<ov::op::v0::Parameter>(element::dynamic, PartialShape::dynamic());
auto Yt = make_shared<ov::op::v0::Parameter>(element::dynamic, PartialShape::dynamic());
auto Xe = make_shared<ov::op::v0::Parameter>(element::dynamic, PartialShape::dynamic());
auto Ye = make_shared<ov::op::v0::Parameter>(element::dynamic, PartialShape::dynamic());
// Body
auto then_op = std::make_shared<op::v1::Add>(Xt, Yt);
auto then_op_res = std::make_shared<op::Result>(then_op);
auto then_op_res = std::make_shared<ov::op::v0::Result>(then_op);
auto then_body = make_shared<ngraph::Function>(OutputVector{then_op_res}, ParameterVector{Xt, Yt});
auto else_op = std::make_shared<op::v1::Maximum>(Xe, Ye);
auto else_op_res = std::make_shared<op::Result>(else_op);
auto else_op_res = std::make_shared<ov::op::v0::Result>(else_op);
auto else_body = make_shared<ngraph::Function>(OutputVector{else_op_res}, ParameterVector{Xe, Ye});
auto if_op = make_shared<op::v8::If>(cond);
if_op->set_then_body(then_body);
@ -363,7 +369,7 @@ TEST(type_prop, if_element_type_dynamic) {
if_op->set_input(X, Xt, Xe);
if_op->set_input(Y, Yt, Ye);
auto res = if_op->set_output(then_op_res, else_op_res);
auto result0 = make_shared<op::Result>(res);
auto result0 = make_shared<ov::op::v0::Result>(res);
Shape out0_shape{32, 40, 10};
auto sh = result0->get_output_shape(0);
EXPECT_EQ(sh, out0_shape);
@ -375,28 +381,28 @@ TEST(type_prop, if_element_type_dynamic) {
TEST(type_prop, if_invalid_false_body) {
// That which we iterate over
auto X = make_shared<op::Parameter>(element::f16, Shape{32, 40, 10});
auto Y = make_shared<op::Parameter>(element::f16, Shape{32, 40});
auto cond = std::make_shared<ngraph::opset5::Constant>(ngraph::element::boolean, ngraph::Shape{1}, false);
auto X = make_shared<ov::op::v0::Parameter>(element::f16, Shape{32, 40, 10});
auto Y = make_shared<ov::op::v0::Parameter>(element::f16, Shape{32, 40});
auto cond = std::make_shared<ov::op::v0::Constant>(ngraph::element::boolean, ngraph::Shape{1}, false);
// Set up the cell body, a function from (Xi, Yi) -> (Zo)
// Body parameters
auto Xt = make_shared<op::Parameter>(element::dynamic, PartialShape::dynamic());
auto Yt = make_shared<op::Parameter>(element::dynamic, PartialShape::dynamic());
auto Xe = make_shared<op::Parameter>(element::dynamic, PartialShape::dynamic());
auto Ye = make_shared<op::Parameter>(element::dynamic, PartialShape::dynamic());
auto Xt = make_shared<ov::op::v0::Parameter>(element::dynamic, PartialShape::dynamic());
auto Yt = make_shared<ov::op::v0::Parameter>(element::dynamic, PartialShape::dynamic());
auto Xe = make_shared<ov::op::v0::Parameter>(element::dynamic, PartialShape::dynamic());
auto Ye = make_shared<ov::op::v0::Parameter>(element::dynamic, PartialShape::dynamic());
// Body
auto axes_4d = opset5::Constant::create(element::i32, ngraph::Shape{2}, {2, 3});
auto axes_4d = ov::op::v0::Constant::create(element::i32, ngraph::Shape{2}, {2, 3});
auto then_reduce_op = std::make_shared<op::v1::ReduceMean>(Xt, Yt);
auto then_op = std::make_shared<op::v1::Add>(then_reduce_op, Yt);
auto then_op_res = std::make_shared<op::Result>(then_op);
auto then_op_res = std::make_shared<ov::op::v0::Result>(then_op);
auto then_body = make_shared<ngraph::Function>(OutputVector{then_op_res}, ParameterVector{Xt, Yt});
auto axes_3d = opset5::Constant::create(element::i32, ngraph::Shape{1}, {2});
auto axes_3d = ov::op::v0::Constant::create(element::i32, ngraph::Shape{1}, {2});
auto else_reduce_op = std::make_shared<op::v1::ReduceMean>(Xe, axes_3d);
auto else_op = std::make_shared<op::v1::Add>(else_reduce_op, Ye);
auto else_op_res = std::make_shared<op::Result>(else_op);
auto else_op_res = std::make_shared<ov::op::v0::Result>(else_op);
auto else_body = make_shared<ngraph::Function>(OutputVector{else_op_res}, ParameterVector{Xe, Ye});
auto if_op = make_shared<op::v8::If>(cond);
if_op->set_then_body(then_body);
@ -404,7 +410,7 @@ TEST(type_prop, if_invalid_false_body) {
if_op->set_input(X, Xt, Xe);
if_op->set_input(Y, Yt, Ye);
auto res = if_op->set_output(then_op_res, else_op_res);
auto result0 = make_shared<op::Result>(res);
auto result0 = make_shared<ov::op::v0::Result>(res);
Shape out0_shape{32, 40};
auto sh = result0->get_output_shape(0);
EXPECT_EQ(sh, out0_shape);

304
src/core/tests/type_prop/interpolate.cpp
View File

@ -4,12 +4,14 @@
#include "openvino/op/interpolate.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 "openvino/op/constant.hpp"
#include "openvino/op/shape_of.hpp"
using namespace ngraph;
using namespace ov;
using namespace testing;
using InterpolateMode = op::v4::Interpolate::InterpolateMode;
@ -19,8 +21,8 @@ using InterpolateAttrs = op::v4::Interpolate::InterpolateAttrs;
using ShapeCalcMode = op::v4::Interpolate::ShapeCalcMode;
TEST(type_prop, interpolate_v0_default_ctor) {
auto image = std::make_shared<op::Parameter>(element::f32, Shape{2, 2, 30, 60});
auto target_shape = op::Constant::create<float>(element::i32, Shape{2}, {15, 30});
auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2, 30, 60});
auto target_shape = ov::op::v0::Constant::create<float>(element::i32, Shape{2}, {15, 30});
op::v0::Interpolate::Attributes attrs;
attrs.axes = AxisSet{2, 3};
@ -38,8 +40,8 @@ TEST(type_prop, interpolate_v0_default_ctor) {
}
TEST(type_prop, interpolate_v0_all_inputs_dynamic_rank) {
const auto image = std::make_shared<op::Parameter>(element::f16, PartialShape::dynamic());
const auto target_shape = std::make_shared<op::Parameter>(element::i32, PartialShape::dynamic());
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f16, PartialShape::dynamic());
const auto target_shape = std::make_shared<ov::op::v0::Parameter>(element::i32, PartialShape::dynamic());
op::v0::Interpolate::Attributes attrs;
attrs.axes = AxisSet{2, 3};
@ -53,8 +55,8 @@ TEST(type_prop, interpolate_v0_all_inputs_dynamic_rank) {
}
TEST(type_prop, interpolate_v0_all_inputs_static_rank) {
const auto image = std::make_shared<op::Parameter>(element::f16, PartialShape::dynamic(6));
const auto target_shape = std::make_shared<op::Parameter>(element::i32, PartialShape::dynamic(1));
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f16, PartialShape::dynamic(6));
const auto target_shape = std::make_shared<ov::op::v0::Parameter>(element::i32, PartialShape::dynamic(1));
op::v0::Interpolate::Attributes attrs;
attrs.axes = AxisSet{2, 3};
@ -68,8 +70,8 @@ TEST(type_prop, interpolate_v0_all_inputs_static_rank) {
}
TEST(type_prop, interpolate_v0_target_shape_not_constant) {
const auto image = std::make_shared<op::Parameter>(element::bf16, PartialShape{2, 4, 12, 12});
const auto target_shape = std::make_shared<op::Parameter>(element::i64, PartialShape{1});
const auto image = std::make_shared<ov::op::v0::Parameter>(element::bf16, PartialShape{2, 4, 12, 12});
const auto target_shape = std::make_shared<ov::op::v0::Parameter>(element::i64, PartialShape{1});
op::v0::Interpolate::Attributes attrs;
attrs.axes = AxisSet{3, 1};
@ -88,8 +90,9 @@ TEST(type_prop, interpolate_v0_target_shape_as_shape_of) {
set_shape_labels(img_shape, 10);
set_shape_labels(out_shape, 20);
auto image = std::make_shared<op::Parameter>(element::f64, img_shape);
auto target_shape = std::make_shared<op::ShapeOf>(std::make_shared<op::Parameter>(element::i32, out_shape));
auto image = std::make_shared<ov::op::v0::Parameter>(element::f64, img_shape);
auto target_shape =
std::make_shared<op::v0::ShapeOf>(std::make_shared<ov::op::v0::Parameter>(element::i32, out_shape));
op::v0::Interpolate::Attributes attrs;
attrs.axes = AxisSet{3, 1};
@ -104,10 +107,10 @@ TEST(type_prop, interpolate_v0_target_shape_as_shape_of) {
// --- v4 ---
TEST(type_prop, interpolate_v4_default_ctor) {
auto image = std::make_shared<op::Parameter>(element::f32, Shape{2, 2, 30, 60});
auto target_shape = std::make_shared<op::Parameter>(element::i32, Shape{});
auto scales = op::Constant::create<float>(element::f32, Shape{2}, {0.5f, 0.5f});
auto axes = op::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2, 30, 60});
auto target_shape = std::make_shared<ov::op::v0::Parameter>(element::i32, Shape{});
auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{2}, {0.5f, 0.5f});
auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
InterpolateAttrs attrs;
attrs.mode = InterpolateMode::NEAREST;
@ -130,10 +133,10 @@ TEST(type_prop, interpolate_v4_default_ctor) {
}
TEST(type_prop, interpolate_v4) {
auto image = std::make_shared<op::Parameter>(element::f32, Shape{2, 2, 30, 60});
auto target_shape = std::make_shared<op::Parameter>(element::i32, Shape{15, 30});
auto scales = op::Constant::create<float>(element::f32, Shape{2}, {0.5f, 0.5f});
auto axes = op::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2, 30, 60});
auto target_shape = std::make_shared<ov::op::v0::Parameter>(element::i32, Shape{15, 30});
auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{2}, {0.5f, 0.5f});
auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
InterpolateAttrs attrs;
attrs.mode = InterpolateMode::NEAREST;
@ -155,10 +158,10 @@ TEST(type_prop, interpolate_v4_non_constant_axes_scales) {
auto img_shape = PartialShape{2, 2, 30, 60};
set_shape_labels(img_shape, 10);
auto image = std::make_shared<op::Parameter>(element::f16, img_shape);
auto target_shape = std::make_shared<op::Parameter>(element::i64, Shape{});
auto scales = op::Constant::create<float>(element::f32, Shape{2}, {0.5f, 0.5f});
auto axes = std::make_shared<op::Parameter>(element::i32, PartialShape{2});
auto image = std::make_shared<ov::op::v0::Parameter>(element::f16, img_shape);
auto target_shape = std::make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{2}, {0.5f, 0.5f});
auto axes = std::make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{2});
InterpolateAttrs attrs;
attrs.mode = InterpolateMode::NEAREST;
@ -180,11 +183,11 @@ TEST(type_prop, interpolate_v4_non_constant_axes_sizes) {
auto img_shape = PartialShape{2, 2, 30, 60};
set_shape_labels(img_shape, 10);
auto image = std::make_shared<op::Parameter>(element::bf16, img_shape);
auto target_shape = std::make_shared<op::Parameter>(element::i64, Shape{2});
auto scales = op::Constant::create<float>(element::f32, Shape{2, 1}, {0.5f, 0.5f});
auto image = std::make_shared<ov::op::v0::Parameter>(element::bf16, img_shape);
auto target_shape = std::make_shared<ov::op::v0::Parameter>(element::i64, Shape{2});
auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{2, 1}, {0.5f, 0.5f});
auto axes = std::make_shared<op::Parameter>(element::i32, PartialShape{2});
auto axes = std::make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{2});
InterpolateAttrs attrs;
attrs.mode = InterpolateMode::NEAREST;
@ -203,10 +206,10 @@ TEST(type_prop, interpolate_v4_non_constant_axes_sizes) {
}
TEST(type_prop, interpolate_v4_img_dynamic_rank) {
auto image = std::make_shared<op::Parameter>(element::bf16, PartialShape::dynamic());
auto target_shape = std::make_shared<op::Parameter>(element::i32, Shape{2});
auto scales = op::Constant::create<float>(element::f32, Shape{2}, {0.5f, 0.5f});
auto axes = op::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
auto image = std::make_shared<ov::op::v0::Parameter>(element::bf16, PartialShape::dynamic());
auto target_shape = std::make_shared<ov::op::v0::Parameter>(element::i32, Shape{2});
auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{2}, {0.5f, 0.5f});
auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
InterpolateAttrs attrs;
attrs.mode = InterpolateMode::NEAREST;
@ -227,10 +230,10 @@ TEST(type_prop, interpolate_v4_partial_static_rank) {
auto img_shape = PartialShape{2, 2, -1, {5, 30}};
set_shape_labels(img_shape, 10);
auto image = std::make_shared<op::Parameter>(element::f32, img_shape);
auto target_shape = std::make_shared<op::Parameter>(element::i32, Shape{2});
auto scales = op::Constant::create<float>(element::f32, Shape{2}, {0.5f, 0.5f});
auto axes = op::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, img_shape);
auto target_shape = std::make_shared<ov::op::v0::Parameter>(element::i32, Shape{2});
auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{2}, {0.5f, 0.5f});
auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
InterpolateAttrs attrs;
attrs.mode = InterpolateMode::NEAREST;
@ -253,10 +256,10 @@ TEST(type_prop, interpolate_v4_img_intervals_use_scales) {
auto img_shape = PartialShape{{1, 2}, -1, 10, {5, 30}};
set_shape_labels(img_shape, 10);
auto image = std::make_shared<op::Parameter>(element::f32, img_shape);
auto target_shape = std::make_shared<op::Parameter>(element::i32, Shape{2});
auto scales = op::Constant::create<float>(element::f32, Shape{2}, {0.5f, 0.5f});
auto axes = op::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, img_shape);
auto target_shape = std::make_shared<ov::op::v0::Parameter>(element::i32, Shape{2});
auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{2}, {0.5f, 0.5f});
auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
InterpolateAttrs attrs;
attrs.mode = InterpolateMode::NEAREST;
@ -280,10 +283,11 @@ TEST(type_prop, interpolate_v4_use_sizes_as_shape_of) {
set_shape_labels(img_shape, 10);
set_shape_labels(out_shape, 20);
auto image = std::make_shared<op::Parameter>(element::f32, img_shape);
auto target_shape = std::make_shared<op::ShapeOf>(std::make_shared<op::Parameter>(element::i32, out_shape));
auto scales = op::Constant::create<float>(element::f32, Shape{2}, {1.0f / 3.0f, 1.0f / 3.0f});
auto axes = op::Constant::create<int64_t>(element::i64, Shape{2}, {3, 1});
auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, img_shape);
auto target_shape =
std::make_shared<op::v0::ShapeOf>(std::make_shared<ov::op::v0::Parameter>(element::i32, out_shape));
auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{2}, {1.0f / 3.0f, 1.0f / 3.0f});
auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{2}, {3, 1});
InterpolateAttrs attrs;
attrs.mode = InterpolateMode::NEAREST;
@ -305,10 +309,10 @@ TEST(type_prop, interpolate_v4_use_scales_interval_shapes) {
auto img_shape = PartialShape{2, 2, {12, 800}, {0, -1}, {24, -1}};
set_shape_labels(img_shape, 10);
auto image = std::make_shared<op::Parameter>(element::f32, img_shape);
auto target_shape = std::make_shared<op::Parameter>(element::i32, Shape{3});
auto scales = op::Constant::create<float>(element::f32, Shape{3}, {0.5f, 0.25f, 0.125f});
auto axes = op::Constant::create<int64_t>(element::i64, Shape{3}, {2, 3, 4});
auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, img_shape);
auto target_shape = std::make_shared<ov::op::v0::Parameter>(element::i32, Shape{3});
auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{3}, {0.5f, 0.25f, 0.125f});
auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{3}, {2, 3, 4});
InterpolateAttrs attrs;
attrs.mode = InterpolateMode::NEAREST;
@ -328,10 +332,10 @@ TEST(type_prop, interpolate_v4_use_scales_interval_shapes) {
}
TEST(type_prop, interpolate_v4_target_shapes_gt_axes_number) {
const auto image = std::make_shared<op::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto target_shape = op::Constant::create<float>(element::i32, Shape{3}, {10, 12, 20});
const auto scales = op::Constant::create<float>(element::f32, Shape{1}, {0.3f});
const auto axes = op::Constant::create<int64_t>(element::i64, Shape{2}, {0, 3});
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto target_shape = ov::op::v0::Constant::create<float>(element::i32, Shape{3}, {10, 12, 20});
const auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{1}, {0.3f});
const auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{2}, {0, 3});
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SIZES;
@ -344,10 +348,10 @@ TEST(type_prop, interpolate_v4_target_shapes_gt_axes_number) {
}
TEST(type_prop, interpolate_v4_scales_gt_axes_number) {
const auto image = std::make_shared<op::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto target_shape = std::make_shared<op::Parameter>(element::i32, Shape{3});
const auto scales = op::Constant::create<float>(element::f32, Shape{3}, {0.2f, 0.2f, 0.3f});
const auto axes = op::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto target_shape = std::make_shared<ov::op::v0::Parameter>(element::i32, Shape{3});
const auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{3}, {0.2f, 0.2f, 0.3f});
const auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SCALES;
@ -360,10 +364,10 @@ TEST(type_prop, interpolate_v4_scales_gt_axes_number) {
}
TEST(type_prop, interpolate_v4_incorrect_mode) {
const auto image = std::make_shared<op::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto target_shape = std::make_shared<op::Parameter>(element::i32, Shape{2});
const auto scales = op::Constant::create<float>(element::f32, Shape{2}, {6.f, 12.f});
const auto axes = op::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto target_shape = std::make_shared<ov::op::v0::Parameter>(element::i32, Shape{2});
const auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{2}, {6.f, 12.f});
const auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SCALES;
@ -382,9 +386,9 @@ TEST(type_prop, interpolate_v4_incorrect_mode) {
}
TEST(type_prop, interpolate_v4_target_shape_not_1d) {
const auto image = std::make_shared<op::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto scales = op::Constant::create<float>(element::f32, Shape{2}, {6.f, 12.f});
const auto axes = op::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{2}, {6.f, 12.f});
const auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SIZES;
@ -394,28 +398,28 @@ TEST(type_prop, interpolate_v4_target_shape_not_1d) {
OV_EXPECT_THROW(std::ignore = std::make_shared<ov::op::v4::Interpolate>(
image,
std::make_shared<op::Parameter>(element::i32, Shape{1, 2}),
std::make_shared<ov::op::v0::Parameter>(element::i32, Shape{1, 2}),
scales,
axes,
attrs),
ov::NodeValidationFailure,
HasSubstr("Input [1] is not rank 1"));
OV_EXPECT_THROW(
std::ignore = std::make_shared<ov::op::v4::Interpolate>(image,
std::make_shared<op::Parameter>(element::i32, Shape{}),
scales,
axes,
attrs),
ov::NodeValidationFailure,
HasSubstr("Input [1] is not rank 1"));
OV_EXPECT_THROW(std::ignore = std::make_shared<ov::op::v4::Interpolate>(
image,
std::make_shared<ov::op::v0::Parameter>(element::i32, Shape{}),
scales,
axes,
attrs),
ov::NodeValidationFailure,
HasSubstr("Input [1] is not rank 1"));
}
TEST(type_prop, interpolate_v4_scales_not_1d) {
const auto image = std::make_shared<op::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto target_shape = op::Constant::create<float>(element::i32, Shape{2}, {10, 20});
const auto scales = op::Constant::create<float>(element::f32, Shape{2}, {6.f, 12.f});
const auto axes = op::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto target_shape = ov::op::v0::Constant::create<float>(element::i32, Shape{2}, {10, 20});
const auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{2}, {6.f, 12.f});
const auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SCALES;
@ -426,27 +430,27 @@ TEST(type_prop, interpolate_v4_scales_not_1d) {
OV_EXPECT_THROW(std::ignore = std::make_shared<ov::op::v4::Interpolate>(
image,
target_shape,
std::make_shared<op::Parameter>(element::f32, Shape{1, 2}),
std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2}),
axes,
attrs),
ov::NodeValidationFailure,
HasSubstr("Input [2] is not rank 1"));
OV_EXPECT_THROW(
std::ignore = std::make_shared<ov::op::v4::Interpolate>(image,
target_shape,
std::make_shared<op::Parameter>(element::f32, Shape{}),
axes,
attrs),
ov::NodeValidationFailure,
HasSubstr("Input [2] is not rank 1"));
OV_EXPECT_THROW(std::ignore = std::make_shared<ov::op::v4::Interpolate>(
image,
target_shape,
std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{}),
axes,
attrs),
ov::NodeValidationFailure,
HasSubstr("Input [2] is not rank 1"));
}
TEST(type_prop, interpolate_v4_axes_not_1d) {
const auto image = std::make_shared<op::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto target_shape = op::Constant::create<float>(element::i32, Shape{2}, {10, 20});
const auto scales = op::Constant::create<float>(element::f32, Shape{2}, {6.f, 12.f});
const auto axes = op::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto target_shape = ov::op::v0::Constant::create<float>(element::i32, Shape{2}, {10, 20});
const auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{2}, {6.f, 12.f});
const auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SCALES;
@ -458,7 +462,7 @@ TEST(type_prop, interpolate_v4_axes_not_1d) {
image,
target_shape,
scales,
std::make_shared<op::Parameter>(element::i32, Shape{1, 2}),
std::make_shared<ov::op::v0::Parameter>(element::i32, Shape{1, 2}),
attrs),
ov::NodeValidationFailure,
HasSubstr("Input [3] is not rank 1"));
@ -467,7 +471,7 @@ TEST(type_prop, interpolate_v4_axes_not_1d) {
image,
target_shape,
scales,
std::make_shared<op::Parameter>(element::i32, Shape{1, 2}),
std::make_shared<ov::op::v0::Parameter>(element::i32, Shape{1, 2}),
attrs),
ov::NodeValidationFailure,
HasSubstr("Input [3] is not rank 1"));
@ -475,9 +479,9 @@ TEST(type_prop, interpolate_v4_axes_not_1d) {
// --- v11 ---
TEST(type_prop, interpolate_v11_default_ctor) {
auto image = std::make_shared<op::Parameter>(element::f32, Shape{1, 3, 30, 60});
auto scales = op::Constant::create<float>(element::f32, Shape{2}, {0.2f, 0.2f});
auto axes = op::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 30, 60});
auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{2}, {0.2f, 0.2f});
auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SCALES;
@ -495,9 +499,9 @@ TEST(type_prop, interpolate_v11_default_ctor) {
}
TEST(type_prop, interpolate_v11_scales) {
const auto image = std::make_shared<op::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto scales = op::Constant::create<float>(element::f32, Shape{2}, {0.2f, 0.2f});
const auto axes = op::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{2}, {0.2f, 0.2f});
const auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SCALES;
@ -510,9 +514,9 @@ TEST(type_prop, interpolate_v11_scales) {
}
TEST(type_prop, interpolate_v11_scales_all_inputs_static_rank) {
const auto image = std::make_shared<op::Parameter>(element::f16, PartialShape::dynamic(8));
const auto scales = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic(1));
const auto axes = std::make_shared<op::Parameter>(element::i64, PartialShape::dynamic(1));
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f16, PartialShape::dynamic(8));
const auto scales = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(1));
const auto axes = std::make_shared<ov::op::v0::Parameter>(element::i64, PartialShape::dynamic(1));
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SCALES;
@ -525,9 +529,9 @@ TEST(type_prop, interpolate_v11_scales_all_inputs_static_rank) {
}
TEST(type_prop, interpolate_v11_sizes) {
const auto image = std::make_shared<op::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto sizes = op::Constant::create<int32_t>(element::i32, Shape{2}, {6, 12});
const auto axes = op::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto sizes = ov::op::v0::Constant::create<int32_t>(element::i32, Shape{2}, {6, 12});
const auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SIZES;
@ -540,9 +544,9 @@ TEST(type_prop, interpolate_v11_sizes) {
}
TEST(type_prop, interpolate_v11_sizes_all_inputs_dynamic_rank) {
const auto image = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
const auto sizes = std::make_shared<op::Parameter>(element::i32, PartialShape::dynamic());
const auto axes = std::make_shared<op::Parameter>(element::i64, PartialShape::dynamic());
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
const auto sizes = std::make_shared<ov::op::v0::Parameter>(element::i32, PartialShape::dynamic());
const auto axes = std::make_shared<ov::op::v0::Parameter>(element::i64, PartialShape::dynamic());
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SIZES;
@ -558,9 +562,9 @@ TEST(type_prop, interpolate_v11_intervals_with_scales_mode) {
auto img_shape = PartialShape{{1, 3}, 3, {1, 10}, {10, -1}, {10, 20}};
set_shape_labels(img_shape, 10);
const auto image = std::make_shared<op::Parameter>(element::f32, img_shape);
const auto scales = op::Constant::create<float>(element::f32, Shape{3}, {2.0f, 3.0f, 1.0f});
const auto axes = op::Constant::create<int64_t>(element::i64, Shape{3}, {2, 3, 4});
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, img_shape);
const auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{3}, {2.0f, 3.0f, 1.0f});
const auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{3}, {2, 3, 4});
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SCALES;
@ -577,9 +581,9 @@ TEST(type_prop, interpolate_v11_intervals_with_sizes_mode) {
auto img_shape = PartialShape{{1, 3}, 3, {1, 10}, {10, -1}};
set_shape_labels(img_shape, 10);
const auto image = std::make_shared<op::Parameter>(element::f32, img_shape);
const auto sizes = op::Constant::create<float>(element::i32, Shape{2}, {200, 300});
const auto axes = op::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, img_shape);
const auto sizes = ov::op::v0::Constant::create<float>(element::i32, Shape{2}, {200, 300});
const auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SIZES;
@ -597,10 +601,10 @@ TEST(type_prop, interpolate_v11_sizes_with_shapeof) {
set_shape_labels(img_shape, 10);
set_shape_labels(sizes_shape, 20);
const auto image = std::make_shared<op::Parameter>(element::f32, img_shape);
const auto param = std::make_shared<op::Parameter>(element::f32, sizes_shape);
const auto sizes = std::make_shared<op::ShapeOf>(param);
const auto axes = op::Constant::create<int64_t>(element::i64, Shape{2}, {2, 1});
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, img_shape);
const auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, sizes_shape);
const auto sizes = std::make_shared<op::v0::ShapeOf>(param);
const auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{2}, {2, 1});
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SIZES;
@ -616,9 +620,9 @@ TEST(type_prop, interpolate_v11_non_constant_axes_scales) {
auto img_shape = PartialShape{2, 2, 30, 60};
set_shape_labels(img_shape, 10);
auto image = std::make_shared<op::Parameter>(element::f16, img_shape);
auto scales = op::Constant::create<float>(element::f32, Shape{2}, {0.5f, 0.5f});
auto axes = std::make_shared<op::Parameter>(element::i32, PartialShape{2});
auto image = std::make_shared<ov::op::v0::Parameter>(element::f16, img_shape);
auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{2}, {0.5f, 0.5f});
auto axes = std::make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{2});
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SCALES;
@ -632,9 +636,9 @@ TEST(type_prop, interpolate_v11_non_constant_axes_scales) {
}
TEST(type_prop, interpolate_v11_scales_incorrect_et) {
const auto image = std::make_shared<op::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto scales = op::Constant::create<int64_t>(element::i64, Shape{2}, {2, 2});
const auto axes = op::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto scales = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{2}, {2, 2});
const auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SCALES;
@ -647,9 +651,9 @@ TEST(type_prop, interpolate_v11_scales_incorrect_et) {
}
TEST(type_prop, interpolate_v11_sizes_incorrect_et) {
const auto image = std::make_shared<op::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto sizes = op::Constant::create<float>(element::f32, Shape{2}, {6.f, 12.f});
const auto axes = op::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto sizes = ov::op::v0::Constant::create<float>(element::f32, Shape{2}, {6.f, 12.f});
const auto axes = ov::op::v0::Constant::create<int64_t>(element::i64, Shape{2}, {2, 3});
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SIZES;
@ -662,8 +666,8 @@ TEST(type_prop, interpolate_v11_sizes_incorrect_et) {
}
TEST(type_prop, interpolate_v11_scales_incorrect_number) {
const auto image = std::make_shared<op::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto scales = op::Constant::create<float>(element::f32, Shape{2}, {0.2f, 0.2f});
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{2}, {0.2f, 0.2f});
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SCALES;
@ -675,8 +679,8 @@ TEST(type_prop, interpolate_v11_scales_incorrect_number) {
}
TEST(type_prop, interpolate_v11_sizes_incorrect_number) {
const auto image = std::make_shared<op::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto sizes = op::Constant::create<int32_t>(element::i32, Shape{2}, {6, 12});
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto sizes = ov::op::v0::Constant::create<int32_t>(element::i32, Shape{2}, {6, 12});
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SIZES;
@ -688,8 +692,8 @@ TEST(type_prop, interpolate_v11_sizes_incorrect_number) {
}
TEST(type_prop, interpolate_v11_scales_not_1d) {
const auto image = std::make_shared<op::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto axes = op::Constant::create<int64_t>(element::i32, Shape{2}, {2, 3});
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto axes = ov::op::v0::Constant::create<int64_t>(element::i32, Shape{2}, {2, 3});
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SCALES;
@ -698,24 +702,24 @@ TEST(type_prop, interpolate_v11_scales_not_1d) {
OV_EXPECT_THROW(std::ignore = std::make_shared<ov::op::v11::Interpolate>(
image,
std::make_shared<op::Parameter>(element::f32, Shape{1, 2}),
std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2}),
axes,
attrs),
ov::NodeValidationFailure,
HasSubstr("Input [1] is not rank 1"));
OV_EXPECT_THROW(
std::ignore = std::make_shared<ov::op::v11::Interpolate>(image,
std::make_shared<op::Parameter>(element::f32, Shape{}),
axes,
attrs),
ov::NodeValidationFailure,
HasSubstr("Input [1] is not rank 1"));
OV_EXPECT_THROW(std::ignore = std::make_shared<ov::op::v11::Interpolate>(
image,
std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{}),
axes,
attrs),
ov::NodeValidationFailure,
HasSubstr("Input [1] is not rank 1"));
}
TEST(type_prop, interpolate_v11_axes_not_1d) {
const auto image = std::make_shared<op::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto scales = op::Constant::create<float>(element::f32, Shape{2}, {6.f, 12.f});
const auto image = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 30, 60});
const auto scales = ov::op::v0::Constant::create<float>(element::f32, Shape{2}, {6.f, 12.f});
ov::op::util::InterpolateBase::InterpolateAttrs attrs;
attrs.shape_calculation_mode = ov::op::util::InterpolateBase::ShapeCalcMode::SCALES;
@ -726,16 +730,16 @@ TEST(type_prop, interpolate_v11_axes_not_1d) {
OV_EXPECT_THROW(std::ignore = std::make_shared<ov::op::v11::Interpolate>(
image,
scales,
std::make_shared<op::Parameter>(element::i32, Shape{1, 2}),
std::make_shared<ov::op::v0::Parameter>(element::i32, Shape{1, 2}),
attrs),
ov::NodeValidationFailure,
HasSubstr("Input [2] is not rank 1"));
OV_EXPECT_THROW(
std::ignore = std::make_shared<ov::op::v11::Interpolate>(image,
scales,
std::make_shared<op::Parameter>(element::i32, Shape{}),
attrs),
ov::NodeValidationFailure,
HasSubstr("Input [2] is not rank 1"));
OV_EXPECT_THROW(std::ignore = std::make_shared<ov::op::v11::Interpolate>(
image,
scales,
std::make_shared<ov::op::v0::Parameter>(element::i32, Shape{}),
attrs),
ov::NodeValidationFailure,
HasSubstr("Input [2] is not rank 1"));
}

65
src/core/tests/type_prop/irdft.cpp
View File

@ -14,11 +14,14 @@
// limitations under the License.
//*****************************************************************************
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/op/irdft.hpp"
using namespace ngraph;
#include <gtest/gtest.h>
#include "common_test_utils/type_prop.hpp"
#include "openvino/op/constant.hpp"
using namespace ov;
struct IRDFTConstantAxesAndConstantSignalSizeTestParams {
PartialShape input_shape;
@ -35,15 +38,15 @@ struct IRDFTConstantAxesAndConstantSignalSizeTest
TEST_P(IRDFTConstantAxesAndConstantSignalSizeTest, irdft_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::v9::IRDFT> irdft;
if (params.signal_size.empty()) {
irdft = std::make_shared<op::v9::IRDFT>(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);
irdft = std::make_shared<op::v9::IRDFT>(data, axes_input, signal_size_input);
}
@ -187,8 +190,8 @@ TEST(type_prop, irdft_dynamic_axes) {
const auto axes_shape = PartialShape::dynamic();
const auto ref_output_shape = PartialShape{Dimension::dynamic(), Dimension::dynamic(), Dimension::dynamic()};
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 irdft = std::make_shared<op::v9::IRDFT>(data, axes_input);
EXPECT_EQ(irdft->get_element_type(), element::f32);
@ -206,8 +209,8 @@ struct IRDFTNonConstantAxesTest : ::testing::TestWithParam<IRDFTNonConstantAxesT
TEST_P(IRDFTNonConstantAxesTest, irdft_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 irdft = std::make_shared<op::v9::IRDFT>(data, axes_input);
EXPECT_EQ(irdft->get_element_type(), element::f32);
@ -278,9 +281,9 @@ struct IRDFTNonConstantSignalSizeTest : ::testing::TestWithParam<IRDFTNonConstan
TEST_P(IRDFTNonConstantSignalSizeTest, irdft_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 irdft = std::make_shared<op::v9::IRDFT>(data, axes_input, signal_size_input);
EXPECT_EQ(irdft->get_element_type(), element::f32);
@ -309,10 +312,10 @@ INSTANTIATE_TEST_SUITE_P(
PrintToDummyParamName());
TEST(type_prop, irdft_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 irdft = std::make_shared<op::v9::IRDFT>(data, axes);
FAIL() << "IRDFT node was created with invalid input.";
} catch (const NodeValidationFailure& error) {
@ -320,7 +323,7 @@ TEST(type_prop, irdft_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 irdft = std::make_shared<op::v9::IRDFT>(data, axes);
FAIL() << "IRDFT node was created with invalid input.";
} catch (const NodeValidationFailure& error) {
@ -328,7 +331,7 @@ TEST(type_prop, irdft_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 irdft = std::make_shared<op::v9::IRDFT>(data, axes);
FAIL() << "IRDFT node was created with invalid input.";
} catch (const NodeValidationFailure& error) {
@ -337,10 +340,10 @@ TEST(type_prop, irdft_invalid_input) {
}
TEST(type_prop, irdft_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 irdft = std::make_shared<op::v9::IRDFT>(data, axes);
FAIL() << "IRDFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) {
@ -348,7 +351,7 @@ TEST(type_prop, irdft_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 irdft = std::make_shared<op::v9::IRDFT>(data, axes);
FAIL() << "IRDFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) {
@ -356,7 +359,7 @@ TEST(type_prop, irdft_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 irdft = std::make_shared<op::v9::IRDFT>(data, axes);
FAIL() << "IRDFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) {
@ -364,7 +367,7 @@ TEST(type_prop, irdft_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 irdft = std::make_shared<op::v9::IRDFT>(data, axes);
FAIL() << "IRDFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) {
@ -372,7 +375,7 @@ TEST(type_prop, irdft_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 irdft = std::make_shared<op::v9::IRDFT>(data, axes);
FAIL() << "IRDFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) {
@ -381,11 +384,11 @@ TEST(type_prop, irdft_invalid_axes) {
}
TEST(type_prop, irdft_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 irdft = std::make_shared<op::v9::IRDFT>(data, axes, signal_size);
FAIL() << "IRDFT node was created with invalid signal size.";
} catch (const NodeValidationFailure& error) {
@ -393,7 +396,7 @@ TEST(type_prop, irdft_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 irdft = std::make_shared<op::v9::IRDFT>(data, axes, signal_size);
FAIL() << "IRDFT node was created with invalid signal size.";
} catch (const NodeValidationFailure& error) {
@ -407,9 +410,9 @@ TEST(type_prop, irdft_dynamic_types) {
const auto signal_size_shape = PartialShape::dynamic();
const auto ref_output_shape = PartialShape{Dimension::dynamic(), Dimension::dynamic(), Dimension::dynamic()};
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 irdft = std::make_shared<op::v9::IRDFT>(data, axes_input, signal_size_input);
EXPECT_EQ(irdft->get_element_type(), element::dynamic);

3
src/core/tests/type_prop/is_finite.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/opsets/opset10.hpp"
using namespace ov::opset10;

3
src/core/tests/type_prop/is_inf.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/opsets/opset10.hpp"
using namespace std;

3
src/core/tests/type_prop/is_nan.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/opsets/opset10.hpp"
using namespace std;

16
src/core/tests/type_prop/log_softmax.cpp
View File

@ -2,22 +2,22 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/log_softmax.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;
TEST(type_prop, log_softmax) {
auto data = make_shared<op::Parameter>(element::f32, Shape{1, 3, 6});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 6});
auto log_softmax_func = make_shared<op::v5::LogSoftmax>(data, 1);
EXPECT_EQ(log_softmax_func->get_element_type(), element::f32);
EXPECT_EQ(log_softmax_func->get_shape(), (Shape{1, 3, 6}));
}
TEST(type_prop, log_softmax_incorrect_axis) {
const auto data = make_shared<op::Parameter>(element::f32, Shape{1, 3, 6});
const auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 6});
try {
auto log_softmax_func = make_shared<op::v5::LogSoftmax>(data, 3);
@ -29,7 +29,7 @@ TEST(type_prop, log_softmax_incorrect_axis) {
// TEST(type_prop, log_softmax_partial)
// {
// auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
// auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
// auto log_softmax_func = make_shared<op::v5::LogSoftmax>(data, 1);
// EXPECT_EQ(log_softmax_func->get_element_type(), element::f32);
// ASSERT_TRUE(log_softmax_func->get_output_partial_shape(0).same_scheme(
@ -37,13 +37,13 @@ TEST(type_prop, log_softmax_incorrect_axis) {
//
// // rank unknown
// auto log_softmax_partial = make_shared<op::v5::LogSoftmax>(
// make_shared<op::Parameter>(element::f32, PartialShape::dynamic()));
// make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic()));
// ASSERT_TRUE(
// log_softmax_partial->get_output_partial_shape(0).same_scheme(PartialShape::dynamic()));
// }
TEST(type_prop, log_softmax_partial_static_rank) {
auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto log_softmax_func = make_shared<op::v5::LogSoftmax>(data, 1);
EXPECT_EQ(log_softmax_func->get_element_type(), element::f32);
ASSERT_TRUE(log_softmax_func->get_output_partial_shape(0).same_scheme((PartialShape{1, Dimension::dynamic(), 6})));

4
src/core/tests/type_prop/logical_and.cpp
View File

@ -2,9 +2,11 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/logical_and.hpp"
#include "common_test_utils/type_prop.hpp"
#include "logical_ops.hpp"
using Type = ::testing::Types<LogicalOperatorType<ngraph::op::v1::LogicalAnd, ngraph::element::boolean>>;
using Type = ::testing::Types<LogicalOperatorType<ov::op::v1::LogicalAnd, ov::element::boolean>>;
INSTANTIATE_TYPED_TEST_SUITE_P(Type_prop_test, LogicalOperatorTypeProp, Type, LogicalOperatorTypeName);

16
src/core/tests/type_prop/logical_not.cpp
View File

@ -2,12 +2,14 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/logical_not.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;
using LogicalNotTestParam = std::tuple<element::Type, PartialShape>;
@ -23,7 +25,7 @@ const auto dynamic_shapes = Values(PartialShape{Dimension::dynamic(), Dimension:
PartialShape::dynamic());
} // namespace
class LogicalNotTest : public TypePropOpTest<op::v1::LogicalNot>, public WithParamInterface<LogicalNotTestParam> {
class LogicalNotTest : public TypePropOpTest<ov::op::v1::LogicalNot>, public WithParamInterface<LogicalNotTestParam> {
protected:
void SetUp() override {
std::tie(exp_type, exp_shape) = GetParam();
@ -43,7 +45,7 @@ INSTANTIATE_TEST_SUITE_P(type_prop_dynamic_static_rank,
PrintToStringParamName());
TEST_P(LogicalNotTest, propagate_dimensions) {
const auto input = std::make_shared<op::Parameter>(exp_type, exp_shape);
const auto input = std::make_shared<ov::op::v0::Parameter>(exp_type, exp_shape);
const auto op = make_op(input);
EXPECT_EQ(op->get_element_type(), exp_type);
@ -57,7 +59,7 @@ TEST_P(LogicalNotTest, propagate_labels) {
}
const auto exp_labels = get_shape_labels(exp_shape);
const auto input = std::make_shared<op::Parameter>(exp_type, exp_shape);
const auto input = std::make_shared<ov::op::v0::Parameter>(exp_type, exp_shape);
const auto op = make_op(input);
EXPECT_EQ(get_shape_labels(op->get_output_partial_shape(0)), exp_labels);
@ -65,7 +67,7 @@ TEST_P(LogicalNotTest, propagate_labels) {
TEST_P(LogicalNotTest, default_ctor) {
const auto op = std::make_shared<op::v1::LogicalNot>();
const auto input = std::make_shared<op::Parameter>(exp_type, exp_shape);
const auto input = std::make_shared<ov::op::v0::Parameter>(exp_type, exp_shape);
op->set_argument(0, input);
op->validate_and_infer_types();

73
src/core/tests/type_prop/logical_ops.hpp
View File

@ -6,14 +6,13 @@
#include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp"
#include "ngraph/ngraph.hpp"
#include "openvino/core/dimension_tracker.hpp"
template <typename T, ngraph::element::Type_t ELEMENT_TYPE>
template <typename T, ov::element::Type_t ELEMENT_TYPE>
class LogicalOperatorType {
public:
using op_type = T;
static constexpr ngraph::element::Type_t element_type = ELEMENT_TYPE;
static constexpr ov::element::Type_t element_type = ELEMENT_TYPE;
};
template <typename T>
@ -27,7 +26,7 @@ public:
template <typename T>
static std::string GetName(int) {
using OP_Type = typename T::op_type;
const ngraph::Node::type_info_t typeinfo = OP_Type::get_type_info_static();
const ov::Node::type_info_t typeinfo = OP_Type::get_type_info_static();
return typeinfo.name;
}
};
@ -36,15 +35,15 @@ TYPED_TEST_SUITE_P(LogicalOperatorTypeProp);
namespace {
template <typename T>
void incorrect_init(const ngraph::element::Type& type,
void incorrect_init(const ov::element::Type& type,
const std::string& err,
const ngraph::Shape& shape1 = {1, 3, 6},
const ngraph::Shape& shape2 = {1, 3, 6}) {
auto input1 = std::make_shared<ngraph::op::Parameter>(type, shape1);
auto input2 = std::make_shared<ngraph::op::Parameter>(type, shape2);
const ov::Shape& shape1 = {1, 3, 6},
const ov::Shape& shape2 = {1, 3, 6}) {
auto input1 = std::make_shared<ov::op::v0::Parameter>(type, shape1);
auto input2 = std::make_shared<ov::op::v0::Parameter>(type, shape2);
try {
auto op = std::make_shared<T>(input1, input2);
} catch (const ngraph::NodeValidationFailure& error) {
} catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), err);
}
}
@ -52,52 +51,52 @@ void incorrect_init(const ngraph::element::Type& type,
TYPED_TEST_P(LogicalOperatorTypeProp, incorrect_type_f32) {
using OP_Type = typename TypeParam::op_type;
incorrect_init<OP_Type>(ngraph::element::f32,
incorrect_init<OP_Type>(ov::element::f32,
"Operands for logical operators must have boolean element type but have element type f32");
}
TYPED_TEST_P(LogicalOperatorTypeProp, incorrect_type_f64) {
using OP_Type = typename TypeParam::op_type;
incorrect_init<OP_Type>(ngraph::element::f64,
incorrect_init<OP_Type>(ov::element::f64,
"Operands for logical operators must have boolean element type but have element type f64");
}
TYPED_TEST_P(LogicalOperatorTypeProp, incorrect_type_i32) {
using OP_Type = typename TypeParam::op_type;
incorrect_init<OP_Type>(ngraph::element::i32,
incorrect_init<OP_Type>(ov::element::i32,
"Operands for logical operators must have boolean element type but have element type i32");
}
TYPED_TEST_P(LogicalOperatorTypeProp, incorrect_type_i64) {
using OP_Type = typename TypeParam::op_type;
incorrect_init<OP_Type>(ngraph::element::i64,
incorrect_init<OP_Type>(ov::element::i64,
"Operands for logical operators must have boolean element type but have element type i64");
}
TYPED_TEST_P(LogicalOperatorTypeProp, incorrect_type_u32) {
using OP_Type = typename TypeParam::op_type;
incorrect_init<OP_Type>(ngraph::element::u32,
incorrect_init<OP_Type>(ov::element::u32,
"Operands for logical operators must have boolean element type but have element type u32");
}
TYPED_TEST_P(LogicalOperatorTypeProp, incorrect_type_u64) {
using OP_Type = typename TypeParam::op_type;
incorrect_init<OP_Type>(ngraph::element::u64,
incorrect_init<OP_Type>(ov::element::u64,
"Operands for logical operators must have boolean element type but have element type u64");
}
TYPED_TEST_P(LogicalOperatorTypeProp, incorrect_shape) {
using OP_Type = typename TypeParam::op_type;
incorrect_init<OP_Type>(ngraph::element::boolean,
incorrect_init<OP_Type>(ov::element::boolean,
"Argument shapes are inconsistent",
ngraph::Shape{1, 3, 6},
ngraph::Shape{1, 2, 3});
ov::Shape{1, 3, 6},
ov::Shape{1, 2, 3});
}
TYPED_TEST_P(LogicalOperatorTypeProp, inputs_have_different_types) {
using namespace ngraph;
const auto a = std::make_shared<op::Parameter>(element::boolean, PartialShape{1, 1, 6});
const auto b = std::make_shared<op::Parameter>(element::f16, PartialShape{1, 3, 1});
using namespace ov;
const auto a = std::make_shared<op::v0::Parameter>(element::boolean, PartialShape{1, 1, 6});
const auto b = std::make_shared<op::v0::Parameter>(element::f16, PartialShape{1, 3, 1});
OV_EXPECT_THROW(const auto logical_op = this->make_op(a, b),
NodeValidationFailure,
@ -105,9 +104,9 @@ TYPED_TEST_P(LogicalOperatorTypeProp, inputs_have_different_types) {
}
TYPED_TEST_P(LogicalOperatorTypeProp, inputs_have_inconsistent_shapes) {
using namespace ngraph;
const auto a = std::make_shared<op::Parameter>(element::boolean, PartialShape{1, 1, 6});
const auto b = std::make_shared<op::Parameter>(element::boolean, PartialShape{1, 3, 3});
using namespace ov;
const auto a = std::make_shared<op::v0::Parameter>(element::boolean, PartialShape{1, 1, 6});
const auto b = std::make_shared<op::v0::Parameter>(element::boolean, PartialShape{1, 3, 3});
OV_EXPECT_THROW(const auto logical_op = this->make_op(a, b),
NodeValidationFailure,
@ -115,11 +114,11 @@ TYPED_TEST_P(LogicalOperatorTypeProp, inputs_have_inconsistent_shapes) {
}
TYPED_TEST_P(LogicalOperatorTypeProp, shape_broadcast) {
using namespace ngraph;
using namespace ov;
const auto exp_dtype = TypeParam::element_type;
const auto a = std::make_shared<op::Parameter>(element::boolean, Shape{1, 1, 6});
const auto b = std::make_shared<op::Parameter>(element::boolean, Shape{1, 3, 1});
const auto a = std::make_shared<op::v0::Parameter>(element::boolean, Shape{1, 1, 6});
const auto b = std::make_shared<op::v0::Parameter>(element::boolean, Shape{1, 3, 1});
const auto logical_op = this->make_op(a, b);
@ -129,7 +128,7 @@ TYPED_TEST_P(LogicalOperatorTypeProp, shape_broadcast) {
}
TYPED_TEST_P(LogicalOperatorTypeProp, partial_shape_no_broadcast) {
using namespace ngraph;
using namespace ov;
using namespace testing;
auto shape_a = PartialShape{1, {2, 4}, {2, 5}, 4, -1};
@ -138,8 +137,8 @@ TYPED_TEST_P(LogicalOperatorTypeProp, partial_shape_no_broadcast) {
set_shape_labels(shape_b, ov::TensorLabel{20, 21, ov::no_label, ov::no_label, ov::no_label});
const auto exp_shape = PartialShape{1, 3, {2, 5}, 4, {-1, 5}};
const auto a = std::make_shared<op::Parameter>(element::boolean, shape_a);
const auto b = std::make_shared<op::Parameter>(element::boolean, shape_b);
const auto a = std::make_shared<op::v0::Parameter>(element::boolean, shape_a);
const auto b = std::make_shared<op::v0::Parameter>(element::boolean, shape_b);
EXPECT_THAT(this->make_op(a, b, "NONE")->get_output_partial_shape(0),
AllOf(Eq(exp_shape), ResultOf(get_shape_labels, ElementsAre(20, 21, 12, ov::no_label, 14))));
@ -149,7 +148,7 @@ TYPED_TEST_P(LogicalOperatorTypeProp, partial_shape_no_broadcast) {
}
TYPED_TEST_P(LogicalOperatorTypeProp, partial_shape_numpy_broadcast) {
using namespace ngraph;
using namespace ov;
using namespace testing;
auto shape_a = PartialShape{1, {2, 4}, {2, 5}, 4, -1};
@ -158,8 +157,8 @@ TYPED_TEST_P(LogicalOperatorTypeProp, partial_shape_numpy_broadcast) {
set_shape_labels(shape_b, ov::TensorLabel{20, 21, ov::no_label, 23});
const auto exp_shape = PartialShape{1, {2, 4}, 3, 4, 4};
const auto a = std::make_shared<op::Parameter>(element::boolean, shape_a);
const auto b = std::make_shared<op::Parameter>(element::boolean, shape_b);
const auto a = std::make_shared<op::v0::Parameter>(element::boolean, shape_a);
const auto b = std::make_shared<op::v0::Parameter>(element::boolean, shape_b);
EXPECT_THAT(this->make_op(a, b, "NUMPY")->get_output_partial_shape(0),
AllOf(Eq(exp_shape), ResultOf(get_shape_labels, ElementsAre(ov::no_label, 11, 21, 13, 23))));
@ -169,11 +168,11 @@ TYPED_TEST_P(LogicalOperatorTypeProp, partial_shape_numpy_broadcast) {
}
TYPED_TEST_P(LogicalOperatorTypeProp, default_ctor) {
using namespace ngraph;
using namespace ov;
const auto op = this->make_op();
const auto a = std::make_shared<op::Parameter>(element::boolean, PartialShape{1, {2, 4}, {2, 5}, 4, -1});
const auto b = std::make_shared<op::Parameter>(element::boolean, PartialShape{1, 3, {1, 6}, 4});
const auto a = std::make_shared<op::v0::Parameter>(element::boolean, PartialShape{1, {2, 4}, {2, 5}, 4, -1});
const auto b = std::make_shared<op::v0::Parameter>(element::boolean, PartialShape{1, 3, {1, 6}, 4});
op->set_arguments(NodeVector{a, b});
op->set_autob("NUMPY");

4
src/core/tests/type_prop/logical_or.cpp
View File

@ -2,9 +2,11 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/logical_or.hpp"
#include "common_test_utils/type_prop.hpp"
#include "logical_ops.hpp"
using Type = ::testing::Types<LogicalOperatorType<ngraph::op::v1::LogicalOr, ngraph::element::boolean>>;
using Type = ::testing::Types<LogicalOperatorType<ov::op::v1::LogicalOr, ov::element::boolean>>;
INSTANTIATE_TYPED_TEST_SUITE_P(Type_prop_test, LogicalOperatorTypeProp, Type, LogicalOperatorTypeName);

4
src/core/tests/type_prop/logical_xor.cpp
View File

@ -2,9 +2,11 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/logical_xor.hpp"
#include "common_test_utils/type_prop.hpp"
#include "logical_ops.hpp"
using Type = ::testing::Types<LogicalOperatorType<ngraph::op::v1::LogicalXor, ngraph::element::boolean>>;
using Type = ::testing::Types<LogicalOperatorType<ov::op::v1::LogicalXor, ov::element::boolean>>;
INSTANTIATE_TYPED_TEST_SUITE_P(Type_prop_test, LogicalOperatorTypeProp, Type, LogicalOperatorTypeName);

789
src/core/tests/type_prop/loop.cpp
View File

File diff suppressed because it is too large Load Diff

23
src/core/tests/type_prop/lrn.cpp
View File

@ -2,20 +2,21 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/lrn.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/op/constant.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
TEST(type_prop, lrn_invalid_axes_rank) {
auto data = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto axes = make_shared<op::Parameter>(element::f32, Shape{1, 2});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto axes = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2});
double alpha = 0.1, beta = 0.2, bias = 0.3;
size_t size = 3;
try {
auto lrn = make_shared<op::LRN>(data, axes, alpha, beta, bias, size);
auto lrn = make_shared<op::v0::LRN>(data, axes, alpha, beta, bias, size);
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input tensor rank not detected";
} catch (const NodeValidationFailure& error) {
@ -24,9 +25,9 @@ TEST(type_prop, lrn_invalid_axes_rank) {
FAIL() << "Deduced type check failed for unexpected reason";
}
axes = make_shared<op::Parameter>(element::f32, Shape{5});
axes = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5});
try {
auto lrn = make_shared<op::LRN>(data, axes, alpha, beta, bias, size);
auto lrn = make_shared<op::v0::LRN>(data, axes, alpha, beta, bias, size);
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input tensor rank not detected";
} catch (const NodeValidationFailure& error) {
@ -37,12 +38,12 @@ TEST(type_prop, lrn_invalid_axes_rank) {
}
TEST(type_prop, lrn_incorrect_axes_value) {
auto data = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
auto axes = make_shared<op::Constant>(element::i64, Shape{2}, vector<int64_t>{3, 4});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3});
auto axes = make_shared<ov::op::v0::Constant>(element::i64, Shape{2}, vector<int64_t>{3, 4});
double alpha = 0.1, beta = 0.2, bias = 0.3;
size_t size = 3;
try {
auto lrn = make_shared<op::LRN>(data, axes, alpha, beta, bias, size);
auto lrn = make_shared<op::v0::LRN>(data, axes, alpha, beta, bias, size);
// Should have thrown, so fail if it didn't
FAIL() << "Invalid input tensor rank not detected";
} catch (const NodeValidationFailure& error) {

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

@ -3,12 +3,10 @@
//
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "ngraph/opsets/opset4.hpp"
#include "openvino/opsets/opset4.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
TEST(type_prop, lstm_cell) {
const size_t batch_size = 2;

8
src/core/tests/type_prop/lstm_sequence.cpp
View File

@ -3,13 +3,11 @@
//
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "ngraph/opsets/opset1.hpp"
#include "ngraph/opsets/opset5.hpp"
#include "openvino/opsets/opset1.hpp"
#include "openvino/opsets/opset5.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
//
// RNN sequence parameters

263
src/core/tests/type_prop/matmul.cpp
View File

@ -2,100 +2,105 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/matmul.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gmock/gmock.h"
#include "ngraph/ngraph.hpp"
#include "openvino/core/dimension_tracker.hpp"
#include "openvino/op/concat.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;
using namespace ov;
using namespace testing;
TEST(type_prop, matmul_2D_same) {
auto A = make_shared<op::Parameter>(element::f32, Shape{2, 2});
auto B = make_shared<op::Parameter>(element::f32, Shape{2, 2});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2});
auto matmul = make_shared<op::MatMul>(A, B);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{2, 2}));
}
TEST(type_prop, matmul_4D_same) {
auto A = make_shared<op::Parameter>(element::f32, Shape{2, 2, 3, 3});
auto B = make_shared<op::Parameter>(element::f32, Shape{2, 2, 3, 3});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2, 3, 3});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2, 3, 3});
auto matmul = make_shared<op::MatMul>(A, B);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{2, 2, 3, 3}));
}
TEST(type_prop, matmul_2D) {
auto A = make_shared<op::Parameter>(element::f32, Shape{3, 6});
auto B = make_shared<op::Parameter>(element::f32, Shape{6, 4});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 6});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{6, 4});
auto matmul = make_shared<op::MatMul>(A, B);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{3, 4}));
}
TEST(type_prop, matmul_4D) {
auto A = make_shared<op::Parameter>(element::f32, Shape{2, 2, 3, 6});
auto B = make_shared<op::Parameter>(element::f32, Shape{2, 2, 6, 4});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2, 3, 6});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2, 6, 4});
auto matmul = make_shared<op::MatMul>(A, B);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{2, 2, 3, 4}));
}
TEST(type_prop, matmul_5D_x_3D_transpose_a_transpose_b) {
auto A = make_shared<op::Parameter>(element::f32, Shape{2, 1, 6, 3});
auto B = make_shared<op::Parameter>(element::f32, Shape{7, 1, 5, 4, 6});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 1, 6, 3});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{7, 1, 5, 4, 6});
auto matmul = make_shared<op::MatMul>(A, B, true, true);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, true, true);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{7, 2, 5, 3, 4}));
}
TEST(type_prop, matmul_2D_transpose_a) {
auto A = make_shared<op::Parameter>(element::f32, Shape{6, 3});
auto B = make_shared<op::Parameter>(element::f32, Shape{6, 4});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{6, 3});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{6, 4});
auto matmul = make_shared<op::MatMul>(A, B, 1);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, 1);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{3, 4}));
}
TEST(type_prop, matmul_4D_transpose_a) {
auto A = make_shared<op::Parameter>(element::f32, Shape{2, 2, 6, 3});
auto B = make_shared<op::Parameter>(element::f32, Shape{2, 2, 6, 4});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2, 6, 3});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2, 6, 4});
auto matmul = make_shared<op::MatMul>(A, B, 1);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, 1);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{2, 2, 3, 4}));
}
TEST(type_prop, matmul_2D_transpose_b) {
auto A = make_shared<op::Parameter>(element::f32, Shape{3, 6});
auto B = make_shared<op::Parameter>(element::f32, Shape{4, 6});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 6});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4, 6});
auto matmul = make_shared<op::MatMul>(A, B, 0, 1);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, 0, 1);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{3, 4}));
}
TEST(type_prop, matmul_4D_transpose_b) {
auto A = make_shared<op::Parameter>(element::f32, Shape{2, 2, 3, 6});
auto B = make_shared<op::Parameter>(element::f32, Shape{2, 2, 4, 6});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2, 3, 6});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2, 4, 6});
auto matmul = make_shared<op::MatMul>(A, B, 0, 1);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, 0, 1);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{2, 2, 3, 4}));
@ -103,10 +108,10 @@ TEST(type_prop, matmul_4D_transpose_b) {
TEST(type_prop, matmul_dynamic_5D_transpose_b) {
Dimension dynamic = Dimension::dynamic();
auto A = make_shared<op::Parameter>(element::f32, PartialShape{dynamic, 4, dynamic, dynamic, 6});
auto B = make_shared<op::Parameter>(element::f32, PartialShape{1, dynamic, dynamic, 4, 6});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{dynamic, 4, dynamic, dynamic, 6});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, dynamic, dynamic, 4, 6});
auto matmul = make_shared<op::MatMul>(A, B, 0, 1);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, 0, 1);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_output_partial_shape(0), (PartialShape{Dimension(-1), 4, dynamic, dynamic, 4}));
@ -114,10 +119,10 @@ TEST(type_prop, matmul_dynamic_5D_transpose_b) {
TEST(type_prop, matmul_dynamic_2D_transpose_a) {
Dimension dynamic = Dimension::dynamic();
auto A = make_shared<op::Parameter>(element::f32, PartialShape{dynamic, 3});
auto B = make_shared<op::Parameter>(element::f32, PartialShape{4, dynamic});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{dynamic, 3});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{4, dynamic});
auto matmul = make_shared<op::MatMul>(A, B, 1, 0);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, 1, 0);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_output_partial_shape(0), (PartialShape{3, dynamic}));
@ -125,10 +130,10 @@ TEST(type_prop, matmul_dynamic_2D_transpose_a) {
TEST(type_prop, matmul_dynamic_1D_3D) {
Dimension dynamic = Dimension::dynamic();
auto A = make_shared<op::Parameter>(element::f32, PartialShape{dynamic});
auto B = make_shared<op::Parameter>(element::f32, PartialShape{2, 4, dynamic});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{dynamic});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, 4, dynamic});
auto matmul = make_shared<op::MatMul>(A, B);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_output_partial_shape(0), (PartialShape{2, dynamic}));
@ -137,54 +142,54 @@ TEST(type_prop, matmul_dynamic_1D_3D) {
// Transpose attributes are ignored for 1D
// 1D x 1D
TEST(type_prop, matmul_1D_x_1D_false_false) {
auto A = make_shared<op::Parameter>(element::f32, Shape{1});
auto B = make_shared<op::Parameter>(element::f32, Shape{1});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
auto matmul = make_shared<op::MatMul>(A, B, false, false);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, false, false);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{}));
}
TEST(type_prop, matmul_1D_x_1D_false_true) {
auto A = make_shared<op::Parameter>(element::f32, Shape{1});
auto B = make_shared<op::Parameter>(element::f32, Shape{1});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
auto matmul = make_shared<op::MatMul>(A, B, false, true);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, false, true);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{}));
}
TEST(type_prop, matmul_1D_x_1D_true_false) {
auto A = make_shared<op::Parameter>(element::f32, Shape{1});
auto B = make_shared<op::Parameter>(element::f32, Shape{1});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
auto matmul = make_shared<op::MatMul>(A, B, true, false);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, true, false);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{}));
}
TEST(type_prop, matmul_1D_x_1D_true_true) {
auto A = make_shared<op::Parameter>(element::f32, Shape{1});
auto B = make_shared<op::Parameter>(element::f32, Shape{1});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
auto matmul = make_shared<op::MatMul>(A, B, true, true);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, true, true);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{}));
}
TEST(type_prop, matmul_1D_x_1D_incompatible) {
auto A = make_shared<op::Parameter>(element::f32, Shape{3});
auto B = make_shared<op::Parameter>(element::f32, Shape{4});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
try {
auto matmul = make_shared<op::MatMul>(A, B);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B);
// Should have thrown, so fail if it didn't
FAIL() << "Incompatible matrix dimensions not detected. ";
} catch (const ngraph_error& error) {
} catch (const ov::Exception& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("Incompatible MatMul matrix dimension"));
} catch (...) {
FAIL() << "MatMul shape validation failed for unexpected reason";
@ -193,34 +198,34 @@ TEST(type_prop, matmul_1D_x_1D_incompatible) {
// 2D x 1D
TEST(type_prop, matmul_2D_x_1D_false_false) {
auto A = make_shared<op::Parameter>(element::f32, Shape{1, 2});
auto B = make_shared<op::Parameter>(element::f32, Shape{2});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2});
auto matmul = make_shared<op::MatMul>(A, B, false, false);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, false, false);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{1}));
}
TEST(type_prop, matmul_2D_x_1D_false_true) {
auto A = make_shared<op::Parameter>(element::f32, Shape{1, 2});
auto B = make_shared<op::Parameter>(element::f32, Shape{2});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2});
auto matmul = make_shared<op::MatMul>(A, B, false, true);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, false, true);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{1}));
}
TEST(type_prop, matmul_2D_x_1D_true_false) {
auto A = make_shared<op::Parameter>(element::f32, Shape{1, 2});
auto B = make_shared<op::Parameter>(element::f32, Shape{2});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2});
try {
auto matmul = make_shared<op::MatMul>(A, B, true, false);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, true, false);
// Should have thrown, so fail if it didn't
FAIL() << "Incompatible matrix dimensions not detected. ";
} catch (const ngraph_error& error) {
} catch (const ov::Exception& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("Incompatible MatMul matrix dimension"));
} catch (...) {
FAIL() << "MatMul shape validation failed for unexpected reason";
@ -228,14 +233,14 @@ TEST(type_prop, matmul_2D_x_1D_true_false) {
}
TEST(type_prop, matmul_2D_x_1D_true_true) {
auto A = make_shared<op::Parameter>(element::f32, Shape{1, 2});
auto B = make_shared<op::Parameter>(element::f32, Shape{2});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2});
try {
auto matmul = make_shared<op::MatMul>(A, B, true, true);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, true, true);
// Should have thrown, so fail if it didn't
FAIL() << "Incompatible matrix dimensions not detected. ";
} catch (const ngraph_error& error) {
} catch (const ov::Exception& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("Incompatible MatMul matrix dimension"));
} catch (...) {
FAIL() << "MatMul shape validation failed for unexpected reason";
@ -244,24 +249,24 @@ TEST(type_prop, matmul_2D_x_1D_true_true) {
// 1D x 2D
TEST(type_prop, matmul_1D_x_2D_false_false) {
auto A = make_shared<op::Parameter>(element::f32, Shape{2});
auto B = make_shared<op::Parameter>(element::f32, Shape{2, 1});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 1});
auto matmul = make_shared<op::MatMul>(A, B, false, false);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, false, false);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{1}));
}
TEST(type_prop, matmul_1D_x_2D_false_true) {
auto A = make_shared<op::Parameter>(element::f32, Shape{2});
auto B = make_shared<op::Parameter>(element::f32, Shape{2, 1});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 1});
try {
auto matmul = make_shared<op::MatMul>(A, B, false, true);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, false, true);
// Should have thrown, so fail if it didn't
FAIL() << "Incompatible matrix dimensions not detected. ";
} catch (const ngraph_error& error) {
} catch (const ov::Exception& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("Incompatible MatMul matrix dimension"));
} catch (...) {
FAIL() << "MatMul shape validation failed for unexpected reason";
@ -269,23 +274,23 @@ TEST(type_prop, matmul_1D_x_2D_false_true) {
}
TEST(type_prop, matmul_1D_x_2D_true_false) {
auto A = make_shared<op::Parameter>(element::f32, Shape{2});
auto B = make_shared<op::Parameter>(element::f32, Shape{2, 1});
auto matmul = make_shared<op::MatMul>(A, B, true, false);
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 1});
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, true, false);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{1}));
}
TEST(type_prop, matmul_1D_x_2D_true_true) {
auto A = make_shared<op::Parameter>(element::f32, Shape{2});
auto B = make_shared<op::Parameter>(element::f32, Shape{2, 1});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 1});
try {
auto matmul = make_shared<op::MatMul>(A, B, true, true);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, true, true);
// Should have thrown, so fail if it didn't
FAIL() << "Incompatible matrix dimensions not detected. ";
} catch (const ngraph_error& error) {
} catch (const ov::Exception& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("Incompatible MatMul matrix dimension"));
} catch (...) {
FAIL() << "MatMul shape validation failed for unexpected reason";
@ -294,10 +299,10 @@ TEST(type_prop, matmul_1D_x_2D_true_true) {
// 1D x 4D
TEST(type_prop, matmul_1D_x_4D_false_false) {
auto A = make_shared<op::Parameter>(element::f32, Shape{3});
auto B = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto matmul = make_shared<op::MatMul>(A, B, false, false);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, false, false);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{1, 2, 4}));
@ -305,10 +310,10 @@ TEST(type_prop, matmul_1D_x_4D_false_false) {
// 4D x 1D
TEST(type_prop, matmul_4D_x_1D_false_false) {
auto A = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto B = make_shared<op::Parameter>(element::f32, Shape{4});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto matmul = make_shared<op::MatMul>(A, B, false, false);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, false, false);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{1, 2, 3}));
@ -316,44 +321,44 @@ TEST(type_prop, matmul_4D_x_1D_false_false) {
// Batch broadcast
TEST(type_prop, matmul_batch_broadcast) {
auto A = make_shared<op::Parameter>(element::f32, Shape{5, 1, 1, 4, 3});
auto B = make_shared<op::Parameter>(element::f32, Shape{1, 1, 6, 3, 2});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 1, 1, 4, 3});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 1, 6, 3, 2});
auto matmul = make_shared<op::MatMul>(A, B, false, false);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, false, false);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{5, 1, 6, 4, 2}));
}
TEST(type_prop, matmul_batch_broadcast_expand_to_A) {
auto A = make_shared<op::Parameter>(element::f32, Shape{1, 4, 3});
auto B = make_shared<op::Parameter>(element::f32, Shape{7, 8, 5, 3, 2});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4, 3});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{7, 8, 5, 3, 2});
auto matmul = make_shared<op::MatMul>(A, B, false, false);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, false, false);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{7, 8, 5, 4, 2}));
}
TEST(type_prop, matmul_batch_broadcast_expand_to_B) {
auto A = make_shared<op::Parameter>(element::f32, Shape{8, 7, 6, 1, 4, 3});
auto B = make_shared<op::Parameter>(element::f32, Shape{1, 5, 3, 2});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{8, 7, 6, 1, 4, 3});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 5, 3, 2});
auto matmul = make_shared<op::MatMul>(A, B, false, false);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, false, false);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_shape(), (Shape{8, 7, 6, 5, 4, 2}));
}
TEST(type_prop, matmul_incompatible_batch_dims) {
auto A = make_shared<op::Parameter>(element::f32, Shape{7, 4, 3});
auto B = make_shared<op::Parameter>(element::f32, Shape{6, 3, 2});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, Shape{7, 4, 3});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, Shape{6, 3, 2});
try {
auto matmul = make_shared<op::MatMul>(A, B);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B);
// Should have thrown, so fail if it didn't
FAIL() << "Incompatible batch dimensions not detected. ";
} catch (const ngraph_error& error) {
} catch (const ov::Exception& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("Incompatible MatMul batch dimension"));
} catch (...) {
FAIL() << "MatMul shape validation failed for unexpected reason";
@ -361,10 +366,10 @@ TEST(type_prop, matmul_incompatible_batch_dims) {
}
TEST(type_prop, matmul_matrix_dynamic_bounds) {
auto A = make_shared<op::Parameter>(element::f32, PartialShape{Dimension(2, 5), Dimension(6, 10)});
auto B = make_shared<op::Parameter>(element::f32, PartialShape{Dimension(7, 8), Dimension(15, 20)});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension(2, 5), Dimension(6, 10)});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension(7, 8), Dimension(15, 20)});
auto matmul = make_shared<op::MatMul>(A, B, false, false);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, false, false);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_output_partial_shape(0), (PartialShape{Dimension(2, 5), Dimension(15, 20)}));
@ -439,37 +444,37 @@ TEST(type_prop, matmul_batch_dynamic_bounds) {
5, // 18
4}; // 19
auto A = make_shared<op::Parameter>(element::f32, A_shape);
auto B = make_shared<op::Parameter>(element::f32, B_shape);
auto A = make_shared<ov::op::v0::Parameter>(element::f32, A_shape);
auto B = make_shared<ov::op::v0::Parameter>(element::f32, B_shape);
auto matmul = make_shared<op::MatMul>(A, B);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_output_partial_shape(0), expected_output_shape);
}
TEST(type_prop, matmul_incompatible_matrix_dim_bounds) {
auto A = make_shared<op::Parameter>(element::f32, PartialShape{Dimension(2, 5), Dimension(3, 4)});
auto B = make_shared<op::Parameter>(element::f32, PartialShape{Dimension(1, 2), Dimension(15, 20)});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension(2, 5), Dimension(3, 4)});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension(1, 2), Dimension(15, 20)});
auto expected_output_shape = PartialShape{Dimension(2, 5), Dimension(15, 20)};
// No error for backward compatibility
auto matmul = make_shared<op::MatMul>(A, B, false, false);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, false, false);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_output_partial_shape(0), expected_output_shape);
}
TEST(type_prop, matmul_incompatible_batch_dim_bounds) {
auto A = make_shared<op::Parameter>(element::f32, PartialShape{Dimension(2, 5), 4, 3});
auto B = make_shared<op::Parameter>(element::f32, PartialShape{Dimension(6, 10), 3, 2});
auto A = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension(2, 5), 4, 3});
auto B = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension(6, 10), 3, 2});
Dimension dynamic = Dimension::dynamic();
auto expected_output_shape = PartialShape{dynamic, 4, 2};
// No error for backward compatibility
auto matmul = make_shared<op::MatMul>(A, B, false, false);
auto matmul = make_shared<ov::op::v0::MatMul>(A, B, false, false);
ASSERT_EQ(matmul->get_element_type(), element::f32);
ASSERT_EQ(matmul->get_output_partial_shape(0), expected_output_shape);
@ -485,9 +490,9 @@ TEST(type_prop, matmul_propagate_labels) {
set_shape_labels(a_shape, a_labels);
set_shape_labels(b_shape, b_labels);
const auto a = make_shared<op::Parameter>(element::f32, a_shape);
const auto b = make_shared<op::Parameter>(element::f32, b_shape);
const auto matmul = make_shared<op::MatMul>(a, b, false, false);
const auto a = make_shared<ov::op::v0::Parameter>(element::f32, a_shape);
const auto b = make_shared<ov::op::v0::Parameter>(element::f32, b_shape);
const auto matmul = make_shared<ov::op::v0::MatMul>(a, b, false, false);
const auto& output_shape = matmul->get_output_partial_shape(0);
const auto labels = get_shape_labels(output_shape);
@ -511,9 +516,9 @@ TEST(type_prop, matmul_propagate_labels_on_interval_dims) {
set_shape_labels(a_shape, a_labels);
set_shape_labels(b_shape, b_labels);
const auto a = make_shared<op::Parameter>(element::f32, a_shape);
const auto b = make_shared<op::Parameter>(element::f32, b_shape);
const auto matmul = make_shared<op::MatMul>(a, b, false, false);
const auto a = make_shared<ov::op::v0::Parameter>(element::f32, a_shape);
const auto b = make_shared<ov::op::v0::Parameter>(element::f32, b_shape);
const auto matmul = make_shared<ov::op::v0::MatMul>(a, b, false, false);
const auto& output_shape = matmul->get_output_partial_shape(0);
const auto labels = get_shape_labels(output_shape);
@ -535,19 +540,19 @@ TEST(type_prop, matmul_propagate_label_on_b_input_after_reshape) {
const auto a_shape = PartialShape{Dimension::dynamic(), 5, 3};
const auto b_shape = PartialShape{3, marked_dim, 2};
const auto b = make_shared<op::Parameter>(element::f32, b_shape);
const auto shape_of_b = std::make_shared<op::ShapeOf>(b);
const auto b = make_shared<ov::op::v0::Parameter>(element::f32, b_shape);
const auto shape_of_b = std::make_shared<op::v0::ShapeOf>(b);
const auto gather = std::make_shared<op::v7::Gather>(
shape_of_b,
std::make_shared<op::Constant>(element::i64, Shape{2}, std::vector<int64_t>{1, 0}),
std::make_shared<op::Constant>(element::i64, Shape{}, 0));
const auto concat =
std::make_shared<op::Concat>(OutputVector{gather, std::make_shared<op::Constant>(element::i64, Shape{1}, 8)},
0);
std::make_shared<ov::op::v0::Constant>(element::i64, Shape{2}, std::vector<int64_t>{1, 0}),
std::make_shared<ov::op::v0::Constant>(element::i64, Shape{}, 0));
const auto concat = std::make_shared<op::v0::Concat>(
OutputVector{gather, std::make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, 8)},
0);
const auto reshape_b = make_shared<op::v1::Reshape>(b, concat, false);
const auto a = make_shared<op::Parameter>(element::f32, a_shape);
const auto matmul = make_shared<op::MatMul>(a, reshape_b, false, false);
const auto a = make_shared<ov::op::v0::Parameter>(element::f32, a_shape);
const auto matmul = make_shared<ov::op::v0::MatMul>(a, reshape_b, false, false);
const auto& output_shape = matmul->get_output_partial_shape(0);
const auto labels = get_shape_labels(output_shape);

45
src/core/tests/type_prop/max_pool.cpp
View File

@ -2,13 +2,14 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/max_pool.hpp"
#include "common_test_utils/type_prop.hpp"
#include "dimension_util.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/op/parameter.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace testing;
TEST(type_prop, max_pool_default_ctor) {
@ -19,7 +20,7 @@ TEST(type_prop, max_pool_default_ctor) {
const Shape pads_end{2};
const Shape kernel_shape{2};
auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
auto mp = make_shared<op::v1::MaxPool>();
mp->set_argument(0, arg);
@ -47,7 +48,7 @@ TEST(type_prop, max_pool_valid_auto_padding) {
const auto rounding_mode = op::RoundingType::FLOOR;
const auto auto_pad = op::PadType::VALID;
auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
auto mp = make_shared<op::v1::MaxPool>(arg, strides, pads_begin, pads_end, kernel_shape, rounding_mode, auto_pad);
EXPECT_EQ(mp->get_output_partial_shape(0), PartialShape({1, 3, {9, 31}}));
EXPECT_THAT(get_shape_labels(mp->get_output_partial_shape(0)), ElementsAre(10, 11, ov::no_label));
@ -64,7 +65,7 @@ TEST(type_prop, max_pool_1D_auto_padding) {
const auto rounding_mode = op::RoundingType::FLOOR;
const auto auto_pad = op::PadType::SAME_LOWER;
auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
auto mp = make_shared<op::v1::MaxPool>(arg, strides, pads_begin, pads_end, kernel_shape, rounding_mode, auto_pad);
EXPECT_EQ(mp->get_output_partial_shape(0), PartialShape({1, 3, 32}));
@ -81,7 +82,7 @@ TEST(type_prop, max_pool_2D_auto_padding) {
const auto rounding_mode = op::RoundingType::FLOOR;
const auto auto_pad = op::PadType::SAME_LOWER;
auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
auto mp = make_shared<op::v1::MaxPool>(arg, strides, pads_begin, pads_end, kernel_shape, rounding_mode, auto_pad);
EXPECT_EQ(mp->get_output_partial_shape(0), PartialShape({1, 3, 32, 32}));
@ -98,7 +99,7 @@ TEST(type_prop, max_pool_auto_padding_1D_nc_dims_dynamic_same_lower) {
const auto rounding_mode = op::RoundingType::FLOOR;
const auto auto_pad = op::PadType::SAME_LOWER;
auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
auto mp = make_shared<op::v1::MaxPool>(arg, strides, pads_begin, pads_end, kernel_shape, rounding_mode, auto_pad);
EXPECT_EQ(mp->get_output_partial_shape(0), PartialShape({Dimension::dynamic(), 32, 32}));
@ -115,7 +116,7 @@ TEST(type_prop, max_pool_auto_padding_2D_nc_dims_dynamic_same_lower) {
const auto rounding_mode = op::RoundingType::FLOOR;
const auto auto_pad = op::PadType::SAME_LOWER;
auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
auto mp = make_shared<op::v1::MaxPool>(arg, strides, pads_begin, pads_end, kernel_shape, rounding_mode, auto_pad);
EXPECT_EQ(mp->get_output_partial_shape(0), PartialShape({Dimension::dynamic(), Dimension::dynamic(), 32, 32}));
@ -133,7 +134,7 @@ TEST(type_prop, max_pool_auto_padding_nc_dims_dynamic_same_upper) {
const auto rounding_mode = op::RoundingType::FLOOR;
const auto auto_pad = op::PadType::SAME_UPPER;
auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
auto mp = make_shared<op::v1::MaxPool>(arg, strides, pads_begin, pads_end, kernel_shape, rounding_mode, auto_pad);
EXPECT_EQ(mp->get_output_partial_shape(0), PartialShape({Dimension::dynamic(), Dimension::dynamic(), 32, 32}));
@ -152,7 +153,7 @@ TEST(type_prop, max_pool_auto_padding_interval_dims_same_upper) {
const auto rounding_mode = op::RoundingType::FLOOR;
const auto auto_pad = op::PadType::SAME_UPPER;
auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
auto mp = make_shared<op::v1::MaxPool>(arg, strides, pads_begin, pads_end, kernel_shape, rounding_mode, auto_pad);
EXPECT_EQ(mp->get_output_partial_shape(0), PartialShape({{1, 2}, {2, 3}, -1, -1}));
@ -170,7 +171,7 @@ TEST(type_prop, max_pool_auto_padding_spatial_dims_dynamic) {
const auto rounding_mode = op::RoundingType::FLOOR;
const auto auto_pad = op::PadType::SAME_LOWER;
auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
auto mp = make_shared<op::v1::MaxPool>(arg, strides, pads_begin, pads_end, kernel_shape, rounding_mode, auto_pad);
EXPECT_EQ(mp->get_output_partial_shape(0), PartialShape({1, 3, 32, Dimension::dynamic()}));
@ -185,7 +186,7 @@ TEST(type_prop, max_pool_default_values) {
const Shape pads_end{0, 0};
const Shape kernel_shape{2, 2};
auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
auto mp = make_shared<op::v1::MaxPool>(arg, strides, pads_begin, pads_end, kernel_shape);
EXPECT_EQ(mp->get_rounding_type(), op::RoundingType::FLOOR);
@ -200,7 +201,7 @@ TEST(type_prop, max_pool_v8_3D_no_dilations) {
const Shape pads_end{0};
const Shape kernel_shape{3};
const auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
const auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
const auto mp = make_shared<op::v8::MaxPool>(arg, strides, dilations, pads_begin, pads_end, kernel_shape);
const auto expected_output_shape = PartialShape({1, 7, 11});
@ -216,7 +217,7 @@ TEST(type_prop, max_pool_v8_3D_with_dilations) {
const Shape pads_end{0};
const Shape kernel_shape{3};
const auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
const auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
const auto mp = make_shared<op::v8::MaxPool>(arg, strides, dilations, pads_begin, pads_end, kernel_shape);
const auto expected_output_shape = PartialShape({1, 7, 9});
@ -232,7 +233,7 @@ TEST(type_prop, max_pool_v8_3D_with_dilations_and_padding) {
const Shape pads_end{2};
const Shape kernel_shape{3};
const auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
const auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
const auto mp = make_shared<op::v8::MaxPool>(arg, strides, dilations, pads_begin, pads_end, kernel_shape);
const auto expected_output_shape = PartialShape({1, 7, 12});
@ -248,7 +249,7 @@ TEST(type_prop, max_pool_v8_4D_no_dilations) {
const Shape pads_end{0, 0};
const Shape kernel_shape{2, 2};
const auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
const auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
const auto mp = make_shared<op::v8::MaxPool>(arg, strides, dilations, pads_begin, pads_end, kernel_shape);
const auto expected_output_shape = PartialShape({1, 3, 12, 12});
@ -264,7 +265,7 @@ TEST(type_prop, max_pool_v8_4D_with_dilations) {
const Shape pads_end{0, 0};
const Shape kernel_shape{2, 2};
const auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
const auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
const auto mp = make_shared<op::v8::MaxPool>(arg, strides, dilations, pads_begin, pads_end, kernel_shape);
const auto expected_output_shape = PartialShape({1, 3, 11, 10});
@ -281,7 +282,7 @@ TEST(type_prop, max_pool_v8_4D_dynamic_dims_with_non_zero_low_range_floor_mode)
const Shape kernel_shape{2, 2};
const auto rounding_mode = op::RoundingType::FLOOR;
const auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
const auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
const auto mp =
make_shared<op::v8::MaxPool>(arg, strides, dilations, pads_begin, pads_end, kernel_shape, rounding_mode);
@ -300,7 +301,7 @@ TEST(type_prop, max_pool_v8_4D_dynamic_dims_with_non_zero_low_range_ceil_mode) {
const Shape kernel_shape{2, 2};
const auto rounding_mode = op::RoundingType::CEIL;
const auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
const auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
const auto mp =
make_shared<op::v8::MaxPool>(arg, strides, dilations, pads_begin, pads_end, kernel_shape, rounding_mode);
@ -319,7 +320,7 @@ TEST(type_prop, max_pool_v8_4D_interval_dims_with_dilations) {
const Shape pads_end{0, 0};
const Shape kernel_shape{2, 2};
const auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
const auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
const auto mp = make_shared<op::v8::MaxPool>(arg, strides, dilations, pads_begin, pads_end, kernel_shape);
const auto expected_output_shape = PartialShape({{2, 3}, {1, 3}, {1, 11}, {3, 10}});
@ -338,7 +339,7 @@ TEST(type_prop, max_pool_v8_4D_with_dilations_and_auto_pad_same_upper) {
const auto rounding_mode = op::RoundingType::FLOOR;
const auto auto_pad = op::PadType::SAME_UPPER;
const auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
const auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
const auto mp = make_shared<op::v8::MaxPool>(arg,
strides,
dilations,

27
src/core/tests/type_prop/mish.cpp
View File

@ -2,33 +2,34 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/mish.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;
TEST(type_prop, mish) {
auto data = make_shared<op::Parameter>(element::f32, Shape{1, 3, 6});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 6});
auto mish_func = make_shared<op::v4::Mish>(data);
EXPECT_EQ(mish_func->get_element_type(), element::f32);
EXPECT_EQ(mish_func->get_shape(), (Shape{1, 3, 6}));
}
TEST(type_prop, mish_partial) {
auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto mish_func = make_shared<op::v4::Mish>(data);
EXPECT_EQ(mish_func->get_element_type(), element::f32);
ASSERT_TRUE(mish_func->get_output_partial_shape(0).same_scheme((PartialShape{1, Dimension::dynamic(), 6})));
// rank unknown
auto mish_partial = make_shared<op::v4::Mish>(make_shared<op::Parameter>(element::f32, PartialShape::dynamic()));
auto mish_partial =
make_shared<op::v4::Mish>(make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic()));
ASSERT_TRUE(mish_partial->get_output_partial_shape(0).same_scheme(PartialShape::dynamic()));
}
TEST(type_prop, mish_partial_static_rank) {
auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto mish_func = make_shared<op::v4::Mish>(data);
EXPECT_EQ(mish_func->get_element_type(), element::f32);
ASSERT_TRUE(mish_func->get_output_partial_shape(0).same_scheme((PartialShape{1, Dimension::dynamic(), 6})));
@ -36,16 +37,16 @@ TEST(type_prop, mish_partial_static_rank) {
}
TEST(type_prop, mish_incompatible_dtype_i32) {
auto data = make_shared<op::Parameter>(element::i32, Shape{1, 3, 6});
ASSERT_THROW(const auto unused = std::make_shared<op::v4::Mish>(data), ngraph::NodeValidationFailure);
auto data = make_shared<ov::op::v0::Parameter>(element::i32, Shape{1, 3, 6});
ASSERT_THROW(const auto unused = std::make_shared<op::v4::Mish>(data), ov::NodeValidationFailure);
}
TEST(type_prop, mish_incompatible_dtype_u32) {
auto data = make_shared<op::Parameter>(element::u32, Shape{1, 3, 6});
ASSERT_THROW(const auto unused = std::make_shared<op::v4::Mish>(data), ngraph::NodeValidationFailure);
auto data = make_shared<ov::op::v0::Parameter>(element::u32, Shape{1, 3, 6});
ASSERT_THROW(const auto unused = std::make_shared<op::v4::Mish>(data), ov::NodeValidationFailure);
}
TEST(type_prop, mish_incompatible_dtype_boolean) {
auto data = make_shared<op::Parameter>(element::boolean, Shape{1, 3, 6});
ASSERT_THROW(const auto unused = std::make_shared<op::v4::Mish>(data), ngraph::NodeValidationFailure);
auto data = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{1, 3, 6});
ASSERT_THROW(const auto unused = std::make_shared<op::v4::Mish>(data), ov::NodeValidationFailure);
}

1
src/core/tests/type_prop/multiclass_nms.cpp
View File

@ -6,7 +6,6 @@
#include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
using namespace std;
using namespace ov;

38
src/core/tests/type_prop/mvn.cpp
View File

@ -2,34 +2,35 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/mvn.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;
// ------------------------------ V0 ------------------------------
TEST(type_prop, mvn) {
auto data = make_shared<op::Parameter>(element::f32, Shape{1, 3, 6});
auto mvn_func = make_shared<op::MVN>(data);
auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 6});
auto mvn_func = make_shared<op::v0::MVN>(data);
EXPECT_EQ(mvn_func->get_element_type(), element::f32);
EXPECT_EQ(mvn_func->get_shape(), (Shape{1, 3, 6}));
}
TEST(type_prop, mvn_partial) {
auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto mvn_func = make_shared<op::MVN>(data);
auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto mvn_func = make_shared<op::v0::MVN>(data);
EXPECT_EQ(mvn_func->get_element_type(), element::f32);
EXPECT_EQ(mvn_func->get_reduction_axes(), (AxisSet{1, 2}));
ASSERT_TRUE(mvn_func->get_output_partial_shape(0).same_scheme((PartialShape{1, Dimension::dynamic(), 6})));
// across_channels = false
EXPECT_EQ(make_shared<op::MVN>(data, false)->get_reduction_axes(), (AxisSet{2}));
EXPECT_EQ(make_shared<op::v0::MVN>(data, false)->get_reduction_axes(), (AxisSet{2}));
// rank unknown
auto mvn_partial = make_shared<op::MVN>(make_shared<op::Parameter>(element::f32, PartialShape::dynamic()));
auto mvn_partial =
make_shared<op::v0::MVN>(make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic()));
EXPECT_EQ(mvn_partial->get_reduction_axes(), AxisSet{});
ASSERT_TRUE(mvn_partial->get_output_partial_shape(0).same_scheme(PartialShape::dynamic()));
}
@ -37,8 +38,8 @@ TEST(type_prop, mvn_partial) {
// ------------------------------ V6 ------------------------------
TEST(type_prop, mvn_6) {
auto data = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto axes = make_shared<op::Parameter>(element::i64, Shape{3});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto axes = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto mvn_func = make_shared<op::v6::MVN>(data, axes, true, 1e-6f, op::MVNEpsMode::INSIDE_SQRT);
EXPECT_EQ(mvn_func->get_element_type(), element::f32);
@ -46,17 +47,18 @@ TEST(type_prop, mvn_6) {
}
TEST(type_prop, mvn_6_partial) {
auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 5, 6});
auto axes = make_shared<op::Parameter>(element::i64, Shape{3});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 5, 6});
auto axes = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto mvn_func = make_shared<op::v6::MVN>(data, axes, true, 1e-6f, op::MVNEpsMode::INSIDE_SQRT);
EXPECT_EQ(mvn_func->get_element_type(), element::f32);
ASSERT_TRUE(mvn_func->get_output_partial_shape(0).same_scheme((PartialShape{1, Dimension::dynamic(), 5, 6})));
// rank unknown
auto mvn_partial = make_shared<op::v6::MVN>(make_shared<op::Parameter>(element::f32, PartialShape::dynamic()),
axes,
true,
1e-6f,
op::MVNEpsMode::INSIDE_SQRT);
auto mvn_partial =
make_shared<op::v6::MVN>(make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic()),
axes,
true,
1e-6f,
op::MVNEpsMode::INSIDE_SQRT);
ASSERT_TRUE(mvn_partial->get_output_partial_shape(0).same_scheme(PartialShape::dynamic()));
}

4
src/core/tests/type_prop/negative.cpp
View File

@ -2,8 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/negative.hpp"
#include "unary_ops.hpp"
using Type = ::testing::Types<ngraph::op::Negative>;
using Type = ::testing::Types<ov::op::v0::Negative>;
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_negative, UnaryOperator, Type);

1
src/core/tests/type_prop/non_max_suppression.cpp
View File

@ -6,7 +6,6 @@
#include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "openvino/op/constant.hpp"
using namespace std;

24
src/core/tests/type_prop/non_zero.cpp
View File

@ -2,36 +2,36 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/non_zero.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;
TEST(type_prop, non_zero) {
auto data = make_shared<op::Parameter>(element::f32, Shape{3, 3, 224, 224});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 3, 224, 224});
auto non_zero = make_shared<op::v3::NonZero>(data);
EXPECT_EQ(non_zero->get_element_type(), element::i64);
ASSERT_EQ(non_zero->get_output_partial_shape(0), (PartialShape{4, {0, 451584}}));
}
TEST(type_prop, non_zero_partial_input) {
auto data = make_shared<op::Parameter>(element::f32, PartialShape{{3, 4}, {5, 6}, {7, 8}});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{{3, 4}, {5, 6}, {7, 8}});
auto non_zero = make_shared<op::v3::NonZero>(data);
EXPECT_EQ(non_zero->get_element_type(), element::i64);
ASSERT_EQ(non_zero->get_output_partial_shape(0), (PartialShape{3, {0, 192}}));
}
TEST(type_prop, non_zero_partial_with_negative) {
auto data = make_shared<op::Parameter>(element::f32, PartialShape{{3, 4}, {5, 6}, -1});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{{3, 4}, {5, 6}, -1});
auto non_zero = make_shared<op::v3::NonZero>(data);
EXPECT_EQ(non_zero->get_element_type(), element::i64);
ASSERT_EQ(non_zero->get_output_partial_shape(0), (PartialShape{3, -1}));
}
TEST(type_prop, non_zero_dynamic) {
auto data = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto non_zero = make_shared<op::v3::NonZero>(data);
EXPECT_EQ(non_zero->get_element_type(), element::i64);
EXPECT_TRUE(
@ -39,7 +39,7 @@ TEST(type_prop, non_zero_dynamic) {
}
TEST(type_prop, non_zero_output_type) {
auto data = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto non_zero = make_shared<op::v3::NonZero>(data, element::i32);
ASSERT_EQ(non_zero->get_output_element_type(0), element::i32);
@ -47,7 +47,7 @@ TEST(type_prop, non_zero_output_type) {
}
TEST(type_prop, non_zero_string_output_type) {
auto data = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto non_zero = make_shared<op::v3::NonZero>(data, "i32");
ASSERT_EQ(non_zero->get_output_element_type(0), element::i32);
@ -55,7 +55,7 @@ TEST(type_prop, non_zero_string_output_type) {
}
TEST(type_prop, non_zero_bool_input_type) {
auto data = make_shared<op::Parameter>(element::boolean, Shape{1, 2, 3, 4});
auto data = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{1, 2, 3, 4});
auto non_zero = make_shared<op::v3::NonZero>(data, element::i32);
ASSERT_EQ(non_zero->get_output_element_type(0), element::i32);
@ -64,9 +64,9 @@ TEST(type_prop, non_zero_bool_input_type) {
TEST(type_prop, non_zero_fail_index_element_type) {
// Deduce type
auto data = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
try {
auto non_zero = make_shared<op::v3::NonZero>(data, element::i16);
auto non_zero = make_shared<ov::op::v3::NonZero>(data, element::i16);
// Should have thrown, so fail if it didn't
FAIL() << "Invalid output type not detected";

31
src/core/tests/type_prop/normalize_l2.cpp
View File

@ -2,17 +2,18 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/normalize_l2.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/op/constant.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
TEST(type_prop, normalize_l2) {
PartialShape data_shape{1, 2, 3, 4};
auto data = make_shared<op::Parameter>(element::f32, data_shape);
const auto axes = make_shared<op::Constant>(element::i32, Shape{2}, vector<int64_t>{1, 2});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
const auto axes = make_shared<ov::op::v0::Constant>(element::i32, Shape{2}, vector<int64_t>{1, 2});
float eps{1e-6f};
auto eps_mode = op::EpsMode::ADD;
auto normalize = make_shared<op::v0::NormalizeL2>(data, axes, eps, eps_mode);
@ -23,8 +24,8 @@ TEST(type_prop, normalize_l2) {
TEST(type_prop, normalize_l2_dynamic) {
PartialShape data_shape{2, Dimension::dynamic(), 3, Dimension(4, 6)};
auto data = make_shared<op::Parameter>(element::f32, data_shape);
const auto axes = make_shared<op::Constant>(element::i32, Shape{2}, vector<int64_t>{1, 2});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
const auto axes = make_shared<ov::op::v0::Constant>(element::i32, Shape{2}, vector<int64_t>{1, 2});
float eps{1e-6f};
auto eps_mode = op::EpsMode::ADD;
auto normalize = make_shared<op::v0::NormalizeL2>(data, axes, eps, eps_mode);
@ -35,8 +36,8 @@ TEST(type_prop, normalize_l2_dynamic) {
TEST(type_prop, normalize_l2_axes_input_not_constant) {
Shape data_shape{1, 2, 3, 4};
auto data = make_shared<op::Parameter>(element::f32, data_shape);
auto axes = make_shared<op::Parameter>(element::u64, Shape{1});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto axes = make_shared<ov::op::v0::Parameter>(element::u64, Shape{1});
float eps{1e-6f};
auto eps_mode = op::EpsMode::ADD;
ASSERT_NO_THROW(auto op = make_shared<op::v0::NormalizeL2>(data, axes, eps, eps_mode));
@ -44,8 +45,8 @@ TEST(type_prop, normalize_l2_axes_input_not_constant) {
TEST(type_prop, normalize_l2_invalid_axes_rank) {
Shape data_shape{1, 2, 3, 4};
auto data = make_shared<op::Parameter>(element::f32, data_shape);
const auto axes = make_shared<op::Constant>(element::i64, Shape{1, 2}, vector<int64_t>{1, 2});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
const auto axes = make_shared<ov::op::v0::Constant>(element::i64, Shape{1, 2}, vector<int64_t>{1, 2});
float eps{1e-6f};
auto eps_mode = op::EpsMode::ADD;
@ -62,8 +63,8 @@ TEST(type_prop, normalize_l2_invalid_axes_rank) {
TEST(type_prop, normalize_l2_axes_out_of_bounds) {
Shape data_shape{1, 2, 3, 4};
auto data = make_shared<op::Parameter>(element::f32, data_shape);
const auto axes = make_shared<op::Constant>(element::i64, Shape{2}, vector<int64_t>{3, 4});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
const auto axes = make_shared<ov::op::v0::Constant>(element::i64, Shape{2}, vector<int64_t>{3, 4});
float eps{1e-6f};
auto eps_mode = op::EpsMode::ADD;
@ -80,8 +81,8 @@ TEST(type_prop, normalize_l2_axes_out_of_bounds) {
TEST(type_prop, normalize_l2_negative_axes) {
PartialShape data_shape{1, 2, 3, 4};
auto data = make_shared<op::Parameter>(element::f32, data_shape);
const auto axes = make_shared<op::Constant>(element::i32, Shape{1}, vector<int64_t>{-1});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
const auto axes = make_shared<ov::op::v0::Constant>(element::i32, Shape{1}, vector<int64_t>{-1});
float eps{1e-6f};
auto eps_mode = op::EpsMode::ADD;
auto normalize = make_shared<op::v0::NormalizeL2>(data, axes, eps, eps_mode);

161
src/core/tests/type_prop/one_hot.cpp
View File

@ -2,43 +2,46 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/one_hot.hpp"
#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/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, one_hot_v1_output_shape) {
auto indices = make_shared<op::Parameter>(element::i64, Shape{3});
auto depth = op::Constant::create(element::i64, Shape{}, {2});
auto on_value = op::Constant::create(element::u32, Shape{}, {5});
auto off_value = op::Constant::create(element::u32, Shape{}, {10});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3});
auto depth = ov::op::v0::Constant::create(element::i64, Shape{}, {2});
auto on_value = ov::op::v0::Constant::create(element::u32, Shape{}, {5});
auto off_value = ov::op::v0::Constant::create(element::u32, Shape{}, {10});
int64_t axis = -1;
auto ont_hot = make_shared<op::v1::OneHot>(indices, depth, on_value, off_value, axis);
ASSERT_EQ(ont_hot->get_element_type(), element::u32);
ASSERT_EQ(ont_hot->get_shape(), (Shape{3, 2}));
auto dyn_indices = make_shared<op::Parameter>(element::i64, PartialShape{{1, 3}});
auto dyn_indices = make_shared<ov::op::v0::Parameter>(element::i64, PartialShape{{1, 3}});
auto dyn_ont_hot = make_shared<op::v1::OneHot>(dyn_indices, depth, on_value, off_value, axis);
ASSERT_EQ(dyn_ont_hot->get_output_element_type(0), element::u32);
ASSERT_EQ(dyn_ont_hot->get_output_partial_shape(0), (PartialShape{{1, 3}, 2}));
}
TEST(type_prop, one_hot_v1_output_shape_2) {
auto indices = make_shared<op::Parameter>(element::i64, Shape{1, 3, 2, 3});
auto depth = op::Constant::create(element::i64, Shape{}, {4});
auto on_value = op::Constant::create(element::f32, Shape{}, {1.0f});
auto off_value = op::Constant::create(element::f32, Shape{}, {0.0f});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{1, 3, 2, 3});
auto depth = ov::op::v0::Constant::create(element::i64, Shape{}, {4});
auto on_value = ov::op::v0::Constant::create(element::f32, Shape{}, {1.0f});
auto off_value = ov::op::v0::Constant::create(element::f32, Shape{}, {0.0f});
int64_t axis = 3;
auto ont_hot = make_shared<op::v1::OneHot>(indices, depth, on_value, off_value, axis);
ASSERT_EQ(ont_hot->get_element_type(), element::f32);
ASSERT_EQ(ont_hot->get_shape(), (Shape{1, 3, 2, 4, 3}));
auto dyn_indices = make_shared<op::Parameter>(element::i64, PartialShape{1, {3, 5}, 2, 3});
auto dyn_indices = make_shared<ov::op::v0::Parameter>(element::i64, PartialShape{1, {3, 5}, 2, 3});
auto dyn_ont_hot = make_shared<op::v1::OneHot>(dyn_indices, depth, on_value, off_value, axis);
ASSERT_EQ(dyn_ont_hot->get_output_element_type(0), element::f32);
ASSERT_EQ(dyn_ont_hot->get_output_partial_shape(0), (PartialShape{1, {3, 5}, 2, 4, 3}));
@ -48,10 +51,10 @@ TEST(type_prop, one_hot_v1_indices_labels) {
auto ind_shape = PartialShape{-1, {3, 5}, 2, 3};
set_shape_labels(ind_shape, {10, 11, 12, 13});
auto dyn_indices = make_shared<op::Parameter>(element::i64, ind_shape);
auto depth = op::Constant::create(element::i64, Shape{}, {4});
auto on_value = op::Constant::create(element::f32, Shape{}, {1.0f});
auto off_value = op::Constant::create(element::f32, Shape{}, {0.0f});
auto dyn_indices = make_shared<ov::op::v0::Parameter>(element::i64, ind_shape);
auto depth = ov::op::v0::Constant::create(element::i64, Shape{}, {4});
auto on_value = ov::op::v0::Constant::create(element::f32, Shape{}, {1.0f});
auto off_value = ov::op::v0::Constant::create(element::f32, Shape{}, {0.0f});
int64_t axis = 1;
PartialShape expected_shape{-1, 4, {3, 5}, 2, 3};
@ -69,16 +72,16 @@ TEST(type_prop, one_hot_v1_depth_shape_of_value) {
auto ind_shape = PartialShape{-1, {3, 5}, 2, 3};
set_shape_labels(ind_shape, {10, 11, 12, 13});
auto dyn_indices = make_shared<op::Parameter>(element::i64, ind_shape);
auto dyn_indices = make_shared<ov::op::v0::Parameter>(element::i64, ind_shape);
PartialShape shape_for_depth = PartialShape{4};
auto data = make_shared<op::Parameter>(element::i8, shape_for_depth);
auto data = make_shared<ov::op::v0::Parameter>(element::i8, shape_for_depth);
auto depth_dim = make_shared<op::v3::ShapeOf>(data);
auto depth = make_shared<op::v0::Squeeze>(depth_dim);
auto on_value = op::Constant::create(element::f32, Shape{}, {1.0f});
auto off_value = op::Constant::create(element::f32, Shape{}, {0.0f});
auto on_value = ov::op::v0::Constant::create(element::f32, Shape{}, {1.0f});
auto off_value = ov::op::v0::Constant::create(element::f32, Shape{}, {0.0f});
int64_t axis = 1;
PartialShape expected_shape{-1, 4, {3, 5}, 2, 3};
@ -94,19 +97,19 @@ TEST(type_prop, one_hot_v1_depth_value_label) {
auto ind_shape = PartialShape{-1, {3, 5}, 2, 3};
set_shape_labels(ind_shape, {10, 11, 12, 13});
auto dyn_indices = make_shared<op::Parameter>(element::i64, ind_shape);
auto dyn_indices = make_shared<ov::op::v0::Parameter>(element::i64, ind_shape);
auto labeled_dim = Dimension(4, 6);
ov::label_t depth_label = 2345664;
ov::DimensionTracker::set_label(labeled_dim, depth_label);
PartialShape shape_for_depth = PartialShape{labeled_dim};
auto data = make_shared<op::Parameter>(element::i8, shape_for_depth);
auto data = make_shared<ov::op::v0::Parameter>(element::i8, shape_for_depth);
auto depth_dim = make_shared<op::v3::ShapeOf>(data);
auto depth = make_shared<op::v0::Squeeze>(depth_dim);
auto on_value = op::Constant::create(element::f32, Shape{}, {1.0f});
auto off_value = op::Constant::create(element::f32, Shape{}, {0.0f});
auto on_value = ov::op::v0::Constant::create(element::f32, Shape{}, {1.0f});
auto off_value = ov::op::v0::Constant::create(element::f32, Shape{}, {0.0f});
int64_t axis = 1;
PartialShape expected_shape{-1, {4, 6}, {3, 5}, 2, 3};
@ -124,10 +127,10 @@ TEST(type_prop, one_hot_v1_output_labels) {
auto ind_shape = PartialShape{-1, {3, 5}, 2, 3};
set_shape_labels(ind_shape, {10, 11, 12, 13});
auto dyn_indices = make_shared<op::Parameter>(element::i64, ind_shape);
auto depth = op::Constant::create(element::i64, Shape{}, {4});
auto on_value = op::Constant::create(element::f32, Shape{}, {1.0f});
auto off_value = op::Constant::create(element::f32, Shape{}, {0.0f});
auto dyn_indices = make_shared<ov::op::v0::Parameter>(element::i64, ind_shape);
auto depth = ov::op::v0::Constant::create(element::i64, Shape{}, {4});
auto on_value = ov::op::v0::Constant::create(element::f32, Shape{}, {1.0f});
auto off_value = ov::op::v0::Constant::create(element::f32, Shape{}, {0.0f});
int64_t axis = 1;
PartialShape expected_shape{-1, 4, {3, 5}, 2, 3};
@ -142,10 +145,10 @@ TEST(type_prop, one_hot_v1_output_labels) {
}
TEST(type_prop, one_hot_v1_default_constructor) {
auto indices = make_shared<op::Parameter>(element::i64, Shape{1, 3, 2, 3});
auto depth = op::Constant::create(element::i64, Shape{}, {4});
auto on_value = op::Constant::create(element::f32, Shape{}, {1.0f});
auto off_value = op::Constant::create(element::f32, Shape{}, {0.0f});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{1, 3, 2, 3});
auto depth = ov::op::v0::Constant::create(element::i64, Shape{}, {4});
auto on_value = ov::op::v0::Constant::create(element::f32, Shape{}, {1.0f});
auto off_value = ov::op::v0::Constant::create(element::f32, Shape{}, {0.0f});
int64_t axis = 3;
auto ont_hot = make_shared<op::v1::OneHot>();
@ -164,16 +167,16 @@ TEST(type_prop, one_hot_v1_default_constructor) {
}
TEST(type_prop, one_hot_v1_indices_elem_not_integral) {
auto indices = make_shared<op::Parameter>(element::f16, Shape{2, 2});
auto depth = make_shared<op::Parameter>(element::i64, Shape{});
auto on_value = make_shared<op::Parameter>(element::u32, Shape{});
auto off_value = make_shared<op::Parameter>(element::u32, Shape{});
auto indices = make_shared<ov::op::v0::Parameter>(element::f16, Shape{2, 2});
auto depth = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto on_value = make_shared<ov::op::v0::Parameter>(element::u32, Shape{});
auto off_value = make_shared<ov::op::v0::Parameter>(element::u32, Shape{});
int64_t axis = -1;
try {
auto ont_hot = make_shared<op::v1::OneHot>(indices, depth, on_value, off_value, axis);
// Should have thrown, so fail if it didn't
FAIL() << "Incorrect indices element type not detected";
} catch (const ngraph_error& error) {
} catch (const ov::Exception& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("Indices must be integral element type."));
} catch (...) {
FAIL() << "Deduced type check failed for unexpected reason";
@ -181,16 +184,16 @@ TEST(type_prop, one_hot_v1_indices_elem_not_integral) {
}
TEST(type_prop, one_hot_v1_depth_elem_not_integral) {
auto indices = make_shared<op::Parameter>(element::i64, Shape{2, 2});
auto depth = make_shared<op::Parameter>(element::f16, Shape{});
auto on_value = make_shared<op::Parameter>(element::u32, Shape{});
auto off_value = make_shared<op::Parameter>(element::u32, Shape{});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{2, 2});
auto depth = make_shared<ov::op::v0::Parameter>(element::f16, Shape{});
auto on_value = make_shared<ov::op::v0::Parameter>(element::u32, Shape{});
auto off_value = make_shared<ov::op::v0::Parameter>(element::u32, Shape{});
int64_t axis = -1;
try {
auto ont_hot = make_shared<op::v1::OneHot>(indices, depth, on_value, off_value, axis);
// Should have thrown, so fail if it didn't
FAIL() << "Incorrect depth element type not detected";
} catch (const ngraph_error& error) {
} catch (const ov::Exception& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("Depth must be integral element type."));
} catch (...) {
FAIL() << "Deduced type check failed for unexpected reason";
@ -198,10 +201,10 @@ TEST(type_prop, one_hot_v1_depth_elem_not_integral) {
}
TEST(type_prop, one_hot_v1_negative_depth) {
auto indices = make_shared<op::Parameter>(element::i32, Shape{2, 2});
auto depth = op::Constant::create(element::i64, Shape{}, {-4});
auto on_value = op::Constant::create(element::f32, Shape{}, {1.0f});
auto off_value = op::Constant::create(element::f32, Shape{}, {0.0f});
auto indices = make_shared<ov::op::v0::Parameter>(element::i32, Shape{2, 2});
auto depth = ov::op::v0::Constant::create(element::i64, Shape{}, {-4});
auto on_value = ov::op::v0::Constant::create(element::f32, Shape{}, {1.0f});
auto off_value = ov::op::v0::Constant::create(element::f32, Shape{}, {0.0f});
int64_t axis = -1;
OV_EXPECT_THROW(auto ont_hot = make_shared<op::v1::OneHot>(indices, depth, on_value, off_value, axis),
@ -210,16 +213,16 @@ TEST(type_prop, one_hot_v1_negative_depth) {
}
TEST(type_prop, one_hot_v1_on_off_values_not_compatible) {
auto indices = make_shared<op::Parameter>(element::i64, Shape{2, 2});
auto depth = make_shared<op::Parameter>(element::i64, Shape{});
auto on_value = make_shared<op::Parameter>(element::bf16, Shape{});
auto off_value = make_shared<op::Parameter>(element::f16, Shape{});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{2, 2});
auto depth = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto on_value = make_shared<ov::op::v0::Parameter>(element::bf16, Shape{});
auto off_value = make_shared<ov::op::v0::Parameter>(element::f16, Shape{});
int64_t axis = -1;
try {
auto ont_hot = make_shared<op::v1::OneHot>(indices, depth, on_value, off_value, axis);
// Should have thrown, so fail if it didn't
FAIL() << "Incompatible on/off element types not detected";
} catch (const ngraph_error& error) {
} catch (const ov::Exception& error) {
EXPECT_HAS_SUBSTRING(error.what(),
std::string("on_value element type must be compatible with off_value element type."));
} catch (...) {
@ -228,16 +231,16 @@ TEST(type_prop, one_hot_v1_on_off_values_not_compatible) {
}
TEST(type_prop, one_hot_v1_depth_not_scalar) {
auto indices = make_shared<op::Parameter>(element::i64, Shape{2, 2});
auto depth = make_shared<op::Parameter>(element::i64, Shape{1});
auto on_value = make_shared<op::Parameter>(element::bf16, Shape{});
auto off_value = make_shared<op::Parameter>(element::bf16, Shape{});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{2, 2});
auto depth = make_shared<ov::op::v0::Parameter>(element::i64, Shape{1});
auto on_value = make_shared<ov::op::v0::Parameter>(element::bf16, Shape{});
auto off_value = make_shared<ov::op::v0::Parameter>(element::bf16, Shape{});
int64_t axis = -1;
try {
auto ont_hot = make_shared<op::v1::OneHot>(indices, depth, on_value, off_value, axis);
// Should have thrown, so fail if it didn't
FAIL() << "Not scalar depth input not detected.";
} catch (const ngraph_error& error) {
} catch (const ov::Exception& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("depth input must be scalar."));
} catch (...) {
FAIL() << "Deduced type check failed for unexpected reason";
@ -245,16 +248,16 @@ TEST(type_prop, one_hot_v1_depth_not_scalar) {
}
TEST(type_prop, one_hot_v1_on_value_not_scalar) {
auto indices = make_shared<op::Parameter>(element::i64, Shape{2, 2});
auto depth = make_shared<op::Parameter>(element::i64, Shape{});
auto on_value = make_shared<op::Parameter>(element::bf16, Shape{2});
auto off_value = make_shared<op::Parameter>(element::bf16, Shape{});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{2, 2});
auto depth = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto on_value = make_shared<ov::op::v0::Parameter>(element::bf16, Shape{2});
auto off_value = make_shared<ov::op::v0::Parameter>(element::bf16, Shape{});
int64_t axis = -1;
try {
auto ont_hot = make_shared<op::v1::OneHot>(indices, depth, on_value, off_value, axis);
// Should have thrown, so fail if it didn't
FAIL() << "Not scalar on_value input not detected.";
} catch (const ngraph_error& error) {
} catch (const ov::Exception& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("on_value input must be scalar."));
} catch (...) {
FAIL() << "Deduced type check failed for unexpected reason";
@ -262,16 +265,16 @@ TEST(type_prop, one_hot_v1_on_value_not_scalar) {
}
TEST(type_prop, one_hot_v1_off_value_not_scalar) {
auto indices = make_shared<op::Parameter>(element::i64, Shape{2, 2});
auto depth = make_shared<op::Parameter>(element::i64, Shape{});
auto on_value = make_shared<op::Parameter>(element::bf16, Shape{});
auto off_value = make_shared<op::Parameter>(element::bf16, Shape{3});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{2, 2});
auto depth = make_shared<ov::op::v0::Parameter>(element::i64, Shape{});
auto on_value = make_shared<ov::op::v0::Parameter>(element::bf16, Shape{});
auto off_value = make_shared<ov::op::v0::Parameter>(element::bf16, Shape{3});
int64_t axis = -1;
try {
auto ont_hot = make_shared<op::v1::OneHot>(indices, depth, on_value, off_value, axis);
// Should have thrown, so fail if it didn't
FAIL() << "Not scalar off_value input not detected.";
} catch (const ngraph_error& error) {
} catch (const ov::Exception& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("off_value input must be scalar."));
} catch (...) {
FAIL() << "Deduced type check failed for unexpected reason";
@ -279,31 +282,31 @@ TEST(type_prop, one_hot_v1_off_value_not_scalar) {
}
TEST(type_prop, one_hot_v1_out_types_1) {
auto indices = make_shared<op::Parameter>(element::i32, Shape{3, 2});
auto depth = op::Constant::create(element::i32, Shape{}, {2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i32, Shape{3, 2});
auto depth = ov::op::v0::Constant::create(element::i32, Shape{}, {2});
int64_t axis = -1;
auto on_value = op::Constant::create(element::f32, Shape{}, {-3.3});
auto off_value = op::Constant::create(element::f32, Shape{}, {-10.12});
auto on_value = ov::op::v0::Constant::create(element::f32, Shape{}, {-3.3});
auto off_value = ov::op::v0::Constant::create(element::f32, Shape{}, {-10.12});
auto ont_hot = make_shared<op::v1::OneHot>(indices, depth, on_value, off_value, axis);
ASSERT_EQ(ont_hot->get_element_type(), element::f32);
}
TEST(type_prop, one_hot_v1_out_types_2) {
auto indices = make_shared<op::Parameter>(element::i64, Shape{3, 2});
auto depth = op::Constant::create(element::i32, Shape{}, {2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i64, Shape{3, 2});
auto depth = ov::op::v0::Constant::create(element::i32, Shape{}, {2});
int64_t axis = -1;
auto on_value = op::Constant::create(element::i32, Shape{}, {-1});
auto off_value = op::Constant::create(element::i32, Shape{}, {7});
auto on_value = ov::op::v0::Constant::create(element::i32, Shape{}, {-1});
auto off_value = ov::op::v0::Constant::create(element::i32, Shape{}, {7});
auto ont_hot = make_shared<op::v1::OneHot>(indices, depth, on_value, off_value, axis);
ASSERT_EQ(ont_hot->get_element_type(), element::i32);
}
TEST(type_prop, one_hot_v1_out_types_3) {
auto indices = make_shared<op::Parameter>(element::i32, Shape{3, 2});
auto depth = op::Constant::create(element::i32, Shape{}, {2});
auto indices = make_shared<ov::op::v0::Parameter>(element::i32, Shape{3, 2});
auto depth = ov::op::v0::Constant::create(element::i32, Shape{}, {2});
int64_t axis = -1;
auto on_value = op::Constant::create(element::boolean, Shape{}, {true});
auto off_value = op::Constant::create(element::boolean, Shape{}, {false});
auto on_value = ov::op::v0::Constant::create(element::boolean, Shape{}, {true});
auto off_value = ov::op::v0::Constant::create(element::boolean, Shape{}, {false});
auto ont_hot = make_shared<op::v1::OneHot>(indices, depth, on_value, off_value, axis);
ASSERT_EQ(ont_hot->get_element_type(), element::boolean);
}

153
src/core/tests/type_prop/pad.cpp
View File

@ -2,15 +2,16 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/pad.hpp"
#include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
NGRAPH_SUPPRESS_DEPRECATED_START
#include "openvino/op/broadcast.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/shape_of.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace testing;
template <class T>
@ -20,9 +21,9 @@ TYPED_TEST_SUITE_P(PadTest);
TYPED_TEST_P(PadTest, pad_default_ctor) {
const auto arg_shape = PartialShape{{1, 2}, {4, 10}, {3, 8}, {1, 2}};
const auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
const auto pads_begin = make_shared<op::Constant>(element::i64, Shape{4}, std::vector<int64_t>{0, 2, 1, 0});
const auto pads_end = make_shared<op::Constant>(element::i64, Shape{4}, std::vector<int64_t>{0, 1, 1, 0});
const auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
const auto pads_begin = make_shared<ov::op::v0::Constant>(element::i64, Shape{4}, std::vector<int64_t>{0, 2, 1, 0});
const auto pads_end = make_shared<ov::op::v0::Constant>(element::i64, Shape{4}, std::vector<int64_t>{0, 1, 1, 0});
const auto pad = make_shared<TypeParam>();
pad->set_arguments(OutputVector{arg, pads_begin, pads_end});
@ -34,10 +35,10 @@ TYPED_TEST_P(PadTest, pad_default_ctor) {
}
TYPED_TEST_P(PadTest, pad_arg_pad_value_type_mismatch) {
auto arg = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
auto pads_begin = make_shared<op::Parameter>(element::i64, Shape{1});
auto pads_end = make_shared<op::Parameter>(element::i64, Shape{1});
auto arg_pad_value = make_shared<op::Parameter>(element::f16, Shape{1});
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3});
auto pads_begin = make_shared<ov::op::v0::Parameter>(element::i64, Shape{1});
auto pads_end = make_shared<ov::op::v0::Parameter>(element::i64, Shape{1});
auto arg_pad_value = make_shared<ov::op::v0::Parameter>(element::f16, Shape{1});
try {
auto pad_v1 = make_shared<TypeParam>(arg, pads_begin, pads_end, arg_pad_value, op::PadMode::CONSTANT);
@ -52,10 +53,10 @@ TYPED_TEST_P(PadTest, pad_arg_pad_value_type_mismatch) {
}
TYPED_TEST_P(PadTest, pad_arg_pad_value_shape_not_compatible) {
auto arg = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
auto pads_begin = make_shared<op::Parameter>(element::i64, Shape{1});
auto pads_end = make_shared<op::Parameter>(element::i64, Shape{1});
auto arg_pad_value = make_shared<op::Parameter>(element::f32, Shape{1});
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3});
auto pads_begin = make_shared<ov::op::v0::Parameter>(element::i64, Shape{1});
auto pads_end = make_shared<ov::op::v0::Parameter>(element::i64, Shape{1});
auto arg_pad_value = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
try {
auto pad_v1 = make_shared<TypeParam>(arg, pads_begin, pads_end, arg_pad_value, op::PadMode::CONSTANT);
@ -70,9 +71,9 @@ TYPED_TEST_P(PadTest, pad_arg_pad_value_shape_not_compatible) {
}
TYPED_TEST_P(PadTest, pad_pads_begin_shape_not_1D) {
auto arg = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
auto pads_begin = make_shared<op::Parameter>(element::i64, Shape{1, 2});
auto pads_end = make_shared<op::Parameter>(element::i64, Shape{1});
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3});
auto pads_begin = make_shared<ov::op::v0::Parameter>(element::i64, Shape{1, 2});
auto pads_end = make_shared<ov::op::v0::Parameter>(element::i64, Shape{1});
try {
auto pad_v1 = make_shared<TypeParam>(arg, pads_begin, pads_end, op::PadMode::SYMMETRIC);
@ -87,9 +88,9 @@ TYPED_TEST_P(PadTest, pad_pads_begin_shape_not_1D) {
}
TYPED_TEST_P(PadTest, pad_pads_end_shape_not_1D) {
auto arg = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
auto pads_begin = make_shared<op::Parameter>(element::i64, Shape{1});
auto pads_end = make_shared<op::Parameter>(element::i64, Shape{1, 2});
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3});
auto pads_begin = make_shared<ov::op::v0::Parameter>(element::i64, Shape{1});
auto pads_end = make_shared<ov::op::v0::Parameter>(element::i64, Shape{1, 2});
try {
auto pad_v1 = make_shared<TypeParam>(arg, pads_begin, pads_end, op::PadMode::SYMMETRIC);
@ -104,9 +105,9 @@ TYPED_TEST_P(PadTest, pad_pads_end_shape_not_1D) {
}
TYPED_TEST_P(PadTest, pad_pads_begin_size_not_correct) {
auto arg = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
auto pads_begin = make_shared<op::Parameter>(element::i64, Shape{4});
auto pads_end = make_shared<op::Parameter>(element::i64, Shape{1});
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3});
auto pads_begin = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto pads_end = make_shared<ov::op::v0::Parameter>(element::i64, Shape{1});
try {
auto pad_v1 = make_shared<TypeParam>(arg, pads_begin, pads_end, op::PadMode::SYMMETRIC);
@ -123,10 +124,10 @@ TYPED_TEST_P(PadTest, pad_pads_begin_size_not_correct) {
}
TYPED_TEST_P(PadTest, pad_pads_end_size_not_correct) {
auto arg = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
auto pads_begin = make_shared<op::Parameter>(element::i64, Shape{1});
auto pads_end = make_shared<op::Parameter>(element::i64, Shape{4});
auto arg_pad_value = make_shared<op::Parameter>(element::f32, Shape{});
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3});
auto pads_begin = make_shared<ov::op::v0::Parameter>(element::i64, Shape{1});
auto pads_end = make_shared<ov::op::v0::Parameter>(element::i64, Shape{4});
auto arg_pad_value = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
try {
auto pad_v1 = make_shared<TypeParam>(arg, pads_begin, pads_end, arg_pad_value, op::PadMode::CONSTANT);
@ -143,9 +144,9 @@ TYPED_TEST_P(PadTest, pad_pads_end_size_not_correct) {
}
TYPED_TEST_P(PadTest, pad_arg_pads_begin_incompatible_type) {
auto arg = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
auto pads_begin = make_shared<op::Parameter>(element::f32, Shape{1});
auto pads_end = make_shared<op::Parameter>(element::i64, Shape{1});
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3});
auto pads_begin = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
auto pads_end = make_shared<ov::op::v0::Parameter>(element::i64, Shape{1});
try {
auto pad_v1 = make_shared<TypeParam>(arg, pads_begin, pads_end, op::PadMode::REFLECT);
@ -160,9 +161,9 @@ TYPED_TEST_P(PadTest, pad_arg_pads_begin_incompatible_type) {
}
TYPED_TEST_P(PadTest, pad_arg_pads_end_incompatible_type) {
auto arg = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
auto pads_begin = make_shared<op::Parameter>(element::i64, Shape{1});
auto pads_end = make_shared<op::Parameter>(element::f32, Shape{1});
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3});
auto pads_begin = make_shared<ov::op::v0::Parameter>(element::i64, Shape{1});
auto pads_end = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
try {
auto pad = make_shared<TypeParam>(arg, pads_begin, pads_end, op::PadMode::REFLECT);
@ -177,10 +178,10 @@ TYPED_TEST_P(PadTest, pad_arg_pads_end_incompatible_type) {
}
TYPED_TEST_P(PadTest, pad_deduce_too_small_for_edge) {
auto arg = make_shared<op::Parameter>(element::f32, Shape{1, 5, 0, 2});
auto pads_begin = make_shared<op::Constant>(element::i64, Shape{4}, std::vector<int64_t>{0, 1, 2, 3});
auto pads_end = make_shared<op::Constant>(element::i64, Shape{4}, std::vector<int64_t>{0, 1, 2, 3});
auto arg_pad_value = make_shared<op::Parameter>(element::f32, Shape{});
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 5, 0, 2});
auto pads_begin = make_shared<ov::op::v0::Constant>(element::i64, Shape{4}, std::vector<int64_t>{0, 1, 2, 3});
auto pads_end = make_shared<ov::op::v0::Constant>(element::i64, Shape{4}, std::vector<int64_t>{0, 1, 2, 3});
auto arg_pad_value = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
try {
auto pad_v1 = make_shared<TypeParam>(arg, pads_begin, pads_end, arg_pad_value, op::PadMode::EDGE);
@ -197,10 +198,10 @@ TYPED_TEST_P(PadTest, pad_deduce_too_small_for_edge) {
}
TYPED_TEST_P(PadTest, pad_deduce_too_small_for_reflect) {
auto arg = make_shared<op::Parameter>(element::f32, Shape{1, 5, 1, 2});
auto pads_begin = make_shared<op::Constant>(element::i64, Shape{4}, std::vector<int64_t>{0, 1, 2, 3});
auto pads_end = make_shared<op::Constant>(element::i64, Shape{4}, std::vector<int64_t>{0, 1, 2, 3});
auto arg_pad_value = make_shared<op::Parameter>(element::f32, Shape{});
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 5, 1, 2});
auto pads_begin = make_shared<ov::op::v0::Constant>(element::i64, Shape{4}, std::vector<int64_t>{0, 1, 2, 3});
auto pads_end = make_shared<ov::op::v0::Constant>(element::i64, Shape{4}, std::vector<int64_t>{0, 1, 2, 3});
auto arg_pad_value = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
try {
auto pad_v1 = make_shared<TypeParam>(arg, pads_begin, pads_end, arg_pad_value, op::PadMode::REFLECT);
@ -219,9 +220,9 @@ TYPED_TEST_P(PadTest, pad_deduce_too_small_for_reflect) {
TYPED_TEST_P(PadTest, pad_pads_end_got_negative_value) {
auto arg_shape = PartialShape{-1, {0, 10}, {2, -1}, {2, 8}, {3, 10}, 5};
set_shape_labels(arg_shape, 10);
const auto arg = std::make_shared<op::Parameter>(element::f32, arg_shape);
const auto pads_begin = op::Constant::create(element::i64, Shape{6}, {2, 0, 1, 3, 2, 1});
const auto pads_end = op::Constant::create(element::i64, Shape{6}, {-3, -2, -2, -3, -1, -3});
const auto arg = std::make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
const auto pads_begin = ov::op::v0::Constant::create(element::i64, Shape{6}, {2, 0, 1, 3, 2, 1});
const auto pads_end = ov::op::v0::Constant::create(element::i64, Shape{6}, {-3, -2, -2, -3, -1, -3});
const auto pad = make_shared<TypeParam>(arg, pads_begin, pads_end, op::PadMode::REFLECT);
@ -233,9 +234,9 @@ TYPED_TEST_P(PadTest, pad_pads_end_got_negative_value) {
TYPED_TEST_P(PadTest, pad_pads_begin_got_negative_value) {
auto arg_shape = PartialShape{-1, {0, 10}, {2, -1}, {2, 8}, {3, 10}, 5};
set_shape_labels(arg_shape, 10);
const auto arg = std::make_shared<op::Parameter>(element::f32, arg_shape);
const auto pads_begin = op::Constant::create(element::i64, Shape{6}, {-1, -1, -2, -3, -8, -4});
const auto pads_end = op::Constant::create(element::i64, Shape{6}, {0, 2, 0, 3, 5, 4});
const auto arg = std::make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
const auto pads_begin = ov::op::v0::Constant::create(element::i64, Shape{6}, {-1, -1, -2, -3, -8, -4});
const auto pads_end = ov::op::v0::Constant::create(element::i64, Shape{6}, {0, 2, 0, 3, 5, 4});
const auto pad = make_shared<TypeParam>(arg, pads_begin, pads_end, op::PadMode::REFLECT);
EXPECT_EQ(pad->get_output_partial_shape(0), PartialShape({-1, {1, 11}, {0, -1}, {2, 8}, {0, 7}, 5}));
@ -244,20 +245,20 @@ TYPED_TEST_P(PadTest, pad_pads_begin_got_negative_value) {
}
TYPED_TEST_P(PadTest, pad_dynamic_output_with_dynamic_rank) {
auto arg = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto pads_begin = make_shared<op::Parameter>(element::i32, Shape{1});
auto pads_end = make_shared<op::Parameter>(element::i32, Shape{1});
auto arg_pad_value = op::Constant::create(element::f32, Shape{}, {0});
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto pads_begin = make_shared<ov::op::v0::Parameter>(element::i32, Shape{1});
auto pads_end = make_shared<ov::op::v0::Parameter>(element::i32, Shape{1});
auto arg_pad_value = ov::op::v0::Constant::create(element::f32, Shape{}, {0});
auto pad = make_shared<TypeParam>(arg, pads_begin, pads_end, arg_pad_value, op::PadMode::CONSTANT);
ASSERT_EQ(pad->get_output_partial_shape(0), PartialShape::dynamic());
}
TYPED_TEST_P(PadTest, pad_dynamic_output_with_static_rank) {
auto arg = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
auto pads_begin = make_shared<op::Parameter>(element::i32, Shape{1});
auto pads_end = make_shared<op::Parameter>(element::i32, Shape{1});
auto arg_pad_value = op::Constant::create(element::f32, Shape{}, {0});
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3});
auto pads_begin = make_shared<ov::op::v0::Parameter>(element::i32, Shape{1});
auto pads_end = make_shared<ov::op::v0::Parameter>(element::i32, Shape{1});
auto arg_pad_value = ov::op::v0::Constant::create(element::f32, Shape{}, {0});
auto pad = make_shared<TypeParam>(arg, pads_begin, pads_end, arg_pad_value, op::PadMode::CONSTANT);
ASSERT_EQ(pad->get_output_partial_shape(0), PartialShape::dynamic(3));
@ -266,9 +267,9 @@ TYPED_TEST_P(PadTest, pad_dynamic_output_with_static_rank) {
TYPED_TEST_P(PadTest, pad_any_dim_for_padding_reflect) {
auto arg_shape = PartialShape{1, {23, 48}, {23, 48}, 1};
set_shape_labels(arg_shape, 10);
auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
auto pads_begin = make_shared<op::Constant>(element::i64, Shape{4}, std::vector<int64_t>{0, 1, 1, 0});
auto pads_end = make_shared<op::Constant>(element::i64, Shape{4}, std::vector<int64_t>{0, 1, 1, 0});
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
auto pads_begin = make_shared<ov::op::v0::Constant>(element::i64, Shape{4}, std::vector<int64_t>{0, 1, 1, 0});
auto pads_end = make_shared<ov::op::v0::Constant>(element::i64, Shape{4}, std::vector<int64_t>{0, 1, 1, 0});
auto pad = make_shared<TypeParam>(arg, pads_begin, pads_end, op::PadMode::REFLECT);
EXPECT_EQ(pad->get_output_partial_shape(0), PartialShape({1, {25, 50}, {25, 50}, 1}));
@ -278,9 +279,11 @@ TYPED_TEST_P(PadTest, pad_any_dim_for_padding_reflect) {
TYPED_TEST_P(PadTest, pad_any_dim_for_padding_edge) {
auto arg_shape = PartialShape{1, {0, 48}, -1, {20, -1}, {5, -1}, 10, 12};
set_shape_labels(arg_shape, 10);
auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
auto pads_begin = make_shared<op::Constant>(element::i64, Shape{7}, std::vector<int64_t>{1, 2, 1, 2, 0, 0, 0});
auto pads_end = make_shared<op::Constant>(element::i64, Shape{7}, std::vector<int64_t>{0, 3, 0, 1, 0, 5, 0});
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
auto pads_begin =
make_shared<ov::op::v0::Constant>(element::i64, Shape{7}, std::vector<int64_t>{1, 2, 1, 2, 0, 0, 0});
auto pads_end =
make_shared<ov::op::v0::Constant>(element::i64, Shape{7}, std::vector<int64_t>{0, 3, 0, 1, 0, 5, 0});
auto pad = make_shared<TypeParam>(arg, pads_begin, pads_end, op::PadMode::EDGE);
EXPECT_EQ(pad->get_output_partial_shape(0), PartialShape({2, {5, 53}, {1, -1}, {23, -1}, {5, -1}, 15, 12}));
@ -289,10 +292,10 @@ TYPED_TEST_P(PadTest, pad_any_dim_for_padding_edge) {
}
TYPED_TEST_P(PadTest, pad_dynamic_input_type_with_static_value) {
auto arg = make_shared<op::Parameter>(element::dynamic, Shape{1, 2, 3});
auto pads_begin = make_shared<op::Parameter>(element::i32, Shape{1});
auto pads_end = make_shared<op::Parameter>(element::i32, Shape{1});
auto arg_pad_value = op::Constant::create(element::f32, Shape{}, {0});
auto arg = make_shared<ov::op::v0::Parameter>(element::dynamic, Shape{1, 2, 3});
auto pads_begin = make_shared<ov::op::v0::Parameter>(element::i32, Shape{1});
auto pads_end = make_shared<ov::op::v0::Parameter>(element::i32, Shape{1});
auto arg_pad_value = ov::op::v0::Constant::create(element::f32, Shape{}, {0});
auto pad = make_shared<TypeParam>(arg, pads_begin, pads_end, arg_pad_value, op::PadMode::CONSTANT);
EXPECT_EQ(pad->get_output_element_type(0), element::f32);
@ -307,9 +310,9 @@ TYPED_TEST_P(PadTest, pad_preserve_partial_values_and_labels_via_evaluates_bound
set_shape_labels(begin_shape, 20);
set_shape_labels(end_shape, 30);
auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
auto s_begin = make_shared<op::ShapeOf>(make_shared<op::Parameter>(element::i64, begin_shape));
auto s_end = make_shared<op::ShapeOf>(make_shared<op::Parameter>(element::i64, end_shape));
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
auto s_begin = make_shared<op::v0::ShapeOf>(make_shared<ov::op::v0::Parameter>(element::i64, begin_shape));
auto s_end = make_shared<op::v0::ShapeOf>(make_shared<ov::op::v0::Parameter>(element::i64, end_shape));
auto pad = make_shared<TypeParam>(arg, s_begin, s_end, op::PadMode::EDGE);
@ -320,14 +323,14 @@ TYPED_TEST_P(PadTest, pad_preserve_partial_values_and_labels_via_evaluates_bound
TYPED_TEST_P(PadTest, pad_preserve_partial_values_and_labels_on_inputs) {
auto arg_shape = PartialShape{1, {2, 5}, {1, 3}};
set_shape_labels(arg_shape, 10);
auto arg = make_shared<op::Parameter>(element::i32, arg_shape);
auto s = make_shared<op::ShapeOf>(arg);
auto arg = make_shared<ov::op::v0::Parameter>(element::i32, arg_shape);
auto s = make_shared<op::v0::ShapeOf>(arg);
auto pads_begin = make_shared<op::Constant>(element::i64, Shape{1}, std::vector<int64_t>{1});
auto pads_end = make_shared<op::Constant>(element::i64, Shape{1}, std::vector<int64_t>{2});
auto pads_begin = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, std::vector<int64_t>{1});
auto pads_end = make_shared<ov::op::v0::Constant>(element::i64, Shape{1}, std::vector<int64_t>{2});
auto pad = make_shared<TypeParam>(s, pads_begin, pads_end, op::PadMode::EDGE);
auto param = make_shared<op::Parameter>(element::f32, PartialShape{1});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1});
auto bc = std::make_shared<op::v3::Broadcast>(param, pad, op::BroadcastType::BIDIRECTIONAL);
EXPECT_EQ(bc->get_output_partial_shape(0), PartialShape({1, 1, {2, 5}, {1, 3}, {1, 3}, {1, 3}}));

14
src/core/tests/type_prop/parameter.cpp
View File

@ -3,14 +3,12 @@
//
#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, param_partial_rank_dynamic) {
auto a = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto a = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto& pshape = a->get_output_partial_shape(0);
@ -19,7 +17,7 @@ TEST(type_prop, param_partial_rank_dynamic) {
}
TEST(type_prop, param_partial_rank_static) {
auto a = make_shared<op::Parameter>(element::f32, PartialShape{2, Dimension::dynamic(), 3, 4});
auto a = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, Dimension::dynamic(), 3, 4});
auto& pshape = a->get_output_partial_shape(0);
@ -32,7 +30,7 @@ TEST(type_prop, param_partial_rank_static) {
}
TEST(type_prop, param_layout) {
auto a = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto a = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
a->set_layout("NHWC");
ASSERT_EQ(a->get_layout(), "NHWC");
a->set_layout(ov::Layout());
@ -41,12 +39,12 @@ TEST(type_prop, param_layout) {
}
TEST(type_prop, param_layout_empty) {
auto a = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto a = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
ASSERT_TRUE(a->get_layout().empty());
}
TEST(type_prop, param_layout_invalid) {
auto a = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto a = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
a->get_output_tensor(0).get_rt_info()[ov::LayoutAttribute::get_type_info_static()] = "NCHW"; // incorrect way
ASSERT_THROW(a->get_layout(), ov::Exception);
}

12
src/core/tests/type_prop/prelu.cpp
View File

@ -2,18 +2,18 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/prelu.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;
TEST(type_prop, prelu) {
auto param = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto slope = make_shared<op::Parameter>(element::f32, Shape{2});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
auto slope = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2});
Shape prelu_shape{2, 4};
auto prelu = make_shared<op::PRelu>(param, slope);
auto prelu = make_shared<op::v0::PRelu>(param, slope);
ASSERT_EQ(prelu->get_element_type(), element::f32);
ASSERT_EQ(prelu->get_shape(), prelu_shape);
}

1
src/core/tests/type_prop/prior_box.cpp
View File

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

1
src/core/tests/type_prop/prior_box_clustered.cpp
View File

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

366
src/core/tests/type_prop/proposal.cpp
View File

@ -2,24 +2,22 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "ngraph/op/proposal.hpp"
#include "openvino/op/proposal.hpp"
#include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gmock/gmock.h"
#include "ngraph/ngraph.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace testing;
// ------------------------------ V0 ------------------------------
TEST(type_prop, proposal_v0_invalid_class_probs_rank) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{3});
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
OV_EXPECT_THROW(std::ignore = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,
@ -27,10 +25,10 @@ TEST(type_prop, proposal_v0_invalid_class_probs_rank) {
}
TEST(type_prop, proposal_v0_invalid_anchor_count) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{3});
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
OV_EXPECT_THROW(std::ignore = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,
@ -38,10 +36,10 @@ TEST(type_prop, proposal_v0_invalid_anchor_count) {
}
TEST(type_prop, proposal_v0_invalid_class_bbox_deltas_rank) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{3});
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
OV_EXPECT_THROW(std::ignore = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,
@ -49,10 +47,10 @@ TEST(type_prop, proposal_v0_invalid_class_bbox_deltas_rank) {
}
TEST(type_prop, proposal_v0_invalid_image_shape_rank) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{2, 1});
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 1});
OV_EXPECT_THROW(std::ignore = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,
@ -60,10 +58,10 @@ TEST(type_prop, proposal_v0_invalid_image_shape_rank) {
}
TEST(type_prop, proposal_v0_invalid_image_shape_size) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{5});
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5});
OV_EXPECT_THROW(std::ignore = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,
@ -71,15 +69,15 @@ TEST(type_prop, proposal_v0_invalid_image_shape_size) {
}
TEST(type_prop, proposal_v0_default_ctor) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.base_size = 1;
attrs.pre_nms_topn = 20;
attrs.post_nms_topn = 200;
const size_t batch_size = 7;
auto class_probs = make_shared<op::Parameter>(element::f16, Shape{batch_size, 12, 34, 62});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f16, Shape{batch_size, 24, 34, 62});
auto image_shape = make_shared<op::Parameter>(element::f16, Shape{3});
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f16, Shape{batch_size, 12, 34, 62});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f16, Shape{batch_size, 24, 34, 62});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f16, Shape{3});
auto op = make_shared<op::v0::Proposal>();
op->set_arguments(OutputVector{class_probs, class_bbox_deltas, image_shape});
@ -93,15 +91,15 @@ TEST(type_prop, proposal_v0_default_ctor) {
}
TEST(type_prop, proposal_v0_shape_infer) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.base_size = 1;
attrs.pre_nms_topn = 20;
attrs.post_nms_topn = 200;
const size_t batch_size = 7;
auto class_probs = make_shared<op::Parameter>(element::bf16, Shape{batch_size, 12, 34, 62});
auto class_bbox_deltas = make_shared<op::Parameter>(element::bf16, Shape{batch_size, 24, 34, 62});
auto image_shape = make_shared<op::Parameter>(element::bf16, Shape{3});
auto class_probs = make_shared<ov::op::v0::Parameter>(element::bf16, Shape{batch_size, 12, 34, 62});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::bf16, Shape{batch_size, 24, 34, 62});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::bf16, Shape{3});
auto op = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
EXPECT_EQ(op->get_output_element_type(0), element::bf16);
@ -109,7 +107,7 @@ TEST(type_prop, proposal_v0_shape_infer) {
}
TEST(type_prop, proposal_v0_dynamic_class_probs_dim1_batch_size_infer) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.post_nms_topn = 1;
const auto batch_size = Dimension(2);
@ -118,9 +116,9 @@ TEST(type_prop, proposal_v0_dynamic_class_probs_dim1_batch_size_infer) {
set_shape_labels(class_props_shape, 10);
set_shape_labels(class_bbox_shape, 20);
auto class_probs = make_shared<op::Parameter>(element::f32, class_props_shape);
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, class_bbox_shape);
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{3});
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, class_props_shape);
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, class_bbox_shape);
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
auto op = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
@ -130,7 +128,7 @@ TEST(type_prop, proposal_v0_dynamic_class_probs_dim1_batch_size_infer) {
}
TEST(type_prop, proposal_v0_dynamic_bbox_deltas_dim1_batch_size_infer) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.post_nms_topn = 1;
const auto batch_size = Dimension(2);
@ -138,9 +136,9 @@ TEST(type_prop, proposal_v0_dynamic_bbox_deltas_dim1_batch_size_infer) {
auto class_bbox_shape = PartialShape{-1, 4, 3, 4};
set_shape_labels(class_props_shape, 10);
auto class_probs = make_shared<op::Parameter>(element::f64, class_props_shape);
auto class_bbox_deltas = make_shared<op::Parameter>(element::f64, class_bbox_shape);
auto image_shape = make_shared<op::Parameter>(element::f64, Shape{3});
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f64, class_props_shape);
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f64, class_bbox_shape);
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f64, Shape{3});
auto op = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
@ -150,11 +148,11 @@ TEST(type_prop, proposal_v0_dynamic_bbox_deltas_dim1_batch_size_infer) {
}
TEST(type_prop, proposal_v0_dynamic_class_probs_bbox_deltas_dim1_batch_size_infer) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.post_nms_topn = 1;
auto class_probs = make_shared<op::Parameter>(element::f32, PartialShape{-1, 2, 3, 4});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, PartialShape{-1, 4, 3, 4});
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{3});
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{-1, 2, 3, 4});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{-1, 4, 3, 4});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
auto op = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
@ -163,7 +161,7 @@ TEST(type_prop, proposal_v0_dynamic_class_probs_bbox_deltas_dim1_batch_size_infe
}
TEST(type_prop, proposal_v0_dynamic_range_class_probs_bbox_deltas_dim1_batch_size_infer) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.post_nms_topn = 2;
auto class_props_shape = PartialShape{{8, 14}, 2, 3, 4};
@ -171,9 +169,9 @@ TEST(type_prop, proposal_v0_dynamic_range_class_probs_bbox_deltas_dim1_batch_siz
set_shape_labels(class_props_shape, 10);
set_shape_labels(class_bbox_shape, 20);
auto class_probs = make_shared<op::Parameter>(element::f32, class_props_shape);
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, class_bbox_shape);
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{3});
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, class_props_shape);
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, class_bbox_shape);
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
auto op = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
EXPECT_EQ(op->get_output_partial_shape(0),
@ -182,7 +180,7 @@ TEST(type_prop, proposal_v0_dynamic_range_class_probs_bbox_deltas_dim1_batch_siz
}
TEST(type_prop, proposal_v0_dynamic_image_shape_shape_infer) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.base_size = 2;
attrs.pre_nms_topn = 20;
attrs.post_nms_topn = 200;
@ -193,9 +191,9 @@ TEST(type_prop, proposal_v0_dynamic_image_shape_shape_infer) {
set_shape_labels(class_props_shape, 10);
set_shape_labels(class_bbox_shape, 20);
auto class_probs = make_shared<op::Parameter>(element::f32, class_props_shape);
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, class_bbox_shape);
auto image_shape = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, class_props_shape);
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, class_bbox_shape);
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto op = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
@ -204,69 +202,69 @@ TEST(type_prop, proposal_v0_dynamic_image_shape_shape_infer) {
}
TEST(type_prop, proposal_v0_class_probs_dynamic_rank_but_batch_shape_defined_in_bbox) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.post_nms_topn = 2;
const auto batch_size = Dimension(7);
auto class_probs = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, PartialShape{batch_size, 24, 32, 32});
auto image_shape = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(1));
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{batch_size, 24, 32, 32});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(1));
auto op = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
EXPECT_EQ(op->get_output_partial_shape(0), (PartialShape{batch_size * attrs.post_nms_topn, 5}));
}
TEST(type_prop, proposal_v0_bbox_dynamic_rank_but_batch_defined_in_class_probs) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.post_nms_topn = 2;
const auto batch_size = Dimension(7);
auto class_probs = make_shared<op::Parameter>(element::f32, PartialShape{batch_size, 24, 32, 32});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto image_shape = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(1));
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{batch_size, 24, 32, 32});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(1));
auto op = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
EXPECT_EQ(op->get_output_partial_shape(0), (PartialShape{batch_size * attrs.post_nms_topn, 5}));
}
TEST(type_prop, proposal_v0_everything_dynamic_shape_infer) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.post_nms_topn = 1;
auto class_probs = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(4));
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(4));
auto image_shape = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(1));
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(4));
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(4));
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(1));
auto op = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
EXPECT_EQ(op->get_output_partial_shape(0), (PartialShape{-1, 5}));
}
TEST(type_prop, proposal_v0_everything_dynamic_class_probs_dynamic_rank_shape_infer) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.post_nms_topn = 1;
auto class_probs = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(4));
auto image_shape = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(1));
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(4));
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(1));
auto op = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
EXPECT_EQ(op->get_output_partial_shape(0), (PartialShape{-1, 5}));
}
TEST(type_prop, proposal_v0_everything_dynamic_class_probs_bbox_deltas_dynamic_rank_shape_infer) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.post_nms_topn = 1;
auto class_probs = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(Rank::dynamic()));
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(Rank::dynamic()));
auto image_shape = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(1));
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(Rank::dynamic()));
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(Rank::dynamic()));
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(1));
auto op = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
EXPECT_EQ(op->get_output_partial_shape(0), (PartialShape{-1, 5}));
}
TEST(type_prop, proposal_v0_invalid_class_probs_dynamic) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(3));
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{5});
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(3));
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5});
OV_EXPECT_THROW(std::ignore = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,
@ -274,10 +272,10 @@ TEST(type_prop, proposal_v0_invalid_class_probs_dynamic) {
}
TEST(type_prop, proposal_v0_invalid_bbox_deltas_dynamic) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(3));
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{5});
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(3));
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5});
OV_EXPECT_THROW(std::ignore = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,
@ -285,10 +283,10 @@ TEST(type_prop, proposal_v0_invalid_bbox_deltas_dynamic) {
}
TEST(type_prop, proposal_v0_invalid_image_shape_dynamic) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(0));
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(0));
OV_EXPECT_THROW(std::ignore = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,
@ -296,10 +294,10 @@ TEST(type_prop, proposal_v0_invalid_image_shape_dynamic) {
}
TEST(type_prop, proposal_v0_invalid_class_probs_type) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::i32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{3});
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::i32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
OV_EXPECT_THROW(std::ignore = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,
@ -307,10 +305,10 @@ TEST(type_prop, proposal_v0_invalid_class_probs_type) {
}
TEST(type_prop, proposal_v0_invalid_bbox_deltas_type) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<op::Parameter>(element::i32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{3});
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::i32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
OV_EXPECT_THROW(std::ignore = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,
@ -318,10 +316,10 @@ TEST(type_prop, proposal_v0_invalid_bbox_deltas_type) {
}
TEST(type_prop, proposal_v0_invalid_image_shape_type) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<op::Parameter>(element::i32, Shape{3});
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::i32, Shape{3});
OV_EXPECT_THROW(std::ignore = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,
@ -331,10 +329,10 @@ TEST(type_prop, proposal_v0_invalid_image_shape_type) {
// ------------------------------ V4 ------------------------------
TEST(type_prop, proposal_v4_invalid_class_probs_rank) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{3});
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
OV_EXPECT_THROW(std::ignore = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,
@ -342,10 +340,10 @@ TEST(type_prop, proposal_v4_invalid_class_probs_rank) {
}
TEST(type_prop, proposal_v4_invalid_class_bbox_deltas_rank) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{3});
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
OV_EXPECT_THROW(std::ignore = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,
@ -353,10 +351,10 @@ TEST(type_prop, proposal_v4_invalid_class_bbox_deltas_rank) {
}
TEST(type_prop, proposal_v4_invalid_image_shape_rank) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{2, 1});
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 1});
OV_EXPECT_THROW(std::ignore = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,
@ -364,10 +362,10 @@ TEST(type_prop, proposal_v4_invalid_image_shape_rank) {
}
TEST(type_prop, proposal_v4_invalid_image_shape_size) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{5});
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5});
OV_EXPECT_THROW(std::ignore = make_shared<op::v0::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,
@ -375,15 +373,15 @@ TEST(type_prop, proposal_v4_invalid_image_shape_size) {
}
TEST(type_prop, proposal_v4_default_ctor) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.base_size = 1;
attrs.pre_nms_topn = 20;
attrs.post_nms_topn = 200;
const size_t batch_size = 7;
auto class_probs = make_shared<op::Parameter>(element::f16, Shape{batch_size, 12, 34, 62});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f16, Shape{batch_size, 24, 34, 62});
auto image_shape = make_shared<op::Parameter>(element::f16, Shape{3});
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f16, Shape{batch_size, 12, 34, 62});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f16, Shape{batch_size, 24, 34, 62});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f16, Shape{3});
auto op = make_shared<op::v4::Proposal>();
op->set_arguments(OutputVector{class_probs, class_bbox_deltas, image_shape});
@ -399,15 +397,15 @@ TEST(type_prop, proposal_v4_default_ctor) {
}
TEST(type_prop, proposal_v4_shape_infer) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.base_size = 1;
attrs.pre_nms_topn = 20;
attrs.post_nms_topn = 200;
const size_t batch_size = 7;
auto class_probs = make_shared<op::Parameter>(element::f32, Shape{batch_size, 12, 34, 62});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, Shape{batch_size, 24, 34, 62});
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{3});
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, Shape{batch_size, 12, 34, 62});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, Shape{batch_size, 24, 34, 62});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
auto op = make_shared<op::v4::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
EXPECT_THAT(op->outputs(), Each(Property("Element type", &Output<Node>::get_element_type, element::f32)));
@ -416,7 +414,7 @@ TEST(type_prop, proposal_v4_shape_infer) {
}
TEST(type_prop, proposal_v4_dynamic_class_probs_dim1_batch_size_infer) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.post_nms_topn = 1;
const auto batch_size = Dimension(2);
@ -425,9 +423,9 @@ TEST(type_prop, proposal_v4_dynamic_class_probs_dim1_batch_size_infer) {
set_shape_labels(class_props_shape, 10);
set_shape_labels(class_bbox_shape, 20);
auto class_probs = make_shared<op::Parameter>(element::f64, class_props_shape);
auto class_bbox_deltas = make_shared<op::Parameter>(element::f64, class_bbox_shape);
auto image_shape = make_shared<op::Parameter>(element::f64, Shape{3});
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f64, class_props_shape);
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f64, class_bbox_shape);
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f64, Shape{3});
auto op = make_shared<op::v4::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
@ -440,7 +438,7 @@ TEST(type_prop, proposal_v4_dynamic_class_probs_dim1_batch_size_infer) {
}
TEST(type_prop, proposal_v4_dynamic_bbox_deltas_dim1_batch_size_infer) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.post_nms_topn = 1;
const auto batch_size = Dimension(2);
@ -448,9 +446,9 @@ TEST(type_prop, proposal_v4_dynamic_bbox_deltas_dim1_batch_size_infer) {
auto class_bbox_shape = PartialShape{-1, 4, {0, 3}, {1, 4}};
set_shape_labels(class_props_shape, 10);
auto class_probs = make_shared<op::Parameter>(element::bf16, class_props_shape);
auto class_bbox_deltas = make_shared<op::Parameter>(element::bf16, class_bbox_shape);
auto image_shape = make_shared<op::Parameter>(element::bf16, Shape{3});
auto class_probs = make_shared<ov::op::v0::Parameter>(element::bf16, class_props_shape);
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::bf16, class_bbox_shape);
auto image_shape = make_shared<ov::op::v0::Parameter>(element::bf16, Shape{3});
auto op = make_shared<op::v4::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
@ -463,16 +461,16 @@ TEST(type_prop, proposal_v4_dynamic_bbox_deltas_dim1_batch_size_infer) {
}
TEST(type_prop, proposal_v4_dynamic_class_probs_bbox_deltas_dim1_batch_size_infer) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.post_nms_topn = 1;
auto class_props_shape = PartialShape{-1, 2, 3, 4};
auto class_bbox_shape = PartialShape{-1, 4, 3, 4};
set_shape_labels(class_bbox_shape, 20);
auto class_probs = make_shared<op::Parameter>(element::f32, class_props_shape);
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, class_bbox_shape);
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{3});
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, class_props_shape);
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, class_bbox_shape);
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
auto op = make_shared<op::v4::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
@ -484,7 +482,7 @@ TEST(type_prop, proposal_v4_dynamic_class_probs_bbox_deltas_dim1_batch_size_infe
}
TEST(type_prop, proposal_v4_dynamic_image_shape_shape_infer) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.base_size = 1;
attrs.pre_nms_topn = 20;
attrs.post_nms_topn = 200;
@ -495,9 +493,9 @@ TEST(type_prop, proposal_v4_dynamic_image_shape_shape_infer) {
set_shape_labels(class_props_shape, 10);
set_shape_labels(class_bbox_shape, 20);
auto class_probs = make_shared<op::Parameter>(element::f32, class_props_shape);
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, class_bbox_shape);
auto image_shape = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, class_props_shape);
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, class_bbox_shape);
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto op = make_shared<op::v4::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
@ -509,11 +507,11 @@ TEST(type_prop, proposal_v4_dynamic_image_shape_shape_infer) {
}
TEST(type_prop, proposal_v4_everything_dynamic_shape_infer) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.post_nms_topn = 1;
auto class_probs = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(4));
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(4));
auto image_shape = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(1));
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(4));
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(4));
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(1));
auto op = make_shared<op::v4::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
@ -522,11 +520,11 @@ TEST(type_prop, proposal_v4_everything_dynamic_shape_infer) {
}
TEST(type_prop, proposal_v4_everything_dynamic_class_probs_dynamic_rank_shape_infer) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.post_nms_topn = 1;
auto class_probs = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(Rank::dynamic()));
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(4));
auto image_shape = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(1));
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(Rank::dynamic()));
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(4));
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(1));
auto op = make_shared<op::v4::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
@ -535,11 +533,11 @@ TEST(type_prop, proposal_v4_everything_dynamic_class_probs_dynamic_rank_shape_in
}
TEST(type_prop, proposal_v4_everything_dynamic_class_probs_bbox_deltas_dynamic_rank_shape_infer) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.post_nms_topn = 1;
auto class_probs = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(Rank::dynamic()));
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(Rank::dynamic()));
auto image_shape = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(1));
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(Rank::dynamic()));
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(Rank::dynamic()));
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(1));
auto op = make_shared<op::v4::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
@ -548,7 +546,7 @@ TEST(type_prop, proposal_v4_everything_dynamic_class_probs_bbox_deltas_dynamic_r
}
TEST(type_prop, proposal_v4_dynamic_range_class_probs_bbox_deltas_dim1_batch_size_infer) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.post_nms_topn = 2;
auto class_props_shape = PartialShape{{8, 14}, 2, 3, 4};
@ -556,9 +554,9 @@ TEST(type_prop, proposal_v4_dynamic_range_class_probs_bbox_deltas_dim1_batch_siz
set_shape_labels(class_props_shape, 10);
set_shape_labels(class_bbox_shape, 20);
auto class_probs = make_shared<op::Parameter>(element::f32, class_props_shape);
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, class_bbox_shape);
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{3});
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, class_props_shape);
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, class_bbox_shape);
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
auto op = make_shared<op::v4::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
@ -572,13 +570,13 @@ TEST(type_prop, proposal_v4_dynamic_range_class_probs_bbox_deltas_dim1_batch_siz
}
TEST(type_prop, proposal_v4_class_dynamic_rank_but_batch_shape_defined_in_bbox) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.post_nms_topn = 1;
const auto batch_size = Dimension(7);
auto class_probs = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, PartialShape{batch_size, 24, 32, 32});
auto image_shape = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(1));
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{batch_size, 24, 32, 32});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(1));
auto op = make_shared<op::v4::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
EXPECT_EQ(op->get_output_partial_shape(0), (PartialShape{batch_size * attrs.post_nms_topn, 5}));
@ -586,13 +584,13 @@ TEST(type_prop, proposal_v4_class_dynamic_rank_but_batch_shape_defined_in_bbox)
}
TEST(type_prop, proposal_v4_bbox_dynamic_rank_but_batch_defined_in_class_probs) {
op::ProposalAttrs attrs;
op::v0::Proposal::Attributes attrs;
attrs.post_nms_topn = 1;
const auto batch_size = Dimension(10);
auto class_probs = make_shared<op::Parameter>(element::f32, PartialShape{batch_size, 24, 32, 32});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto image_shape = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(1));
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{batch_size, 24, 32, 32});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(1));
auto op = make_shared<op::v4::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs);
EXPECT_EQ(op->get_output_partial_shape(0), (PartialShape{batch_size * attrs.post_nms_topn, 5}));
@ -600,10 +598,10 @@ TEST(type_prop, proposal_v4_bbox_dynamic_rank_but_batch_defined_in_class_probs)
}
TEST(type_prop, proposal_v4_invalid_class_probs_dynamic) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(3));
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{5});
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(3));
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5});
OV_EXPECT_THROW(std::ignore = make_shared<op::v4::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,
@ -611,10 +609,10 @@ TEST(type_prop, proposal_v4_invalid_class_probs_dynamic) {
}
TEST(type_prop, proposal_v4_invalid_bbox_deltas_dynamic) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(3));
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{5});
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(3));
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5});
OV_EXPECT_THROW(std::ignore = make_shared<op::v4::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,
@ -622,10 +620,10 @@ TEST(type_prop, proposal_v4_invalid_bbox_deltas_dynamic) {
}
TEST(type_prop, proposal_v4_invalid_image_shape_dynamic) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(0));
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(0));
OV_EXPECT_THROW(std::ignore = make_shared<op::v4::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,
@ -633,10 +631,10 @@ TEST(type_prop, proposal_v4_invalid_image_shape_dynamic) {
}
TEST(type_prop, proposal_v4_invalid_class_probs_type) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::i32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{3});
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::i32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
OV_EXPECT_THROW(std::ignore = make_shared<op::v4::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,
@ -644,10 +642,10 @@ TEST(type_prop, proposal_v4_invalid_class_probs_type) {
}
TEST(type_prop, proposal_v4_invalid_bbox_deltas_type) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<op::Parameter>(element::i32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<op::Parameter>(element::f32, Shape{3});
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::i32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3});
OV_EXPECT_THROW(std::ignore = make_shared<op::v4::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,
@ -655,10 +653,10 @@ TEST(type_prop, proposal_v4_invalid_bbox_deltas_type) {
}
TEST(type_prop, proposal_v4_invalid_image_shape_type) {
op::ProposalAttrs attrs;
auto class_probs = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<op::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<op::Parameter>(element::i32, Shape{3});
op::v0::Proposal::Attributes attrs;
auto class_probs = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto class_bbox_deltas = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4, 3, 4});
auto image_shape = make_shared<ov::op::v0::Parameter>(element::i32, Shape{3});
OV_EXPECT_THROW(std::ignore = make_shared<op::v4::Proposal>(class_probs, class_bbox_deltas, image_shape, attrs),
NodeValidationFailure,

1
src/core/tests/type_prop/psroi_pooling.cpp
View File

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

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

@ -2,8 +2,6 @@
// 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 "openvino/opsets/opset8.hpp"

339
src/core/tests/type_prop/range.cpp
View File

@ -2,12 +2,13 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/range.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/op/constant.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
struct RangeParams {
double start;
@ -19,56 +20,56 @@ struct RangeParams {
// ------------------------------ V0 ------------------------------
TEST(type_prop, range_nonconst_ok) {
auto start = make_shared<op::Parameter>(element::i32, Shape{});
auto stop = make_shared<op::Parameter>(element::i32, Shape{});
auto step = make_shared<op::Parameter>(element::i32, Shape{});
auto start = make_shared<ov::op::v0::Parameter>(element::i32, Shape{});
auto stop = make_shared<ov::op::v0::Parameter>(element::i32, Shape{});
auto step = make_shared<ov::op::v0::Parameter>(element::i32, Shape{});
auto range = make_shared<op::Range>(start, stop, step);
auto range = make_shared<op::v0::Range>(start, stop, step);
EXPECT_EQ(range->get_element_type(), element::i32);
EXPECT_TRUE(range->get_output_partial_shape(0).same_scheme(PartialShape::dynamic(1)));
}
TEST(type_prop, range_nonconst_some_dyn_et_ok) {
auto start = make_shared<op::Parameter>(element::i32, Shape{});
auto stop = make_shared<op::Parameter>(element::dynamic, Shape{});
auto step = make_shared<op::Parameter>(element::i32, Shape{});
auto start = make_shared<ov::op::v0::Parameter>(element::i32, Shape{});
auto stop = make_shared<ov::op::v0::Parameter>(element::dynamic, Shape{});
auto step = make_shared<ov::op::v0::Parameter>(element::i32, Shape{});
auto range = make_shared<op::Range>(start, stop, step);
auto range = make_shared<op::v0::Range>(start, stop, step);
EXPECT_EQ(range->get_element_type(), element::i32);
EXPECT_TRUE(range->get_output_partial_shape(0).same_scheme(PartialShape::dynamic(1)));
}
TEST(type_prop, range_nonconst_all_dyn_et_ok) {
auto start = make_shared<op::Parameter>(element::dynamic, Shape{});
auto stop = make_shared<op::Parameter>(element::dynamic, Shape{});
auto step = make_shared<op::Parameter>(element::dynamic, Shape{});
auto start = make_shared<ov::op::v0::Parameter>(element::dynamic, Shape{});
auto stop = make_shared<ov::op::v0::Parameter>(element::dynamic, Shape{});
auto step = make_shared<ov::op::v0::Parameter>(element::dynamic, Shape{});
auto range = make_shared<op::Range>(start, stop, step);
auto range = make_shared<op::v0::Range>(start, stop, step);
EXPECT_EQ(range->get_element_type(), element::dynamic);
EXPECT_TRUE(range->get_output_partial_shape(0).same_scheme(PartialShape::dynamic(1)));
}
TEST(type_prop, range_nonconst_f32_ok) {
auto start = make_shared<op::Parameter>(element::dynamic, Shape{});
auto stop = make_shared<op::Parameter>(element::f32, Shape{});
auto step = make_shared<op::Parameter>(element::dynamic, Shape{});
auto start = make_shared<ov::op::v0::Parameter>(element::dynamic, Shape{});
auto stop = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto step = make_shared<ov::op::v0::Parameter>(element::dynamic, Shape{});
auto range = make_shared<op::Range>(start, stop, step);
auto range = make_shared<op::v0::Range>(start, stop, step);
EXPECT_EQ(range->get_element_type(), element::f32);
EXPECT_TRUE(range->get_output_partial_shape(0).same_scheme(PartialShape::dynamic(1)));
}
TEST(type_prop, range_nonconst_boolean_fails) {
auto start = make_shared<op::Parameter>(element::dynamic, Shape{});
auto stop = make_shared<op::Parameter>(element::boolean, Shape{});
auto step = make_shared<op::Parameter>(element::dynamic, Shape{});
auto start = make_shared<ov::op::v0::Parameter>(element::dynamic, Shape{});
auto stop = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{});
auto step = make_shared<ov::op::v0::Parameter>(element::dynamic, Shape{});
try {
auto range = make_shared<op::Range>(start, stop, step);
auto range = make_shared<op::v0::Range>(start, stop, step);
FAIL() << "Boolean element type not detected";
} catch (const NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), "Element type for start, stop, and step, must not be boolean.");
@ -78,23 +79,23 @@ TEST(type_prop, range_nonconst_boolean_fails) {
}
TEST(type_prop, range_some_const_ok) {
auto start = make_shared<op::Constant>(element::i32, Shape{}, std::vector<int32_t>{3});
auto stop = make_shared<op::Parameter>(element::i32, Shape{});
auto step = make_shared<op::Constant>(element::i32, Shape{}, std::vector<int32_t>{2});
auto start = make_shared<ov::op::v0::Constant>(element::i32, Shape{}, std::vector<int32_t>{3});
auto stop = make_shared<ov::op::v0::Parameter>(element::i32, Shape{});
auto step = make_shared<ov::op::v0::Constant>(element::i32, Shape{}, std::vector<int32_t>{2});
auto range = make_shared<op::Range>(start, stop, step);
auto range = make_shared<op::v0::Range>(start, stop, step);
EXPECT_EQ(range->get_element_type(), element::i32);
EXPECT_TRUE(range->get_output_partial_shape(0).same_scheme(PartialShape::dynamic(1)));
}
TEST(type_prop, range_some_const_zero_stride_fails) {
auto start = make_shared<op::Constant>(element::i32, Shape{}, std::vector<int32_t>{3});
auto stop = make_shared<op::Parameter>(element::i32, Shape{});
auto step = make_shared<op::Constant>(element::i32, Shape{}, std::vector<int32_t>{0});
auto start = make_shared<ov::op::v0::Constant>(element::i32, Shape{}, std::vector<int32_t>{3});
auto stop = make_shared<ov::op::v0::Parameter>(element::i32, Shape{});
auto step = make_shared<ov::op::v0::Constant>(element::i32, Shape{}, std::vector<int32_t>{0});
try {
auto range = make_shared<op::Range>(start, stop, step);
auto range = make_shared<op::v0::Range>(start, stop, step);
FAIL() << "Zero stride not detected";
} catch (const NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), "'step' cannot be zero");
@ -104,13 +105,14 @@ TEST(type_prop, range_some_const_zero_stride_fails) {
}
TEST(type_prop, range_some_const_plus_inf_start_fails) {
auto start =
make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{std::numeric_limits<float>::infinity()});
auto stop = make_shared<op::Parameter>(element::f32, Shape{});
auto step = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto start = make_shared<ov::op::v0::Constant>(element::f32,
Shape{},
std::vector<float>{std::numeric_limits<float>::infinity()});
auto stop = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto step = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{1});
try {
auto range = make_shared<op::Range>(start, stop, step);
auto range = make_shared<op::v0::Range>(start, stop, step);
FAIL() << "+Infinity start not detected";
} catch (const NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), "'start' cannot be nan or infinite.");
@ -122,13 +124,14 @@ TEST(type_prop, range_some_const_plus_inf_start_fails) {
}
TEST(type_prop, range_some_const_minus_inf_start_fails) {
auto start =
make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{-std::numeric_limits<float>::infinity()});
auto stop = make_shared<op::Parameter>(element::f32, Shape{});
auto step = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto start = make_shared<ov::op::v0::Constant>(element::f32,
Shape{},
std::vector<float>{-std::numeric_limits<float>::infinity()});
auto stop = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto step = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{1});
try {
auto range = make_shared<op::Range>(start, stop, step);
auto range = make_shared<op::v0::Range>(start, stop, step);
FAIL() << "-Infinity start not detected";
} catch (const NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), "'start' cannot be nan or infinite.");
@ -142,12 +145,12 @@ TEST(type_prop, range_some_const_minus_inf_start_fails) {
}
TEST(type_prop, range_some_const_nan_start_fails) {
auto start = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{std::nanf("")});
auto stop = make_shared<op::Parameter>(element::f32, Shape{});
auto step = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto start = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{std::nanf("")});
auto stop = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto step = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{1});
try {
auto range = make_shared<op::Range>(start, stop, step);
auto range = make_shared<op::v0::Range>(start, stop, step);
FAIL() << "NaN start not detected";
} catch (const NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), "'start' cannot be nan or infinite.");
@ -161,13 +164,14 @@ TEST(type_prop, range_some_const_nan_start_fails) {
}
TEST(type_prop, range_some_const_plus_inf_stop_fails) {
auto start = make_shared<op::Parameter>(element::f32, Shape{});
auto stop =
make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{std::numeric_limits<float>::infinity()});
auto step = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto start = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto stop = make_shared<ov::op::v0::Constant>(element::f32,
Shape{},
std::vector<float>{std::numeric_limits<float>::infinity()});
auto step = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{1});
try {
auto range = make_shared<op::Range>(start, stop, step);
auto range = make_shared<op::v0::Range>(start, stop, step);
FAIL() << "+Infinity stop not detected";
} catch (const NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), "'stop' cannot be nan or infinite.");
@ -179,13 +183,14 @@ TEST(type_prop, range_some_const_plus_inf_stop_fails) {
}
TEST(type_prop, range_some_const_minus_inf_stop_fails) {
auto start = make_shared<op::Parameter>(element::f32, Shape{});
auto stop =
make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{-std::numeric_limits<float>::infinity()});
auto step = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto start = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto stop = make_shared<ov::op::v0::Constant>(element::f32,
Shape{},
std::vector<float>{-std::numeric_limits<float>::infinity()});
auto step = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{1});
try {
auto range = make_shared<op::Range>(start, stop, step);
auto range = make_shared<op::v0::Range>(start, stop, step);
FAIL() << "-Infinity stop not detected";
} catch (const NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), "'stop' cannot be nan or infinite.");
@ -199,12 +204,12 @@ TEST(type_prop, range_some_const_minus_inf_stop_fails) {
}
TEST(type_prop, range_some_const_nan_stio_fails) {
auto start = make_shared<op::Parameter>(element::f32, Shape{});
auto stop = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{std::nanf("")});
auto step = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto start = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto stop = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{std::nanf("")});
auto step = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{1});
try {
auto range = make_shared<op::Range>(start, stop, step);
auto range = make_shared<op::v0::Range>(start, stop, step);
FAIL() << "NaN stop not detected";
} catch (const NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), "'stop' cannot be nan or infinite.");
@ -218,13 +223,14 @@ TEST(type_prop, range_some_const_nan_stio_fails) {
}
TEST(type_prop, range_some_const_plus_inf_stride_fails) {
auto start = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{3});
auto stop = make_shared<op::Parameter>(element::f32, Shape{});
auto step =
make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{std::numeric_limits<float>::infinity()});
auto start = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{3});
auto stop = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto step = make_shared<ov::op::v0::Constant>(element::f32,
Shape{},
std::vector<float>{std::numeric_limits<float>::infinity()});
try {
auto range = make_shared<op::Range>(start, stop, step);
auto range = make_shared<op::v0::Range>(start, stop, step);
FAIL() << "+Infinity stride not detected";
} catch (const NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), "'step' cannot be zero, nan, or infinite.");
@ -236,13 +242,14 @@ TEST(type_prop, range_some_const_plus_inf_stride_fails) {
}
TEST(type_prop, range_some_const_minus_inf_stride_fails) {
auto start = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{3});
auto stop = make_shared<op::Parameter>(element::f32, Shape{});
auto step =
make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{-std::numeric_limits<float>::infinity()});
auto start = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{3});
auto stop = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto step = make_shared<ov::op::v0::Constant>(element::f32,
Shape{},
std::vector<float>{-std::numeric_limits<float>::infinity()});
try {
auto range = make_shared<op::Range>(start, stop, step);
auto range = make_shared<op::v0::Range>(start, stop, step);
FAIL() << "-Infinity stride not detected";
} catch (const NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), "'step' cannot be zero, nan, or infinite.");
@ -256,12 +263,12 @@ TEST(type_prop, range_some_const_minus_inf_stride_fails) {
}
TEST(type_prop, range_some_const_nan_stride_fails) {
auto start = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{3});
auto stop = make_shared<op::Parameter>(element::f32, Shape{});
auto step = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{std::nanf("")});
auto start = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{3});
auto stop = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto step = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{std::nanf("")});
try {
auto range = make_shared<op::Range>(start, stop, step);
auto range = make_shared<op::v0::Range>(start, stop, step);
FAIL() << "NaN stride not detected";
} catch (const NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), "'step' cannot be zero, nan, or infinite.");
@ -275,12 +282,12 @@ TEST(type_prop, range_some_const_nan_stride_fails) {
}
TEST(type_prop, range_all_const_zero_stride_fails) {
auto start = make_shared<op::Constant>(element::i32, Shape{}, std::vector<int32_t>{3});
auto stop = make_shared<op::Constant>(element::i32, Shape{}, std::vector<int32_t>{5});
auto step = make_shared<op::Constant>(element::i32, Shape{}, std::vector<int32_t>{0});
auto start = make_shared<ov::op::v0::Constant>(element::i32, Shape{}, std::vector<int32_t>{3});
auto stop = make_shared<ov::op::v0::Constant>(element::i32, Shape{}, std::vector<int32_t>{5});
auto step = make_shared<ov::op::v0::Constant>(element::i32, Shape{}, std::vector<int32_t>{0});
try {
auto range = make_shared<op::Range>(start, stop, step);
auto range = make_shared<op::v0::Range>(start, stop, step);
FAIL() << "Zero stride not detected";
} catch (const NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), "'step' cannot be zero");
@ -291,11 +298,11 @@ TEST(type_prop, range_all_const_zero_stride_fails) {
template <typename T>
void run_range_test(const element::Type& et, const RangeParams& params) {
auto start = make_shared<op::Constant>(et, Shape{}, std::vector<T>{static_cast<T>(params.start)});
auto stop = make_shared<op::Constant>(et, Shape{}, std::vector<T>{static_cast<T>(params.stop)});
auto step = make_shared<op::Constant>(et, Shape{}, std::vector<T>{static_cast<T>(params.step)});
auto start = make_shared<ov::op::v0::Constant>(et, Shape{}, std::vector<T>{static_cast<T>(params.start)});
auto stop = make_shared<ov::op::v0::Constant>(et, Shape{}, std::vector<T>{static_cast<T>(params.stop)});
auto step = make_shared<ov::op::v0::Constant>(et, Shape{}, std::vector<T>{static_cast<T>(params.step)});
auto range = make_shared<op::Range>(start, stop, step);
auto range = make_shared<op::v0::Range>(start, stop, step);
EXPECT_EQ(range->get_element_type(), et);
EXPECT_TRUE(range->get_output_partial_shape(0).same_scheme(params.expected_shape))
@ -438,9 +445,9 @@ TEST(type_prop, range_v4_all_const_shape_inference) {
int start_val = 0;
int stop_val = num_elems * step_val + start_val;
element::Type_t et = element::i32;
auto start = make_shared<op::Constant>(et, Shape{}, std::vector<int>{start_val});
auto stop = make_shared<op::Constant>(et, Shape{}, std::vector<int>{stop_val});
auto step = make_shared<op::Constant>(et, Shape{}, std::vector<int>{step_val});
auto start = make_shared<ov::op::v0::Constant>(et, Shape{}, std::vector<int>{start_val});
auto stop = make_shared<ov::op::v0::Constant>(et, Shape{}, std::vector<int>{stop_val});
auto step = make_shared<ov::op::v0::Constant>(et, Shape{}, std::vector<int>{step_val});
auto range = make_shared<op::v4::Range>(start, stop, step, et);
auto pshape_out = range->get_output_partial_shape(0);
ASSERT_TRUE(pshape_out.rank().is_static() && pshape_out.rank() == Dimension{1});
@ -451,9 +458,9 @@ TEST(type_prop, range_v4_some_const_shape_inference) {
int step_val = 5;
int start_val = 0;
element::Type_t et = element::i32;
auto start = make_shared<op::Constant>(et, Shape{}, std::vector<int>{start_val});
auto stop = make_shared<op::Parameter>(et, Shape{});
auto step = make_shared<op::Constant>(et, Shape{}, std::vector<int>{step_val});
auto start = make_shared<ov::op::v0::Constant>(et, Shape{}, std::vector<int>{start_val});
auto stop = make_shared<ov::op::v0::Parameter>(et, Shape{});
auto step = make_shared<ov::op::v0::Constant>(et, Shape{}, std::vector<int>{step_val});
auto range = make_shared<op::v4::Range>(start, stop, step, et);
auto pshape_out = range->get_output_partial_shape(0);
ASSERT_TRUE(pshape_out.rank().is_static() && pshape_out.rank() == Dimension{1});
@ -462,9 +469,9 @@ TEST(type_prop, range_v4_some_const_shape_inference) {
TEST(type_prop, range_v4_trunc_inputs_shape_inference) {
element::Type_t et = element::f32;
auto start = make_shared<op::Constant>(et, Shape{}, std::vector<float>{0.9f});
auto stop = make_shared<op::Constant>(et, Shape{}, std::vector<float>{10.3f});
auto step = make_shared<op::Constant>(et, Shape{}, std::vector<float>{1.7f});
auto start = make_shared<ov::op::v0::Constant>(et, Shape{}, std::vector<float>{0.9f});
auto stop = make_shared<ov::op::v0::Constant>(et, Shape{}, std::vector<float>{10.3f});
auto step = make_shared<ov::op::v0::Constant>(et, Shape{}, std::vector<float>{1.7f});
auto range = make_shared<op::v4::Range>(start, stop, step, element::i32);
auto pshape_out = range->get_output_partial_shape(0);
ASSERT_TRUE(pshape_out.rank().is_static() && pshape_out.rank() == Dimension{1});
@ -474,12 +481,12 @@ TEST(type_prop, range_v4_trunc_inputs_shape_inference) {
TEST(type_prop, range_v4_invalid_inputs_elem_type) {
// invalid element type for start scalar
try {
auto start = make_shared<op::Parameter>(element::boolean, Shape{});
auto stop = make_shared<op::Parameter>(element::i32, Shape{});
auto step = make_shared<op::Parameter>(element::i32, Shape{});
auto start = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{});
auto stop = make_shared<ov::op::v0::Parameter>(element::i32, Shape{});
auto step = make_shared<ov::op::v0::Parameter>(element::i32, Shape{});
auto range = make_shared<op::v4::Range>(start, stop, step, element::i32);
FAIL() << "Exception expected";
} catch (ngraph::NodeValidationFailure& error) {
} catch (ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("'start' input scalar should be a numeric type"));
} catch (...) {
FAIL() << "Unknown exception was thrown";
@ -487,12 +494,12 @@ TEST(type_prop, range_v4_invalid_inputs_elem_type) {
// invalid element type for stop scalar
try {
auto start = make_shared<op::Parameter>(element::dynamic, Shape{});
auto stop = make_shared<op::Parameter>(element::boolean, Shape{});
auto step = make_shared<op::Parameter>(element::i32, Shape{});
auto start = make_shared<ov::op::v0::Parameter>(element::dynamic, Shape{});
auto stop = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{});
auto step = make_shared<ov::op::v0::Parameter>(element::i32, Shape{});
auto range = make_shared<op::v4::Range>(start, stop, step, element::i32);
FAIL() << "Exception expected";
} catch (ngraph::NodeValidationFailure& error) {
} catch (ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("'stop' input scalar should be a numeric type"));
} catch (...) {
FAIL() << "Unknown exception was thrown";
@ -500,12 +507,12 @@ TEST(type_prop, range_v4_invalid_inputs_elem_type) {
// invalid element type for step scalar
try {
auto start = make_shared<op::Parameter>(element::i32, Shape{});
auto stop = make_shared<op::Parameter>(element::undefined, Shape{});
auto step = make_shared<op::Parameter>(element::boolean, Shape{});
auto start = make_shared<ov::op::v0::Parameter>(element::i32, Shape{});
auto stop = make_shared<ov::op::v0::Parameter>(element::undefined, Shape{});
auto step = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{});
auto range = make_shared<op::v4::Range>(start, stop, step, element::i32);
FAIL() << "Exception expected";
} catch (const ngraph::NodeValidationFailure& error) {
} catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("'step' input scalar should be a numeric type"));
} catch (...) {
FAIL() << "Unknown exception was thrown";
@ -514,11 +521,11 @@ TEST(type_prop, range_v4_invalid_inputs_elem_type) {
TEST(type_prop, range_v4_invalid_output_elem_type) {
try {
auto start = make_shared<op::Parameter>(element::f16, Shape{1});
auto stop = make_shared<op::Parameter>(element::f16, Shape{});
auto step = make_shared<op::Parameter>(element::f16, Shape{});
auto start = make_shared<ov::op::v0::Parameter>(element::f16, Shape{1});
auto stop = make_shared<ov::op::v0::Parameter>(element::f16, Shape{});
auto step = make_shared<ov::op::v0::Parameter>(element::f16, Shape{});
auto range = make_shared<op::v4::Range>(start, stop, step, element::boolean);
} catch (const ngraph::NodeValidationFailure& error) {
} catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("output tensor type should be a numeric type"));
} catch (...) {
FAIL() << "Unknown exception was thrown";
@ -528,12 +535,12 @@ TEST(type_prop, range_v4_invalid_output_elem_type) {
TEST(type_prop, range_v4_invalid_inputs_non_scalar) {
// start input not a scalar
try {
auto start = make_shared<op::Parameter>(element::f32, Shape{1});
auto stop = make_shared<op::Parameter>(element::f32, Shape{});
auto step = make_shared<op::Parameter>(element::f32, Shape{});
auto start = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
auto stop = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto step = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto range = make_shared<op::v4::Range>(start, stop, step, element::f32);
FAIL() << "Exception expected";
} catch (const ngraph::NodeValidationFailure& error) {
} catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("'start' input is not a scalar"));
} catch (...) {
FAIL() << "Unknown exception was thrown";
@ -541,12 +548,12 @@ TEST(type_prop, range_v4_invalid_inputs_non_scalar) {
// stop input not a scalar
try {
auto start = make_shared<op::Parameter>(element::f32, Shape{});
auto stop = make_shared<op::Parameter>(element::f32, PartialShape{Dimension::dynamic()});
auto step = make_shared<op::Parameter>(element::f32, Shape{});
auto start = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto stop = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension::dynamic()});
auto step = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto range = make_shared<op::v4::Range>(start, stop, step, element::f32);
FAIL() << "Exception expected";
} catch (const ngraph::NodeValidationFailure& error) {
} catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("'stop' input is not a scalar"));
} catch (...) {
FAIL() << "Unknown exception was thrown";
@ -554,12 +561,12 @@ TEST(type_prop, range_v4_invalid_inputs_non_scalar) {
// step input not a scalar
try {
auto start = make_shared<op::Parameter>(element::f32, Shape{});
auto stop = make_shared<op::Parameter>(element::f32, Shape{});
auto step = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(2));
auto start = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto stop = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto step = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(2));
auto range = make_shared<op::v4::Range>(start, stop, step, element::f32);
FAIL() << "Exception expected";
} catch (const ngraph::NodeValidationFailure& error) {
} catch (const ov::NodeValidationFailure& error) {
EXPECT_HAS_SUBSTRING(error.what(), std::string("'step' input is not a scalar"));
} catch (...) {
FAIL() << "Unknown exception was thrown";
@ -569,11 +576,11 @@ TEST(type_prop, range_v4_invalid_inputs_non_scalar) {
TEST(type_prop, range_v4_invalid_inputs_plus_inf) {
// invalid start input scalar, +inf
try {
auto start = make_shared<op::Constant>(element::f32,
Shape{},
std::vector<float>{std::numeric_limits<float>::infinity()});
auto stop = make_shared<op::Parameter>(element::f32, Shape{});
auto step = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto start = make_shared<ov::op::v0::Constant>(element::f32,
Shape{},
std::vector<float>{std::numeric_limits<float>::infinity()});
auto stop = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto step = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto range = make_shared<op::v4::Range>(start, stop, step, element::f32);
FAIL() << "+Infinity start not detected";
} catch (const NodeValidationFailure& error) {
@ -586,11 +593,11 @@ TEST(type_prop, range_v4_invalid_inputs_plus_inf) {
// invalid stop input scalar, +inf
try {
auto start = make_shared<op::Parameter>(element::f32, Shape{});
auto stop = make_shared<op::Constant>(element::f32,
Shape{},
std::vector<float>{std::numeric_limits<float>::infinity()});
auto step = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto start = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto stop = make_shared<ov::op::v0::Constant>(element::f32,
Shape{},
std::vector<float>{std::numeric_limits<float>::infinity()});
auto step = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto range = make_shared<op::v4::Range>(start, stop, step, element::f32);
FAIL() << "+Infinity stop not detected";
} catch (const NodeValidationFailure& error) {
@ -603,11 +610,11 @@ TEST(type_prop, range_v4_invalid_inputs_plus_inf) {
// invalid step input scalar, +inf
try {
auto start = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{3});
auto stop = make_shared<op::Parameter>(element::f32, Shape{});
auto step = make_shared<op::Constant>(element::f32,
Shape{},
std::vector<float>{std::numeric_limits<float>::infinity()});
auto start = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{3});
auto stop = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto step = make_shared<ov::op::v0::Constant>(element::f32,
Shape{},
std::vector<float>{std::numeric_limits<float>::infinity()});
auto range = make_shared<op::v4::Range>(start, stop, step, element::f32);
FAIL() << "+Infinity step not detected";
} catch (const NodeValidationFailure& error) {
@ -622,11 +629,11 @@ TEST(type_prop, range_v4_invalid_inputs_plus_inf) {
TEST(type_prop, range_v4_invalid_inputs_minus_inf) {
// invalid start input scalar, -inf
try {
auto start = make_shared<op::Constant>(element::f32,
Shape{},
std::vector<float>{-std::numeric_limits<float>::infinity()});
auto stop = make_shared<op::Parameter>(element::f32, Shape{});
auto step = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto start = make_shared<ov::op::v0::Constant>(element::f32,
Shape{},
std::vector<float>{-std::numeric_limits<float>::infinity()});
auto stop = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto step = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto range = make_shared<op::v4::Range>(start, stop, step, element::f32);
FAIL() << "-Infinity start not detected";
} catch (const NodeValidationFailure& error) {
@ -641,11 +648,11 @@ TEST(type_prop, range_v4_invalid_inputs_minus_inf) {
// invalid stop input scalar, -inf
try {
auto start = make_shared<op::Parameter>(element::f32, Shape{});
auto stop = make_shared<op::Constant>(element::f32,
Shape{},
std::vector<float>{-std::numeric_limits<float>::infinity()});
auto step = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto start = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto stop = make_shared<ov::op::v0::Constant>(element::f32,
Shape{},
std::vector<float>{-std::numeric_limits<float>::infinity()});
auto step = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto range = make_shared<op::v4::Range>(start, stop, step, element::f32);
FAIL() << "-Infinity stop not detected";
} catch (const NodeValidationFailure& error) {
@ -660,11 +667,11 @@ TEST(type_prop, range_v4_invalid_inputs_minus_inf) {
// invalid step input scalar, -inf
try {
auto start = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{3});
auto stop = make_shared<op::Parameter>(element::f32, Shape{});
auto step = make_shared<op::Constant>(element::f32,
Shape{},
std::vector<float>{-std::numeric_limits<float>::infinity()});
auto start = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{3});
auto stop = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto step = make_shared<ov::op::v0::Constant>(element::f32,
Shape{},
std::vector<float>{-std::numeric_limits<float>::infinity()});
auto range = make_shared<op::v4::Range>(start, stop, step, element::f32);
FAIL() << "-Infinity step not detected";
} catch (const NodeValidationFailure& error) {
@ -681,9 +688,9 @@ TEST(type_prop, range_v4_invalid_inputs_minus_inf) {
TEST(type_prop, range_v4_invalid_inputs_nan) {
// invalid start input scalar, nan
try {
auto start = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{std::nanf("")});
auto stop = make_shared<op::Parameter>(element::f32, Shape{});
auto step = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto start = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{std::nanf("")});
auto stop = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto step = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto range = make_shared<op::v4::Range>(start, stop, step, element::f32);
FAIL() << "NaN start not detected";
} catch (const NodeValidationFailure& error) {
@ -698,9 +705,9 @@ TEST(type_prop, range_v4_invalid_inputs_nan) {
// invalid stop input scalar, nan
try {
auto start = make_shared<op::Parameter>(element::f32, Shape{});
auto stop = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{std::nanf("")});
auto step = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto start = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto stop = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{std::nanf("")});
auto step = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto range = make_shared<op::v4::Range>(start, stop, step, element::f32);
FAIL() << "NaN stop not detected";
} catch (const NodeValidationFailure& error) {
@ -715,9 +722,9 @@ TEST(type_prop, range_v4_invalid_inputs_nan) {
// invalid step input scalar, nan
try {
auto start = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto stop = make_shared<op::Parameter>(element::f32, Shape{});
auto step = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{std::nanf("")});
auto start = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto stop = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto step = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{std::nanf("")});
auto range = make_shared<op::v4::Range>(start, stop, step, element::f32);
FAIL() << "NaN step not detected";
} catch (const NodeValidationFailure& error) {
@ -732,18 +739,18 @@ TEST(type_prop, range_v4_invalid_inputs_nan) {
}
TEST(type_prop, range_v4_zero_output_elem_pos_step) {
auto start = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{5});
auto stop = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto step = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto start = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{5});
auto stop = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto step = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto range = make_shared<op::v4::Range>(start, stop, step, element::f32);
// if step is positive and start >= stop, number of output elements is zero
ASSERT_TRUE(range->get_output_partial_shape(0).same_scheme(PartialShape{Dimension(0)}));
}
TEST(type_prop, range_v4_zero_output_elem_neg_step) {
auto start = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto stop = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{5});
auto step = make_shared<op::Constant>(element::f32, Shape{}, std::vector<float>{-1});
auto start = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{1});
auto stop = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{5});
auto step = make_shared<ov::op::v0::Constant>(element::f32, Shape{}, std::vector<float>{-1});
auto range = make_shared<op::v4::Range>(start, stop, step, element::f32);
// if step is negative and start <= stop, number of output elements is zero
ASSERT_TRUE(range->get_output_partial_shape(0).same_scheme(PartialShape{Dimension(0)}));
@ -751,9 +758,9 @@ TEST(type_prop, range_v4_zero_output_elem_neg_step) {
template <typename T>
void run_range_v4_test(const element::Type& et, const RangeParams& params) {
auto start = make_shared<op::Constant>(et, Shape{}, std::vector<T>{static_cast<T>(params.start)});
auto stop = make_shared<op::Constant>(et, Shape{}, std::vector<T>{static_cast<T>(params.stop)});
auto step = make_shared<op::Constant>(et, Shape{}, std::vector<T>{static_cast<T>(params.step)});
auto start = make_shared<ov::op::v0::Constant>(et, Shape{}, std::vector<T>{static_cast<T>(params.start)});
auto stop = make_shared<ov::op::v0::Constant>(et, Shape{}, std::vector<T>{static_cast<T>(params.stop)});
auto step = make_shared<ov::op::v0::Constant>(et, Shape{}, std::vector<T>{static_cast<T>(params.step)});
auto range = make_shared<op::v4::Range>(start, stop, step, et);

61
src/core/tests/type_prop/rdft.cpp
View File

@ -14,11 +14,12 @@
// limitations under the License.
//*****************************************************************************
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/op/rdft.hpp"
using namespace ngraph;
#include "common_test_utils/type_prop.hpp"
#include "openvino/op/constant.hpp"
using namespace ov;
struct RDFTConstantAxesAndConstantSignalSizeTestParams {
PartialShape input_shape;
@ -35,15 +36,15 @@ struct RDFTConstantAxesAndConstantSignalSizeTest
TEST_P(RDFTConstantAxesAndConstantSignalSizeTest, rdft_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::v9::RDFT> rdft;
if (params.signal_size.empty()) {
rdft = std::make_shared<op::v9::RDFT>(data, axes_input);
rdft = std::make_shared<ov::op::v9::RDFT>(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);
rdft = std::make_shared<op::v9::RDFT>(data, axes_input, signal_size_input);
}
@ -144,8 +145,8 @@ TEST(type_prop, rdft_dynamic_axes) {
const auto axes_shape = PartialShape::dynamic();
const auto ref_output_shape = PartialShape{Dimension::dynamic(), Dimension::dynamic(), Dimension::dynamic(), 2};
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 rdft = std::make_shared<op::v9::RDFT>(data, axes_input);
EXPECT_EQ(rdft->get_element_type(), element::f32);
@ -163,8 +164,8 @@ struct RDFTNonConstantAxesTest : ::testing::TestWithParam<RDFTNonConstantAxesTes
TEST_P(RDFTNonConstantAxesTest, rdft_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 rdft = std::make_shared<op::v9::RDFT>(data, axes_input);
EXPECT_EQ(rdft->get_element_type(), element::f32);
@ -214,9 +215,9 @@ struct RDFTNonConstantSignalSizeTest : ::testing::TestWithParam<RDFTNonConstantS
TEST_P(RDFTNonConstantSignalSizeTest, rdft_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 rdft = std::make_shared<op::v9::RDFT>(data, axes_input, signal_size_input);
EXPECT_EQ(rdft->get_element_type(), element::f32);
@ -245,10 +246,10 @@ INSTANTIATE_TEST_SUITE_P(
PrintToDummyParamName());
TEST(type_prop, rdft_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{});
auto data = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto rdft = std::make_shared<op::v9::RDFT>(data, axes);
FAIL() << "RDFT node was created with invalid input.";
} catch (const NodeValidationFailure& error) {
@ -256,7 +257,7 @@ TEST(type_prop, rdft_invalid_input) {
}
try {
auto data = std::make_shared<op::Parameter>(element::f32, Shape{4});
auto data = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{4});
auto rdft = std::make_shared<op::v9::RDFT>(data, axes);
FAIL() << "RDFT node was created with invalid input.";
} catch (const NodeValidationFailure& error) {
@ -266,10 +267,10 @@ TEST(type_prop, rdft_invalid_input) {
}
TEST(type_prop, rdft_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 rdft = std::make_shared<op::v9::RDFT>(data, axes);
FAIL() << "RDFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) {
@ -277,7 +278,7 @@ TEST(type_prop, rdft_invalid_axes) {
}
try {
auto axes = op::Constant::create(element::i64, Shape{1}, {-4});
auto axes = ov::op::v0::Constant::create(element::i64, Shape{1}, {-4});
auto rdft = std::make_shared<op::v9::RDFT>(data, axes);
FAIL() << "RDFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) {
@ -285,7 +286,7 @@ TEST(type_prop, rdft_invalid_axes) {
}
try {
auto axes = op::Constant::create(element::i64, Shape{2}, {0, -3});
auto axes = ov::op::v0::Constant::create(element::i64, Shape{2}, {0, -3});
auto rdft = std::make_shared<op::v9::RDFT>(data, axes);
FAIL() << "RDFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) {
@ -293,7 +294,7 @@ TEST(type_prop, rdft_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 rdft = std::make_shared<op::v9::RDFT>(data, axes);
FAIL() << "RDFT node was created with invalid axes.";
} catch (const NodeValidationFailure& error) {
@ -302,11 +303,11 @@ TEST(type_prop, rdft_invalid_axes) {
}
TEST(type_prop, rdft_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 rdft = std::make_shared<op::v9::RDFT>(data, axes, signal_size);
FAIL() << "RDFT node was created with invalid signal size.";
} catch (const NodeValidationFailure& error) {
@ -314,7 +315,7 @@ TEST(type_prop, rdft_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 rdft = std::make_shared<op::v9::RDFT>(data, axes, signal_size);
FAIL() << "RDFT node was created with invalid signal size.";
} catch (const NodeValidationFailure& error) {
@ -328,9 +329,9 @@ TEST(type_prop, rdft_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 rdft = std::make_shared<op::v9::RDFT>(data, axes_input, signal_size_input);
EXPECT_EQ(rdft->get_element_type(), element::dynamic);

11
src/core/tests/type_prop/read_value.cpp
View File

@ -2,17 +2,16 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/read_value.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "ngraph/opsets/opset5.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
TEST(type_prop, read_value_deduce) {
auto input = make_shared<op::Parameter>(element::f32, Shape{1, 2, 64, 64});
auto read_value = make_shared<opset5::ReadValue>(input, "variable_id");
auto input = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 64, 64});
auto read_value = make_shared<ov::op::v3::ReadValue>(input, "variable_id");
ASSERT_EQ(read_value->get_element_type(), element::f32);
ASSERT_EQ(read_value->get_shape(), (Shape{1, 2, 64, 64}));

4
src/core/tests/type_prop/reduce_l1.cpp
View File

@ -2,8 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/reduce_l1.hpp"
#include "reduce_ops.hpp"
using Type = ::testing::Types<op::v4::ReduceL1>;
using Type = ::testing::Types<ov::op::v4::ReduceL1>;
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_reduce_l1, ReduceTest, Type);
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_reduce_l1_et, ReduceArithmeticTest, Type);

4
src/core/tests/type_prop/reduce_l2.cpp
View File

@ -2,8 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/reduce_l2.hpp"
#include "reduce_ops.hpp"
using Type = ::testing::Types<op::v4::ReduceL2>;
using Type = ::testing::Types<ov::op::v4::ReduceL2>;
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_reduce_l2, ReduceTest, Type);
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_reduce_l2_et, ReduceArithmeticTest, Type);

4
src/core/tests/type_prop/reduce_logical_and.cpp
View File

@ -2,8 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/reduce_logical_and.hpp"
#include "reduce_ops.hpp"
using Type = ::testing::Types<op::v1::ReduceLogicalAnd>;
using Type = ::testing::Types<ov::op::v1::ReduceLogicalAnd>;
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_reduce_logical_and, ReduceTest, Type);
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_reduce_logical_and_et, ReduceLogicalTest, Type);

4
src/core/tests/type_prop/reduce_logical_or.cpp
View File

@ -2,8 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/reduce_logical_or.hpp"
#include "reduce_ops.hpp"
using Type = ::testing::Types<op::v1::ReduceLogicalOr>;
using Type = ::testing::Types<ov::op::v1::ReduceLogicalOr>;
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_reduce_logical_or, ReduceTest, Type);
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_reduce_logical_or_et, ReduceLogicalTest, Type);

10
src/core/tests/type_prop/reduce_max.cpp
View File

@ -2,17 +2,21 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/reduce_max.hpp"
#include "openvino/op/reshape.hpp"
#include "openvino/op/shape_of.hpp"
#include "reduce_ops.hpp"
using Type = ::testing::Types<op::v1::ReduceMax>;
using Type = ::testing::Types<ov::op::v1::ReduceMax>;
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_reduce_max, ReduceTest, Type);
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_reduce_max_et, ReduceArithmeticTest, Type);
TEST(type_prop, reduce_max_value_propagation) {
const auto param = std::make_shared<op::Parameter>(element::f32, PartialShape{{1, 8}, {2, 3}, 6});
const auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{{1, 8}, {2, 3}, 6});
const auto shape_of = std::make_shared<op::v3::ShapeOf>(param);
const auto reduce_prod =
std::make_shared<op::v1::ReduceMax>(shape_of, op::Constant::create(element::i64, {1}, {0}), true);
std::make_shared<op::v1::ReduceMax>(shape_of, ov::op::v0::Constant::create(element::i64, {1}, {0}), true);
const auto reshape = std::make_shared<op::v1::Reshape>(param, reduce_prod, false);
EXPECT_EQ(reshape->get_element_type(), ov::element::f32);

4
src/core/tests/type_prop/reduce_mean.cpp
View File

@ -2,8 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/reduce_mean.hpp"
#include "reduce_ops.hpp"
using Type = ::testing::Types<op::v1::ReduceMean>;
using Type = ::testing::Types<ov::op::v1::ReduceMean>;
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_reduce_mean, ReduceTest, Type);
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_reduce_mean_et, ReduceArithmeticTest, Type);

10
src/core/tests/type_prop/reduce_min.cpp
View File

@ -2,17 +2,21 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/reduce_min.hpp"
#include "openvino/op/reshape.hpp"
#include "openvino/op/shape_of.hpp"
#include "reduce_ops.hpp"
using Type = ::testing::Types<op::v1::ReduceMin>;
using Type = ::testing::Types<ov::op::v1::ReduceMin>;
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_reduce_min, ReduceTest, Type);
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_reduce_min_et, ReduceArithmeticTest, Type);
TEST(type_prop, reduce_min_value_propagation) {
const auto param = std::make_shared<op::Parameter>(element::f32, PartialShape{{1, 8}, {2, 3}, 6});
const auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{{1, 8}, {2, 3}, 6});
const auto shape_of = std::make_shared<op::v3::ShapeOf>(param);
const auto reduce_prod =
std::make_shared<op::v1::ReduceMin>(shape_of, op::Constant::create(element::i64, {1}, {0}), true);
std::make_shared<op::v1::ReduceMin>(shape_of, ov::op::v0::Constant::create(element::i64, {1}, {0}), true);
const auto reshape = std::make_shared<op::v1::Reshape>(param, reduce_prod, false);
EXPECT_EQ(reshape->get_element_type(), ov::element::f32);

18
src/core/tests/type_prop/reduce_ops.hpp
View File

@ -2,13 +2,15 @@
// 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 "ngraph/ngraph.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/parameter.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
struct ReduceParams {
PartialShape data_ps;
@ -21,15 +23,15 @@ struct ReduceParams {
template <class T>
static std::shared_ptr<Node> makeReduceOp(const ReduceParams& p, bool axes_as_param = false) {
auto in_data = make_shared<op::Parameter>(p.data_et, p.data_ps);
auto in_data = make_shared<ov::op::v0::Parameter>(p.data_et, p.data_ps);
shared_ptr<Node> in_axes;
if (axes_as_param) {
in_axes = make_shared<op::Parameter>(p.axes_et, p.axes_ps);
in_axes = make_shared<ov::op::v0::Parameter>(p.axes_et, p.axes_ps);
} else {
if (shape_size(p.axes_ps) != p.axes.size()) {
OPENVINO_THROW("Axes shape does not match with axes elements");
}
in_axes = make_shared<op::Constant>(p.axes_et, p.axes_ps, p.axes);
in_axes = make_shared<ov::op::v0::Constant>(p.axes_et, p.axes_ps, p.axes);
}
return make_shared<T>(in_data, in_axes, p.keep_dims);
}
@ -49,8 +51,8 @@ TYPED_TEST_P(ReduceTest, reduce_default_ctor) {
bool keep_dims = true;
const auto data = make_shared<op::Parameter>(data_et, data_ps);
const auto in_axes = make_shared<op::Parameter>(axes_et, axes_ps);
const auto data = make_shared<ov::op::v0::Parameter>(data_et, data_ps);
const auto in_axes = make_shared<ov::op::v0::Parameter>(axes_et, axes_ps);
auto op = std::make_shared<TypeParam>();
op->set_arguments(OutputVector{data, in_axes});

10
src/core/tests/type_prop/reduce_prod.cpp
View File

@ -2,17 +2,21 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/reduce_prod.hpp"
#include "openvino/op/reshape.hpp"
#include "openvino/op/shape_of.hpp"
#include "reduce_ops.hpp"
using Type = ::testing::Types<op::v1::ReduceProd>;
using Type = ::testing::Types<ov::op::v1::ReduceProd>;
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_reduce_prod, ReduceTest, Type);
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_reduce_prod_et, ReduceArithmeticTest, Type);
TEST(type_prop, reduce_prod_value_propagation) {
const auto param = std::make_shared<op::Parameter>(element::f32, PartialShape{{1, 8}, {2, 3}, 6});
const auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{{1, 8}, {2, 3}, 6});
const auto shape_of = std::make_shared<op::v3::ShapeOf>(param);
const auto reduce_prod =
std::make_shared<op::v1::ReduceProd>(shape_of, op::Constant::create(element::i64, {1}, {0}), true);
std::make_shared<op::v1::ReduceProd>(shape_of, ov::op::v0::Constant::create(element::i64, {1}, {0}), true);
const auto reshape = std::make_shared<op::v1::Reshape>(param, reduce_prod, false);
EXPECT_EQ(reshape->get_element_type(), ov::element::f32);

4
src/core/tests/type_prop/reduce_sum.cpp
View File

@ -2,8 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/reduce_sum.hpp"
#include "reduce_ops.hpp"
using Type = ::testing::Types<op::v1::ReduceSum>;
using Type = ::testing::Types<ov::op::v1::ReduceSum>;
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_reduce_sum, ReduceTest, Type);
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_reduce_sum_et, ReduceArithmeticTest, Type);

14
src/core/tests/type_prop/relu.cpp
View File

@ -2,25 +2,25 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/relu.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;
TEST(type_prop, relu_2d) {
auto param = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
Shape relu_shape{2, 4};
auto relu = make_shared<op::Relu>(param);
auto relu = make_shared<op::v0::Relu>(param);
ASSERT_EQ(relu->get_element_type(), element::f32);
ASSERT_EQ(relu->get_shape(), relu_shape);
}
TEST(type_prop, relu_4d) {
auto param = make_shared<op::Parameter>(element::f32, Shape{2, 2, 2, 2});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2, 2, 2});
Shape relu_shape{2, 2, 2, 2};
auto relu = make_shared<op::Relu>(param);
auto relu = make_shared<op::v0::Relu>(param);
ASSERT_EQ(relu->get_element_type(), element::f32);
ASSERT_EQ(relu->get_shape(), relu_shape);
}

471
src/core/tests/type_prop/reshape.cpp
View File

@ -2,16 +2,27 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/reshape.hpp"
#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/concat.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/convert.hpp"
#include "openvino/op/divide.hpp"
#include "openvino/op/gather.hpp"
#include "openvino/op/multiply.hpp"
#include "openvino/op/reduce_prod.hpp"
#include "openvino/op/shape_of.hpp"
#include "openvino/op/squeeze.hpp"
#include "openvino/op/unsqueeze.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
TEST(type_prop, static_value_propagation) {
auto param = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3});
auto shape_of = make_shared<op::v3::ShapeOf>(param);
auto r = make_shared<op::v1::Reshape>(param, shape_of, false);
@ -21,7 +32,7 @@ TEST(type_prop, static_value_propagation) {
}
TEST(type_prop, interval_value_propagation) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{Dimension(1, 8), 2, 3});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension(1, 8), 2, 3});
auto shape_of = make_shared<op::v3::ShapeOf>(param);
auto r = make_shared<op::v1::Reshape>(param, shape_of, false);
@ -38,11 +49,11 @@ TEST(type_prop, interval_value_propagation) {
}
TEST(type_prop, static_value_propagation_through_gather) {
auto param = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 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}));
ov::op::v0::Constant::create(element::i64, {3}, {2, 1, 0}),
ov::op::v0::Constant::create(element::i64, {}, {0}));
auto r = make_shared<op::v1::Reshape>(param, gather, false);
@ -51,11 +62,11 @@ TEST(type_prop, static_value_propagation_through_gather) {
}
TEST(type_prop, interval_value_propagation_through_gather) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{Dimension(1, 8), 2, 3});
auto param = make_shared<ov::op::v0::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}));
ov::op::v0::Constant::create(element::i64, {3}, {2, 1, 0}),
ov::op::v0::Constant::create(element::i64, {}, {0}));
auto r = make_shared<op::v1::Reshape>(param, gather, false);
@ -64,15 +75,15 @@ TEST(type_prop, interval_value_propagation_through_gather) {
}
TEST(type_prop, interval_value_propagation_through_consecutive_gathers) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{Dimension(1, 8), 2, 3});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension(1, 8), 2, 3});
auto shape_of = make_shared<op::v3::ShapeOf>(param);
auto gather_1 = make_shared<op::v1::Gather>(shape_of,
op::Constant::create(element::i64, {3}, {2, 1, 0}),
op::Constant::create(element::i64, {}, {0}));
ov::op::v0::Constant::create(element::i64, {3}, {2, 1, 0}),
ov::op::v0::Constant::create(element::i64, {}, {0}));
auto gather_2 = make_shared<op::v1::Gather>(gather_1,
op::Constant::create(element::i64, {3}, {1, 2, 0}),
op::Constant::create(element::i64, {}, {0}));
ov::op::v0::Constant::create(element::i64, {3}, {1, 2, 0}),
ov::op::v0::Constant::create(element::i64, {}, {0}));
auto r = make_shared<op::v1::Reshape>(param, gather_2, false);
@ -81,26 +92,27 @@ TEST(type_prop, interval_value_propagation_through_consecutive_gathers) {
}
TEST(type_prop, interval_value_propagation_concatenated_gathers) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{Dimension(1, 8), 2, 3});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension(1, 8), 2, 3});
auto shape_of = make_shared<op::v3::ShapeOf>(param);
auto gather_1 = make_shared<op::v1::Gather>(shape_of,
op::Constant::create(element::i64, {}, {2}),
op::Constant::create(element::i64, {}, {0}));
auto dim_1 = make_shared<op::Unsqueeze>(gather_1, op::Constant::create(element::i64, {1}, {0}));
ov::op::v0::Constant::create(element::i64, {}, {2}),
ov::op::v0::Constant::create(element::i64, {}, {0}));
auto dim_1 = make_shared<op::v0::Unsqueeze>(gather_1, ov::op::v0::Constant::create(element::i64, {1}, {0}));
auto gather_2 = make_shared<op::v1::Gather>(shape_of,
op::Constant::create(element::i64, {}, {1}),
op::Constant::create(element::i64, {}, {0}));
auto tmp_dim_2 = make_shared<op::v1::Reshape>(gather_2, op::Constant::create(element::i64, {2}, {1, 1}), true);
auto dim_2 = make_shared<op::v0::Squeeze>(tmp_dim_2, op::Constant::create(element::i64, {1}, {0}));
ov::op::v0::Constant::create(element::i64, {}, {1}),
ov::op::v0::Constant::create(element::i64, {}, {0}));
auto tmp_dim_2 =
make_shared<op::v1::Reshape>(gather_2, ov::op::v0::Constant::create(element::i64, {2}, {1, 1}), true);
auto dim_2 = make_shared<op::v0::Squeeze>(tmp_dim_2, ov::op::v0::Constant::create(element::i64, {1}, {0}));
auto gather_3 = make_shared<op::v1::Gather>(shape_of,
op::Constant::create(element::i64, {}, {0}),
op::Constant::create(element::i64, {}, {0}));
auto dim_3 = make_shared<op::Unsqueeze>(gather_3, op::Constant::create(element::i64, {1}, {0}));
ov::op::v0::Constant::create(element::i64, {}, {0}),
ov::op::v0::Constant::create(element::i64, {}, {0}));
auto dim_3 = make_shared<op::v0::Unsqueeze>(gather_3, ov::op::v0::Constant::create(element::i64, {1}, {0}));
auto shape = make_shared<op::Concat>(OutputVector{dim_1, dim_2, dim_3}, 0);
auto shape = make_shared<op::v0::Concat>(OutputVector{dim_1, dim_2, dim_3}, 0);
auto r = make_shared<op::v1::Reshape>(param, shape, false);
ASSERT_EQ(r->get_element_type(), element::f32);
@ -108,13 +120,13 @@ TEST(type_prop, interval_value_propagation_concatenated_gathers) {
}
TEST(type_prop, interval_value_propagation_mul_div) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{Dimension(2, 8), Dimension(4, 16), 2});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension(2, 8), Dimension(4, 16), 2});
auto shape_of = make_shared<op::v3::ShapeOf>(param);
auto cast_fp = make_shared<op::Convert>(shape_of, element::f32);
auto mul = make_shared<op::v1::Multiply>(cast_fp, op::Constant::create(element::f32, {3}, {-2, 2, -4}));
auto div = make_shared<op::v1::Divide>(mul, op::Constant::create(element::f32, {3}, {-2, 2, -4}));
auto cast_int = make_shared<op::Convert>(div, element::i32);
auto cast_fp = make_shared<op::v0::Convert>(shape_of, element::f32);
auto mul = make_shared<op::v1::Multiply>(cast_fp, ov::op::v0::Constant::create(element::f32, {3}, {-2, 2, -4}));
auto div = make_shared<op::v1::Divide>(mul, ov::op::v0::Constant::create(element::f32, {3}, {-2, 2, -4}));
auto cast_int = make_shared<op::v0::Convert>(div, element::i32);
auto r = make_shared<op::v1::Reshape>(param, cast_int, false);
@ -123,15 +135,15 @@ TEST(type_prop, interval_value_propagation_mul_div) {
}
TEST(type_prop, interval_value_propagation_mul_div_rhs_shape) {
auto param =
make_shared<op::Parameter>(element::f32, PartialShape{Dimension(1, 5), Dimension(0, 4), Dimension(2, 3)});
auto param = make_shared<ov::op::v0::Parameter>(element::f32,
PartialShape{Dimension(1, 5), Dimension(0, 4), Dimension(2, 3)});
auto shape_of = make_shared<op::v3::ShapeOf>(param);
auto cast_fp = make_shared<op::Convert>(shape_of, element::f32);
auto mul = make_shared<op::v1::Multiply>(op::Constant::create(element::f32, {}, {2}), cast_fp);
auto div = make_shared<op::v1::Divide>(op::Constant::create(element::f32, {3}, {10, 16, 12}), mul);
auto cast_int = make_shared<op::Convert>(div, element::i32);
auto cast_fp = make_shared<op::v0::Convert>(shape_of, element::f32);
auto mul = make_shared<op::v1::Multiply>(ov::op::v0::Constant::create(element::f32, {}, {2}), cast_fp);
auto div = make_shared<op::v1::Divide>(ov::op::v0::Constant::create(element::f32, {3}, {10, 16, 12}), mul);
auto cast_int = make_shared<op::v0::Convert>(div, element::i32);
auto r = make_shared<op::v1::Reshape>(param, cast_int, false);
@ -140,12 +152,12 @@ TEST(type_prop, interval_value_propagation_mul_div_rhs_shape) {
}
TEST(type_prop, interval_value_propagation_mul_div_lhs_scalar) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{Dimension(2, 8), Dimension(4, 16), 6});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension(2, 8), Dimension(4, 16), 6});
auto shape_of = make_shared<op::v3::ShapeOf>(param);
auto cast_fp = make_shared<op::Convert>(shape_of, element::f32);
auto mul = make_shared<op::v1::Multiply>(op::Constant::create(element::f32, {}, {2}), cast_fp);
auto div = make_shared<op::v1::Divide>(mul, op::Constant::create(element::f32, {3}, {2, 1, 3}));
auto cast_int = make_shared<op::Convert>(div, element::i32);
auto cast_fp = make_shared<op::v0::Convert>(shape_of, element::f32);
auto mul = make_shared<op::v1::Multiply>(ov::op::v0::Constant::create(element::f32, {}, {2}), cast_fp);
auto div = make_shared<op::v1::Divide>(mul, ov::op::v0::Constant::create(element::f32, {3}, {2, 1, 3}));
auto cast_int = make_shared<op::v0::Convert>(div, element::i32);
auto r = make_shared<op::v1::Reshape>(param, cast_int, false);
@ -154,12 +166,12 @@ TEST(type_prop, interval_value_propagation_mul_div_lhs_scalar) {
}
TEST(type_prop, interval_value_propagation_mul_div_rhs_scalar) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{Dimension(2, 8), Dimension(4, 16), 6});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension(2, 8), Dimension(4, 16), 6});
auto shape_of = make_shared<op::v3::ShapeOf>(param);
auto cast_fp = make_shared<op::Convert>(shape_of, element::f32);
auto mul = make_shared<op::v1::Multiply>(cast_fp, op::Constant::create(element::f32, {}, {2}));
auto div = make_shared<op::v1::Divide>(mul, op::Constant::create(element::f32, {3}, {2, 1, 3}));
auto cast_int = make_shared<op::Convert>(div, element::i32);
auto cast_fp = make_shared<op::v0::Convert>(shape_of, element::f32);
auto mul = make_shared<op::v1::Multiply>(cast_fp, ov::op::v0::Constant::create(element::f32, {}, {2}));
auto div = make_shared<op::v1::Divide>(mul, ov::op::v0::Constant::create(element::f32, {3}, {2, 1, 3}));
auto cast_int = make_shared<op::v0::Convert>(div, element::i32);
auto r = make_shared<op::v1::Reshape>(param, cast_int, false);
@ -168,12 +180,12 @@ TEST(type_prop, interval_value_propagation_mul_div_rhs_scalar) {
}
TEST(type_prop, interval_value_propagation_mul_lhs_1D_div) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{Dimension(2, 8), Dimension(4, 16), 6});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension(2, 8), Dimension(4, 16), 6});
auto shape_of = make_shared<op::v3::ShapeOf>(param);
auto cast_fp = make_shared<op::Convert>(shape_of, element::f32);
auto mul = make_shared<op::v1::Multiply>(op::Constant::create(element::f32, {1}, {2}), cast_fp);
auto div = make_shared<op::v1::Divide>(mul, op::Constant::create(element::f32, {3}, {2, 1, 3}));
auto cast_int = make_shared<op::Convert>(div, element::i32);
auto cast_fp = make_shared<op::v0::Convert>(shape_of, element::f32);
auto mul = make_shared<op::v1::Multiply>(ov::op::v0::Constant::create(element::f32, {1}, {2}), cast_fp);
auto div = make_shared<op::v1::Divide>(mul, ov::op::v0::Constant::create(element::f32, {3}, {2, 1, 3}));
auto cast_int = make_shared<op::v0::Convert>(div, element::i32);
auto r = make_shared<op::v1::Reshape>(param, cast_int, false);
@ -182,12 +194,12 @@ TEST(type_prop, interval_value_propagation_mul_lhs_1D_div) {
}
TEST(type_prop, interval_value_propagation_mul_rhs_1D_div) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{Dimension(2, 8), Dimension(4, 16), 6});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension(2, 8), Dimension(4, 16), 6});
auto shape_of = make_shared<op::v3::ShapeOf>(param);
auto cast_fp = make_shared<op::Convert>(shape_of, element::f32);
auto mul = make_shared<op::v1::Multiply>(cast_fp, op::Constant::create(element::f32, {1}, {2}));
auto div = make_shared<op::v1::Divide>(mul, op::Constant::create(element::f32, {3}, {2, 1, 3}));
auto cast_int = make_shared<op::Convert>(div, element::i32);
auto cast_fp = make_shared<op::v0::Convert>(shape_of, element::f32);
auto mul = make_shared<op::v1::Multiply>(cast_fp, ov::op::v0::Constant::create(element::f32, {1}, {2}));
auto div = make_shared<op::v1::Divide>(mul, ov::op::v0::Constant::create(element::f32, {3}, {2, 1, 3}));
auto cast_int = make_shared<op::v0::Convert>(div, element::i32);
auto r = make_shared<op::v1::Reshape>(param, cast_int, false);
@ -196,12 +208,12 @@ TEST(type_prop, interval_value_propagation_mul_rhs_1D_div) {
}
TEST(type_prop, interval_value_propagation_mul_div_lhs_1D) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{Dimension(2, 8), Dimension(4, 16), 6});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension(2, 8), Dimension(4, 16), 6});
auto shape_of = make_shared<op::v3::ShapeOf>(param);
auto cast_fp = make_shared<op::Convert>(shape_of, element::f32);
auto mul = make_shared<op::v1::Multiply>(cast_fp, op::Constant::create(element::f32, {1}, {2}));
auto div = make_shared<op::v1::Divide>(op::Constant::create(element::f32, {}, {192}), mul);
auto cast_int = make_shared<op::Convert>(div, element::i32);
auto cast_fp = make_shared<op::v0::Convert>(shape_of, element::f32);
auto mul = make_shared<op::v1::Multiply>(cast_fp, ov::op::v0::Constant::create(element::f32, {1}, {2}));
auto div = make_shared<op::v1::Divide>(ov::op::v0::Constant::create(element::f32, {}, {192}), mul);
auto cast_int = make_shared<op::v0::Convert>(div, element::i32);
auto r = make_shared<op::v1::Reshape>(param, cast_int, false);
@ -210,9 +222,10 @@ TEST(type_prop, interval_value_propagation_mul_div_lhs_1D) {
}
TEST(type_prop, interval_value_propagation_reduce) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{Dimension(1, 8), 2, 3});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension(1, 8), 2, 3});
auto shape_of = make_shared<op::v3::ShapeOf>(param);
auto reduce_prod = make_shared<op::v1::ReduceProd>(shape_of, op::Constant::create(element::i64, {1}, {0}), true);
auto reduce_prod =
make_shared<op::v1::ReduceProd>(shape_of, ov::op::v0::Constant::create(element::i64, {1}, {0}), true);
auto r = make_shared<op::v1::Reshape>(param, reduce_prod, false);
ASSERT_EQ(r->get_element_type(), element::f32);
@ -220,16 +233,17 @@ TEST(type_prop, interval_value_propagation_reduce) {
}
TEST(type_prop, interval_value_propagation_reshape_zero_special_value) {
auto param = make_shared<op::Parameter>(element::f32,
PartialShape{Dimension(1, 8), Dimension(16, 64), 3, Dimension(200, 400)});
auto param =
make_shared<ov::op::v0::Parameter>(element::f32,
PartialShape{Dimension(1, 8), Dimension(16, 64), 3, Dimension(200, 400)});
auto shape_of = make_shared<op::v3::ShapeOf>(param);
auto dim_021 = make_shared<op::v1::Gather>(shape_of,
op::Constant::create(element::i64, {3}, {0, 2, 1}),
op::Constant::create(element::i64, {}, {0}));
auto dim_3 = op::Constant::create(element::i64, {1}, {0});
ov::op::v0::Constant::create(element::i64, {3}, {0, 2, 1}),
ov::op::v0::Constant::create(element::i64, {}, {0}));
auto dim_3 = ov::op::v0::Constant::create(element::i64, {1}, {0});
auto shape = make_shared<op::Concat>(OutputVector{dim_021, dim_3}, 0);
auto shape = make_shared<op::v0::Concat>(OutputVector{dim_021, dim_3}, 0);
auto r = make_shared<op::v1::Reshape>(param, shape, true);
ASSERT_EQ(r->get_element_type(), element::f32);
@ -238,17 +252,18 @@ TEST(type_prop, interval_value_propagation_reshape_zero_special_value) {
}
TEST(type_prop, interval_value_propagation_reshape_zero_minus_one_special_values) {
auto param = make_shared<op::Parameter>(element::f32,
PartialShape{Dimension(1, 8), Dimension(16, 64), 6, Dimension(200, 400)});
auto param =
make_shared<ov::op::v0::Parameter>(element::f32,
PartialShape{Dimension(1, 8), Dimension(16, 64), 6, Dimension(200, 400)});
auto shape_of = make_shared<op::v3::ShapeOf>(param);
auto dim_0 = make_shared<op::v1::Gather>(shape_of,
op::Constant::create(element::i64, {1}, {1}),
op::Constant::create(element::i64, {}, {0}));
auto dim_1 = op::Constant::create(element::i64, {1}, {0});
auto dim_2 = op::Constant::create(element::i64, {1}, {-1});
ov::op::v0::Constant::create(element::i64, {1}, {1}),
ov::op::v0::Constant::create(element::i64, {}, {0}));
auto dim_1 = ov::op::v0::Constant::create(element::i64, {1}, {0});
auto dim_2 = ov::op::v0::Constant::create(element::i64, {1}, {-1});
auto shape = make_shared<op::Concat>(OutputVector{dim_0, dim_1, dim_2}, 0);
auto shape = make_shared<op::v0::Concat>(OutputVector{dim_0, dim_1, dim_2}, 0);
auto r = make_shared<op::v1::Reshape>(param, shape, true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0),
@ -256,51 +271,53 @@ TEST(type_prop, interval_value_propagation_reshape_zero_minus_one_special_values
}
TEST(type_prop, reshape_deduce_s2t) {
auto param = make_shared<op::Parameter>(element::f32, Shape{});
auto r = make_shared<op::v1::Reshape>(param, op::Constant::create(element::u64, {1}, Shape{1}), false);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto r = make_shared<op::v1::Reshape>(param, ov::op::v0::Constant::create(element::u64, {1}, Shape{1}), false);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_shape(), (Shape{1}));
}
TEST(type_prop, reshape_deduce_s2m) {
auto param = make_shared<op::Parameter>(element::f32, Shape{});
auto r = make_shared<op::v1::Reshape>(param, op::Constant::create(element::u64, {2}, Shape{1, 1}), false);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto r = make_shared<op::v1::Reshape>(param, ov::op::v0::Constant::create(element::u64, {2}, Shape{1, 1}), false);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_shape(), (Shape{1, 1}));
}
TEST(type_prop, reshape_deduce_s2m3) {
auto param = make_shared<op::Parameter>(element::f32, Shape{});
auto r = make_shared<op::v1::Reshape>(param, op::Constant::create(element::u64, {3}, Shape{1, 1, 1}), false);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto r =
make_shared<op::v1::Reshape>(param, ov::op::v0::Constant::create(element::u64, {3}, Shape{1, 1, 1}), false);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_shape(), (Shape{1, 1, 1}));
}
TEST(type_prop, reshape_deduce_2d_to_1d) {
auto param = make_shared<op::Parameter>(element::f32, Shape{3, 4});
auto r = make_shared<op::v1::Reshape>(param, op::Constant::create(element::u64, {1}, Shape{12}), false);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 4});
auto r = make_shared<op::v1::Reshape>(param, ov::op::v0::Constant::create(element::u64, {1}, Shape{12}), false);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_shape(), (Shape{12}));
}
TEST(type_prop, reshape_deduce_3d_to_1d) {
auto param = make_shared<op::Parameter>(element::f32, Shape{3, 4, 5});
auto r = make_shared<op::v1::Reshape>(param, op::Constant::create(element::u64, {1}, Shape{60}), false);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 4, 5});
auto r = make_shared<op::v1::Reshape>(param, ov::op::v0::Constant::create(element::u64, {1}, Shape{60}), false);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_shape(), (Shape{60}));
}
TEST(type_prop, reshape_deduce_zero_special) {
auto param = make_shared<op::Parameter>(element::f32, Shape{3, 4, 5});
auto r = make_shared<op::v1::Reshape>(param, op::Constant::create(element::u64, {3}, Shape{6, 2, 0}), true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 4, 5});
auto r = make_shared<op::v1::Reshape>(param, ov::op::v0::Constant::create(element::u64, {3}, Shape{6, 2, 0}), true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_shape(), (Shape{6, 2, 5}));
}
TEST(type_prop, reshape_deduce_wrong_output_shape) {
auto param = make_shared<op::Parameter>(element::f32, Shape{3, 4, 5});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 4, 5});
try {
auto r = make_shared<op::v1::Reshape>(param, op::Constant::create(element::u64, {3}, Shape{3, 3, 3}), false);
auto r =
make_shared<op::v1::Reshape>(param, ov::op::v0::Constant::create(element::u64, {3}, Shape{3, 3, 3}), false);
// Should have thrown, so fail if it didn't
FAIL() << "No exception was thrown";
} catch (const NodeValidationFailure& error) {
@ -314,8 +331,9 @@ TEST(type_prop, reshape_deduce_wrong_output_shape) {
// Input shape rank dynamic, so we should set the desired output shape
//
TEST(type_prop, reshape_partial_rank_dynamic) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto r = make_shared<op::v1::Reshape>(param, op::Constant::create(element::u64, {4}, Shape{3, 1, 8, 2}), false);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto r =
make_shared<op::v1::Reshape>(param, ov::op::v0::Constant::create(element::u64, {4}, Shape{3, 1, 8, 2}), false);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_TRUE(r->get_output_partial_shape(0).is_static());
ASSERT_EQ(r->get_shape(), (Shape{3, 1, 8, 2}));
@ -326,8 +344,9 @@ TEST(type_prop, reshape_partial_rank_dynamic) {
//
TEST(type_prop, reshape_partial_rank_static) {
auto param_shape = PartialShape{Dimension::dynamic(), 6, Dimension::dynamic(), Dimension::dynamic()};
auto param = make_shared<op::Parameter>(element::f32, param_shape);
auto r = make_shared<op::v1::Reshape>(param, op::Constant::create(element::u64, {4}, Shape{3, 1, 8, 2}), false);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, param_shape);
auto r =
make_shared<op::v1::Reshape>(param, ov::op::v0::Constant::create(element::u64, {4}, Shape{3, 1, 8, 2}), false);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_TRUE(r->get_output_partial_shape(0).is_static());
ASSERT_EQ(r->get_shape(), (Shape{3, 1, 8, 2}));
@ -339,271 +358,301 @@ TEST(type_prop, reshape_partial_rank_static) {
//
TEST(type_prop, reshape_partial_rank_static_dynamic_but_zero_ok) {
auto param_shape = PartialShape{Dimension::dynamic(), 0, Dimension::dynamic(), Dimension::dynamic()};
auto param = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto r = make_shared<op::v1::Reshape>(param, op::Constant::create(element::u64, {4}, Shape{3, 1, 0, 2}), false);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto r =
make_shared<op::v1::Reshape>(param, ov::op::v0::Constant::create(element::u64, {4}, Shape{3, 1, 0, 2}), false);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_TRUE(r->get_output_partial_shape(0).is_static());
ASSERT_EQ(r->get_shape(), (Shape{3, 1, 0, 2}));
}
TEST(type_prop, reshape_deduce_special_zero_shape_neg_zero) {
auto param = make_shared<op::Parameter>(element::f32, Shape{3, 1, 2});
auto r =
make_shared<op::v1::Reshape>(param, op::Constant::create(element::i64, {2}, std::vector<int64_t>{-1, 0}), true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 1, 2});
auto r = make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {2}, std::vector<int64_t>{-1, 0}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_shape(), (Shape{6, 1}));
}
TEST(type_prop, reshape_deduce_special_zero_shape_zero_neg) {
auto param = make_shared<op::Parameter>(element::f32, Shape{3, 1, 2});
auto r =
make_shared<op::v1::Reshape>(param, op::Constant::create(element::i64, {2}, std::vector<int64_t>{0, -1}), true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 1, 2});
auto r = make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {2}, std::vector<int64_t>{0, -1}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_shape(), (Shape{3, 2}));
}
TEST(type_prop, reshape_deduce_special_zero_shape_zero_neg_copy_input) {
auto param = make_shared<op::Parameter>(element::f32, Shape{3, 1});
auto r =
make_shared<op::v1::Reshape>(param, op::Constant::create(element::i64, {2}, std::vector<int64_t>{0, -1}), true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 1});
auto r = make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {2}, std::vector<int64_t>{0, -1}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_shape(), (Shape{3, 1}));
}
TEST(type_prop, reshape_deduce_special_zero_shape_zero_zero_one_neg) {
auto param = make_shared<op::Parameter>(element::f32, Shape{2, 2, 3});
auto r = make_shared<op::v1::Reshape>(param,
op::Constant::create(element::i64, {4}, std::vector<int64_t>{0, 0, 1, -1}),
true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 2, 3});
auto r =
make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {4}, std::vector<int64_t>{0, 0, 1, -1}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_shape(), (Shape{2, 2, 1, 3}));
}
TEST(type_prop, reshape_deduce_special_zero_shape_neg_zero_dynamic) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 1, 2});
auto r =
make_shared<op::v1::Reshape>(param, op::Constant::create(element::i64, {2}, std::vector<int64_t>{-1, 0}), true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 1, 2});
auto r = make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {2}, std::vector<int64_t>{-1, 0}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), (PartialShape{Dimension::dynamic(), 1}));
}
TEST(type_prop, reshape_deduce_special_zero_shape_zero_neg_dynamic) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 1, 1});
auto r =
make_shared<op::v1::Reshape>(param, op::Constant::create(element::i64, {2}, std::vector<int64_t>{0, -1}), true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 1, 1});
auto r = make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {2}, std::vector<int64_t>{0, -1}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), (PartialShape{Dimension::dynamic(), 1}));
}
TEST(type_prop, reshape_deduce_special_zero_shape_zero_zero_one_neg_dynamic) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{2, Dimension::dynamic(), 3});
auto r = make_shared<op::v1::Reshape>(param,
op::Constant::create(element::i64, {4}, std::vector<int64_t>{0, 0, 1, -1}),
true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, Dimension::dynamic(), 3});
auto r =
make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {4}, std::vector<int64_t>{0, 0, 1, -1}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), (PartialShape{2, Dimension::dynamic(), 1, 3}));
}
TEST(type_prop, reshape_deduce_special_zero_shape_zero_neg_copy_input_dynamic) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 1});
auto r =
make_shared<op::v1::Reshape>(param, op::Constant::create(element::i64, {2}, std::vector<int64_t>{0, -1}), true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 1});
auto r = make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {2}, std::vector<int64_t>{0, -1}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), (PartialShape{Dimension::dynamic(), 1}));
}
TEST(type_prop, reshape_partial_rank_dynamic_special_zero) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto r = make_shared<op::v1::Reshape>(param,
op::Constant::create(element::i64, {4}, std::vector<int64_t>{3, 1, 0, 2}),
true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto r =
make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {4}, std::vector<int64_t>{3, 1, 0, 2}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), (PartialShape{3, 1, Dimension::dynamic(), 2}));
}
TEST(type_prop, reshape_partial_rank_dynamic_special_neg) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto r = make_shared<op::v1::Reshape>(param,
op::Constant::create(element::i64, {4}, std::vector<int64_t>{3, -1, 0, 2}),
true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto r =
make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {4}, std::vector<int64_t>{3, -1, 0, 2}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), (PartialShape{3, Dimension::dynamic(), Dimension::dynamic(), 2}));
}
TEST(type_prop, reshape_deduce_special_zero_shape_zero_zero_one_neg_dynamic_with_interval) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{2, Dimension(1, 3), 3});
auto r = make_shared<op::v1::Reshape>(param,
op::Constant::create(element::i64, {4}, std::vector<int64_t>{0, 0, 1, -1}),
true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, Dimension(1, 3), 3});
auto r =
make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {4}, std::vector<int64_t>{0, 0, 1, -1}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), (PartialShape{2, Dimension(1, 3), 1, 3}));
}
TEST(type_prop, reshape_deduce_special_zero_shape_zero_zero_one_neg_double_dynamic_with_interval) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{2, Dimension(1, 3), Dimension::dynamic()});
auto r = make_shared<op::v1::Reshape>(param,
op::Constant::create(element::i64, {4}, std::vector<int64_t>{0, 0, 1, -1}),
true);
auto param =
make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, Dimension(1, 3), Dimension::dynamic()});
auto r =
make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {4}, std::vector<int64_t>{0, 0, 1, -1}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), (PartialShape{2, Dimension(1, 3), 1, Dimension::dynamic()}));
}
TEST(type_prop, reshape_deduce_special_zero_shape_zero_neg_dynamic_with_interval) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{2, Dimension(1, 3)});
auto r =
make_shared<op::v1::Reshape>(param, op::Constant::create(element::i64, {2}, std::vector<int64_t>{0, -1}), true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, Dimension(1, 3)});
auto r = make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {2}, std::vector<int64_t>{0, -1}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), (PartialShape{2, Dimension(1, 3)}));
}
TEST(type_prop, reshape_deduce_special_zero_shape_neg_zero_dynamic_with_interval) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{2, Dimension(1, 3)});
auto r =
make_shared<op::v1::Reshape>(param, op::Constant::create(element::i64, {2}, std::vector<int64_t>{-1, 0}), true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, Dimension(1, 3)});
auto r = make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {2}, std::vector<int64_t>{-1, 0}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), (PartialShape{2, Dimension(1, 3)}));
}
TEST(type_prop, reshape_deduce_special_zero_shape_neg_zero_dynamic_with_interval_1) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{Dimension(1, 3), 2});
auto r =
make_shared<op::v1::Reshape>(param, op::Constant::create(element::i64, {2}, std::vector<int64_t>{-1, 0}), true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension(1, 3), 2});
auto r = make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {2}, std::vector<int64_t>{-1, 0}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), (PartialShape{Dimension(1, 3), 2}));
}
TEST(type_prop, reshape_pass_interval_dimension_through_minus_one) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension(1, 3), 2});
auto r = make_shared<op::v1::Reshape>(param,
op::Constant::create(element::i64, {3}, std::vector<int64_t>{0, -1, 2}),
true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension(1, 3), 2});
auto r =
make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {3}, std::vector<int64_t>{0, -1, 2}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), (PartialShape{1, Dimension(1, 3), 2}));
}
TEST(type_prop, reshape_multiply_interval_by_defined_dim_for_minus_one) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension(1, 3), 2});
auto r =
make_shared<op::v1::Reshape>(param, op::Constant::create(element::i64, {2}, std::vector<int64_t>{0, -1}), true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension(1, 3), 2});
auto r = make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {2}, std::vector<int64_t>{0, -1}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), (PartialShape{1, Dimension(2, 6)}));
}
TEST(type_prop, reshape_multiply_interval_by_interval_for_minus_one) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension(1, 3), Dimension(1, 6)});
auto r =
make_shared<op::v1::Reshape>(param, op::Constant::create(element::i64, {2}, std::vector<int64_t>{0, -1}), true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension(1, 3), Dimension(1, 6)});
auto r = make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {2}, std::vector<int64_t>{0, -1}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), (PartialShape{1, Dimension(1, 18)}));
}
TEST(type_prop, reshape_multiply_interval_by_interval_divide_by_defined_dim_for_minus_one) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension(1, 3), 3, Dimension(1, 6)});
auto r = make_shared<op::v1::Reshape>(param,
op::Constant::create(element::i64, {3}, std::vector<int64_t>{0, -1, 3}),
true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension(1, 3), 3, Dimension(1, 6)});
auto r =
make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {3}, std::vector<int64_t>{0, -1, 3}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), (PartialShape{1, Dimension(1, 18), 3}));
}
TEST(type_prop, reshape_multiply_interval_by_interval_divide_by_interval_for_minus_one) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{1, -1, Dimension(1, 6)});
auto r =
make_shared<op::v1::Reshape>(param, op::Constant::create(element::i64, {2}, std::vector<int64_t>{0, -1}), true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, -1, Dimension(1, 6)});
auto r = make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {2}, std::vector<int64_t>{0, -1}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), (PartialShape{1, Dimension::dynamic()}));
}
TEST(type_prop, reshape_multiply_interval_by_interval_divide_by_interval_for_minus_one_zero_included_in_input) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{1, -1, Dimension(0, 6)});
auto r =
make_shared<op::v1::Reshape>(param, op::Constant::create(element::i64, {2}, std::vector<int64_t>{0, -1}), true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, -1, Dimension(0, 6)});
auto r = make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {2}, std::vector<int64_t>{0, -1}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), (PartialShape{1, Dimension::dynamic()}));
}
TEST(type_prop, reshape_multiply_intervals_by_interval) {
auto param =
make_shared<op::Parameter>(element::f32, PartialShape{Dimension(1, 2), Dimension(1, 3), Dimension(1, 4)});
auto r =
make_shared<op::v1::Reshape>(param, op::Constant::create(element::i64, {1}, std::vector<int64_t>{-1}), true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32,
PartialShape{Dimension(1, 2), Dimension(1, 3), Dimension(1, 4)});
auto r = make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {1}, std::vector<int64_t>{-1}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), (PartialShape{Dimension(1, 24)}));
}
TEST(type_prop, reshape_multiply_intervals_by_interval_zero_included) {
auto param =
make_shared<op::Parameter>(element::f32, PartialShape{Dimension(0, 2), Dimension(0, 3), Dimension(0, 4)});
auto r =
make_shared<op::v1::Reshape>(param, op::Constant::create(element::i64, {1}, std::vector<int64_t>{-1}), true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32,
PartialShape{Dimension(0, 2), Dimension(0, 3), Dimension(0, 4)});
auto r = make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {1}, std::vector<int64_t>{-1}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_partial_shape(0), (PartialShape{Dimension(0, 24)}));
}
TEST(type_prop, reshape_to_zero_shape) {
auto param = make_shared<op::Parameter>(element::f32, Shape{0, 1});
auto r =
make_shared<op::v1::Reshape>(param, op::Constant::create(element::i64, {1}, std::vector<int64_t>{0}), false);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{0, 1});
auto r = make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {1}, std::vector<int64_t>{0}),
false);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_shape(0), (Shape{0}));
}
TEST(type_prop, reshape_to_zero_shape_dynamic) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto r =
make_shared<op::v1::Reshape>(param, op::Constant::create(element::i64, {1}, std::vector<int64_t>{0}), false);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto r = make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {1}, std::vector<int64_t>{0}),
false);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_shape(0), (Shape{0}));
}
TEST(type_prop, reshape_to_zero_shape_incorrect) {
auto param = make_shared<op::Parameter>(element::f32, Shape{2, 1});
ASSERT_THROW(const auto unused =
make_shared<op::v1::Reshape>(param,
op::Constant::create(element::i64, {1}, std::vector<int64_t>{0}),
false),
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 1});
ASSERT_THROW(const auto unused = make_shared<op::v1::Reshape>(
param,
ov::op::v0::Constant::create(element::i64, {1}, std::vector<int64_t>{0}),
false),
std::exception);
}
TEST(type_prop, reshape_to_zero) {
auto param = make_shared<op::Parameter>(element::f32, Shape{2, 1});
auto r =
make_shared<op::v1::Reshape>(param, op::Constant::create(element::i64, {1}, std::vector<int64_t>{0}), true);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 1});
auto r = make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {1}, std::vector<int64_t>{0}),
true);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_shape(0), (Shape{2}));
}
TEST(type_prop, reshape_to_scalar) {
auto param = make_shared<op::Parameter>(element::f32, Shape{});
auto r =
make_shared<op::v1::Reshape>(param, op::Constant::create(element::i64, {}, std::vector<int64_t>{1}), false);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto r = make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {}, std::vector<int64_t>{1}),
false);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_shape(0), (Shape{}));
}
TEST(type_prop, reshape_to_scalar_2) {
auto param = make_shared<op::Parameter>(element::f32, Shape{});
auto r =
make_shared<op::v1::Reshape>(param, op::Constant::create(element::i64, {}, std::vector<int64_t>{1}), false);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{});
auto r = make_shared<op::v1::Reshape>(param,
ov::op::v0::Constant::create(element::i64, {}, std::vector<int64_t>{1}),
false);
ASSERT_EQ(r->get_element_type(), element::f32);
ASSERT_EQ(r->get_output_shape(0), (Shape{}));
}
TEST(type_prop, reshape_to_scalar_3) {
auto param = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
ASSERT_THROW(const auto unused =
make_shared<op::v1::Reshape>(param,
op::Constant::create(element::i64, {}, std::vector<int64_t>{100}),
false),
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3});
ASSERT_THROW(const auto unused = make_shared<op::v1::Reshape>(
param,
ov::op::v0::Constant::create(element::i64, {}, std::vector<int64_t>{100}),
false),
std::exception);
}
TEST(type_prop, dynamic_shape_propagation_with_i32_precision) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape{1, -1, -1});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, -1, -1});
auto shape_of = std::make_shared<op::v3::ShapeOf>(param, element::i32);
auto indices = op::Constant::create(element::i32, {3}, {1, 2, 0});
auto axis = op::Constant::create(element::i32, {1}, {0});
auto indices = ov::op::v0::Constant::create(element::i32, {3}, {1, 2, 0});
auto axis = ov::op::v0::Constant::create(element::i32, {1}, {0});
auto gather = std::make_shared<op::v1::Gather>(shape_of, indices, axis);
auto reshape = std::make_shared<op::v1::Reshape>(param, gather, true);
@ -617,9 +666,9 @@ TEST(type_prop, reshape_dynamic_value_and_label_propagation) {
ov::DimensionTracker::set_label(marked_0, 10);
PartialShape target_0 = PartialShape{marked_0, 4};
auto param = std::make_shared<op::Parameter>(element::f32, Shape{1});
auto param_0 = std::make_shared<op::Parameter>(element::f32, target_0);
auto shape_0 = std::make_shared<op::ShapeOf>(param_0);
auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
auto param_0 = std::make_shared<ov::op::v0::Parameter>(element::f32, target_0);
auto shape_0 = std::make_shared<op::v0::ShapeOf>(param_0);
const auto& et = element::i64;
std::vector<int64_t> zero{0};
@ -643,8 +692,8 @@ TEST(type_prop, reshape_label_shape_propagation_minus_one) {
PartialShape initial_shape = PartialShape{marked_0, 4, 3, 1};
auto input = std::make_shared<op::Parameter>(element::f32, initial_shape);
auto output_pattern = std::make_shared<op::Constant>(element::i64, Shape{2}, std::vector<int64_t>{-1, 12});
auto input = std::make_shared<ov::op::v0::Parameter>(element::f32, initial_shape);
auto output_pattern = std::make_shared<ov::op::v0::Constant>(element::i64, Shape{2}, std::vector<int64_t>{-1, 12});
const auto reshape = std::make_shared<op::v1::Reshape>(input, output_pattern, false);

28
src/core/tests/type_prop/result.cpp
View File

@ -2,36 +2,36 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/result.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "ngraph/opsets/opset1.hpp"
#include "openvino/op/constant.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
TEST(type_prop, result) {
const auto arg_shape = Shape{1, 2, 3, 4, 5};
auto arg = make_shared<opset1::Constant>(element::f32, arg_shape);
auto arg = make_shared<ov::op::v0::Constant>(element::f32, arg_shape);
auto result = make_shared<opset1::Result>(arg);
auto result = make_shared<ov::op::v0::Result>(arg);
EXPECT_EQ(result->get_output_element_type(0), element::f32);
EXPECT_EQ(result->get_output_shape(0), arg_shape);
}
TEST(type_prop, result_dynamic_shape) {
auto arg = make_shared<opset1::Parameter>(element::f32, PartialShape::dynamic());
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto result = make_shared<opset1::Result>(arg);
auto result = make_shared<ov::op::v0::Result>(arg);
EXPECT_EQ(result->get_output_element_type(0), element::f32);
EXPECT_TRUE(result->get_output_partial_shape(0).same_scheme(PartialShape::dynamic()));
}
TEST(type_prop, result_layout) {
auto a = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto result = make_shared<opset1::Result>(a);
auto a = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto result = make_shared<ov::op::v0::Result>(a);
result->set_layout("NHWC");
EXPECT_EQ(result->get_layout(), "NHWC");
result->set_layout(ov::Layout());
@ -40,14 +40,14 @@ TEST(type_prop, result_layout) {
}
TEST(type_prop, result_layout_empty) {
auto a = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto result = make_shared<opset1::Result>(a);
auto a = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto result = make_shared<ov::op::v0::Result>(a);
EXPECT_TRUE(result->get_layout().empty());
}
TEST(type_prop, result_layout_invalid) {
auto a = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto result = make_shared<opset1::Result>(a);
auto a = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto result = make_shared<ov::op::v0::Result>(a);
result->output(0).get_rt_info()[ov::LayoutAttribute::get_type_info_static()] = "NCHW"; // incorrect way
ASSERT_THROW(result->get_layout(), ov::Exception);
}

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

@ -2,25 +2,24 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/reverse.hpp"
#include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/opsets/opset10.hpp"
NGRAPH_SUPPRESS_DEPRECATED_START
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace testing;
class TypePropReverseV1Test : public TypePropOpTest<op::v1::Reverse> {};
TEST(type_prop, reverse_1d_deduce) {
// Deduce type
auto param = make_shared<op::Parameter>(element::f32, Shape{5});
auto rev =
make_shared<op::v1::Reverse>(param, op::Constant::create(element::i64, {1}, {0}), op::v1::Reverse::Mode::INDEX);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5});
auto rev = make_shared<op::v1::Reverse>(param,
ov::op::v0::Constant::create(element::i64, {1}, {0}),
op::v1::Reverse::Mode::INDEX);
EXPECT_EQ(rev->get_element_type(), element::f32);
EXPECT_EQ(rev->get_shape(), (Shape{5}));
@ -28,9 +27,10 @@ TEST(type_prop, reverse_1d_deduce) {
TEST(type_prop, reverse_2d_deduce_0) {
// Deduce type
auto param = make_shared<op::Parameter>(element::f32, Shape{5, 6});
auto rev =
make_shared<op::v1::Reverse>(param, op::Constant::create(element::i64, {1}, {0}), op::v1::Reverse::Mode::INDEX);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 6});
auto rev = make_shared<op::v1::Reverse>(param,
ov::op::v0::Constant::create(element::i64, {1}, {0}),
op::v1::Reverse::Mode::INDEX);
EXPECT_EQ(rev->get_element_type(), element::f32);
EXPECT_EQ(rev->get_shape(), (Shape{5, 6}));
@ -38,9 +38,10 @@ TEST(type_prop, reverse_2d_deduce_0) {
TEST(type_prop, reverse_2d_deduce_1) {
// Deduce type
auto param = make_shared<op::Parameter>(element::f32, Shape{5, 6});
auto rev =
make_shared<op::v1::Reverse>(param, op::Constant::create(element::i64, {1}, {1}), op::v1::Reverse::Mode::INDEX);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 6});
auto rev = make_shared<op::v1::Reverse>(param,
ov::op::v0::Constant::create(element::i64, {1}, {1}),
op::v1::Reverse::Mode::INDEX);
EXPECT_EQ(rev->get_element_type(), element::f32);
EXPECT_EQ(rev->get_shape(), (Shape{5, 6}));
@ -48,9 +49,9 @@ TEST(type_prop, reverse_2d_deduce_1) {
TEST(type_prop, reverse_2d_deduce_01) {
// Deduce type
auto param = make_shared<op::Parameter>(element::f32, Shape{5, 6});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 6});
auto rev = make_shared<op::v1::Reverse>(param,
op::Constant::create(element::i64, {2}, {0, 1}),
ov::op::v0::Constant::create(element::i64, {2}, {0, 1}),
op::v1::Reverse::Mode::INDEX);
EXPECT_EQ(rev->get_element_type(), element::f32);
@ -59,9 +60,10 @@ TEST(type_prop, reverse_2d_deduce_01) {
TEST(type_prop, reverse_3d_deduce_0) {
// Deduce type
auto param = make_shared<op::Parameter>(element::f32, Shape{5, 6, 7});
auto rev =
make_shared<op::v1::Reverse>(param, op::Constant::create(element::i64, {1}, {0}), op::v1::Reverse::Mode::INDEX);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 6, 7});
auto rev = make_shared<op::v1::Reverse>(param,
ov::op::v0::Constant::create(element::i64, {1}, {0}),
op::v1::Reverse::Mode::INDEX);
EXPECT_EQ(rev->get_element_type(), element::f32);
EXPECT_EQ(rev->get_shape(), (Shape{5, 6, 7}));
@ -69,9 +71,10 @@ TEST(type_prop, reverse_3d_deduce_0) {
TEST(type_prop, reverse_3d_deduce_1) {
// Deduce type
auto param = make_shared<op::Parameter>(element::f32, Shape{5, 6, 7});
auto rev =
make_shared<op::v1::Reverse>(param, op::Constant::create(element::i64, {1}, {1}), op::v1::Reverse::Mode::INDEX);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 6, 7});
auto rev = make_shared<op::v1::Reverse>(param,
ov::op::v0::Constant::create(element::i64, {1}, {1}),
op::v1::Reverse::Mode::INDEX);
EXPECT_EQ(rev->get_element_type(), element::f32);
EXPECT_EQ(rev->get_shape(), (Shape{5, 6, 7}));
@ -79,9 +82,10 @@ TEST(type_prop, reverse_3d_deduce_1) {
TEST(type_prop, reverse_3d_deduce_2) {
// Deduce type
auto param = make_shared<op::Parameter>(element::f32, Shape{5, 6, 7});
auto rev =
make_shared<op::v1::Reverse>(param, op::Constant::create(element::i64, {1}, {2}), op::v1::Reverse::Mode::INDEX);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 6, 7});
auto rev = make_shared<op::v1::Reverse>(param,
ov::op::v0::Constant::create(element::i64, {1}, {2}),
op::v1::Reverse::Mode::INDEX);
EXPECT_EQ(rev->get_element_type(), element::f32);
EXPECT_EQ(rev->get_shape(), (Shape{5, 6, 7}));
@ -89,9 +93,9 @@ TEST(type_prop, reverse_3d_deduce_2) {
TEST(type_prop, reverse_3d_deduce_01) {
// Deduce type
auto param = make_shared<op::Parameter>(element::f32, Shape{5, 6, 7});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 6, 7});
auto rev = make_shared<op::v1::Reverse>(param,
op::Constant::create(element::i64, {2}, {0, 1}),
ov::op::v0::Constant::create(element::i64, {2}, {0, 1}),
op::v1::Reverse::Mode::INDEX);
EXPECT_EQ(rev->get_element_type(), element::f32);
@ -100,9 +104,9 @@ TEST(type_prop, reverse_3d_deduce_01) {
TEST(type_prop, reverse_3d_deduce_02) {
// Deduce type
auto param = make_shared<op::Parameter>(element::f32, Shape{5, 6, 7});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 6, 7});
auto rev = make_shared<op::v1::Reverse>(param,
op::Constant::create(element::i64, {2}, {0, 2}),
ov::op::v0::Constant::create(element::i64, {2}, {0, 2}),
op::v1::Reverse::Mode::INDEX);
EXPECT_EQ(rev->get_element_type(), element::f32);
@ -111,9 +115,9 @@ TEST(type_prop, reverse_3d_deduce_02) {
TEST(type_prop, reverse_3d_deduce_12) {
// Deduce type
auto param = make_shared<op::Parameter>(element::f32, Shape{5, 6, 7});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 6, 7});
auto rev = make_shared<op::v1::Reverse>(param,
op::Constant::create(element::i64, {2}, {1, 2}),
ov::op::v0::Constant::create(element::i64, {2}, {1, 2}),
op::v1::Reverse::Mode::INDEX);
EXPECT_EQ(rev->get_element_type(), element::f32);
@ -122,9 +126,9 @@ TEST(type_prop, reverse_3d_deduce_12) {
TEST(type_prop, reverse_3d_deduce_012) {
// Deduce type
auto param = make_shared<op::Parameter>(element::f32, Shape{5, 6, 7});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 6, 7});
auto rev = make_shared<op::v1::Reverse>(param,
op::Constant::create(element::i64, {3}, {0, 1, 2}),
ov::op::v0::Constant::create(element::i64, {3}, {0, 1, 2}),
op::v1::Reverse::Mode::INDEX);
EXPECT_EQ(rev->get_element_type(), element::f32);
@ -133,10 +137,10 @@ TEST(type_prop, reverse_3d_deduce_012) {
TEST(type_prop, reverse_3d_deduce_oob) {
// Deduce type
auto param = make_shared<op::Parameter>(element::f32, Shape{5, 6, 7});
auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{5, 6, 7});
try {
auto rev = make_shared<op::v1::Reverse>(param,
op::Constant::create(element::i64, {3}, {0, 3, 2}),
ov::op::v0::Constant::create(element::i64, {3}, {0, 3, 2}),
op::v1::Reverse::Mode::INDEX);
// Should have thrown, so fail if it didn't
@ -154,9 +158,9 @@ TEST(type_prop, reverse_3d_deduce_oob) {
// If the input rank is dynamic, we should pass unconditionally.
//
TEST(type_prop, reverse_partial_rank_dynamic) {
auto param = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto rev = make_shared<op::v1::Reverse>(param,
op::Constant::create(element::i64, {4}, {0, 2, 1776, 90909}),
ov::op::v0::Constant::create(element::i64, {4}, {0, 2, 1776, 90909}),
op::v1::Reverse::Mode::INDEX);
EXPECT_EQ(rev->get_element_type(), element::f32);
@ -182,7 +186,7 @@ TEST_F(TypePropReverseV1Test, partial_rank_static_dynamic_axes_ok) {
TEST_F(TypePropReverseV1Test, axes_index_is_not_1d_tensor) {
PartialShape param_shape{Dimension::dynamic(), Dimension::dynamic(), 2, 3};
auto param = make_shared<op::Parameter>(element::f32, param_shape);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, param_shape);
auto axes = make_shared<Parameter>(element::i64, PartialShape{2, 3});
OV_EXPECT_THROW(auto op = make_op(param, axes, op::v1::Reverse::Mode::INDEX),
@ -192,7 +196,7 @@ TEST_F(TypePropReverseV1Test, axes_index_is_not_1d_tensor) {
TEST_F(TypePropReverseV1Test, axes_mask_is_not_1d_tensor) {
PartialShape param_shape{Dimension::dynamic(), Dimension::dynamic(), 2, 3};
auto param = make_shared<op::Parameter>(element::f32, param_shape);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, param_shape);
auto axes = make_shared<Parameter>(element::boolean, PartialShape{2, 3});
OV_EXPECT_THROW(auto op = make_op(param, axes, op::v1::Reverse::Mode::MASK),
@ -202,7 +206,7 @@ TEST_F(TypePropReverseV1Test, axes_mask_is_not_1d_tensor) {
TEST_F(TypePropReverseV1Test, axes_mask_length_lt_input_rank) {
PartialShape param_shape{Dimension::dynamic(), Dimension::dynamic(), 2, 3};
auto param = make_shared<op::Parameter>(element::f32, param_shape);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, param_shape);
auto axes = make_shared<Parameter>(element::boolean, PartialShape{2});
OV_EXPECT_THROW(
@ -213,7 +217,7 @@ TEST_F(TypePropReverseV1Test, axes_mask_length_lt_input_rank) {
TEST_F(TypePropReverseV1Test, axes_mask_length_gt_input_rank) {
PartialShape param_shape{Dimension::dynamic(), Dimension::dynamic(), 2, 3};
auto param = make_shared<op::Parameter>(element::f32, param_shape);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, param_shape);
auto axes = make_shared<Parameter>(element::boolean, PartialShape{5});
OV_EXPECT_THROW(
@ -264,7 +268,7 @@ TEST_F(TypePropReverseV1Test, axes_index_not_integer_type) {
TEST_F(TypePropReverseV1Test, param_static_rank_partial_shape_axes_out_of_input_rank) {
PartialShape param_shape{Dimension::dynamic(), Dimension::dynamic(), 2, 3};
auto param = make_shared<op::Parameter>(element::f32, param_shape);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, param_shape);
OV_EXPECT_THROW(
auto op = make_op(param, Constant::create(element::i64, {3}, {0, 4, 2}), op::v1::Reverse::Mode::INDEX),
@ -275,7 +279,7 @@ TEST_F(TypePropReverseV1Test, param_static_rank_partial_shape_axes_out_of_input_
TEST_F(TypePropReverseV1Test, param_static_rank_partial_shape_axes_negatives) {
PartialShape param_shape{-1, {2, -1}, {-1, 3}, 5};
set_shape_labels(param_shape, 10);
auto param = make_shared<op::Parameter>(element::f32, param_shape);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, param_shape);
auto op = make_op(param, Constant::create(element::i64, {3}, {0, -1, 2}), op::v1::Reverse::Mode::INDEX);
@ -286,7 +290,7 @@ TEST_F(TypePropReverseV1Test, param_static_rank_partial_shape_axes_negatives) {
TEST_F(TypePropReverseV1Test, more_axes_index_than_input_rank) {
PartialShape param_shape{-1, {2, -1}, {-1, 3}, 5};
auto param = make_shared<op::Parameter>(element::f32, param_shape);
auto param = make_shared<ov::op::v0::Parameter>(element::f32, param_shape);
auto op = make_op(param, Constant::create(element::i64, {7}, {0, -1, 1, 2, 3, 3, 2}), op::v1::Reverse::Mode::INDEX);

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

@ -3,12 +3,10 @@
//
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "ngraph/opsets/opset4.hpp"
#include "openvino/opsets/opset4.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
TEST(type_prop, rnn_cell) {
const size_t batch_size = 2;

1
src/core/tests/type_prop/rnn_cell_base.cpp
View File

@ -6,7 +6,6 @@
#include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gmock/gmock.h"
#include "openvino/openvino.hpp"
#include "openvino/opsets/opset12.hpp"

21
src/core/tests/type_prop/rnn_sequence.cpp
View File

@ -4,11 +4,10 @@
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "ngraph/opsets/opset5.hpp"
#include "openvino/opsets/opset5.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
TEST(type_prop, rnn_sequence_forward) {
const size_t batch_size = 8;
@ -20,7 +19,7 @@ TEST(type_prop, rnn_sequence_forward) {
const auto X = make_shared<opset5::Parameter>(element::f32, Shape{batch_size, seq_length, input_size});
const auto initial_hidden_state =
make_shared<opset5::Parameter>(element::f32, Shape{batch_size, num_directions, hidden_size});
const auto sequence_lengths = make_shared<op::Parameter>(element::i32, Shape{batch_size});
const auto sequence_lengths = make_shared<ov::op::v0::Parameter>(element::i32, Shape{batch_size});
const auto W = make_shared<opset5::Parameter>(element::f32, Shape{num_directions, hidden_size, input_size});
const auto R = make_shared<opset5::Parameter>(element::f32, Shape{num_directions, hidden_size, hidden_size});
@ -53,7 +52,7 @@ TEST(type_prop, rnn_sequence_invalid_input) {
auto X = make_shared<opset5::Parameter>(element::f32, Shape{batch_size, seq_length, input_size});
auto H_t = make_shared<opset5::Parameter>(element::f32, Shape{batch_size, num_directions, hidden_size});
const auto sequence_lengths = make_shared<op::Parameter>(element::i32, Shape{batch_size});
const auto sequence_lengths = make_shared<ov::op::v0::Parameter>(element::i32, Shape{batch_size});
auto W = make_shared<opset5::Parameter>(element::f32, Shape{num_directions, hidden_size, input_size});
auto R = make_shared<opset5::Parameter>(element::f32, Shape{num_directions, hidden_size, hidden_size});
@ -144,7 +143,7 @@ TEST(type_prop, rnn_sequence_dynamic_inputs) {
const auto X = make_shared<opset5::Parameter>(element::f32, PartialShape{batch_size, seq_length, input_size});
const auto H_t =
make_shared<opset5::Parameter>(element::f32, PartialShape{batch_size, num_directions, hidden_size});
const auto sequence_lengths = make_shared<op::Parameter>(element::i32, PartialShape{batch_size});
const auto sequence_lengths = make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{batch_size});
const auto W = make_shared<opset5::Parameter>(element::f32, PartialShape{num_directions, hidden_size, input_size});
const auto R = make_shared<opset5::Parameter>(element::f32, PartialShape{num_directions, hidden_size, hidden_size});
@ -172,7 +171,7 @@ TEST(type_prop, rnn_sequence_dynamic_batch_size) {
const auto X = make_shared<opset5::Parameter>(element::f32, PartialShape{batch_size, seq_length, input_size});
const auto H_t =
make_shared<opset5::Parameter>(element::f32, PartialShape{batch_size, num_directions, hidden_size});
const auto sequence_lengths = make_shared<op::Parameter>(element::i32, PartialShape{batch_size});
const auto sequence_lengths = make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{batch_size});
const auto W = make_shared<opset5::Parameter>(element::f32, PartialShape{num_directions, hidden_size, input_size});
const auto R = make_shared<opset5::Parameter>(element::f32, PartialShape{num_directions, hidden_size, hidden_size});
@ -200,7 +199,7 @@ TEST(type_prop, rnn_sequence_dynamic_input_size) {
const auto X = make_shared<opset5::Parameter>(element::f32, PartialShape{batch_size, seq_length, input_size});
const auto H_t =
make_shared<opset5::Parameter>(element::f32, PartialShape{batch_size, num_directions, hidden_size});
const auto sequence_lengths = make_shared<op::Parameter>(element::i32, PartialShape{batch_size});
const auto sequence_lengths = make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{batch_size});
const auto W = make_shared<opset5::Parameter>(element::f32, PartialShape{num_directions, hidden_size, input_size});
const auto R = make_shared<opset5::Parameter>(element::f32, PartialShape{num_directions, hidden_size, hidden_size});
@ -228,7 +227,7 @@ TEST(type_prop, rnn_sequence_dynamic_hidden_size) {
const auto X = make_shared<opset5::Parameter>(element::f32, PartialShape{batch_size, seq_length, input_size});
const auto H_t =
make_shared<opset5::Parameter>(element::f32, PartialShape{batch_size, num_directions, hidden_size});
const auto sequence_lengths = make_shared<op::Parameter>(element::i32, PartialShape{batch_size});
const auto sequence_lengths = make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{batch_size});
const auto W = make_shared<opset5::Parameter>(element::f32, PartialShape{num_directions, hidden_size, input_size});
const auto R = make_shared<opset5::Parameter>(element::f32, PartialShape{num_directions, hidden_size, hidden_size});
@ -255,7 +254,7 @@ TEST(type_prop, rnn_sequence_dynamic_invalid_input_rank0) {
auto X = make_shared<opset5::Parameter>(element::f32, Shape{batch_size, seq_length, input_size});
auto H_t = make_shared<opset5::Parameter>(element::f32, Shape{batch_size, num_directions, hidden_size});
const auto sequence_lengths = make_shared<op::Parameter>(element::i32, Shape{batch_size});
const auto sequence_lengths = make_shared<ov::op::v0::Parameter>(element::i32, Shape{batch_size});
auto W = make_shared<opset5::Parameter>(element::f32, Shape{num_directions, hidden_size, input_size});
auto R = make_shared<opset5::Parameter>(element::f32, Shape{num_directions, hidden_size, hidden_size});
@ -312,7 +311,7 @@ TEST(type_prop, rnn_sequence_input_dynamic_rank) {
auto X = make_shared<opset5::Parameter>(element::f32, PartialShape{batch_size, seq_length, input_size});
auto H_t = make_shared<opset5::Parameter>(element::f32, PartialShape{batch_size, num_directions, hidden_size});
const auto sequence_lengths = make_shared<op::Parameter>(element::i32, PartialShape{batch_size});
const auto sequence_lengths = make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{batch_size});
auto W = make_shared<opset5::Parameter>(element::f32, PartialShape{num_directions, hidden_size, input_size});
auto R = make_shared<opset5::Parameter>(element::f32, PartialShape{num_directions, hidden_size, hidden_size});

29
src/core/tests/type_prop/round.cpp
View File

@ -2,53 +2,56 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/round.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/op/parameter.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
TEST(type_prop, rounding_to_even) {
auto data = make_shared<op::Parameter>(element::f32, Shape{1, 3, 6});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 6});
auto round_func = make_shared<op::v5::Round>(data, op::v5::Round::RoundMode::HALF_TO_EVEN);
EXPECT_EQ(round_func->get_element_type(), element::f32);
EXPECT_EQ(round_func->get_shape(), (Shape{1, 3, 6}));
}
TEST(type_prop, rounding_away) {
auto data = make_shared<op::Parameter>(element::f32, Shape{1, 3, 6});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 6});
auto round_func = make_shared<op::v5::Round>(data, op::v5::Round::RoundMode::HALF_AWAY_FROM_ZERO);
EXPECT_EQ(round_func->get_element_type(), element::f32);
EXPECT_EQ(round_func->get_shape(), (Shape{1, 3, 6}));
}
TEST(type_prop, rounding_to_even_partial) {
auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto round_func = make_shared<op::v5::Round>(data, op::v5::Round::RoundMode::HALF_TO_EVEN);
EXPECT_EQ(round_func->get_element_type(), element::f32);
ASSERT_TRUE(round_func->get_output_partial_shape(0).same_scheme((PartialShape{1, Dimension::dynamic(), 6})));
// rank unknown
auto round_partial = make_shared<op::v5::Round>(make_shared<op::Parameter>(element::f32, PartialShape::dynamic()),
op::v5::Round::RoundMode::HALF_TO_EVEN);
auto round_partial =
make_shared<op::v5::Round>(make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic()),
op::v5::Round::RoundMode::HALF_TO_EVEN);
ASSERT_TRUE(round_partial->get_output_partial_shape(0).same_scheme(PartialShape::dynamic()));
}
TEST(type_prop, rounding_away_partial) {
auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto round_func = make_shared<op::v5::Round>(data, op::v5::Round::RoundMode::HALF_AWAY_FROM_ZERO);
EXPECT_EQ(round_func->get_element_type(), element::f32);
ASSERT_TRUE(round_func->get_output_partial_shape(0).same_scheme((PartialShape{1, Dimension::dynamic(), 6})));
// rank unknown
auto round_partial = make_shared<op::v5::Round>(make_shared<op::Parameter>(element::f32, PartialShape::dynamic()),
op::v5::Round::RoundMode::HALF_AWAY_FROM_ZERO);
auto round_partial =
make_shared<op::v5::Round>(make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic()),
op::v5::Round::RoundMode::HALF_AWAY_FROM_ZERO);
ASSERT_TRUE(round_partial->get_output_partial_shape(0).same_scheme(PartialShape::dynamic()));
}
TEST(type_prop, rounding_to_even_partial_static_rank) {
auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto round_func = make_shared<op::v5::Round>(data, op::v5::Round::RoundMode::HALF_TO_EVEN);
EXPECT_EQ(round_func->get_element_type(), element::f32);
ASSERT_TRUE(round_func->get_output_partial_shape(0).same_scheme((PartialShape{1, Dimension::dynamic(), 6})));
@ -56,7 +59,7 @@ TEST(type_prop, rounding_to_even_partial_static_rank) {
}
TEST(type_prop, rounding_away_partial_static_rank) {
auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto round_func = make_shared<op::v5::Round>(data, op::v5::Round::RoundMode::HALF_AWAY_FROM_ZERO);
EXPECT_EQ(round_func->get_element_type(), element::f32);
ASSERT_TRUE(round_func->get_output_partial_shape(0).same_scheme((PartialShape{1, Dimension::dynamic(), 6})));

17
src/core/tests/type_prop/scatter_elements_update.cpp
View File

@ -2,10 +2,13 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/scatter_elements_update.hpp"
#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/broadcast.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/shape_of.hpp"
using namespace std;
using namespace ov;
@ -191,11 +194,11 @@ TEST(type_prop, scatter_elements_update_mean_reduction_of_bool) {
const auto axis = make_shared<op::v0::Constant>(element::i32, Shape{1}, std::vector<int>{0});
OV_EXPECT_THROW(
std::ignore = make_shared<op::v12::ScatterElementsUpdate>(data,
indices,
updates,
axis,
op::v12::ScatterElementsUpdate::Reduction::MEAN),
std::ignore = make_shared<ov::op::v12::ScatterElementsUpdate>(data,
indices,
updates,
axis,
op::v12::ScatterElementsUpdate::Reduction::MEAN),
NodeValidationFailure,
HasSubstr("The 'mean' reduction type is not supported for boolean tensors"));
}

49
src/core/tests/type_prop/scatter_nd_update.cpp
View File

@ -2,21 +2,22 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/scatter_nd_update.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/op/shape_of.hpp"
#include "openvino/opsets/opset10.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
TEST(type_prop, scatter_nd_update_v3_fail_indices_element_type) {
Shape ref_shape{2, 3, 4};
Shape indices_shape{2, 1};
Shape updates_shape{2, 2, 1, 4};
auto R = make_shared<op::Parameter>(element::f32, ref_shape);
auto I = make_shared<op::Parameter>(element::f16, indices_shape);
auto U = make_shared<op::Parameter>(element::f32, updates_shape);
auto R = make_shared<ov::op::v0::Parameter>(element::f32, ref_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::f16, indices_shape);
auto U = make_shared<ov::op::v0::Parameter>(element::f32, updates_shape);
try {
auto G = make_shared<op::v3::ScatterNDUpdate>(R, I, U);
// Should have thrown, so fail if it didn't
@ -33,11 +34,11 @@ TEST(type_prop, scatter_nd_update_v3_fail_updates_rank) {
Shape indices_shape{1};
Shape updates_shape{3, 3, 3};
Shape out_shape{3, 3, 3};
auto R = make_shared<op::Parameter>(element::f32, ref_shape);
auto I = make_shared<op::Parameter>(element::i32, indices_shape);
auto U = make_shared<op::Parameter>(element::f32, updates_shape);
auto R = make_shared<ov::op::v0::Parameter>(element::f32, ref_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i32, indices_shape);
auto U = make_shared<ov::op::v0::Parameter>(element::f32, updates_shape);
try {
auto G = make_shared<op::ScatterNDUpdate>(R, I, U);
auto G = make_shared<op::v3::ScatterNDUpdate>(R, I, U);
// Should have thrown, so fail if it didn't
FAIL() << "Incorrect updates rank";
} catch (const NodeValidationFailure& error) {
@ -54,11 +55,11 @@ TEST(type_prop, scatter_nd_update_fail_updates_element_type) {
Shape indices_shape{1};
Shape updates_shape{3, 3};
Shape out_shape{3, 3, 3};
auto R = make_shared<op::Parameter>(element::f32, ref_shape);
auto I = make_shared<op::Parameter>(element::i32, indices_shape);
auto U = make_shared<op::Parameter>(element::i32, updates_shape);
auto R = make_shared<ov::op::v0::Parameter>(element::f32, ref_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i32, indices_shape);
auto U = make_shared<ov::op::v0::Parameter>(element::i32, updates_shape);
try {
auto G = make_shared<op::ScatterNDUpdate>(R, I, U);
auto G = make_shared<op::v3::ScatterNDUpdate>(R, I, U);
// Should have thrown, so fail if it didn't
FAIL() << "Created ScatterND op with incorrect updates element type.";
} catch (const NodeValidationFailure& error) {
@ -73,11 +74,11 @@ TEST(type_prop, scatter_nd_update_fail_updates_shape) {
Shape indices_shape{1};
Shape updates_shape{2, 3};
Shape out_shape{3, 3, 3};
auto R = make_shared<op::Parameter>(element::f32, ref_shape);
auto I = make_shared<op::Parameter>(element::i32, indices_shape);
auto U = make_shared<op::Parameter>(element::f32, updates_shape);
auto R = make_shared<ov::op::v0::Parameter>(element::f32, ref_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i32, indices_shape);
auto U = make_shared<ov::op::v0::Parameter>(element::f32, updates_shape);
try {
auto G = make_shared<op::ScatterNDUpdate>(R, I, U);
auto G = make_shared<op::v3::ScatterNDUpdate>(R, I, U);
// Should have thrown, so fail if it didn't
FAIL() << "Incorrect updates shape";
} catch (const NodeValidationFailure& error) {
@ -94,11 +95,11 @@ TEST(type_prop, scatter_nd_update_fail_indices_last_dim) {
Shape indices_shape{2, 4};
Shape updates_shape{2, 3, 3};
Shape out_shape{3, 3, 3};
auto R = make_shared<op::Parameter>(element::f32, ref_shape);
auto I = make_shared<op::Parameter>(element::i32, indices_shape);
auto U = make_shared<op::Parameter>(element::f32, updates_shape);
auto R = make_shared<ov::op::v0::Parameter>(element::f32, ref_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i32, indices_shape);
auto U = make_shared<ov::op::v0::Parameter>(element::f32, updates_shape);
try {
auto G = make_shared<op::ScatterNDUpdate>(R, I, U);
auto G = make_shared<op::v3::ScatterNDUpdate>(R, I, U);
// Should have thrown, so fail if it didn't
FAIL() << "Incorrect indices innermost dim";
} catch (const NodeValidationFailure& error) {
@ -200,10 +201,10 @@ TEST_F(TypePropScatterUpdateNDV3Test, preserve_partial_values_and_labels_via_eva
auto u_shape = PartialShape{{10, 20}, {3, 4}};
set_shape_labels(u_shape, 20);
const auto shape_of_u = std::make_shared<op::ShapeOf>(std::make_shared<Parameter>(element::i64, u_shape));
const auto shape_of_u = std::make_shared<op::v0::ShapeOf>(std::make_shared<Parameter>(element::i64, u_shape));
const auto op = make_op(d, i, shape_of_u);
auto param = std::make_shared<op::Parameter>(element::f32, PartialShape{1});
auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1});
auto bc = std::make_shared<op::v3::Broadcast>(param, op, op::BroadcastType::BIDIRECTIONAL);
EXPECT_EQ(bc->get_output_partial_shape(0), PartialShape({{3, 4}, 3, {10, 20}, 4}));

83
src/core/tests/type_prop/scatter_update.cpp
View File

@ -2,14 +2,19 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/scatter_update.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/core/dimension_tracker.hpp"
#include "openvino/op/broadcast.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/parameter.hpp"
#include "openvino/op/reshape.hpp"
#include "openvino/op/shape_of.hpp"
#include "openvino/op/strided_slice.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace testing;
namespace {
@ -18,10 +23,10 @@ void type_check(const type& refType) {
Shape ref_shape{2, 3, 4};
Shape indices_shape{2, 1};
Shape updates_shape{2, 2, 1, 4};
auto R = make_shared<op::Parameter>(refType, ref_shape);
auto I = make_shared<op::Parameter>(element::i32, indices_shape);
auto U = make_shared<op::Parameter>(refType, updates_shape);
auto A = op::Constant::create(element::i32, Shape{1}, {1});
auto R = make_shared<ov::op::v0::Parameter>(refType, ref_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i32, indices_shape);
auto U = make_shared<ov::op::v0::Parameter>(refType, updates_shape);
auto A = ov::op::v0::Constant::create(element::i32, Shape{1}, {1});
auto scatter_update = make_shared<op::v3::ScatterUpdate>(R, I, U, A);
EXPECT_EQ(scatter_update->get_output_element_type(0), refType);
EXPECT_EQ(scatter_update->get_output_shape(0), ref_shape);
@ -35,10 +40,10 @@ void incorrect_type_check(const type& refType,
Shape ref_shape{2, 3, 4};
Shape indices_shape{2, 1};
Shape updates_shape{2, 2, 1, 4};
auto R = make_shared<op::Parameter>(refType, ref_shape);
auto I = make_shared<op::Parameter>(indicesType, indices_shape);
auto U = make_shared<op::Parameter>(updatesType, updates_shape);
auto A = op::Constant::create(axisType, Shape{1}, {1});
auto R = make_shared<ov::op::v0::Parameter>(refType, ref_shape);
auto I = make_shared<ov::op::v0::Parameter>(indicesType, indices_shape);
auto U = make_shared<ov::op::v0::Parameter>(updatesType, updates_shape);
auto A = ov::op::v0::Constant::create(axisType, Shape{1}, {1});
try {
auto G = make_shared<op::v3::ScatterUpdate>(R, I, U, A);
// Should have thrown, so fail if it didn't
@ -59,10 +64,10 @@ void incorrect_shape_check(const Shape& refShape,
Shape ref_shape{2, 3, 4};
Shape indices_shape{2, 1};
Shape updates_shape{2, 2, 1, 4};
auto R = make_shared<op::Parameter>(element::f32, refShape);
auto I = make_shared<op::Parameter>(element::i32, indicesShape);
auto U = make_shared<op::Parameter>(element::f32, updatesShape);
auto A = op::Constant::create(element::i32, axisShape, {axisVal});
auto R = make_shared<ov::op::v0::Parameter>(element::f32, refShape);
auto I = make_shared<ov::op::v0::Parameter>(element::i32, indicesShape);
auto U = make_shared<ov::op::v0::Parameter>(element::f32, updatesShape);
auto A = ov::op::v0::Constant::create(element::i32, axisShape, {axisVal});
try {
auto G = make_shared<op::v3::ScatterUpdate>(R, I, U, A);
// Should have thrown, so fail if it didn't
@ -201,10 +206,10 @@ TEST(type_prop, scatter_update_v3_dynamic_data_shape) {
PartialShape ref_shape = PartialShape::dynamic();
Shape indices_shape{2, 1};
Shape updates_shape{2, 2, 1, 4};
auto R = make_shared<op::Parameter>(element::i8, ref_shape);
auto I = make_shared<op::Parameter>(element::i16, indices_shape);
auto U = make_shared<op::Parameter>(element::i8, updates_shape);
auto A = op::Constant::create(element::i16, Shape{}, {1});
auto R = make_shared<ov::op::v0::Parameter>(element::i8, ref_shape);
auto I = make_shared<ov::op::v0::Parameter>(element::i16, indices_shape);
auto U = make_shared<ov::op::v0::Parameter>(element::i8, updates_shape);
auto A = ov::op::v0::Constant::create(element::i16, Shape{}, {1});
auto scatter_update = make_shared<op::v3::ScatterUpdate>(R, I, U, A);
EXPECT_EQ(scatter_update->get_output_element_type(0), element::i8);
@ -219,10 +224,10 @@ TEST(type_prop, scatter_update_v3_interval_label_data_shape) {
Shape indices_shape{2, 1};
Shape updates_shape{3, 2, 1, 2, 4};
auto data = make_shared<op::Parameter>(element::f32, data_shape);
auto idx = make_shared<op::Parameter>(element::i32, indices_shape);
auto updates = make_shared<op::Parameter>(element::f32, updates_shape);
auto axis = op::Constant::create(element::i32, Shape{}, {1});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_shape);
auto idx = make_shared<ov::op::v0::Parameter>(element::i32, indices_shape);
auto updates = make_shared<ov::op::v0::Parameter>(element::f32, updates_shape);
auto axis = ov::op::v0::Constant::create(element::i32, Shape{}, {1});
auto scatter_update = make_shared<op::v3::ScatterUpdate>(data, idx, updates, axis);
@ -238,14 +243,15 @@ TEST(type_prop, scatter_update_v3_value_label_propagation) {
ov::DimensionTracker::set_label(labeled_dim, label);
PartialShape data_shape = PartialShape{labeled_dim};
auto data = make_shared<op::Parameter>(element::i8, data_shape);
auto data = make_shared<ov::op::v0::Parameter>(element::i8, data_shape);
auto shape_of = make_shared<op::v3::ShapeOf>(data);
auto scatter_update = make_shared<op::v3::ScatterUpdate>(op::Constant::create(element::i64, Shape{2}, {1, 0}),
op::Constant::create(element::i64, Shape{1}, {1}),
shape_of,
op::Constant::create(element::i64, Shape{1}, {0}));
auto scatter_update =
make_shared<op::v3::ScatterUpdate>(ov::op::v0::Constant::create(element::i64, Shape{2}, {1, 0}),
ov::op::v0::Constant::create(element::i64, Shape{1}, {1}),
shape_of,
ov::op::v0::Constant::create(element::i64, Shape{1}, {0}));
auto broadcast =
make_shared<op::v3::Broadcast>(op::Constant::create(element::i64, Shape{1, 1}, {4}), scatter_update);
make_shared<op::v3::Broadcast>(ov::op::v0::Constant::create(element::i64, Shape{1, 1}, {4}), scatter_update);
const auto& output_shape = broadcast->get_output_partial_shape(0);
EXPECT_EQ(output_shape, PartialShape({1, {5, 7}}));
@ -255,18 +261,19 @@ TEST(type_prop, scatter_update_v3_value_label_propagation) {
TEST(type_prop, scatter_update_v3_partial_value_propagation) {
// strided slice should take from 5 to 7 elements from the 10 elements in the input data
auto input = make_shared<op::Parameter>(element::i8, PartialShape{ov::Dimension(5, 7)});
auto input = make_shared<ov::op::v0::Parameter>(element::i8, PartialShape{ov::Dimension(5, 7)});
auto shape = make_shared<op::v3::ShapeOf>(input);
auto scatter_update = make_shared<op::v3::ScatterUpdate>(op::Constant::create(element::i64, Shape{2}, {1, 0}),
op::Constant::create(element::i64, Shape{1}, {1}),
shape,
op::Constant::create(element::i64, Shape{1}, {0}));
auto scatter_update =
make_shared<op::v3::ScatterUpdate>(ov::op::v0::Constant::create(element::i64, Shape{2}, {1, 0}),
ov::op::v0::Constant::create(element::i64, Shape{1}, {1}),
shape,
ov::op::v0::Constant::create(element::i64, Shape{1}, {0}));
const auto& masks = std::vector<int64_t>(0, 2);
const auto& strided_slice = make_shared<op::v1::StridedSlice>(
op::Constant::create(element::i64, Shape{1, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 0}),
op::Constant::create(element::i64, Shape{2}, {0, 0}),
ov::op::v0::Constant::create(element::i64, Shape{1, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 0}),
ov::op::v0::Constant::create(element::i64, Shape{2}, {0, 0}),
scatter_update,
op::Constant::create(element::i64, Shape{2}, {1, 1}),
ov::op::v0::Constant::create(element::i64, Shape{2}, {1, 1}),
masks,
masks);

183
src/core/tests/type_prop/select.cpp
View File

@ -2,29 +2,27 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/select.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/core/dimension_tracker.hpp"
NGRAPH_SUPPRESS_DEPRECATED_START
using namespace std;
using namespace ngraph;
using namespace ov;
TEST(type_prop, select_deduce) {
auto tv0_2_4_param_0 = make_shared<op::Parameter>(element::boolean, Shape{2, 4});
auto tv0_2_4_param_1 = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto tv0_2_4_param_2 = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto tv0_2_4_param_0 = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{2, 4});
auto tv0_2_4_param_1 = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
auto tv0_2_4_param_2 = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
auto bc = make_shared<op::v1::Select>(tv0_2_4_param_0, tv0_2_4_param_1, tv0_2_4_param_2);
ASSERT_EQ(bc->get_element_type(), element::f32);
ASSERT_EQ(bc->get_shape(), (Shape{2, 4}));
}
TEST(type_prop, select_default_constructor) {
auto cond_param = make_shared<op::Parameter>(element::boolean, Shape{2, 4});
auto then_param = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto else_param = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto cond_param = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{2, 4});
auto then_param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
auto else_param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
auto op = make_shared<op::v1::Select>();
EXPECT_EQ(op->get_auto_broadcast().m_type, op::AutoBroadcastType::NUMPY);
@ -47,9 +45,9 @@ TEST(type_prop, select_labels_cond_numpy) {
set_shape_labels(labeled_shape, 10);
ov::TensorLabel expected_labels{10, 11, 12, ov::no_label, 14};
auto cond_param = make_shared<op::Parameter>(element::boolean, labeled_shape);
auto then_param = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(5));
auto else_param = make_shared<op::Parameter>(element::f32, PartialShape({{1, 5}, {1, 11}, 5, {1, 8}}));
auto cond_param = make_shared<ov::op::v0::Parameter>(element::boolean, labeled_shape);
auto then_param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(5));
auto else_param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape({{1, 5}, {1, 11}, 5, {1, 8}}));
auto op = make_shared<op::v1::Select>(cond_param, then_param, else_param);
const auto& out_shape = op->get_output_partial_shape(0);
@ -65,9 +63,9 @@ TEST(type_prop, select_labels_then_numpy) {
ov::TensorLabel expected_labels{ov::no_label, ov::no_label, 12, ov::no_label, 14};
auto cond_param =
make_shared<op::Parameter>(element::boolean, PartialShape{{2, 8}, {3, 7}, {1, 10}, {1, 6}, {1, 10}});
auto then_param = make_shared<op::Parameter>(element::f32, labeled_shape);
auto else_param = make_shared<op::Parameter>(element::f32, PartialShape({{1, 5}, {1, 11}, 5, {1, 8}}));
make_shared<ov::op::v0::Parameter>(element::boolean, PartialShape{{2, 8}, {3, 7}, {1, 10}, {1, 6}, {1, 10}});
auto then_param = make_shared<ov::op::v0::Parameter>(element::f32, labeled_shape);
auto else_param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape({{1, 5}, {1, 11}, 5, {1, 8}}));
auto op = make_shared<op::v1::Select>(cond_param, then_param, else_param);
const auto& out_shape = op->get_output_partial_shape(0);
@ -84,9 +82,9 @@ TEST(type_prop, select_labels_else_numpy) {
ov::TensorLabel expected_labels{ov::no_label, ov::no_label, 11, 12, 13};
auto cond_param =
make_shared<op::Parameter>(element::boolean, PartialShape{{2, 8}, {3, 7}, {1, 10}, {1, 6}, {1, 10}});
auto then_param = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(5));
auto else_param = make_shared<op::Parameter>(element::f32, labeled_shape);
make_shared<ov::op::v0::Parameter>(element::boolean, PartialShape{{2, 8}, {3, 7}, {1, 10}, {1, 6}, {1, 10}});
auto then_param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(5));
auto else_param = make_shared<ov::op::v0::Parameter>(element::f32, labeled_shape);
auto op = make_shared<op::v1::Select>(cond_param, then_param, else_param);
const auto& out_shape = op->get_output_partial_shape(0);
@ -107,9 +105,9 @@ TEST(type_prop, select_labels_all_params_numpy) {
ov::TensorLabel expected_labels{10, 11, 22, 13, 34, 15, 26, 17, 18};
auto cond_param = make_shared<op::Parameter>(element::boolean, labeled_shape_cond);
auto then_param = make_shared<op::Parameter>(element::f32, labeled_shape_then);
auto else_param = make_shared<op::Parameter>(element::f32, labeled_shape_else);
auto cond_param = make_shared<ov::op::v0::Parameter>(element::boolean, labeled_shape_cond);
auto then_param = make_shared<ov::op::v0::Parameter>(element::f32, labeled_shape_then);
auto else_param = make_shared<ov::op::v0::Parameter>(element::f32, labeled_shape_else);
auto op = make_shared<op::v1::Select>(cond_param, then_param, else_param);
const auto& out_shape = op->get_output_partial_shape(0);
@ -130,9 +128,9 @@ TEST(type_prop, select_labels_all_params_none) {
ov::TensorLabel expected_labels{10, 11, 12, 13, 14, 15, 16, 17, 18};
auto cond_param = make_shared<op::Parameter>(element::boolean, labeled_shape_cond);
auto then_param = make_shared<op::Parameter>(element::f32, labeled_shape_then);
auto else_param = make_shared<op::Parameter>(element::f32, labeled_shape_else);
auto cond_param = make_shared<ov::op::v0::Parameter>(element::boolean, labeled_shape_cond);
auto then_param = make_shared<ov::op::v0::Parameter>(element::f32, labeled_shape_then);
auto else_param = make_shared<ov::op::v0::Parameter>(element::f32, labeled_shape_else);
auto op = make_shared<op::v1::Select>(cond_param, then_param, else_param, op::AutoBroadcastType::NONE);
const auto& out_shape = op->get_output_partial_shape(0);
@ -153,9 +151,9 @@ TEST(type_prop, select_labels_all_params_pdpd) {
ov::TensorLabel expected_labels{10, 11, 22, 33, 24, 25, 26, 17, 18};
auto cond_param = make_shared<op::Parameter>(element::boolean, labeled_shape_cond);
auto then_param = make_shared<op::Parameter>(element::f32, labeled_shape_then);
auto else_param = make_shared<op::Parameter>(element::f32, labeled_shape_else);
auto cond_param = make_shared<ov::op::v0::Parameter>(element::boolean, labeled_shape_cond);
auto then_param = make_shared<ov::op::v0::Parameter>(element::f32, labeled_shape_then);
auto else_param = make_shared<ov::op::v0::Parameter>(element::f32, labeled_shape_else);
auto op = make_shared<op::v1::Select>(cond_param,
then_param,
else_param,
@ -170,18 +168,18 @@ TEST(type_prop, select_labels_all_params_pdpd) {
TEST(type_prop, select_dynamic) {
auto param_0 =
make_shared<op::Parameter>(element::boolean, PartialShape({{2, 8}, {3, 7}, {1, 10}, {1, 6}, {1, 10}}));
auto param_1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic(5));
auto param_2 = make_shared<op::Parameter>(element::f32, PartialShape({{1, 5}, {1, 11}, 5, {1, 8}}));
make_shared<ov::op::v0::Parameter>(element::boolean, PartialShape({{2, 8}, {3, 7}, {1, 10}, {1, 6}, {1, 10}}));
auto param_1 = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic(5));
auto param_2 = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape({{1, 5}, {1, 11}, 5, {1, 8}}));
auto bc = make_shared<op::v1::Select>(param_0, param_1, param_2);
ASSERT_EQ(bc->get_element_type(), element::f32);
ASSERT_EQ(bc->get_output_partial_shape(0), PartialShape({{2, 8}, {3, 7}, -1, 5, -1}));
}
TEST(type_prop, select_shape_mismatch_a) {
auto tv0_2_4_param_0 = make_shared<op::Parameter>(element::boolean, Shape{3, 5});
auto tv0_2_4_param_1 = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto tv0_2_4_param_2 = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto tv0_2_4_param_0 = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{3, 5});
auto tv0_2_4_param_1 = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
auto tv0_2_4_param_2 = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
try {
auto bc = make_shared<op::v1::Select>(tv0_2_4_param_0, tv0_2_4_param_1, tv0_2_4_param_2);
// Should have thrown, so fail if it didn't
@ -194,9 +192,9 @@ TEST(type_prop, select_shape_mismatch_a) {
}
TEST(type_prop, select_shape_mismatch_b) {
auto tv0_2_4_param_0 = make_shared<op::Parameter>(element::boolean, Shape{2, 4});
auto tv0_2_4_param_1 = make_shared<op::Parameter>(element::f32, Shape{3, 5});
auto tv0_2_4_param_2 = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto tv0_2_4_param_0 = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{2, 4});
auto tv0_2_4_param_1 = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 5});
auto tv0_2_4_param_2 = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
try {
auto bc = make_shared<op::v1::Select>(tv0_2_4_param_0, tv0_2_4_param_1, tv0_2_4_param_2);
// Should have thrown, so fail if it didn't
@ -209,9 +207,9 @@ TEST(type_prop, select_shape_mismatch_b) {
}
TEST(type_prop, select_shape_mismatch_c) {
auto tv0_2_4_param_0 = make_shared<op::Parameter>(element::boolean, Shape{2, 4});
auto tv0_2_4_param_1 = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto tv0_2_4_param_2 = make_shared<op::Parameter>(element::f32, Shape{3, 5});
auto tv0_2_4_param_0 = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{2, 4});
auto tv0_2_4_param_1 = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
auto tv0_2_4_param_2 = make_shared<ov::op::v0::Parameter>(element::f32, Shape{3, 5});
try {
auto bc = make_shared<op::v1::Select>(tv0_2_4_param_0, tv0_2_4_param_1, tv0_2_4_param_2);
// Should have thrown, so fail if it didn't
@ -224,9 +222,9 @@ TEST(type_prop, select_shape_mismatch_c) {
}
TEST(type_prop, select_elem_mismatch_a) {
auto tv0_2_4_param_0 = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto tv0_2_4_param_1 = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto tv0_2_4_param_2 = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto tv0_2_4_param_0 = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
auto tv0_2_4_param_1 = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
auto tv0_2_4_param_2 = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
try {
auto bc = make_shared<op::v1::Select>(tv0_2_4_param_0, tv0_2_4_param_1, tv0_2_4_param_2);
// Should have thrown, so fail if it didn't
@ -239,9 +237,9 @@ TEST(type_prop, select_elem_mismatch_a) {
}
TEST(type_prop, select_elem_mismatch_bc) {
auto tv0_2_4_param_0 = make_shared<op::Parameter>(element::boolean, Shape{2, 4});
auto tv0_2_4_param_1 = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto tv0_2_4_param_2 = make_shared<op::Parameter>(element::i32, Shape{2, 4});
auto tv0_2_4_param_0 = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{2, 4});
auto tv0_2_4_param_1 = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
auto tv0_2_4_param_2 = make_shared<ov::op::v0::Parameter>(element::i32, Shape{2, 4});
try {
auto bc = make_shared<op::v1::Select>(tv0_2_4_param_0, tv0_2_4_param_1, tv0_2_4_param_2);
// Should have thrown, so fail if it didn't
@ -254,9 +252,9 @@ TEST(type_prop, select_elem_mismatch_bc) {
}
TEST(type_prop, select_partial_all_rank_dynamic) {
auto param0 = make_shared<op::Parameter>(element::boolean, PartialShape::dynamic());
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto param2 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto param0 = make_shared<ov::op::v0::Parameter>(element::boolean, PartialShape::dynamic());
auto param1 = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto param2 = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto sel = make_shared<op::v1::Select>(param0, param1, param2);
@ -265,9 +263,9 @@ TEST(type_prop, select_partial_all_rank_dynamic) {
}
TEST(type_prop, select_partial_all_rank_dynamic_arg0_et_dynamic_arg1_arg2_et_mismatch) {
auto param0 = make_shared<op::Parameter>(element::dynamic, PartialShape::dynamic());
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto param2 = make_shared<op::Parameter>(element::i32, PartialShape::dynamic());
auto param0 = make_shared<ov::op::v0::Parameter>(element::dynamic, PartialShape::dynamic());
auto param1 = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto param2 = make_shared<ov::op::v0::Parameter>(element::i32, PartialShape::dynamic());
try {
auto sel = make_shared<op::v1::Select>(param0, param1, param2);
@ -281,9 +279,9 @@ TEST(type_prop, select_partial_all_rank_dynamic_arg0_et_dynamic_arg1_arg2_et_mis
}
TEST(type_prop, select_partial_all_rank_dynamic_arg0_arg1_et_dynamic) {
auto param0 = make_shared<op::Parameter>(element::dynamic, PartialShape::dynamic());
auto param1 = make_shared<op::Parameter>(element::dynamic, PartialShape::dynamic());
auto param2 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto param0 = make_shared<ov::op::v0::Parameter>(element::dynamic, PartialShape::dynamic());
auto param1 = make_shared<ov::op::v0::Parameter>(element::dynamic, PartialShape::dynamic());
auto param2 = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto sel = make_shared<op::v1::Select>(param0, param1, param2);
@ -292,9 +290,9 @@ TEST(type_prop, select_partial_all_rank_dynamic_arg0_arg1_et_dynamic) {
}
TEST(type_prop, select_partial_all_rank_dynamic_arg0_arg2_et_dynamic) {
auto param0 = make_shared<op::Parameter>(element::dynamic, PartialShape::dynamic());
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto param2 = make_shared<op::Parameter>(element::dynamic, PartialShape::dynamic());
auto param0 = make_shared<ov::op::v0::Parameter>(element::dynamic, PartialShape::dynamic());
auto param1 = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto param2 = make_shared<ov::op::v0::Parameter>(element::dynamic, PartialShape::dynamic());
auto sel = make_shared<op::v1::Select>(param0, param1, param2);
@ -303,9 +301,9 @@ TEST(type_prop, select_partial_all_rank_dynamic_arg0_arg2_et_dynamic) {
}
TEST(type_prop, select_partial_all_rank_dynamic_arg0_arg1_arg2_et_dynamic) {
auto param0 = make_shared<op::Parameter>(element::dynamic, PartialShape::dynamic());
auto param1 = make_shared<op::Parameter>(element::dynamic, PartialShape::dynamic());
auto param2 = make_shared<op::Parameter>(element::dynamic, PartialShape::dynamic());
auto param0 = make_shared<ov::op::v0::Parameter>(element::dynamic, PartialShape::dynamic());
auto param1 = make_shared<ov::op::v0::Parameter>(element::dynamic, PartialShape::dynamic());
auto param2 = make_shared<ov::op::v0::Parameter>(element::dynamic, PartialShape::dynamic());
auto sel = make_shared<op::v1::Select>(param0, param1, param2);
@ -314,10 +312,12 @@ TEST(type_prop, select_partial_all_rank_dynamic_arg0_arg1_arg2_et_dynamic) {
}
TEST(type_prop, select_partial_all_rank_static_dynamic_ok) {
auto param0 =
make_shared<op::Parameter>(element::boolean, PartialShape{2, Dimension::dynamic(), Dimension::dynamic()});
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 8, Dimension::dynamic()});
auto param2 = make_shared<op::Parameter>(element::f32, PartialShape{Dimension::dynamic(), Dimension::dynamic(), 3});
auto param0 = make_shared<ov::op::v0::Parameter>(element::boolean,
PartialShape{2, Dimension::dynamic(), Dimension::dynamic()});
auto param1 =
make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 8, Dimension::dynamic()});
auto param2 =
make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension::dynamic(), Dimension::dynamic(), 3});
auto sel = make_shared<op::v1::Select>(param0, param1, param2);
@ -327,10 +327,11 @@ TEST(type_prop, select_partial_all_rank_static_dynamic_ok) {
}
TEST(type_prop, select_partial_all_rank_static_intransitive_incompatibility) {
auto param0 =
make_shared<op::Parameter>(element::boolean, PartialShape{2, Dimension::dynamic(), Dimension::dynamic()});
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 8, Dimension::dynamic()});
auto param2 = make_shared<op::Parameter>(element::f32, PartialShape{3, Dimension::dynamic(), 3});
auto param0 = make_shared<ov::op::v0::Parameter>(element::boolean,
PartialShape{2, Dimension::dynamic(), Dimension::dynamic()});
auto param1 =
make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension::dynamic(), 8, Dimension::dynamic()});
auto param2 = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{3, Dimension::dynamic(), 3});
try {
auto sel = make_shared<op::v1::Select>(param0, param1, param2);
@ -362,9 +363,9 @@ struct DeduceV1SelectTest : ::testing::TestWithParam<SelectParams> {};
TEST_P(DeduceV1SelectTest, output_shape) {
auto tp = GetParam();
auto cond = make_shared<op::Parameter>(tp.ets[0], tp.shapes[0]);
auto ptrue = make_shared<op::Parameter>(tp.ets[1], tp.shapes[1]);
auto pfalse = make_shared<op::Parameter>(tp.ets[2], tp.shapes[2]);
auto cond = make_shared<ov::op::v0::Parameter>(tp.ets[0], tp.shapes[0]);
auto ptrue = make_shared<ov::op::v0::Parameter>(tp.ets[1], tp.shapes[1]);
auto pfalse = make_shared<ov::op::v0::Parameter>(tp.ets[2], tp.shapes[2]);
auto select = make_shared<op::v1::Select>(cond, ptrue, pfalse, tp.auto_broadcast);
ASSERT_EQ(select->get_shape(), tp.shapes[3]);
@ -411,27 +412,27 @@ INSTANTIATE_TEST_SUITE_P(
PrintToDummyParamName());
TEST(type_prop, select_v1_partial_shape) {
auto a = make_shared<op::Parameter>(element::boolean, PartialShape::dynamic());
auto b = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto c = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto a = make_shared<ov::op::v0::Parameter>(element::boolean, PartialShape::dynamic());
auto b = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
auto c = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
auto select = make_shared<op::v1::Select>(a, b, c, op::AutoBroadcastType::NONE);
ASSERT_EQ(select->get_shape(), (Shape{2, 4}));
}
TEST(type_prop, select_v1_partial_shape_autob) {
auto a = make_shared<op::Parameter>(element::boolean, PartialShape{Dimension::dynamic()});
auto b = make_shared<op::Parameter>(element::f32, PartialShape{Dimension::dynamic()});
auto c = make_shared<op::Parameter>(element::f32, PartialShape{2, Dimension::dynamic()});
auto a = make_shared<ov::op::v0::Parameter>(element::boolean, PartialShape{Dimension::dynamic()});
auto b = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{Dimension::dynamic()});
auto c = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, Dimension::dynamic()});
auto select = make_shared<op::v1::Select>(a, b, c);
ASSERT_TRUE(select->get_output_partial_shape(0).same_scheme(PartialShape{2, Dimension::dynamic()}));
}
TEST(type_prop, select_v1_wrong_et) {
auto param0 = make_shared<op::Parameter>(element::i8, Shape{2, 4});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto param0 = make_shared<ov::op::v0::Parameter>(element::i8, Shape{2, 4});
auto param1 = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
auto param2 = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
try {
auto sel = make_shared<op::v1::Select>(param0, param1, param2);
@ -444,9 +445,9 @@ TEST(type_prop, select_v1_wrong_et) {
}
TEST(type_prop, select_v1_et_mismatch) {
auto param0 = make_shared<op::Parameter>(element::boolean, Shape{2, 4});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto param2 = make_shared<op::Parameter>(element::i8, Shape{2, 4});
auto param0 = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{2, 4});
auto param1 = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
auto param2 = make_shared<ov::op::v0::Parameter>(element::i8, Shape{2, 4});
try {
auto sel = make_shared<op::v1::Select>(param0, param1, param2);
@ -459,9 +460,9 @@ TEST(type_prop, select_v1_et_mismatch) {
}
TEST(type_prop, select_v1_shape_mismatch) {
auto param0 = make_shared<op::Parameter>(element::boolean, Shape{2, 4});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{2, 3});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto param0 = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{2, 4});
auto param1 = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 3});
auto param2 = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
try {
auto sel = make_shared<op::v1::Select>(param0, param1, param2);
@ -474,9 +475,9 @@ TEST(type_prop, select_v1_shape_mismatch) {
}
TEST(type_prop, select_v1_partial_shape_mismatch) {
auto param0 = make_shared<op::Parameter>(element::boolean, PartialShape{3, Dimension::dynamic()});
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape{2, Dimension::dynamic()});
auto param2 = make_shared<op::Parameter>(element::f32, Shape{2, 4});
auto param0 = make_shared<ov::op::v0::Parameter>(element::boolean, PartialShape{3, Dimension::dynamic()});
auto param1 = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{2, Dimension::dynamic()});
auto param2 = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 4});
try {
auto sel = make_shared<op::v1::Select>(param0, param1, param2);

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

@ -2,48 +2,48 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/selu.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;
TEST(type_prop, selu_basic_inference_f32_3D) {
const auto param = make_shared<op::Parameter>(element::f32, Shape{1, 32, 32});
const auto alpha = make_shared<op::Parameter>(element::f32, Shape{1});
const auto lambda = make_shared<op::Parameter>(element::f32, Shape{1});
const auto selu = make_shared<op::Selu>(param, alpha, lambda);
const auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 32, 32});
const auto alpha = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
const auto lambda = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
const auto selu = make_shared<op::v0::Selu>(param, alpha, lambda);
ASSERT_EQ(selu->get_element_type(), element::f32);
ASSERT_EQ(selu->get_shape(), (Shape{1, 32, 32}));
}
TEST(type_prop, selu_basic_inference_f16_3D) {
const auto param = make_shared<op::Parameter>(element::f16, Shape{1, 32, 32});
const auto alpha = make_shared<op::Parameter>(element::f16, Shape{1});
const auto lambda = make_shared<op::Parameter>(element::f16, Shape{1});
const auto selu = make_shared<op::Selu>(param, alpha, lambda);
const auto param = make_shared<ov::op::v0::Parameter>(element::f16, Shape{1, 32, 32});
const auto alpha = make_shared<ov::op::v0::Parameter>(element::f16, Shape{1});
const auto lambda = make_shared<ov::op::v0::Parameter>(element::f16, Shape{1});
const auto selu = make_shared<op::v0::Selu>(param, alpha, lambda);
ASSERT_EQ(selu->get_element_type(), element::f16);
ASSERT_EQ(selu->get_shape(), (Shape{1, 32, 32}));
}
TEST(type_prop, selu_basic_inference_f32_5D) {
const auto param = make_shared<op::Parameter>(element::f32, Shape{12, 135, 221, 31, 15});
const auto alpha = make_shared<op::Parameter>(element::f32, Shape{1});
const auto lambda = make_shared<op::Parameter>(element::f32, Shape{1});
const auto selu = make_shared<op::Selu>(param, alpha, lambda);
const auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{12, 135, 221, 31, 15});
const auto alpha = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
const auto lambda = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
const auto selu = make_shared<op::v0::Selu>(param, alpha, lambda);
ASSERT_EQ(selu->get_element_type(), element::f32);
ASSERT_EQ(selu->get_shape(), (Shape{12, 135, 221, 31, 15}));
}
TEST(type_prop, selu_basic_inference_f16_5D) {
const auto param = make_shared<op::Parameter>(element::f16, Shape{12, 135, 221, 31, 15});
const auto alpha = make_shared<op::Parameter>(element::f16, Shape{1});
const auto lambda = make_shared<op::Parameter>(element::f16, Shape{1});
const auto selu = make_shared<op::Selu>(param, alpha, lambda);
const auto param = make_shared<ov::op::v0::Parameter>(element::f16, Shape{12, 135, 221, 31, 15});
const auto alpha = make_shared<ov::op::v0::Parameter>(element::f16, Shape{1});
const auto lambda = make_shared<ov::op::v0::Parameter>(element::f16, Shape{1});
const auto selu = make_shared<op::v0::Selu>(param, alpha, lambda);
ASSERT_EQ(selu->get_element_type(), element::f16);
ASSERT_EQ(selu->get_shape(), (Shape{12, 135, 221, 31, 15}));
@ -52,10 +52,10 @@ TEST(type_prop, selu_basic_inference_f16_5D) {
TEST(type_prop, selu_incompatible_input_type_boolean) {
// Invalid data input element type
try {
auto data = make_shared<op::Parameter>(element::boolean, Shape{1, 2, 3, 4});
const auto alpha = make_shared<op::Parameter>(element::boolean, Shape{1});
const auto lambda = make_shared<op::Parameter>(element::boolean, Shape{1});
auto selu = make_shared<op::Selu>(data, alpha, lambda);
auto data = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{1, 2, 3, 4});
const auto alpha = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{1});
const auto lambda = make_shared<ov::op::v0::Parameter>(element::boolean, Shape{1});
auto selu = make_shared<op::v0::Selu>(data, alpha, lambda);
// Data input expected to be of numeric type
FAIL() << "Invalid input type not detected";
} catch (const NodeValidationFailure& error) {
@ -68,10 +68,10 @@ TEST(type_prop, selu_incompatible_input_type_boolean) {
TEST(type_prop, selu_incompatible_input_type_i32) {
// Invalid data input element type
try {
auto data = make_shared<op::Parameter>(element::i32, Shape{1, 2, 3, 4});
const auto alpha = make_shared<op::Parameter>(element::i32, Shape{1});
const auto lambda = make_shared<op::Parameter>(element::i32, Shape{1});
auto selu = make_shared<op::Selu>(data, alpha, lambda);
auto data = make_shared<ov::op::v0::Parameter>(element::i32, Shape{1, 2, 3, 4});
const auto alpha = make_shared<ov::op::v0::Parameter>(element::i32, Shape{1});
const auto lambda = make_shared<ov::op::v0::Parameter>(element::i32, Shape{1});
auto selu = make_shared<op::v0::Selu>(data, alpha, lambda);
// Data input expected to be of numeric type
FAIL() << "Invalid input type not detected";
} catch (const NodeValidationFailure& error) {
@ -84,10 +84,10 @@ TEST(type_prop, selu_incompatible_input_type_i32) {
TEST(type_prop, selu_incompatible_input_type_u16) {
// Invalid data input element type
try {
auto data = make_shared<op::Parameter>(element::u16, Shape{1, 2, 3, 4});
const auto alpha = make_shared<op::Parameter>(element::u16, Shape{1});
const auto lambda = make_shared<op::Parameter>(element::u16, Shape{1});
auto selu = make_shared<op::Selu>(data, alpha, lambda);
auto data = make_shared<ov::op::v0::Parameter>(element::u16, Shape{1, 2, 3, 4});
const auto alpha = make_shared<ov::op::v0::Parameter>(element::u16, Shape{1});
const auto lambda = make_shared<ov::op::v0::Parameter>(element::u16, Shape{1});
auto selu = make_shared<op::v0::Selu>(data, alpha, lambda);
// Data input expected to be of numeric type
FAIL() << "Invalid input type not detected";
} catch (const NodeValidationFailure& error) {
@ -100,10 +100,10 @@ TEST(type_prop, selu_incompatible_input_type_u16) {
TEST(type_prop, selu_incompatible_input_types) {
// Invalid data input element type
try {
auto data = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
const auto alpha = make_shared<op::Parameter>(element::f32, Shape{1});
const auto lambda = make_shared<op::Parameter>(element::u16, Shape{1});
auto selu = make_shared<op::Selu>(data, alpha, lambda);
auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
const auto alpha = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
const auto lambda = make_shared<ov::op::v0::Parameter>(element::u16, Shape{1});
auto selu = make_shared<op::v0::Selu>(data, alpha, lambda);
// Data input expected to be of numeric type
FAIL() << "Inavlid input types not detected";
} catch (const NodeValidationFailure& error) {
@ -115,26 +115,26 @@ TEST(type_prop, selu_incompatible_input_types) {
TEST(type_prop, selu_dynamic_rank_input_shape_2D) {
const PartialShape param_shape{Dimension::dynamic(), 10};
const auto param = std::make_shared<op::Parameter>(element::f32, param_shape);
const auto alpha = make_shared<op::Parameter>(element::f32, Shape{2, 1});
const auto lambda = make_shared<op::Parameter>(element::f32, Shape{1});
const auto op = std::make_shared<op::Selu>(param, alpha, lambda);
const auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, param_shape);
const auto alpha = make_shared<ov::op::v0::Parameter>(element::f32, Shape{2, 1});
const auto lambda = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
const auto op = std::make_shared<op::v0::Selu>(param, alpha, lambda);
ASSERT_TRUE(op->get_output_partial_shape(0).same_scheme(PartialShape{Dimension(), 10}));
}
TEST(type_prop, selu_dynamic_rank_input_shape_3D) {
const PartialShape param_shape{100, Dimension::dynamic(), 58};
const auto param = std::make_shared<op::Parameter>(element::f32, param_shape);
const auto alpha = make_shared<op::Parameter>(element::f32, Shape{1});
const auto lambda = make_shared<op::Parameter>(element::f32, Shape{1});
const auto op = std::make_shared<op::Selu>(param, alpha, lambda);
const auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, param_shape);
const auto alpha = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
const auto lambda = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
const auto op = std::make_shared<op::v0::Selu>(param, alpha, lambda);
ASSERT_TRUE(op->get_output_partial_shape(0).same_scheme(PartialShape{100, Dimension(), 58}));
}
TEST(type_prop, selu_dynamic_rank_input_shape_full) {
const auto param = std::make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
const auto alpha = make_shared<op::Parameter>(element::f32, Shape{1});
const auto lambda = make_shared<op::Parameter>(element::f32, Shape{1});
const auto op = std::make_shared<op::Selu>(param, alpha, lambda);
const auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
const auto alpha = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
const auto lambda = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
const auto op = std::make_shared<op::v0::Selu>(param, alpha, lambda);
ASSERT_TRUE(op->get_output_partial_shape(0).same_scheme(PartialShape::dynamic()));
}

37
src/core/tests/type_prop/shape_of.cpp
View File

@ -2,16 +2,17 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/shape_of.hpp"
#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"
using namespace std;
using namespace ngraph;
using namespace ov;
TEST(type_prop, shape_of_v0) {
auto a = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto a = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto so = make_shared<op::v0::ShapeOf>(a);
ASSERT_EQ(so->get_output_element_type(0), element::i64);
@ -19,7 +20,7 @@ TEST(type_prop, shape_of_v0) {
}
TEST(type_prop, shape_of_partial_et_dynamic_v0) {
auto a = make_shared<op::Parameter>(element::dynamic, Shape{1, 2, 3, 4});
auto a = make_shared<ov::op::v0::Parameter>(element::dynamic, Shape{1, 2, 3, 4});
auto so = make_shared<op::v0::ShapeOf>(a);
ASSERT_EQ(so->get_output_element_type(0), element::i64);
@ -27,7 +28,8 @@ TEST(type_prop, shape_of_partial_et_dynamic_v0) {
}
TEST(type_prop, shape_of_partial_rank_static_dynamic_v0) {
auto a = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), Dimension::dynamic(), 4});
auto a = make_shared<ov::op::v0::Parameter>(element::f32,
PartialShape{1, Dimension::dynamic(), Dimension::dynamic(), 4});
auto so = make_shared<op::v0::ShapeOf>(a);
ASSERT_EQ(so->get_output_element_type(0), element::i64);
@ -35,7 +37,7 @@ TEST(type_prop, shape_of_partial_rank_static_dynamic_v0) {
}
TEST(type_prop, shape_of_partial_rank_dynamic_v0) {
auto a = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto a = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto so = make_shared<op::v0::ShapeOf>(a);
ASSERT_EQ(so->get_output_element_type(0), element::i64);
@ -43,7 +45,7 @@ TEST(type_prop, shape_of_partial_rank_dynamic_v0) {
}
TEST(type_prop, shape_of_v3) {
auto a = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto a = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto so = make_shared<op::v3::ShapeOf>(a);
ASSERT_EQ(so->get_output_element_type(0), element::i64);
@ -51,7 +53,7 @@ TEST(type_prop, shape_of_v3) {
}
TEST(type_prop, shape_of_partial_et_dynamic_v3) {
auto a = make_shared<op::Parameter>(element::dynamic, Shape{1, 2, 3, 4});
auto a = make_shared<ov::op::v0::Parameter>(element::dynamic, Shape{1, 2, 3, 4});
auto so = make_shared<op::v3::ShapeOf>(a);
ASSERT_EQ(so->get_output_element_type(0), element::i64);
@ -59,7 +61,8 @@ TEST(type_prop, shape_of_partial_et_dynamic_v3) {
}
TEST(type_prop, shape_of_partial_rank_static_dynamic_v3) {
auto a = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), Dimension::dynamic(), 4});
auto a = make_shared<ov::op::v0::Parameter>(element::f32,
PartialShape{1, Dimension::dynamic(), Dimension::dynamic(), 4});
auto so = make_shared<op::v3::ShapeOf>(a);
ASSERT_EQ(so->get_output_element_type(0), element::i64);
@ -67,7 +70,7 @@ TEST(type_prop, shape_of_partial_rank_static_dynamic_v3) {
}
TEST(type_prop, shape_of_partial_rank_dynamic_v3) {
auto a = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto a = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic());
auto so = make_shared<op::v3::ShapeOf>(a);
ASSERT_EQ(so->get_output_element_type(0), element::i64);
@ -75,7 +78,7 @@ TEST(type_prop, shape_of_partial_rank_dynamic_v3) {
}
TEST(type_prop, shape_of_output_type_v3) {
auto a = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto a = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
auto so = make_shared<op::v3::ShapeOf>(a, element::i32);
try {
auto sx = make_shared<op::v3::ShapeOf>(a, element::i8);
@ -108,9 +111,9 @@ TEST(type_prop, shape_of_1_dynamic_value_and_label_propagation) {
ov::DimensionTracker::set_label(marked_0, 10);
PartialShape target_0 = PartialShape{marked_0, 4};
auto param = std::make_shared<op::Parameter>(element::f32, Shape{1});
auto param_0 = std::make_shared<op::Parameter>(element::f32, target_0);
auto shape_0 = std::make_shared<op::ShapeOf>(param_0);
auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
auto param_0 = std::make_shared<ov::op::v0::Parameter>(element::f32, target_0);
auto shape_0 = std::make_shared<op::v0::ShapeOf>(param_0);
auto bc = std::make_shared<op::v1::Broadcast>(param, shape_0);
ASSERT_EQ(bc->get_shape(), (Shape{3, 4}));
@ -124,8 +127,8 @@ TEST(type_prop, shape_of_3_dynamic_value_and_label_propagation) {
ov::DimensionTracker::set_label(marked_0, 10);
PartialShape target_0 = PartialShape{marked_0, 4};
auto param = std::make_shared<op::Parameter>(element::f32, Shape{1});
auto param_0 = std::make_shared<op::Parameter>(element::f32, target_0);
auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
auto param_0 = std::make_shared<ov::op::v0::Parameter>(element::f32, target_0);
auto shape_0 = std::make_shared<op::v3::ShapeOf>(param_0);
auto bc = std::make_shared<op::v1::Broadcast>(param, shape_0);

40
src/core/tests/type_prop/shuffle_channels.cpp
View File

@ -2,18 +2,18 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/shuffle_channels.hpp"
#include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp"
#include "gmock/gmock.h"
#include "ngraph/ngraph.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
using namespace testing;
TEST(type_prop, shuffle_channels_default_4D) {
const auto data_input_shape = Shape{3, 9, 4, 5};
const auto data = make_shared<op::Parameter>(element::f32, data_input_shape);
const auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_input_shape);
const auto shuffle_channels = make_shared<op::v0::ShuffleChannels>(data);
EXPECT_EQ(shuffle_channels->get_element_type(), element::f32);
@ -22,7 +22,7 @@ TEST(type_prop, shuffle_channels_default_4D) {
TEST(type_prop, shuffle_channels_basic_4D) {
const auto data_input_shape = Shape{3, 9, 4, 5};
const auto data = make_shared<op::Parameter>(element::f32, data_input_shape);
const auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_input_shape);
const auto axis = 1;
const auto group = 3;
const auto shuffle_channels = make_shared<op::v0::ShuffleChannels>(data, axis, group);
@ -34,7 +34,7 @@ TEST(type_prop, shuffle_channels_basic_4D) {
TEST(type_prop, shuffle_channels_dynamic_4D) {
auto data_input_shape = PartialShape{Dimension::dynamic(), Dimension(3, 9), 4, Dimension(4, 15)};
set_shape_labels(data_input_shape, 10);
const auto data = make_shared<op::Parameter>(element::f32, data_input_shape);
const auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_input_shape);
const auto axis = 1;
const auto group = 3;
const auto shuffle_channels = make_shared<op::v0::ShuffleChannels>(data, axis, group);
@ -46,7 +46,7 @@ TEST(type_prop, shuffle_channels_dynamic_4D) {
TEST(type_prop, shuffle_channels_dynamic_fully) {
const auto data_input_shape = PartialShape::dynamic();
const auto data = make_shared<op::Parameter>(element::f32, data_input_shape);
const auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_input_shape);
const auto axis = 1;
const auto group = 3;
const auto shuffle_channels = make_shared<op::v0::ShuffleChannels>(data, axis, group);
@ -59,7 +59,7 @@ TEST(type_prop, shuffle_channels_ND_bigger) {
{
// 5D
const auto data_input_shape = Shape{2, 3, 9, 4, 5};
const auto data = make_shared<op::Parameter>(element::f32, data_input_shape);
const auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_input_shape);
const auto axis = 2;
const auto group = 3;
const auto shuffle_channels = make_shared<op::v0::ShuffleChannels>(data, axis, group);
@ -69,7 +69,7 @@ TEST(type_prop, shuffle_channels_ND_bigger) {
{
// 6D
const auto data_input_shape = Shape{6, 2, 3, 9, 4, 5};
const auto data = make_shared<op::Parameter>(element::f32, data_input_shape);
const auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_input_shape);
const auto axis = 3;
const auto group = 3;
const auto shuffle_channels = make_shared<op::v0::ShuffleChannels>(data, axis, group);
@ -82,7 +82,7 @@ TEST(type_prop, shuffle_channels_ND_smaller) {
{
// 3D
const auto data_input_shape = Shape{5, 4, 9};
const auto data = make_shared<op::Parameter>(element::f32, data_input_shape);
const auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_input_shape);
const auto axis = 2;
const auto group = 3;
const auto shuffle_channels = make_shared<op::v0::ShuffleChannels>(data, axis, group);
@ -92,7 +92,7 @@ TEST(type_prop, shuffle_channels_ND_smaller) {
{
// 2D
const auto data_input_shape = Shape{9, 20};
const auto data = make_shared<op::Parameter>(element::f32, data_input_shape);
const auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_input_shape);
const auto axis = 0;
const auto group = 3;
const auto shuffle_channels = make_shared<op::v0::ShuffleChannels>(data, axis, group);
@ -102,7 +102,7 @@ TEST(type_prop, shuffle_channels_ND_smaller) {
{
// 1D
const auto data_input_shape = Shape{9};
const auto data = make_shared<op::Parameter>(element::f32, data_input_shape);
const auto data = make_shared<ov::op::v0::Parameter>(element::f32, data_input_shape);
const auto axis = 0;
const auto group = 3;
const auto shuffle_channels = make_shared<op::v0::ShuffleChannels>(data, axis, group);
@ -112,7 +112,7 @@ TEST(type_prop, shuffle_channels_ND_smaller) {
}
TEST(type_prop, shuffle_channels_axis_validation) {
const auto data = make_shared<op::Parameter>(element::f64, Shape{1, 2, 3, 4});
const auto data = make_shared<ov::op::v0::Parameter>(element::f64, Shape{1, 2, 3, 4});
OV_EXPECT_THROW(const auto op = make_shared<op::v0::ShuffleChannels>(data, -5, 5),
ov::AssertFailure,
@ -120,7 +120,7 @@ TEST(type_prop, shuffle_channels_axis_validation) {
}
TEST(type_prop, shuffle_channels_negative_axis_calculation) {
const auto data = make_shared<op::Parameter>(element::f64, Shape{1, 2, 3, 4});
const auto data = make_shared<ov::op::v0::Parameter>(element::f64, Shape{1, 2, 3, 4});
const auto shuffle_channels = make_shared<op::v0::ShuffleChannels>(data, -3, 2);
@ -132,21 +132,21 @@ TEST(type_prop, shuffle_channels_infer_shape_with_negative_axis_calculation) {
const auto group = 2;
{
const auto data_input_shape = Shape{1, 3, 5, 8};
const auto data = make_shared<op::Parameter>(element::f64, data_input_shape);
const auto data = make_shared<ov::op::v0::Parameter>(element::f64, data_input_shape);
const auto shuffle_channels = make_shared<op::v0::ShuffleChannels>(data, -1, group);
EXPECT_EQ(shuffle_channels->get_output_partial_shape(0), data_input_shape);
}
{
const auto data_input_shape = Shape{1, 3, 8, 5};
const auto data = make_shared<op::Parameter>(element::f64, data_input_shape);
const auto data = make_shared<ov::op::v0::Parameter>(element::f64, data_input_shape);
const auto shuffle_channels = make_shared<op::v0::ShuffleChannels>(data, -2, group);
EXPECT_EQ(shuffle_channels->get_output_partial_shape(0), data_input_shape);
}
{
const auto data_input_shape = Shape{8, 3, 5, 7};
const auto data = make_shared<op::Parameter>(element::f64, data_input_shape);
const auto data = make_shared<ov::op::v0::Parameter>(element::f64, data_input_shape);
const auto shuffle_channels = make_shared<op::v0::ShuffleChannels>(data, -4, group);
EXPECT_EQ(shuffle_channels->get_output_partial_shape(0), data_input_shape);
@ -154,7 +154,7 @@ TEST(type_prop, shuffle_channels_infer_shape_with_negative_axis_calculation) {
}
TEST(type_prop, shuffle_channels_invalid_input_shape) {
const auto data = make_shared<op::Parameter>(element::f64, Shape{});
const auto data = make_shared<ov::op::v0::Parameter>(element::f64, Shape{});
OV_EXPECT_THROW(const auto op = make_shared<op::v0::ShuffleChannels>(data, 0, 1),
NodeValidationFailure,
@ -162,7 +162,7 @@ TEST(type_prop, shuffle_channels_invalid_input_shape) {
}
TEST(type_prop, shuffle_channels_invalid_groups_value) {
const auto data = make_shared<op::Parameter>(element::f64, Shape{1, 2, 3, 15});
const auto data = make_shared<ov::op::v0::Parameter>(element::f64, Shape{1, 2, 3, 15});
OV_EXPECT_THROW(const auto op = make_shared<op::v0::ShuffleChannels>(data, -1, 2),
NodeValidationFailure,
@ -171,7 +171,7 @@ TEST(type_prop, shuffle_channels_invalid_groups_value) {
TEST(type_prop, shuffle_channels_default_ctor) {
const auto data_shape = PartialShape{{2, 5}, {0, 2}, 3, {2, -1}};
const auto data = make_shared<op::Parameter>(element::i32, data_shape);
const auto data = make_shared<ov::op::v0::Parameter>(element::i32, data_shape);
const auto shuffle_channels = make_shared<op::v0::ShuffleChannels>();
shuffle_channels->set_axis(-3);

21
src/core/tests/type_prop/sigmoid.cpp
View File

@ -2,34 +2,35 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/sigmoid.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;
TEST(type_prop, sigmoid) {
auto data = make_shared<op::Parameter>(element::f32, Shape{1, 3, 6});
auto sigmoid_func = make_shared<op::Sigmoid>(data);
auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 6});
auto sigmoid_func = make_shared<op::v0::Sigmoid>(data);
EXPECT_EQ(sigmoid_func->get_element_type(), element::f32);
EXPECT_EQ(sigmoid_func->get_shape(), data->get_output_shape(0));
}
TEST(type_prop, sigmoid_partial) {
auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto sigmoid_func = make_shared<op::Sigmoid>(data);
auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto sigmoid_func = make_shared<op::v0::Sigmoid>(data);
EXPECT_EQ(sigmoid_func->get_element_type(), element::f32);
ASSERT_TRUE(sigmoid_func->get_output_partial_shape(0).same_scheme(data->get_output_partial_shape(0)));
// rank unknown
auto sigmoid_partial = make_shared<op::Sigmoid>(make_shared<op::Parameter>(element::f32, PartialShape::dynamic()));
auto sigmoid_partial =
make_shared<op::v0::Sigmoid>(make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic()));
ASSERT_TRUE(sigmoid_partial->get_output_partial_shape(0).same_scheme(PartialShape::dynamic()));
}
TEST(type_prop, sigmoid_partial_static_rank) {
auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto sigmoid_func = make_shared<op::Sigmoid>(data);
auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto sigmoid_func = make_shared<op::v0::Sigmoid>(data);
EXPECT_EQ(sigmoid_func->get_element_type(), element::f32);
ASSERT_TRUE(sigmoid_func->get_output_partial_shape(0).same_scheme(data->get_output_partial_shape(0)));
ASSERT_TRUE(sigmoid_func->get_output_partial_shape(0).rank().is_static());

4
src/core/tests/type_prop/sign.cpp
View File

@ -2,8 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/sign.hpp"
#include "unary_ops.hpp"
using Type = ::testing::Types<ngraph::op::Sign>;
using Type = ::testing::Types<ov::op::v0::Sign>;
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_sign, UnaryOperator, Type);

4
src/core/tests/type_prop/sin.cpp
View File

@ -2,8 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/sin.hpp"
#include "unary_ops.hpp"
using Type = ::testing::Types<ngraph::op::Sin>;
using Type = ::testing::Types<ov::op::v0::Sin>;
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_sin, UnaryOperator, Type);

4
src/core/tests/type_prop/sinh.cpp
View File

@ -2,8 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/sinh.hpp"
#include "unary_ops.hpp"
using Type = ::testing::Types<ngraph::op::Sinh>;
using Type = ::testing::Types<ov::op::v0::Sinh>;
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_sinh, UnaryOperator, Type);

69
src/core/tests/type_prop/slice.cpp
View File

@ -6,12 +6,11 @@
#include "common_test_utils/test_assertions.hpp"
#include "common_test_utils/type_prop.hpp"
#include "ngraph/ngraph.hpp"
#include "openvino/core/dimension_tracker.hpp"
#include "openvino/opsets/opset9.hpp"
#include "sequnce_generator.hpp"
using namespace ngraph;
using namespace ov;
using namespace testing;
namespace {
@ -1067,9 +1066,9 @@ TEST(type_prop, slice_v8_dynamic_value_and_label_propagation) {
ov::DimensionTracker::set_label(marked_0, 10);
PartialShape target_0 = PartialShape{marked_0, 4};
auto param = std::make_shared<op::Parameter>(element::f32, Shape{1});
auto param_0 = std::make_shared<op::Parameter>(element::f32, target_0);
auto shape_0 = std::make_shared<op::ShapeOf>(param_0);
auto param = std::make_shared<ov::op::v0::Parameter>(element::f32, Shape{1});
auto param_0 = std::make_shared<ov::op::v0::Parameter>(element::f32, target_0);
auto shape_0 = std::make_shared<op::v0::ShapeOf>(param_0);
const auto& et = element::i64;
std::vector<int64_t> start_val{0}, stop_val{1}, step_val{1};
@ -1105,10 +1104,10 @@ TEST(type_prop, slice_v8_dynamic_dimension_but_slice_min_is_lt_input_min_size) {
TEST(type_prop, slice_v8_use_default_ctor) {
const auto zero_mask = std::vector<int64_t>(3, 0);
auto data = std::make_shared<op::Parameter>(element::f32, PartialShape{10, 11, 12, 2});
auto start = op::Constant::create(element::i64, Shape{4}, {0, 0, 0, 0});
auto stop = op::Constant::create(element::i64, Shape{4}, {1, 5, 20, 20});
auto step = op::Constant::create(element::i64, Shape{4}, {1, 1, 1, 1});
auto data = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{10, 11, 12, 2});
auto start = ov::op::v0::Constant::create(element::i64, Shape{4}, {0, 0, 0, 0});
auto stop = ov::op::v0::Constant::create(element::i64, Shape{4}, {1, 5, 20, 20});
auto step = ov::op::v0::Constant::create(element::i64, Shape{4}, {1, 1, 1, 1});
auto slice = std::make_shared<op::v8::Slice>();
slice->set_arguments(ov::OutputVector{data, start, stop, step});
@ -1120,12 +1119,12 @@ TEST(type_prop, slice_v8_use_default_ctor) {
TEST(type_prop, slice_v8_stop_is_shape_of_with_bounds) {
auto shape = PartialShape{1, {5, 7}};
set_shape_labels(shape, 20);
const auto p_stop = std::make_shared<op::Parameter>(element::i64, shape);
const auto shape_of_stop = std::make_shared<op::ShapeOf>(p_stop);
const auto p_stop = std::make_shared<ov::op::v0::Parameter>(element::i64, shape);
const auto shape_of_stop = std::make_shared<op::v0::ShapeOf>(p_stop);
auto data = op::Constant::create(element::i64, Shape{1, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 0});
auto start = op::Constant::create(element::i64, Shape{2}, {0, 0});
auto steps = op::Constant::create(element::i64, Shape{2}, {1, 1});
auto data = ov::op::v0::Constant::create(element::i64, Shape{1, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 0});
auto start = ov::op::v0::Constant::create(element::i64, Shape{2}, {0, 0});
auto steps = ov::op::v0::Constant::create(element::i64, Shape{2}, {1, 1});
auto slice = std::make_shared<op::v8::Slice>(data, start, shape_of_stop, steps);
@ -1136,12 +1135,12 @@ TEST(type_prop, slice_v8_stop_is_shape_of_with_bounds) {
TEST(type_prop, slice_v8_start_is_shape_of_with_bounds) {
auto shape = PartialShape{0, {3, 5}};
set_shape_labels(shape, 20);
const auto p_start = std::make_shared<op::Parameter>(element::i64, shape);
const auto shape_of_start = std::make_shared<op::ShapeOf>(p_start);
const auto p_start = std::make_shared<ov::op::v0::Parameter>(element::i64, shape);
const auto shape_of_start = std::make_shared<op::v0::ShapeOf>(p_start);
auto data = op::Constant::create(element::i64, Shape{1, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 0});
auto stop = op::Constant::create(element::i64, Shape{2}, {1, 7});
auto steps = op::Constant::create(element::i64, Shape{2}, {1, 1});
auto data = ov::op::v0::Constant::create(element::i64, Shape{1, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 0});
auto stop = ov::op::v0::Constant::create(element::i64, Shape{2}, {1, 7});
auto steps = ov::op::v0::Constant::create(element::i64, Shape{2}, {1, 1});
auto slice = std::make_shared<op::v8::Slice>(data, shape_of_start, stop, steps);
@ -1154,13 +1153,13 @@ TEST(type_prop, slice_v8_start_stop_is_shape_of_with_bounds) {
auto stop_shape = PartialShape{2, {6, 7}};
set_shape_labels(start_shape, 10);
set_shape_labels(stop_shape, 20);
const auto p_start = std::make_shared<op::Parameter>(element::i64, start_shape);
const auto p_stop = std::make_shared<op::Parameter>(element::i64, stop_shape);
const auto shape_of_start = std::make_shared<op::ShapeOf>(p_start);
const auto shape_of_stop = std::make_shared<op::ShapeOf>(p_stop);
const auto p_start = std::make_shared<ov::op::v0::Parameter>(element::i64, start_shape);
const auto p_stop = std::make_shared<ov::op::v0::Parameter>(element::i64, stop_shape);
const auto shape_of_start = std::make_shared<op::v0::ShapeOf>(p_start);
const auto shape_of_stop = std::make_shared<op::v0::ShapeOf>(p_stop);
auto data = op::Constant::create(element::i64, Shape{1, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 0});
auto steps = op::Constant::create(element::i64, Shape{2}, {1, 1});
auto data = ov::op::v0::Constant::create(element::i64, Shape{1, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 0});
auto steps = ov::op::v0::Constant::create(element::i64, Shape{2}, {1, 1});
auto slice = std::make_shared<op::v8::Slice>(data, shape_of_start, shape_of_stop, steps);
@ -1169,11 +1168,11 @@ TEST(type_prop, slice_v8_start_stop_is_shape_of_with_bounds) {
}
TEST(type_prop, slice_v8_unknowns_axes) {
const auto data = std::make_shared<op::Parameter>(element::i64, Shape{5, 10, 15});
const auto start = std::make_shared<op::Parameter>(element::i64, PartialShape{-1});
const auto stop = std::make_shared<op::Parameter>(element::i64, Shape{1});
const auto steps = std::make_shared<op::Parameter>(element::i64, Shape{1});
const auto axes = std::make_shared<op::Parameter>(element::i64, Shape{1});
const auto data = std::make_shared<ov::op::v0::Parameter>(element::i64, Shape{5, 10, 15});
const auto start = std::make_shared<ov::op::v0::Parameter>(element::i64, PartialShape{-1});
const auto stop = std::make_shared<ov::op::v0::Parameter>(element::i64, Shape{1});
const auto steps = std::make_shared<ov::op::v0::Parameter>(element::i64, Shape{1});
const auto axes = std::make_shared<ov::op::v0::Parameter>(element::i64, Shape{1});
auto slice = std::make_shared<op::v8::Slice>(data, start, stop, steps, axes);
@ -1181,11 +1180,11 @@ TEST(type_prop, slice_v8_unknowns_axes) {
}
TEST(type_prop, slice_v8_inf_dim_start_from_last_N_to_end) {
auto data = std::make_shared<op::Parameter>(element::f32, PartialShape{1, 256, -1});
auto start = op::Constant::create(element::i64, Shape{1}, {-7});
auto stop = op::Constant::create(element::i64, Shape{1}, std::vector<int64_t>{INT64_MAX});
auto step = op::Constant::create(element::i64, Shape{1}, {1});
auto axes = op::Constant::create(element::i64, Shape{1}, {2});
auto data = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, 256, -1});
auto start = ov::op::v0::Constant::create(element::i64, Shape{1}, {-7});
auto stop = ov::op::v0::Constant::create(element::i64, Shape{1}, std::vector<int64_t>{INT64_MAX});
auto step = ov::op::v0::Constant::create(element::i64, Shape{1}, {1});
auto axes = ov::op::v0::Constant::create(element::i64, Shape{1}, {2});
auto slice = std::make_shared<op::v8::Slice>(data, start, stop, step, axes);

29
src/core/tests/type_prop/softmax.cpp
View File

@ -2,50 +2,53 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "openvino/op/softmax.hpp"
#include <gtest/gtest.h>
#include "openvino/op/parameter.hpp"
using namespace std;
using namespace ngraph;
using namespace ov;
TEST(type_prop, softmax_default_axis) {
const Shape arg_shape{2, 3};
auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
auto sm = make_shared<op::v1::Softmax>(arg);
ASSERT_EQ(sm->get_axis(), 1);
}
TEST(type_prop, softmax_out_of_bound_axis) {
const Shape arg_shape{2, 3};
auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
// axis cannot be a negative number
ASSERT_THROW(const auto unused = make_shared<op::v1::Softmax>(arg, -1), ngraph::NodeValidationFailure);
ASSERT_THROW(const auto unused = make_shared<op::v1::Softmax>(arg, -1), ov::NodeValidationFailure);
}
TEST(type_prop, softmax_8_default_axis) {
const Shape arg_shape{2, 3};
auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
auto sm = make_shared<op::v8::Softmax>(arg);
ASSERT_EQ(sm->get_axis(), 1);
}
TEST(type_prop, softmax_8_out_of_bound_negative_axis) {
const Shape arg_shape{2, 3};
auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
// axis should be in range [-rank, rank - 1]
ASSERT_THROW(const auto unused = make_shared<op::v8::Softmax>(arg, -10), ngraph::NodeValidationFailure);
ASSERT_THROW(const auto unused = make_shared<op::v8::Softmax>(arg, -10), ov::NodeValidationFailure);
}
TEST(type_prop, softmax_8_out_of_bound_positive_axis) {
const Shape arg_shape{2, 3};
auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
// axis should be in range [-rank, rank - 1]
ASSERT_THROW(const auto unused = make_shared<op::v8::Softmax>(arg, 10), ngraph::NodeValidationFailure);
ASSERT_THROW(const auto unused = make_shared<op::v8::Softmax>(arg, 10), ov::NodeValidationFailure);
}
TEST(type_prop, softmax_8_positive_axis) {
const Shape arg_shape{1, 10};
auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
auto softmax = make_shared<op::v8::Softmax>(arg, 1);
ASSERT_EQ(softmax->get_element_type(), element::f32);
ASSERT_EQ(softmax->get_shape(), (Shape{1, 10}));
@ -53,7 +56,7 @@ TEST(type_prop, softmax_8_positive_axis) {
TEST(type_prop, softmax_8_negative_axis) {
const Shape arg_shape{1, 10};
auto arg = make_shared<op::Parameter>(element::f32, arg_shape);
auto arg = make_shared<ov::op::v0::Parameter>(element::f32, arg_shape);
auto softmax = make_shared<op::v8::Softmax>(arg, -1);
ASSERT_EQ(softmax->get_element_type(), element::f32);
ASSERT_EQ(softmax->get_shape(), (Shape{1, 10}));

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

@ -2,34 +2,36 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/softplus.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, softplus) {
auto data = make_shared<op::Parameter>(element::f32, Shape{1, 3, 6});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 3, 6});
auto softplus_func = make_shared<op::v4::SoftPlus>(data);
EXPECT_EQ(softplus_func->get_element_type(), element::f32);
EXPECT_EQ(softplus_func->get_shape(), (Shape{1, 3, 6}));
}
TEST(type_prop, softplus_partial) {
auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto softplus_func = make_shared<op::v4::SoftPlus>(data);
EXPECT_EQ(softplus_func->get_element_type(), element::f32);
ASSERT_TRUE(softplus_func->get_output_partial_shape(0).same_scheme((PartialShape{1, Dimension::dynamic(), 6})));
// rank unknown
auto softplus_partial =
make_shared<op::v4::SoftPlus>(make_shared<op::Parameter>(element::f32, PartialShape::dynamic()));
make_shared<op::v4::SoftPlus>(make_shared<ov::op::v0::Parameter>(element::f32, PartialShape::dynamic()));
ASSERT_TRUE(softplus_partial->get_output_partial_shape(0).same_scheme(PartialShape::dynamic()));
}
TEST(type_prop, softplus_partial_static_rank) {
auto data = make_shared<op::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto data = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, Dimension::dynamic(), 6});
auto softplus_func = make_shared<op::v4::SoftPlus>(data);
EXPECT_EQ(softplus_func->get_element_type(), element::f32);
ASSERT_TRUE(softplus_func->get_output_partial_shape(0).same_scheme((PartialShape{1, Dimension::dynamic(), 6})));
@ -37,7 +39,7 @@ TEST(type_prop, softplus_partial_static_rank) {
}
TEST(type_prop, softplus_invalid_element_type) {
auto data = make_shared<op::Parameter>(element::i32, Shape{2, 2});
auto data = make_shared<ov::op::v0::Parameter>(element::i32, Shape{2, 2});
try {
auto softplus = make_shared<op::v4::SoftPlus>(data);

Some files were not shown because too many files have changed in this diff Show More