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
9 changed files with 1 additions and 600 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

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