Review opset1 unsqueeze for shape inference aspects (#13538)

* Use non-blocking assertions in unsqueeze tests
for independent properties

* Review unsqueeze interval shape propagation:
- extend partial shape propagation tests
- add invalid axis value tests
- fix issues when repeated axes on input

* Shape inference test, unsqueeze using default ctor
- private fields set by setters

* Review unsqeeze bounds propagation:
- preserve and propagate labels
- bounds propagation lowe/upper

* Add template shape inference for unsqueeze
- extract current implementation and unify it for shape types
- add unit test for static shape inference
- add unsqueeze in/out indexes

* Unify axes normalization

* Use common fixture for static shape inference

* Fix build issue in GPU plugin
- include unsqueeze shape inference

* Remove enum with in/out indexes
Due to build issue on Windows

* Remove make move iterator
minor changes validation util

* Add test for label propagation
- expand static shape inference tests

* Add common validation for axes input

* Fix build issues

Co-authored-by: Evgenya Stepyreva <[email protected]>

Author: praasz

src/core/include/openvino/core/validation_util.hpp

@@ -108,9 +108,9 @@ int64_t normalize_axis(const std::string& node_description,
 /// If any negative axis in vector, it counts from the last to the first axis,
 /// by adding tensor_rank to axis. Changes axes vector inplace.
 ///
-/// \param[in]  node  The node with requested axes.
-/// \param[in]  tensor_rank       The corresponding tensor rank.
-/// \param[in]  axes              The requested vector of axes.
+/// \param[in]      node         The node with requested axes.
+/// \param[in]      tensor_rank  The corresponding tensor rank.
+/// \param[in,out]  axes         The requested vector of axes.
 ///
 OPENVINO_API
 void normalize_axes(const Node* node, const int64_t& tensor_rank, std::vector<int64_t>& axes);
@@ -157,4 +157,19 @@ OPENVINO_API bool is_valid_axes_order(const std::vector<int64_t>& axes_order, co
 /// \param labels  Label tensor for check.
 /// \return True if there is no labels, otherwise false.
 OPENVINO_API bool has_no_labels(const TensorLabel& labels);
+
+/// \brief Get the node input partial shapes.
+///
+/// \param node   Node to extract input shapes.
+///
+/// \return Vector of PartialShapes of each input.
+OPENVINO_API std::vector<PartialShape> get_node_input_partial_shapes(const ov::Node& node);
+
+/// \brief Check if rank is compatible to any of rank from container.
+///
+/// \param rank   Rank to check.
+/// \param ranks  VEctor of ranks used to check input rank compatibility.
+///
+/// \return True if rank compatible to any from ranks, otherwise false.
+OPENVINO_API bool is_rank_compatible_any_of(const ov::Rank& rank, const std::vector<ov::Rank>& ranks);
 }  // namespace ov

src/core/shape_inference/include/compare.hpp

@@ -23,29 +23,37 @@ enum Bound : uint8_t { NONE, LOWER, UPPER, BOTH };
  */
 template <class T, Bound BMode = Bound::NONE>
 class Between {
-    T _lower_bound, _upper_bound;
+    const T m_lower_bound, m_upper_bound;
 
 public:
-    constexpr Between(const T& lower, const T& upper) : _lower_bound{lower}, _upper_bound{upper} {}
+    constexpr Between(const T& lower, const T& upper) : m_lower_bound{lower}, m_upper_bound{upper} {}
 
     template <Bound B = BMode, typename std::enable_if<B == Bound::NONE>::type* = nullptr>
     constexpr bool operator()(const T& value) const {
-        return (_lower_bound < value) && (value < _upper_bound);
+        return (lower() < value) && (value < upper());
     }
 
     template <Bound B = BMode, typename std::enable_if<B == Bound::LOWER>::type* = nullptr>
     constexpr bool operator()(const T& value) const {
-        return (_lower_bound <= value) && (value < _upper_bound);
+        return (lower() <= value) && (value < upper());
     }
 
     template <Bound B = BMode, typename std::enable_if<B == Bound::UPPER>::type* = nullptr>
     constexpr bool operator()(const T& value) const {
-        return (_lower_bound < value) && (value <= _upper_bound);
+        return (lower() < value) && (value <= upper());
     }
 
     template <Bound B = BMode, typename std::enable_if<B == Bound::BOTH>::type* = nullptr>
     constexpr bool operator()(const T& value) const {
-        return (_lower_bound <= value) && (value <= _upper_bound);
+        return (lower() <= value) && (value <= upper());
+    }
+
+    const T& upper() const {
+        return m_upper_bound;
+    }
+
+    const T& lower() const {
+        return m_lower_bound;
     }
 };
 

src/core/shape_inference/include/shape_nodes.hpp

@@ -124,33 +124,6 @@ void shape_infer(const ov::opset1::Squeeze* op,
     }
 }
 
-template <class T>
-void shape_infer(const ov::opset1::Unsqueeze* op,
-                 const std::vector<T>& input_shapes,
-                 std::vector<T>& output_shapes,
-                 const std::map<size_t, std::shared_ptr<ngraph::runtime::HostTensor>>& constant_data = {}) {
-    NODE_VALIDATION_CHECK(op, input_shapes.size() == 2 && output_shapes.size() == 1);
-    std::vector<int64_t> axes;
-    bool axes_is_constant = get_data_as_int64<T>(1, op, axes, constant_data);
-    NODE_VALIDATION_CHECK(op, axes_is_constant, "Shape inference lacks input data");
-
-    auto& input_shape = input_shapes[0];
-    OPENVINO_ASSERT(input_shape.is_static());
-    auto& output_shape = output_shapes[0];
-    output_shape = input_shape;
-
-    NODE_VALIDATION_CHECK(op, !axes.empty(), "'axes' input is mandatory");
-
-    int64_t expanded_rank = input_shape.size() + axes.size();
-    ov::normalize_axes(op, static_cast<int64_t>(expanded_rank), axes);
-
-    std::set<int64_t> unique_sorted_axes(axes.begin(), axes.end());
-    for (const auto& axis : unique_sorted_axes) {
-        NODE_VALIDATION_CHECK(op, axis <= expanded_rank, "provided 'axes' value ", axis, " is not valid.");
-        output_shape.insert(next(output_shape.begin(), axis), 1);
-    }
-}
-
 template <class T>
 inline void dynamic_shape(T& output_shape) {
     OPENVINO_UNREACHABLE("This code should be executed only for PartialShape class");

src/core/shape_inference/include/unsqueeze_shape_inference.hpp

@@ -0,0 +1,71 @@
+// Copyright (C) 2022 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+#pragma once
+
+#include "openvino/op/unsqueeze.hpp"
+#include "utils.hpp"
+
+namespace ov {
+namespace op {
+namespace v0 {
+
+template <class TOp>
+void check_unsqueeze_axes_rank(const TOp* op, const Rank& rank) {
+    NODE_VALIDATION_CHECK(op,
+                          is_rank_compatible_any_of(rank, {0, 1}),
+                          "Second input (axes) should not be of rank higher than 1. Got: ",
+                          rank);
+}
+
+template <class T>
+void shape_infer(const Unsqueeze* op,
+                 const std::vector<T>& input_shapes,
+                 std::vector<T>& output_shapes,
+                 const std::map<size_t, std::shared_ptr<ngraph::runtime::HostTensor>>& constant_data = {}) {
+    NODE_VALIDATION_CHECK(op, input_shapes.size() == 2 && output_shapes.size() == 1);
+    check_unsqueeze_axes_rank(op, input_shapes[1].rank());
+    const auto& arg_shape = input_shapes[0];
+    auto& out_shape = output_shapes[0];
+
+    std::vector<int64_t> axes_val;
+    const auto has_axes = get_data_as_int64<T>(1, op, axes_val, constant_data);
+
+    if (has_axes && arg_shape.rank().is_static()) {
+        NODE_VALIDATION_CHECK(op, !axes_val.empty(), "'axes' input is mandatory");
+        // Remove repeated axes on input
+        std::unordered_set<int64_t> tmp(axes_val.begin(), axes_val.end());
+        std::vector<int64_t> unique_axes(tmp.begin(), tmp.end());
+
+        const auto expanded_rank = arg_shape.rank().get_length() + unique_axes.size();
+
+        // Normalize then remove repeated axes after normalization.
+        normalize_axes(op, expanded_rank, unique_axes);
+        const std::set<int64_t> axes(unique_axes.begin(), unique_axes.end());
+
+        out_shape = arg_shape;
+        for (const auto& axis : axes) {
+            NODE_VALIDATION_CHECK(op,
+                                  static_cast<size_t>(axis) <= out_shape.size() + 1,
+                                  "provided 'axes' value ",
+                                  axis,
+                                  " is not valid.");
+            // As shape not throw exception on repeated axis it has to be check if insert or append dimension.
+            // This will be not required if this op has same behaviour as numpy expand_dims.
+            if (static_cast<size_t>(axis) <= out_shape.size()) {
+                out_shape.insert(std::next(std::begin(out_shape), axis), 1);
+            } else {
+                // Append dimension at end when there is difference in size of input axes and after normalization
+                // e.g. input shape {2,3,4} axes_value(4,-1) then output rank is determined as 5,
+                // but after final normalization and removing duplicates it points sam location in shape.
+                // The numpy throws exception "repeated axis" in that case.
+                out_shape.push_back(1);
+            }
+        }
+    } else {
+        out_shape = ov::PartialShape::dynamic();
+    }
+}
+}  // namespace v0
+}  // namespace op
+}  // namespace ov

src/core/src/op/unsqueeze.cpp

@@ -9,12 +9,9 @@
 #include <set>
 
 #include "itt.hpp"
-#include "ngraph/builder/reshape.hpp"
-#include "ngraph/op/constant.hpp"
-#include "ngraph/op/reshape.hpp"
-#include "ngraph/op/util/op_types.hpp"
 #include "ngraph/runtime/reference/copy.hpp"
 #include "ngraph/validation_util.hpp"
+#include "unsqueeze_shape_inference.hpp"
 
 using namespace std;
 using namespace ngraph;
@@ -27,38 +24,13 @@ op::v0::Unsqueeze::Unsqueeze(const Output<Node>& data, const Output<Node>& axes)
 
 void op::v0::Unsqueeze::validate_and_infer_types() {
     OV_OP_SCOPE(v0_Unsqueeze_validate_and_infer_types);
-    const auto data = input_value(0);
-    auto data_partial_shape = data.get_partial_shape();
-    const auto data_rank = data_partial_shape.rank();
 
-    const auto axes_constant = get_constant_from_source(input_value(1));
-    auto axes_pshape = get_input_partial_shape(1);
+    const auto input_shapes = get_node_input_partial_shapes(*this);
+    auto output_shapes = std::vector<ov::PartialShape>(1);
 
-    NODE_VALIDATION_CHECK(this,
-                          axes_pshape.rank().compatible(0) || axes_pshape.rank().compatible(1),
-                          "Second input (axes) should not be of rank higher than 1. Got: ",
-                          axes_pshape.rank().get_length());
+    shape_infer(this, input_shapes, output_shapes);
 
-    if (data_rank.is_dynamic() || !axes_constant) {
-        set_output_type(0, get_input_element_type(0), ov::PartialShape::dynamic());
-        return;
-    }
-
-    const auto axes_values = axes_constant->cast_vector<int64_t>();
-    uint64_t data_rank_value = data_partial_shape.rank().get_length();
-    const int64_t expanded_rank = data_rank_value + axes_values.size();
-
-    NODE_VALIDATION_CHECK(this, !axes_values.empty(), "'axes' input is mandatory");
-
-    auto normalized_axes = normalize_axes(this->description(), axes_values, expanded_rank);
-    set<int64_t> axes(begin(normalized_axes), end(normalized_axes));
-    vector<Dimension> output_shape{data_partial_shape};
-    for (auto axis : axes) {
-        NODE_VALIDATION_CHECK(this, axis <= expanded_rank, "provided 'axes' value ", axis, " is not valid.");
-
-        output_shape.insert(next(begin(output_shape), axis), 1);
-    }
-    set_output_type(0, get_input_element_type(0), ov::PartialShape{output_shape});
+    set_output_type(0, get_input_element_type(0), output_shapes[0]);
 }
 
 bool op::v0::Unsqueeze::visit_attributes(AttributeVisitor& visitor) {
@@ -82,29 +54,32 @@ bool evaluate(const HostTensorPtr& arg0, const HostTensorPtr& out) {
     return true;
 }
 
-bool evaluate_unsqueeze(const HostTensorPtr& arg0, const HostTensorPtr& arg1, const HostTensorPtr& out) {
+// The evaluate cannot use shape_infer for output shape calculation as shape inference accepts
+// repeated axis and evaluate not. When shape inference will changed to be compatible with `numpy` then
+// evaluate and inference can use same function to calculate output shape. TODO for next version for this operator.
+bool evaluate_unsqueeze(const Node* node,
+                        const HostTensorPtr& arg0,
+                        const HostTensorPtr& arg1,
+                        const HostTensorPtr& out) {
     auto element_type = arg0->get_element_type();
     out->set_element_type(element_type);
 
-    auto data_shape = arg0->get_shape();
-    int64_t data_rank = static_cast<int64_t>(data_shape.size());
-    auto axes_shape = arg1->get_shape();
-    NGRAPH_CHECK(axes_shape.size() == 1 || axes_shape.empty(),
-                 "Axes to add must be a scalar or 1D tensor with 1 element");
+    const auto& axes_shape = arg1->get_shape();
+    ov::op::v0::check_unsqueeze_axes_rank(node, Rank(axes_shape.size()));
+
+    const auto& data_shape = arg0->get_shape();
+    const auto out_rank = static_cast<int64_t>(data_shape.size() + shape_size(axes_shape));
+
+    // Get axes and normalize
+    auto axes = read_index_vector(arg1);
+    normalize_axes(node, out_rank, axes);
 
-    auto out_shape = data_shape;
-    int64_t out_rank = data_rank + static_cast<int64_t>(shape_size(axes_shape));
-    // Get axes
-    vector<int64_t> axes = read_index_vector(arg1);
-    // Normalize axes
-    std::transform(axes.begin(), axes.end(), axes.begin(), [out_rank](int64_t i) -> int64_t {
-        return i < 0 ? out_rank + i : i;
-    });
     // Sort in increasing order
-    std::set<int64_t, less<int64_t>> axes_set(axes.begin(), axes.end());
+    std::set<int64_t> axes_set(axes.begin(), axes.end());
     NGRAPH_CHECK(axes.size() == axes_set.size(), "Axes has duplicate axis.");
+
+    auto out_shape = data_shape;
     for (int64_t axis : axes_set) {
-        NGRAPH_CHECK(axis >= 0 && axis < out_rank, "Axis is out of bounds: ", axis);
         out_shape.insert(out_shape.begin() + axis, 1);
     }
     out->set_shape(out_shape);
@@ -130,7 +105,7 @@ bool op::v0::Unsqueeze::evaluate(const HostTensorVector& outputs, const HostTens
     OV_OP_SCOPE(v0_Unsqueeze_evaluate);
     NGRAPH_CHECK(validate_host_tensor_vector(inputs, 2));
     NGRAPH_CHECK(validate_host_tensor_vector(outputs, 1));
-    return unsqueeze::evaluate_unsqueeze(inputs[0], inputs[1], outputs[0]);
+    return unsqueeze::evaluate_unsqueeze(this, inputs[0], inputs[1], outputs[0]);
 }
 
 bool op::v0::Unsqueeze::has_evaluate() const {