onnx 1.16.2__cp39-cp39-win_amd64.whl → 1.17.0__cp39-cp39-win_amd64.whl

onnx/reference/reference_evaluator.py

@@ -1,9 +1,10 @@
 # Copyright (c) ONNX Project Contributors
 #
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 from io import BytesIO
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any
 
 import numpy as np
 
@@ -182,7 +183,7 @@ class ReferenceEvaluator:
 
         An operator may have a reference implementation such as `CastLike`
         and still be defined as a function. By default, the reference implementation
-        is used. This behaviour can be changed by adding a class to the list
+        is used. This behavior can be changed by adding a class to the list
         of overwritten operators. It must inherit from :class:`OpRunExpand`.
 
         ::
@@ -202,10 +203,10 @@ class ReferenceEvaluator:
     def __init__(  # type: ignore
         self,
         proto: Any,
-        opsets: Optional[Dict[str, int]] = None,
-        functions: Optional[List[Union["ReferenceEvaluator", FunctionProto]]] = None,  # type: ignore
+        opsets: dict[str, int] | None = None,
+        functions: list[ReferenceEvaluator | FunctionProto] | None = None,  # type: ignore
         verbose: int = 0,
-        new_ops: Optional[List[OpRun]] = None,
+        new_ops: list[OpRun] | None = None,
         optimized: bool = True,
     ):
         if optimized:
@@ -231,8 +232,8 @@ class ReferenceEvaluator:
         elif isinstance(proto, bytes):
             proto = load(BytesIO(proto))
         self.proto_ = proto
-        self.functions_: Dict[Tuple[str, str], ReferenceEvaluator] = {}
-        self.attributes_: List[str] = []
+        self.functions_: dict[tuple[str, str], ReferenceEvaluator] = {}
+        self.attributes_: list[str] = []
         if isinstance(proto, ModelProto):
             self.onnx_graph_ = proto.graph
             self.opsets_ = {d.domain: d.version for d in proto.opset_import}
@@ -244,7 +245,7 @@ class ReferenceEvaluator:
         elif isinstance(proto, GraphProto):
             self.onnx_graph_ = proto
             if not isinstance(opsets, dict):
-                raise ValueError("opsets must be a dictionary if proto is GraphProto.")
+                raise TypeError("opsets must be a dictionary if proto is GraphProto.")
             self.opsets_ = opsets
         elif isinstance(proto, FunctionProto):
             self.onnx_graph_ = None  # type: ignore
@@ -293,7 +294,7 @@ class ReferenceEvaluator:
                 else:
                     raise TypeError(f"Unexpected type {type(f)!r} for a function.")
         self.verbose = verbose
-        self.new_ops_: Dict[Tuple[str, str], OpRun] = {}
+        self.new_ops_: dict[tuple[str, str], OpRun] = {}
         if new_ops is not None:
             for cl in new_ops:
                 if not hasattr(cl, "op_domain"):
@@ -342,7 +343,7 @@ class ReferenceEvaluator:
             return ", ".join(map(self._log_arg, a))
         return a
 
-    def _log(self, level: int, pattern: str, *args: List[Any]) -> None:
+    def _log(self, level: int, pattern: str, *args: list[Any]) -> None:
         if level < self.verbose:
             new_args = [self._log_arg(a) for a in args]
             print(pattern % tuple(new_args))
@@ -453,7 +454,7 @@ class ReferenceEvaluator:
             self.rt_nodes_.append(inst)
 
     def _load_impl(  # noqa: PLR0911
-        self, node: NodeProto, input_types: Optional[TypeProto] = None
+        self, node: NodeProto, input_types: TypeProto | None = None
     ) -> Any:
         """Loads the implementation for a specified runtime."""
         if node.domain not in self.opsets:
@@ -542,7 +543,13 @@ class ReferenceEvaluator:
             f"is unknown, known functions: {sorted(self.functions_)}."
         )
 
-    def run(self, output_names, feed_inputs: Dict[str, Any], attributes: Optional[Dict[str, Any]] = None):  # type: ignore
+    def run(
+        self,
+        output_names,
+        feed_inputs: dict[str, Any],
+        attributes: dict[str, Any] | None = None,
+        intermediate: bool = False,
+    ) -> dict[str, Any] | list[Any]:  # type: ignore
         """Executes the onnx model.
 
         Args:
@@ -550,9 +557,13 @@ class ReferenceEvaluator:
             feed_inputs: dictionary `{ input name: input value }`
             attributes: attributes value if the instance runs a
                 FunctionProto
+            intermediate: if True, the function returns all the results,
+                final ones and intermediates one in a same dictionary,
+                if False, only the final results are returned in a list
 
         Returns:
-            list of requested outputs
+            list of requested outputs if intermediate is False,
+            named results in a dictionary otherwise
         """
         if output_names is None:
             output_names = self.output_names
@@ -591,6 +602,9 @@ class ReferenceEvaluator:
                 results[name] = value
 
         # return the results
+        if intermediate:
+            return results
+
         for name in output_names:
             if name not in results:
                 raise RuntimeError(

onnx/serialization.py

@@ -171,7 +171,7 @@ class _TextualSerializer(ProtoSerializer):
     """Serialize and deserialize the ONNX textual representation."""
 
     supported_format = "onnxtxt"
-    file_extensions = frozenset({".onnxtxt"})
+    file_extensions = frozenset({".onnxtxt", ".onnxtext"})
 
     def serialize_proto(self, proto: _Proto) -> bytes:
         text = onnx.printer.to_text(proto)  # type: ignore[arg-type]

onnx/shape_inference/implementation.cc

@@ -906,7 +906,7 @@ struct FunctionInferenceContext : public InferenceContext {
       const std::vector<TypeProto>& input_types,
       const std::vector<AttributeProto>& attributes,
       const ShapeInferenceOptions& options)
-      : input_types_(input_types), options_(options) {
+      : input_types_(input_types), options_(options), func_proto_(&func_proto) {
     for (const auto& attr : attributes) {
       attributesByName_[attr.name()] = &attr;
     }
@@ -971,11 +971,25 @@ struct FunctionInferenceContext : public InferenceContext {
     return std::move(output_types_);
   }
 
+  std::string getDisplayName() const override {
+    if (func_proto_ == nullptr)
+      return "";
+    if (func_proto_->domain().empty()) {
+      if (func_proto_->name().empty())
+        return "";
+      return MakeString("function ", func_proto_->name());
+    }
+    if (func_proto_->name().empty())
+      return MakeString("function [", func_proto_->domain(), "]");
+    return MakeString("function ", func_proto_->name(), "[", func_proto_->domain(), "]");
+  }
+
  private:
   const std::vector<TypeProto>& input_types_;
   std::vector<TypeProto> output_types_;
   std::unordered_map<std::string, const AttributeProto*> attributesByName_;
   ShapeInferenceOptions options_;
+  const FunctionProto* func_proto_;
 };
 
 std::vector<TypeProto> InferFunctionOutputTypes(

onnx/shape_inference/implementation.h

@@ -146,7 +146,7 @@ struct InferenceContextImpl : public InferenceContext {
       const ShapeInferenceOptions& options,
       DataValueMap* generatedShapeData = nullptr,
       GraphInferenceContext* graphInferenceContext = nullptr)
-      : graphInferenceContext_{graphInferenceContext}, options_(options) {
+      : graphInferenceContext_{graphInferenceContext}, options_(options), node_(&n) {
     for (auto& attr : *n.mutable_attribute()) {
       attributesByName_[attr.name()] = &attr;
       if (attr.has_g()) {
@@ -277,6 +277,19 @@ struct InferenceContextImpl : public InferenceContext {
     return inferencer;
   }
 
+  std::string getDisplayName() const override {
+    if (node_ == nullptr)
+      return "";
+    if (node_->domain().empty()) {
+      if (node_->name().empty())
+        return MakeString("node ", node_->op_type());
+      return MakeString("node ", node_->op_type(), " (", node_->name(), ")");
+    }
+    if (node_->name().empty())
+      return MakeString("node ", node_->op_type(), "[", node_->domain(), "]");
+    return MakeString("node ", node_->op_type(), "[", node_->domain(), "]", " (", node_->name(), ")");
+  }
+
   std::vector<const TensorProto*> allInputData_;
   std::vector<const SparseTensorProto*> allInputSparseData_;
   std::vector<const TensorShapeProto*> allShapeInputData_;
@@ -289,6 +302,7 @@ struct InferenceContextImpl : public InferenceContext {
   // mutable as internal cache of GraphInferencer instances
   mutable std::unordered_map<std::string, std::unique_ptr<GraphInferencer>> graphAttributeInferencers_;
   ShapeInferenceOptions options_;
+  NodeProto* node_;
 };
 
 struct DataPropagationContextImpl : public DataPropagationContext {

onnx/shape_inference.py

@@ -118,7 +118,7 @@ def infer_node_outputs(
 
     # catch KeyError if node's input does not exist in input_types
     passed_input_types = {
-        key: input_types[key].SerializeToString() for key in node.input
+        key: input_types[key].SerializeToString() for key in node.input if key != ""
     }
     # input_types will also be used as outer_scope_value_types so do not filter by node's input here
     for key in input_types:

onnx/subbyte.py

@@ -1,8 +1,7 @@
 # Copyright (c) ONNX Project Contributors
 #
 # SPDX-License-Identifier: Apache-2.0
-
-from typing import Tuple, Union
+from __future__ import annotations
 
 import numpy as np
 
@@ -13,7 +12,7 @@ UINT4_MAX = 15
 
 
 def float32_to_4bit_unpacked(
-    x: Union[np.ndarray, np.dtype, float], signed: bool
+    x: np.ndarray | np.dtype | float, signed: bool
 ) -> np.ndarray:
     """Cast to 4bit via rounding and clipping (without packing).
 
@@ -30,7 +29,8 @@ def float32_to_4bit_unpacked(
     if not isinstance(x, np.ndarray):
         x = np.asarray(x)
 
-    return np.rint(np.clip(x, clip_low, clip_high)).astype(dtype)  # type: ignore[no-any-return]
+    clipped = np.clip(x, clip_low, clip_high)
+    return np.rint(clipped).astype(dtype)  # type: ignore[no-any-return]
 
 
 def float32x2_to_4bitx2(
@@ -52,8 +52,8 @@ def float32x2_to_4bitx2(
 
 
 def unpack_single_4bitx2(
-    x: Union[np.ndarray, np.dtype, float], signed: bool
-) -> Tuple[np.ndarray, np.ndarray]:
+    x: np.ndarray | np.dtype | float, signed: bool
+) -> tuple[np.ndarray, np.ndarray]:
     unpack_signed = lambda x: np.where((x >> 3) == 0, x, x | 0xF0)  # noqa: E731
     """Unpack a single byte 4bitx2 to two 4 bit elements
     Args:

onnx/test/basic_test.py

@@ -1,6 +1,7 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import io
 import os

onnx/test/checker_test.py

@@ -1,6 +1,8 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
 import os
 import tempfile
 import unittest
@@ -797,7 +799,7 @@ class TestChecker(unittest.TestCase):
                             ],
                             outputs=[
                                 helper.make_tensor_value_info(
-                                    "cond___while_Identity_graph_outputs_Identity__3_0",
+                                    "cond___while_Less__13_0",
                                     TensorProto.BOOL,
                                     shape=[],
                                 ),
@@ -825,7 +827,7 @@ class TestChecker(unittest.TestCase):
                                     outputs=["cond___while_Less__13_0"],
                                     name="cond___while_Less__13",
                                     domain="",
-                                    to=TensorProto.FLOAT,
+                                    to=TensorProto.BOOL,
                                 ),
                             ],
                         ),
@@ -1076,6 +1078,39 @@ class TestChecker(unittest.TestCase):
             onnx.save(model, unicode_model_path)
             checker.check_model(unicode_model_path, full_check=True)
 
+    def test_graph_output_is_defined(self):
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 7, opset_import: [ "" : 17]>
+            agraph (float[N] x) => (float[N] y, float[N] z)
+            {
+                y = Add(x, x)
+            }
+            # Error: z is not defined
+        """
+        )
+        self.assertRaises(checker.ValidationError, checker.check_model, model)
+
+    def test_graph_output_is_defined_within_sub_graph(self):
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 7, opset_import: [ "" : 17]>
+            agraph (float[N] x, bool cond) => (float[N] y)
+            {
+                sum = Add (x, x)
+                prod = Mul (x, x)
+                y = If (cond) <
+                    then_branch = then_graph () => (sum) {},
+                    else_branch = else_graph () => (prod) {}
+                >
+            }
+            # Error: sum/prod are accessible inside if-then-else branches, but cannot
+            # be used as outputs of the then/else branch implicitly.
+            # An explicit "Identity(sum)" must be used to return sum as output.
+        """
+        )
+        self.assertRaises(checker.ValidationError, checker.check_model, model)
+
 
 if __name__ == "__main__":
     unittest.main()

onnx/test/compose_test.py

@@ -1,9 +1,10 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import unittest
-from typing import Callable, List, Optional, Sequence, Tuple
+from typing import Callable, Sequence
 
 import numpy as np
 
@@ -35,7 +36,7 @@ def _prefixed(prefix: str, s: str) -> str:
     return prefix + s if len(s) > 0 else s
 
 
-def _get_shape(value_info: ValueInfoProto) -> List[int]:
+def _get_shape(value_info: ValueInfoProto) -> list[int]:
     """Returns a list of integers representing the shape of the provided ValueInfoProto"""
     return [
         value_info.type.tensor_type.shape.dim[d].dim_value
@@ -87,7 +88,7 @@ M2_DEF = """
     {
         C0 = Add(B01, B11)
         C1 = Sub(B11, B21)
-        M1 = Mul(C0, C1)
+        D0 = Mul(C0, C1)
     }
     """
 
@@ -97,12 +98,12 @@ class TestComposeFunctions(unittest.TestCase):
         self,
         m1def: str,
         m2def: str,
-        io_map: List[Tuple[str, str]],
+        io_map: list[tuple[str, str]],
         check_expectations: Callable[[GraphProto, GraphProto, GraphProto], None],
-        inputs: Optional[List[str]] = None,
-        outputs: Optional[List[str]] = None,
-        prefix1: Optional[str] = None,
-        prefix2: Optional[str] = None,
+        inputs: list[str] | None = None,
+        outputs: list[str] | None = None,
+        prefix1: str | None = None,
+        prefix2: str | None = None,
     ) -> None:
         m1, m2 = _load_model(m1def), _load_model(m2def)
         g3 = compose.merge_graphs(
@@ -767,9 +768,9 @@ class TestComposeFunctions(unittest.TestCase):
         def _make_function(
             domain: str,
             fname: str,
-            inputs: List[str],
-            outputs: List[str],
-            nodes: List[NodeProto],
+            inputs: list[str],
+            outputs: list[str],
+            nodes: list[NodeProto],
         ) -> FunctionProto:
             f = FunctionProto()
             f.domain = domain

onnx/test/cpp/schema_registration_test.cc

@@ -73,11 +73,11 @@ TEST(SchemaRegistrationTest, RegisterAndDeregisterAllOpsetSchemaVersion) {
   // Acos-7
   // Add-1,6,7,13,14
   // Trilu-14
-  auto schema = OpSchemaRegistry::Schema("Acos");
+  auto schema = OpSchemaRegistry::Schema("Acos", 7);
   EXPECT_NE(nullptr, schema);
   EXPECT_EQ(schema->SinceVersion(), 7);
 
-  schema = OpSchemaRegistry::Schema("Add");
+  schema = OpSchemaRegistry::Schema("Add", 14);
   EXPECT_NE(nullptr, schema);
   EXPECT_EQ(schema->SinceVersion(), 14);
 
@@ -121,7 +121,7 @@ TEST(SchemaRegistrationTest, RegisterSpecifiedOpsetSchemaVersion) {
   EXPECT_EQ(nullptr, opSchema);
 
   // Acos-7 is the latest Acos before specified 13
-  opSchema = OpSchemaRegistry::Schema("Acos");
+  opSchema = OpSchemaRegistry::Schema("Acos", 13);
   EXPECT_NE(nullptr, opSchema);
   EXPECT_EQ(opSchema->SinceVersion(), 7);
 #endif

onnx/test/cpp/shape_inference_test.cc

@@ -507,8 +507,7 @@ TEST(GraphInferencerImplTest, Scan9_BasicTest) {
   doInferencingTest(false);
 }
 
-void RunReshapeShapeInfTest(const char* modelStr, TensorShapeProto& expectedShape) {
-  ModelProto model;
+void ParseAndInfer(ModelProto& model, const char* modelStr) {
   OnnxParser parser(modelStr);
   auto status = parser.Parse(model);
   EXPECT_TRUE(status.IsOK()) << status.ErrorMessage();
@@ -516,6 +515,11 @@ void RunReshapeShapeInfTest(const char* modelStr, TensorShapeProto& expectedShap
 
   ShapeInferenceOptions options{true, 1, true};
   ONNX_NAMESPACE::shape_inference::InferShapes(model, ONNX_NAMESPACE::OpSchemaRegistry::Instance(), options);
+}
+
+void RunReshapeShapeInfTest(const char* modelStr, TensorShapeProto& expectedShape) {
+  ModelProto model;
+  ParseAndInfer(model, modelStr);
 
   const auto inferredShape = model.graph().output(0).type().tensor_type().shape();
   EXPECT_TRUE(inferredShape.dim_size() == expectedShape.dim_size());
@@ -620,5 +624,37 @@ TEST(ShapeInferenceTest, CheckShapesAndTypesTest) {
 #endif
 }
 
+TEST(ShapeInferenceTest, CustomOpTest) {
+  const char* modelStr = R"ONNX(
+<ir_version: 8,  opset_import: ["" : 15, "custom.domain" : 1]>
+agraph (float[256, 768, 3] x) => (z1, z2)
+{
+    z1 = custom.domain.CustomOp (x)
+    # Inference cannot determine the type/shape of z1
+    z2 = Abs(x)
+    # Inference SHOULD determine the type/shape of z2 (same as that of x)
+}
+)ONNX";
+
+  ModelProto model;
+  ParseAndInfer(model, modelStr);
+
+  auto& z1_value_info = model.graph().output(0);
+  // Check no inferred type for z1 (It's a quirk of the implementation that it
+  // has a dummy TypeProto, but it should have no values filled in.)
+  ASSERT_TRUE(z1_value_info.has_type());
+  ASSERT_FALSE(z1_value_info.type().has_tensor_type());
+
+  // Check inferred type for z2:
+  auto& z2_value_info = model.graph().output(1);
+  ASSERT_TRUE(z2_value_info.has_type());
+  ASSERT_TRUE(z2_value_info.type().has_tensor_type());
+  EXPECT_EQ(z2_value_info.type().tensor_type().elem_type(), TensorProto_DataType_FLOAT);
+  EXPECT_EQ(z2_value_info.type().tensor_type().shape().dim_size(), 3);
+  EXPECT_EQ(z2_value_info.type().tensor_type().shape().dim(0).dim_value(), 256);
+  EXPECT_EQ(z2_value_info.type().tensor_type().shape().dim(1).dim_value(), 768);
+  EXPECT_EQ(z2_value_info.type().tensor_type().shape().dim(2).dim_value(), 3);
+}
+
 } // namespace Test
 } // namespace ONNX_NAMESPACE

onnx/test/elu_test.py

@@ -1,6 +1,8 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
 import unittest
 
 from onnx import checker, defs, helper

onnx/test/function_inference_test.py

@@ -1,6 +1,8 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
 import unittest
 from typing import Sequence
 

onnx/test/function_test.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 # Copyright (c) ONNX Project Contributors
+from __future__ import annotations
 
 import unittest