onnx 1.13.1__cp37-cp37m-macosx_10_12_universal2.whl → 1.14.1__cp37-cp37m-macosx_10_12_universal2.whl

onnx/defs/rnn/defs.cc

@@ -182,61 +182,40 @@ via some custom implementation such as CuDNN.
 
 Notations:
 
-`X` - input tensor
-
-`i` - input gate
-
-`t` - time step (t-1 means previous time step)
-
-`Wi` - W parameter weight matrix for input gate
-
-`Ri` - R recurrence weight matrix for input gate
-
-`Wbi` - W parameter bias vector for input gate
-
-`Rbi` - R parameter bias vector for input gate
-
-`WBi` - W parameter weight matrix for backward input gate
-
-`RBi` - R recurrence weight matrix for backward input gate
-
-`WBbi` - WR bias vectors for backward input gate
-
-`RBbi` - RR bias vectors for backward input gate
-
-`H` - Hidden state
-
-`num_directions` - 2 if direction == bidirectional else 1
+* `X` - input tensor
+* `i` - input gate
+* `t` - time step (t-1 means previous time step)
+* `Wi` - W parameter weight matrix for input gate
+* `Ri` - R recurrence weight matrix for input gate
+* `Wbi` - W parameter bias vector for input gate
+* `Rbi` - R parameter bias vector for input gate
+* `WBi` - W parameter weight matrix for backward input gate
+* `RBi` - R recurrence weight matrix for backward input gate
+* `WBbi` - WR bias vectors for backward input gate
+* `RBbi` - RR bias vectors for backward input gate
+* `H` - Hidden state
+* `num_directions` - 2 if direction == bidirectional else 1
 
 Activation functions:
 
-  Relu(x)                - max(0, x)
-
-  Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
-
-  Sigmoid(x)             - 1/(1 + e^{-x})
-
-  (NOTE: Below are optional)
-
-  Affine(x)              - alpha*x + beta
-
-  LeakyRelu(x)           - x if x >= 0 else alpha * x
-
-  ThresholdedRelu(x)     - x if x >= alpha else 0
-
-  ScaledTanh(x)          - alpha*Tanh(beta*x)
-
-  HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+* Relu(x)                - max(0, x)
+* Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+* Sigmoid(x)             - 1/(1 + e^{-x})
 
-  Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+NOTE: Below are optional
 
-  Softsign(x)            - x/(1 + |x|)
-
-  Softplus(x)            - log(1 + e^x)
+* Affine(x)              - alpha*x + beta
+* LeakyRelu(x)           - x if x >= 0 else alpha * x
+* ThresholdedRelu(x)     - x if x >= alpha else 0
+* ScaledTanh(x)          - alpha*Tanh(beta*x)
+* HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+* Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+* Softsign(x)            - x/(1 + |x|)
+* Softplus(x)            - log(1 + e^x)
 
 Equations (Default: f=Tanh):
 
-  - Ht = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Wbi + Rbi)
+* Ht = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Wbi + Rbi)
 )DOC";
 
 ONNX_OPERATOR_SET_SCHEMA(
@@ -293,73 +272,47 @@ implementation such as CuDNN.
 
 Notations:
 
-`X` - input tensor
-
-`z` - update gate
-
-`r` - reset gate
-
-`h` - hidden gate
-
-`t` - time step (t-1 means previous time step)
-
-`W[zrh]` - W parameter weight matrix for update, reset, and hidden gates
-
-`R[zrh]` - R recurrence weight matrix for update, reset, and hidden gates
-
-`Wb[zrh]` - W bias vectors for update, reset, and hidden gates
-
-`Rb[zrh]` - R bias vectors for update, reset, and hidden gates
-
-`WB[zrh]` - W parameter weight matrix for backward update, reset, and hidden gates
-
-`RB[zrh]` - R recurrence weight matrix for backward update, reset, and hidden gates
-
-`WBb[zrh]` - W bias vectors for backward update, reset, and hidden gates
-
-`RBb[zrh]` - R bias vectors for backward update, reset, and hidden gates
-
-`H` - Hidden state
-
-`num_directions` - 2 if direction == bidirectional else 1
+* `X` - input tensor
+* `z` - update gate
+* `r` - reset gate
+* `h` - hidden gate
+* `t` - time step (t-1 means previous time step)
+* `W[zrh]` - W parameter weight matrix for update, reset, and hidden gates
+* `R[zrh]` - R recurrence weight matrix for update, reset, and hidden gates
+* `Wb[zrh]` - W bias vectors for update, reset, and hidden gates
+* `Rb[zrh]` - R bias vectors for update, reset, and hidden gates
+* `WB[zrh]` - W parameter weight matrix for backward update, reset, and hidden gates
+* `RB[zrh]` - R recurrence weight matrix for backward update, reset, and hidden gates
+* `WBb[zrh]` - W bias vectors for backward update, reset, and hidden gates
+* `RBb[zrh]` - R bias vectors for backward update, reset, and hidden gates
+* `H` - Hidden state
+* `num_directions` - 2 if direction == bidirectional else 1
 
 Activation functions:
 
-  Relu(x)                - max(0, x)
-
-  Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
-
-  Sigmoid(x)             - 1/(1 + e^{-x})
-
-  (NOTE: Below are optional)
-
-  Affine(x)              - alpha*x + beta
-
-  LeakyRelu(x)           - x if x >= 0 else alpha * x
+* Relu(x)                - max(0, x)
+* Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+* Sigmoid(x)             - 1/(1 + e^{-x})
 
-  ThresholdedRelu(x)     - x if x >= alpha else 0
+NOTE:
+  Below are optional
 
-  ScaledTanh(x)          - alpha*Tanh(beta*x)
-
-  HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
-
-  Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
-
-  Softsign(x)            - x/(1 + |x|)
-
-  Softplus(x)            - log(1 + e^x)
+* Affine(x)              - alpha * x + beta
+* LeakyRelu(x)           - x if x >= 0 else alpha * x
+* ThresholdedRelu(x)     - x if x >= alpha else 0
+* ScaledTanh(x)          - alpha * Tanh(beta * x)
+* HardSigmoid(x)         - min(max(alpha * x + beta, 0), 1)
+* Elu(x)                 - x if x >= 0 else alpha * (e^x - 1)
+* Softsign(x)            - x/(1 + |x|)
+* Softplus(x)            - log(1 + e^x)
 
 Equations (Default: f=Sigmoid, g=Tanh):
 
-  - zt = f(Xt*(Wz^T) + Ht-1*(Rz^T) + Wbz + Rbz)
-
-  - rt = f(Xt*(Wr^T) + Ht-1*(Rr^T) + Wbr + Rbr)
-
-  - ht = g(Xt*(Wh^T) + (rt (.) Ht-1)*(Rh^T) + Rbh + Wbh) # default, when linear_before_reset = 0
-
-  - ht = g(Xt*(Wh^T) + (rt (.) (Ht-1*(Rh^T) + Rbh)) + Wbh) # when linear_before_reset != 0
-
-  - Ht = (1 - zt) (.) ht + zt (.) Ht-1
+* zt = f(Xt*(Wz^T) + Ht-1*(Rz^T) + Wbz + Rbz)
+* rt = f(Xt*(Wr^T) + Ht-1*(Rr^T) + Wbr + Rbr)
+* ht = g(Xt*(Wh^T) + (rt (.) Ht-1)*(Rh^T) + Rbh + Wbh) # default, when linear_before_reset = 0
+* ht = g(Xt*(Wh^T) + (rt (.) (Ht-1*(Rh^T) + Rbh)) + Wbh) # when linear_before_reset != 0
+* Ht = (1 - zt) (.) ht + zt (.) Ht-1
 )DOC";
 
 ONNX_OPERATOR_SET_SCHEMA(
@@ -424,81 +377,50 @@ custom implementation such as CuDNN.
 
 Notations:
 
-`X` - input tensor
-
-`i` - input gate
-
-`o` - output gate
-
-`f` - forget gate
-
-`c` - cell gate
-
-`t` - time step (t-1 means previous time step)
-
-`W[iofc]` - W parameter weight matrix for input, output, forget, and cell gates
-
-`R[iofc]` - R recurrence weight matrix for input, output, forget, and cell gates
-
-`Wb[iofc]` - W bias vectors for input, output, forget, and cell gates
-
-`Rb[iofc]` - R bias vectors for input, output, forget, and cell gates
-
-`P[iof]`  - P peephole weight vector for input, output, and forget gates
-
-`WB[iofc]` - W parameter weight matrix for backward input, output, forget, and cell gates
-
-`RB[iofc]` - R recurrence weight matrix for backward input, output, forget, and cell gates
-
-`WBb[iofc]` - W bias vectors for backward input, output, forget, and cell gates
-
-`RBb[iofc]` - R bias vectors for backward input, output, forget, and cell gates
-
-`PB[iof]`  - P peephole weight vector for backward input, output, and forget gates
-
-`H` - Hidden state
-
-`num_directions` - 2 if direction == bidirectional else 1
+* `X` - input tensor
+* `i` - input gate
+* `o` - output gate
+* `f` - forget gate
+* `c` - cell gate
+* `t` - time step (t-1 means previous time step)
+* `W[iofc]` - W parameter weight matrix for input, output, forget, and cell gates
+* `R[iofc]` - R recurrence weight matrix for input, output, forget, and cell gates
+* `Wb[iofc]` - W bias vectors for input, output, forget, and cell gates
+* `Rb[iofc]` - R bias vectors for input, output, forget, and cell gates
+* `P[iof]`  - P peephole weight vector for input, output, and forget gates
+* `WB[iofc]` - W parameter weight matrix for backward input, output, forget, and cell gates
+* `RB[iofc]` - R recurrence weight matrix for backward input, output, forget, and cell gates
+* `WBb[iofc]` - W bias vectors for backward input, output, forget, and cell gates
+* `RBb[iofc]` - R bias vectors for backward input, output, forget, and cell gates
+* `PB[iof]`  - P peephole weight vector for backward input, output, and forget gates
+* `H` - Hidden state
+* `num_directions` - 2 if direction == bidirectional else 1
 
 Activation functions:
 
-  Relu(x)                - max(0, x)
-
-  Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
-
-  Sigmoid(x)             - 1/(1 + e^{-x})
-
-  (NOTE: Below are optional)
-
-  Affine(x)              - alpha*x + beta
-
-  LeakyRelu(x)           - x if x >= 0 else alpha * x
+* Relu(x)                - max(0, x)
+* Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+* Sigmoid(x)             - 1/(1 + e^{-x})
 
-  ThresholdedRelu(x)     - x if x >= alpha else 0
+NOTE: Below are optional
 
-  ScaledTanh(x)          - alpha*Tanh(beta*x)
-
-  HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
-
-  Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
-
-  Softsign(x)            - x/(1 + |x|)
-
-  Softplus(x)            - log(1 + e^x)
+* Affine(x)              - alpha*x + beta
+* LeakyRelu(x)           - x if x >= 0 else alpha * x
+* ThresholdedRelu(x)     - x if x >= alpha else 0
+* ScaledTanh(x)          - alpha*Tanh(beta*x)
+* HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+* Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+* Softsign(x)            - x/(1 + |x|)
+* Softplus(x)            - log(1 + e^x)
 
 Equations (Default: f=Sigmoid, g=Tanh, h=Tanh):
 
-  - it = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Pi (.) Ct-1 + Wbi + Rbi)
-
-  - ft = f(Xt*(Wf^T) + Ht-1*(Rf^T) + Pf (.) Ct-1 + Wbf + Rbf)
-
-  - ct = g(Xt*(Wc^T) + Ht-1*(Rc^T) + Wbc + Rbc)
-
-  - Ct = ft (.) Ct-1 + it (.) ct
-
-  - ot = f(Xt*(Wo^T) + Ht-1*(Ro^T) + Po (.) Ct + Wbo + Rbo)
-
-  - Ht = ot (.) h(Ct)
+* it = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Pi (.) Ct-1 + Wbi + Rbi)
+* ft = f(Xt*(Wf^T) + Ht-1*(Rf^T) + Pf (.) Ct-1 + Wbf + Rbf)
+* ct = g(Xt*(Wc^T) + Ht-1*(Rc^T) + Wbc + Rbc)
+* Ct = ft (.) Ct-1 + it (.) ct
+* ot = f(Xt*(Wo^T) + Ht-1*(Ro^T) + Po (.) Ct + Wbo + Rbo)
+* Ht = ot (.) h(Ct)
 )DOC";
 
 ONNX_OPERATOR_SET_SCHEMA(

onnx/defs/schema.cc

@@ -553,6 +553,14 @@ OpSchema& OpSchema::AllowUncheckedAttributes() {
   return *this;
 }
 
+OpSchema& OpSchema::Input(int n, FormalParameter formal_parameter) {
+  if (inputs_.size() <= static_cast<size_t>(n)) {
+    inputs_.resize(n + 1);
+  }
+  inputs_[n] = std::move(formal_parameter);
+  return *this;
+}
+
 OpSchema& OpSchema::Input(
     int n,
     std::string name,
@@ -562,22 +570,20 @@ OpSchema& OpSchema::Input(
     bool is_homogeneous,
     int min_arity,
     DifferentiationCategory differentiation_category) {
-  if (int(inputs_.size()) <= n) {
-    inputs_.resize(n + 1);
-  }
-  inputs_[n] = FormalParameter(
-      std::move(name),
+  return Input(
+      n,
+      FormalParameter(
+          std::move(name),
 #ifndef __ONNX_NO_DOC_STRINGS
-      description,
+          description,
 #else
-      std::string(),
+          std::string(),
 #endif
-      std::move(type_str),
-      param_option,
-      is_homogeneous,
-      min_arity,
-      differentiation_category);
-  return *this;
+          std::move(type_str),
+          param_option,
+          is_homogeneous,
+          min_arity,
+          differentiation_category));
 }
 
 OpSchema& OpSchema::Input(
@@ -604,6 +610,14 @@ OpSchema& OpSchema::Input(
       differentiation_category);
 }
 
+OpSchema& OpSchema::Output(int n, FormalParameter formal_parameter) {
+  if (outputs_.size() <= static_cast<size_t>(n)) {
+    outputs_.resize(n + 1);
+  }
+  outputs_[n] = std::move(formal_parameter);
+  return *this;
+}
+
 OpSchema& OpSchema::Output(
     int n,
     std::string name,
@@ -613,22 +627,20 @@ OpSchema& OpSchema::Output(
     bool is_homogeneous,
     int min_arity,
     DifferentiationCategory differentiation_category) {
-  if (int(outputs_.size()) <= n) {
-    outputs_.resize(n + 1);
-  }
-  outputs_[n] = FormalParameter(
-      std::move(name),
+  return Output(
+      n,
+      FormalParameter(
+          std::move(name),
 #ifndef __ONNX_NO_DOC_STRINGS
-      description,
+          description,
 #else
-      std::string(),
+          std::string(),
 #endif
-      std::move(type_str),
-      param_option,
-      is_homogeneous,
-      min_arity,
-      differentiation_category);
-  return *this;
+          std::move(type_str),
+          param_option,
+          is_homogeneous,
+          min_arity,
+          differentiation_category));
 }
 
 OpSchema& OpSchema::Output(
@@ -824,11 +836,15 @@ OpSchema& OpSchema::FunctionBody(
 }
 
 const FunctionProto* OpSchema::GetFunction(int requested_opset_version, bool validate) const {
-  if (requested_opset_version == OpSchema::kUninitializedSinceVersion)
-    requested_opset_version = since_version_;
+  if (opset_version_to_function_body_.empty())
+    return nullptr;
+  // Return latest FunctionProto when opset version request is not set
+  if (requested_opset_version == OpSchema::kUninitializedSinceVersion) {
+    return opset_version_to_function_body_.rbegin()->second.get();
+  }
   std::map<int, std::shared_ptr<FunctionProto>>::const_iterator it =
       opset_version_to_function_body_.upper_bound(requested_opset_version);
-  if (!opset_version_to_function_body_.empty() && it != opset_version_to_function_body_.begin()) {
+  if (it != opset_version_to_function_body_.begin()) {
     --it;
     int function_since_version = it->first;
     const FunctionProto* function = it->second.get();

onnx/defs/schema.h

@@ -10,6 +10,7 @@
 #include <initializer_list>
 #include <iostream>
 #include <limits>
+#include <map>
 #include <memory>
 #include <ostream>
 #include <set>
@@ -520,6 +521,8 @@ class OpSchema final {
   // (represented as "") in the graph even though the later inputs have values.
   // It's useful for complex situation when there are several independent
   // optional inputs.
+  OpSchema& Input(int n, FormalParameter formal_parameter);
+
   OpSchema& Input(
       int n,
       std::string name,
@@ -541,6 +544,8 @@ class OpSchema final {
       int min_arity = 1,
       DifferentiationCategory differentiation_category = Unknown);
 
+  OpSchema& Output(int n, FormalParameter formal_parameter);
+
   OpSchema& Output(
       int n,
       std::string name,
@@ -571,8 +576,25 @@ class OpSchema final {
   // Convenience members for types
 
   // All high-precision numeric types.
-  static const std::vector<std::string>& numeric_types_for_math_reduction_with_bfloat() {
-    static const std::vector<std::string> numeric_types_for_math_reduction_with_bfloat = {
+  static const std::vector<std::string>& numeric_types_for_math_reduction_ir9() {
+    static const std::vector<std::string> numeric_types_for_math_reduction_ir9 = {
+        "tensor(uint32)",
+        "tensor(uint64)",
+        "tensor(int32)",
+        "tensor(int64)",
+        "tensor(float16)",
+        "tensor(float)",
+        "tensor(double)",
+        "tensor(bfloat16)",
+        "tensor(float8e4m3fn)",
+        "tensor(float8e4m3fnuz)",
+        "tensor(float8e5m2)",
+        "tensor(float8e5m2fnuz)"};
+    return numeric_types_for_math_reduction_ir9;
+  }
+
+  static const std::vector<std::string>& numeric_types_for_math_reduction_ir4() {
+    static const std::vector<std::string> numeric_types_for_math_reduction_ir4 = {
         "tensor(uint32)",
         "tensor(uint64)",
         "tensor(int32)",
@@ -581,7 +603,12 @@ class OpSchema final {
         "tensor(float)",
         "tensor(double)",
         "tensor(bfloat16)"};
-    return numeric_types_for_math_reduction_with_bfloat;
+    return numeric_types_for_math_reduction_ir4;
+  }
+
+  // Deprecated function, use numeric_types_for_math_reduction_ir4 instead. It will be removed in onnx==1.15.0.
+  static const std::vector<std::string>& numeric_types_for_math_reduction_with_bfloat() {
+    return numeric_types_for_math_reduction_ir4();
   }
 
   static const std::vector<std::string>& numeric_types_for_math_reduction() {
@@ -596,8 +623,29 @@ class OpSchema final {
     return numeric_types_for_math_reduction;
   }
 
-  static const std::vector<std::string>& all_numeric_types_with_bfloat() {
-    static const std::vector<std::string> all_numeric_types_with_bfloat = {
+  static const std::vector<std::string>& all_numeric_types_ir9() {
+    static const std::vector<std::string> all_numeric_types_ir9 = {
+        "tensor(uint8)",
+        "tensor(uint16)",
+        "tensor(uint32)",
+        "tensor(uint64)",
+        "tensor(int8)",
+        "tensor(int16)",
+        "tensor(int32)",
+        "tensor(int64)",
+        "tensor(float16)",
+        "tensor(float)",
+        "tensor(double)",
+        "tensor(bfloat16)",
+        "tensor(float8e4m3fn)",
+        "tensor(float8e4m3fnuz)",
+        "tensor(float8e5m2)",
+        "tensor(float8e5m2fnuz)"};
+    return all_numeric_types_ir9;
+  }
+
+  static const std::vector<std::string>& all_numeric_types_ir4() {
+    static const std::vector<std::string> all_numeric_types_ir4 = {
         "tensor(uint8)",
         "tensor(uint16)",
         "tensor(uint32)",
@@ -610,7 +658,12 @@ class OpSchema final {
         "tensor(float)",
         "tensor(double)",
         "tensor(bfloat16)"};
-    return all_numeric_types_with_bfloat;
+    return all_numeric_types_ir4;
+  }
+
+  // Deprecated function, use all_numeric_types_ir4 instead. It will be removed in onnx==1.15.0.
+  static const std::vector<std::string>& all_numeric_types_with_bfloat() {
+    return all_numeric_types_ir4();
   }
 
   static const std::vector<std::string>& all_numeric_types() {
@@ -665,8 +718,8 @@ class OpSchema final {
     return all_tensor_types;
   }
 
-  static const std::vector<std::string>& all_tensor_types_with_bfloat() {
-    static const std::vector<std::string> all_tensor_types_with_bfloat = {
+  static const std::vector<std::string>& all_tensor_types_ir4() {
+    static const std::vector<std::string> all_tensor_types_ir4 = {
         "tensor(uint8)",
         "tensor(uint16)",
         "tensor(uint32)",
@@ -683,7 +736,22 @@ class OpSchema final {
         "tensor(bool)",
         "tensor(complex64)",
         "tensor(complex128)"};
-    return all_tensor_types_with_bfloat;
+    return all_tensor_types_ir4;
+  }
+
+  // Deprecated function, use all_tensor_types_ir4 instead. It will be removed in onnx==1.15.0.
+  static const std::vector<std::string>& all_tensor_types_with_bfloat() {
+    return all_tensor_types_ir4();
+  }
+
+  static const std::vector<std::string>& all_tensor_types_ir9() {
+    static const std::vector<std::string> all_tensor_types_ir9 = {
+        "tensor(uint8)",        "tensor(uint16)",         "tensor(uint32)",     "tensor(uint64)",
+        "tensor(int8)",         "tensor(int16)",          "tensor(int32)",      "tensor(int64)",
+        "tensor(bfloat16)",     "tensor(float16)",        "tensor(float)",      "tensor(double)",
+        "tensor(string)",       "tensor(bool)",           "tensor(complex64)",  "tensor(complex128)",
+        "tensor(float8e4m3fn)", "tensor(float8e4m3fnuz)", "tensor(float8e5m2)", "tensor(float8e5m2fnuz)"};
+    return all_tensor_types_ir9;
   }
 
   static const std::vector<std::string>& all_tensor_sequence_types() {
@@ -706,8 +774,8 @@ class OpSchema final {
     return all_tensor_sequence_types;
   }
 
-  static const std::vector<std::string>& all_tensor_sequence_types_with_bfloat() {
-    static const std::vector<std::string> all_tensor_sequence_types_with_bfloat = {
+  static const std::vector<std::string>& all_tensor_sequence_types_ir4() {
+    static const std::vector<std::string> all_tensor_sequence_types_ir4 = {
         "seq(tensor(uint8))",
         "seq(tensor(uint16))",
         "seq(tensor(uint32))",
@@ -724,7 +792,24 @@ class OpSchema final {
         "seq(tensor(bool))",
         "seq(tensor(complex64))",
         "seq(tensor(complex128))"};
-    return all_tensor_sequence_types_with_bfloat;
+    return all_tensor_sequence_types_ir4;
+  }
+
+  // Deprecated function, use all_tensor_sequence_types_ir4 instead. It will be removed in onnx==1.15.0.
+  static const std::vector<std::string>& all_tensor_sequence_types_with_bfloat() {
+    return all_tensor_sequence_types_ir4();
+  }
+
+  static const std::vector<std::string>& all_tensor_sequence_types_ir9() {
+    static const std::vector<std::string> all_tensor_sequence_types_ir4 = {
+        "seq(tensor(uint8))",      "seq(tensor(uint16))",        "seq(tensor(uint32))",
+        "seq(tensor(uint64))",     "seq(tensor(int8))",          "seq(tensor(int16))",
+        "seq(tensor(int32))",      "seq(tensor(int64))",         "seq(tensor(bfloat16))",
+        "seq(tensor(float16))",    "seq(tensor(float))",         "seq(tensor(double))",
+        "seq(tensor(string))",     "seq(tensor(bool))",          "seq(tensor(complex64))",
+        "seq(tensor(complex128))", "seq(tensor(float8e4m3fn))",  "seq(tensor(float8e4m3fnuz))",
+        "seq(tensor(float8e5m2))", "seq(tensor(float8e5m2fnuz))"};
+    return all_tensor_sequence_types_ir4;
   }
 
   static const std::vector<std::string>& all_optional_types() {
@@ -742,7 +827,7 @@ class OpSchema final {
     return all_optional_types;
   }
 
-  static const std::vector<std::string>& all_optional_types_with_bfloat() {
+  static const std::vector<std::string>& all_optional_types_ir4() {
     static const std::vector<std::string> all_optional_types = {
         "optional(seq(tensor(uint8)))",      "optional(seq(tensor(uint16)))", "optional(seq(tensor(uint32)))",
         "optional(seq(tensor(uint64)))",     "optional(seq(tensor(int8)))",   "optional(seq(tensor(int16)))",
@@ -758,6 +843,27 @@ class OpSchema final {
     return all_optional_types;
   }
 
+  // Deprecated function, use all_optional_types_ir4 instead. It will be removed in onnx==1.15.0.
+  static const std::vector<std::string>& all_optional_types_with_bfloat() {
+    return all_optional_types_ir4();
+  }
+  static const std::vector<std::string>& all_optional_types_ir9() {
+    static const std::vector<std::string> all_optional_types = {
+        "optional(seq(tensor(uint8)))",      "optional(seq(tensor(uint16)))", "optional(seq(tensor(uint32)))",
+        "optional(seq(tensor(uint64)))",     "optional(seq(tensor(int8)))",   "optional(seq(tensor(int16)))",
+        "optional(seq(tensor(int32)))",      "optional(seq(tensor(int64)))",  "optional(seq(tensor(bfloat16)))",
+        "optional(seq(tensor(float16)))",    "optional(seq(tensor(float)))",  "optional(seq(tensor(double)))",
+        "optional(seq(tensor(string)))",     "optional(seq(tensor(bool)))",   "optional(seq(tensor(complex64)))",
+        "optional(seq(tensor(complex128)))", "optional(tensor(uint8))",       "optional(tensor(uint16))",
+        "optional(tensor(uint32))",          "optional(tensor(uint64))",      "optional(tensor(int8))",
+        "optional(tensor(int16))",           "optional(tensor(int32))",       "optional(tensor(int64))",
+        "optional(tensor(bfloat16))",        "optional(tensor(float16))",     "optional(tensor(float))",
+        "optional(tensor(double))",          "optional(tensor(string))",      "optional(tensor(bool))",
+        "optional(tensor(complex64))",       "optional(tensor(complex128))",  "optional(tensor(float8e4m3fn))",
+        "optional(tensor(float8e4m3fnuz))",  "optional(tensor(float8e5m2))",  "optional(tensor(float8e5m2fnuz))"};
+    return all_optional_types;
+  }
+
   // Calls the passed function with `this` as an argument. Useful for
   // adding docs for temlated/macro ops.
   OpSchema& FillUsing(const std::function<void(OpSchema&)>& populator);
@@ -786,6 +892,10 @@ class OpSchema final {
     return type_constraint_params_;
   }
 
+  const TypeConstraintMap& typeConstraintMap() const {
+    return type_constraints_;
+  }
+
   const std::string& Name() const {
     return name_;
   }
@@ -966,7 +1076,7 @@ class OpSchemaRegistry final : public ISchemaRegistry {
       // Increase the highest version when you make BC-breaking changes to the
       // operator schema on specific domain. Update the lowest version when it's
       // determined to remove too old version history.
-      map_[ONNX_DOMAIN] = std::make_pair(1, 18);
+      map_[ONNX_DOMAIN] = std::make_pair(1, 19);
       map_[AI_ONNX_ML_DOMAIN] = std::make_pair(1, 3);
       map_[AI_ONNX_TRAINING_DOMAIN] = std::make_pair(1, 1);
       // ONNX's preview domain contains operators subject to change, so
@@ -976,7 +1086,7 @@ class OpSchemaRegistry final : public ISchemaRegistry {
       // Version corresponding last release of ONNX. Update this to match with
       // the max version above in a *release* version of ONNX. But in other
       // versions, the max version may be ahead of the last-release-version.
-      last_release_version_map_[ONNX_DOMAIN] = 18;
+      last_release_version_map_[ONNX_DOMAIN] = 19;
       last_release_version_map_[AI_ONNX_ML_DOMAIN] = 3;
       last_release_version_map_[AI_ONNX_TRAINING_DOMAIN] = 1;
       last_release_version_map_[AI_ONNX_PREVIEW_TRAINING_DOMAIN] = 1;