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

onnx/defs/controlflow/utils.cc

@@ -192,7 +192,7 @@ void LoopInferenceFunction(InferenceContext& ctx) {
 }
 
 int handle_negative_axis_validate(const std::string& attrib, int axis, int rank) {
-  if (!(-rank <= axis && axis < rank)) {
+  if (-rank > axis || axis >= rank) {
     fail_shape_inference(attrib, " axis value ", axis, " is invalid for a tensor of rank ", rank);
   }
   return (axis >= 0 ? axis : axis + rank);
@@ -277,8 +277,8 @@ void ScanInferenceFunction(InferenceContext& ctx) {
         const auto& dims = shape.dim();
         mergeInDimensionInfo(dims.Get(axis), sequence_len_dim, 1);
 
-        temporary_type_protos.push_back(RemoveIthDimensionFromShape(*input_type, axis));
-        subgraph_input_types.push_back(&temporary_type_protos.back());
+        temporary_type_protos.emplace_back(RemoveIthDimensionFromShape(*input_type, axis));
+        subgraph_input_types.emplace_back(&temporary_type_protos.back());
 
       } else {
         subgraph_input_types.push_back(input_type);

onnx/defs/data_propagators.h

@@ -33,18 +33,21 @@ inline bool axisIsZero(DataPropagationContext& ctx, bool defaultZero = false) {
     }
   }
   int axis = static_cast<int>(axisAttr->i());
-  auto input_data_0 = ctx.getInputData(0);
-  if (input_data_0 == nullptr) {
+  if (axis >= 0) {
+    return axis == 0;
+  }
+  // For negative axes, we need rank information to determine if it is equivalent to axis 0
+  const TypeProto* type = ctx.getInputType(0);
+  if ((type == nullptr) || (!type->has_tensor_type()) || (!type->tensor_type().has_shape())) {
     return false;
   }
-  int rank = input_data_0->dim_size();
+
+  int rank = type->tensor_type().shape().dim_size();
   if (axis < -rank || axis >= rank) {
     fail_shape_inference("axis must be in [-rank, rank-1].");
     return false;
   }
-  if (axis < 0) {
-    axis += rank;
-  }
+  axis += rank;
   // Only supports axis = 0 since the data comes from Shape
   return axis == 0;
 }
@@ -68,7 +71,7 @@ inline void GatherOp13DataPropagator(DataPropagationContext& ctx) {
     return;
   }
   const auto input_indices = ctx.getInputData(1);
-  if (input_data == nullptr || input_indices == nullptr) {
+  if (input_indices == nullptr) {
     return;
   }
   TensorShapeProto tsp;

onnx/defs/data_type_utils.cc

@@ -5,9 +5,7 @@
 #include "data_type_utils.h"
 
 #include <cctype>
-#include <iostream>
-#include <iterator>
-#include <sstream>
+#include <unordered_set>
 
 namespace ONNX_NAMESPACE {
 namespace Utils {
@@ -46,7 +44,9 @@ class StringRange final {
  public:
   StringRange();
   StringRange(const char* data, size_t size);
+  // NOLINTNEXTLINE(google-explicit-constructor)
   StringRange(const std::string& str);
+  // NOLINTNEXTLINE(google-explicit-constructor)
   StringRange(const char* data);
   const char* Data() const;
   size_t Size() const;
@@ -97,12 +97,14 @@ std::mutex& DataTypeUtils::GetTypeStrLock() {
 DataType DataTypeUtils::ToType(const TypeProto& type_proto) {
   auto typeStr = ToString(type_proto);
   std::lock_guard<std::mutex> lock(GetTypeStrLock());
-  if (GetTypeStrToProtoMap().find(typeStr) == GetTypeStrToProtoMap().end()) {
+  auto it = GetTypeStrToProtoMap().find(typeStr);
+  if (it == GetTypeStrToProtoMap().end()) {
     TypeProto type;
     FromString(typeStr, type);
     GetTypeStrToProtoMap()[typeStr] = type;
+    it = GetTypeStrToProtoMap().find(typeStr);
   }
-  return &(GetTypeStrToProtoMap().find(typeStr)->first);
+  return &(it->first);
 }
 
 DataType DataTypeUtils::ToType(const std::string& type_str) {
@@ -158,7 +160,7 @@ std::string DataTypeUtils::ToString(const TypeProto& type_proto, const std::stri
       return left + "sparse_tensor(" + ToDataTypeString(type_proto.sparse_tensor_type().elem_type()) + ")" + right;
     }
     default:
-      ONNX_THROW_EX(std::invalid_argument("Unsuported type proto value case."));
+      ONNX_THROW_EX(std::invalid_argument("Unsupported type proto value case."));
   }
 }
 
@@ -188,8 +190,7 @@ void DataTypeUtils::FromString(const std::string& type_str, TypeProto& type_prot
     s.LStrip(key_size);
     s.LStrip(",");
     StringRange v(s.Data(), s.Size());
-    int32_t key_type;
-    FromDataTypeString(key, key_type);
+    auto key_type = FromDataTypeString(key);
     type_proto.mutable_map_type()->set_key_type(key_type);
     return FromString(std::string(v.Data(), v.Size()), *type_proto.mutable_map_type()->mutable_value_type());
   } else
@@ -213,18 +214,15 @@ void DataTypeUtils::FromString(const std::string& type_str, TypeProto& type_prot
 #endif
       if (s.LStrip("sparse_tensor")) {
     s.ParensWhitespaceStrip();
-    int32_t e;
-    FromDataTypeString(std::string(s.Data(), s.Size()), e);
+    auto e = FromDataTypeString(std::string(s.Data(), s.Size()));
     type_proto.mutable_sparse_tensor_type()->set_elem_type(e);
   } else if (s.LStrip("tensor")) {
     s.ParensWhitespaceStrip();
-    int32_t e;
-    FromDataTypeString(std::string(s.Data(), s.Size()), e);
+    auto e = FromDataTypeString(std::string(s.Data(), s.Size()));
     type_proto.mutable_tensor_type()->set_elem_type(e);
   } else {
     // Scalar
-    int32_t e;
-    FromDataTypeString(std::string(s.Data(), s.Size()), e);
+    auto e = FromDataTypeString(std::string(s.Data(), s.Size()));
     TypeProto::Tensor* t = type_proto.mutable_tensor_type();
     t->set_elem_type(e);
     // Call mutable_shape() to initialize a shape with no dimension.
@@ -238,14 +236,15 @@ bool DataTypeUtils::IsValidDataTypeString(const std::string& type_str) {
   return (allowedSet.find(type_str) != allowedSet.end());
 }
 
-void DataTypeUtils::FromDataTypeString(const std::string& type_str, int32_t& tensor_data_type) {
+int32_t DataTypeUtils::FromDataTypeString(const std::string& type_str) {
   if (!IsValidDataTypeString(type_str)) {
-    ONNX_THROW_EX(std::invalid_argument(
-        "DataTypeUtils::FromDataTypeString - Received invalid data type string '" + type_str + "'."));
+    ONNX_THROW_EX(
+        std::invalid_argument(
+            "DataTypeUtils::FromDataTypeString - Received invalid data type string '" + type_str + "'."));
   }
 
   TypesWrapper& t = TypesWrapper::GetTypesWrapper();
-  tensor_data_type = t.TypeStrToTensorDataType()[type_str];
+  return t.TypeStrToTensorDataType()[type_str];
 }
 
 StringRange::StringRange() : data_(""), size_(0), start_(data_), end_(data_) {}
@@ -439,8 +438,10 @@ TypesWrapper::TypesWrapper() {
   type_str_to_tensor_data_type_["float8e4m3fnuz"] = TensorProto_DataType_FLOAT8E4M3FNUZ;
   type_str_to_tensor_data_type_["float8e5m2"] = TensorProto_DataType_FLOAT8E5M2;
   type_str_to_tensor_data_type_["float8e5m2fnuz"] = TensorProto_DataType_FLOAT8E5M2FNUZ;
+  type_str_to_tensor_data_type_["float8e8m0"] = TensorProto_DataType_FLOAT8E8M0;
   type_str_to_tensor_data_type_["uint4"] = TensorProto_DataType_UINT4;
   type_str_to_tensor_data_type_["int4"] = TensorProto_DataType_INT4;
+  type_str_to_tensor_data_type_["float4e2m1"] = TensorProto_DataType_FLOAT4E2M1;
 
   for (auto& str_type_pair : type_str_to_tensor_data_type_) {
     tensor_data_type_to_type_str_[str_type_pair.second] = str_type_pair.first;

onnx/defs/data_type_utils.h

@@ -8,7 +8,6 @@
 #include <mutex>
 #include <string>
 #include <unordered_map>
-#include <unordered_set>
 
 #include "onnx/common/common.h"
 #include "onnx/onnx_pb.h"
@@ -53,7 +52,7 @@ class DataTypeUtils final {
  private:
   static void FromString(const std::string& type_str, TypeProto& type_proto);
 
-  static void FromDataTypeString(const std::string& type_str, int32_t& tensor_data_type);
+  static int32_t FromDataTypeString(const std::string& type_str);
 
   static std::string ToString(const TypeProto& type_proto, const std::string& left = "", const std::string& right = "");
 

onnx/defs/function.cc

@@ -4,17 +4,15 @@
 
 #include "onnx/defs/function.h"
 
-#include <map>
-
 #include "onnx/defs/schema.h"
-#include "onnx/string_utils.h"
+#include "onnx/inliner/inliner.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 +43,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 +68,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 +137,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);
@@ -172,4 +169,51 @@ bool FunctionBodyHelper::BuildFunctionProto(
   return true;
 }
 
+FunctionBuilder& FunctionBuilder::AddInlinedCall(
+    std::initializer_list<std::string_view> outputs,
+    const GraphProto& graph,
+    std::initializer_list<std::string_view> inputs,
+    std::string_view prefix) {
+  // Create a renamer with the given prefix
+  inliner::Renamer renamer(std::string(prefix), graph);
+
+  // Bind formal inputs to actual inputs
+  auto input_it = inputs.begin();
+  for (const auto& graph_input : graph.input()) {
+    if (input_it != inputs.end()) {
+      renamer.BindName(graph_input.name(), std::string(*input_it));
+      ++input_it;
+    }
+  }
+
+  // Bind formal outputs to actual outputs
+  auto output_it = outputs.begin();
+  for (const auto& graph_output : graph.output()) {
+    if (output_it != outputs.end()) {
+      renamer.BindName(graph_output.name(), std::string(*output_it));
+      ++output_it;
+    }
+  }
+
+  // Add Constant nodes for every initializer in the graph
+  for (const auto& initializer : graph.initializer()) {
+    std::string const_name = renamer.BindToUniqueName(initializer.name());
+    Const(const_name, initializer);
+  }
+
+  // Add a copy of every node in the graph with renamed variables
+  for (const auto& node : graph.node()) {
+    NodeProto new_node;
+    new_node.CopyFrom(node);
+
+    // Rename the node using the renamer
+    renamer.RenameNode(new_node);
+
+    // Add the node to the function
+    *funProto.add_node() = new_node;
+  }
+
+  return *this;
+}
+
 } // namespace ONNX_NAMESPACE

onnx/defs/function.h

@@ -4,14 +4,12 @@
 
 #pragma once
 
-#include <mutex>
 #include <string>
-#include <unordered_map>
+#include <string_view>
 #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"
@@ -19,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,
@@ -30,16 +28,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 {
@@ -71,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:
@@ -87,32 +82,32 @@ 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)}}};
   }
 };
 
 class FunctionBuilder {
  public:
-  FunctionBuilder(FunctionProto& funProto_) : funProto(funProto_) {}
+  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();
 
@@ -125,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);
@@ -143,11 +138,43 @@ 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));
   }
 
-  FunctionBuilder& Const(const std::string& name, const TensorProto& tensor) {
+  template <typename T>
+  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) {
+      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>
+  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...);
+    }
+    return *this;
+  }
+
+  // Adds variable number of attributes to a node
+  template <typename... Args>
+  ONNX_API FunctionBuilder& Add(const char* node_txt, Args... args) {
+    Add(node_txt);
+    if constexpr (sizeof...(args) % 2 == 0) {
+      AddAttributes(args...);
+    }
+    return *this;
+  }
+
+  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));
@@ -155,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)));
@@ -163,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);
@@ -173,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);
@@ -182,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/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"
@@ -10,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,
-    21,
+    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",
@@ -57,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_ir10(), "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,
-    21,
+    24,
     OpSchema()
-        .SetDoc(ConstantOfShape_ver20_doc)
+        .SetDoc(ConstantOfShape_ver24_doc)
         .Attr(
             "value",
             "(Optional) The value of the output elements."
@@ -92,25 +91,12 @@ 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)",
+             "tensor(float8e8m0)"},
             "Constrain output types to be numerics or boolean.")
         .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
           if (ctx.getAttribute("value") != nullptr) {
@@ -120,7 +106,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;
           }
@@ -151,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")
@@ -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]));