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

v0::Pad operator removal (#1912)

Browse Source 
* v0::Pad operator removal

* Obsolete test removal
This commit is contained in:
Tomasz Dołbniak 2020-08-24 18:03:01 +02:00 committed by GitHub
parent 0ad27cb527
commit 4013649fe8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 1 additions and 600 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
inference-engine/src/transformations/src/transformations/common_optimizations/nop_elimination.cpp
View File

@ -334,8 +334,7 @@ static bool eliminate_stop_gradient(const std::shared_ptr<Node>& node) {
bool pass::NopElimination::run_on_function(std::shared_ptr<Function> function) {
static const std::unordered_map<NodeTypeInfo, std::function<bool(const std::shared_ptr<Node>&)>>
dispatcher{{TI(op::v0::Pad), &eliminate_nop},
{TI(opset3::Pad), &eliminate_nop},
dispatcher{{TI(opset3::Pad), &eliminate_nop},
{TI(op::v0::Sum), &eliminate_sum},
{TI(opset3::Convert), &eliminate_convert},
{TI(op::v0::Slice), &eliminate_nop},

17
inference-engine/tests/functional/inference_engine/transformations/nop_elimination.cpp
View File

@ -25,23 +25,6 @@ NGRAPH_SUPPRESS_DEPRECATED_START
using namespace ngraph;
using namespace std;
TEST(nop_elimination, eliminate_pad) {
Shape shape_a{2};
auto A = make_shared<op::Parameter>(element::f32, shape_a);
Shape shape_b{};
auto B = make_shared<op::Parameter>(element::f32, shape_b);
CoordinateDiff padding_below{0};
CoordinateDiff padding_above{0};
auto p = make_shared<op::v0::Pad>(A, B, padding_below, padding_above);
auto f = make_shared<Function>(make_shared<op::v0::Abs>(p), ParameterVector{A, B});
pass::Manager pass_manager;
pass_manager.register_pass<pass::NopElimination>();
pass_manager.run_passes(f);
ASSERT_EQ(count_ops_of_type<op::v0::Pad>(f), 0);
}
TEST(nop_elimination, eliminate_sum) {
Shape shape{2, 2};
auto A = make_shared<op::Parameter>(element::f32, shape);

1
ngraph/core/include/ngraph/op/op_version_tbl.hpp
View File

@ -131,7 +131,6 @@ NGRAPH_OP(OneHot, ngraph::op::v0, 0)
NGRAPH_OP(Or, ngraph::op::v0, 0)
NGRAPH_OP(PRelu, ngraph::op::v0, 0)
NGRAPH_OP(PSROIPooling, ngraph::op::v0, 0)
NGRAPH_OP(Pad, ngraph::op::v0, 0)
NGRAPH_OP(Pad, ngraph::op::v1, 1)
NGRAPH_OP(Parameter, ngraph::op::v0, 0)
NGRAPH_OP(Power, ngraph::op::v0, 0)

73
ngraph/core/include/ngraph/op/pad.hpp
View File

@ -24,74 +24,6 @@ namespace ngraph
{
namespace op
{
namespace v0
{
/// \brief Generic padding operation.
class NGRAPH_DEPRECATED(
"This operation is deprecated and will be removed soon. Use v1::Pad instead of it.")
NGRAPH_API Pad : public Op
{
NGRAPH_SUPPRESS_DEPRECATED_START
public:
static constexpr NodeTypeInfo type_info{"Pad", 0};
const NodeTypeInfo& get_type_info() const override { return type_info; }
/// \brief Constructs a generic padding operation.
Pad() = default;
/// \brief Constructs a padding operation. Padding embeds the values of the input
/// tensor into a larger tensor initialized to arg_pad_value.
///
/// \param arg The node producing the input tensor to be padded.
/// \param arg_pad_value The node producing the scalar value
/// to be used outside the are initialized by arg when pad_mode is CONSTANT.
/// \param padding_below How many elements to add on
/// each axis before index 0 of arg. Rank must match arg.
/// \param padding_above How many elements to add on
/// each axis after the last element of arg. Rank must match arg.
/// \param pad_mode The padding mode: CONSTANT(default), EDGE, REFLECT or SYMMETRIC.
/// CONSTANT initializes new elements with arg_pad_value, EDGE uses the nearest
/// value from arg. REFLECT and SYMMETRIC tile the background by flipping arg
/// at the edge (SYMMETRIC) or on the last row/column/etc. (REFLECT).
Pad(const Output<Node>& arg,
const Output<Node>& arg_pad_value,
const CoordinateDiff& padding_below,
const CoordinateDiff& padding_above,
PadMode pad_mode = PadMode::CONSTANT);
virtual std::shared_ptr<Node>
clone_with_new_inputs(const OutputVector& new_args) const override;
void validate_and_infer_types() override;
/// \return The padding-below sizes.
const CoordinateDiff& get_padding_below() const { return m_padding_below; }
void set_padding_below(const CoordinateDiff& padding_below)
{
m_padding_below = padding_below;
}
/// \return The padding-above sizes.
const CoordinateDiff& get_padding_above() const { return m_padding_above; }
void set_padding_above(const CoordinateDiff& padding_above)
{
m_padding_above = padding_above;
}
/// \brief DEPRECATED. This is just a stub for backends that used to implement the
/// interior padding feature, which is no longer supported.
/// \return Returns a shape full of zeros,
/// with the same rank as get_padding_below().
const Shape& get_padding_interior() const { return m_padding_interior_fake; }
/// \return The padding mode.
PadMode get_pad_mode() const { return m_pad_mode; }
void set_pad_mode(PadMode pad_mode) { m_pad_mode = pad_mode; }
/// \return The default value for Pad.
virtual std::shared_ptr<Node> get_default_value() const override;
protected:
CoordinateDiff m_padding_below;
CoordinateDiff m_padding_above;
Shape m_padding_interior_fake; // LEGACY: This is all zeros.
PadMode m_pad_mode;
NGRAPH_SUPPRESS_DEPRECATED_END
};
}
namespace v1
{
/// \brief Generic padding operation.
@ -159,10 +91,5 @@ namespace ngraph
PadMode m_pad_mode;
};
}
// latest stable opset version
NGRAPH_SUPPRESS_DEPRECATED_START
using v0::Pad;
NGRAPH_SUPPRESS_DEPRECATED_END
}
}

114
ngraph/core/src/op/pad.cpp
View File

@ -27,120 +27,6 @@ NGRAPH_SUPPRESS_DEPRECATED_START
using namespace std;
using namespace ngraph;
constexpr NodeTypeInfo op::v0::Pad::type_info;
op::v0::Pad::Pad(const Output<Node>& arg,
const Output<Node>& arg_pad_value,
const CoordinateDiff& padding_below,
const CoordinateDiff& padding_above,
PadMode pad_mode)
: Op({arg, arg_pad_value})
, m_padding_below(padding_below)
, m_padding_above(padding_above)
, m_padding_interior_fake(padding_below.size())
, m_pad_mode(pad_mode)
{
constructor_validate_and_infer_types();
}
void op::v0::Pad::validate_and_infer_types()
{
element::Type result_et;
NODE_VALIDATION_CHECK(
this,
element::Type::merge(result_et, get_input_element_type(0), get_input_element_type(1)),
"Argument element types do not match (arg0 element type: ",
get_input_element_type(0),
", arg1 element type: ",
get_input_element_type(1),
").");
NODE_VALIDATION_CHECK(this,
get_input_partial_shape(1).compatible(PartialShape{}),
"Argument for padding value is not a scalar (shape: ",
get_input_partial_shape(1),
").");
auto arg_shape = get_input_partial_shape(0);
NODE_VALIDATION_CHECK(this,
m_padding_below.size() == m_padding_above.size(),
"Ranks for padding below (",
m_padding_below,
") and padding above (",
m_padding_above,
") do not match.");
size_t implied_rank = m_padding_below.size();
NODE_VALIDATION_CHECK(this,
arg_shape.rank().compatible(implied_rank),
"Rank for padding below and padding above do not match the rank of the ",
"data argument (padding below: ",
m_padding_below,
", padding above: ",
m_padding_above,
").");
std::vector<Dimension> result_dims(implied_rank, Dimension::dynamic());
if (arg_shape.rank().is_static())
{
for (size_t i = 0; i < implied_rank; i++)
{
if (arg_shape[i].is_static())
{
ptrdiff_t result_dim =
m_padding_below[i] + arg_shape[i].get_length() + m_padding_above[i];
NODE_VALIDATION_CHECK(this,
result_dim >= 0,
"Inferred result dimension at axis ",
i,
" is negative after padding (padding below: ",
m_padding_below,
", ",
", padding above: ",
m_padding_above,
").");
result_dims[i] = static_cast<size_t>(result_dim);
if (i > 1)
{
NODE_VALIDATION_CHECK(
this,
m_pad_mode != op::PadMode::EDGE || arg_shape[i].get_length() >= 1,
"EDGE padding mode requires an input of dimension of at least 1 at each "
"spatial axis.");
NODE_VALIDATION_CHECK(
this,
m_pad_mode != op::PadMode::REFLECT || arg_shape[i].get_length() >= 2,
"REFLECT padding mode requires an input of dimension of at least 2 at each "
"spatial axis.");
}
}
}
}
set_output_type(0, result_et, PartialShape(result_dims));
}
shared_ptr<Node> op::v0::Pad::clone_with_new_inputs(const OutputVector& new_args) const
{
check_new_args_count(this, new_args);
return make_shared<v0::Pad>(
new_args.at(0), new_args.at(1), m_padding_below, m_padding_above, m_pad_mode);
}
std::shared_ptr<Node> op::Pad::get_default_value() const
{
AxisSet axes{};
for (size_t i = 0; i < get_shape().size(); i++)
{
axes.insert(i);
}
return std::make_shared<op::Broadcast>(input_value(1), get_shape(), axes);
}
constexpr NodeTypeInfo op::v1::Pad::type_info;
op::v1::Pad::Pad(const Output<Node>& arg,

9
ngraph/test/op_is.cpp
View File

@ -605,15 +605,6 @@ namespace
EXPECT_TRUE(op::is_binary_elementwise_logical(&node));
}
void op_is_Pad()
{
op::Pad node;
EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
}
void op_is_Parameter()
{
op::Parameter node;

1
ngraph/test/runtime/interpreter/int_executable.hpp
View File

@ -1289,7 +1289,6 @@ protected:
case OP_TYPEID::NonZero_v3:
case OP_TYPEID::NotEqual:
case OP_TYPEID::Or:
case OP_TYPEID::Pad:
case OP_TYPEID::Power:
case OP_TYPEID::Product:
case OP_TYPEID::Range:

1
ngraph/test/runtime/opset0_tbl.hpp
View File

@ -110,7 +110,6 @@ NGRAPH_OP(Not, ngraph::op)
NGRAPH_OP(NotEqual, ngraph::op)
NGRAPH_OP(OneHot, ngraph::op)
NGRAPH_OP(Or, ngraph::op)
NGRAPH_OP(Pad, ngraph::op)
NGRAPH_OP(Parameter, ngraph::op)
NGRAPH_OP(Power, ngraph::op)
NGRAPH_OP(PRelu, ngraph::op)

382
ngraph/test/type_prop/pad.cpp
View File

@ -23,388 +23,6 @@ NGRAPH_SUPPRESS_DEPRECATED_START
using namespace std;
using namespace ngraph;
TEST(type_prop, pad_deduce_1d)
{
// Deduce type
auto param0 = make_shared<op::Parameter>(element::f32, Shape{50});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{});
CoordinateDiff padding_below{2};
CoordinateDiff padding_above{3};
auto pad = make_shared<op::Pad>(param0, param1, padding_below, padding_above);
EXPECT_EQ(pad->get_element_type(), element::f32);
EXPECT_EQ(pad->get_shape(), (Shape{55}));
EXPECT_EQ(pad->get_padding_below(), (CoordinateDiff{2}));
EXPECT_EQ(pad->get_padding_above(), (CoordinateDiff{3}));
}
TEST(type_prop, pad_deduce_2d)
{
// Deduce type
auto param0 = make_shared<op::Parameter>(element::f32, Shape{50, 40});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{});
CoordinateDiff padding_below{5, 3};
CoordinateDiff padding_above{6, 9};
auto pad = make_shared<op::Pad>(param0, param1, padding_below, padding_above);
EXPECT_EQ(pad->get_element_type(), element::f32);
EXPECT_EQ(pad->get_shape(), (Shape{61, 52}));
EXPECT_EQ(pad->get_padding_below(), (CoordinateDiff{5, 3}));
EXPECT_EQ(pad->get_padding_above(), (CoordinateDiff{6, 9}));
}
TEST(type_prop, pad_deduce_3d)
{
// Deduce type
auto param0 = make_shared<op::Parameter>(element::f32, Shape{50, 40, 20});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{});
CoordinateDiff padding_below{5, 3, 0};
CoordinateDiff padding_above{6, 9, 4};
auto pad = make_shared<op::Pad>(param0, param1, padding_below, padding_above);
EXPECT_EQ(pad->get_element_type(), element::f32);
EXPECT_EQ(pad->get_shape(), (Shape{61, 52, 24}));
EXPECT_EQ(pad->get_padding_below(), (CoordinateDiff{5, 3, 0}));
EXPECT_EQ(pad->get_padding_above(), (CoordinateDiff{6, 9, 4}));
}
TEST(type_prop, pad_deduce_3d_neg)
{
// Deduce type
auto param0 = make_shared<op::Parameter>(element::f32, Shape{50, 40, 20});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{});
CoordinateDiff padding_below{-5, 3, -2};
CoordinateDiff padding_above{-6, -9, 4};
auto pad = make_shared<op::Pad>(param0, param1, padding_below, padding_above);
EXPECT_EQ(pad->get_element_type(), element::f32);
EXPECT_EQ(pad->get_shape(), (Shape{39, 34, 22}));
EXPECT_EQ(pad->get_padding_below(), (CoordinateDiff{-5, 3, -2}));
EXPECT_EQ(pad->get_padding_above(), (CoordinateDiff{-6, -9, 4}));
}
TEST(type_prop, pad_deduce_element_type_mismatch)
{
// Deduce type
auto param0 = make_shared<op::Parameter>(element::f32, Shape{50, 40, 20});
auto param1 = make_shared<op::Parameter>(element::i32, Shape{});
CoordinateDiff padding_below{5, 3, 0};
CoordinateDiff padding_above{6, 9, 4};
try
{
auto pad = make_shared<op::Pad>(param0, param1, padding_below, padding_above);
// Should have thrown, so fail if it didn't
FAIL() << "Element tpye mismatch not detected";
}
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(), std::string("Argument element types do not match"));
}
catch (...)
{
FAIL() << "Deduced type check failed for unexpected reason";
}
}
TEST(type_prop, pad_deduce_nonscalar_pad_value)
{
// Deduce type
auto param0 = make_shared<op::Parameter>(element::f32, Shape{50, 40, 20});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{6});
CoordinateDiff padding_below{5, 3, 0};
CoordinateDiff padding_above{6, 9, 4};
try
{
auto pad = make_shared<op::Pad>(param0, param1, padding_below, padding_above);
// Should have thrown, so fail if it didn't
FAIL() << "Non-scalar pad value not detected";
}
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Argument for padding value is not a scalar"));
}
catch (...)
{
FAIL() << "Deduced type check failed for unexpected reason";
}
}
TEST(type_prop, pad_deduce_below_padding_wrong_rank)
{
// Deduce type
auto param0 = make_shared<op::Parameter>(element::f32, Shape{50, 40, 20});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{});
CoordinateDiff padding_below{5, 3, 0, 6};
CoordinateDiff padding_above{6, 9, 4};
try
{
auto pad = make_shared<op::Pad>(param0, param1, padding_below, padding_above);
// Should have thrown, so fail if it didn't
FAIL() << "Wrong below-padding rank not detected";
}
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Ranks for padding below (CoordinateDiff{5, 3, 0, 6}) and "
"padding above (CoordinateDiff{6, 9, "
"4}) do not match"));
}
catch (...)
{
FAIL() << "Deduced type check failed for unexpected reason";
}
}
TEST(type_prop, pad_deduce_above_padding_wrong_rank)
{
// Deduce type
auto param0 = make_shared<op::Parameter>(element::f32, Shape{50, 40, 20});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{});
CoordinateDiff padding_below{5, 3, 0};
CoordinateDiff padding_above{6, 9};
try
{
auto pad = make_shared<op::Pad>(param0, param1, padding_below, padding_above);
// Should have thrown, so fail if it didn't
FAIL() << "Wrong above-padding rank not detected";
}
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Ranks for padding below (CoordinateDiff{5, 3, 0}) and "
"padding above (CoordinateDiff{6, 9}) do not match"));
}
catch (...)
{
FAIL() << "Deduced type check failed for unexpected reason";
}
}
TEST(type_prop, pad_deduce_too_small_for_edge)
{
// Deduce type
auto param0 = make_shared<op::Parameter>(element::f32, Shape{1, 5, 0, 2});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{});
CoordinateDiff padding_below{0, 1, 2, 3};
CoordinateDiff padding_above{0, 1, 2, 3};
try
{
auto pad =
make_shared<op::Pad>(param0, param1, padding_below, padding_above, op::PadMode::EDGE);
// Should have thrown, so fail if it didn't
FAIL() << "Input too small for edge padding not detected";
}
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("EDGE padding mode requires an input of dimension of at "
"least 1 at each spatial axis"));
}
catch (...)
{
FAIL() << "Deduced type check failed for unexpected reason";
}
}
TEST(type_prop, pad_deduce_too_small_for_reflect)
{
// Deduce type
auto param0 = make_shared<op::Parameter>(element::f32, Shape{1, 5, 1, 2});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{});
CoordinateDiff padding_below{0, 1, 2, 3};
CoordinateDiff padding_above{0, 1, 2, 3};
try
{
auto pad = make_shared<op::Pad>(
param0, param1, padding_below, padding_above, op::PadMode::REFLECT);
// Should have thrown, so fail if it didn't
FAIL() << "Input too small for reflect padding not detected";
}
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("REFLECT padding mode requires an input of dimension of "
"at least 2 at each spatial axis"));
}
catch (...)
{
FAIL() << "Deduced type check failed for unexpected reason";
}
}
TEST(type_prop, pad_deduce_too_much_negative_padding)
{
// Deduce type
auto param0 = make_shared<op::Parameter>(element::f32, Shape{5, 4, 2});
auto param1 = make_shared<op::Parameter>(element::f32, Shape{});
CoordinateDiff padding_below{5, 3, 0};
CoordinateDiff padding_above{6, 9, -3};
try
{
auto pad = make_shared<op::Pad>(param0, param1, padding_below, padding_above);
// Should have thrown, so fail if it didn't
FAIL() << "Too much negative padding not detected";
}
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
std::string("Inferred result dimension at axis 2 is negative after padding"));
}
catch (...)
{
FAIL() << "Deduced type check failed for unexpected reason";
}
}
TEST(type_prop, pad_partial_data_rank_dynamic_padding_rank_dynamic_ok)
{
auto param0 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
CoordinateDiff padding_below{2, 4, 6};
CoordinateDiff padding_above{8, 2, 3};
auto pad = make_shared<op::Pad>(param0, param1, padding_below, padding_above);
ASSERT_EQ(pad->get_output_element_type(0), element::f32);
ASSERT_TRUE(pad->get_output_partial_shape(0).same_scheme(
PartialShape{Dimension::dynamic(), Dimension::dynamic(), Dimension::dynamic()}));
}
TEST(type_prop, pad_partial_data_rank_dynamic_padding_rank_dynamic_attribs_rank_inconsistent)
{
auto param0 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
CoordinateDiff padding_below{2, 4, 6};
CoordinateDiff padding_above{8, 2, 3, 0};
try
{
auto pad = make_shared<op::Pad>(param0, param1, padding_below, padding_above);
FAIL() << "Inconsistent attribute ranks not detected (rank-dynamic/rank-dynamic arguments)";
}
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Ranks for padding below (CoordinateDiff{2, 4, 6}) and "
"padding above (CoordinateDiff{8, 2, 3, "
"0}) do not match"));
}
catch (...)
{
FAIL() << "Deduced type check failed for unexpected reason";
}
}
TEST(type_prop, pad_partial_data_rank_static_dynamic_padding_rank_dynamic_ok)
{
auto param0 = make_shared<op::Parameter>(
element::f32,
PartialShape{Dimension::dynamic(), Dimension::dynamic(), Dimension::dynamic()});
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
CoordinateDiff padding_below{2, 4, 6};
CoordinateDiff padding_above{8, 2, 3};
auto pad = make_shared<op::Pad>(param0, param1, padding_below, padding_above);
ASSERT_EQ(pad->get_output_element_type(0), element::f32);
ASSERT_TRUE(pad->get_output_partial_shape(0).same_scheme(
PartialShape{Dimension::dynamic(), Dimension::dynamic(), Dimension::dynamic()}));
}
TEST(type_prop, pad_partial_data_rank_static_dynamic_some_dims_known_padding_rank_dynamic_ok)
{
auto param0 =
make_shared<op::Parameter>(element::f32, PartialShape{3, 5, Dimension::dynamic()});
auto param1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
CoordinateDiff padding_below{2, 4, 6};
CoordinateDiff padding_above{8, 2, 3};
auto pad = make_shared<op::Pad>(param0, param1, padding_below, padding_above);
ASSERT_EQ(pad->get_output_element_type(0), element::f32);
ASSERT_TRUE(
pad->get_output_partial_shape(0).same_scheme(PartialShape{13, 11, Dimension::dynamic()}));
}
TEST(type_prop, pad_partial_data_rank_dynamic_padding_static_ok)
{
auto param0 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto param1 = make_shared<op::Parameter>(element::f32, Shape{});
CoordinateDiff padding_below{2, 4, 6};
CoordinateDiff padding_above{8, 2, 3};
auto pad = make_shared<op::Pad>(param0, param1, padding_below, padding_above);
ASSERT_EQ(pad->get_output_element_type(0), element::f32);
ASSERT_TRUE(pad->get_output_partial_shape(0).same_scheme(
PartialShape{Dimension::dynamic(), Dimension::dynamic(), Dimension::dynamic()}));
}
TEST(type_prop, pad_partial_data_rank_dynamic_padding_static_wrong_padding_rank)
{
auto param0 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto param1 = make_shared<op::Parameter>(element::f32, Shape{2, 3, 8});
CoordinateDiff padding_below{2, 4, 6};
CoordinateDiff padding_above{8, 2, 3};
try
{
auto pad = make_shared<op::Pad>(param0, param1, padding_below, padding_above);
FAIL() << "Wrong padding rank not detected (rank-dynamic/static arguments)";
}
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(
error.what(),
std::string("Argument for padding value is not a scalar (shape: {2,3,8})"));
}
catch (...)
{
FAIL() << "Deduced type check failed for unexpected reason";
}
}
TEST(type_prop, pad_partial_data_rank_dynamic_padding_static_attribs_rank_inconsistent)
{
auto param0 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
auto param1 = make_shared<op::Parameter>(element::f32, Shape{});
CoordinateDiff padding_below{2, 4, 6};
CoordinateDiff padding_above{8, 2, 3, 4};
try
{
auto pad = make_shared<op::Pad>(param0, param1, padding_below, padding_above);
FAIL() << "Wrong padding rank not detected (rank-dynamic/static arguments)";
}
catch (const NodeValidationFailure& error)
{
EXPECT_HAS_SUBSTRING(error.what(),
std::string("Ranks for padding below (CoordinateDiff{2, 4, 6}) and "
"padding above (CoordinateDiff{8, 2, 3, "
"4}) do not match"));
}
catch (...)
{
FAIL() << "Deduced type check failed for unexpected reason";
}
}
TEST(type_prop, pad_v1_arg_pad_value_type_mismatch)
{
auto arg = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});