From 3f35746c45e0431e37c7a87ac596d24077b0d451 Mon Sep 17 00:00:00 2001 From: Mateusz Tabaka Date: Mon, 2 Nov 2020 04:46:30 +0100 Subject: [PATCH] Remove deprecated v0::Reverse op (#2899) * Remove deprecated v0::Reverse op * fix unit tests * add include for std::inserter --- .../core/include/ngraph/op/op_version_tbl.hpp | 1 - ngraph/core/include/ngraph/op/reverse.hpp | 65 ------- ngraph/core/src/op/reverse.cpp | 117 +++++++------ ngraph/test/backend/broadcast.in.cpp | 3 +- ngraph/test/backend/dynamic.in.cpp | 3 +- ngraph/test/backend/reverse.in.cpp | 165 +++++++++--------- ngraph/test/constant_folding.cpp | 22 ++- ngraph/test/op_is.cpp | 2 +- ngraph/test/pass_shape_relevance.cpp | 9 +- ngraph/test/runtime/ie/unit_test.manifest | 4 +- .../runtime/interpreter/int_executable.hpp | 12 +- .../runtime/interpreter/opset_int_tbl.hpp | 1 + ngraph/test/runtime/opset0_tbl.hpp | 1 - ngraph/test/runtime/pass/opset0_downgrade.cpp | 36 +--- ngraph/test/runtime/pass/opset1_upgrade.cpp | 16 -- ngraph/test/type_prop/reverse.cpp | 101 +++++------ 16 files changed, 226 insertions(+), 332 deletions(-) diff --git a/ngraph/core/include/ngraph/op/op_version_tbl.hpp b/ngraph/core/include/ngraph/op/op_version_tbl.hpp index 288e4dd4a23..d1a73b6c42a 100644 --- a/ngraph/core/include/ngraph/op/op_version_tbl.hpp +++ b/ngraph/core/include/ngraph/op/op_version_tbl.hpp @@ -149,7 +149,6 @@ NGRAPH_OP(ReorgYolo, ngraph::op::v0, 0) NGRAPH_OP(Reshape, ngraph::op::v0, 0) NGRAPH_OP(Reshape, ngraph::op::v1, 1) NGRAPH_OP(Result, ngraph::op::v0, 0) -NGRAPH_OP(Reverse, ngraph::op::v0, 0) NGRAPH_OP(Reverse, ngraph::op::v1, 1) NGRAPH_OP(ReverseSequence, ngraph::op::v0, 0) NGRAPH_OP(Round, ngraph::op::v0, 0) diff --git a/ngraph/core/include/ngraph/op/reverse.hpp b/ngraph/core/include/ngraph/op/reverse.hpp index 221999ff17c..7e9539e3738 100644 --- a/ngraph/core/include/ngraph/op/reverse.hpp +++ b/ngraph/core/include/ngraph/op/reverse.hpp @@ -22,67 +22,6 @@ namespace ngraph { namespace op { - namespace v0 - { - // clang-format off - /// \brief Axis-reverse operation. - /// - /// Reverses the direction of zero or more axes in a tensor, where "reversing" an axis means - /// that at the output tensor. - /// - /// ## Parameters - /// - /// | | Description | - /// | --------------- | ------------------------ | - /// | `reversed_axes` | The axes to be reversed. | - /// - /// ## Inputs - /// - /// | | Type | Description | - /// | ----- | --------------------------------- | -------------------------------------- | - /// | `arg` | \f$E[d_1,\dots,d_n]~(n \geq 0)\f$ | An input tensor of any type and shape. | - /// - /// ## Output - /// - /// | Type | Description | - /// | ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - /// | \f$E[d_1,\dots,d_n]\f$ | The tensor \f$T\f$, where \f$T[i_1,\dots,i_n] = \texttt{arg}[j_1,\dots,j_n]\f$ and \f$j_k = d_k - i_k - 1\f$ if axis \f$k\f$ is in the reverse set; else \f$j_k = i_k\f$. | - // clang-format on - class NGRAPH_DEPRECATED( - "This operation is deprecated and will be removed soon. " - "Use v1::Reverse instead of it.") NGRAPH_API Reverse : public Op - { - NGRAPH_SUPPRESS_DEPRECATED_START - public: - static constexpr NodeTypeInfo type_info{"Reverse", 0}; - const NodeTypeInfo& get_type_info() const override { return type_info; } - Reverse() = default; - /// \brief Constructs a reverse operation. - /// - /// \param arg The input tensor, some of whose axes are to be reversed. - /// \param reversed_axes The axes to reverse. - Reverse(const Output& arg, const AxisSet& reversed_axes); - - void validate_and_infer_types() override; - - virtual std::shared_ptr - clone_with_new_inputs(const OutputVector& new_args) const override; - - /// \return The set of axes to reverse. - const AxisSet& get_reversed_axes() const { return m_reversed_axes; } - void set_reversed_axes(const AxisSet& reversed_axes) - { - m_reversed_axes = reversed_axes; - } - bool evaluate(const HostTensorVector& outputs, - const HostTensorVector& inputs) const override; - - protected: - AxisSet m_reversed_axes; - NGRAPH_SUPPRESS_DEPRECATED_END - }; - } - namespace v1 { class NGRAPH_API Reverse : public Op @@ -136,10 +75,6 @@ namespace ngraph Mode m_mode; }; } - // default opset version - NGRAPH_SUPPRESS_DEPRECATED_START - using v0::Reverse; - NGRAPH_SUPPRESS_DEPRECATED_END } NGRAPH_API diff --git a/ngraph/core/src/op/reverse.cpp b/ngraph/core/src/op/reverse.cpp index 7f6a96ed8db..fe929235617 100644 --- a/ngraph/core/src/op/reverse.cpp +++ b/ngraph/core/src/op/reverse.cpp @@ -15,6 +15,7 @@ //***************************************************************************** #include +#include #include #include "ngraph/attribute_visitor.hpp" @@ -24,49 +25,9 @@ #include "ngraph/op/util/op_types.hpp" #include "ngraph/runtime/reference/reverse.hpp" -NGRAPH_SUPPRESS_DEPRECATED_START - using namespace std; using namespace ngraph; -constexpr NodeTypeInfo op::v0::Reverse::type_info; - -op::v0::Reverse::Reverse(const Output& arg, const AxisSet& reversed_axes) - : Op({arg}) - , m_reversed_axes(reversed_axes) -{ - constructor_validate_and_infer_types(); -} - -void op::v0::Reverse::validate_and_infer_types() -{ - const auto input_shape = get_input_partial_shape(0); - const Dimension input_rank = input_shape.rank(); - - if (input_rank.is_static()) - { - // Make sure all reversed axis indices are valid. - for (size_t axis : m_reversed_axes) - { - NODE_VALIDATION_CHECK(this, - axis < input_rank.get_length(), - "Reverse axis (", - axis, - ") is out of bounds (argument shape: ", - input_shape, - ")."); - } - } - - set_output_type(0, get_input_element_type(0), input_shape); -} - -shared_ptr op::v0::Reverse::clone_with_new_inputs(const OutputVector& new_args) const -{ - check_new_args_count(this, new_args); - return make_shared(new_args.at(0), m_reversed_axes); -} - constexpr NodeTypeInfo op::v1::Reverse::type_info; op::v1::Reverse::Reverse(const Output& data, @@ -186,27 +147,75 @@ op::v1::Reverse::Mode op::v1::Reverse::mode_from_string(const std::string& mode) return allowed_values.at(mode); } -bool op::v0::Reverse::evaluate(const HostTensorVector& outputs, - const HostTensorVector& inputs) const -{ - runtime::reference::reverse(inputs[0]->get_data_ptr(), - outputs[0]->get_data_ptr(), - inputs[0]->get_shape(), - outputs[0]->get_shape(), - get_reversed_axes(), - inputs[0]->get_element_type().size()); - return true; -} + bool op::v1::Reverse::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const { AxisSet axes{}; + size_t axes_rank = inputs[1]->get_element_count(); if (get_mode() == op::v1::Reverse::Mode::INDEX) { - auto axes_mask = inputs[1]->get_data_ptr(); - for (size_t i = 0; i < inputs[1]->get_element_count(); ++i) + switch (inputs[1]->get_element_type()) { - axes.emplace(i); + case element::Type_t::i8: + { + auto axes_indices = inputs[1]->get_data_ptr(); + std::copy(axes_indices, axes_indices + axes_rank, std::inserter(axes, axes.end())); + break; + } + case element::Type_t::u8: + { + auto axes_indices = inputs[1]->get_data_ptr(); + std::copy(axes_indices, axes_indices + axes_rank, std::inserter(axes, axes.end())); + break; + } + case element::Type_t::i16: + { + auto axes_indices = inputs[1]->get_data_ptr(); + std::copy(axes_indices, axes_indices + axes_rank, std::inserter(axes, axes.end())); + break; + } + case element::Type_t::u16: + { + auto axes_indices = inputs[1]->get_data_ptr(); + std::copy(axes_indices, axes_indices + axes_rank, std::inserter(axes, axes.end())); + break; + } + case element::Type_t::i32: + { + auto axes_indices = inputs[1]->get_data_ptr(); + std::copy(axes_indices, axes_indices + axes_rank, std::inserter(axes, axes.end())); + break; + } + case element::Type_t::u32: + { + auto axes_indices = inputs[1]->get_data_ptr(); + std::copy(axes_indices, axes_indices + axes_rank, std::inserter(axes, axes.end())); + break; + } + case element::Type_t::i64: + { + auto axes_indices = inputs[1]->get_data_ptr(); + std::copy(axes_indices, axes_indices + axes_rank, std::inserter(axes, axes.end())); + break; + } + case element::Type_t::u64: + { + auto axes_indices = inputs[1]->get_data_ptr(); + std::copy(axes_indices, axes_indices + axes_rank, std::inserter(axes, axes.end())); + break; + } + case element::Type_t::undefined: + case element::Type_t::dynamic: + case element::Type_t::boolean: + case element::Type_t::bf16: + case element::Type_t::f16: + case element::Type_t::f32: + case element::Type_t::f64: + case element::Type_t::u1: + default: + NGRAPH_CHECK(false, "Not supported axes type", inputs[1]->get_element_type()); + break; } } else // Mode::MASK diff --git a/ngraph/test/backend/broadcast.in.cpp b/ngraph/test/backend/broadcast.in.cpp index 176ae897f9f..25b5ac6976b 100644 --- a/ngraph/test/backend/broadcast.in.cpp +++ b/ngraph/test/backend/broadcast.in.cpp @@ -195,7 +195,8 @@ NGRAPH_TEST(${BACKEND_NAME}, broadcast_vector_rowwise_reversed) A, op::Constant::create(element::u64, Shape{shape_r.size()}, shape_r), op::Constant::create(element::i64, Shape{1}, {1})); - auto reverse = make_shared(broadcast, AxisSet{1}); + auto reverse = make_shared( + broadcast, op::Constant::create(element::i64, {1}, {1}), op::v1::Reverse::Mode::INDEX); auto f = make_shared(reverse, ParameterVector{A}); auto backend = runtime::Backend::create("${BACKEND_NAME}"); diff --git a/ngraph/test/backend/dynamic.in.cpp b/ngraph/test/backend/dynamic.in.cpp index 59cb8de15d6..3fa206b6486 100644 --- a/ngraph/test/backend/dynamic.in.cpp +++ b/ngraph/test/backend/dynamic.in.cpp @@ -243,7 +243,8 @@ static void reverse_shape_test(const PartialShape& input_pshape, auto x = make_shared(element::f32, input_pshape); shared_ptr x_new_shape = make_shared(x); - x_new_shape = make_shared(x_new_shape, AxisSet{0}); + x_new_shape = make_shared( + x_new_shape, op::Constant::create(element::i64, {1}, {0}), op::v1::Reverse::Mode::INDEX); auto x_reshaped = make_shared(x, x_new_shape, true); diff --git a/ngraph/test/backend/reverse.in.cpp b/ngraph/test/backend/reverse.in.cpp index 914838b4413..90caa46a9b9 100644 --- a/ngraph/test/backend/reverse.in.cpp +++ b/ngraph/test/backend/reverse.in.cpp @@ -24,57 +24,19 @@ #include "util/test_control.hpp" #include "util/test_tools.hpp" -NGRAPH_SUPPRESS_DEPRECATED_START - using namespace std; using namespace ngraph; static string s_manifest = "${MANIFEST}"; -NGRAPH_TEST(${BACKEND_NAME}, reverse_0d) -{ - Shape shape{}; - auto A = make_shared(element::f32, shape); - auto f = make_shared(make_shared(A, AxisSet{}), ParameterVector{A}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape); - copy_data(a, vector{6}); - auto result = backend->create_tensor(element::f32, shape); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f( - (vector{6}), read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, reverse_1d_nochange) +NGRAPH_TEST(${BACKEND_NAME}, reverse_1d) { Shape shape{8}; auto A = make_shared(element::f32, shape); - auto f = make_shared(make_shared(A, AxisSet{}), ParameterVector{A}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape); - copy_data(a, vector{0, 1, 2, 3, 4, 5, 6, 7}); - auto result = backend->create_tensor(element::f32, shape); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f((vector{0, 1, 2, 3, 4, 5, 6, 7}), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, reverse_1d_0) -{ - Shape shape{8}; - auto A = make_shared(element::f32, shape); - auto f = make_shared(make_shared(A, AxisSet{0}), ParameterVector{A}); + auto f = make_shared( + make_shared( + A, op::Constant::create(element::i64, {1}, {0}), op::v1::Reverse::Mode::INDEX), + ParameterVector{A}); auto backend = runtime::Backend::create("${BACKEND_NAME}"); @@ -90,33 +52,14 @@ NGRAPH_TEST(${BACKEND_NAME}, reverse_1d_0) MIN_FLOAT_TOLERANCE_BITS)); } -NGRAPH_TEST(${BACKEND_NAME}, reverse_2d_nochange) -{ - Shape shape{4, 3}; - auto A = make_shared(element::f32, shape); - auto f = make_shared(make_shared(A, AxisSet{}), ParameterVector{A}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape); - copy_data(a, - test::NDArray({{0, 1, 2}, {3, 4, 5}, {6, 7, 8}, {9, 10, 11}}).get_vector()); - auto result = backend->create_tensor(element::f32, shape); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f( - (test::NDArray({{0, 1, 2}, {3, 4, 5}, {6, 7, 8}, {9, 10, 11}}).get_vector()), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - NGRAPH_TEST(${BACKEND_NAME}, reverse_2d_0) { Shape shape{4, 3}; auto A = make_shared(element::f32, shape); - auto f = make_shared(make_shared(A, AxisSet{0}), ParameterVector{A}); + auto f = make_shared( + make_shared( + A, op::Constant::create(element::i64, {1}, {0}), op::v1::Reverse::Mode::INDEX), + ParameterVector{A}); auto backend = runtime::Backend::create("${BACKEND_NAME}"); @@ -138,7 +81,36 @@ NGRAPH_TEST(${BACKEND_NAME}, reverse_2d_1) { Shape shape{4, 3}; auto A = make_shared(element::f32, shape); - auto f = make_shared(make_shared(A, AxisSet{1}), ParameterVector{A}); + auto f = make_shared( + make_shared( + A, op::Constant::create(element::i64, {1}, {1}), op::v1::Reverse::Mode::INDEX), + ParameterVector{A}); + + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + + // Create some tensors for input/output + auto a = backend->create_tensor(element::f32, shape); + copy_data(a, + test::NDArray({{0, 1, 2}, {3, 4, 5}, {6, 7, 8}, {9, 10, 11}}).get_vector()); + auto result = backend->create_tensor(element::f32, shape); + + auto handle = backend->compile(f); + handle->call_with_validate({result}, {a}); + EXPECT_TRUE(test::all_close_f( + (test::NDArray({{2, 1, 0}, {5, 4, 3}, {8, 7, 6}, {11, 10, 9}}).get_vector()), + read_vector(result), + MIN_FLOAT_TOLERANCE_BITS)); +} + +NGRAPH_TEST(${BACKEND_NAME}, reverse_2d_1_mask) +{ + Shape shape{4, 3}; + auto A = make_shared(element::f32, shape); + auto f = make_shared( + make_shared(A, + op::Constant::create(element::boolean, {2}, {false, true}), + op::v1::Reverse::Mode::MASK), + ParameterVector{A}); auto backend = runtime::Backend::create("${BACKEND_NAME}"); @@ -160,7 +132,10 @@ NGRAPH_TEST(${BACKEND_NAME}, reverse_2d_01) { Shape shape{4, 3}; auto A = make_shared(element::f32, shape); - auto f = make_shared(make_shared(A, AxisSet{0, 1}), ParameterVector{A}); + auto f = make_shared( + make_shared( + A, op::Constant::create(element::i64, {2}, {0, 1}), op::v1::Reverse::Mode::INDEX), + ParameterVector{A}); auto backend = runtime::Backend::create("${BACKEND_NAME}"); @@ -178,28 +153,28 @@ NGRAPH_TEST(${BACKEND_NAME}, reverse_2d_01) MIN_FLOAT_TOLERANCE_BITS)); } -NGRAPH_TEST(${BACKEND_NAME}, reverse_3d_nochange) +NGRAPH_TEST(${BACKEND_NAME}, reverse_2d_01_mask) { - Shape shape{2, 4, 3}; + Shape shape{4, 3}; auto A = make_shared(element::f32, shape); - auto f = make_shared(make_shared(A, AxisSet{}), ParameterVector{A}); + auto f = make_shared( + make_shared(A, + op::Constant::create(element::boolean, {2}, {true, true}), + op::v1::Reverse::Mode::MASK), + ParameterVector{A}); auto backend = runtime::Backend::create("${BACKEND_NAME}"); // Create some tensors for input/output auto a = backend->create_tensor(element::f32, shape); copy_data(a, - test::NDArray({{{0, 1, 2}, {3, 4, 5}, {6, 7, 8}, {9, 10, 11}}, - {{12, 13, 14}, {15, 16, 17}, {18, 19, 20}, {21, 22, 23}}}) - .get_vector()); + test::NDArray({{0, 1, 2}, {3, 4, 5}, {6, 7, 8}, {9, 10, 11}}).get_vector()); auto result = backend->create_tensor(element::f32, shape); auto handle = backend->compile(f); handle->call_with_validate({result}, {a}); EXPECT_TRUE(test::all_close_f( - (test::NDArray({{{0, 1, 2}, {3, 4, 5}, {6, 7, 8}, {9, 10, 11}}, - {{12, 13, 14}, {15, 16, 17}, {18, 19, 20}, {21, 22, 23}}}) - .get_vector()), + (test::NDArray({{11, 10, 9}, {8, 7, 6}, {5, 4, 3}, {2, 1, 0}}).get_vector()), read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); } @@ -208,7 +183,10 @@ NGRAPH_TEST(${BACKEND_NAME}, reverse_3d_0) { Shape shape{2, 4, 3}; auto A = make_shared(element::f32, shape); - auto f = make_shared(make_shared(A, AxisSet{0}), ParameterVector{A}); + auto f = make_shared( + make_shared( + A, op::Constant::create(element::i64, {1}, {0}), op::v1::Reverse::Mode::INDEX), + ParameterVector{A}); auto backend = runtime::Backend::create("${BACKEND_NAME}"); @@ -234,7 +212,10 @@ NGRAPH_TEST(${BACKEND_NAME}, reverse_3d_1) { Shape shape{2, 4, 3}; auto A = make_shared(element::f32, shape); - auto f = make_shared(make_shared(A, AxisSet{1}), ParameterVector{A}); + auto f = make_shared( + make_shared( + A, op::Constant::create(element::i64, {1}, {1}), op::v1::Reverse::Mode::INDEX), + ParameterVector{A}); auto backend = runtime::Backend::create("${BACKEND_NAME}"); @@ -260,7 +241,10 @@ NGRAPH_TEST(${BACKEND_NAME}, reverse_3d_2) { Shape shape{2, 4, 3}; auto A = make_shared(element::f32, shape); - auto f = make_shared(make_shared(A, AxisSet{2}), ParameterVector{A}); + auto f = make_shared( + make_shared( + A, op::Constant::create(element::i64, {1}, {2}), op::v1::Reverse::Mode::INDEX), + ParameterVector{A}); auto backend = runtime::Backend::create("${BACKEND_NAME}"); @@ -286,7 +270,10 @@ NGRAPH_TEST(${BACKEND_NAME}, reverse_3d_01) { Shape shape{2, 4, 3}; auto A = make_shared(element::f32, shape); - auto f = make_shared(make_shared(A, AxisSet{0, 1}), ParameterVector{A}); + auto f = make_shared( + make_shared( + A, op::Constant::create(element::i64, {2}, {0, 1}), op::v1::Reverse::Mode::INDEX), + ParameterVector{A}); auto backend = runtime::Backend::create("${BACKEND_NAME}"); @@ -312,7 +299,10 @@ NGRAPH_TEST(${BACKEND_NAME}, reverse_3d_02) { Shape shape{2, 4, 3}; auto A = make_shared(element::f32, shape); - auto f = make_shared(make_shared(A, AxisSet{0, 2}), ParameterVector{A}); + auto f = make_shared( + make_shared( + A, op::Constant::create(element::i64, {2}, {0, 2}), op::v1::Reverse::Mode::INDEX), + ParameterVector{A}); auto backend = runtime::Backend::create("${BACKEND_NAME}"); @@ -338,7 +328,10 @@ NGRAPH_TEST(${BACKEND_NAME}, reverse_3d_12) { Shape shape{2, 4, 3}; auto A = make_shared(element::f32, shape); - auto f = make_shared(make_shared(A, AxisSet{1, 2}), ParameterVector{A}); + auto f = make_shared( + make_shared( + A, op::Constant::create(element::i64, {2}, {1, 2}), op::v1::Reverse::Mode::INDEX), + ParameterVector{A}); auto backend = runtime::Backend::create("${BACKEND_NAME}"); @@ -364,8 +357,10 @@ NGRAPH_TEST(${BACKEND_NAME}, reverse_3d_012) { Shape shape{2, 4, 3}; auto A = make_shared(element::f32, shape); - auto f = - make_shared(make_shared(A, AxisSet{0, 1, 2}), ParameterVector{A}); + auto f = make_shared( + make_shared( + A, op::Constant::create(element::i64, {3}, {0, 1, 2}), op::v1::Reverse::Mode::INDEX), + ParameterVector{A}); auto backend = runtime::Backend::create("${BACKEND_NAME}"); diff --git a/ngraph/test/constant_folding.cpp b/ngraph/test/constant_folding.cpp index 3dedc58f8d0..1b792a56172 100644 --- a/ngraph/test/constant_folding.cpp +++ b/ngraph/test/constant_folding.cpp @@ -800,13 +800,14 @@ TEST(constant_folding, shape_of_rank_dynamic_v3) ASSERT_EQ(result_shape_of->get_friendly_name(), "test"); } -TEST(constant_folding, const_reverse) +void const_reverse(const element::Type& axes_elem_type) { Shape input_shape{3, 3}; vector values_in{1, 2, 3, 4, 5, 6, 7, 8, 9}; auto constant = op::Constant::create(element::i32, input_shape, values_in); - auto convert = make_shared(constant, AxisSet{1}); + auto axes = op::Constant::create(axes_elem_type, {1}, {1}); + auto convert = make_shared(constant, axes, op::v1::Reverse::Mode::INDEX); convert->set_friendly_name("test"); auto f = make_shared(convert, ParameterVector{}); @@ -814,7 +815,7 @@ TEST(constant_folding, const_reverse) pass_manager.register_pass(); pass_manager.run_passes(f); - ASSERT_EQ(count_ops_of_type(f), 0); + ASSERT_EQ(count_ops_of_type(f), 0); ASSERT_EQ(count_ops_of_type(f), 1); auto new_const = @@ -827,6 +828,21 @@ TEST(constant_folding, const_reverse) ASSERT_EQ(values_expected, values_out); } +TEST(constant_folding, const_reverse) +{ + for (auto&& axes_elem_type : {element::i8, + element::u8, + element::i16, + element::u16, + element::i32, + element::u32, + element::i64, + element::u64}) + { + const_reverse(axes_elem_type); + } +} + TEST(constant_folding, const_reduceprod) { Shape input_shape{3, 3}; diff --git a/ngraph/test/op_is.cpp b/ngraph/test/op_is.cpp index 3038a88cc27..176488032fe 100644 --- a/ngraph/test/op_is.cpp +++ b/ngraph/test/op_is.cpp @@ -661,7 +661,7 @@ namespace void op_is_Reverse() { - op::Reverse node; + op::v1::Reverse 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)); diff --git a/ngraph/test/pass_shape_relevance.cpp b/ngraph/test/pass_shape_relevance.cpp index 18a49daaa04..18470dc0511 100644 --- a/ngraph/test/pass_shape_relevance.cpp +++ b/ngraph/test/pass_shape_relevance.cpp @@ -133,7 +133,8 @@ TEST(shape_relevance, param_shape_of_indirect_v0) auto param0 = make_shared(element::f32, Shape{4, 6}); auto s = make_shared(param0); - auto r = make_shared(s, AxisSet{0}); + auto r = make_shared( + s, op::Constant::create(element::i64, {1}, {0}), op::v1::Reverse::Mode::INDEX); auto x = make_shared(param0, r, true); auto f = make_shared(x, ParameterVector{param0}); @@ -150,7 +151,8 @@ TEST(shape_relevance, param_shape_of_indirect_v3) auto param0 = make_shared(element::f32, Shape{4, 6}); auto s = make_shared(param0); - auto r = make_shared(s, AxisSet{0}); + auto r = make_shared( + s, op::Constant::create(element::i64, {1}, {0}), op::v1::Reverse::Mode::INDEX); auto x = make_shared(param0, r, true); auto f = make_shared(x, ParameterVector{param0}); @@ -167,7 +169,8 @@ TEST(shape_relevance, param_shape_of_indirect_i32_v3) auto param0 = make_shared(element::f32, Shape{4, 6}); auto s = make_shared(param0, element::i32); - auto r = make_shared(s, AxisSet{0}); + auto r = make_shared( + s, op::Constant::create(element::i64, {1}, {0}), op::v1::Reverse::Mode::INDEX); auto x = make_shared(param0, r, true); auto f = make_shared(x, ParameterVector{param0}); diff --git a/ngraph/test/runtime/ie/unit_test.manifest b/ngraph/test/runtime/ie/unit_test.manifest index de833110138..d269c33e2e5 100644 --- a/ngraph/test/runtime/ie/unit_test.manifest +++ b/ngraph/test/runtime/ie/unit_test.manifest @@ -303,7 +303,7 @@ slice_scalar slice_3d_start_just_oob shape_of_scalar reverse_0d -reverse_1d_nochange +reverse_1d reverse_2d_nochange reverse_3d_nochange product_trivial @@ -636,7 +636,9 @@ select_v1 reverse_1d_0 reverse_2d_0 reverse_2d_1 +reverse_2d_1_mask reverse_2d_01 +reverse_2d_01_mask reverse_3d_0 reverse_3d_1 reverse_3d_2 diff --git a/ngraph/test/runtime/interpreter/int_executable.hpp b/ngraph/test/runtime/interpreter/int_executable.hpp index cf685d0643e..9a00a9e0e14 100644 --- a/ngraph/test/runtime/interpreter/int_executable.hpp +++ b/ngraph/test/runtime/interpreter/int_executable.hpp @@ -1245,17 +1245,6 @@ protected: args[0]->get_data_ptr(), out[0]->get_data_ptr(), element_count); break; } - case OP_TYPEID::Reverse: - { - const op::Reverse* reverse = static_cast(&node); - reference::reverse(args[0]->get_data_ptr(), - out[0]->get_data_ptr(), - node.get_input_shape(0), - node.get_output_shape(0), - reverse->get_reversed_axes(), - args[0]->get_element_type().size()); - break; - } case OP_TYPEID::ReverseSequence: { const op::ReverseSequence* reverse = static_cast(&node); @@ -1514,6 +1503,7 @@ protected: case OP_TYPEID::Range: case OP_TYPEID::Reshape: case OP_TYPEID::Result: + case OP_TYPEID::Reverse_v1: case OP_TYPEID::Round_v5: case OP_TYPEID::ShapeOf_v3: case OP_TYPEID::ShapeOf: diff --git a/ngraph/test/runtime/interpreter/opset_int_tbl.hpp b/ngraph/test/runtime/interpreter/opset_int_tbl.hpp index dfd66189f4c..0c85a46b1c8 100644 --- a/ngraph/test/runtime/interpreter/opset_int_tbl.hpp +++ b/ngraph/test/runtime/interpreter/opset_int_tbl.hpp @@ -34,6 +34,7 @@ NGRAPH_OP(LogicalXor, op::v1) NGRAPH_OP(LogicalNot, op::v1) NGRAPH_OP(GatherTree, op::v1) NGRAPH_OP(OneHot, op::v1) +NGRAPH_OP(Reverse, op::v1) #undef ID_SUFFIX #define ID_SUFFIX(NAME) NAME##_v3 diff --git a/ngraph/test/runtime/opset0_tbl.hpp b/ngraph/test/runtime/opset0_tbl.hpp index 30809e0a959..f11c88ce8e2 100644 --- a/ngraph/test/runtime/opset0_tbl.hpp +++ b/ngraph/test/runtime/opset0_tbl.hpp @@ -111,7 +111,6 @@ NGRAPH_OP(Range, ngraph::op) NGRAPH_OP(Relu, ngraph::op) NGRAPH_OP(Reshape, ngraph::op) NGRAPH_OP(Result, ngraph::op) -NGRAPH_OP(Reverse, ngraph::op) NGRAPH_OP(ReverseSequence, ngraph::op) NGRAPH_OP(Round, ngraph::op) NGRAPH_OP(Select, ngraph::op) diff --git a/ngraph/test/runtime/pass/opset0_downgrade.cpp b/ngraph/test/runtime/pass/opset0_downgrade.cpp index 2a1b3ec2712..6e18de9af98 100644 --- a/ngraph/test/runtime/pass/opset0_downgrade.cpp +++ b/ngraph/test/runtime/pass/opset0_downgrade.cpp @@ -376,36 +376,6 @@ namespace opset0_downgrade return replacement_node; } - shared_ptr op_cast(shared_ptr node) - { - auto axes_node = node->input_value(1).get_node_shared_ptr(); - NGRAPH_CHECK(op::is_constant(axes_node), - "Unable to convert Reverse:v1 to Reverse:v0 " - "if reduction axes are not constant. Node: ", - *node); - const auto axes_node_const = as_type_ptr(axes_node); - AxisSet axes{}; - if (node->get_mode() == op::v1::Reverse::Mode::INDEX) - { - axes = axes_node_const->get_axis_vector_val(); - } - else // Mode::MASK - { - auto axes_mask = axes_node_const->get_vector(); - for (size_t i = 0; i < axes_mask.size(); ++i) - { - if (axes_mask[i]) - { - axes.emplace(i); - } - } - } - auto replacement_node = make_shared(node->input_value(0), axes); - - replace_node(node, replacement_node); - return replacement_node; - } - shared_ptr op_cast(shared_ptr node) { ngraph::pass::ImplicitBroadcastElimination().run_on_node(node); @@ -474,7 +444,11 @@ namespace opset0_downgrade if (!p.reverse_axes.empty()) { - replacement_node = make_shared(replacement_node, p.reverse_axes); + replacement_node = make_shared( + replacement_node, + op::Constant::create( + element::u64, {p.reverse_axes.size()}, p.reverse_axes.to_vector()), + op::v1::Reverse::Mode::INDEX); } replace_node(node, replacement_node); diff --git a/ngraph/test/runtime/pass/opset1_upgrade.cpp b/ngraph/test/runtime/pass/opset1_upgrade.cpp index 3494662200d..88918435c61 100644 --- a/ngraph/test/runtime/pass/opset1_upgrade.cpp +++ b/ngraph/test/runtime/pass/opset1_upgrade.cpp @@ -287,22 +287,6 @@ namespace opset1_upgrade return op_cast_binary_elementwise_node(node); } - shared_ptr op_cast(shared_ptr node) - { - // creates a Constant node from the v0::Reverse reversed_axes attribute - // and uses it as the second input of v1::Reverse - const auto reversed_axes = node->get_reversed_axes(); - - const auto reversed_axes_constant = op::Constant::create( - element::i64, Shape{reversed_axes.size()}, reversed_axes.to_vector()); - - const auto replacement_node = make_shared( - node->input_value(0), reversed_axes_constant, op::v1::Reverse::Mode::INDEX); - - replace_node(node, replacement_node); - return replacement_node; - } - shared_ptr op_cast(shared_ptr node) { auto replacement_node = make_shared(node->input_value(0), diff --git a/ngraph/test/type_prop/reverse.cpp b/ngraph/test/type_prop/reverse.cpp index 12136547156..6a77fe367b8 100644 --- a/ngraph/test/type_prop/reverse.cpp +++ b/ngraph/test/type_prop/reverse.cpp @@ -23,51 +23,23 @@ NGRAPH_SUPPRESS_DEPRECATED_START using namespace std; using namespace ngraph; -TEST(type_prop, reverse_0d_deduce) -{ - // Deduce type - auto param = make_shared(element::f32, Shape{}); - auto rev = make_shared(param, AxisSet{}); - - EXPECT_EQ(rev->get_element_type(), element::f32); - EXPECT_EQ(rev->get_shape(), (Shape{})); -} - -TEST(type_prop, reverse_1d_deduce_nochange) +TEST(type_prop, reverse_1d_deduce) { // Deduce type auto param = make_shared(element::f32, Shape{5}); - auto rev = make_shared(param, AxisSet{}); + auto rev = make_shared( + param, op::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})); } -TEST(type_prop, reverse_1d_deduce_0) -{ - // Deduce type - auto param = make_shared(element::f32, Shape{5}); - auto rev = make_shared(param, AxisSet{0}); - - EXPECT_EQ(rev->get_element_type(), element::f32); - EXPECT_EQ(rev->get_shape(), (Shape{5})); -} - -TEST(type_prop, reverse_2d_deduce_nochange) -{ - // Deduce type - auto param = make_shared(element::f32, Shape{5, 6}); - auto rev = make_shared(param, AxisSet{}); - - EXPECT_EQ(rev->get_element_type(), element::f32); - EXPECT_EQ(rev->get_shape(), (Shape{5, 6})); -} - TEST(type_prop, reverse_2d_deduce_0) { // Deduce type auto param = make_shared(element::f32, Shape{5, 6}); - auto rev = make_shared(param, AxisSet{0}); + auto rev = make_shared( + param, op::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})); @@ -77,7 +49,8 @@ TEST(type_prop, reverse_2d_deduce_1) { // Deduce type auto param = make_shared(element::f32, Shape{5, 6}); - auto rev = make_shared(param, AxisSet{1}); + auto rev = make_shared( + param, op::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})); @@ -87,27 +60,19 @@ TEST(type_prop, reverse_2d_deduce_01) { // Deduce type auto param = make_shared(element::f32, Shape{5, 6}); - auto rev = make_shared(param, AxisSet{0, 1}); + auto rev = make_shared( + param, op::Constant::create(element::i64, {2}, {0, 1}), op::v1::Reverse::Mode::INDEX); EXPECT_EQ(rev->get_element_type(), element::f32); EXPECT_EQ(rev->get_shape(), (Shape{5, 6})); } -TEST(type_prop, reverse_3d_deduce_nochange) -{ - // Deduce type - auto param = make_shared(element::f32, Shape{5, 6, 7}); - auto rev = make_shared(param, AxisSet{}); - - EXPECT_EQ(rev->get_element_type(), element::f32); - EXPECT_EQ(rev->get_shape(), (Shape{5, 6, 7})); -} - TEST(type_prop, reverse_3d_deduce_0) { // Deduce type auto param = make_shared(element::f32, Shape{5, 6, 7}); - auto rev = make_shared(param, AxisSet{0}); + auto rev = make_shared( + param, op::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})); @@ -117,7 +82,8 @@ TEST(type_prop, reverse_3d_deduce_1) { // Deduce type auto param = make_shared(element::f32, Shape{5, 6, 7}); - auto rev = make_shared(param, AxisSet{1}); + auto rev = make_shared( + param, op::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})); @@ -127,7 +93,8 @@ TEST(type_prop, reverse_3d_deduce_2) { // Deduce type auto param = make_shared(element::f32, Shape{5, 6, 7}); - auto rev = make_shared(param, AxisSet{2}); + auto rev = make_shared( + param, op::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})); @@ -137,7 +104,8 @@ TEST(type_prop, reverse_3d_deduce_01) { // Deduce type auto param = make_shared(element::f32, Shape{5, 6, 7}); - auto rev = make_shared(param, AxisSet{0, 1}); + auto rev = make_shared( + param, op::Constant::create(element::i64, {2}, {0, 1}), op::v1::Reverse::Mode::INDEX); EXPECT_EQ(rev->get_element_type(), element::f32); EXPECT_EQ(rev->get_shape(), (Shape{5, 6, 7})); @@ -147,7 +115,8 @@ TEST(type_prop, reverse_3d_deduce_02) { // Deduce type auto param = make_shared(element::f32, Shape{5, 6, 7}); - auto rev = make_shared(param, AxisSet{0, 2}); + auto rev = make_shared( + param, op::Constant::create(element::i64, {2}, {0, 2}), op::v1::Reverse::Mode::INDEX); EXPECT_EQ(rev->get_element_type(), element::f32); EXPECT_EQ(rev->get_shape(), (Shape{5, 6, 7})); @@ -157,7 +126,8 @@ TEST(type_prop, reverse_3d_deduce_12) { // Deduce type auto param = make_shared(element::f32, Shape{5, 6, 7}); - auto rev = make_shared(param, AxisSet{1, 2}); + auto rev = make_shared( + param, op::Constant::create(element::i64, {2}, {1, 2}), op::v1::Reverse::Mode::INDEX); EXPECT_EQ(rev->get_element_type(), element::f32); EXPECT_EQ(rev->get_shape(), (Shape{5, 6, 7})); @@ -167,7 +137,8 @@ TEST(type_prop, reverse_3d_deduce_012) { // Deduce type auto param = make_shared(element::f32, Shape{5, 6, 7}); - auto rev = make_shared(param, AxisSet{0, 1, 2}); + auto rev = make_shared( + param, op::Constant::create(element::i64, {3}, {0, 1, 2}), op::v1::Reverse::Mode::INDEX); EXPECT_EQ(rev->get_element_type(), element::f32); EXPECT_EQ(rev->get_shape(), (Shape{5, 6, 7})); @@ -179,14 +150,19 @@ TEST(type_prop, reverse_3d_deduce_oob) auto param = make_shared(element::f32, Shape{5, 6, 7}); try { - auto rev = make_shared(param, AxisSet{0, 3, 2}); + auto rev = make_shared(param, + op::Constant::create(element::i64, {3}, {0, 3, 2}), + op::v1::Reverse::Mode::INDEX); // Should have thrown, so fail if it didn't FAIL() << "Axis out of bounds not detected"; } catch (const NodeValidationFailure& error) { - EXPECT_HAS_SUBSTRING(error.what(), std::string("Reverse axis (3) is out of bounds")); + EXPECT_HAS_SUBSTRING( + error.what(), + std::string( + "Some of the provided axes (AxisSet{0, 2, 3}) are out of bounds (input rank: 3).")); } catch (...) { @@ -200,7 +176,10 @@ TEST(type_prop, reverse_3d_deduce_oob) TEST(type_prop, reverse_partial_rank_dynamic) { auto param = make_shared(element::f32, PartialShape::dynamic()); - auto rev = make_shared(param, AxisSet{0, 2, 1776, 90909}); + auto rev = + make_shared(param, + op::Constant::create(element::i64, {4}, {0, 2, 1776, 90909}), + op::v1::Reverse::Mode::INDEX); EXPECT_EQ(rev->get_element_type(), element::f32); EXPECT_TRUE(rev->get_output_partial_shape(0).rank().is_dynamic()); @@ -214,7 +193,8 @@ TEST(type_prop, reverse_partial_rank_static_dynamic_axes_ok) { PartialShape param_shape{Dimension::dynamic(), Dimension::dynamic(), 2, 3}; auto param = make_shared(element::f32, param_shape); - auto rev = make_shared(param, AxisSet{0, 2}); + auto rev = make_shared( + param, op::Constant::create(element::i64, {2}, {0, 2}), op::v1::Reverse::Mode::INDEX); EXPECT_EQ(rev->get_element_type(), element::f32); EXPECT_TRUE(rev->get_output_partial_shape(0).same_scheme(param_shape)); @@ -226,14 +206,19 @@ TEST(type_prop, reverse_partial_rank_static_dynamic_axes_oob) auto param = make_shared(element::f32, param_shape); try { - auto rev = make_shared(param, AxisSet{0, 4, 2}); + auto rev = make_shared(param, + op::Constant::create(element::i64, {3}, {0, 4, 2}), + op::v1::Reverse::Mode::INDEX); // Should have thrown, so fail if it didn't FAIL() << "Axis out of bounds not detected"; } catch (const NodeValidationFailure& error) { - EXPECT_HAS_SUBSTRING(error.what(), std::string("Reverse axis (4) is out of bounds")); + EXPECT_HAS_SUBSTRING( + error.what(), + std::string( + "Some of the provided axes (AxisSet{0, 2, 4}) are out of bounds (input rank: 4).")); } catch (...) {