onnx 1.16.2__cp311-cp311-win32.whl → 1.18.0__cp311-cp311-win32.whl

onnx/defs/quantization/defs.cc

@@ -7,7 +7,7 @@
 
 namespace ONNX_NAMESPACE {
 
-static const char* QuantizeLinear_ver21_doc = R"DOC(
+static const char* QuantizeLinear_ver23_doc = R"DOC(
 The linear quantization operator 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 the same shape, determining the quantization
 granularity. The quantization formula is `y = saturate((x / y_scale) + y_zero_point)`.
@@ -22,8 +22,10 @@ Saturation is done according to:
 
 For `(x / y_scale)`, it rounds to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details.
 
-`y_zero_point` and `y` must have the same type. `y_zero_point` is usually not used for quantization to float8 types, but the quantization
+`y_zero_point` and `y` must have the same type. `y_zero_point` is usually not used for quantization to float8 and 4bit types, but the quantization
 formula remains the same for consistency, and the type of the attribute `y_zero_point` still determines the quantization type.
+`x` and `y_scale` are allowed to have different types. The type of `y_scale` determines the precision of the division operation between `x` and
+`y_scale`, unless the `precision` attribute is specified.
 
 There are three supported quantization granularities, determined by the shape of `y_scale`.
 In all cases, `y_zero_point` must have the same shape as `y_scale`.
@@ -37,7 +39,7 @@ In all cases, `y_zero_point` must have the same shape as `y_scale`.
 
 ONNX_OPERATOR_SET_SCHEMA(
     QuantizeLinear,
-    21,
+    23,
     OpSchema()
         .Input(0, "x", "N-D full precision Input tensor to be quantized.", "T1")
         .Input(
@@ -46,20 +48,21 @@ ONNX_OPERATOR_SET_SCHEMA(
             "Scale for doing quantization to get `y`. For per-tensor/layer quantization the scale is a scalar, for "
             "per-axis quantization it is a 1-D Tensor and for blocked quantization it has the same shape as the "
             "input, except for one dimension in which blocking is performed.",
-            "T1")
+            "T2")
         .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",
+            "T3",
             OpSchema::Optional)
-        .Output(0, "y", "N-D quantized output tensor. It has same shape as input `x`.", "T2")
+        .Output(0, "y", "N-D quantized output tensor. It has same shape as input `x`.", "T3")
         .Attr(
             "axis",
-            "(Optional) The axis of the dequantizing dimension of the input tensor. Used for per-axis and blocked "
+            "(Optional) The axis of the dequantizing dimension of the input tensor. Used only for per-axis and blocked "
             "quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` "
-            "where `r = rank(input)`.",
+            "where `r = rank(input)`. When the rank of the input is 1, per-tensor quantization is applied, "
+            "rendering the axis unnecessary in this scenario.",
             AttributeProto::INT,
             static_cast<int64_t>(1))
         .Attr(
@@ -80,9 +83,15 @@ ONNX_OPERATOR_SET_SCHEMA(
             static_cast<int64_t>(0))
         .Attr(
             "output_dtype",
-            "(Optional) The output data type. If not supplied, the output data type is inferred from `y_zero_point` data type (`T2`). "
+            "(Optional) The output data type. If not supplied, the output data type is inferred from `y_zero_point` data type (`T3`). "
             "If neither `output_dtype` nor `y_zero_point` are supplied, output data type is uint8. "
-            "If both `output_dtype` and `y_zero_point` are specified, `output_dtype` must be `T2`.",
+            "If both `output_dtype` and `y_zero_point` are specified, `output_dtype` must be `T3`.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "precision",
+            "(Optional) The precision of the division operation between `x` and `y_scale`. If not provided, "
+            "it will be the same as the type of `y_scale`.",
             AttributeProto::INT,
             static_cast<int64_t>(0))
         .TypeConstraint(
@@ -91,6 +100,10 @@ ONNX_OPERATOR_SET_SCHEMA(
             "The type of the input 'x'.")
         .TypeConstraint(
             "T2",
+            {"tensor(float)", "tensor(float16)", "tensor(bfloat16)", "tensor(int32)"},
+            "The type of the input 'y_scale'.")
+        .TypeConstraint(
+            "T3",
             {"tensor(int8)",
              "tensor(uint8)",
              "tensor(int16)",
@@ -100,9 +113,10 @@ ONNX_OPERATOR_SET_SCHEMA(
              "tensor(float8e5m2)",
              "tensor(float8e5m2fnuz)",
              "tensor(uint4)",
-             "tensor(int4)"},
+             "tensor(int4)",
+             "tensor(float4e2m1)"},
             "The type of the input `y_zero_point` and the output `y`.")
-        .SetDoc(QuantizeLinear_ver21_doc)
+        .SetDoc(QuantizeLinear_ver23_doc)
         .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
           auto const zp_type = ctx.hasInput(2) ? ctx.getInputType(2) : nullptr;
           auto const output_dtype =
@@ -131,7 +145,7 @@ ONNX_OPERATOR_SET_SCHEMA(
           updateOutputShape(ctx, 0, input_shape);
         }));
 
-static const char* DequantizeLinear_ver21_doc = R"DOC(
+static const char* DequantizeLinear_ver23_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 the same shape, determining the quantization's granularity: a scalar for per-tensor/per-layer quantization,
@@ -140,13 +154,15 @@ See QuantizeLinear for details on quantization granularity.
 
 `x_zero_point` and `x` must have the same type. `x` and `y` must have the 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 float8 types quantization, but the dequantization formula remains the same
-for consistency, and `x_scale` still determines the output type.
+`zero-point` is usually not used in the case of float8 and 4-bit types quantization, but the dequantization formula remains the same
+for consistency. The output type is determined by the attribute `output_dtype`. If `output_dtype` is not supplied then the output type
+is the same as `x_scale`. The output type also determines the precision of the multiplication operation.
+
 )DOC";
 
 ONNX_OPERATOR_SET_SCHEMA(
     DequantizeLinear,
-    21,
+    23,
     OpSchema()
         .Input(0, "x", "N-D quantized input tensor to be de-quantized.", "T1")
         .Input(
@@ -163,7 +179,12 @@ ONNX_OPERATOR_SET_SCHEMA(
             "It's optional. Zero point is 0 when it's not specified.",
             "T1",
             OpSchema::Optional)
-        .Output(0, "y", "N-D full precision output tensor. It has same shape as input `x`.", "T2")
+        .Output(
+            0,
+            "y",
+            "N-D full precision output tensor. It has the same shape as input `x`. The data type is specified "
+            "by the `output_dtype` attribute or, in its absence, the type of `x_scale`.",
+            "T3")
         .Attr(
             "axis",
             "(Optional) The axis of the dequantizing dimension of the input tensor. Used for per-axis and blocked "
@@ -179,6 +200,11 @@ ONNX_OPERATOR_SET_SCHEMA(
             "`[ceil(Di/Si), ceil(Di/(Si-1))-1]`",
             AttributeProto::INT,
             static_cast<int64_t>(0))
+        .Attr(
+            "output_dtype",
+            "(Optional) The output data type. If not supplied, the output data type is inferred from `x_scale` data type (`T2`)",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
         .TypeConstraint(
             "T1",
             {"tensor(int8)",
@@ -191,15 +217,23 @@ ONNX_OPERATOR_SET_SCHEMA(
              "tensor(float8e5m2)",
              "tensor(float8e5m2fnuz)",
              "tensor(uint4)",
-             "tensor(int4)"},
+             "tensor(int4)",
+             "tensor(float4e2m1)"},
             "The type of the inputs 'x_zero_point' and 'x'.")
         .TypeConstraint(
             "T2",
             {"tensor(float)", "tensor(float16)", "tensor(bfloat16)"},
-            "'x_scale' determines the output type.")
-        .SetDoc(DequantizeLinear_ver21_doc)
+            "The type of the input 'x_scale'.")
+        .TypeConstraint("T3", {"tensor(float)", "tensor(float16)", "tensor(bfloat16)"}, "The type of the output 'y'.")
+        .SetDoc(DequantizeLinear_ver23_doc)
         .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
-          propagateElemTypeFromInputToOutput(ctx, 1, 0);
+          auto const output_dtype =
+              static_cast<TensorProto_DataType>(getAttribute(ctx, "output_dtype", TensorProto::UNDEFINED));
+          if (output_dtype != TensorProto::UNDEFINED) {
+            propagateElemTypeFromAttributeToOutput(ctx, "output_dtype", 0);
+          } else {
+            propagateElemTypeFromInputToOutput(ctx, 1, 0);
+          }
           if (!hasInputShape(ctx, 0)) {
             return;
           }

onnx/defs/quantization/old.cc

@@ -7,6 +7,202 @@
 
 namespace ONNX_NAMESPACE {
 
+static const char* QuantizeLinear_ver21_doc = R"DOC(
+The linear quantization operator 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 the same shape, determining the quantization
+granularity. The quantization formula is `y = saturate((x / y_scale) + y_zero_point)`.
+Saturation is done according to:
+- uint16: [0, 65535]
+- int16: [-32768, 32767]
+- uint8: [0, 255]
+- int8: [-128, 127]
+- uint4: [0, 15]
+- int4: [-8, 7]
+For `(x / y_scale)`, it rounds to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details.
+`y_zero_point` and `y` must have the same type. `y_zero_point` is usually not used for quantization to float8 types, but the quantization
+formula remains the same for consistency, and the type of the attribute `y_zero_point` still determines the quantization type.
+There are three supported quantization granularities, determined by the shape of `y_scale`.
+In all cases, `y_zero_point` must have the same shape as `y_scale`.
+- Per-tensor (per-layer) quantization: `y_scale` is a scalar.
+- Per-axis quantization: The scale must be a 1-D tensor, with the length of the quantization axis. For an input shape
+ `(D0, ..., Di, ..., Dn)` and `axis=i`, `y_scale` is a 1-D tensor of length `Di`.
+- Blocked quantization: The scale's shape is identical to the input's shape, except for one dimension, in which
+  blocking is performed. Given `x` shape `(D0, ..., Di, ..., Dn)`, `axis=i`, and block size `B`: `y_scale` shape is
+  `(D0, ..., ceil(Di/B), ..., Dn)`.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    QuantizeLinear,
+    21,
+    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`. For per-tensor/layer quantization the scale is a scalar, for "
+            "per-axis quantization it is a 1-D Tensor and for blocked quantization it has the same shape as the "
+            "input, except for one dimension in which blocking is performed.",
+            "T1")
+        .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 dequantizing dimension of the input tensor. Used only for per-axis and blocked "
+            "quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` "
+            "where `r = rank(input)`. When the rank of the input is 1, per-tensor quantization is applied, "
+            "rendering the axis unnecessary in this scenario.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .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))
+        .Attr(
+            "block_size",
+            "(Optional) The size of the quantization block (number of times every scale is replicated). Used only for "
+            "blocked quantization. The block size is a positive integer. Given `x` shape `(D0, ..., Di, ..., Dn)`, "
+            "`y_scale` shape `(S0, ... Si, ...Sn)` and `axis=i`, the accepted range is "
+            "`[ceil(Di/Si), ceil(Di/(Si-1))-1]`",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "output_dtype",
+            "(Optional) The output data type. If not supplied, the output data type is inferred from `y_zero_point` data type (`T2`). "
+            "If neither `output_dtype` nor `y_zero_point` are supplied, output data type is uint8. "
+            "If both `output_dtype` and `y_zero_point` are specified, `output_dtype` must be `T2`.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .TypeConstraint(
+            "T1",
+            {"tensor(float)", "tensor(float16)", "tensor(bfloat16)", "tensor(int32)"},
+            "The type of the input 'x'.")
+        .TypeConstraint(
+            "T2",
+            {"tensor(int8)",
+             "tensor(uint8)",
+             "tensor(int16)",
+             "tensor(uint16)",
+             "tensor(float8e4m3fn)",
+             "tensor(float8e4m3fnuz)",
+             "tensor(float8e5m2)",
+             "tensor(float8e5m2fnuz)",
+             "tensor(uint4)",
+             "tensor(int4)"},
+            "The type of the input `y_zero_point` and the output `y`.")
+        .SetDoc(QuantizeLinear_ver21_doc)
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          auto const zp_type = ctx.hasInput(2) ? ctx.getInputType(2) : nullptr;
+          auto const output_dtype =
+              static_cast<TensorProto_DataType>(getAttribute(ctx, "output_dtype", TensorProto::UNDEFINED));
+          if (zp_type != nullptr) {
+            auto const zp_elem_type = static_cast<TensorProto_DataType>(getTensorElementType(*zp_type));
+            if (output_dtype != TensorProto::UNDEFINED && output_dtype != zp_elem_type) {
+              fail_type_inference(
+                  "output_dtype ",
+                  TensorProto_DataType_Name(output_dtype),
+                  " does not match y_zero_point type ",
+                  TensorProto_DataType_Name(zp_elem_type),
+                  ".");
+            }
+            propagateElemTypeFromInputToOutput(ctx, 2, 0);
+          } else if (output_dtype != TensorProto::UNDEFINED) {
+            propagateElemTypeFromAttributeToOutput(ctx, "output_dtype", 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_ver21_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 the same shape, determining the quantization's granularity: a scalar for per-tensor/per-layer quantization,
+a 1-D tensor for per-axis quantization, or have a rank identical to the input for blocked quantization.
+See QuantizeLinear for details on quantization granularity.
+`x_zero_point` and `x` must have the same type. `x` and `y` must have the 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 float8 types quantization, but the dequantization formula remains the same
+for consistency, and `x_scale` still determines the output type.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    DequantizeLinear,
+    21,
+    OpSchema()
+        .Input(0, "x", "N-D quantized input tensor to be de-quantized.", "T1")
+        .Input(
+            1,
+            "x_scale",
+            "Scale for input `x`. For per-tensor/layer dequantization the scale is a scalar, for "
+            "per per-axis dequantization it is a 1-D Tensor and for blocked dequantization it has the same shape as "
+            "the input, except for one dimension in which blocking is performed.",
+            "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.",
+            "T1",
+            OpSchema::Optional)
+        .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. Used for per-axis and blocked "
+            "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))
+        .Attr(
+            "block_size",
+            "(Optional) The size of the quantization block (number of times every scale is replicated). Used only for "
+            "blocked quantization. The block size is a positive integer. Given `x` shape `(D0, ..., Di, ..., Dn)`, "
+            "`y_scale` shape `(S0, ... Si, ...Sn)` and `axis=i`, the accepted range is "
+            "`[ceil(Di/Si), ceil(Di/(Si-1))-1]`",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .TypeConstraint(
+            "T1",
+            {"tensor(int8)",
+             "tensor(uint8)",
+             "tensor(int16)",
+             "tensor(uint16)",
+             "tensor(int32)",
+             "tensor(float8e4m3fn)",
+             "tensor(float8e4m3fnuz)",
+             "tensor(float8e5m2)",
+             "tensor(float8e5m2fnuz)",
+             "tensor(uint4)",
+             "tensor(int4)"},
+            "The type of the inputs 'x_zero_point' and 'x'.")
+        .TypeConstraint(
+            "T2",
+            {"tensor(float)", "tensor(float16)", "tensor(bfloat16)"},
+            "'x_scale' determines the output type.")
+        .SetDoc(DequantizeLinear_ver21_doc)
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 1, 0);
+          if (!hasInputShape(ctx, 0)) {
+            return;
+          }
+          auto& input_shape = getInputShape(ctx, 0);
+          updateOutputShape(ctx, 0, input_shape);
+        }));
+
 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.
@@ -110,7 +306,10 @@ ONNX_OPERATOR_SET_SCHEMA(
         .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).",
+            "(Optional) The axis of the dequantizing dimension of the input tensor. Used only for per-axis quantization. "
+            "Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` "
+            "where `r = rank(input)`. When the rank of the input is 1, per-tensor quantization is applied, "
+            "rendering the axis unnecessary in this scenario.",
             AttributeProto::INT,
             static_cast<int64_t>(1))
         .TypeConstraint(

onnx/defs/reduction/defs.cc

@@ -24,7 +24,7 @@ ONNX_OPERATOR_SET_SCHEMA(
 
 ONNX_OPERATOR_SET_SCHEMA(ReduceSum, 13, OpSchema().FillUsing(ReduceOpDynamicAxes("sum", EMPTY_ZERO)));
 
-const char* reduce_sum_square_func_body = R"ONNX(
+static const char* reduce_sum_square_func_body = R"ONNX(
   {
     data_square = Mul(data, data)
     reduced = ReduceSum<keepdims: int = @keepdims>(data_square, axes)
@@ -40,7 +40,7 @@ ONNX_OPERATOR_SET_SCHEMA(ReduceMean, 18, OpSchema().FillUsing(ReduceOpDynamicAxe
 
 ONNX_OPERATOR_SET_SCHEMA(ReduceProd, 18, OpSchema().FillUsing(ReduceOpDynamicAxes("product", EMPTY_ONE)));
 
-const char* reduce_log_sum_func_body = R"ONNX(
+static const char* reduce_log_sum_func_body = R"ONNX(
   {
     reduced_sum = ReduceSum<keepdims: int = @keepdims>(data, axes)
     reduced = Log (reduced_sum)
@@ -52,7 +52,7 @@ ONNX_OPERATOR_SET_SCHEMA(
     18,
     OpSchema().FillUsing(ReduceFunctionOp("log sum", EMPTY_MINUS_INF, reduce_log_sum_func_body)));
 
-const char* reduce_log_sum_exp_func_body = R"ONNX(
+static const char* reduce_log_sum_exp_func_body = R"ONNX(
   {
     data_double = Cast<to = 11>(data)
     data_exp = Exp (data_double)
@@ -67,7 +67,7 @@ ONNX_OPERATOR_SET_SCHEMA(
     18,
     OpSchema().FillUsing(ReduceFunctionOp("log sum exponent", EMPTY_MINUS_INF, reduce_log_sum_exp_func_body)));
 
-const char* reduce_l1_func_body = R"ONNX(
+static const char* reduce_l1_func_body = R"ONNX(
   {
     data_abs = Abs(data)
     reduced = ReduceSum<keepdims: int = @keepdims>(data_abs, axes)
@@ -79,7 +79,7 @@ ONNX_OPERATOR_SET_SCHEMA(
     18,
     OpSchema().FillUsing(ReduceFunctionOp("L1 norm", EMPTY_ZERO, reduce_l1_func_body)));
 
-const char* reduce_l2_func_body = R"ONNX(
+static const char* reduce_l2_func_body = R"ONNX(
   {
     data_square = Mul(data, data)
     sum_square = ReduceSum<keepdims: int = @keepdims>(data_square, axes)
@@ -94,7 +94,7 @@ ONNX_OPERATOR_SET_SCHEMA(
     18,
     OpSchema().FillUsing(ReduceFunctionOp("L2 norm", EMPTY_ZERO, reduce_l2_func_body)));
 
-std::function<void(OpSchema&)> ArgReduceDocGenerator(const char* name) {
+static std::function<void(OpSchema&)> ArgReduceDocGenerator(const char* name) {
   return [=](OpSchema& schema) {
     std::string doc;
     POPULATE_OP_DOC_STR(doc = R"DOC(

onnx/defs/reduction/old.cc

@@ -10,11 +10,11 @@
 
 namespace ONNX_NAMESPACE {
 
-std::vector<std::string> GetSupportedDataTypesForReductionOps_opset12(bool supports8bit) {
+static std::vector<std::string> GetSupportedDataTypesForReductionOps_opset12(bool supports8bit) {
   if (supports8bit) {
     auto data_types = OpSchema::numeric_types_for_math_reduction();
-    data_types.push_back("tensor(uint8)");
-    data_types.push_back("tensor(int8)");
+    data_types.emplace_back("tensor(uint8)");
+    data_types.emplace_back("tensor(int8)");
 
     return data_types;
   }
@@ -22,7 +22,9 @@ std::vector<std::string> GetSupportedDataTypesForReductionOps_opset12(bool suppo
   return OpSchema::numeric_types_for_math_reduction();
 }
 
-std::function<void(OpSchema&)> ReduceDocGenerator_opset12(const char* name, bool supports_8bit_datatypes = false) {
+static std::function<void(OpSchema&)> ReduceDocGenerator_opset12(
+    const char* name,
+    bool supports_8bit_datatypes = false) {
   return [=](OpSchema& schema) {
     std::string doc;
     POPULATE_OP_DOC_STR(doc = R"DOC(
@@ -71,12 +73,12 @@ False instead of True.)DOC";
       if (axes_proto)
         axes.assign(axes_proto->ints().begin(), axes_proto->ints().end());
 
-      for (size_t i = 0; i < axes.size(); ++i) {
-        if (axes[i] < -input_ndim || axes[i] >= input_ndim) {
+      for (int64_t& axe : axes) {
+        if (axe < -input_ndim || axe >= input_ndim) {
           fail_shape_inference("axis must be in [-rank, rank-1]. input rank was ", input_ndim);
         }
-        if (axes[i] < 0)
-          axes[i] += input_ndim;
+        if (axe < 0)
+          axe += input_ndim;
       }
       // do we need handle negative axis?
       for (int i = 0; i < input_ndim; ++i) {
@@ -115,7 +117,7 @@ ONNX_OPERATOR_SET_SCHEMA(ReduceL1, 11, OpSchema().FillUsing(ReduceDocGenerator_o
 
 ONNX_OPERATOR_SET_SCHEMA(ReduceL2, 11, OpSchema().FillUsing(ReduceDocGenerator_opset12("L2 norm")));
 
-std::function<void(OpSchema&)> ArgReduceDocGenerator_opset12(const char* name) {
+static std::function<void(OpSchema&)> ArgReduceDocGenerator_opset12(const char* name) {
   return [=](OpSchema& schema) {
     std::string doc;
     POPULATE_OP_DOC_STR(doc = R"DOC(
@@ -194,7 +196,8 @@ ONNX_OPERATOR_SET_SCHEMA(ArgMax, 12, OpSchema().FillUsing(ArgReduceDocGenerator_
 
 ONNX_OPERATOR_SET_SCHEMA(ArgMin, 12, OpSchema().FillUsing(ArgReduceDocGenerator_opset12("min")));
 
-std::function<void(OpSchema&)> ReduceDocGenerator_opset1(const char* name, const char* empty_value, int opset = 1) {
+static std::function<void(OpSchema&)>
+ReduceDocGenerator_opset1(const char* name, const char* empty_value, int opset = 1) {
   return [=](OpSchema& schema) {
     std::string doc;
     POPULATE_OP_DOC_STR(doc = R"DOC(
@@ -246,9 +249,9 @@ False instead of True.)DOC";
       if (axes_proto)
         axes.assign(axes_proto->ints().begin(), axes_proto->ints().end());
 
-      for (size_t i = 0; i < axes.size(); ++i) {
-        if (axes[i] < 0)
-          axes[i] += input_ndim;
+      for (int64_t& axe : axes) {
+        if (axe < 0)
+          axe += input_ndim;
       }
       // do we need handle negative axis?
       for (int i = 0; i < input_ndim; ++i) {
@@ -294,7 +297,7 @@ ONNX_OPERATOR_SET_SCHEMA(ReduceMax, 11, OpSchema().FillUsing(ReduceDocGenerator_
 
 ONNX_OPERATOR_SET_SCHEMA(ReduceMin, 11, OpSchema().FillUsing(ReduceDocGenerator_opset1("min", EMPTY_MAX, 11)));
 
-std::function<void(OpSchema&)> ArgReduceDocGenerator_opset1(const char* name) {
+static std::function<void(OpSchema&)> ArgReduceDocGenerator_opset1(const char* name) {
   return [=](OpSchema& schema) {
     std::string doc;
     POPULATE_OP_DOC_STR(doc = R"DOC(
@@ -358,7 +361,7 @@ ONNX_OPERATOR_SET_SCHEMA(ArgMax, 1, OpSchema().FillUsing(ArgReduceDocGenerator_o
 
 ONNX_OPERATOR_SET_SCHEMA(ArgMin, 1, OpSchema().FillUsing(ArgReduceDocGenerator_opset1("min")));
 
-std::function<void(OpSchema&)> ArgReduceDocGenerator_opset11(const char* name) {
+static std::function<void(OpSchema&)> ArgReduceDocGenerator_opset11(const char* name) {
   return [=](OpSchema& schema) {
     std::string doc = R"DOC(
 Computes the indices of the {name} elements of the input tensor's element along the

onnx/defs/reduction/utils.cc

@@ -10,14 +10,14 @@
 
 namespace ONNX_NAMESPACE {
 
-std::vector<std::string> GetSupportedDataTypesForReductionOps(bool supports8bit, bool supports_bool) {
+static std::vector<std::string> GetSupportedDataTypesForReductionOps(bool supports8bit, bool supports_bool) {
   auto data_types = OpSchema::numeric_types_for_math_reduction_ir4();
   if (supports8bit) {
-    data_types.push_back("tensor(uint8)");
-    data_types.push_back("tensor(int8)");
+    data_types.emplace_back("tensor(uint8)");
+    data_types.emplace_back("tensor(int8)");
   }
   if (supports_bool) {
-    data_types.push_back("tensor(bool)");
+    data_types.emplace_back("tensor(bool)");
   }
 
   return data_types;
@@ -29,7 +29,7 @@ std::function<void(OpSchema&)> ReduceOpGenerator(
     bool supports_8bit_datatypes,
     bool axes_input,
     const char* func_body,
-    ContextDependentFunctionBodyBuilder function_builder,
+    const ContextDependentFunctionBodyBuilder& function_builder,
     bool supports_boolean_datatype /* = false */) {
   return [=](OpSchema& schema) {
     std::string doc = R"DOC(
@@ -138,12 +138,12 @@ to `False` instead of `True`.)DOC";
       int64_t input_ndim = input_shape.dim_size();
       auto output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
 
-      for (size_t i = 0; i < axes.size(); ++i) {
-        if (axes[i] < -input_ndim || axes[i] >= input_ndim) {
-          fail_shape_inference("axis must be in [-rank, rank-1]. input rank was ", input_ndim);
+      for (int64_t& axe : axes) {
+        if (axe < -input_ndim || axe >= input_ndim) {
+          fail_shape_inference("axis must be in [-rank, rank-1]. Input rank was ", input_ndim);
         }
-        if (axes[i] < 0)
-          axes[i] += input_ndim;
+        if (axe < 0)
+          axe += input_ndim;
       }
       for (int i = 0; i < input_ndim; ++i) {
         // axes empty means reduce all dim

onnx/defs/reduction/utils.h

@@ -27,7 +27,7 @@ std::function<void(OpSchema&)> ReduceOpGenerator(
     bool supports_8bit_datatypes = false,
     bool axes_input = false,
     const char* func_body = nullptr,
-    ContextDependentFunctionBodyBuilder function_builder = nullptr,
+    const ContextDependentFunctionBodyBuilder& function_builder = nullptr,
     bool supports_boolean_datatype = false);
 
 inline std::function<void(OpSchema&)> ReduceOpDynamicAxes(const char* name, const char* empty_value) {