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

onnx/defs/schema.cc

@@ -247,7 +247,7 @@ void OpSchema::Verify(const NodeProto& node) const {
     };
 
     const auto& search = attributes_.find(name);
-    AttributeProto::AttributeType expected_type;
+    AttributeProto::AttributeType expected_type{};
     if (search != attributes_.end()) {
       expected_type = search->second.type;
     } else if (allows_unchecked_attributes_ || isInternalSymbol(name)) {
@@ -392,17 +392,14 @@ OpSchema& OpSchema::SinceVersion(OperatorSetVersion v) {
   // however, if a runtime needs to inline LayerNormalization, the inlined model has a ReduceMean op.
   // ReduceMean in opset 18 is different from opset 17.
   // This requires us to define more than one function body
-  std::map<int, ContextDependentFunctionBodyBuilder>::const_iterator it =
-      opset_version_to_function_builder_.find(OpSchema::kUninitializedSinceVersion);
-
-  if (it != opset_version_to_function_builder_.cend()) {
+  auto it = opset_version_to_function_builder_.find(OpSchema::kUninitializedSinceVersion);
+  if (it != opset_version_to_function_builder_.end()) {
     opset_version_to_function_builder_[since_version_] = it->second;
     opset_version_to_function_builder_.erase(it);
   }
 
-  std::map<int, std::shared_ptr<FunctionProto>>::const_iterator it_function_body =
-      opset_version_to_function_body_.find(OpSchema::kUninitializedSinceVersion);
-  if (it_function_body != opset_version_to_function_body_.cend()) {
+  auto it_function_body = opset_version_to_function_body_.find(OpSchema::kUninitializedSinceVersion);
+  if (it_function_body != opset_version_to_function_body_.end()) {
     opset_version_to_function_body_[since_version_] = it_function_body->second;
     UpdateFunctionProtoOpsetImportVersion(*opset_version_to_function_body_[since_version_], since_version_);
     opset_version_to_function_body_.erase(it_function_body);
@@ -416,14 +413,14 @@ OpSchema& OpSchema::Deprecate() {
   return *this;
 }
 
-OpSchema& OpSchema::NumInputs(std::set<int> allowed_input_nums) {
+OpSchema& OpSchema::NumInputs(std::unordered_set<int> allowed_input_nums) {
   num_inputs_allowed_ = [allowed_input_nums = std::move(allowed_input_nums)](int n) -> bool {
     return allowed_input_nums.count(n);
   };
   return *this;
 }
 
-OpSchema& OpSchema::NumOutputs(std::set<int> allowed_output_nums) {
+OpSchema& OpSchema::NumOutputs(std::unordered_set<int> allowed_output_nums) {
   num_outputs_allowed_ = [allowed_output_nums = std::move(allowed_output_nums)](int n) -> bool {
     return allowed_output_nums.count(n) > 0;
   };
@@ -477,7 +474,7 @@ OpSchema& OpSchema::SetDomain(const char* domain) {
 
 OpSchema& OpSchema::Attr(Attribute attr) {
   auto name = attr.name; // copy name so we can move attr in the next line
-  attributes_.insert(std::make_pair(std::move(name), std::move(attr)));
+  attributes_.emplace(std::move(name), std::move(attr));
   return *this;
 }
 
@@ -702,9 +699,8 @@ OpSchema::TypeConstraint(std::string type_str, std::vector<std::string> constrai
   for (const auto& t : constraints) {
     d.insert(Utils::DataTypeUtils::ToType(t));
   }
-  type_constraints_.insert(std::make_pair(type_str, std::make_pair(d, description)));
-  type_constraint_params_.push_back(
-      TypeConstraintParam(std::move(type_str), std::move(constraints), std::move(description)));
+  type_constraints_.emplace(type_str, std::make_pair(d, description));
+  type_constraint_params_.emplace_back(std::move(type_str), std::move(constraints), std::move(description));
   return *this;
 }
 
@@ -714,8 +710,8 @@ OpSchema& OpSchema::TypeConstraint(
     const char* description) {
   std::vector<std::string> constraints_vector;
   constraints_vector.reserve(constraints.size());
-  for (auto iter = constraints.begin(); iter != constraints.end(); ++iter) {
-    constraints_vector.push_back(*iter);
+  for (auto constraint : constraints) {
+    constraints_vector.emplace_back(constraint);
   }
 
   return TypeConstraint(std::string(type_str), constraints_vector, std::string(description));
@@ -755,8 +751,7 @@ bool OpSchema::BuildContextDependentFunction(
   if (requested_opset_version == OpSchema::kUninitializedSinceVersion)
     requested_opset_version = since_version_;
 
-  std::map<int, ContextDependentFunctionBodyBuilder>::const_iterator it =
-      opset_version_to_function_builder_.upper_bound(requested_opset_version);
+  auto it = opset_version_to_function_builder_.upper_bound(requested_opset_version);
   if (opset_version_to_function_builder_.empty() || it == opset_version_to_function_builder_.begin()) {
     ONNX_THROW_EX(std::out_of_range(
         std::string("Cannot find a function builder that satisfies the requested opset version: op_type = ") +
@@ -803,7 +798,7 @@ OpSchema& OpSchema::FunctionBody(const char* func_body, int opset_version) {
   if (opset_version == OpSchema::kUninitializedSinceVersion && since_version_ != OpSchema::kUninitializedSinceVersion) {
     opset_version = since_version_;
   }
-  std::shared_ptr<FunctionProto> function_proto(new FunctionProto());
+  auto function_proto = std::make_shared<FunctionProto>();
   OnnxParser parser(func_body);
   auto status = parser.Parse(*function_proto->mutable_node());
   if (!status.IsOK())
@@ -815,7 +810,7 @@ OpSchema& OpSchema::FunctionBody(const char* func_body, int opset_version) {
   // we may need to update its version with the specified opset_version
   UpdateFunctionProtoOpsetImportVersion(*function_proto, opset_version);
 
-  opset_version_to_function_body_.insert(std::make_pair(opset_version, function_proto));
+  opset_version_to_function_body_.emplace(opset_version, function_proto);
   return *this;
 }
 
@@ -823,7 +818,7 @@ OpSchema& OpSchema::FunctionBody(const std::vector<NodeProto>& func_nodes, int o
   if (opset_version == OpSchema::kUninitializedSinceVersion && since_version_ != OpSchema::kUninitializedSinceVersion) {
     opset_version = since_version_;
   }
-  std::shared_ptr<FunctionProto> function_proto(new FunctionProto());
+  auto function_proto = std::make_shared<FunctionProto>();
   for (const auto& node : func_nodes) {
     auto new_node = function_proto->add_node();
     new_node->CopyFrom(node);
@@ -832,7 +827,7 @@ OpSchema& OpSchema::FunctionBody(const std::vector<NodeProto>& func_nodes, int o
   // opset import may have been set
   // we may need to update its version with the specified opset_version
   UpdateFunctionProtoOpsetImportVersion(*function_proto, opset_version);
-  opset_version_to_function_body_.insert(std::make_pair(opset_version, function_proto));
+  opset_version_to_function_body_.emplace(opset_version, std::move(function_proto));
   return *this;
 }
 
@@ -844,7 +839,7 @@ OpSchema& OpSchema::FunctionBody(
     opset_version = since_version_;
   }
 
-  std::shared_ptr<FunctionProto> function_proto(new FunctionProto());
+  auto function_proto = std::make_shared<FunctionProto>();
   for (auto& relied_opset : relied_opsets) {
     *(function_proto->mutable_opset_import()->Add()) = relied_opset;
   }
@@ -856,7 +851,7 @@ OpSchema& OpSchema::FunctionBody(
   // opset import may have been set
   // we may need to update its version with the specified opset_version
   UpdateFunctionProtoOpsetImportVersion(*function_proto, opset_version);
-  opset_version_to_function_body_.insert(std::make_pair(opset_version, function_proto));
+  opset_version_to_function_body_.emplace(opset_version, std::move(function_proto));
   return *this;
 }
 
@@ -867,8 +862,7 @@ const FunctionProto* OpSchema::GetFunction(int requested_opset_version, bool val
   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);
+  auto it = opset_version_to_function_body_.upper_bound(requested_opset_version);
   if (it != opset_version_to_function_body_.begin()) {
     --it;
     int function_since_version = it->first;
@@ -890,13 +884,13 @@ bool OpSchema::ValidateReferencedOpsInFuncton(
     const FunctionProto* function,
     int requested_opset_version,
     int function_since_version,
-    std::set<std::string>* updated_ops) const {
+    std::unordered_set<std::string>* updated_ops) const {
   bool all_ops_are_invalid = true;
   if (requested_opset_version == function_since_version) {
     return all_ops_are_invalid;
   }
   for (auto& node : function->node()) {
-    if (node.domain() == "" || node.domain() == "ai.onnx") {
+    if (node.domain().empty() || node.domain() == "ai.onnx") {
       const OpSchema* op1 =
           OpSchemaRegistry::Instance()->GetSchema(node.op_type(), requested_opset_version, node.domain());
       const OpSchema* op2 =
@@ -940,13 +934,473 @@ void OpSchema::BuildFunction(FunctionProto& function_body) const {
   // This is simply for convienince. If any of the function body ops do not belong to same
   // domain as function itself, then the function author needs to explicitly add all the relevant
   // opset imports.
-  if (function_body.opset_import().size() == 0) {
+  if (function_body.opset_import().empty()) {
     auto* schema_opset = function_body.mutable_opset_import()->Add();
     schema_opset->set_domain(domain_);
     schema_opset->set_version(since_version_);
   }
 }
 
+const std::vector<std::string>& OpSchema::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;
+}
+
+const std::vector<std::string>& OpSchema::numeric_types_for_math_reduction_ir4() {
+  static const std::vector<std::string> numeric_types_for_math_reduction_ir4 = {
+      "tensor(uint32)",
+      "tensor(uint64)",
+      "tensor(int32)",
+      "tensor(int64)",
+      "tensor(float16)",
+      "tensor(float)",
+      "tensor(double)",
+      "tensor(bfloat16)"};
+  return numeric_types_for_math_reduction_ir4;
+}
+
+const std::vector<std::string>& OpSchema::numeric_types_for_math_reduction() {
+  static const std::vector<std::string> numeric_types_for_math_reduction = {
+      "tensor(uint32)",
+      "tensor(uint64)",
+      "tensor(int32)",
+      "tensor(int64)",
+      "tensor(float16)",
+      "tensor(float)",
+      "tensor(double)"};
+  return numeric_types_for_math_reduction;
+}
+
+const std::vector<std::string>& OpSchema::all_numeric_types_ir11() {
+  static const std::vector<std::string> all_numeric_types_ir11 = {
+      "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)",
+      "tensor(uint4)",
+      "tensor(int4)",
+      "tensor(float4e2m1)"};
+  return all_numeric_types_ir11;
+}
+const std::vector<std::string>& OpSchema::all_numeric_types_ir10() {
+  static const std::vector<std::string> all_numeric_types_ir10 = {
+      "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)",
+      "tensor(uint4)",
+      "tensor(int4)"};
+  return all_numeric_types_ir10;
+}
+
+const std::vector<std::string>& OpSchema::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;
+}
+
+const std::vector<std::string>& OpSchema::all_numeric_types_ir4() {
+  static const std::vector<std::string> all_numeric_types_ir4 = {
+      "tensor(uint8)",
+      "tensor(uint16)",
+      "tensor(uint32)",
+      "tensor(uint64)",
+      "tensor(int8)",
+      "tensor(int16)",
+      "tensor(int32)",
+      "tensor(int64)",
+      "tensor(float16)",
+      "tensor(float)",
+      "tensor(double)",
+      "tensor(bfloat16)"};
+  return all_numeric_types_ir4;
+}
+
+const std::vector<std::string>& OpSchema::all_numeric_types() {
+  static const std::vector<std::string> all_numeric_types = {
+      "tensor(uint8)",
+      "tensor(uint16)",
+      "tensor(uint32)",
+      "tensor(uint64)",
+      "tensor(int8)",
+      "tensor(int16)",
+      "tensor(int32)",
+      "tensor(int64)",
+      "tensor(float16)",
+      "tensor(float)",
+      "tensor(double)"};
+  return all_numeric_types;
+}
+
+const std::vector<std::string>& OpSchema::all_numeric_sequence_types() {
+  static const std::vector<std::string> all_numeric_sequence_types = {
+      "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(float16))",
+      "seq(tensor(float))",
+      "seq(tensor(double))"};
+  return all_numeric_sequence_types;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_types() {
+  static const std::vector<std::string> all_tensor_types = {
+      "tensor(uint8)",
+      "tensor(uint16)",
+      "tensor(uint32)",
+      "tensor(uint64)",
+      "tensor(int8)",
+      "tensor(int16)",
+      "tensor(int32)",
+      "tensor(int64)",
+      "tensor(float16)",
+      "tensor(float)",
+      "tensor(double)",
+      "tensor(string)",
+      "tensor(bool)",
+      "tensor(complex64)",
+      "tensor(complex128)"};
+  return all_tensor_types;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_types_ir4() {
+  static const std::vector<std::string> all_tensor_types_ir4 = {
+      "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)"};
+  return all_tensor_types_ir4;
+}
+
+const std::vector<std::string>& OpSchema::all_non_complex_numeric_types_plus_bool_ir4() {
+  static const std::vector<std::string> all_non_complex_numeric_types_plus_bool_ir4 = {
+      "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(bool)"};
+  return all_non_complex_numeric_types_plus_bool_ir4;
+}
+
+const std::vector<std::string>& OpSchema::all_float_types_ir4() {
+  static const std::vector<std::string> all_float_types_ir4 = {
+      "tensor(bfloat16)", "tensor(float16)", "tensor(float)", "tensor(double)"};
+  return all_float_types_ir4;
+}
+
+const std::vector<std::string>& OpSchema::all_float_types_plus_Xint8_ir4() {
+  static const std::vector<std::string> all_float_types_ir4 = {
+      "tensor(bfloat16)", "tensor(float16)", "tensor(float)", "tensor(double)", "tensor(int8)", "tensor(uint8)"};
+  return all_float_types_ir4;
+}
+
+const std::vector<std::string>& OpSchema::all_float_types_ir9() {
+  static const std::vector<std::string> all_float_types_ir9 = {
+      "tensor(bfloat16)",
+      "tensor(float16)",
+      "tensor(float)",
+      "tensor(double)",
+      "tensor(float8e4m3fn)",
+      "tensor(float8e4m3fnuz)",
+      "tensor(float8e5m2)",
+      "tensor(float8e5m2fnuz)"};
+  return all_float_types_ir9;
+}
+
+const std::vector<std::string>& OpSchema::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;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_types_ir10() {
+  static const std::vector<std::string> all_tensor_types_ir10 = {
+      "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)", "tensor(uint4)",
+      "tensor(int4)"};
+  return all_tensor_types_ir10;
+}
+
+const std::vector<std::string>& OpSchema::all_non_complex_tensor_types_ir10() {
+  static const std::vector<std::string> all_non_complex_tensor_types_ir10 = {
+      "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(float8e4m3fn)", "tensor(float8e4m3fnuz)",
+      "tensor(float8e5m2)", "tensor(float8e5m2fnuz)", "tensor(uint4)",        "tensor(int4)"};
+  return all_non_complex_tensor_types_ir10;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_types_ir11() {
+  static const std::vector<std::string> all_tensor_types_ir11 = {
+      "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)",
+      "tensor(uint4)",        "tensor(int4)",           "tensor(float4e2m1)"};
+  return all_tensor_types_ir11;
+}
+
+const std::vector<std::string>& OpSchema::all_non_complex_tensor_types_ir11() {
+  static const std::vector<std::string> all_non_complex_tensor_types_ir11 = {
+      "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(float8e4m3fn)", "tensor(float8e4m3fnuz)",
+      "tensor(float8e5m2)", "tensor(float8e5m2fnuz)", "tensor(uint4)",        "tensor(int4)",
+      "tensor(float4e2m1)"};
+  return all_non_complex_tensor_types_ir11;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_sequence_types() {
+  static const std::vector<std::string> all_tensor_sequence_types = {
+      "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(float16))",
+      "seq(tensor(float))",
+      "seq(tensor(double))",
+      "seq(tensor(string))",
+      "seq(tensor(bool))",
+      "seq(tensor(complex64))",
+      "seq(tensor(complex128))"};
+  return all_tensor_sequence_types;
+}
+
+const std::vector<std::string>& OpSchema::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))",
+      "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))"};
+  return all_tensor_sequence_types_ir4;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_sequence_types_ir9() {
+  static const std::vector<std::string> all_tensor_sequence_types_ir9 = {
+      "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_ir9;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_sequence_types_ir10() {
+  static const std::vector<std::string> all_tensor_sequence_types_ir10 = {
+      "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))", "seq(tensor(uint4))",
+      "seq(tensor(int4))"};
+  return all_tensor_sequence_types_ir10;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_sequence_types_ir11() {
+  static const std::vector<std::string> all_tensor_sequence_types_ir11 = {
+      "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))", "seq(tensor(uint4))",
+      "seq(tensor(int4))",       "seq(tensor(float4e2m1))"};
+  return all_tensor_sequence_types_ir11;
+}
+
+const std::vector<std::string>& OpSchema::all_optional_types() {
+  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(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(float16))",
+      "optional(tensor(float))",       "optional(tensor(double))",         "optional(tensor(string))",
+      "optional(tensor(bool))",        "optional(tensor(complex64))",      "optional(tensor(complex128))"};
+  return all_optional_types;
+}
+
+const std::vector<std::string>& OpSchema::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)))",
+      "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))"};
+  return all_optional_types;
+}
+
+const std::vector<std::string>& OpSchema::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;
+}
+
+const std::vector<std::string>& OpSchema::all_optional_types_ir10() {
+  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))",
+      "optional(tensor(uint4))",           "optional(tensor(int4))"};
+  return all_optional_types;
+}
+
+const std::vector<std::string>& OpSchema::all_optional_types_ir11() {
+  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))",
+      "optional(tensor(uint4))",           "optional(tensor(int4))",        "optional(tensor(float4e2m1))"};
+  return all_optional_types;
+}
+
 void OpSchema::Finalize() {
 #define ENFORCE(x)                                                                                      \
   do {                                                                                                  \
@@ -1022,13 +1476,13 @@ void OpSchema::Finalize() {
 
 std::ostream& operator<<(std::ostream& out, const OpSchema& schema) {
   if (!schema.attributes_.empty()) {
-    out << "Attributes:" << std::endl;
+    out << "Attributes:" << '\n';
     for (const auto& pair : schema.attributes_) {
-      out << "  " << pair.second.name << " : " << pair.second.description << std::endl;
+      out << "  " << pair.second.name << " : " << pair.second.description << '\n';
     }
   }
   if (schema.max_input_ > 0) {
-    out << "Inputs:" << std::endl;
+    out << "Inputs:" << '\n';
     if (!schema.inputs_.empty()) {
       for (size_t i = 0; i < schema.inputs_.size(); ++i) {
         const auto& p = schema.inputs_[i];
@@ -1037,14 +1491,14 @@ std::ostream& operator<<(std::ostream& out, const OpSchema& schema) {
         const auto& type_str = p.GetTypeStr();
         out << "  " << i << ", " << (!name.empty() ? name : "(unnamed)") << " : "
             << (!description.empty() ? description : "(no doc)") << " : "
-            << (!type_str.empty() ? type_str : "(no type)") << std::endl;
+            << (!type_str.empty() ? type_str : "(no type)") << '\n';
       }
     } else {
-      out << "  (no explicit description available)" << std::endl;
+      out << "  (no explicit description available)" << '\n';
     }
   }
   if (schema.max_output_ > 0) {
-    out << "Outputs:" << std::endl;
+    out << "Outputs:" << '\n';
     if (!schema.outputs_.empty()) {
       for (size_t i = 0; i < schema.outputs_.size(); ++i) {
         const auto& p = schema.outputs_[i];
@@ -1053,21 +1507,21 @@ std::ostream& operator<<(std::ostream& out, const OpSchema& schema) {
         const auto& type_str = p.GetTypeStr();
         out << "  " << i << ", " << (!name.empty() ? name : "(unnamed)") << " : "
             << (!description.empty() ? description : "(no doc)") << " : "
-            << (!type_str.empty() ? type_str : "(no type)") << std::endl;
+            << (!type_str.empty() ? type_str : "(no type)") << '\n';
       }
     } else {
-      out << "  (no explicit description available)" << std::endl;
+      out << "  (no explicit description available)" << '\n';
     }
   }
-  out << std::endl;
+  out << '\n';
   if (schema.doc()) {
     out << schema.doc();
   } else {
-    out << "(no documentation yet)" << std::endl;
+    out << "(no documentation yet)" << '\n';
   }
-  out << std::endl;
+  out << '\n';
   if (schema.line_) {
-    out << "Defined at " << schema.file_ << ":" << schema.line_ << std::endl;
+    out << "Defined at " << schema.file_ << ":" << schema.line_ << '\n';
   }
   return out;
 }
@@ -1124,6 +1578,7 @@ OpName_Domain_Version_Schema_Map& OpSchemaRegistry::map() {
     }
 
    private:
+#ifndef NDEBUG
     static size_t GetRegisteredSchemaCount() {
       size_t count = 0;
       for (auto& x : GetMapWithoutEnsuringRegistration()) {
@@ -1133,6 +1588,7 @@ OpName_Domain_Version_Schema_Map& OpSchemaRegistry::map() {
       }
       return count;
     }
+#endif
   };
 
 #ifndef __ONNX_DISABLE_STATIC_REGISTRATION