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

Remove deprecated v0::Reverse op (#2899)

Browse Source 
* Remove deprecated v0::Reverse op

* fix unit tests

* add include for std::inserter
This commit is contained in:
Mateusz Tabaka
2020-11-02 04:46:30 +01:00
committed by GitHub
parent 4acd117c8d
commit 3f35746c45
16 changed files with 226 additions and 332 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -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)

65
ngraph/core/include/ngraph/op/reverse.hpp
View File

@@ -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<Node>& arg, const AxisSet& reversed_axes);
void validate_and_infer_types() override;
virtual std::shared_ptr<Node>
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

117
ngraph/core/src/op/reverse.cpp
View File

@@ -15,6 +15,7 @@
//*****************************************************************************
#include <algorithm>
#include <iterator>
#include <sstream>
#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<Node>& 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<Node> op::v0::Reverse::clone_with_new_inputs(const OutputVector& new_args) const
{
check_new_args_count(this, new_args);
return make_shared<v0::Reverse>(new_args.at(0), m_reversed_axes);
}
constexpr NodeTypeInfo op::v1::Reverse::type_info;
op::v1::Reverse::Reverse(const Output<Node>& 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<const char>(),
outputs[0]->get_data_ptr<char>(),
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<int64_t>();
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<int8_t>();
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<uint8_t>();
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<int16_t>();
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<uint16_t>();
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<int32_t>();
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<uint32_t>();
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<int64_t>();
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<uint64_t>();
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

3
ngraph/test/backend/broadcast.in.cpp
View File

@@ -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<op::Reverse>(broadcast, AxisSet{1});
auto reverse = make_shared<op::v1::Reverse>(
broadcast, op::Constant::create(element::i64, {1}, {1}), op::v1::Reverse::Mode::INDEX);
auto f = make_shared<Function>(reverse, ParameterVector{A});
auto backend = runtime::Backend::create("${BACKEND_NAME}");

3
ngraph/test/backend/dynamic.in.cpp
View File

@@ -243,7 +243,8 @@ static void reverse_shape_test(const PartialShape& input_pshape,
auto x = make_shared<op::Parameter>(element::f32, input_pshape);
shared_ptr<Node> x_new_shape = make_shared<op::v0::ShapeOf>(x);
x_new_shape = make_shared<op::Reverse>(x_new_shape, AxisSet{0});
x_new_shape = make_shared<op::v1::Reverse>(
x_new_shape, op::Constant::create(element::i64, {1}, {0}), op::v1::Reverse::Mode::INDEX);
auto x_reshaped = make_shared<op::v1::Reshape>(x, x_new_shape, true);

165
ngraph/test/backend/reverse.in.cpp
View File

@@ -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<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Reverse>(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<float>{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<float>{6}), read_vector<float>(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<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Reverse>(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<float>{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<float>{0, 1, 2, 3, 4, 5, 6, 7}),
read_vector<float>(result),
MIN_FLOAT_TOLERANCE_BITS));
}
NGRAPH_TEST(${BACKEND_NAME}, reverse_1d_0)
{
Shape shape{8};
auto A = make_shared<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Reverse>(A, AxisSet{0}), ParameterVector{A});
auto f = make_shared<Function>(
make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Reverse>(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<float, 2>({{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<float, 2>({{0, 1, 2}, {3, 4, 5}, {6, 7, 8}, {9, 10, 11}}).get_vector()),
read_vector<float>(result),
MIN_FLOAT_TOLERANCE_BITS));
}
NGRAPH_TEST(${BACKEND_NAME}, reverse_2d_0)
{
Shape shape{4, 3};
auto A = make_shared<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Reverse>(A, AxisSet{0}), ParameterVector{A});
auto f = make_shared<Function>(
make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Reverse>(A, AxisSet{1}), ParameterVector{A});
auto f = make_shared<Function>(
make_shared<op::v1::Reverse>(
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<float, 2>({{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<float, 2>({{2, 1, 0}, {5, 4, 3}, {8, 7, 6}, {11, 10, 9}}).get_vector()),
read_vector<float>(result),
MIN_FLOAT_TOLERANCE_BITS));
}
NGRAPH_TEST(${BACKEND_NAME}, reverse_2d_1_mask)
{
Shape shape{4, 3};
auto A = make_shared<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(
make_shared<op::v1::Reverse>(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<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Reverse>(A, AxisSet{0, 1}), ParameterVector{A});
auto f = make_shared<Function>(
make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Reverse>(A, AxisSet{}), ParameterVector{A});
auto f = make_shared<Function>(
make_shared<op::v1::Reverse>(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<float, 3>({{{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<float, 2>({{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<float, 3>({{{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<float, 2>({{11, 10, 9}, {8, 7, 6}, {5, 4, 3}, {2, 1, 0}}).get_vector()),
read_vector<float>(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<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Reverse>(A, AxisSet{0}), ParameterVector{A});
auto f = make_shared<Function>(
make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Reverse>(A, AxisSet{1}), ParameterVector{A});
auto f = make_shared<Function>(
make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Reverse>(A, AxisSet{2}), ParameterVector{A});
auto f = make_shared<Function>(
make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Reverse>(A, AxisSet{0, 1}), ParameterVector{A});
auto f = make_shared<Function>(
make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Reverse>(A, AxisSet{0, 2}), ParameterVector{A});
auto f = make_shared<Function>(
make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Reverse>(A, AxisSet{1, 2}), ParameterVector{A});
auto f = make_shared<Function>(
make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, shape);
auto f =
make_shared<Function>(make_shared<op::Reverse>(A, AxisSet{0, 1, 2}), ParameterVector{A});
auto f = make_shared<Function>(
make_shared<op::v1::Reverse>(
A, op::Constant::create(element::i64, {3}, {0, 1, 2}), op::v1::Reverse::Mode::INDEX),
ParameterVector{A});
auto backend = runtime::Backend::create("${BACKEND_NAME}");

22
ngraph/test/constant_folding.cpp
View File

@@ -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<int32_t> 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<op::Reverse>(constant, AxisSet{1});
auto axes = op::Constant::create(axes_elem_type, {1}, {1});
auto convert = make_shared<op::v1::Reverse>(constant, axes, op::v1::Reverse::Mode::INDEX);
convert->set_friendly_name("test");
auto f = make_shared<Function>(convert, ParameterVector{});
@@ -814,7 +815,7 @@ TEST(constant_folding, const_reverse)
pass_manager.register_pass<pass::ConstantFolding>();
pass_manager.run_passes(f);
ASSERT_EQ(count_ops_of_type<op::Reverse>(f), 0);
ASSERT_EQ(count_ops_of_type<op::v1::Reverse>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(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};

2
ngraph/test/op_is.cpp
View File

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

9
ngraph/test/pass_shape_relevance.cpp
View File

@@ -133,7 +133,8 @@ TEST(shape_relevance, param_shape_of_indirect_v0)
auto param0 = make_shared<op::Parameter>(element::f32, Shape{4, 6});
auto s = make_shared<op::v0::ShapeOf>(param0);
auto r = make_shared<op::Reverse>(s, AxisSet{0});
auto r = make_shared<op::v1::Reverse>(
s, op::Constant::create(element::i64, {1}, {0}), op::v1::Reverse::Mode::INDEX);
auto x = make_shared<op::v1::Reshape>(param0, r, true);
auto f = make_shared<Function>(x, ParameterVector{param0});
@@ -150,7 +151,8 @@ TEST(shape_relevance, param_shape_of_indirect_v3)
auto param0 = make_shared<op::Parameter>(element::f32, Shape{4, 6});
auto s = make_shared<op::v3::ShapeOf>(param0);
auto r = make_shared<op::Reverse>(s, AxisSet{0});
auto r = make_shared<op::v1::Reverse>(
s, op::Constant::create(element::i64, {1}, {0}), op::v1::Reverse::Mode::INDEX);
auto x = make_shared<op::v1::Reshape>(param0, r, true);
auto f = make_shared<Function>(x, ParameterVector{param0});
@@ -167,7 +169,8 @@ TEST(shape_relevance, param_shape_of_indirect_i32_v3)
auto param0 = make_shared<op::Parameter>(element::f32, Shape{4, 6});
auto s = make_shared<op::v3::ShapeOf>(param0, element::i32);
auto r = make_shared<op::Reverse>(s, AxisSet{0});
auto r = make_shared<op::v1::Reverse>(
s, op::Constant::create(element::i64, {1}, {0}), op::v1::Reverse::Mode::INDEX);
auto x = make_shared<op::v1::Reshape>(param0, r, true);
auto f = make_shared<Function>(x, ParameterVector{param0});

4
ngraph/test/runtime/ie/unit_test.manifest
View File

@@ -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

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

@@ -1245,17 +1245,6 @@ protected:
args[0]->get_data_ptr<const T>(), out[0]->get_data_ptr<T>(), element_count);
break;
}
case OP_TYPEID::Reverse:
{
const op::Reverse* reverse = static_cast<const op::Reverse*>(&node);
reference::reverse(args[0]->get_data_ptr<const char>(),
out[0]->get_data_ptr<char>(),
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<const op::ReverseSequence*>(&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:

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

@@ -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

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

@@ -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)

36
ngraph/test/runtime/pass/opset0_downgrade.cpp
View File

@@ -376,36 +376,6 @@ namespace opset0_downgrade
return replacement_node;
}
shared_ptr<Node> op_cast(shared_ptr<op::v1::Reverse> 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<op::Constant>(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<bool>();
for (size_t i = 0; i < axes_mask.size(); ++i)
{
if (axes_mask[i])
{
axes.emplace(i);
}
}
}
auto replacement_node = make_shared<op::v0::Reverse>(node->input_value(0), axes);
replace_node(node, replacement_node);
return replacement_node;
}
shared_ptr<Node> op_cast(shared_ptr<op::v1::Select> node)
{
ngraph::pass::ImplicitBroadcastElimination().run_on_node(node);
@@ -474,7 +444,11 @@ namespace opset0_downgrade
if (!p.reverse_axes.empty())
{
replacement_node = make_shared<op::Reverse>(replacement_node, p.reverse_axes);
replacement_node = make_shared<op::v1::Reverse>(
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);

16
ngraph/test/runtime/pass/opset1_upgrade.cpp
View File

@@ -287,22 +287,6 @@ namespace opset1_upgrade
return op_cast_binary_elementwise_node<op::v0::Power, op::v1::Power>(node);
}
shared_ptr<Node> op_cast(shared_ptr<op::Reverse> 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<op::v1::Reverse>(
node->input_value(0), reversed_axes_constant, op::v1::Reverse::Mode::INDEX);
replace_node(node, replacement_node);
return replacement_node;
}
shared_ptr<Node> op_cast(shared_ptr<op::Select> node)
{
auto replacement_node = make_shared<op::v1::Select>(node->input_value(0),

101
ngraph/test/type_prop/reverse.cpp
View File

@@ -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<op::Parameter>(element::f32, Shape{});
auto rev = make_shared<op::Reverse>(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<op::Parameter>(element::f32, Shape{5});
auto rev = make_shared<op::Reverse>(param, AxisSet{});
auto rev = make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, Shape{5});
auto rev = make_shared<op::Reverse>(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<op::Parameter>(element::f32, Shape{5, 6});
auto rev = make_shared<op::Reverse>(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<op::Parameter>(element::f32, Shape{5, 6});
auto rev = make_shared<op::Reverse>(param, AxisSet{0});
auto rev = make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, Shape{5, 6});
auto rev = make_shared<op::Reverse>(param, AxisSet{1});
auto rev = make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, Shape{5, 6});
auto rev = make_shared<op::Reverse>(param, AxisSet{0, 1});
auto rev = make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, Shape{5, 6, 7});
auto rev = make_shared<op::Reverse>(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<op::Parameter>(element::f32, Shape{5, 6, 7});
auto rev = make_shared<op::Reverse>(param, AxisSet{0});
auto rev = make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, Shape{5, 6, 7});
auto rev = make_shared<op::Reverse>(param, AxisSet{1});
auto rev = make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, Shape{5, 6, 7});
auto rev = make_shared<op::Reverse>(param, AxisSet{2});
auto rev = make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, Shape{5, 6, 7});
auto rev = make_shared<op::Reverse>(param, AxisSet{0, 1});
auto rev = make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, Shape{5, 6, 7});
auto rev = make_shared<op::Reverse>(param, AxisSet{0, 2});
auto rev = make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, Shape{5, 6, 7});
auto rev = make_shared<op::Reverse>(param, AxisSet{1, 2});
auto rev = make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, Shape{5, 6, 7});
auto rev = make_shared<op::Reverse>(param, AxisSet{0, 1, 2});
auto rev = make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, Shape{5, 6, 7});
try
{
auto rev = make_shared<op::Reverse>(param, AxisSet{0, 3, 2});
auto rev = make_shared<op::v1::Reverse>(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<op::Parameter>(element::f32, PartialShape::dynamic());
auto rev = make_shared<op::Reverse>(param, AxisSet{0, 2, 1776, 90909});
auto rev =
make_shared<op::v1::Reverse>(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<op::Parameter>(element::f32, param_shape);
auto rev = make_shared<op::Reverse>(param, AxisSet{0, 2});
auto rev = make_shared<op::v1::Reverse>(
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<op::Parameter>(element::f32, param_shape);
try
{
auto rev = make_shared<op::Reverse>(param, AxisSet{0, 4, 2});
auto rev = make_shared<op::v1::Reverse>(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 (...)
{