onnx 1.13.0__cp310-cp310-win_amd64.whl → 1.14.0__cp310-cp310-win_amd64.whl

onnx/defs/parser.h

@@ -72,22 +72,26 @@ class StringIntMap {
 class PrimitiveTypeNameMap : public StringIntMap<PrimitiveTypeNameMap> {
  public:
   PrimitiveTypeNameMap() : StringIntMap() {
-    map_["float"] = 1;
-    map_["uint8"] = 2;
-    map_["int8"] = 3;
-    map_["uint16"] = 4;
-    map_["int16"] = 5;
-    map_["int32"] = 6;
-    map_["int64"] = 7;
-    map_["string"] = 8;
-    map_["bool"] = 9;
-    map_["float16"] = 10;
-    map_["double"] = 11;
-    map_["uint32"] = 12;
-    map_["uint64"] = 13;
-    map_["complex64"] = 14;
-    map_["complex128"] = 15;
-    map_["bfloat16"] = 16;
+    map_["float"] = TensorProto_DataType_FLOAT;
+    map_["uint8"] = TensorProto_DataType_UINT8;
+    map_["int8"] = TensorProto_DataType_INT8;
+    map_["uint16"] = TensorProto_DataType_UINT16;
+    map_["int16"] = TensorProto_DataType_INT16;
+    map_["int32"] = TensorProto_DataType_INT32;
+    map_["int64"] = TensorProto_DataType_INT64;
+    map_["string"] = TensorProto_DataType_STRING;
+    map_["bool"] = TensorProto_DataType_BOOL;
+    map_["float16"] = TensorProto_DataType_FLOAT16;
+    map_["double"] = TensorProto_DataType_DOUBLE;
+    map_["uint32"] = TensorProto_DataType_UINT32;
+    map_["uint64"] = TensorProto_DataType_UINT64;
+    map_["complex64"] = TensorProto_DataType_COMPLEX64;
+    map_["complex128"] = TensorProto_DataType_COMPLEX128;
+    map_["bfloat16"] = TensorProto_DataType_BFLOAT16;
+    map_["float8e4m3fn"] = TensorProto_DataType_FLOAT8E4M3FN;
+    map_["float8e4m3fnuz"] = TensorProto_DataType_FLOAT8E4M3FNUZ;
+    map_["float8e5m2"] = TensorProto_DataType_FLOAT8E5M2;
+    map_["float8e5m2fnuz"] = TensorProto_DataType_FLOAT8E5M2FNUZ;
   }
 
   static bool IsTypeName(const std::string& dtype) {
@@ -98,20 +102,20 @@ class PrimitiveTypeNameMap : public StringIntMap<PrimitiveTypeNameMap> {
 class AttributeTypeNameMap : public StringIntMap<AttributeTypeNameMap> {
  public:
   AttributeTypeNameMap() : StringIntMap() {
-    map_["float"] = 1;
-    map_["int"] = 2;
-    map_["string"] = 3;
-    map_["tensor"] = 4;
-    map_["graph"] = 5;
-    map_["sparse_tensor"] = 11;
-    map_["type_proto"] = 13;
-    map_["floats"] = 6;
-    map_["ints"] = 7;
-    map_["strings"] = 8;
-    map_["tensors"] = 9;
-    map_["graphs"] = 10;
-    map_["sparse_tensors"] = 12;
-    map_["type_protos"] = 14;
+    map_["float"] = AttributeProto_AttributeType_FLOAT;
+    map_["int"] = AttributeProto_AttributeType_INT;
+    map_["string"] = AttributeProto_AttributeType_STRING;
+    map_["tensor"] = AttributeProto_AttributeType_TENSOR;
+    map_["graph"] = AttributeProto_AttributeType_GRAPH;
+    map_["sparse_tensor"] = AttributeProto_AttributeType_SPARSE_TENSOR;
+    map_["type_proto"] = AttributeProto_AttributeType_TYPE_PROTO;
+    map_["floats"] = AttributeProto_AttributeType_FLOATS;
+    map_["ints"] = AttributeProto_AttributeType_INTS;
+    map_["strings"] = AttributeProto_AttributeType_STRINGS;
+    map_["tensors"] = AttributeProto_AttributeType_TENSORS;
+    map_["graphs"] = AttributeProto_AttributeType_GRAPHS;
+    map_["sparse_tensors"] = AttributeProto_AttributeType_SPARSE_TENSORS;
+    map_["type_protos"] = AttributeProto_AttributeType_TYPE_PROTOS;
   }
 };
 
@@ -386,6 +390,8 @@ class OnnxParser : public ParserBase {
 
   Status Parse(AttributeProto& attr);
 
+  Status Parse(AttributeProto& attr, std::string& name);
+
   Status Parse(AttrList& attrlist);
 
   Status Parse(NodeProto& node);
@@ -411,6 +417,10 @@ class OnnxParser : public ParserBase {
 
   Status Parse(char open, IdList& idlist, char close);
 
+  Status Parse(IdList& idlist, AttrList& attrlist);
+
+  Status Parse(char open, IdList& idlist, AttrList& attrlist, char close);
+
   Status ParseSingleAttributeValue(AttributeProto& attr);
 
   Status Parse(ValueInfoProto& valueinfo);
@@ -426,6 +436,8 @@ class OnnxParser : public ParserBase {
   Status Parse(OpsetIdList& opsets);
 
   bool NextIsType();
+
+  bool NextIsIdentifier();
 };
 
-} // namespace ONNX_NAMESPACE
+} // namespace ONNX_NAMESPACE

onnx/defs/printer.cc

@@ -307,6 +307,12 @@ void ProtoPrinter::print(const AttributeProto& attr) {
     case AttributeProto_AttributeType_TENSORS:
       printSet("[", ", ", "]", attr.tensors());
       break;
+    case AttributeProto_AttributeType_TYPE_PROTO:
+      print(attr.tp());
+      break;
+    case AttributeProto_AttributeType_TYPE_PROTOS:
+      printSet("[", ", ", "]", attr.type_protos());
+      break;
     default:
       break;
   }
@@ -436,4 +442,4 @@ DEF_OP(FunctionProto)
 
 DEF_OP(ModelProto)
 
-} // namespace ONNX_NAMESPACE
+} // namespace ONNX_NAMESPACE

onnx/defs/printer.h

@@ -47,4 +47,4 @@ std::string ProtoToString(const ProtoType& proto) {
   return ss.str();
 }
 
-} // namespace ONNX_NAMESPACE
+} // namespace ONNX_NAMESPACE

onnx/defs/quantization/defs.cc

@@ -7,17 +7,21 @@
 
 namespace ONNX_NAMESPACE {
 
-static const char* QuantizeLinear_ver13_doc = R"DOC(
+static const char* QuantizeLinear_ver19_doc = R"DOC(
 The linear quantization operator. It consumes a high precision tensor, a scale, and a zero point to compute the low precision / quantized tensor.
 The scale factor and zero point must have same shape, and can be either a scalar for per-tensor / per layer quantization, or a 1-D tensor for per-axis quantization.
-The quantization formula is y = saturate ((x / y_scale) + y_zero_point).
+The quantization formula is `y = saturate ((x / y_scale) + y_zero_point)`.
 For saturation, it saturates to [0, 255] if it's uint8, or [-128, 127] if it's int8.
-For (x / y_scale), it's rounding to nearest ties to even. Refer to https://en.wikipedia.org/wiki/Rounding for details. 'y_zero_point' and 'y' must have same type.
+For (x / y_scale), it's rounding to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details.
+'y_zero_point' and 'y' must have same type.
+'y_zero_point' is usually not used for quantization to float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz,
+but the quantization formula remains the same for consistency and
+the type of the attribute 'y_zero_point' still determines the quantization type.
 )DOC";
 
 ONNX_OPERATOR_SET_SCHEMA(
     QuantizeLinear,
-    13,
+    19,
     OpSchema()
         .Input(0, "x", "N-D full precision Input tensor to be quantized.", "T1")
         .Input(
@@ -25,7 +29,7 @@ ONNX_OPERATOR_SET_SCHEMA(
             "y_scale",
             "Scale for doing quantization to get 'y'. It can be a scalar, which means per-tensor/layer quantization, "
             "or a 1-D Tensor for per-axis quantization.",
-            "tensor(float)")
+            "T1")
         .Input(
             2,
             "y_zero_point",
@@ -39,12 +43,28 @@ ONNX_OPERATOR_SET_SCHEMA(
             "(Optional) The axis of the quantization dimension of the input tensor. Ignored for per-tensor quantization. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).",
             AttributeProto::INT,
             static_cast<int64_t>(1))
-        .TypeConstraint("T1", {"tensor(float)", "tensor(int32)"}, "Constrain 'x' to float or int32 tensor.")
+        .Attr(
+            "saturate",
+            "The parameter defines how the conversion behaves if an input value is out of "
+            "range of the destination type. It only applies for float 8 quantization "
+            "(float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. "
+            "All cases are fully described in two tables inserted in the operator description.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeConstraint(
+            "T1",
+            {"tensor(float)", "tensor(float16)", "tensor(bfloat16)", "tensor(int32)"},
+            "Constrain 'x' to float, float16, bfloat16 or int32 tensor.")
         .TypeConstraint(
             "T2",
-            {"tensor(int8)", "tensor(uint8)"},
-            "Constrain 'y_zero_point' and 'y' to 8-bit integer tensor.")
-        .SetDoc(QuantizeLinear_ver13_doc)
+            {"tensor(int8)",
+             "tensor(uint8)",
+             "tensor(float8e4m3fn)",
+             "tensor(float8e4m3fnuz)",
+             "tensor(float8e5m2)",
+             "tensor(float8e5m2fnuz)"},
+            "Constrain 'y_zero_point' and 'y' to 8-bit integer/float tensor.")
+        .SetDoc(QuantizeLinear_ver19_doc)
         .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
           if (ctx.hasInput(2)) {
             propagateElemTypeFromInputToOutput(ctx, 2, 0);
@@ -59,43 +79,55 @@ ONNX_OPERATOR_SET_SCHEMA(
           updateOutputShape(ctx, 0, input_shape);
         }));
 
-static const char* DequantizeLinear_ver13_doc = R"DOC(
+static const char* DequantizeLinear_ver19_doc = R"DOC(
 The linear dequantization operator. It consumes a quantized tensor, a scale, and a zero point to compute the full precision tensor.
-The dequantization formula is y = (x - x_zero_point) * x_scale. 'x_scale' and 'x_zero_point' must have same shape, and can be either a scalar
+The dequantization formula is `y = (x - x_zero_point) * x_scale`. `x_scale` and `x_zero_point` must have same shape, and can be either a scalar
 for per-tensor / per layer quantization, or a 1-D tensor for per-axis quantization.
-'x_zero_point' and 'x' must have same type. 'x' and 'y' must have same shape. In the case of dequantizing int32,
+`x_zero_point` and `x` must have same type. `x` and `y` must have same shape. In the case of dequantizing int32,
 there's no zero point (zero point is supposed to be 0).
+`zero-point` is usually not used in the case of float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz quantization,
+but the dequantization formula remains the same for consistency and 'x_scale' still determines the output type.
 )DOC";
 
 ONNX_OPERATOR_SET_SCHEMA(
     DequantizeLinear,
-    13,
+    19,
     OpSchema()
-        .Input(0, "x", "N-D quantized input tensor to be de-quantized.", "T")
+        .Input(0, "x", "N-D quantized input tensor to be de-quantized.", "T1")
         .Input(
             1,
             "x_scale",
             "Scale for input 'x'. It can be a scalar, which means a per-tensor/layer dequantization, "
             "or a 1-D tensor for per-axis dequantization.",
-            "tensor(float)")
+            "T2")
         .Input(
             2,
             "x_zero_point",
             "Zero point for input 'x'. Shape must match x_scale. "
             "It's optional. Zero point is 0 when it's not specified.",
-            "T",
+            "T1",
             OpSchema::Optional)
-        .Output(0, "y", "N-D full precision output tensor. It has same shape as input 'x'.", "tensor(float)")
+        .Output(0, "y", "N-D full precision output tensor. It has same shape as input 'x'.", "T2")
         .Attr(
             "axis",
             "(Optional) The axis of the dequantizing dimension of the input tensor. Ignored for per-tensor quantization. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).",
             AttributeProto::INT,
             static_cast<int64_t>(1))
         .TypeConstraint(
-            "T",
-            {"tensor(int8)", "tensor(uint8)", "tensor(int32)"},
-            "Constrain 'x_zero_point' and 'x' to 8-bit/32-bit integer tensor.")
-        .SetDoc(DequantizeLinear_ver13_doc)
+            "T1",
+            {"tensor(int8)",
+             "tensor(uint8)",
+             "tensor(int32)",
+             "tensor(float8e4m3fn)",
+             "tensor(float8e4m3fnuz)",
+             "tensor(float8e5m2)",
+             "tensor(float8e5m2fnuz)"},
+            "Constrain 'x_zero_point' and 'x' to 8-bit integer or float, or /32-bit integer tensor.")
+        .TypeConstraint(
+            "T2",
+            {"tensor(float)", "tensor(float16)", "tensor(bfloat16)"},
+            "'y_scale' determines the output type.")
+        .SetDoc(DequantizeLinear_ver19_doc)
         .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
           auto y_type = ctx.getOutputType(0);
           // only float is supported
@@ -113,24 +145,29 @@ A Function to fuse calculation for Scale, Zero Point and FP32->8Bit convertion o
 Outputs Scale, ZeroPoint and Quantized Input for a given FP32 Input.
 Scale is calculated as:
 ```
- y_scale = (max(x) - min(x))/(qmax - qmin)
- * where qmax and qmin are max and min values for quantization range .i.e [0, 255] in case of uint8
- * data range is adjusted to include 0.
+y_scale = (max(x) - min(x))/(qmax - qmin)
 ```
+
+* where qmax and qmin are max and min values for quantization range .i.e [0, 255] in case of uint8
+* data range is adjusted to include 0.
+
 Zero point is calculated as:
 ```
 intermediate_zero_point = qmin - min(x)/y_scale
 y_zero_point = cast(round(saturate(itermediate_zero_point)))
+```
+
 * where qmax and qmin are max and min values for quantization range .i.e [0, 255] in case of uint8
 * for saturation, it saturates to [0, 255] if it's uint8, or [-127, 127] if it's int8. Right now only uint8 is supported.
 * rounding to nearest ties to even.
-```
+
 Data quantization formula is:
 ```
 y = saturate (round (x / y_scale) + y_zero_point)
+```
+
 * for saturation, it saturates to [0, 255] if it's uint8, or [-127, 127] if it's int8. Right now only uint8 is supported.
 * rounding to nearest ties to even.
-```
 )DOC";
 
 ONNX_OPERATOR_SET_SCHEMA(

onnx/defs/quantization/old.cc

@@ -7,10 +7,111 @@
 
 namespace ONNX_NAMESPACE {
 
+static const char* QuantizeLinear_ver13_doc = R"DOC(
+The linear quantization operator. It consumes a high precision tensor, a scale, and a zero point to compute the low precision / quantized tensor.
+The scale factor and zero point must have same shape, and can be either a scalar for per-tensor / per layer quantization, or a 1-D tensor for per-axis quantization.
+The quantization formula is y = saturate ((x / y_scale) + y_zero_point).
+For saturation, it saturates to [0, 255] if it's uint8, or [-128, 127] if it's int8.
+For (x / y_scale), it's rounding to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details. 'y_zero_point' and 'y' must have same type.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    QuantizeLinear,
+    13,
+    OpSchema()
+        .Input(0, "x", "N-D full precision Input tensor to be quantized.", "T1")
+        .Input(
+            1,
+            "y_scale",
+            "Scale for doing quantization to get 'y'. It can be a scalar, which means per-tensor/layer quantization, "
+            "or a 1-D Tensor for per-axis quantization.",
+            "tensor(float)")
+        .Input(
+            2,
+            "y_zero_point",
+            "Zero point for doing quantization to get 'y'. Shape must match y_scale. "
+            "Default is uint8 with zero point of 0 if it's not specified.",
+            "T2",
+            OpSchema::Optional)
+        .Output(0, "y", "N-D quantized output tensor. It has same shape as input 'x'.", "T2")
+        .Attr(
+            "axis",
+            "(Optional) The axis of the quantization dimension of the input tensor. Ignored for per-tensor quantization. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeConstraint("T1", {"tensor(float)", "tensor(int32)"}, "Constrain 'x' to float or int32 tensor.")
+        .TypeConstraint(
+            "T2",
+            {"tensor(int8)", "tensor(uint8)"},
+            "Constrain 'y_zero_point' and 'y' to 8-bit integer tensor.")
+        .SetDoc(QuantizeLinear_ver13_doc)
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          if (ctx.hasInput(2)) {
+            propagateElemTypeFromInputToOutput(ctx, 2, 0);
+          } else {
+            updateOutputElemType(ctx, 0, TensorProto::UINT8);
+          }
+          if (!hasInputShape(ctx, 0)) {
+            return;
+          }
+
+          auto& input_shape = getInputShape(ctx, 0);
+          updateOutputShape(ctx, 0, input_shape);
+        }));
+
+static const char* DequantizeLinear_ver13_doc = R"DOC(
+The linear dequantization operator. It consumes a quantized tensor, a scale, and a zero point to compute the full precision tensor.
+The dequantization formula is `y = (x - x_zero_point) * x_scale`. `x_scale` and `x_zero_point` must have same shape, and can be either a scalar
+for per-tensor / per layer quantization, or a 1-D tensor for per-axis quantization.
+`x_zero_point` and `x` must have same type. `x` and `y` must have same shape. In the case of dequantizing int32,
+there's no zero point (zero point is supposed to be 0).
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    DequantizeLinear,
+    13,
+    OpSchema()
+        .Input(0, "x", "N-D quantized input tensor to be de-quantized.", "T")
+        .Input(
+            1,
+            "x_scale",
+            "Scale for input 'x'. It can be a scalar, which means a per-tensor/layer dequantization, "
+            "or a 1-D tensor for per-axis dequantization.",
+            "tensor(float)")
+        .Input(
+            2,
+            "x_zero_point",
+            "Zero point for input 'x'. Shape must match x_scale. "
+            "It's optional. Zero point is 0 when it's not specified.",
+            "T",
+            OpSchema::Optional)
+        .Output(0, "y", "N-D full precision output tensor. It has same shape as input 'x'.", "tensor(float)")
+        .Attr(
+            "axis",
+            "(Optional) The axis of the dequantizing dimension of the input tensor. Ignored for per-tensor quantization. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeConstraint(
+            "T",
+            {"tensor(int8)", "tensor(uint8)", "tensor(int32)"},
+            "Constrain 'x_zero_point' and 'x' to 8-bit/32-bit integer tensor.")
+        .SetDoc(DequantizeLinear_ver13_doc)
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          auto y_type = ctx.getOutputType(0);
+          // only float is supported
+          y_type->mutable_tensor_type()->set_elem_type(ONNX_NAMESPACE::TensorProto::FLOAT);
+
+          if (!hasInputShape(ctx, 0))
+            return;
+
+          auto& input_shape = getInputShape(ctx, 0);
+          updateOutputShape(ctx, 0, input_shape);
+        }));
+
 static const char* QuantizeLinear_ver10_doc = R"DOC(
 The linear per-tensor/layer quantization operator. It consumes a high precision tensor, a scale, a zero point to compute the low precision / quantized tensor.
 The quantization formula is y = saturate ((x / y_scale) + y_zero_point). For saturation, it saturates to [0, 255] if it's uint8, or [-128, 127] if it's int8.
-For (x / y_scale), it's rounding to nearest ties to even. Refer to https://en.wikipedia.org/wiki/Rounding for details. 'y_zero_point' and 'y' must have same type.
+For (x / y_scale), it's rounding to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details. 'y_zero_point' and 'y' must have same type.
 )DOC";
 
 ONNX_OPERATOR_SET_SCHEMA(

onnx/defs/reduction/defs.cc

@@ -126,7 +126,7 @@ The type of the output tensor is integer.)DOC";
         1,
         OpSchema::NonDifferentiable);
     schema.TypeConstraint(
-        "T", OpSchema::all_numeric_types_with_bfloat(), "Constrain input and output types to all numeric tensors.");
+        "T", OpSchema::all_numeric_types_ir4(), "Constrain input and output types to all numeric tensors.");
     schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
       // set output element type to int64
       updateOutputElemType(ctx, 0, TensorProto_DataType_INT64);

onnx/defs/reduction/utils.cc

@@ -8,14 +8,14 @@
 namespace ONNX_NAMESPACE {
 std::vector<std::string> GetSupportedDataTypesForReductionOps(bool supports8bit) {
   if (supports8bit) {
-    auto data_types = OpSchema::numeric_types_for_math_reduction_with_bfloat();
+    auto data_types = OpSchema::numeric_types_for_math_reduction_ir4();
     data_types.push_back("tensor(uint8)");
     data_types.push_back("tensor(int8)");
 
     return data_types;
   }
 
-  return OpSchema::numeric_types_for_math_reduction_with_bfloat();
+  return OpSchema::numeric_types_for_math_reduction_ir4();
 }
 
 std::function<void(OpSchema&)> ReduceDocGenerator_opset13_18(
@@ -27,9 +27,10 @@ std::function<void(OpSchema&)> ReduceDocGenerator_opset13_18(
   return [=](OpSchema& schema) {
     std::string doc;
     POPULATE_OP_DOC_STR(doc = R"DOC(
-Computes the {name} of the input tensor's element along the provided axes. The resulting
+Computes the {name} of the input tensor's elements along the provided axes. The resulting
 tensor has the same rank as the input if keepdims equals 1. If keepdims equals 0, then
-the resulting tensor has the reduced dimension pruned.
+the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+valid.
 
 The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
 False instead of True.)DOC";