onnx 1.15.0__cp311-cp311-win_amd64.whl → 1.16.1__cp311-cp311-win_amd64.whl

onnx/common/ir.h

@@ -39,6 +39,16 @@
 
 namespace ONNX_NAMESPACE {
 
+namespace { // internal/private API
+
+std::string toVarName(size_t i) {
+  std::ostringstream oss;
+  oss << "_v_" << i;
+  return oss.str();
+}
+
+} // namespace
+
 // Graph represents one "function" of computation.
 // It uses a simple ownership model where the graph owns all the nodes inside it.
 // All references inside the graph are raw pointers.
@@ -346,7 +356,7 @@ struct Value final {
   std::string uniqueName() const {
     if (has_unique_name())
       return unique_name_;
-    return ONNX_NAMESPACE::to_string(unique());
+    return toVarName(unique());
   }
   Value* setUniqueName(const std::string& name, bool rename_subgraph_captured_nodes = true);
   Value* setStage(size_t s) {
@@ -434,6 +444,8 @@ struct Node : public Attributes<Node> {
   std::string domain_;
   bool has_doc_string_;
   std::string doc_string_;
+  bool has_overload_;
+  std::string overload_;
 
  protected:
   Node(Graph* graph_, NodeKind kind_); // defined after graph
@@ -459,6 +471,16 @@ struct Node : public Attributes<Node> {
     has_domain_ = true;
     domain_ = std::move(domain);
   }
+  bool has_overload() const {
+    return has_overload_;
+  }
+  const std::string& overload() const {
+    return overload_;
+  }
+  void setOverload(std::string overload) {
+    has_overload_ = true;
+    overload_ = std::move(overload);
+  }
   bool has_doc_string() const {
     return has_doc_string_;
   }
@@ -954,7 +976,7 @@ struct Graph final {
 
   void addInitializer(Tensor& initializer) {
     if (initializer.name().empty()) {
-      initializer.setName(ONNX_NAMESPACE::to_string(getNextUnique()));
+      initializer.setName(toVarName(getNextUnique()));
     }
     initializers_.push_back(initializer);
     initializer_names_.push_back(initializer.name());
@@ -1034,9 +1056,9 @@ struct Graph final {
   }
 
   size_t getNextUnique() {
-    std::string next_unique_name = ONNX_NAMESPACE::to_string(++next_unique_);
+    std::string next_unique_name = toVarName(++next_unique_);
     while (!isNameUnique(next_unique_name)) {
-      next_unique_name = ONNX_NAMESPACE::to_string(++next_unique_);
+      next_unique_name = toVarName(++next_unique_);
     }
     return next_unique_;
   }
@@ -1144,7 +1166,7 @@ struct Graph final {
   }
 
   Value* addInitializerAndInput(const Tensor& initializer) {
-    return addInitializerAndInput(initializer, ONNX_NAMESPACE::to_string(getNextUnique()));
+    return addInitializerAndInput(initializer, toVarName(getNextUnique()));
   }
 
   // Erases from graph initializer list, initializer names list, and as a graph input
@@ -1311,7 +1333,7 @@ inline void Value::replaceAllUsesWith(Value* newValue) {
     newValue->setUniqueName(unique_name);
     // The "unique" semantic of unique_name should be kept or uses()
     // will return an incorrect result when the value is used in subgraph
-    this->setUniqueName(ONNX_NAMESPACE::to_string(graph->getNextUnique()), false);
+    this->setUniqueName(toVarName(graph->getNextUnique()), false);
   }
   newValue->uses_in_current_graph_.reserve(this->uses_in_current_graph_.size());
   for (auto u : uses_in_current_graph_) {
@@ -1340,7 +1362,8 @@ inline Node::Node(Graph* graph_, NodeKind kind_)
       stage_(graph_->new_node_stage_),
       has_name_(false),
       has_domain_(false),
-      has_doc_string_(false) {
+      has_doc_string_(false),
+      has_overload_(false) {
   graph_->all_nodes.emplace(this);
 }
 

onnx/common/ir_pb_converter.cc

@@ -326,6 +326,9 @@ std::unique_ptr<Graph> graphProtoToGraph(const ONNX_NAMESPACE::GraphProto& gp, b
     if (np.has_domain()) {
       n->setDomain(np.domain());
     }
+    if (np.has_overload()) {
+      n->setOverload(np.overload());
+    }
   }
 
   for (auto n : g->nodes()) {
@@ -638,6 +641,9 @@ void encodeGraph(GraphProto* p_g, const std::shared_ptr<Graph>& g) {
     if (node->has_domain()) {
       p_n->set_domain(node->domain());
     }
+    if (node->has_overload()) {
+      p_n->set_overload(node->overload());
+    }
   }
 
   auto num_initializers = g->initializers().size();

onnx/common/path.h

@@ -8,6 +8,11 @@
 
 #include <string>
 #ifdef _WIN32
+// windows.h has preproc definitions for min and max, which prevents from using std::min and std::max.
+//  defining NOMINMAX disables the preproc macro.
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
 #include <windows.h>
 
 #include <filesystem>
@@ -31,11 +36,22 @@ inline std::wstring utf8str_to_wstring(const std::string& utf8str) {
   if (utf8str.size() > INT_MAX) {
     fail_check("utf8str_to_wstring: string is too long for converting to wstring.");
   }
-  int size_required = MultiByteToWideChar(CP_UTF8, 0, utf8str.c_str(), (int)utf8str.size(), NULL, 0);
+  int size_required = MultiByteToWideChar(CP_UTF8, 0, utf8str.c_str(), static_cast<int>(utf8str.size()), NULL, 0);
   std::wstring ws_str(size_required, 0);
-  MultiByteToWideChar(CP_UTF8, 0, utf8str.c_str(), (int)utf8str.size(), &ws_str[0], size_required);
+  MultiByteToWideChar(CP_UTF8, 0, utf8str.c_str(), static_cast<int>(utf8str.size()), &ws_str[0], size_required);
   return ws_str;
 }
+inline std::string wstring_to_utf8str(const std::wstring& ws_str) {
+  if (ws_str.size() > INT_MAX) {
+    fail_check("wstring_to_utf8str: string is too long for converting to UTF-8.");
+  }
+  int size_required =
+      WideCharToMultiByte(CP_UTF8, 0, ws_str.c_str(), static_cast<int>(ws_str.size()), NULL, 0, NULL, NULL);
+  std::string utf8str(size_required, 0);
+  WideCharToMultiByte(
+      CP_UTF8, 0, ws_str.c_str(), static_cast<int>(ws_str.size()), &utf8str[0], size_required, NULL, NULL);
+  return utf8str;
+}
 
 #else
 std::string path_join(const std::string& origin, const std::string& append);

onnx/common/proto_util.h

@@ -0,0 +1,43 @@
+// Copyright (c) ONNX Project Contributors
+
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <string>
+
+#include "onnx/common/constants.h"
+#include "onnx/onnx_pb.h"
+
+namespace ONNX_NAMESPACE {
+
+// ONNX (model-local) function identifiers are a tuple (domain, op, overload).
+// The pair (domain, op) represents a specification of a function, while
+// overload is used to disambiguate between multiple (specialized) implementations of
+// the same specification. Overload is optional and can be empty.
+// Multiple overloads may be used to distinguish implementations specialized
+// for a specific type or rank of input tensors or for specific attribute values.
+
+// A single string representation of (domain, op)
+using FunctionSpecId = std::string;
+
+// A single string representation of (domain, op, overload)
+using FunctionImplId = std::string;
+
+FunctionImplId GetFunctionImplId(const std::string& domain, const std::string& op, const std::string& overload) {
+  if (overload.empty())
+    return NormalizeDomain(domain) + "::" + op;
+  return NormalizeDomain(domain) + "::" + op + "::" + overload;
+}
+
+FunctionImplId GetFunctionImplId(const FunctionProto& function) {
+  return GetFunctionImplId(function.domain(), function.name(), function.overload());
+}
+
+FunctionImplId GetCalleeId(const NodeProto& node) {
+  return GetFunctionImplId(node.domain(), node.op_type(), node.overload());
+}
+
+} // namespace ONNX_NAMESPACE

onnx/common/version.h

@@ -9,6 +9,6 @@
 namespace ONNX_NAMESPACE {
 
 // Represents the most recent release version. Updated with every release.
-constexpr const char* LAST_RELEASE_VERSION = "1.15.0";
+constexpr const char* LAST_RELEASE_VERSION = "1.16.1";
 
 } // namespace ONNX_NAMESPACE

onnx/cpp2py_export.cc

@@ -233,34 +233,7 @@ PYBIND11_MODULE(onnx_cpp2py_export, onnx_cpp2py_export) {
       .def_property_readonly("option", &OpSchema::FormalParameter::GetOption)
       .def_property_readonly("is_homogeneous", &OpSchema::FormalParameter::GetIsHomogeneous)
       .def_property_readonly("min_arity", &OpSchema::FormalParameter::GetMinArity)
-      .def_property_readonly("differentiation_category", &OpSchema::FormalParameter::GetDifferentiationCategory)
-      // Legacy camel cased names. We retain them for backward compatibility.
-      // TODO(#5074): Remove these before the 1.16 release.
-      .def_property_readonly(
-          "typeStr",
-          [](const OpSchema::FormalParameter& self) {
-            auto warnings = py::module::import("warnings");
-            warnings.attr("warn")(
-                "OpSchema.FormalParameter.typeStr is deprecated and will be removed in 1.16. "
-                "Use OpSchema.FormalParameter.type_str instead.");
-            return self.GetTypeStr();
-          })
-      .def_property_readonly(
-          "isHomogeneous",
-          [](const OpSchema::FormalParameter& self) {
-            auto warnings = py::module::import("warnings");
-            warnings.attr("warn")(
-                "OpSchema.FormalParameter.isHomogeneous is deprecated and will be removed in 1.16. "
-                "Use OpSchema.FormalParameter.is_homogeneous instead.");
-            return self.GetIsHomogeneous();
-          })
-      .def_property_readonly("differentiationCategory", [](const OpSchema::FormalParameter& self) {
-        auto warnings = py::module::import("warnings");
-        warnings.attr("warn")(
-            "OpSchema.FormalParameter.differentiationCategory is deprecated and will be removed in 1.16. "
-            "Use OpSchema.FormalParameter.differentiation_category instead.");
-        return self.GetDifferentiationCategory();
-      });
+      .def_property_readonly("differentiation_category", &OpSchema::FormalParameter::GetDifferentiationCategory);
 
   op_schema
       .def(
@@ -430,6 +403,14 @@ PYBIND11_MODULE(onnx_cpp2py_export, onnx_cpp2py_export) {
           },
           "op_type"_a,
           "domain"_a = ONNX_DOMAIN)
+      .def(
+          "has_schema",
+          [](const std::string& op_type, int max_inclusive_version, const std::string& domain) -> bool {
+            return OpSchemaRegistry::Schema(op_type, max_inclusive_version, domain) != nullptr;
+          },
+          "op_type"_a,
+          "max_inclusive_version"_a,
+          "domain"_a = ONNX_DOMAIN)
       .def(
           "schema_version_map",
           []() -> std::unordered_map<std::string, std::pair<int, int>> {
@@ -469,7 +450,34 @@ PYBIND11_MODULE(onnx_cpp2py_export, onnx_cpp2py_export) {
       .def(
           "get_all_schemas_with_history",
           []() -> const std::vector<OpSchema> { return OpSchemaRegistry::get_all_schemas_with_history(); },
-          "Return the schema of all existing operators and all versions.");
+          "Return the schema of all existing operators and all versions.")
+      .def(
+          "set_domain_to_version",
+          [](const std::string& domain, int min_version, int max_version, int last_release_version) {
+            auto& obj = OpSchemaRegistry::DomainToVersionRange::Instance();
+            if (obj.Map().count(domain) == 0) {
+              obj.AddDomainToVersion(domain, min_version, max_version, last_release_version);
+            } else {
+              obj.UpdateDomainToVersion(domain, min_version, max_version, last_release_version);
+            }
+          },
+          "domain"_a,
+          "min_version"_a,
+          "max_version"_a,
+          "last_release_version"_a = -1,
+          "Set the version range and last release version of the specified domain.")
+      .def(
+          "register_schema",
+          [](OpSchema schema) { RegisterSchema(std::move(schema), 0, true, true); },
+          "schema"_a,
+          "Register a user provided OpSchema.")
+      .def(
+          "deregister_schema",
+          &DeregisterSchema,
+          "op_type"_a,
+          "version"_a,
+          "domain"_a,
+          "Deregister the specified OpSchema.");
 
   // Submodule `checker`
   auto checker = onnx_cpp2py_export.def_submodule("checker");
@@ -481,6 +489,9 @@ PYBIND11_MODULE(onnx_cpp2py_export, onnx_cpp2py_export) {
       .def_property(
           "opset_imports", &checker::CheckerContext::get_opset_imports, &checker::CheckerContext::set_opset_imports);
 
+  py::class_<checker::LexicalScopeContext> lexical_scope_context(checker, "LexicalScopeContext");
+  lexical_scope_context.def(py::init<>());
+
   py::register_exception<checker::ValidationError>(checker, "ValidationError");
 
   checker.def("check_value_info", [](const py::bytes& bytes, const checker::CheckerContext& ctx) -> void {
@@ -501,49 +512,70 @@ PYBIND11_MODULE(onnx_cpp2py_export, onnx_cpp2py_export) {
     checker::check_sparse_tensor(proto, ctx);
   });
 
-  checker.def("check_attribute", [](const py::bytes& bytes, const checker::CheckerContext& ctx) -> void {
-    AttributeProto proto{};
-    ParseProtoFromPyBytes(&proto, bytes);
-    checker::check_attribute(proto, ctx, checker::LexicalScopeContext());
-  });
+  checker.def(
+      "check_attribute",
+      [](const py::bytes& bytes,
+         const checker::CheckerContext& ctx,
+         const checker::LexicalScopeContext& lex_ctx) -> void {
+        AttributeProto proto{};
+        ParseProtoFromPyBytes(&proto, bytes);
+        checker::check_attribute(proto, ctx, lex_ctx);
+      });
 
-  checker.def("check_node", [](const py::bytes& bytes, const checker::CheckerContext& ctx) -> void {
-    NodeProto proto{};
-    ParseProtoFromPyBytes(&proto, bytes);
-    checker::LexicalScopeContext lex_ctx;
-    checker::check_node(proto, ctx, lex_ctx);
-  });
+  checker.def(
+      "check_node",
+      [](const py::bytes& bytes,
+         const checker::CheckerContext& ctx,
+         const checker::LexicalScopeContext& lex_ctx) -> void {
+        NodeProto proto{};
+        ParseProtoFromPyBytes(&proto, bytes);
+        checker::check_node(proto, ctx, lex_ctx);
+      });
 
-  checker.def("check_function", [](const py::bytes& bytes, const checker::CheckerContext& ctx) -> void {
-    FunctionProto proto{};
-    ParseProtoFromPyBytes(&proto, bytes);
-    checker::check_function(proto, ctx, checker::LexicalScopeContext());
-  });
+  checker.def(
+      "check_function",
+      [](const py::bytes& bytes,
+         const checker::CheckerContext& ctx,
+         const checker::LexicalScopeContext& lex_ctx) -> void {
+        FunctionProto proto{};
+        ParseProtoFromPyBytes(&proto, bytes);
+        checker::check_function(proto, ctx, lex_ctx);
+      });
 
-  checker.def("check_graph", [](const py::bytes& bytes, const checker::CheckerContext& ctx) -> void {
-    GraphProto proto{};
-    ParseProtoFromPyBytes(&proto, bytes);
-    checker::LexicalScopeContext lex_ctx;
-    checker::check_graph(proto, ctx, lex_ctx);
-  });
+  checker.def(
+      "check_graph",
+      [](const py::bytes& bytes,
+         const checker::CheckerContext& ctx,
+         const checker::LexicalScopeContext& lex_ctx) -> void {
+        GraphProto proto{};
+        ParseProtoFromPyBytes(&proto, bytes);
+        checker::check_graph(proto, ctx, lex_ctx);
+      });
 
   checker.def(
       "check_model",
-      [](const py::bytes& bytes, bool full_check, bool skip_opset_compatibility_check) -> void {
+      [](const py::bytes& bytes, bool full_check, bool skip_opset_compatibility_check, bool check_custom_domain)
+          -> void {
         ModelProto proto{};
         ParseProtoFromPyBytes(&proto, bytes);
-        checker::check_model(proto, full_check, skip_opset_compatibility_check);
+        checker::check_model(proto, full_check, skip_opset_compatibility_check, check_custom_domain);
       },
       "bytes"_a,
       "full_check"_a = false,
-      "skip_opset_compatibility_check"_a = false);
+      "skip_opset_compatibility_check"_a = false,
+      "check_custom_domain"_a = false);
 
   checker.def(
       "check_model_path",
-      (void (*)(const std::string& path, bool full_check, bool skip_opset_compatibility_check)) & checker::check_model,
+      (void (*)(
+          const std::string& path, bool full_check, bool skip_opset_compatibility_check, bool check_custom_domain)) &
+          checker::check_model,
       "path"_a,
       "full_check"_a = false,
-      "skip_opset_compatibility_check"_a = false);
+      "skip_opset_compatibility_check"_a = false,
+      "check_custom_domain"_a = false);
+
+  checker.def("_resolve_external_data_location", &checker::resolve_external_data_location);
 
   // Submodule `version_converter`
   auto version_converter = onnx_cpp2py_export.def_submodule("version_converter");

onnx/defs/__init__.py

@@ -8,6 +8,8 @@ __all__ = [
     "ONNX_ML_DOMAIN",
     "AI_ONNX_PREVIEW_TRAINING_DOMAIN",
     "has",
+    "register_schema",
+    "deregister_schema",
     "get_schema",
     "get_all_schemas",
     "get_all_schemas_with_history",
@@ -31,16 +33,19 @@ has = C.has_schema
 get_schema = C.get_schema
 get_all_schemas = C.get_all_schemas
 get_all_schemas_with_history = C.get_all_schemas_with_history
+deregister_schema = C.deregister_schema
 
 
 def onnx_opset_version() -> int:
-    """
-    Return current opset for domain `ai.onnx`.
-    """
-
+    """Return current opset for domain `ai.onnx`."""
     return C.schema_version_map()[ONNX_DOMAIN][1]
 
 
+def onnx_ml_opset_version() -> int:
+    """Return current opset for domain `ai.onnx.ml`."""
+    return C.schema_version_map()[ONNX_ML_DOMAIN][1]
+
+
 @property  # type: ignore
 def _function_proto(self):  # type: ignore
     func_proto = FunctionProto()
@@ -112,12 +117,28 @@ OpSchema.Attribute.__repr__ = _op_schema_attribute_repr  # type: ignore
 
 
 def get_function_ops() -> List[OpSchema]:
-    """
-    Return operators defined as functions.
-    """
-
+    """Return operators defined as functions."""
     schemas = C.get_all_schemas()
     return [schema for schema in schemas if schema.has_function or schema.has_context_dependent_function]  # type: ignore
 
 
 SchemaError = C.SchemaError
+
+
+def register_schema(schema: OpSchema) -> None:
+    """Register a user provided OpSchema.
+
+    The function extends available operator set versions for the provided domain if necessary.
+
+    Args:
+        schema: The OpSchema to register.
+    """
+    version_map = C.schema_version_map()
+    domain = schema.domain
+    version = schema.since_version
+    min_version, max_version = version_map.get(domain, (version, version))
+    if domain not in version_map or not (min_version <= version <= max_version):
+        min_version = min(min_version, version)
+        max_version = max(max_version, version)
+        C.set_domain_to_version(schema.domain, min_version, max_version)
+    C.register_schema(schema)

onnx/defs/controlflow/defs.cc

@@ -12,10 +12,10 @@
 namespace ONNX_NAMESPACE {
 using SupportType = OpSchema::SupportType;
 
-static std::vector<std::string> control_flow_types_ir9() {
-  auto t = OpSchema::all_tensor_types_ir9();
-  auto s = OpSchema::all_tensor_sequence_types_ir9();
-  auto o = OpSchema::all_optional_types_ir9();
+static std::vector<std::string> control_flow_types_ir10() {
+  auto t = OpSchema::all_tensor_types_ir10();
+  auto s = OpSchema::all_tensor_sequence_types_ir10();
+  auto o = OpSchema::all_optional_types_ir10();
   t.insert(t.end(), s.begin(), s.end());
   t.insert(t.end(), o.begin(), o.end());
   return t;
@@ -23,7 +23,7 @@ static std::vector<std::string> control_flow_types_ir9() {
 
 ONNX_OPERATOR_SET_SCHEMA(
     If,
-    19,
+    21,
     OpSchema()
         .SetDoc("If conditional")
         .Input(0, "cond", "Condition for the if. The tensor must contain a single element.", "B")
@@ -63,12 +63,12 @@ ONNX_OPERATOR_SET_SCHEMA(
             AttributeProto::GRAPH)
         .TypeConstraint(
             "V",
-            control_flow_types_ir9(),
-            "All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv9.")
+            control_flow_types_ir10(),
+            "All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv10.")
         .TypeConstraint("B", {"tensor(bool)"}, "Only bool")
         .TypeAndShapeInferenceFunction(IfInferenceFunction));
 
-static const char* Loop_ver19_doc = R"DOC(
+static const char* Loop_ver16_doc = R"DOC(
 Generic Looping construct. This loop has multiple termination conditions:
 
 1) Trip count. Iteration count specified at runtime. Set by
@@ -208,9 +208,9 @@ The input/output of subgraph (produced by loop node) matching is based on order
 
 ONNX_OPERATOR_SET_SCHEMA(
     Loop,
-    19,
+    21,
     OpSchema()
-        .SetDoc(Loop_ver19_doc)
+        .SetDoc(Loop_ver16_doc)
         .Input(
             0,
             "M",
@@ -253,13 +253,13 @@ ONNX_OPERATOR_SET_SCHEMA(
             AttributeProto::GRAPH)
         .TypeConstraint(
             "V",
-            control_flow_types_ir9(),
-            "All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv9.")
+            control_flow_types_ir10(),
+            "All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv10.")
         .TypeConstraint("I", {"tensor(int64)"}, "tensor of int64, which should be a scalar.")
         .TypeConstraint("B", {"tensor(bool)"}, "tensor of bool, which should be a scalar.")
         .TypeAndShapeInferenceFunction(LoopInferenceFunction));
 
-static const char* scan_19_doc = R"DOC(
+static const char* scan_16_doc = R"DOC(
 Scan can be used to iterate over one or more scan_input tensors,
 constructing zero or more scan_output tensors. It combines ideas from general recurrences,
 functional programming constructs such as scan, fold, map, and zip, and is intended to enable
@@ -385,9 +385,9 @@ values are computed in the outer graph, they need to be passed in as extra state
 
 ONNX_OPERATOR_SET_SCHEMA(
     Scan,
-    19,
+    21,
     OpSchema()
-        .SetDoc(scan_19_doc)
+        .SetDoc(scan_16_doc)
         .Input(
             0,
             "initial_state_and_scan_inputs",
@@ -448,7 +448,7 @@ ONNX_OPERATOR_SET_SCHEMA(
             "range is [-r, r-1].",
             AttributeProto::INTS,
             false)
-        .TypeConstraint("V", OpSchema::all_tensor_types_ir9(), "All Tensor types up to IRv9.")
+        .TypeConstraint("V", OpSchema::all_tensor_types_ir10(), "All Tensor types up to IRv10.")
         .TypeAndShapeInferenceFunction(ScanInferenceFunction)); // Shares same shape inference as opset 11
 
 } // namespace ONNX_NAMESPACE