onnx 1.13.1__cp311-cp311-macosx_10_12_universal2.whl → 1.14.0__cp311-cp311-macosx_10_12_universal2.whl

onnx/defs/generator/defs.cc

@@ -8,16 +8,16 @@
 #include "onnx/defs/schema.h"
 
 namespace ONNX_NAMESPACE {
-static const char* Constant_ver13_doc = R"DOC(
+static const char* Constant_ver19_doc = R"DOC(
 This operator produces a constant tensor. Exactly one of the provided attributes, either value, sparse_value,
 or value_* must be specified.
 )DOC";
 
 ONNX_OPERATOR_SET_SCHEMA(
     Constant,
-    13,
+    19,
     OpSchema()
-        .SetDoc(Constant_ver13_doc)
+        .SetDoc(Constant_ver19_doc)
         .Attr("value", "The value for the elements of the output tensor.", AttributeProto::TENSOR, false)
         .Attr(
             "sparse_value",
@@ -55,10 +55,7 @@ ONNX_OPERATOR_SET_SCHEMA(
             AttributeProto::STRINGS,
             false)
         .Output(0, "output", "Output tensor containing the same value of the provided tensor.", "T")
-        .TypeConstraint(
-            "T",
-            OpSchema::all_tensor_types_with_bfloat(),
-            "Constrain input and output types to all tensor types.")
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir9(), "Constrain input and output types to all tensor types.")
         .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
           auto* value = ctx.getAttribute("value");
           auto* sparse_value = ctx.getAttribute("sparse_value");
@@ -541,28 +538,33 @@ static const char* Range_ver11_doc = R"DOC(
 Generate a tensor containing a sequence of numbers that begin at `start` and extends by increments of `delta`
 up to `limit` (exclusive).
 
-The number of elements in the output of range is computed as below-
-
-`number_of_elements = max( ceil( (limit - start) / delta ) , 0 )`
-
-The pseudocode determining the contents of the output is shown below-
+The number of elements in the output of range is computed as below:
 
-`for(int i=0; i<number_of_elements; ++i)`
+```
+number_of_elements = max( ceil( (limit - start) / delta ) , 0 )
+```
 
-`{`
+The pseudocode determining the contents of the output is shown below:
 
-`    output[i] =  start + (i * delta);  `
+```
+for(int i=0; i<number_of_elements; ++i) {
+  output[i] =  start + (i * delta);
+}
+```
 
-`}`
+Example 1
 
-`Example 1`
+```
 Inputs: start = 3, limit = 9, delta = 3
 Output: [3, 6]
+```
+
+Example 2
 
-`Example 2`
+```
 Inputs: start = 10, limit = 4, delta = -2
 Output: [10, 8, 6]
-
+```
 )DOC";
 
 template <typename T>

onnx/defs/generator/old.cc

@@ -7,6 +7,163 @@
 #include "onnx/defs/schema.h"
 
 namespace ONNX_NAMESPACE {
+static const char* Constant_ver13_doc = R"DOC(
+This operator produces a constant tensor. Exactly one of the provided attributes, either value, sparse_value,
+or value_* must be specified.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Constant,
+    13,
+    OpSchema()
+        .SetDoc(Constant_ver13_doc)
+        .Attr("value", "The value for the elements of the output tensor.", AttributeProto::TENSOR, false)
+        .Attr(
+            "sparse_value",
+            "The value for the elements of the output tensor in sparse format.",
+            AttributeProto::SPARSE_TENSOR,
+            false)
+        .Attr(
+            "value_int",
+            "The value for the sole element for the scalar, int64, output tensor.",
+            AttributeProto::INT,
+            false)
+        .Attr(
+            "value_ints",
+            "The values for the elements for the 1D, int64, output tensor.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "value_float",
+            "The value for the sole element for the scalar, float32, output tensor.",
+            AttributeProto::FLOAT,
+            false)
+        .Attr(
+            "value_floats",
+            "The values for the elements for the 1D, float32, output tensor.",
+            AttributeProto::FLOATS,
+            false)
+        .Attr(
+            "value_string",
+            "The value for the sole element for the scalar, UTF-8 string, output tensor.",
+            AttributeProto::STRING,
+            false)
+        .Attr(
+            "value_strings",
+            "The values for the elements for the 1D, UTF-8 string, output tensor.",
+            AttributeProto::STRINGS,
+            false)
+        .Output(0, "output", "Output tensor containing the same value of the provided tensor.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto* value = ctx.getAttribute("value");
+          auto* sparse_value = ctx.getAttribute("sparse_value");
+          auto* value_int = ctx.getAttribute("value_int");
+          auto* value_ints = ctx.getAttribute("value_ints");
+          auto* value_float = ctx.getAttribute("value_float");
+          auto* value_floats = ctx.getAttribute("value_floats");
+          auto* value_string = ctx.getAttribute("value_string");
+          auto* value_strings = ctx.getAttribute("value_strings");
+
+          std::vector<bool> non_null_attr = {
+              (nullptr != value),
+              (nullptr != sparse_value),
+              (nullptr != value_int),
+              (nullptr != value_ints),
+              (nullptr != value_float),
+              (nullptr != value_floats),
+              (nullptr != value_string),
+              (nullptr != value_strings)};
+          if (std::count(non_null_attr.begin(), non_null_attr.end(), true) != 1) {
+            fail_shape_inference(
+                "One and only one of the attributes 'value', 'value_*' or 'sparse_value' must be specified for a Constant node.");
+          }
+
+          if (nullptr != value) {
+            // OpSchema::Verify check ensures that the attribute value has_t():
+            const TensorProto& tensor_proto = value->t();
+            updateOutputElemType(ctx, 0, tensor_proto.data_type());
+            updateOutputShape(ctx, 0, tensor_proto);
+            return;
+          }
+
+          if (nullptr != value_int) {
+            // OpSchema::Verify check ensures that the attribute value has_i():
+            if (!value_int->has_i()) {
+              fail_shape_inference("Attribute 'value_int' expect an integer.")
+            }
+            updateOutputElemType(ctx, 0, TensorProto::INT64);
+            updateOutputShape(ctx, 0, TensorShapeProto());
+            return;
+          }
+
+          if (nullptr != value_ints) {
+            // OpSchema::Verify check ensures that the attribute value has ints.
+            if (value_ints->ints_size() < 1) {
+              fail_shape_inference("Attribute 'value_ints' expect a list of integers.");
+            }
+            updateOutputElemType(ctx, 0, TensorProto::INT64);
+            appendDim(getOutputShape(ctx, 0), value_ints->ints_size());
+            return;
+          }
+
+          if (nullptr != value_float) {
+            // OpSchema::Verify check ensures that the attribute value has_i():
+            if (!value_float->has_f()) {
+              fail_shape_inference("Attribute 'value_float' expect a float.");
+            }
+            updateOutputElemType(ctx, 0, TensorProto::FLOAT);
+            updateOutputShape(ctx, 0, TensorShapeProto());
+            return;
+          }
+
+          if (nullptr != value_floats) {
+            // OpSchema::Verify check ensures that the attribute value has ints.
+            if (value_floats->floats_size() < 1) {
+              fail_shape_inference("Attribute 'value_floats' expect a list of floats.");
+            }
+            updateOutputElemType(ctx, 0, TensorProto::FLOAT);
+            appendDim(getOutputShape(ctx, 0), value_floats->floats_size());
+            return;
+          }
+
+          if (nullptr != value_string) {
+            // OpSchema::Verify check ensures that the attribute value has_i():
+            if (!value_string->has_s()) {
+              fail_shape_inference("Attribute 'value_string' expect a string.");
+            }
+            updateOutputElemType(ctx, 0, TensorProto::STRING);
+            updateOutputShape(ctx, 0, TensorShapeProto());
+            return;
+          }
+
+          if (nullptr != value_strings) {
+            // OpSchema::Verify check ensures that the attribute value has ints.
+            if (value_strings->strings_size() < 1) {
+              fail_shape_inference("Attribute 'value_strings' expect a list of strings.");
+            }
+            updateOutputElemType(ctx, 0, TensorProto::STRING);
+            appendDim(getOutputShape(ctx, 0), value_strings->strings_size());
+            return;
+          }
+
+          if (nullptr != sparse_value) {
+            // OpSchema::Verify check ensures that the attribute value
+            // has_sparse_tensor():
+            const SparseTensorProto& sparse = sparse_value->sparse_tensor();
+            // checker.cc::check_sparse_tensor checks that the sparse-value is
+            // well-formed
+            updateOutputElemType(ctx, 0, sparse.values().data_type());
+            auto* output_shape = getOutputShape(ctx, 0);
+            for (int i = 0; i < sparse.dims_size(); ++i)
+              appendDim(output_shape, sparse.dims(i));
+            return;
+          }
+
+          fail_shape_inference(
+              "TypeAndShapeInferenceFunction implementation incomplete: "
+              "this line should never be reached.");
+        }));
 
 static const char* Constant_ver12_doc = R"DOC(
 This operator produces a constant tensor. Exactly one of the provided attributes, either value, sparse_value,

onnx/defs/logical/defs.cc

@@ -89,7 +89,7 @@ ONNX_OPERATOR_SET_SCHEMA(
     13,
     OpSchema()
         .FillUsing(BinaryLogicDocGenerator("greater"))
-        .TypeConstraint("T", OpSchema::all_numeric_types_with_bfloat(), "Constrain input types to all numeric tensors.")
+        .TypeConstraint("T", OpSchema::all_numeric_types_ir4(), "Constrain input types to all numeric tensors.")
         .TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
 
 ONNX_OPERATOR_SET_SCHEMA(
@@ -97,12 +97,12 @@ ONNX_OPERATOR_SET_SCHEMA(
     13,
     OpSchema()
         .FillUsing(BinaryLogicDocGenerator("less"))
-        .TypeConstraint("T", OpSchema::all_numeric_types_with_bfloat(), "Constrain input types to all numeric tensors.")
+        .TypeConstraint("T", OpSchema::all_numeric_types_ir4(), "Constrain input types to all numeric tensors.")
         .TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
 
 ONNX_OPERATOR_SET_SCHEMA(
     Equal,
-    13,
+    19,
     OpSchema()
         .FillUsing(BinaryLogicDocGenerator("equal"))
         .TypeConstraint(
@@ -119,8 +119,9 @@ ONNX_OPERATOR_SET_SCHEMA(
              "tensor(float16)",
              "tensor(float)",
              "tensor(double)",
-             "tensor(bfloat16)"},
-            "Constrain input types to all numeric tensors.")
+             "tensor(bfloat16)",
+             "tensor(string)"},
+            "Constrain input types to all (non-complex) tensors.")
         .TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
 
 static const char* Not_ver1_doc = R"DOC(
@@ -139,16 +140,16 @@ ONNX_OPERATOR_SET_SCHEMA(
 
 static const char* BitShift_ver11_doc = R"DOC(
 Bitwise shift operator performs element-wise operation. For each input element, if the
- attribute "direction" is "RIGHT", this operator moves its binary representation toward
- the right side so that the input value is effectively decreased. If the attribute "direction"
- is "LEFT", bits of binary representation moves toward the left side, which results the
- increase of its actual value. The input X is the tensor to be shifted and another input
- Y specifies the amounts of shifting. For example, if "direction" is "Right", X is [1, 4],
- and S is [1, 1], the corresponding output Z would be [0, 2]. If "direction" is "LEFT" with
- X=[1, 2] and S=[1, 2], the corresponding output Y would be [2, 8].
+attribute "direction" is "RIGHT", this operator moves its binary representation toward
+the right side so that the input value is effectively decreased. If the attribute "direction"
+is "LEFT", bits of binary representation moves toward the left side, which results the
+increase of its actual value. The input X is the tensor to be shifted and another input
+Y specifies the amounts of shifting. For example, if "direction" is "Right", X is [1, 4],
+and S is [1, 1], the corresponding output Z would be [0, 2]. If "direction" is "LEFT" with
+X=[1, 2] and S=[1, 2], the corresponding output Y would be [2, 8].
 
- Because this operator supports Numpy-style broadcasting, X's and Y's shapes are
- not necessarily identical.
+Because this operator supports Numpy-style broadcasting, X's and Y's shapes are
+not necessarily identical.
 )DOC";
 
 ONNX_OPERATOR_SET_SCHEMA(
@@ -192,7 +193,7 @@ ONNX_OPERATOR_SET_SCHEMA(
     16,
     OpSchema()
         .FillUsing(BinaryLogicDocGenerator("less_equal"))
-        .TypeConstraint("T", OpSchema::all_numeric_types_with_bfloat(), "Constrain input types to all numeric tensors.")
+        .TypeConstraint("T", OpSchema::all_numeric_types_ir4(), "Constrain input types to all numeric tensors.")
         .TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor.")
         .TypeAndShapeInferenceFunction(InferenceFunction())
         .FunctionBody(R"ONNX(
@@ -208,7 +209,7 @@ ONNX_OPERATOR_SET_SCHEMA(
     16,
     OpSchema()
         .FillUsing(BinaryLogicDocGenerator("greater_equal"))
-        .TypeConstraint("T", OpSchema::all_numeric_types_with_bfloat(), "Constrain input types to all numeric tensors.")
+        .TypeConstraint("T", OpSchema::all_numeric_types_ir4(), "Constrain input types to all numeric tensors.")
         .TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor.")
         .TypeAndShapeInferenceFunction(InferenceFunction())
         .FunctionBody(R"ONNX(

onnx/defs/logical/old.cc

@@ -248,4 +248,27 @@ ONNX_OPERATOR_SET_SCHEMA(
         }
         )ONNX"));
 
+ONNX_OPERATOR_SET_SCHEMA(
+    Equal,
+    13,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator("equal"))
+        .TypeConstraint(
+            "T",
+            {"tensor(bool)",
+             "tensor(uint8)",
+             "tensor(uint16)",
+             "tensor(uint32)",
+             "tensor(uint64)",
+             "tensor(int8)",
+             "tensor(int16)",
+             "tensor(int32)",
+             "tensor(int64)",
+             "tensor(float16)",
+             "tensor(float)",
+             "tensor(double)",
+             "tensor(bfloat16)"},
+            "Constrain input types to all numeric tensors.")
+        .TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
+
 } // namespace ONNX_NAMESPACE