Removed backprop operations

Author: ilyachur

ngraph/src/ngraph/op/avg_pool.cpp

@@ -241,170 +241,11 @@ shared_ptr<Node> op::v0::AvgPool::clone_with_new_inputs(const OutputVector& new_
                                     m_ceil_mode);
 }
 
-constexpr NodeTypeInfo op::v0::AvgPoolBackprop::type_info;
 shared_ptr<Node> op::v0::AvgPool::get_default_value() const
 {
     return Constant::create(get_element_type(), get_shape(), {0});
 }
 
-op::v0::AvgPoolBackprop::AvgPoolBackprop(const Shape& forward_arg_shape,
-                                         const Output<Node>& delta,
-                                         const Shape& window_shape,
-                                         const Strides& window_movement_strides,
-                                         const Shape& padding_below,
-                                         const Shape& padding_above,
-                                         bool include_padding_in_avg_computation)
-    : Op({delta})
-    , m_forward_arg_shape(forward_arg_shape)
-    , m_window_shape(window_shape)
-    , m_window_movement_strides(window_movement_strides)
-    , m_padding_below(padding_below)
-    , m_padding_above(padding_above)
-    , m_include_padding_in_avg_computation(include_padding_in_avg_computation)
-{
-    constructor_validate_and_infer_types();
-}
-
-bool op::v0::AvgPoolBackprop::visit_attributes(AttributeVisitor& visitor)
-{
-    visitor.on_attribute("forward_arg_shape", m_forward_arg_shape);
-    visitor.on_attribute("window_shape", m_window_shape);
-    visitor.on_attribute("window_movement_strides", m_window_movement_strides);
-    visitor.on_attribute("padding_below", m_padding_below);
-    visitor.on_attribute("padding_above", m_padding_above);
-    visitor.on_attribute("include_padding_in_avg_computation",
-                         m_include_padding_in_avg_computation);
-    return true;
-}
-
-void op::v0::AvgPoolBackprop::validate_and_infer_types()
-{
-    // infer_batched_forward_pooling wants CoordinateDiffs for these, while the pooling ops for
-    // now still take Shape (no negative padding).
-    CoordinateDiff padding_below(m_padding_below.begin(), m_padding_below.end());
-    CoordinateDiff padding_above(m_padding_above.begin(), m_padding_above.end());
-
-    PartialShape forward_result_shape =
-        infer_batched_pooling_forward(this,
-                                      m_forward_arg_shape,
-                                      padding_below,
-                                      padding_above,
-                                      m_window_shape,
-                                      m_window_movement_strides,
-                                      m_include_padding_in_avg_computation);
-
-    const PartialShape& delta_shape = get_input_partial_shape(0);
-
-    NODE_VALIDATION_CHECK(
-        this,
-        forward_result_shape.compatible(delta_shape),
-        "Inferred forward output shape does not match delta shape (inferred forward output ",
-        "shape: ",
-        forward_result_shape,
-        ", delta shape: ",
-        delta_shape,
-        ").");
-
-    // TODO(amprocte): Once m_forward_arg_shape is allowed to be dynamic, we may technically be
-    // able to infer some extra information from forward_result_shape that was not present in the
-    // forward arg shape---namely batch size and channel count. Merge that info in.
-    set_output_type(0, get_input_element_type(0), m_forward_arg_shape);
-}
-
-const Shape& op::v0::AvgPoolBackprop::get_forward_arg_shape() const
-{
-    return m_forward_arg_shape;
-}
-
-void op::v0::AvgPoolBackprop::set_forward_arg_shape(const Shape& forward_arg_shape)
-{
-    m_forward_arg_shape = forward_arg_shape;
-}
-
-const Shape& op::v0::AvgPoolBackprop::get_window_shape() const
-{
-    return m_window_shape;
-}
-
-void op::v0::AvgPoolBackprop::set_window_shape(const Shape& window_shape)
-{
-    m_window_shape = window_shape;
-}
-
-const Strides& op::v0::AvgPoolBackprop::get_window_movement_strides() const
-{
-    return m_window_movement_strides;
-}
-
-void op::v0::AvgPoolBackprop::set_window_movement_strides(const Strides& window_movement_strides)
-{
-    m_window_movement_strides = window_movement_strides;
-}
-
-const Shape& op::v0::AvgPoolBackprop::get_padding_below() const
-{
-    return m_padding_below;
-}
-
-void op::v0::AvgPoolBackprop::set_padding_below(const Shape& padding_below)
-{
-    m_padding_below = padding_below;
-}
-
-const Shape& op::v0::AvgPoolBackprop::get_padding_above() const
-{
-    return m_padding_above;
-}
-
-void op::v0::AvgPoolBackprop::set_padding_above(const Shape& padding_above)
-{
-    m_padding_above = padding_above;
-}
-
-bool op::v0::AvgPoolBackprop::get_include_padding_in_avg_computation() const
-{
-    return m_include_padding_in_avg_computation;
-}
-
-void op::v0::AvgPoolBackprop::set_include_padding_in_avg_computation(
-    bool include_padding_in_avg_computation)
-{
-    m_include_padding_in_avg_computation = include_padding_in_avg_computation;
-}
-
-shared_ptr<Node> op::v0::AvgPoolBackprop::clone_with_new_inputs(const OutputVector& new_args) const
-{
-    check_new_args_count(this, new_args);
-    return make_shared<v0::AvgPoolBackprop>(m_forward_arg_shape,
-                                            new_args.at(0),
-                                            m_window_shape,
-                                            m_window_movement_strides,
-                                            m_padding_below,
-                                            m_padding_above,
-                                            m_include_padding_in_avg_computation);
-}
-
-void op::v0::AvgPool::generate_adjoints(autodiff::Adjoints& adjoints, const OutputVector& deltas)
-{
-    if (m_ceil_mode)
-    {
-        throw ngraph_error("Autodiff not supported on AvgPool with ceil_mode set");
-    }
-
-    auto delta = deltas.at(0);
-
-    auto operand = input_value(0);
-    auto& operand_shape = get_input_shape(0);
-    auto backprop = make_shared<op::v0::AvgPoolBackprop>(operand_shape,
-                                                         delta,
-                                                         m_window_shape,
-                                                         m_window_movement_strides,
-                                                         m_padding_below,
-                                                         m_padding_above,
-                                                         m_include_padding_in_avg_computation);
-    adjoints.add_delta(operand, backprop);
-}
-
 // *** AvgPool OP SET 1 ***
 constexpr NodeTypeInfo op::v1::AvgPool::type_info;
 
@@ -594,155 +435,6 @@ shared_ptr<Node> op::v1::AvgPool::clone_with_new_inputs(const OutputVector& new_
                                     m_auto_pad);
 }
 
-constexpr NodeTypeInfo op::v1::AvgPoolBackprop::type_info;
-
-op::v1::AvgPoolBackprop::AvgPoolBackprop(const Output<Node>& delta,
-                                         const Output<Node>& forward_arg_shape,
-                                         const Strides& strides,
-                                         const Shape& pads_begin,
-                                         const Shape& pads_end,
-                                         const Shape& kernel,
-                                         bool exclude_pad)
-    : Op({delta, forward_arg_shape})
-    , m_kernel(kernel)
-    , m_strides(strides)
-    , m_pads_begin(pads_begin)
-    , m_pads_end(pads_end)
-    , m_exclude_pad(exclude_pad)
-{
-    constructor_validate_and_infer_types();
-}
-
-bool op::v1::AvgPoolBackprop::visit_attributes(AttributeVisitor& visitor)
-{
-    visitor.on_attribute("kernel", m_kernel);
-    visitor.on_attribute("strides", m_strides);
-    visitor.on_attribute("pads_begin", m_pads_begin);
-    visitor.on_attribute("pads_end", m_pads_end);
-    visitor.on_attribute("exclude_pad", m_exclude_pad);
-    return true;
-}
-
-const Shape op::v1::AvgPoolBackprop::get_forward_arg_shape() const
-{
-    Shape shape;
-    if (auto const_op = as_type<op::Constant>(input_value(1).get_node()))
-    {
-        shape = const_op->get_shape_val();
-    }
-    return shape;
-}
-
-void op::v1::AvgPoolBackprop::validate_and_infer_types()
-{
-    // infer_batched_forward_pooling wants CoordinateDiffs for these, while the pooling ops for
-    // now still take Shape (no negative padding).
-    CoordinateDiff pads_begin(m_pads_begin.begin(), m_pads_begin.end());
-    CoordinateDiff pads_end(m_pads_end.begin(), m_pads_end.end());
-
-    PartialShape forward_arg_shape{PartialShape::dynamic()};
-
-    if (input_value(1).get_node_shared_ptr()->is_constant())
-    {
-        forward_arg_shape = get_forward_arg_shape();
-    }
-
-    PartialShape forward_result_shape = infer_batched_pooling_forward(
-        this, forward_arg_shape, pads_begin, pads_end, m_kernel, m_strides, m_exclude_pad);
-
-    const PartialShape& delta_shape = get_input_partial_shape(0);
-
-    NODE_VALIDATION_CHECK(
-        this,
-        forward_result_shape.compatible(delta_shape),
-        "Inferred forward output shape does not match delta shape (inferred forward output ",
-        "shape: ",
-        forward_result_shape,
-        ", delta shape: ",
-        delta_shape,
-        ").");
-
-    set_input_is_relevant_to_shape(1);
-    set_output_type(0, get_input_element_type(0), forward_arg_shape);
-}
-
-const Shape& op::v1::AvgPoolBackprop::get_kernel() const
-{
-    return m_kernel;
-}
-
-void op::v1::AvgPoolBackprop::set_kernel(const Shape& kernel)
-{
-    m_kernel = kernel;
-}
-
-const Strides& op::v1::AvgPoolBackprop::get_strides() const
-{
-    return m_strides;
-}
-
-void op::v1::AvgPoolBackprop::set_strides(const Strides& strides)
-{
-    m_strides = strides;
-}
-
-const Shape& op::v1::AvgPoolBackprop::get_pads_begin() const
-{
-    return m_pads_begin;
-}
-
-void op::v1::AvgPoolBackprop::set_pads_begin(const Shape& pads_begin)
-{
-    m_pads_begin = pads_begin;
-}
-
-const Shape& op::v1::AvgPoolBackprop::get_pads_end() const
-{
-    return m_pads_end;
-}
-
-void op::v1::AvgPoolBackprop::set_pads_end(const Shape& pads_end)
-{
-    m_pads_end = pads_end;
-}
-
-bool op::v1::AvgPoolBackprop::get_exclude_pad() const
-{
-    return m_exclude_pad;
-}
-
-void op::v1::AvgPoolBackprop::set_exclude_pad(bool exclude_pad)
-{
-    m_exclude_pad = exclude_pad;
-}
-
-shared_ptr<Node> op::v1::AvgPoolBackprop::clone_with_new_inputs(const OutputVector& new_args) const
-{
-    check_new_args_count(this, new_args);
-    return make_shared<v1::AvgPoolBackprop>(new_args.at(0),
-                                            new_args.at(1),
-                                            m_strides,
-                                            m_pads_begin,
-                                            m_pads_end,
-                                            m_kernel,
-                                            m_exclude_pad);
-}
-
-void op::v1::AvgPool::generate_adjoints(autodiff::Adjoints& adjoints, const OutputVector& deltas)
-{
-    if (m_rounding_type == op::RoundingType::CEIL)
-    {
-        throw ngraph_error("Autodiff not supported on AvgPool with ceil_mode set");
-    }
-
-    auto delta = deltas.at(0);
-
-    auto operand = input_value(0);
-    auto backprop = make_shared<op::v1::AvgPoolBackprop>(
-        delta, input_value(1), m_strides, m_pads_begin, m_pads_end, m_kernel, m_exclude_pad);
-    adjoints.add_delta(operand, backprop);
-}
-
 shared_ptr<Node> op::v1::AvgPool::get_default_value() const
 {
     return op::Constant::create(get_element_type(), get_shape(), {0});