onnx 1.13.1__cp311-cp311-macosx_10_12_universal2.whl → 1.14.0__cp311-cp311-macosx_10_12_universal2.whl

onnx/common/ir_pb_converter.cc

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -38,7 +40,11 @@ Tensor tensorProtoToTensor(const ONNX_NAMESPACE::TensorProto& tp) {
     case ONNX_NAMESPACE::TensorProto_DataType_INT16:
     case ONNX_NAMESPACE::TensorProto_DataType_INT32:
     case ONNX_NAMESPACE::TensorProto_DataType_UINT8:
-    case ONNX_NAMESPACE::TensorProto_DataType_UINT16: {
+    case ONNX_NAMESPACE::TensorProto_DataType_UINT16:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E4M3FN:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E4M3FNUZ:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E5M2:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E5M2FNUZ: {
       ret.int32s().reserve(tp.int32_data_size());
       for (int i = 0; i < tp.int32_data_size(); i++) {
         ret.int32s().push_back(tp.int32_data(i));

onnx/common/ir_pb_converter.h

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */

onnx/common/model_helpers.cc

@@ -1,6 +1,6 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- */
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
 
 #include "onnx/common/model_helpers.h"
 #include "onnx/checker.h"

onnx/common/model_helpers.h

@@ -1,6 +1,6 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- */
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
 
 #pragma once
 

onnx/common/path.cc

@@ -3,7 +3,6 @@
  */
 
 // Copyright (c) ONNX Project Contributors.
-// Licensed under the MIT license.
 
 #include "onnx/common/path.h"
 

onnx/common/path.h

@@ -3,7 +3,6 @@
  */
 
 // Copyright (c) ONNX Project Contributors.
-// Licensed under the MIT license.
 
 #pragma once
 

onnx/common/platform_helpers.h

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */

onnx/common/status.cc

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */

onnx/common/status.h

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */

onnx/common/stl_backports.h

@@ -1,6 +1,6 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- */
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
 
 #pragma once
 

onnx/common/tensor.h

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -36,15 +38,6 @@ struct Tensor final {
   bool is_raw_data_;
   std::string raw_data_;
 
-  template <typename F, typename T>
-  void bin_func(const F& f, T* ptr, const T* a_ptr);
-
-  template <typename F, typename T>
-  void un_func(const F& f, T* ptr);
-
-  template <typename T>
-  void scale_dim(T* ptr, const T* s_ptr);
-
  public:
   Tensor()
       : is_segment_(false),
@@ -108,7 +101,11 @@ struct Tensor final {
   std::vector<int64_t>& sizes() {
     return sizes_;
   }
-
+  /// if tensor is a scalar, the sizes is empty, but the element number is actually 1.
+  /// size_from_dim() cannot handle this case, while elem_num() handles it correctly
+  int64_t elem_num() const {
+    return std::accumulate(sizes_.begin(), sizes_.end(), (int64_t)1, std::multiplies<int64_t>{});
+  }
   int64_t size_from_dim(int dim) const {
     if (dim < 0) {
       dim += (int)sizes_.size();
@@ -222,49 +219,25 @@ struct Tensor final {
   bool is_raw_data() const {
     return is_raw_data_;
   }
-
-  // this += a
-  // Supported for
-  // FLOAT, BOOL, INT8, INT16, INT32, UINT8, UINT16, INT64,
-  // UINT32, UINT64, DOUBLE,
-  // TODO: Support for FLOAT16, COMPLEX64, COMPLEX128
-  void add(const Tensor& a);
-
-  // this -= a
-  // Supported for
-  // FLOAT, BOOL, INT8, INT16, INT32, UINT8, UINT16, INT64,
-  // UINT32, UINT64, DOUBLE
-  // TODO: Support for FLOAT16, COMPLEX64, COMPLEX128
-  void subtract(const Tensor& a);
-
-  // this *= a
-  // Supported for
-  // FLOAT, BOOL, INT8, INT16, INT32, UINT8, UINT16, INT64,
-  // UINT32, UINT64, DOUBLE
-  // TODO: Support for FLOAT16, COMPLEX64, COMPLEX128
-  void multiply(const Tensor& a);
-
-  // this /= a
-  // Supported for
-  // FLOAT, INT8, INT16, INT32, UINT8, UINT16, INT64,
-  // UINT32, UINT64, DOUBLE
-  // TODO: Support for FLOAT16, COMPLEX64, COMPLEX128
-  void divide(const Tensor& a);
-
-  // Element-wise square root of This
-  // Supported for
-  // FLOAT, DOUBLE,
-  // TODO: Support for FLOAT16
-  void sqrt();
-
-  // Element wise scaling of tensor s
-  // s is one dimensional, has size M, where M is size of first dimension of tensor
-  // s must have has data type corresponding to this
-  // Supported for
-  // FLOAT16, FLOAT, DOUBLE
-  void scale_by_first_dim(const Tensor& s);
 };
 
+template <>
+inline std::string* Tensor::data<std::string>() {
+  ONNX_ASSERTM(
+      !is_raw_data(),
+      "data type is string. string content is required to be stored in repeated bytes string_data field."
+      "raw_data type cannot be string.");
+  return string_data_.data();
+}
+template <>
+inline const std::string* Tensor::data<std::string>() const {
+  ONNX_ASSERTM(
+      !is_raw_data(),
+      "data type is string. string content is required to be stored in repeated bytes string_data field."
+      "raw_data type cannot be string.");
+  return string_data_.data();
+}
+
 #define define_data(type, field)                             \
   template <>                                                \
   inline type* Tensor::data<type>() {                        \
@@ -289,126 +262,6 @@ define_data(double, double_data_);
 define_data(int32_t, int32_data_);
 define_data(int64_t, int64_data_);
 define_data(uint64_t, uint64_data_);
-define_data(std::string, string_data_);
 #undef define_data
 
-template <typename F, typename T>
-inline void Tensor::bin_func(const F& f, T* ptr, const T* a_ptr) {
-  const int64_t num_elements = size_from_dim(0);
-  for (int64_t i = 0; i < num_elements; ++i) {
-    ptr[i] = f(ptr[i], a_ptr[i]);
-  }
-}
-
-template <typename F, typename T>
-inline void Tensor::un_func(const F& f, T* ptr) {
-  const int64_t num_elements = size_from_dim(0);
-  for (int64_t i = 0; i < num_elements; ++i) {
-    ptr[i] = f(ptr[i]);
-  }
-}
-
-template <typename T>
-inline void Tensor::scale_dim(T* ptr, const T* s_ptr) {
-  int64_t elems_per_first_dim = size_from_dim(1);
-  int64_t first_dim_size = sizes_[0];
-  int64_t counter = 0;
-  for (int64_t i = 0; i < first_dim_size; ++i) {
-    for (int64_t j = 0; j < elems_per_first_dim; ++j) {
-      ptr[counter++] *= s_ptr[i];
-    }
-  }
-}
-
-#define APPLY_BINARY_FUNCTION(op_name, f)                                  \
-  inline void Tensor::op_name(const Tensor& other) {                       \
-    TENSOR_ASSERTM(                                                        \
-        other.elem_type() == elem_type_,                                   \
-        "Tensor types do not match: %s != %s",                             \
-        to_string(elem_type_).c_str(),                                     \
-        " vs. ",                                                           \
-        to_string(other.elem_type()).c_str());                             \
-    TENSOR_ASSERTM(other.sizes() == sizes_, "Tensor sizes do not match."); \
-    switch (elem_type_) {                                                  \
-      case ONNX_NAMESPACE::TensorProto_DataType_FLOAT: {                   \
-        bin_func(f<float>(), data<float>(), other.data<float>());          \
-        break;                                                             \
-      }                                                                    \
-      case ONNX_NAMESPACE::TensorProto_DataType_BOOL:                      \
-      case ONNX_NAMESPACE::TensorProto_DataType_INT8:                      \
-      case ONNX_NAMESPACE::TensorProto_DataType_INT16:                     \
-      case ONNX_NAMESPACE::TensorProto_DataType_INT32:                     \
-      case ONNX_NAMESPACE::TensorProto_DataType_UINT8:                     \
-      case ONNX_NAMESPACE::TensorProto_DataType_UINT16: {                  \
-        bin_func(f<int32_t>(), data<int32_t>(), other.data<int32_t>());    \
-        break;                                                             \
-      }                                                                    \
-      case ONNX_NAMESPACE::TensorProto_DataType_INT64: {                   \
-        bin_func(f<int64_t>(), data<int64_t>(), other.data<int64_t>());    \
-        break;                                                             \
-      }                                                                    \
-      case ONNX_NAMESPACE::TensorProto_DataType_UINT32:                    \
-      case ONNX_NAMESPACE::TensorProto_DataType_UINT64: {                  \
-        bin_func(f<uint64_t>(), data<uint64_t>(), other.data<uint64_t>()); \
-        break;                                                             \
-      }                                                                    \
-      case ONNX_NAMESPACE::TensorProto_DataType_DOUBLE: {                  \
-        bin_func(f<double>(), data<double>(), other.data<double>());       \
-        break;                                                             \
-      }                                                                    \
-      default:                                                             \
-        TENSOR_ASSERTM(                                                    \
-            false,                                                         \
-            "Operation %s not supported for data type %s",                 \
-            #op_name,                                                      \
-            " not supported for data type ",                               \
-            to_string(elem_type_).c_str());                                \
-    }                                                                      \
-  }
-
-APPLY_BINARY_FUNCTION(add, std::plus)
-APPLY_BINARY_FUNCTION(subtract, std::minus)
-APPLY_BINARY_FUNCTION(multiply, std::multiplies)
-APPLY_BINARY_FUNCTION(divide, std::divides)
-
-#undef APPLY_BINARY_FUNCTION
-
-inline void Tensor::sqrt() {
-  switch (elem_type_) {
-    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT: {
-      un_func<float (*)(float), float>(std::sqrt, data<float>());
-      break;
-    }
-    case ONNX_NAMESPACE::TensorProto_DataType_DOUBLE: {
-      un_func<double (*)(double), double>(std::sqrt, data<double>());
-      break;
-    }
-    default:
-      TENSOR_ASSERTM(false, "Operation sqrt not supported for data type %s", to_string(elem_type_).c_str());
-  }
-}
-
-inline void Tensor::scale_by_first_dim(const Tensor& other) {
-  ONNX_ASSERT(sizes_.size() > 1 && other.sizes().size() == 1 && other.sizes()[0] == sizes_[0]);
-  ONNX_ASSERT(other.elem_type() == elem_type_);
-
-  switch (elem_type_) {
-    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT: {
-      scale_dim(data<float>(), other.data<float>());
-      break;
-    }
-    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT16: {
-      scale_dim(data<int32_t>(), other.data<int32_t>());
-      break;
-    }
-    case ONNX_NAMESPACE::TensorProto_DataType_DOUBLE: {
-      scale_dim(data<double>(), other.data<double>());
-      break;
-    }
-    default:
-      TENSOR_ASSERTM(
-          false, "Operation scale_by_first_dim not supported for data type %s", to_string(elem_type_).c_str());
-  }
-}
-
 } // namespace ONNX_NAMESPACE

onnx/common/version.h

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -7,6 +9,6 @@
 namespace ONNX_NAMESPACE {
 
 // Represents the most recent release version. Updated with every release.
-constexpr const char* LAST_RELEASE_VERSION = "1.13.1";
+constexpr const char* LAST_RELEASE_VERSION = "1.14.0";
 
 } // namespace ONNX_NAMESPACE

onnx/compose.py

@@ -1,10 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import List, MutableMapping, Optional, Set, Tuple
+# pylint: disable=unidiomatic-typecheck
 
-from onnx import GraphProto, ModelProto
-from onnx import TensorProto as tp
-from onnx import checker, helper, utils
+from typing import Dict, List, MutableMapping, Optional, Set, Tuple
+
+from onnx import GraphProto, ModelProto, TensorProto, checker, helper, utils
 
 
 def check_overlapping_names(
@@ -76,7 +78,7 @@ def check_overlapping_names(
     return result
 
 
-def merge_graphs(
+def merge_graphs(  # pylint: disable=too-many-branches,too-many-statements
     g1: GraphProto,
     g2: GraphProto,
     io_map: List[Tuple[str, str]],
@@ -208,9 +210,9 @@ def merge_graphs(
     # Connecting outputs of the first graph with the inputs of the second
     for node_idx in range(g2_nodes_begin, g2_nodes_end):
         node = g.node[node_idx]
-        for index, name in enumerate(node.input):
-            if name in reversed_io_map:
-                node.input[index] = reversed_io_map[name]
+        for index, name_ in enumerate(node.input):
+            if name_ in reversed_io_map:
+                node.input[index] = reversed_io_map[name_]
 
     if inputs:
         input_set = set(inputs)
@@ -263,7 +265,7 @@ def merge_graphs(
     return g
 
 
-def merge_models(
+def merge_models(  # pylint: disable=too-many-branches
     m1: ModelProto,
     m2: ModelProto,
     io_map: List[Tuple[str, str]],
@@ -325,9 +327,7 @@ def merge_models(
     ir_version = m1.ir_version
 
     opset_import_map: MutableMapping[str, int] = {}
-    opset_imports = [entry for entry in m1.opset_import] + [
-        entry for entry in m2.opset_import
-    ]
+    opset_imports = list(m1.opset_import) + list(m2.opset_import)
 
     for entry in opset_imports:
         if entry.domain in opset_import_map:
@@ -411,7 +411,7 @@ def merge_models(
     return model
 
 
-def add_prefix_graph(
+def add_prefix_graph(  # pylint: disable=too-many-branches
     graph: GraphProto,
     prefix: str,
     rename_nodes: Optional[bool] = True,
@@ -421,6 +421,7 @@ def add_prefix_graph(
     rename_initializers: Optional[bool] = True,
     rename_value_infos: Optional[bool] = True,
     inplace: Optional[bool] = False,
+    name_map: Optional[Dict[str, str]] = None,
 ) -> GraphProto:
     """Adds a prefix to names of elements in a graph: nodes, edges, inputs, outputs,
     initializers, sparse initializer, value infos.
@@ -439,6 +440,7 @@ def add_prefix_graph(
         rename_value_infos (bool): Whether to prefix value info names
         inplace (bool): If True, mutates the graph directly.
                         Otherwise, a copy will be created
+        name_map: (Dict): shared name_map in subgraph
 
     Returns:
         GraphProto
@@ -455,24 +457,30 @@ def add_prefix_graph(
     def _prefixed(prefix: str, name: str) -> str:
         return prefix + name if len(name) > 0 else name
 
-    name_map = {}
+    if name_map is None:
+        name_map = {}
     if rename_edges:
         for n in g.node:
             for e in n.input:
                 name_map[e] = _prefixed(prefix, e)
             for e in n.output:
                 name_map[e] = _prefixed(prefix, e)
-    else:
-        if rename_outputs:
-            for entry in g.output:
-                name_map[entry.name] = _prefixed(prefix, entry.name)
-        if rename_inputs:
-            for entry in g.input:
-                name_map[entry.name] = _prefixed(prefix, entry.name)
+
+    if rename_inputs:
+        for entry in g.input:
+            name_map[entry.name] = _prefixed(prefix, entry.name)
+    if rename_outputs:
+        for entry in g.output:
+            name_map[entry.name] = _prefixed(prefix, entry.name)
 
     if rename_nodes:
         for n in g.node:
             n.name = _prefixed(prefix, n.name)
+            for attribute in n.attribute:
+                if attribute.g:
+                    add_prefix_graph(
+                        attribute.g, prefix, inplace=True, name_map=name_map
+                    )
 
     if rename_initializers:
         for init in g.initializer:
@@ -490,12 +498,12 @@ def add_prefix_graph(
             name_map[entry.name] = _prefixed(prefix, entry.name)
 
     for n in g.node:
-        for i in range(len(n.output)):
+        for i, output in enumerate(n.output):
             if n.output[i] in name_map:
-                n.output[i] = name_map[n.output[i]]
-        for i in range(len(n.input)):
+                n.output[i] = name_map[output]
+        for i, input_ in enumerate(n.input):
             if n.input[i] in name_map:
-                n.input[i] = name_map[n.input[i]]
+                n.input[i] = name_map[input_]
 
     for in_desc in g.input:
         if in_desc.name in name_map:
@@ -626,12 +634,12 @@ def expand_out_dim_graph(
     orig_out_names = [output.name for output in g.output]
 
     for n in g.node:
-        for i in range(len(n.output)):
-            if n.output[i] in orig_out_names:
-                n.output[i] = n.output[i] + f"_collapsed_dim_{dim_idx}"
-        for i in range(len(n.input)):
-            if n.input[i] in orig_out_names:
-                n.input[i] = n.input[i] + f"_collapsed_dim_{dim_idx}"
+        for i, out in enumerate(n.output):
+            if out in orig_out_names:
+                n.output[i] = out + f"_collapsed_dim_{dim_idx}"
+        for i, inp in enumerate(n.input):
+            if inp in orig_out_names:
+                n.input[i] = inp + f"_collapsed_dim_{dim_idx}"
 
     expand_dim_k = g.name + "_expand_out_dim_idx"
     g.node.append(
@@ -642,7 +650,7 @@ def expand_out_dim_graph(
             name=f"{expand_dim_k}-constant",
             value=helper.make_tensor(
                 name=f"{expand_dim_k}-value",
-                data_type=tp.INT64,
+                data_type=TensorProto.INT64,
                 dims=[
                     1,
                 ],