onnx 1.17.0__cp39-cp39-macosx_12_0_universal2.whl → 1.18.0__cp39-cp39-macosx_12_0_universal2.whl

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.

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) {

onnx/defs/rnn/defs.cc

@@ -5,7 +5,7 @@
 #include "onnx/defs/schema.h"
 
 namespace ONNX_NAMESPACE {
-void RNNShapeInference(InferenceContext& ctx) {
+static void RNNShapeInference(InferenceContext& ctx) {
   TensorShapeProto::Dimension num_directions, seq_length, batch_size, hidden_size;
 
   auto direction = getAttribute(ctx, "direction", "forward");
@@ -72,7 +72,7 @@ void RNNShapeInference(InferenceContext& ctx) {
   }
 }
 
-std::function<void(OpSchema&)> RNNDocGenerator(const char* /*name*/) {
+static std::function<void(OpSchema&)> RNNDocGenerator(const char* /*name*/) {
   return [=](OpSchema& schema) {
     schema.Attr(
         "direction",

onnx/defs/rnn/old.cc

@@ -6,7 +6,7 @@
 
 namespace ONNX_NAMESPACE {
 
-void RNNShapeInference_opset14(InferenceContext& ctx) {
+static void RNNShapeInference_opset14(InferenceContext& ctx) {
   TensorShapeProto::Dimension num_directions, seq_length, batch_size, hidden_size;
 
   auto direction = getAttribute(ctx, "direction", "forward");
@@ -72,7 +72,7 @@ void RNNShapeInference_opset14(InferenceContext& ctx) {
     }
   }
 }
-std::function<void(OpSchema&)> RNNDocGenerator_opset14(const char* /*name*/) {
+static std::function<void(OpSchema&)> RNNDocGenerator_opset14(const char* /*name*/) {
   return [=](OpSchema& schema) {
     schema.Attr(
         "direction",
@@ -520,7 +520,7 @@ ONNX_OPERATOR_SET_SCHEMA(
             OpSchema::Differentiable)
         .FillUsing(RNNDocGenerator_opset14("RNN")));
 
-std::function<void(OpSchema&)> RNNDocGeneratorOld(const char* /*name*/) {
+static std::function<void(OpSchema&)> RNNDocGeneratorOld(const char* /*name*/) {
   return [=](OpSchema& schema) {
     schema.Attr(
         "direction",
@@ -713,7 +713,7 @@ ONNX_OPERATOR_SET_SCHEMA(
 
 // Versions 1 to 6 of RNN/LSTM and versions 3 to 6 of GRU:
 
-void RNNShapeInference1(InferenceContext& ctx) {
+static void RNNShapeInference1(InferenceContext& ctx) {
   TensorShapeProto::Dimension num_directions, seq_length, batch_size, hidden_size;
 
   auto direction = getAttribute(ctx, "direction", "forward");
@@ -764,7 +764,7 @@ void RNNShapeInference1(InferenceContext& ctx) {
   }
 }
 
-std::function<void(OpSchema&)> RNNDocGenerator1(const char* /*name*/) {
+static std::function<void(OpSchema&)> RNNDocGenerator1(const char* /*name*/) {
   return [=](OpSchema& schema) {
     schema.Attr(
         "direction",
@@ -1219,7 +1219,7 @@ ONNX_OPERATOR_SET_SCHEMA(
 // Versions 7 to 13 of RNN/LSTM/GRU
 
 namespace ONNX_NAMESPACE {
-void RNNShapeInference2(InferenceContext& ctx) {
+static void RNNShapeInference2(InferenceContext& ctx) {
   TensorShapeProto::Dimension num_directions, seq_length, batch_size, hidden_size;
 
   auto direction = getAttribute(ctx, "direction", "forward");
@@ -1263,7 +1263,7 @@ void RNNShapeInference2(InferenceContext& ctx) {
   }
 }
 
-std::function<void(OpSchema&)> RNNDocGenerator2(const char* /*name*/) {
+static std::function<void(OpSchema&)> RNNDocGenerator2(const char* /*name*/) {
   return [=](OpSchema& schema) {
     schema.Attr(
         "direction",