onnx 1.16.1__cp311-cp311-win_amd64.whl → 1.17.0__cp311-cp311-win_amd64.whl

onnx/test/helper_test.py

@@ -1,13 +1,14 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
-
+from __future__ import annotations
 
 import itertools
+import math
 import random
 import struct
 import unittest
-from typing import Any, List, Tuple
+from typing import Any
 
 import numpy as np
 import parameterized
@@ -22,12 +23,14 @@ from onnx import (
     SequenceProto,
     TensorProto,
     TypeProto,
+    _custom_element_types,
     checker,
     defs,
     helper,
     numpy_helper,
 )
 from onnx.reference.op_run import to_array_extended
+from onnx.reference.ops.op_cast import Cast_19 as Cast
 
 
 class TestHelperAttributeFunctions(unittest.TestCase):
@@ -253,7 +256,7 @@ class TestHelperAttributeFunctions(unittest.TestCase):
         def _extend(
             attr: AttributeProto,
             type_: AttributeProto.AttributeType,
-            var: List[Any],
+            var: list[Any],
             value: Any,
         ) -> None:
             var.extend(value)
@@ -382,14 +385,14 @@ class TestHelperNodeFunctions(unittest.TestCase):
         self.assertRaises(checker.ValidationError, checker.check_model, model_def)
 
     def test_model_irversion(self) -> None:
-        def mk_model(opset_versions: List[Tuple[str, int]]) -> ModelProto:
+        def mk_model(opset_versions: list[tuple[str, int]]) -> ModelProto:
             graph = helper.make_graph([], "my graph", [], [])
             return helper.make_model_gen_version(
                 graph,
                 opset_imports=[helper.make_opsetid(*pair) for pair in opset_versions],
             )
 
-        def test(opset_versions: List[Tuple[str, int]], ir_version: int) -> None:
+        def test(opset_versions: list[tuple[str, int]], ir_version: int) -> None:
             model = mk_model(opset_versions)
             self.assertEqual(model.ir_version, ir_version)
 
@@ -407,6 +410,7 @@ class TestHelperNodeFunctions(unittest.TestCase):
         test([("", 19)], 9)
         test([("", 20)], 9)
         test([("", 21)], 10)
+        test([("", 22)], 10)
         # standard opset can be referred to using empty-string or "ai.onnx"
         test([("ai.onnx", 9)], 4)
         test([("ai.onnx.ml", 2)], 6)
@@ -431,6 +435,10 @@ class TestHelperTensorFunctions(unittest.TestCase):
         )
         self.assertEqual(string_list, list(tensor.string_data))
 
+    @unittest.skipIf(
+        version_utils.numpy_older_than("1.26.0"),
+        "The test requires numpy 1.26.0 or later",
+    )
     def test_make_bfloat16_tensor(self) -> None:
         # numpy doesn't support bf16, so we have to compute the correct result manually
         np_array = np.array(
@@ -479,7 +487,10 @@ class TestHelperTensorFunctions(unittest.TestCase):
             vals=np_array,
         )
         self.assertEqual(tensor.name, "test")
-        np.testing.assert_equal(np_results, numpy_helper.to_array(tensor))
+        np.testing.assert_equal(
+            Cast.eval(np_results, to=TensorProto.BFLOAT16),  # type: ignore[arg-type]
+            numpy_helper.to_array(tensor),
+        )
 
     def test_make_float8e4m3fn_tensor(self) -> None:
         y = helper.make_tensor(
@@ -487,7 +498,7 @@ class TestHelperTensorFunctions(unittest.TestCase):
         )
         ynp = numpy_helper.to_array(y)
         expected = np.array([0, 0.5, 1, 448, 10], dtype=np.float32)
-        np.testing.assert_equal(expected, ynp)
+        np.testing.assert_equal(Cast.eval(expected, to=TensorProto.FLOAT8E4M3FN), ynp)  # type: ignore[arg-type]
 
     def test_make_float8e4m3fnuz_tensor(self) -> None:
         y = helper.make_tensor(
@@ -498,7 +509,7 @@ class TestHelperTensorFunctions(unittest.TestCase):
         )
         ynp = numpy_helper.to_array(y)
         expected = np.array([0, 0.5, 1, 240, 10, 0, 0], dtype=np.float32)
-        np.testing.assert_equal(expected, ynp)
+        np.testing.assert_equal(Cast.eval(expected, to=TensorProto.FLOAT8E4M3FNUZ), ynp)  # type: ignore[arg-type]
 
     def test_make_float8e5m2_tensor(self) -> None:
         y = helper.make_tensor(
@@ -506,7 +517,7 @@ class TestHelperTensorFunctions(unittest.TestCase):
         )
         ynp = numpy_helper.to_array(y)
         expected = np.array([0, 0.5, 1, 49152, 96], dtype=np.float32)
-        np.testing.assert_equal(expected, ynp)
+        np.testing.assert_equal(Cast.eval(expected, to=TensorProto.FLOAT8E5M2), ynp)  # type: ignore[arg-type]
 
     def test_make_float8e5m2fnuz_tensor(self) -> None:
         y = helper.make_tensor(
@@ -517,8 +528,12 @@ class TestHelperTensorFunctions(unittest.TestCase):
         )
         ynp = numpy_helper.to_array(y)
         expected = np.array([0, 0.5, 1, 49152, 96, 0, 0], dtype=np.float32)
-        np.testing.assert_equal(expected, ynp)
+        np.testing.assert_equal(Cast.eval(expected, to=TensorProto.FLOAT8E5M2FNUZ), ynp)  # type: ignore[arg-type]
 
+    @unittest.skipIf(
+        version_utils.numpy_older_than("1.26.0"),
+        "The test requires numpy 1.26.0 or later",
+    )
     def test_make_bfloat16_tensor_raw(self) -> None:
         # numpy doesn't support bf16, so we have to compute the correct result manually
         np_array = np.array(
@@ -570,7 +585,11 @@ class TestHelperTensorFunctions(unittest.TestCase):
             raw=True,
         )
         self.assertEqual(tensor.name, "test")
-        np.testing.assert_equal(np_results, numpy_helper.to_array(tensor))
+        np.testing.assert_allclose(
+            Cast.eval(np_results, to=TensorProto.BFLOAT16),  # type: ignore[arg-type]
+            numpy_helper.to_array(tensor),
+            rtol=1e-4,  # truncate is not nearest even rounding
+        )
 
     def test_make_float8e4m3fn_tensor_raw(self) -> None:
         expected = np.array([0, 0.5, 1, 448, 10], dtype=np.float32)
@@ -586,7 +605,7 @@ class TestHelperTensorFunctions(unittest.TestCase):
             raw=True,
         )
         ynp = numpy_helper.to_array(y)
-        np.testing.assert_equal(expected, ynp)
+        np.testing.assert_equal(Cast.eval(expected, to=TensorProto.FLOAT8E4M3FN), ynp)  # type: ignore[arg-type]
 
     def test_make_float8e4m3fnuz_tensor_raw(self) -> None:
         expected = np.array([0, 0.5, 1, 240, 10], dtype=np.float32)
@@ -602,7 +621,7 @@ class TestHelperTensorFunctions(unittest.TestCase):
             raw=True,
         )
         ynp = numpy_helper.to_array(y)
-        np.testing.assert_equal(expected, ynp)
+        np.testing.assert_equal(Cast.eval(expected, to=TensorProto.FLOAT8E4M3FNUZ), ynp)  # type: ignore[arg-type]
 
     def test_make_float8e5m2_tensor_raw(self) -> None:
         expected = np.array([0, 0.5, 1, 49152, 10], dtype=np.float32)
@@ -618,7 +637,7 @@ class TestHelperTensorFunctions(unittest.TestCase):
             raw=True,
         )
         ynp = numpy_helper.to_array(y)
-        np.testing.assert_equal(expected, ynp)
+        np.testing.assert_equal(Cast.eval(expected, to=TensorProto.FLOAT8E5M2), ynp)  # type: ignore[arg-type]
 
     def test_make_float8e5m2fnuz_tensor_raw(self) -> None:
         expected = np.array([0, 0.5, 1, 49152, 10], dtype=np.float32)
@@ -635,7 +654,7 @@ class TestHelperTensorFunctions(unittest.TestCase):
             raw=True,
         )
         ynp = numpy_helper.to_array(y)
-        np.testing.assert_equal(expected, ynp)
+        np.testing.assert_equal(Cast.eval(expected, to=TensorProto.FLOAT8E5M2FNUZ), ynp)  # type: ignore[arg-type]
 
     @parameterized.parameterized.expand(
         itertools.product(
@@ -656,14 +675,46 @@ class TestHelperTensorFunctions(unittest.TestCase):
             type_range[dtype][0], high=type_range[dtype][1] + 1, size=dims
         )
         y = helper.make_tensor("y", dtype, data.shape, data)
+
+        # Check the expected size of int32_data in bytes
+        expected_data_size = math.ceil(np.prod(data.shape) / 2.0)
+        actual_data_size = len(bytes(y.int32_data))
+        np.testing.assert_equal(actual_data_size, expected_data_size)
+
+        # Check the expected data values.
         ynp = to_array_extended(y)
         np.testing.assert_equal(data, ynp)
 
+    @parameterized.parameterized.expand(
+        itertools.product(
+            ((5, 4, 6), (4, 6, 5), (3, 3), (1,), (2**10,)),
+        )
+    )
+    @unittest.skipIf(
+        version_utils.numpy_older_than("1.22.0"),
+        "The test requires numpy 1.22.0 or later",
+    )
+    def test_4bit_tensor_size(self, dims) -> None:
+        # A bug caused negative int4 values to inflate tensor size.
+        # So, test negative values here.
+        num_elems = np.prod(dims)
+        data = np.array([-4] * num_elems, dtype=np.int8).reshape(dims)
+        y = helper.make_tensor("y", TensorProto.INT4, data.shape, data)
+
+        # Check the expected size of int32_data in bytes
+        expected_data_size = math.ceil(num_elems / 2.0)
+        actual_data_size = len(bytes(y.int32_data))
+        np.testing.assert_equal(actual_data_size, expected_data_size)
+
     @parameterized.parameterized.expand(
         itertools.product(
             (TensorProto.UINT4, TensorProto.INT4), ((5, 4, 6), (4, 6, 5), (3, 3), (1,))
         )
     )
+    @unittest.skipIf(
+        version_utils.numpy_older_than("1.26.0"),
+        "The test requires numpy 1.26.0 or later",
+    )
     def test_make_4bit_raw_tensor(self, dtype, dims) -> None:
         type_range = {
             TensorProto.UINT4: (0, 15),
@@ -671,7 +722,7 @@ class TestHelperTensorFunctions(unittest.TestCase):
         }
         data = np.random.randint(
             type_range[dtype][0], high=type_range[dtype][1] + 1, size=dims
-        )
+        ).astype(np.float32)
         packed_data = helper.pack_float32_to_4bit(
             data, signed=(dtype == TensorProto.INT4)
         )
@@ -993,6 +1044,16 @@ class TestAttrTypeToStr(unittest.TestCase):
         result = helper._attr_type_to_str(9999)
         self.assertEqual(result, "UNDEFINED")
 
+    def test_custom_types(self):
+        def _get(name):
+            if hasattr(_custom_element_types, name):
+                return getattr(_custom_element_types, name)
+            name = f"float8{name}"
+            return getattr(_custom_element_types, name)
+
+        for k, v in _custom_element_types.mapping_name_to_data_type.items():
+            self.assertEqual(helper.np_dtype_to_tensor_dtype(_get(k)), v)
+
 
 if __name__ == "__main__":
     unittest.main()

onnx/test/hub_test.py

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

onnx/test/inference_function_test.py

@@ -1,9 +1,9 @@
 # SPDX-License-Identifier: Apache-2.0
 
 # Copyright (c) ONNX Project Contributors
+from __future__ import annotations
 
 import unittest
-from typing import Dict, List, Optional, Tuple, Union
 
 import numpy as np
 
@@ -33,21 +33,25 @@ RESHAPE_SCHEMA = max(
     ),
     key=lambda s: s.since_version,
 )
+CLIP_SCHEMA = max(
+    (s for s in get_all_schemas_with_history() if s.name == "Clip" and s.domain == ""),
+    key=lambda s: s.since_version,
+)
 
 
 def _to_tensor_types(
-    tensor_types: Dict[str, Tuple[int, Tuple[Union[int, str, None], ...]]]
-) -> Dict[str, TypeProto]:
+    tensor_types: dict[str, tuple[int, tuple[int | str | None, ...]]]
+) -> dict[str, TypeProto]:
     return {key: make_tensor_type_proto(*value) for key, value in tensor_types.items()}
 
 
 def _run_case(
     schema: OpSchema,
-    input_names: List[str],
-    output_names: List[str],
-    input_types: Dict[str, TypeProto],
-    input_data: Optional[Dict[str, np.ndarray]] = None,
-) -> Dict[str, TypeProto]:
+    input_names: list[str],
+    output_names: list[str],
+    input_types: dict[str, TypeProto],
+    input_data: dict[str, np.ndarray] | None = None,
+) -> dict[str, TypeProto]:
     if input_data is None:
         input_data = {}
     return infer_node_outputs(
@@ -97,6 +101,19 @@ class TestInferenceFunctionCall(unittest.TestCase):
         for ins, outs in cases:
             assert _run_case(ADD_SCHEMA, ["A", "B"], ["C"], _to_tensor_types(ins)) == _to_tensor_types(outs)  # type: ignore
 
+    def test_clip_inference_with_optional_input(self) -> None:
+        # Test case where the second input is optional
+        input_names = ["X", "", "max"]
+        output_names = ["Y"]
+        input_types = _to_tensor_types(
+            {"X": (TensorProto.FLOAT, (3, 4)), "max": (TensorProto.FLOAT, ())}
+        )
+        expected_output_types = _to_tensor_types({"Y": (TensorProto.FLOAT, (3, 4))})
+        assert (
+            _run_case(CLIP_SCHEMA, input_names, output_names, input_types)
+            == expected_output_types
+        )
+
     def test_add_inference_raises_errors(self) -> None:
         with self.assertRaises(ValidationError):
             _run_case(

onnx/test/inliner_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 inliner, parser

onnx/test/model_container_refeval_test.py

@@ -1,6 +1,7 @@
 # Copyright (c) ONNX Project Contributors
 #
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import os
 import tempfile
@@ -96,7 +97,7 @@ class TestLargeOnnxReferenceEvaluator(unittest.TestCase):
             ],
             dtype=np.float32,
         )
-        npt.assert_allclose(expected, got[0])
+        npt.assert_allclose(expected, got[0])  # type: ignore[index]
 
     def test_large_onnx_no_large_initializer(self):
         model_proto = _linear_regression()

onnx/test/model_container_test.py

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

onnx/test/model_inference_test.py

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

onnx/test/numpy_helper_test.py

@@ -1,6 +1,7 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import unittest
 from typing import Any
@@ -9,6 +10,7 @@ import numpy as np
 import parameterized
 
 import onnx
+import onnx.reference
 from onnx import helper, numpy_helper
 
 
@@ -596,6 +598,59 @@ class TestNumpyHelper(unittest.TestCase):
             # Differing value types should raise a TypeError
             numpy_helper.from_dict({0: np.array(1), 1: np.array(0.9)})
 
+    def _to_array_from_array(self, value: int, check_dtype: bool = True):
+        onnx_model = helper.make_model(
+            helper.make_graph(
+                [helper.make_node("Cast", ["X"], ["Y"], to=value)],
+                "test",
+                [helper.make_tensor_value_info("X", onnx.TensorProto.FLOAT, [4])],
+                [helper.make_tensor_value_info("Y", value, [4])],
+            )
+        )
+        ref = onnx.reference.ReferenceEvaluator(onnx_model)
+        start = ref.run(None, {"X": np.array([0, 1, -2, 3], dtype=np.float32)})
+        tp = numpy_helper.from_array(start[0], name="check")
+        self.assertEqual(tp.data_type, value)
+        back = numpy_helper.to_array(tp)
+        self.assertEqual(start[0].shape, back.shape)
+        if check_dtype:
+            self.assertEqual(start[0].dtype, back.dtype)
+        again = numpy_helper.from_array(back, name="check")
+        self.assertEqual(tp.data_type, again.data_type)
+        self.assertEqual(tp.name, again.name)
+        self.assertEqual(len(tp.raw_data), len(again.raw_data))
+        self.assertEqual(list(tp.raw_data), list(again.raw_data))
+        self.assertEqual(tp.raw_data, again.raw_data)
+        self.assertEqual(tuple(tp.dims), tuple(again.dims))
+        self.assertEqual(tp.SerializeToString(), again.SerializeToString())
+        self.assertEqual(tp.data_type, helper.np_dtype_to_tensor_dtype(back.dtype))
+
+    @parameterized.parameterized.expand([(att,) for att in dir(onnx.TensorProto)])
+    def test_to_array_from_array(self, att):
+        if att in {
+            "INT4",
+            "UINT4",
+            "STRING",
+            "UNDEFINED",
+            "DEFAULT",
+            "NAME_FIELD_NUMBER",
+        }:
+            return
+        if att[0] < "A" or att[0] > "Z":
+            return
+        value = getattr(onnx.TensorProto, att)
+        if not isinstance(value, int):
+            return
+
+        self._to_array_from_array(value)
+
+    def test_to_array_from_array_subtype(self):
+        self._to_array_from_array(onnx.TensorProto.INT4)
+        self._to_array_from_array(onnx.TensorProto.UINT4)
+
+    def test_to_array_from_array_string(self):
+        self._to_array_from_array(onnx.TensorProto.STRING, False)
+
 
 if __name__ == "__main__":
-    unittest.main()
+    unittest.main(verbosity=2)

onnx/test/parser_test.py

@@ -1,12 +1,14 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
 import unittest
 
 from parameterized import parameterized
 
 import onnx
-from onnx import GraphProto, OperatorSetIdProto, checker
+from onnx import GraphProto, OperatorSetIdProto, TensorProto, checker
 
 
 class TestBasicFunctions(unittest.TestCase):
@@ -266,6 +268,50 @@ class TestBasicFunctions(unittest.TestCase):
                 str(model.graph.node[0].attribute[0].f), str(float(test_literal))
             )
 
+    @parameterized.expand(
+        [
+            ("bfloat16", TensorProto.BFLOAT16),
+            ("bool", TensorProto.BOOL),
+            ("complex64", TensorProto.COMPLEX64),
+            ("complex128", TensorProto.COMPLEX128),
+            ("double", TensorProto.DOUBLE),
+            ("float16", TensorProto.FLOAT16),
+            ("float", TensorProto.FLOAT),
+            ("float8e4m3fn", TensorProto.FLOAT8E4M3FN),
+            ("float8e4m3fnuz", TensorProto.FLOAT8E4M3FNUZ),
+            ("float8e5m2", TensorProto.FLOAT8E5M2),
+            ("float8e5m2fnuz", TensorProto.FLOAT8E5M2FNUZ),
+            ("int4", TensorProto.INT4),
+            ("int8", TensorProto.INT8),
+            ("int16", TensorProto.INT16),
+            ("int32", TensorProto.INT32),
+            ("int64", TensorProto.INT64),
+            ("string", TensorProto.STRING),
+            ("uint4", TensorProto.UINT4),
+            ("uint8", TensorProto.UINT8),
+            ("uint16", TensorProto.UINT16),
+            ("uint32", TensorProto.UINT32),
+            ("uint64", TensorProto.UINT64),
+        ]
+    )
+    def test_parse_graph_types(self, name, itype) -> None:
+        w = '{"0"}' if itype == TensorProto.STRING else "{0}"
+        text_graph = f"""
+           <
+             ir_version: 10,
+             opset_import: [ "" : 19]
+           >
+           agraph (float[N] X) => ({name}[N] C)
+           <
+             {name}[1] weight = {w}
+           >
+           {{
+              C = Cast<to={itype}>(X)
+           }}
+           """
+        graph = onnx.parser.parse_model(text_graph)
+        self.assertEqual(len(graph.graph.node), 1)
+
 
 if __name__ == "__main__":
-    unittest.main()
+    unittest.main(verbosity=2)

onnx/test/printer_test.py

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

onnx/test/reference_evaluator_ml_test.py

@@ -2,7 +2,7 @@
 
 # SPDX-License-Identifier: Apache-2.0
 # type: ignore
-
+from __future__ import annotations
 
 import itertools
 import unittest
@@ -52,10 +52,9 @@ def has_onnxruntime():
         import onnxruntime
 
         del onnxruntime
-
-        return True
     except ImportError:
         return False
+    return True
 
 
 def skip_if_no_onnxruntime(fn):

onnx/test/reference_evaluator_model_test.py

@@ -2,6 +2,8 @@
 
 # SPDX-License-Identifier: Apache-2.0
 # type: ignore
+from __future__ import annotations
+
 import unittest
 
 import numpy as np