onnx 1.13.1__cp38-cp38-win_amd64.whl → 1.14.1__cp38-cp38-win_amd64.whl

onnx/defs/sequence/defs.cc

@@ -256,16 +256,19 @@ ONNX_OPERATOR_SET_SCHEMA(
 // Updated operators that consume/produce sequence of tensors.
 
 static const char* SplitToSequence_ver11_doc =
-    R"DOC(Split a tensor into a sequence of tensors, along the specified
-'axis'. Lengths of the parts can be specified using argument 'split'.
+    R"DOC(
+Split a tensor into a sequence of tensors, along the specified 'axis'.
+Lengths of the parts can be specified using the optional argument 'split'.
+If the argument `split' is not specified, a default scalar value of 1
+is used as the value of `split'.
 'split' must contain only positive numbers.
 'split' is either a scalar (tensor of empty shape), or a 1-D tensor.
-If 'split' is a scalar, then 'input' will be split into equally sized chunks(if possible).
-Last chunk will be smaller if the 'input' size along the given axis 'axis' is not divisible
-by 'split'.
-Otherwise, the tensor is split into 'size(split)' chunks, with lengths of the parts on 'axis'
-specified in 'split'. In this scenario, the sum of entries in 'split' must be equal to the
-dimension size of input tensor on 'axis'.
+If 'split' is a scalar, then 'input' will be split into chunks all of size 'split'
+if possible. The last chunk alone may be smaller than 'split' if the 'input' size
+along the given axis 'axis' is not divisible by 'split'.
+If 'split' is a 1-dimensional tensor, the input tensor is split into 'size(split)' chunks,
+with lengths of the parts on 'axis' specified in 'split'. In this scenario, the sum of entries
+in 'split' must be equal to the dimension size of input tensor on 'axis'.
 )DOC";
 
 ONNX_OPERATOR_SET_SCHEMA(

onnx/defs/shape_inference.cc

@@ -230,6 +230,28 @@ void UnionShapeInfo(const TensorShapeProto& source_shape, TypeProto_Tensor& targ
   UnionShapeInfoForTensor(source_shape, target_type);
 }
 
+void UnionShapeInfo(const TypeProto_Tensor& source_type, TypeProto_Tensor& target_type) {
+  // The union of a tensor of unknown rank and a tensor of known rank is a tensor of unknown rank.
+  // Hence, if the source_type had unknown rank, we clear the shape of the target_type.
+  // Otherwise, UnionShapeInfoForTensor handles the rest.
+  if (source_type.has_shape()) {
+    UnionShapeInfoForTensor(source_type.shape(), target_type);
+  } else {
+    target_type.clear_shape();
+  }
+}
+
+void UnionShapeInfo(const TypeProto_SparseTensor& source_type, TypeProto_SparseTensor& target_type) {
+  // The union of a tensor of unknown rank and a tensor of known rank is a tensor of unknown rank.
+  // Hence, if the source_type had unknown rank, we clear the shape of the target_type.
+  // Otherwise, UnionShapeInfoForTensor handles the rest.
+  if (source_type.has_shape()) {
+    UnionShapeInfoForTensor(source_type.shape(), target_type);
+  } else {
+    target_type.clear_shape();
+  }
+}
+
 void UnionShapeInfo(const TensorShapeProto& source_shape, TypeProto_SparseTensor& target_type) {
   UnionShapeInfoForTensor(source_shape, target_type);
 }
@@ -249,7 +271,7 @@ void UnionTypeInfo(const TypeProto& source_type, TypeProto& target_type) {
           "Mismatched tensor element type:", " source=", source_elem_type, " target=", target_elem_type);
     }
 
-    UnionShapeInfoForTensor(source_type.tensor_type().shape(), *target_type.mutable_tensor_type());
+    UnionShapeInfo(source_type.tensor_type(), *target_type.mutable_tensor_type());
   } else if (target_case == TypeProto::ValueCase::kSparseTensorType) {
     auto source_elem_type = source_type.sparse_tensor_type().elem_type();
     auto target_elem_type = target_type.sparse_tensor_type().elem_type();
@@ -257,8 +279,7 @@ void UnionTypeInfo(const TypeProto& source_type, TypeProto& target_type) {
       fail_type_inference(
           "Mismatched sparse tensor element type:", " source=", source_elem_type, " target=", target_elem_type);
     }
-
-    UnionShapeInfoForTensor(source_type.sparse_tensor_type().shape(), *target_type.mutable_sparse_tensor_type());
+    UnionShapeInfo(source_type.sparse_tensor_type(), *target_type.mutable_sparse_tensor_type());
   } else if (target_case == TypeProto::ValueCase::kSequenceType) {
     if (!source_type.sequence_type().has_elem_type()) {
       fail_type_inference("source sequence type missing element type.");
@@ -469,4 +490,4 @@ TensorShapeProto getShapeInput(InferenceContext& ctx, size_t input_index, bool&
   return shape_input;
 }
 
-} // namespace ONNX_NAMESPACE
+} // namespace ONNX_NAMESPACE

onnx/defs/shape_inference.h

@@ -716,7 +716,7 @@ inline TypeProto RemoveDimensionsFromShape(const TypeProto& proto, int num_dimen
 }
 
 // copied from GSL:
-// https://github.com/Microsoft/GSL/blob/master/include/gsl/gsl_util
+// https://github.com/Microsoft/GSL/blob/main/include/gsl/gsl_util
 template <class T, class U>
 static constexpr T narrow_cast(U&& u) noexcept {
   return static_cast<T>(std::forward<U>(u));
@@ -822,4 +822,32 @@ void UnionShapeInfo(const TensorShapeProto& source_shape, TypeProto_SparseTensor
 //    output: sequence of tensor, elem_type: float, shape: None
 void UnionTypeInfo(const TypeProto& source_type, TypeProto& target_type);
 
+// adjustNegativeAxes: Negative axes values are translated to the right axis in the positive range
+template <typename Axes>
+void adjustNegativeAxes(Axes& axes, int rank) {
+  std::transform(
+      axes.begin(), axes.end(), axes.begin(), [&](int64_t axis) -> int64_t { return axis < 0 ? axis + rank : axis; });
+}
+
+// checkAxesRange: Checks that values are within the range [-rank, rank)
+template <typename Axes>
+void checkAxesRange(Axes& axes, int rank) {
+  for (auto axis : axes) {
+    if (axis < -rank || axis > (rank - 1))
+      fail_shape_inference("Unexpected axis value: ", axis, ". Expected range [", -rank, ", ", rank, ")");
+  }
+}
+
+// checkDuplicateAxes: Check that there are no duplicated axes
+template <typename Axes>
+void checkDuplicateAxes(Axes& axes, int rank) {
+  std::vector<bool> tmp(rank, false);
+  for (auto axis : axes) {
+    int actual_axis = axis < 0 ? axis + rank : axis;
+    if (tmp[actual_axis])
+      fail_shape_inference("Axis ", axis, " is referred to more than once.");
+    tmp[actual_axis] = true;
+  }
+}
+
 } // namespace ONNX_NAMESPACE