onnx 1.17.0__cp310-cp310-win32.whl → 1.18.0__cp310-cp310-win32.whl

onnx/test/helper_test.py

@@ -6,14 +6,14 @@ from __future__ import annotations
 import itertools
 import math
 import random
-import struct
 import unittest
 from typing import Any
 
+import ml_dtypes
 import numpy as np
+import numpy.typing as npt
 import parameterized
 import pytest
-import version_utils
 
 from onnx import (
     AttributeProto,
@@ -29,8 +29,19 @@ from onnx import (
     helper,
     numpy_helper,
 )
-from onnx.reference.op_run import to_array_extended
-from onnx.reference.ops.op_cast import Cast_19 as Cast
+
+
+def _pack_4bit(array: np.ndarray) -> npt.NDArray[np.uint8]:
+    """Convert a numpy array to flatten, packed int4/uint4. Elements must be in the correct range."""
+    # Create a 1D copy
+    array_flat = array.ravel().view(np.uint8).copy()
+    size = array.size
+    odd_sized = size % 2 == 1
+    if odd_sized:
+        array_flat.resize([size + 1], refcheck=False)
+    array_flat &= 0x0F
+    array_flat[1::2] <<= 4
+    return array_flat[0::2] | array_flat[1::2]
 
 
 class TestHelperAttributeFunctions(unittest.TestCase):
@@ -411,6 +422,7 @@ class TestHelperNodeFunctions(unittest.TestCase):
         test([("", 20)], 9)
         test([("", 21)], 10)
         test([("", 22)], 10)
+        test([("", 23)], 11)
         # standard opset can be referred to using empty-string or "ai.onnx"
         test([("ai.onnx", 9)], 4)
         test([("ai.onnx.ml", 2)], 6)
@@ -435,10 +447,6 @@ 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(
@@ -451,34 +459,6 @@ class TestHelperTensorFunctions(unittest.TestCase):
             ],
             dtype=np.float32,
         )
-        np_results = np.array(
-            [
-                [
-                    struct.unpack("!f", bytes.fromhex("3F800000"))[0],  # 1.0
-                    struct.unpack("!f", bytes.fromhex("40000000"))[0],
-                ],  # 2.0
-                [
-                    struct.unpack("!f", bytes.fromhex("40400000"))[0],  # 3.0
-                    struct.unpack("!f", bytes.fromhex("40800000"))[0],
-                ],  # 4.0
-                [
-                    struct.unpack("!f", bytes.fromhex("3DCC0000"))[
-                        0
-                    ],  # round-to-nearest-even rounds down (0x8000)
-                    struct.unpack("!f", bytes.fromhex("3DCC0000"))[0],
-                ],  # round-to-nearest-even rounds up   (0x8000)
-                [
-                    struct.unpack("!f", bytes.fromhex("3DCC0000"))[
-                        0
-                    ],  # round-to-nearest-even rounds down (0x7fff)
-                    struct.unpack("!f", bytes.fromhex("3DCD0000"))[0],
-                ],  # round-to-nearest-even rounds up   (0xCCCD)
-                [
-                    struct.unpack("!f", bytes.fromhex("7FC00000"))[0],  # NaN
-                    struct.unpack("!f", bytes.fromhex("7F800000"))[0],
-                ],  # inf
-            ]
-        )
 
         tensor = helper.make_tensor(
             name="test",
@@ -488,8 +468,8 @@ class TestHelperTensorFunctions(unittest.TestCase):
         )
         self.assertEqual(tensor.name, "test")
         np.testing.assert_equal(
-            Cast.eval(np_results, to=TensorProto.BFLOAT16),  # type: ignore[arg-type]
-            numpy_helper.to_array(tensor),
+            numpy_helper.to_array(tensor).view(np.uint16),
+            np_array.astype(ml_dtypes.bfloat16).view(np.uint16),
         )
 
     def test_make_float8e4m3fn_tensor(self) -> None:
@@ -497,8 +477,8 @@ class TestHelperTensorFunctions(unittest.TestCase):
             "zero_point", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 50000, 10.1]
         )
         ynp = numpy_helper.to_array(y)
-        expected = np.array([0, 0.5, 1, 448, 10], dtype=np.float32)
-        np.testing.assert_equal(Cast.eval(expected, to=TensorProto.FLOAT8E4M3FN), ynp)  # type: ignore[arg-type]
+        expected = np.array([0, 0.5, 1, 448, 10], dtype=ml_dtypes.float8_e4m3fn)
+        np.testing.assert_equal(ynp.view(np.uint8), expected.view(np.uint8))
 
     def test_make_float8e4m3fnuz_tensor(self) -> None:
         y = helper.make_tensor(
@@ -508,16 +488,16 @@ class TestHelperTensorFunctions(unittest.TestCase):
             [0, 0.5, 1, 50000, 10.1, -0.00001, 0.00001],
         )
         ynp = numpy_helper.to_array(y)
-        expected = np.array([0, 0.5, 1, 240, 10, 0, 0], dtype=np.float32)
-        np.testing.assert_equal(Cast.eval(expected, to=TensorProto.FLOAT8E4M3FNUZ), ynp)  # type: ignore[arg-type]
+        expected = np.array([0, 0.5, 1, 240, 10, 0, 0], dtype=ml_dtypes.float8_e4m3fnuz)
+        np.testing.assert_equal(ynp.view(np.uint8), expected.view(np.uint8))
 
     def test_make_float8e5m2_tensor(self) -> None:
         y = helper.make_tensor(
             "zero_point", TensorProto.FLOAT8E5M2, [5], [0, 0.5, 1, 50000, 96]
         )
         ynp = numpy_helper.to_array(y)
-        expected = np.array([0, 0.5, 1, 49152, 96], dtype=np.float32)
-        np.testing.assert_equal(Cast.eval(expected, to=TensorProto.FLOAT8E5M2), ynp)  # type: ignore[arg-type]
+        expected = np.array([0, 0.5, 1, 49152, 96], dtype=ml_dtypes.float8_e5m2)
+        np.testing.assert_equal(ynp.view(np.uint8), expected.view(np.uint8))
 
     def test_make_float8e5m2fnuz_tensor(self) -> None:
         y = helper.make_tensor(
@@ -527,16 +507,13 @@ class TestHelperTensorFunctions(unittest.TestCase):
             [0, 0.5, 1, 50000, 96, -0.0000001, 0.0000001],
         )
         ynp = numpy_helper.to_array(y)
-        expected = np.array([0, 0.5, 1, 49152, 96, 0, 0], dtype=np.float32)
-        np.testing.assert_equal(Cast.eval(expected, to=TensorProto.FLOAT8E5M2FNUZ), ynp)  # type: ignore[arg-type]
+        expected = np.array(
+            [0, 0.5, 1, 49152, 96, 0, 0], dtype=ml_dtypes.float8_e5m2fnuz
+        )
+        np.testing.assert_equal(ynp.view(np.uint8), expected.view(np.uint8))
 
-    @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(
+        array = np.array(
             [
                 [1.0, 2.0],
                 [3.0, 4.0],
@@ -544,52 +521,17 @@ class TestHelperTensorFunctions(unittest.TestCase):
                 [0.0998535081744, 0.1],
                 [np.nan, np.inf],
             ],
-            dtype=np.float32,
-        )
-        np_results = np.array(
-            [
-                [
-                    struct.unpack("!f", bytes.fromhex("3F800000"))[0],  # 1.0
-                    struct.unpack("!f", bytes.fromhex("40000000"))[0],
-                ],  # 2.0
-                [
-                    struct.unpack("!f", bytes.fromhex("40400000"))[0],  # 3.0
-                    struct.unpack("!f", bytes.fromhex("40800000"))[0],
-                ],  # 4.0
-                [
-                    struct.unpack("!f", bytes.fromhex("3DCC0000"))[0],  # truncated
-                    struct.unpack("!f", bytes.fromhex("3DCB0000"))[0],
-                ],  # truncated
-                [
-                    struct.unpack("!f", bytes.fromhex("3DCC0000"))[0],  # truncated
-                    struct.unpack("!f", bytes.fromhex("3DCC0000"))[0],
-                ],  # truncated
-                [
-                    struct.unpack("!f", bytes.fromhex("7FC00000"))[0],  # NaN
-                    struct.unpack("!f", bytes.fromhex("7F800000"))[0],
-                ],  # inf
-            ]
-        )
+            dtype=ml_dtypes.bfloat16,
+        ).view(np.uint16)
 
-        # write out 16-bit of fp32 to create bf16 using truncation, no rounding
-        def truncate(x):
-            return x >> 16
-
-        values_as_ints = np_array.astype(np.float32).view(np.uint32).flatten()
-        packed_values = truncate(values_as_ints).astype(np.uint16).tobytes()
         tensor = helper.make_tensor(
             name="test",
             data_type=TensorProto.BFLOAT16,
-            dims=np_array.shape,
-            vals=packed_values,
+            dims=array.shape,
+            vals=array.tobytes(),
             raw=True,
         )
-        self.assertEqual(tensor.name, "test")
-        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
-        )
+        np.testing.assert_allclose(numpy_helper.to_array(tensor).view(np.uint16), array)
 
     def test_make_float8e4m3fn_tensor_raw(self) -> None:
         expected = np.array([0, 0.5, 1, 448, 10], dtype=np.float32)
@@ -605,7 +547,9 @@ class TestHelperTensorFunctions(unittest.TestCase):
             raw=True,
         )
         ynp = numpy_helper.to_array(y)
-        np.testing.assert_equal(Cast.eval(expected, to=TensorProto.FLOAT8E4M3FN), ynp)  # type: ignore[arg-type]
+        np.testing.assert_equal(
+            ynp.view(np.uint8), expected.astype(ml_dtypes.float8_e4m3fn).view(np.uint8)
+        )
 
     def test_make_float8e4m3fnuz_tensor_raw(self) -> None:
         expected = np.array([0, 0.5, 1, 240, 10], dtype=np.float32)
@@ -621,7 +565,10 @@ class TestHelperTensorFunctions(unittest.TestCase):
             raw=True,
         )
         ynp = numpy_helper.to_array(y)
-        np.testing.assert_equal(Cast.eval(expected, to=TensorProto.FLOAT8E4M3FNUZ), ynp)  # type: ignore[arg-type]
+        np.testing.assert_equal(
+            ynp.view(np.uint8),
+            expected.astype(ml_dtypes.float8_e4m3fnuz).view(np.uint8),
+        )
 
     def test_make_float8e5m2_tensor_raw(self) -> None:
         expected = np.array([0, 0.5, 1, 49152, 10], dtype=np.float32)
@@ -637,7 +584,9 @@ class TestHelperTensorFunctions(unittest.TestCase):
             raw=True,
         )
         ynp = numpy_helper.to_array(y)
-        np.testing.assert_equal(Cast.eval(expected, to=TensorProto.FLOAT8E5M2), ynp)  # type: ignore[arg-type]
+        np.testing.assert_equal(
+            ynp.view(np.uint8), expected.astype(ml_dtypes.float8_e5m2).view(np.uint8)
+        )
 
     def test_make_float8e5m2fnuz_tensor_raw(self) -> None:
         expected = np.array([0, 0.5, 1, 49152, 10], dtype=np.float32)
@@ -654,7 +603,10 @@ class TestHelperTensorFunctions(unittest.TestCase):
             raw=True,
         )
         ynp = numpy_helper.to_array(y)
-        np.testing.assert_equal(Cast.eval(expected, to=TensorProto.FLOAT8E5M2FNUZ), ynp)  # type: ignore[arg-type]
+        np.testing.assert_equal(
+            ynp.view(np.uint8),
+            expected.astype(ml_dtypes.float8_e5m2fnuz).view(np.uint8),
+        )
 
     @parameterized.parameterized.expand(
         itertools.product(
@@ -662,10 +614,6 @@ class TestHelperTensorFunctions(unittest.TestCase):
             ((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_make_4bit_tensor(self, dtype, dims) -> None:
         type_range = {
             TensorProto.UINT4: (0, 15),
@@ -682,18 +630,14 @@ class TestHelperTensorFunctions(unittest.TestCase):
         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)
+        ynp = numpy_helper.to_array(y)
+        np.testing.assert_equal(ynp, data)
 
     @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.
@@ -711,10 +655,6 @@ class TestHelperTensorFunctions(unittest.TestCase):
             (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),
@@ -722,16 +662,41 @@ 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)
-        )
+        ).astype(np.uint8)
+        packed_data = _pack_4bit(data)
 
         y = helper.make_tensor(
             "packed_int4", dtype, dims, packed_data.tobytes(), raw=True
         )
         ynp = numpy_helper.to_array(y)
-        np.testing.assert_equal(data, ynp)
+        np.testing.assert_equal(ynp.view(np.uint8), data)
+
+    def test_make_float4e2m1_raw_tensor(self) -> None:
+        data = np.array([0, 0.5, 1, 240, 10, -2], dtype=ml_dtypes.float4_e2m1fn)
+        expected = data.view(np.uint8)
+        packed_data = _pack_4bit(expected)
+        y = helper.make_tensor(
+            "packed_fp4e2m1",
+            TensorProto.FLOAT4E2M1,
+            data.shape,
+            packed_data.tobytes(),
+            raw=True,
+        )
+        ynp = numpy_helper.to_array(y)
+        np.testing.assert_equal(ynp.view(np.uint8), expected)
+
+    def test_make_float4e2m1_tensor(self) -> None:
+        y = helper.make_tensor(
+            "zero_point",
+            TensorProto.FLOAT4E2M1,
+            [7],
+            [0, 0.5, 1, 50000, -0.6, -100, -5],
+        )
+        ynp = numpy_helper.to_array(y)
+        expected = np.array(
+            [0, 0.5, 1, 6, -0.5, -6, -4], dtype=ml_dtypes.float4_e2m1fn
+        ).view(np.uint8)
+        np.testing.assert_equal(ynp, expected)
 
     def test_make_sparse_tensor(self) -> None:
         values = [1.1, 2.2, 3.3, 4.4, 5.5]
@@ -932,6 +897,7 @@ class TestPrintableGraph(unittest.TestCase):
             TensorProto.STRING,
             TensorProto.COMPLEX64,
             TensorProto.COMPLEX128,
+            TensorProto.FLOAT4E2M1,
         }
     ],
     ids=lambda tensor_dtype: helper.tensor_dtype_to_string(tensor_dtype),
@@ -961,6 +927,7 @@ def test_make_tensor_vals(tensor_dtype: int) -> None:
             TensorProto.FLOAT8E5M2FNUZ,
             TensorProto.UINT4,
             TensorProto.INT4,
+            TensorProto.FLOAT4E2M1,
         }
     ],
     ids=lambda tensor_dtype: helper.tensor_dtype_to_string(tensor_dtype),
@@ -1020,20 +987,20 @@ class TestHelperMappingFunctions(unittest.TestCase):
 class TestAttrTypeToStr(unittest.TestCase):
     @parameterized.parameterized.expand(
         [
-            (AttributeProto.AttributeType.FLOAT, "FLOAT"),  # type: ignore[attr-defined]
-            (AttributeProto.AttributeType.INT, "INT"),  # type: ignore[attr-defined]
-            (AttributeProto.AttributeType.STRING, "STRING"),  # type: ignore[attr-defined]
-            (AttributeProto.AttributeType.TENSOR, "TENSOR"),  # type: ignore[attr-defined]
-            (AttributeProto.AttributeType.GRAPH, "GRAPH"),  # type: ignore[attr-defined]
-            (AttributeProto.AttributeType.SPARSE_TENSOR, "SPARSE_TENSOR"),  # type: ignore[attr-defined]
-            (AttributeProto.AttributeType.TYPE_PROTO, "TYPE_PROTO"),  # type: ignore[attr-defined]
-            (AttributeProto.AttributeType.FLOATS, "FLOATS"),  # type: ignore[attr-defined]
-            (AttributeProto.AttributeType.INTS, "INTS"),  # type: ignore[attr-defined]
-            (AttributeProto.AttributeType.STRINGS, "STRINGS"),  # type: ignore[attr-defined]
-            (AttributeProto.AttributeType.TENSORS, "TENSORS"),  # type: ignore[attr-defined]
-            (AttributeProto.AttributeType.GRAPHS, "GRAPHS"),  # type: ignore[attr-defined]
-            (AttributeProto.AttributeType.SPARSE_TENSORS, "SPARSE_TENSORS"),  # type: ignore[attr-defined]
-            (AttributeProto.AttributeType.TYPE_PROTOS, "TYPE_PROTOS"),  # type: ignore[attr-defined]
+            (AttributeProto.AttributeType.FLOAT, "FLOAT"),
+            (AttributeProto.AttributeType.INT, "INT"),
+            (AttributeProto.AttributeType.STRING, "STRING"),
+            (AttributeProto.AttributeType.TENSOR, "TENSOR"),
+            (AttributeProto.AttributeType.GRAPH, "GRAPH"),
+            (AttributeProto.AttributeType.SPARSE_TENSOR, "SPARSE_TENSOR"),
+            (AttributeProto.AttributeType.TYPE_PROTO, "TYPE_PROTO"),
+            (AttributeProto.AttributeType.FLOATS, "FLOATS"),
+            (AttributeProto.AttributeType.INTS, "INTS"),
+            (AttributeProto.AttributeType.STRINGS, "STRINGS"),
+            (AttributeProto.AttributeType.TENSORS, "TENSORS"),
+            (AttributeProto.AttributeType.GRAPHS, "GRAPHS"),
+            (AttributeProto.AttributeType.SPARSE_TENSORS, "SPARSE_TENSORS"),
+            (AttributeProto.AttributeType.TYPE_PROTOS, "TYPE_PROTOS"),
         ]
     )
     def test_attr_type_to_str(self, attr_type, expected_str):

onnx/test/inference_function_test.py

@@ -40,7 +40,7 @@ CLIP_SCHEMA = max(
 
 
 def _to_tensor_types(
-    tensor_types: dict[str, tuple[int, tuple[int | str | None, ...]]]
+    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()}
 
@@ -99,7 +99,12 @@ 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
+            assert _run_case(
+                ADD_SCHEMA,
+                ["A", "B"],
+                ["C"],
+                _to_tensor_types(ins),  # type: ignore[arg-type]
+            ) == _to_tensor_types(outs)  # type: ignore[arg-type]
 
     def test_clip_inference_with_optional_input(self) -> None:
         # Test case where the second input is optional

onnx/test/model_container_test.py

@@ -125,7 +125,7 @@ class TestLargeOnnx(unittest.TestCase):
                 if ext_data.uses_external_data(tensor):
                     tested = 0
                     for ext in tensor.external_data:
-                        if ext.key == "location":  # type: ignore[attr-defined]
+                        if ext.key == "location":
                             assert os.path.exists(ext.value)
                             tested += 1
                     self.assertEqual(tested, 1)

onnx/test/numpy_helper_test.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 import unittest
 from typing import Any
 
+import ml_dtypes
 import numpy as np
 import parameterized
 
@@ -15,17 +16,7 @@ from onnx import helper, numpy_helper
 
 
 def bfloat16_to_float32(ival: int) -> Any:
-    if ival == 0x7FC0:
-        return np.float32(np.nan)
-
-    expo = ival >> 7
-    prec = ival - (expo << 7)
-    sign = expo & 256
-    powe = expo & 255
-    fval = float(prec * 2 ** (-7) + 1) * 2.0 ** (powe - 127)
-    if sign:
-        fval = -fval
-    return np.float32(fval)
+    return np.int16(ival).view(ml_dtypes.bfloat16).astype(np.float32)
 
 
 def float8e4m3_to_float32(ival: int) -> Any:
@@ -625,28 +616,34 @@ class TestNumpyHelper(unittest.TestCase):
         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)
+    @parameterized.parameterized.expand(
+        [
+            ("FLOAT", onnx.TensorProto.FLOAT),
+            ("UINT8", onnx.TensorProto.UINT8),
+            ("INT8", onnx.TensorProto.INT8),
+            ("UINT16", onnx.TensorProto.UINT16),
+            ("INT16", onnx.TensorProto.INT16),
+            ("INT32", onnx.TensorProto.INT32),
+            ("INT64", onnx.TensorProto.INT64),
+            ("BOOL", onnx.TensorProto.BOOL),
+            ("FLOAT16", onnx.TensorProto.FLOAT16),
+            ("DOUBLE", onnx.TensorProto.DOUBLE),
+            ("UINT32", onnx.TensorProto.UINT32),
+            ("UINT64", onnx.TensorProto.UINT64),
+            ("COMPLEX64", onnx.TensorProto.COMPLEX64),
+            ("COMPLEX128", onnx.TensorProto.COMPLEX128),
+            ("BFLOAT16", onnx.TensorProto.BFLOAT16),
+            ("FLOAT8E4M3FN", onnx.TensorProto.FLOAT8E4M3FN),
+            ("FLOAT8E4M3FNUZ", onnx.TensorProto.FLOAT8E4M3FNUZ),
+            ("FLOAT8E5M2", onnx.TensorProto.FLOAT8E5M2),
+            ("FLOAT8E5M2FNUZ", onnx.TensorProto.FLOAT8E5M2FNUZ),
+            ("UINT4", onnx.TensorProto.UINT4),
+            ("INT4", onnx.TensorProto.INT4),
+            ("FLOAT4E2M1", onnx.TensorProto.FLOAT4E2M1),
+        ]
+    )
+    def test_to_array_from_array(self, _: str, data_type: onnx.TensorProto.DataType):
+        self._to_array_from_array(data_type)
 
     def test_to_array_from_array_string(self):
         self._to_array_from_array(onnx.TensorProto.STRING, False)

onnx/test/parser_test.py

@@ -220,6 +220,28 @@ class TestBasicFunctions(unittest.TestCase):
         self.assertEqual(node.domain, "SomeDomain")
         self.assertEqual(node.op_type, "SomeOp")
 
+    def test_missing_identifier(self):
+        node = onnx.parser.parse_node("= SomeOp ()")
+        self.assertEqual(list(node.input), [])
+        self.assertEqual(list(node.output), [])
+        node = onnx.parser.parse_node(", = SomeOp (,)")
+        self.assertEqual(list(node.input), [""])
+        self.assertEqual(list(node.output), [""])
+        node = onnx.parser.parse_node("x, = SomeOp (y,)")
+        self.assertEqual(list(node.input), ["y"])
+        self.assertEqual(list(node.output), ["x"])
+        node = onnx.parser.parse_node(",x = SomeOp (,y)")
+        self.assertEqual(list(node.input), ["", "y"])
+        self.assertEqual(list(node.output), ["", "x"])
+
+    def test_quoted_empty_identifier(self):
+        node = onnx.parser.parse_node('"" = SomeOp ("")')
+        self.assertEqual(list(node.input), [""])
+        self.assertEqual(list(node.output), [""])
+        node = onnx.parser.parse_node('"",x = SomeOp ("",y)')
+        self.assertEqual(list(node.input), ["", "y"])
+        self.assertEqual(list(node.output), ["", "x"])
+
     @parameterized.expand(
         [
             ("not_a_good_float", True),
@@ -292,6 +314,7 @@ class TestBasicFunctions(unittest.TestCase):
             ("uint16", TensorProto.UINT16),
             ("uint32", TensorProto.UINT32),
             ("uint64", TensorProto.UINT64),
+            ("float4e2m1", TensorProto.FLOAT4E2M1),
         ]
     )
     def test_parse_graph_types(self, name, itype) -> None: