onnx 1.17.0__cp312-cp312-win32.whl → 1.18.0__cp312-cp312-win32.whl

onnx/defs/function.cc

@@ -4,17 +4,14 @@
 
 #include "onnx/defs/function.h"
 
-#include <map>
-
 #include "onnx/defs/schema.h"
-#include "onnx/string_utils.h"
 
-namespace ONNX_NAMESPACE {
-std::string InteralTensorNameGenerator(const std::string& node_name, const std::string& internal_name) {
+static std::string InteralTensorNameGenerator(const std::string& node_name, const std::string& internal_name) {
   std::string new_name = "Func_" + node_name + internal_name;
   return new_name;
 }
 
+namespace ONNX_NAMESPACE {
 void FunctionExpandHelper(
     const NodeProto& node,
     const FunctionProto& func,
@@ -45,7 +42,7 @@ void FunctionExpandHelper(
     // If the node output is missing, the corresponding function output should
     // be treated as an internal value (not as missing) because it could also be
     // an intermediate value.
-    if (node.output().Get(idx) == "") {
+    if (node.output().Get(idx).empty()) {
       continue;
     }
     io_names_map[func.output().Get(idx)] = node.output().Get(idx);
@@ -70,7 +67,7 @@ void FunctionExpandHelper(
 
   const OpSchemaRegistry* schema_registry = OpSchemaRegistry::Instance();
   const auto schema = schema_registry->GetSchema(node.op_type(), domain_version, node.domain());
-  std::map<std::string, OpSchema::Attribute> default_attrs = schema->attributes();
+  auto default_attrs = schema->attributes();
 
   for (const auto& pair : default_attrs) {
     const auto& attr_name = pair.first;
@@ -139,8 +136,7 @@ std::vector<NodeProto> FunctionBodyHelper::BuildNodes(const std::vector<NodeDef>
 }
 
 void FunctionBodyHelper::BuildNodes(FunctionProto& functionProto, const std::vector<NodeDef>& node_defs) {
-  for (size_t i = 0; i < node_defs.size(); i++) {
-    const NodeDef& node = node_defs[i];
+  for (const auto& node : node_defs) {
     auto* np = functionProto.add_node();
 
     np->set_op_type(node.op_type);

onnx/defs/function.h

@@ -4,14 +4,11 @@
 
 #pragma once
 
-#include <mutex>
 #include <string>
-#include <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "attr_proto_util.h"
-#include "onnx/common/constants.h"
 #include "onnx/common/status.h"
 #include "onnx/defs/parser.h"
 #include "onnx/defs/schema.h"
@@ -30,16 +27,13 @@ class FunctionBodyHelper {
   struct AttributeProtoWrapper {
     AttributeProto proto;
 
-    AttributeProtoWrapper() {}
+    AttributeProtoWrapper() = default;
 
-    AttributeProtoWrapper(const AttributeProto& attr_prot) {
-      proto = attr_prot;
-    }
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    AttributeProtoWrapper(AttributeProto attr_prot) : proto(std::move(attr_prot)) {}
 
     template <typename T>
-    AttributeProtoWrapper(const std::string& attr_name, const T& value) {
-      proto = MakeAttribute(attr_name, value);
-    }
+    AttributeProtoWrapper(const std::string& attr_name, const T& value) : proto(MakeAttribute(attr_name, value)) {}
   };
 
   struct NodeDef {
@@ -110,7 +104,7 @@ class FunctionBodyHelper {
 
 class FunctionBuilder {
  public:
-  FunctionBuilder(FunctionProto& funProto_) : funProto(funProto_) {}
+  explicit FunctionBuilder(FunctionProto& funProto_) : funProto(funProto_) {}
 
   FunctionBuilder& Add(const char* nodes_txt) {
     OnnxParser parser(nodes_txt);
@@ -147,6 +141,37 @@ class FunctionBuilder {
     return Add(node_txt, MakeAttribute(attr_name, attr_value));
   }
 
+  template <typename T>
+  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) {
+      auto& node = *funProto.mutable_node(nodes_size - 1);
+      *node.add_attribute() = MakeAttribute(attr_name, attr_value);
+    } else {
+      ONNX_THROW_EX(std::logic_error("Error adding attribute to node of a graph with no nodes"));
+    }
+    return *this;
+  }
+
+  template <typename T, typename... Args>
+  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...);
+    }
+    return *this;
+  }
+
+  // Adds variable number of attributes to a node
+  template <typename... Args>
+  FunctionBuilder& Add(const char* node_txt, Args... args) {
+    Add(node_txt);
+    if constexpr (sizeof...(args) % 2 == 0) {
+      return AddAttributes(args...);
+    }
+  }
+
   FunctionBuilder& Const(const std::string& name, const TensorProto& tensor) {
     std::string constant_op(name);
     constant_op += " = Constant()";

onnx/defs/gen_doc.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 
 import os
 from collections import defaultdict
-from typing import Any, NamedTuple, Sequence
+from typing import TYPE_CHECKING, Any, NamedTuple
 
 import numpy as np
 
@@ -16,6 +16,9 @@ from onnx.backend.sample.ops import collect_sample_implementations
 from onnx.backend.test.case import collect_snippets
 from onnx.defs import ONNX_ML_DOMAIN, OpSchema
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 SNIPPETS = collect_snippets()
 SAMPLE_IMPLEMENTATIONS = collect_sample_implementations()
 ONNX_ML = not bool(os.getenv("ONNX_ML") == "0")

onnx/defs/generator/defs.cc

@@ -2,7 +2,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <algorithm>
 #include <cmath>
 
 #include "onnx/defs/function.h"
@@ -17,7 +16,7 @@ or value_* must be specified.
 
 ONNX_OPERATOR_SET_SCHEMA(
     Constant,
-    21,
+    23,
     OpSchema()
         .SetDoc(Constant_ver19_doc)
         .Attr("value", "The value for the elements of the output tensor.", AttributeProto::TENSOR, false)
@@ -57,7 +56,7 @@ 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_ir10(), "Constrain input and output types to all tensor types.")
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir11(), "Constrain input and output types to all tensor types.")
         .TypeAndShapeInferenceFunction(ConstantOpInference));
 
 static const char* ConstantOfShape_ver20_doc = R"DOC(
@@ -66,7 +65,7 @@ Generate a tensor with given value and shape.
 
 ONNX_OPERATOR_SET_SCHEMA(
     ConstantOfShape,
-    21,
+    23,
     OpSchema()
         .SetDoc(ConstantOfShape_ver20_doc)
         .Attr(
@@ -92,25 +91,11 @@ ONNX_OPERATOR_SET_SCHEMA(
         .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(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) {
@@ -120,7 +105,7 @@ ONNX_OPERATOR_SET_SCHEMA(
           }
 
           bool found = false;
-          TensorShapeProto output_shape = getShapeInput(ctx, 0, found);
+          TensorShapeProto output_shape = getShapeInput(ctx, 0, true, found);
           if (found) {
             *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape() = output_shape;
           }
@@ -432,15 +417,15 @@ Output: [10, 8, 6]
 )DOC";
 
 template <typename T>
-inline int64_t
+static int64_t
 compute_output_dim_for_range(const TensorProto* start, const TensorProto* limit, const TensorProto* delta) {
-  if (start->dims().size() != 0 || limit->dims().size() != 0 || delta->dims().size() != 0) {
+  if (!start->dims().empty() || !limit->dims().empty() || !delta->dims().empty()) {
     fail_shape_inference("Input to 'Range' op should be scalars (Tensor with only one element and shape empty)");
   }
 
-  const auto& start_data = ParseData<T>(start);
-  const auto& limit_data = ParseData<T>(limit);
-  const auto& delta_data = ParseData<T>(delta);
+  const auto start_data = ParseData<T>(start);
+  const auto limit_data = ParseData<T>(limit);
+  const auto delta_data = ParseData<T>(delta);
 
   int64_t n = static_cast<int64_t>(ceil((1.0 * (limit_data[0] - start_data[0])) / delta_data[0]));
 

onnx/defs/generator/old.cc

@@ -2,9 +2,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <algorithm>
-#include <functional>
-
 #include "onnx/defs/function.h"
 #include "onnx/defs/generator/utils.h"
 #include "onnx/defs/schema.h"
@@ -404,6 +401,51 @@ This operator produces a constant tensor. Exactly one of the provided attributes
 or value_* must be specified.
 )DOC";
 
+ONNX_OPERATOR_SET_SCHEMA(
+    Constant,
+    21,
+    OpSchema()
+        .SetDoc(Constant_ver19_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_ir10(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction(ConstantOpInference));
+
 ONNX_OPERATOR_SET_SCHEMA(
     Constant,
     19,
@@ -646,6 +688,68 @@ static const char* ConstantOfShape_ver20_doc = R"DOC(
 Generate a tensor with given value and shape.
 )DOC";
 
+ONNX_OPERATOR_SET_SCHEMA(
+    ConstantOfShape,
+    21,
+    OpSchema()
+        .SetDoc(ConstantOfShape_ver20_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)"},
+            "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;
+          }
+        }));
+
 ONNX_OPERATOR_SET_SCHEMA(
     ConstantOfShape,
     20,
@@ -700,7 +804,7 @@ ONNX_OPERATOR_SET_SCHEMA(
           }
 
           bool found = false;
-          TensorShapeProto output_shape = getShapeInput(ctx, 0, found);
+          TensorShapeProto output_shape = getShapeInput(ctx, 0, true, found);
           if (found) {
             *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape() = output_shape;
           }
@@ -759,7 +863,7 @@ ONNX_OPERATOR_SET_SCHEMA(
           }
 
           bool found = false;
-          TensorShapeProto output_shape = getShapeInput(ctx, 0, found);
+          TensorShapeProto output_shape = getShapeInput(ctx, 0, true, found);
           if (found) {
             *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape() = output_shape;
           }

onnx/defs/generator/utils.cc

@@ -45,7 +45,7 @@ void ConstantOpInference(InferenceContext& ctx) {
   if (nullptr != value_int) {
     // OpSchema::Verify check ensures that the attribute value has_i():
     if (!value_int->has_i()) {
-      fail_shape_inference("Attribute 'value_int' expect an integer.")
+      fail_shape_inference("Attribute 'value_int' expect an integer.");
     }
     updateOutputElemType(ctx, 0, TensorProto::INT64);
     updateOutputShape(ctx, 0, TensorShapeProto());

onnx/defs/logical/defs.cc

@@ -2,12 +2,11 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include "onnx/defs/function.h"
 #include "onnx/defs/schema.h"
 
 namespace ONNX_NAMESPACE {
 
-inline void unaryLogicalOpInference(InferenceContext& ctx) {
+inline static void unaryLogicalOpInference(InferenceContext& ctx) {
   // Type inference
   updateOutputElemType(ctx, 0, TensorProto::BOOL);
   // Shape inference
@@ -16,6 +15,7 @@ inline void unaryLogicalOpInference(InferenceContext& ctx) {
   }
 }
 
+// NOLINTNEXTLINE(misc-use-internal-linkage)
 std::function<void(OpSchema&)> BinaryLogicDocGenerator(const char* name) {
   return [=](OpSchema& schema) {
     std::string doc;
@@ -244,7 +244,7 @@ ONNX_OPERATOR_SET_SCHEMA(
             "Constrain input/output to integer tensors.")
         .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
 
-std::function<void(OpSchema&)> BinaryBitwiseDocGenerator(const char* name) {
+static std::function<void(OpSchema&)> BinaryBitwiseDocGenerator(const char* name) {
   return [=](OpSchema& schema) {
     std::string doc;
     POPULATE_OP_DOC_STR(doc = R"DOC(

onnx/defs/logical/old.cc

@@ -8,7 +8,7 @@ using namespace ONNX_NAMESPACE;
 
 namespace ONNX_NAMESPACE {
 
-std::function<void(OpSchema&)> BinaryLogicDocGenerator_opset12(const char* name) {
+static std::function<void(OpSchema&)> BinaryLogicDocGenerator_opset12(const char* name) {
   return [=](OpSchema& schema) {
     std::string doc;
     POPULATE_OP_DOC_STR(doc = R"DOC(
@@ -74,14 +74,14 @@ ONNX_OPERATOR_SET_SCHEMA(
             "Constrain input types to all numeric tensors.")
         .TypeConstraint("T1", {"tensor(bool)"}, "Constrain output to boolean tensor."));
 
-inline void logicalOpInference_opset1(InferenceContext& ctx) {
+inline static void logicalOpInference_opset1(InferenceContext& ctx) {
   updateOutputElemType(ctx, 0, TensorProto::BOOL);
   if (hasInputShape(ctx, 0)) {
     propagateShapeFromInputToOutput(ctx, 0, 0);
   }
 }
 
-std::function<void(OpSchema&)> BinaryLogicDocGenerator_opset1(const char* name) {
+static std::function<void(OpSchema&)> BinaryLogicDocGenerator_opset1(const char* name) {
   return [=](OpSchema& schema) {
     std::string doc;
     POPULATE_OP_DOC_STR(doc = R"DOC(
@@ -103,7 +103,7 @@ detailed description of the broadcasting rules.
   };
 }
 
-std::function<void(OpSchema&)> BinaryLogicDocGenerator_opset7(const char* name) {
+static std::function<void(OpSchema&)> BinaryLogicDocGenerator_opset7(const char* name) {
   return [=](OpSchema& schema) {
     std::string doc;
     POPULATE_OP_DOC_STR(doc = R"DOC(