onnx 1.18.0__cp313-cp313-macosx_12_0_universal2.whl → 1.19.1rc1__cp313-cp313-macosx_12_0_universal2.whl

onnx/defs/function.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <string>
+#include <string_view>
 #include <utility>
 #include <vector>
 
@@ -16,7 +17,7 @@
 
 namespace ONNX_NAMESPACE {
 // Helper function to expand a function node given the function proto
-void FunctionExpandHelper(
+ONNX_API void FunctionExpandHelper(
     const NodeProto& node,
     const FunctionProto& func,
     GraphProto& g,
@@ -65,12 +66,12 @@ class FunctionBodyHelper {
   To build a node with attribute:
     {{"Y"}, "Concat", {"X1", "X2", "X3"}, {{"axis", 1}}}
       represents Y = Concat(X1,X2,X3) with axis = 1
-    The attribute type are infered from the attribute value's c++ type
+    The attribute type are inferred from the attribute value's c++ type
     Supported value types are
       int64_t -> int, vector<int64_t> -> ints
       float -> float, vector<float> -> floats
       string -> string, vector<string> ->strings
-    For refering an attribute from parent, use:
+    For referring an attribute from parent, use:
       {MakeRefAttribute("axes", AttributeProto::INTS)}}
 
   To build a node which belongs to a domain other than onnx standard domain:
@@ -81,23 +82,23 @@ class FunctionBodyHelper {
 
   For more examples, please find the references of this function
   */
-  static std::vector<NodeProto> BuildNodes(const std::vector<NodeDef>& node_defs);
+  ONNX_API static std::vector<NodeProto> BuildNodes(const std::vector<NodeDef>& node_defs);
 
-  static void BuildNodes(FunctionProto& functionProto, const std::vector<NodeDef>& node_defs);
+  ONNX_API static void BuildNodes(FunctionProto& functionProto, const std::vector<NodeDef>& node_defs);
 
-  static bool BuildFunctionProto(
+  ONNX_API static bool BuildFunctionProto(
       FunctionProto& functionProto,
       const OpSchema& schema,
       const std::vector<NodeDef>& node_defs,
       const std::vector<OperatorSetIdProto>& relied_opsets);
 
   template <typename T>
-  static NodeDef Const(const std::string& name, const T& value) {
+  ONNX_API static NodeDef Const(const std::string& name, const T& value) {
     return NodeDef{{name}, "Constant", {}, {{"value", ToTensor<T>(value)}}};
   }
 
   template <typename T>
-  static NodeDef Const(const std::string& name, const std::vector<T>& values) {
+  ONNX_API static NodeDef Const(const std::string& name, const std::vector<T>& values) {
     return NodeDef{{name}, "Constant", {}, {{"value", ToTensor<T>(values)}}};
   }
 };
@@ -106,7 +107,7 @@ class FunctionBuilder {
  public:
   explicit FunctionBuilder(FunctionProto& funProto_) : funProto(funProto_) {}
 
-  FunctionBuilder& Add(const char* nodes_txt) {
+  ONNX_API FunctionBuilder& Add(const char* nodes_txt) {
     OnnxParser parser(nodes_txt);
     auto& nodes = *funProto.mutable_node();
 
@@ -119,7 +120,7 @@ class FunctionBuilder {
     return *this;
   }
 
-  FunctionBuilder& Add(const char* node_txt, const AttributeProto& attr) {
+  ONNX_API FunctionBuilder& Add(const char* node_txt, const AttributeProto& attr) {
     OnnxParser parser(node_txt);
     auto& node = *funProto.add_node();
     auto status = parser.Parse(node);
@@ -137,12 +138,12 @@ class FunctionBuilder {
   }
 
   template <typename T>
-  FunctionBuilder& Add(const char* node_txt, const std::string& attr_name, const T& attr_value) {
+  ONNX_API FunctionBuilder& Add(const char* node_txt, const std::string& attr_name, const T& attr_value) {
     return Add(node_txt, MakeAttribute(attr_name, attr_value));
   }
 
   template <typename T>
-  FunctionBuilder& AddAttributeToNode(const std::string& attr_name, const T& attr_value) {
+  ONNX_API FunctionBuilder& AddAttributeToNode(const std::string& attr_name, const T& attr_value) {
     auto& nodes = *funProto.mutable_node();
     int nodes_size = nodes.size();
     if (nodes_size != 0) {
@@ -155,7 +156,7 @@ class FunctionBuilder {
   }
 
   template <typename T, typename... Args>
-  FunctionBuilder& AddAttributes(const std::string& attr_name, const T& attr_value, Args... args) {
+  ONNX_API FunctionBuilder& AddAttributes(const std::string& attr_name, const T& attr_value, Args... args) {
     AddAttributeToNode(attr_name, attr_value);
     if constexpr (sizeof...(args) > 0) {
       AddAttributes(args...);
@@ -165,14 +166,15 @@ class FunctionBuilder {
 
   // Adds variable number of attributes to a node
   template <typename... Args>
-  FunctionBuilder& Add(const char* node_txt, Args... args) {
+  ONNX_API FunctionBuilder& Add(const char* node_txt, Args... args) {
     Add(node_txt);
     if constexpr (sizeof...(args) % 2 == 0) {
-      return AddAttributes(args...);
+      AddAttributes(args...);
     }
+    return *this;
   }
 
-  FunctionBuilder& Const(const std::string& name, const TensorProto& tensor) {
+  ONNX_API FunctionBuilder& Const(const std::string& name, const TensorProto& tensor) {
     std::string constant_op(name);
     constant_op += " = Constant()";
     return Add(constant_op.c_str(), MakeAttribute("value", tensor));
@@ -180,7 +182,7 @@ class FunctionBuilder {
 
   // Creates a scalar constant (a tensor of rank zero).
   template <typename T>
-  FunctionBuilder& Const(const std::string& name, T const_value) {
+  ONNX_API FunctionBuilder& Const(const std::string& name, T const_value) {
     std::string constant_op(name);
     constant_op += " = Constant()";
     return Add(constant_op.c_str(), MakeAttribute("value", ToTensor(const_value)));
@@ -188,7 +190,7 @@ class FunctionBuilder {
 
   // Creates a 1D tensor constant consisting of a single value.
   template <typename T>
-  FunctionBuilder& Const1D(const std::string& name, T const_value) {
+  ONNX_API FunctionBuilder& Const1D(const std::string& name, T const_value) {
     std::string constant_op(name);
     constant_op += " = Constant()";
     auto tensor = ToTensor(const_value);
@@ -198,7 +200,7 @@ class FunctionBuilder {
 
   // Creates a 1D tensor constant consisting of zero or more values.
   template <typename T>
-  FunctionBuilder& Const(const std::string& name, const std::vector<T>& values) {
+  ONNX_API FunctionBuilder& Const(const std::string& name, const std::vector<T>& values) {
     std::string constant_op(name);
     constant_op += " = Constant()";
     auto tensor = ToTensor(values);
@@ -207,13 +209,37 @@ class FunctionBuilder {
     return Add(constant_op.c_str(), MakeAttribute("value", tensor));
   }
 
-  FunctionBuilder& AddOpset(const char* domain, int version) {
+  ONNX_API FunctionBuilder& AddOpset(const char* domain, int version) {
     auto* opset = funProto.add_opset_import();
     opset->set_domain(domain);
     opset->set_version(version);
     return *this;
   }
 
+  /**
+   * @brief Adds an inlined call to a graph as a sequence of nodes in the function.
+   *
+   * This method effectively inlines the logic from the given graph into the function
+   * being constructed. It:
+   * - Adds a Constant node for every initializer in the graph
+   * - Adds a copy of every node in the graph
+   * - Renames formal input parameters to match actual inputs
+   * - Renames formal output parameters to match actual outputs
+   * - Renames all other intermediate values with a unique prefix
+   * - Leaves references to undefined names (outer scope variables) unchanged
+   *
+   * @param outputs List of output variable names for the inlined call
+   * @param graph The graph to inline
+   * @param inputs List of input variable names for the inlined call
+   * @param prefix Prefix to add to intermediate variable names for uniqueness
+   * @return Reference to this FunctionBuilder for method chaining
+   */
+  ONNX_API FunctionBuilder& AddInlinedCall(
+      std::initializer_list<std::string_view> outputs,
+      const GraphProto& graph,
+      std::initializer_list<std::string_view> inputs,
+      std::string_view prefix);
+
  private:
   FunctionProto& funProto;
 };

onnx/defs/generator/defs.cc

@@ -9,16 +9,16 @@
 #include "onnx/defs/schema.h"
 
 namespace ONNX_NAMESPACE {
-static const char* Constant_ver19_doc = R"DOC(
+static const char* Constant_ver24_doc = R"DOC(
 This operator produces a constant tensor. Exactly one of the provided attributes, either value, sparse_value,
 or value_* must be specified.
 )DOC";
 
 ONNX_OPERATOR_SET_SCHEMA(
     Constant,
-    23,
+    24,
     OpSchema()
-        .SetDoc(Constant_ver19_doc)
+        .SetDoc(Constant_ver24_doc)
         .Attr("value", "The value for the elements of the output tensor.", AttributeProto::TENSOR, false)
         .Attr(
             "sparse_value",
@@ -56,18 +56,18 @@ ONNX_OPERATOR_SET_SCHEMA(
             AttributeProto::STRINGS,
             false)
         .Output(0, "output", "Output tensor containing the same value of the provided tensor.", "T")
-        .TypeConstraint("T", OpSchema::all_tensor_types_ir11(), "Constrain input and output types to all tensor types.")
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir12(), "Constrain input and output types to all tensor types.")
         .TypeAndShapeInferenceFunction(ConstantOpInference));
 
-static const char* ConstantOfShape_ver20_doc = R"DOC(
+static const char* ConstantOfShape_ver24_doc = R"DOC(
 Generate a tensor with given value and shape.
 )DOC";
 
 ONNX_OPERATOR_SET_SCHEMA(
     ConstantOfShape,
-    23,
+    24,
     OpSchema()
-        .SetDoc(ConstantOfShape_ver20_doc)
+        .SetDoc(ConstantOfShape_ver24_doc)
         .Attr(
             "value",
             "(Optional) The value of the output elements."
@@ -95,7 +95,8 @@ ONNX_OPERATOR_SET_SCHEMA(
              "tensor(int16)",          "tensor(int32)",      "tensor(int64)",          "tensor(uint8)",
              "tensor(uint16)",         "tensor(uint32)",     "tensor(uint64)",         "tensor(uint4)",
              "tensor(int4)",           "tensor(bool)",       "tensor(bfloat16)",       "tensor(float8e4m3fn)",
-             "tensor(float8e4m3fnuz)", "tensor(float8e5m2)", "tensor(float8e5m2fnuz)", "tensor(float4e2m1)"},
+             "tensor(float8e4m3fnuz)", "tensor(float8e5m2)", "tensor(float8e5m2fnuz)", "tensor(float4e2m1)",
+             "tensor(float8e8m0)"},
             "Constrain output types to be numerics or boolean.")
         .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
           if (ctx.getAttribute("value") != nullptr) {
@@ -136,8 +137,7 @@ ONNX_OPERATOR_SET_SCHEMA(
         .Attr(
             "dtype",
             "(Optional) The data type for the elements of the output tensor. If not specified,"
-            "the data type of the input tensor T1 is used. If input tensor T1 is also not"
-            "specified, then type defaults to 'float'.",
+            " the data type of the input tensor T1 is used.",
             AttributeProto::INT,
             OPTIONAL_VALUE)
         .Input(0, "input", "2D input tensor to copy shape, and optionally, type information from.", "T1")

onnx/defs/generator/old.cc

@@ -396,6 +396,56 @@ ONNX_OPERATOR_SET_SCHEMA(
           propagateShapeFromInputToOutput(ctx, 0, 0);
         }));
 
+static const char* Constant_ver23_doc = R"DOC(
+This operator produces a constant tensor. Exactly one of the provided attributes, either value, sparse_value,
+or value_* must be specified.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Constant,
+    23,
+    OpSchema()
+        .SetDoc(Constant_ver23_doc)
+        .Attr("value", "The value for the elements of the output tensor.", AttributeProto::TENSOR, false)
+        .Attr(
+            "sparse_value",
+            "The value for the elements of the output tensor in sparse format.",
+            AttributeProto::SPARSE_TENSOR,
+            false)
+        .Attr(
+            "value_int",
+            "The value for the sole element for the scalar, int64, output tensor.",
+            AttributeProto::INT,
+            false)
+        .Attr(
+            "value_ints",
+            "The values for the elements for the 1D, int64, output tensor.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "value_float",
+            "The value for the sole element for the scalar, float32, output tensor.",
+            AttributeProto::FLOAT,
+            false)
+        .Attr(
+            "value_floats",
+            "The values for the elements for the 1D, float32, output tensor.",
+            AttributeProto::FLOATS,
+            false)
+        .Attr(
+            "value_string",
+            "The value for the sole element for the scalar, UTF-8 string, output tensor.",
+            AttributeProto::STRING,
+            false)
+        .Attr(
+            "value_strings",
+            "The values for the elements for the 1D, UTF-8 string, output tensor.",
+            AttributeProto::STRINGS,
+            false)
+        .Output(0, "output", "Output tensor containing the same value of the provided tensor.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir11(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction(ConstantOpInference));
+
 static const char* Constant_ver19_doc = R"DOC(
 This operator produces a constant tensor. Exactly one of the provided attributes, either value, sparse_value,
 or value_* must be specified.
@@ -684,6 +734,58 @@ ONNX_OPERATOR_SET_SCHEMA(
               "One of the attributes 'value' or 'sparse_value' must be specified for a Constant node.");
         }));
 
+static const char* ConstantOfShape_ver23_doc = R"DOC(
+Generate a tensor with given value and shape.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ConstantOfShape,
+    23,
+    OpSchema()
+        .SetDoc(ConstantOfShape_ver23_doc)
+        .Attr(
+            "value",
+            "(Optional) The value of the output elements."
+            "Should be a one-element tensor. If not specified, it defaults to a tensor of value 0 and datatype float32",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Input(
+            0,
+            "input",
+            "1D tensor. The shape of the expected output tensor. If empty tensor is given, the output would be a scalar."
+            " All values must be >= 0.",
+            "T1")
+        .Output(
+            0,
+            "output",
+            "Output tensor of shape specified by 'input'."
+            "If attribute 'value' is specified, the value and datatype of the output tensor is taken from 'value'."
+            "If attribute 'value' is not specified, the value in the output defaults to 0, and the datatype "
+            "defaults to float32.",
+            "T2")
+        .TypeConstraint("T1", {"tensor(int64)"}, "Constrain input types.")
+        .TypeConstraint(
+            "T2",
+            {"tensor(float16)",        "tensor(float)",      "tensor(double)",         "tensor(int8)",
+             "tensor(int16)",          "tensor(int32)",      "tensor(int64)",          "tensor(uint8)",
+             "tensor(uint16)",         "tensor(uint32)",     "tensor(uint64)",         "tensor(uint4)",
+             "tensor(int4)",           "tensor(bool)",       "tensor(bfloat16)",       "tensor(float8e4m3fn)",
+             "tensor(float8e4m3fnuz)", "tensor(float8e5m2)", "tensor(float8e5m2fnuz)", "tensor(float4e2m1)"},
+            "Constrain output types to be numerics or boolean.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          if (ctx.getAttribute("value") != nullptr) {
+            propagateElemTypeFromDtypeToOutput(ctx, ctx.getAttribute("value"), 0);
+          } else {
+            propagateElemTypeFromDtypeToOutput(ctx, TensorProto::FLOAT, 0);
+          }
+
+          bool found = false;
+          TensorShapeProto output_shape = getShapeInput(ctx, 0, true, found);
+          if (found) {
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape() = output_shape;
+          }
+        }));
+
 static const char* ConstantOfShape_ver20_doc = R"DOC(
 Generate a tensor with given value and shape.
 )DOC";

onnx/defs/logical/defs.cc

@@ -19,14 +19,15 @@ inline static void unaryLogicalOpInference(InferenceContext& ctx) {
 std::function<void(OpSchema&)> BinaryLogicDocGenerator(const char* name) {
   return [=](OpSchema& schema) {
     std::string doc;
-    POPULATE_OP_DOC_STR(doc = R"DOC(
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
 Returns the tensor resulted from performing the `{name}` logical operation
 elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
 
 {broadcast_doc}
 )DOC";
-                        ReplaceAll(doc, "{name}", name);
-                        ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
     schema.SetDoc(doc);
     schema.Input(
         0,
@@ -247,14 +248,15 @@ ONNX_OPERATOR_SET_SCHEMA(
 static std::function<void(OpSchema&)> BinaryBitwiseDocGenerator(const char* name) {
   return [=](OpSchema& schema) {
     std::string doc;
-    POPULATE_OP_DOC_STR(doc = R"DOC(
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
 Returns the tensor resulting from performing the bitwise `{name}` operation
 elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
 
 {broadcast_doc}
 )DOC";
-                        ReplaceAll(doc, "{name}", name);
-                        ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
     schema.SetDoc(doc);
     schema.Input(
         0,

onnx/defs/logical/old.cc

@@ -11,14 +11,15 @@ namespace ONNX_NAMESPACE {
 static std::function<void(OpSchema&)> BinaryLogicDocGenerator_opset12(const char* name) {
   return [=](OpSchema& schema) {
     std::string doc;
-    POPULATE_OP_DOC_STR(doc = R"DOC(
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
 Returns the tensor resulted from performing the `{name}` logical operation
 elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
 
 {broadcast_doc}
 )DOC";
-                        ReplaceAll(doc, "{name}", name);
-                        ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
     schema.SetDoc(doc);
     schema.Input(0, "A", "First input operand for the logical operator.", "T");
     schema.Input(1, "B", "Second input operand for the logical operator.", "T");
@@ -84,7 +85,8 @@ inline static void logicalOpInference_opset1(InferenceContext& ctx) {
 static std::function<void(OpSchema&)> BinaryLogicDocGenerator_opset1(const char* name) {
   return [=](OpSchema& schema) {
     std::string doc;
-    POPULATE_OP_DOC_STR(doc = R"DOC(
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
 Returns the tensor resulted from performing the `{name}` logical operation
 elementwise on the input tensors `A` and `B`.
 
@@ -92,7 +94,7 @@ If broadcasting is enabled, the right-hand-side argument will be broadcasted
 to match the shape of left-hand-side argument. See the doc of `Add` for a
 detailed description of the broadcasting rules.
 )DOC";
-                        ReplaceAll(doc, "{name}", name););
+        ReplaceAll(doc, "{name}", name););
     schema.SetDoc(doc);
     schema.Attr("broadcast", "Enable broadcasting", AttributeProto::INT, static_cast<int64_t>(0));
     schema.Attr("axis", "If set, defines the broadcast dimensions.", AttributeProto::INT, OPTIONAL_VALUE);
@@ -106,14 +108,15 @@ detailed description of the broadcasting rules.
 static std::function<void(OpSchema&)> BinaryLogicDocGenerator_opset7(const char* name) {
   return [=](OpSchema& schema) {
     std::string doc;
-    POPULATE_OP_DOC_STR(doc = R"DOC(
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
 Returns the tensor resulted from performing the `{name}` logical operation
 elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
 
 {broadcast_doc}
 )DOC";
-                        ReplaceAll(doc, "{name}", name);
-                        ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
     schema.SetDoc(doc);
     schema.Input(0, "A", "First input operand for the logical operator.", "T");
     schema.Input(1, "B", "Second input operand for the logical operator.", "T");