onnx 1.17.0__cp311-cp311-macosx_12_0_universal2.whl → 1.19.0__cp311-cp311-macosx_12_0_universal2.whl

onnx/test/numpy_helper_test.py

@@ -4,7 +4,6 @@
 from __future__ import annotations
 
 import unittest
-from typing import Any
 
 import numpy as np
 import parameterized
@@ -14,78 +13,6 @@ import onnx.reference
 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)
-
-
-def float8e4m3_to_float32(ival: int) -> Any:
-    if ival < 0 or ival > 255:
-        raise ValueError(f"{ival} is not a float8.")
-    if ival == 255:
-        return np.float32(-np.nan)
-    if ival == 127:
-        return np.float32(np.nan)
-    if (ival & 0x7F) == 0:
-        return np.float32(0)
-
-    sign = ival & 0x80
-    ival &= 0x7F
-    expo = ival >> 3
-    mant = ival & 0x07
-    powe = expo & 0x0F
-    if expo == 0:
-        powe -= 6
-        fraction = 0
-    else:
-        powe -= 7
-        fraction = 1
-    fval = float(mant / 8 + fraction) * 2.0**powe
-    if sign:
-        fval = -fval
-    return np.float32(fval)
-
-
-def float8e5m2_to_float32(ival: int) -> Any:
-    if ival < 0 or ival > 255:
-        raise ValueError(f"{ival} is not a float8.")
-    if ival in (255, 254, 253):
-        return np.float32(-np.nan)
-    if ival in (127, 126, 125):
-        return np.float32(np.nan)
-    if ival == 252:
-        return -np.float32(np.inf)
-    if ival == 124:
-        return np.float32(np.inf)
-    if (ival & 0x7F) == 0:
-        return np.float32(0)
-
-    sign = ival & 0x80
-    ival &= 0x7F
-    expo = ival >> 2
-    mant = ival & 0x03
-    powe = expo & 0x1F
-    if expo == 0:
-        powe -= 14
-        fraction = 0
-    else:
-        powe -= 15
-        fraction = 1
-    fval = float(mant / 4 + fraction) * 2.0**powe
-    if sign:
-        fval = -fval
-    return np.float32(fval)
-
-
 class TestNumpyHelper(unittest.TestCase):
     def _test_numpy_helper_float_type(self, dtype: np.number) -> None:
         a = np.random.rand(13, 37).astype(dtype)
@@ -147,408 +74,6 @@ class TestNumpyHelper(unittest.TestCase):
     def test_complex128(self) -> None:
         self._test_numpy_helper_float_type(np.complex128)
 
-    @parameterized.parameterized.expand(
-        [
-            (1,),
-            (0.100097656,),
-            (130048,),
-            (1.2993813e-5,),
-            (np.nan,),
-            (np.inf,),
-        ]
-    )
-    def test_bfloat16_to_float32(self, f):
-        f32 = np.float32(f)
-        bf16 = helper.float32_to_bfloat16(f32)
-        assert isinstance(bf16, int)
-        f32_1 = numpy_helper.bfloat16_to_float32(np.array([bf16]))[0]
-        f32_2 = bfloat16_to_float32(bf16)
-        if np.isnan(f32):
-            assert np.isnan(f32_1)
-            assert np.isnan(f32_2)
-        else:
-            self.assertEqual(f32, f32_1)
-            self.assertEqual(f32, f32_2)
-
-    def test_float8e4m3_to_float32(self):
-        self.assertEqual(numpy_helper.float8e4m3_to_float32(int("1111110", 2)), 448)
-        self.assertEqual(numpy_helper.float8e4m3_to_float32(int("1000", 2)), 2 ** (-6))
-        self.assertEqual(numpy_helper.float8e4m3_to_float32(int("1", 2)), 2 ** (-9))
-        self.assertEqual(
-            numpy_helper.float8e4m3_to_float32(int("111", 2)), 0.875 * 2 ** (-6)
-        )
-        for f in [
-            0,
-            1,
-            -1,
-            0.5,
-            -0.5,
-            0.1015625,
-            -0.1015625,
-            2,
-            3,
-            -2,
-            -3,
-            448,
-            2 ** (-6),
-            2 ** (-9),
-            0.875 * 2 ** (-6),
-            np.nan,
-        ]:
-            with self.subTest(f=f):
-                f32 = np.float32(f)
-                f8 = helper.float32_to_float8e4m3(f32)
-                assert isinstance(f8, int)
-                f32_1 = numpy_helper.float8e4m3_to_float32(np.array([f8]))[0]
-                f32_2 = float8e4m3_to_float32(f8)
-                if np.isnan(f32):
-                    assert np.isnan(f32_1)
-                    assert np.isnan(f32_2)
-                else:
-                    self.assertEqual(f32, f32_1)
-                    self.assertEqual(f32, f32_2)
-
-    @parameterized.parameterized.expand(
-        [
-            (0.00439453125, 0.00390625),
-            (0.005859375, 0.005859375),
-            (0.005759375, 0.005859375),
-            (0.0046875, 0.00390625),
-            (0.001953125, 0.001953125),
-            (0.0029296875, 0.00390625),
-            (0.002053125, 0.001953125),
-            (0.00234375, 0.001953125),
-            (0.0087890625, 0.0078125),
-            (0.001171875, 0.001953125),
-            (1.8131605, 1.875),
-        ]
-    )
-    def test_float8e4m3_to_float32_round(self, val, expected):
-        f8 = helper.float32_to_float8e4m3(val)
-        f32 = numpy_helper.float8e4m3_to_float32(f8)
-        self.assertEqual(f32, expected)
-
-    def test_float8e5m2_to_float32(self):
-        self.assertEqual(numpy_helper.float8e5m2_to_float32(int("1111011", 2)), 57344)
-        self.assertEqual(numpy_helper.float8e5m2_to_float32(int("100", 2)), 2 ** (-14))
-        self.assertEqual(
-            numpy_helper.float8e5m2_to_float32(int("11", 2)), 0.75 * 2 ** (-14)
-        )
-        self.assertEqual(numpy_helper.float8e5m2_to_float32(int("1", 2)), 2 ** (-16))
-        self.assertTrue(np.isnan(numpy_helper.float8e5m2_to_float32(int("1111101", 2))))
-        self.assertTrue(np.isnan(numpy_helper.float8e5m2_to_float32(int("1111110", 2))))
-        self.assertTrue(np.isnan(numpy_helper.float8e5m2_to_float32(int("1111111", 2))))
-        self.assertTrue(
-            np.isnan(numpy_helper.float8e5m2_to_float32(int("11111101", 2)))
-        )
-        self.assertTrue(
-            np.isnan(numpy_helper.float8e5m2_to_float32(int("11111110", 2)))
-        )
-        self.assertTrue(
-            np.isnan(numpy_helper.float8e5m2_to_float32(int("11111111", 2)))
-        )
-        self.assertEqual(numpy_helper.float8e5m2_to_float32(int("1111100", 2)), np.inf)
-        self.assertEqual(
-            numpy_helper.float8e5m2_to_float32(int("11111100", 2)), -np.inf
-        )
-        for f in [
-            0,
-            0.0017089844,
-            20480,
-            14,
-            -3584,
-            np.nan,
-        ]:
-            with self.subTest(f=f):
-                f32 = np.float32(f)
-                f8 = helper.float32_to_float8e5m2(f32)
-                assert isinstance(f8, int)
-                f32_1 = numpy_helper.float8e5m2_to_float32(np.array([f8]))[0]
-                f32_2 = float8e5m2_to_float32(f8)
-                if np.isnan(f32):
-                    assert np.isnan(f32_1)
-                    assert np.isnan(f32_2)
-                else:
-                    self.assertEqual(f32, f32_1)
-                    self.assertEqual(f32, f32_2)
-
-    def test_float8_e4m3fn_inf(self):
-        x = np.float32(np.inf)
-        to = helper.float32_to_float8e4m3(x)
-        back = numpy_helper.float8e4m3_to_float32(to)
-        self.assertEqual(back, 448)
-
-        x = np.float32(np.inf)
-        to = helper.float32_to_float8e4m3(x, saturate=False)
-        back = numpy_helper.float8e4m3_to_float32(to)
-        self.assertTrue(np.isnan(back))
-
-        x = np.float32(-np.inf)
-        to = helper.float32_to_float8e4m3(x)
-        self.assertEqual(to & 0x80, 0x80)
-        back = numpy_helper.float8e4m3_to_float32(to)
-        self.assertEqual(back, -448)
-
-        x = np.float32(-np.inf)
-        to = helper.float32_to_float8e4m3(x, saturate=False)
-        self.assertEqual(to & 0x80, 0x80)
-        back = numpy_helper.float8e4m3_to_float32(to)
-        self.assertTrue(np.isnan(back))
-
-    def test_float8_e4m3fnuz_inf(self):
-        x = np.float32(np.inf)
-        to = helper.float32_to_float8e4m3(x, uz=True)
-        back = numpy_helper.float8e4m3_to_float32(to, uz=True)
-        self.assertEqual(back, 240)
-
-        x = np.float32(np.inf)
-        to = helper.float32_to_float8e4m3(x, uz=True, saturate=False)
-        back = numpy_helper.float8e4m3_to_float32(to, uz=True)
-        self.assertTrue(np.isnan(back))
-
-        x = np.float32(-np.inf)
-        to = helper.float32_to_float8e4m3(x, uz=True)
-        back = numpy_helper.float8e4m3_to_float32(to, uz=True)
-        self.assertEqual(back, -240)
-
-        x = np.float32(-np.inf)
-        to = helper.float32_to_float8e4m3(x, uz=True, saturate=False)
-        back = numpy_helper.float8e4m3_to_float32(to, uz=True)
-        self.assertTrue(np.isnan(back))
-
-    def test_float8_e5m2_inf(self):
-        x = np.float32(np.inf)
-        to = helper.float32_to_float8e5m2(x)
-        back = numpy_helper.float8e5m2_to_float32(to)
-        self.assertEqual(back, 57344)
-
-        x = np.float32(np.inf)
-        to = helper.float32_to_float8e5m2(x, saturate=False)
-        back = numpy_helper.float8e5m2_to_float32(to)
-        self.assertTrue(np.isinf(back))
-
-        x = np.float32(-np.inf)
-        to = helper.float32_to_float8e5m2(x)
-        self.assertEqual(to & 0x80, 0x80)
-        back = numpy_helper.float8e5m2_to_float32(to)
-        self.assertEqual(back, -57344)
-
-        x = np.float32(-np.inf)
-        to = helper.float32_to_float8e5m2(x, saturate=False)
-        self.assertEqual(to & 0x80, 0x80)
-        back = numpy_helper.float8e5m2_to_float32(to)
-        self.assertTrue(np.isinf(back))
-        self.assertLess(back, 0)
-
-    def test_float8_e5m2fnuz_inf(self):
-        x = np.float32(np.inf)
-        to = helper.float32_to_float8e5m2(x, fn=True, uz=True)
-        back = numpy_helper.float8e5m2_to_float32(to, fn=True, uz=True)
-        self.assertEqual(back, 57344)
-
-        x = np.float32(np.inf)
-        to = helper.float32_to_float8e5m2(x, fn=True, uz=True, saturate=False)
-        back = numpy_helper.float8e5m2_to_float32(to, fn=True, uz=True)
-        self.assertTrue(np.isnan(back))
-
-        x = np.float32(-np.inf)
-        to = helper.float32_to_float8e5m2(x, fn=True, uz=True)
-        back = numpy_helper.float8e5m2_to_float32(to, fn=True, uz=True)
-        self.assertEqual(back, -57344)
-
-        x = np.float32(-np.inf)
-        to = helper.float32_to_float8e5m2(x, fn=True, uz=True, saturate=False)
-        back = numpy_helper.float8e5m2_to_float32(to, fn=True, uz=True)
-        self.assertTrue(np.isnan(back))
-
-    def test_float8_e4m3fn_out_of_range(self):
-        x = np.float32(1000000)
-        to = helper.float32_to_float8e4m3(x)
-        back = numpy_helper.float8e4m3_to_float32(to)
-        self.assertEqual(back, 448)
-
-        x = np.float32(1000000)
-        to = helper.float32_to_float8e4m3(x, saturate=False)
-        back = numpy_helper.float8e4m3_to_float32(to)
-        self.assertTrue(np.isnan(back))
-
-        x = np.float32(-1000000)
-        to = helper.float32_to_float8e4m3(x)
-        back = numpy_helper.float8e4m3_to_float32(to)
-        self.assertEqual(back, -448)
-
-        x = np.float32(-1000000)
-        to = helper.float32_to_float8e4m3(x, saturate=False)
-        back = numpy_helper.float8e4m3_to_float32(to)
-        self.assertTrue(np.isnan(back))
-
-    def test_float8_e4m3fnuz_out_of_range(self):
-        x = np.float32(1000000)
-        to = helper.float32_to_float8e4m3(x, uz=True)
-        back = numpy_helper.float8e4m3_to_float32(to, uz=True)
-        self.assertEqual(back, 240)
-
-        x = np.float32(1000000)
-        to = helper.float32_to_float8e4m3(x, uz=True, saturate=False)
-        back = numpy_helper.float8e4m3_to_float32(to, uz=True)
-        self.assertTrue(np.isnan(back))
-
-        x = np.float32(-1000000)
-        to = helper.float32_to_float8e4m3(x, uz=True)
-        back = numpy_helper.float8e4m3_to_float32(to, uz=True)
-        self.assertEqual(back, -240)
-
-        x = np.float32(-1000000)
-        to = helper.float32_to_float8e4m3(x, uz=True, saturate=False)
-        back = numpy_helper.float8e4m3_to_float32(to, uz=True)
-        self.assertTrue(np.isnan(back))
-
-    def test_float8_e5m2_out_of_range(self):
-        x = np.float32(1000000)
-        to = helper.float32_to_float8e5m2(x)
-        back = numpy_helper.float8e5m2_to_float32(to)
-        self.assertEqual(back, 57344)
-
-        x = np.float32(1000000)
-        to = helper.float32_to_float8e5m2(x, saturate=False)
-        back = numpy_helper.float8e5m2_to_float32(to)
-        self.assertTrue(np.isinf(back))
-
-        x = np.float32(-1000000)
-        to = helper.float32_to_float8e5m2(x)
-        back = numpy_helper.float8e5m2_to_float32(to)
-        self.assertEqual(back, -57344)
-
-        x = np.float32(-1000000)
-        to = helper.float32_to_float8e5m2(x, saturate=False)
-        back = numpy_helper.float8e5m2_to_float32(to)
-        self.assertTrue(np.isinf(back))
-
-    def test_float8_e5m2fnuz_out_of_range(self):
-        x = np.float32(1000000)
-        to = helper.float32_to_float8e5m2(x, fn=True, uz=True)
-        back = numpy_helper.float8e5m2_to_float32(to, fn=True, uz=True)
-        self.assertEqual(back, 57344)
-
-        x = np.float32(1000000)
-        to = helper.float32_to_float8e5m2(x, fn=True, uz=True, saturate=False)
-        back = numpy_helper.float8e5m2_to_float32(to, fn=True, uz=True)
-        self.assertTrue(np.isnan(back))
-
-        x = np.float32(-1000000)
-        to = helper.float32_to_float8e5m2(x, fn=True, uz=True)
-        back = numpy_helper.float8e5m2_to_float32(to, fn=True, uz=True)
-        self.assertEqual(back, -57344)
-
-        x = np.float32(-1000000)
-        to = helper.float32_to_float8e5m2(x, fn=True, uz=True, saturate=False)
-        back = numpy_helper.float8e5m2_to_float32(to, fn=True, uz=True)
-        self.assertTrue(np.isnan(back))
-
-    def test_float8_e4m3fn_negative_zero(self):
-        x = numpy_helper.float8e5m2_to_float32(0x80)  # -0
-        to = helper.float32_to_float8e4m3(x)
-        self.assertEqual(to, 0x80)
-        back = numpy_helper.float8e4m3_to_float32(to)
-        self.assertEqual(back, 0)
-
-        x = numpy_helper.float8e5m2_to_float32(0x80)  # -0
-        to = helper.float32_to_float8e4m3(x, saturate=False)
-        self.assertEqual(to, 0x80)
-        back = numpy_helper.float8e4m3_to_float32(to)
-        self.assertEqual(back, 0)
-
-    def test_float8_e4m3fnuz_negative_zero(self):
-        x = numpy_helper.float8e5m2_to_float32(0x80)  # -0
-        to = helper.float32_to_float8e4m3(x, uz=True)
-        self.assertEqual(to, 0)
-        back = numpy_helper.float8e4m3_to_float32(to, uz=True)
-        self.assertEqual(back, 0)
-
-        x = numpy_helper.float8e5m2_to_float32(0x80)  # -0
-        to = helper.float32_to_float8e4m3(x, uz=True, saturate=False)
-        back = numpy_helper.float8e4m3_to_float32(to, uz=True)
-        self.assertEqual(back, 0)
-        self.assertEqual(to, 0)
-
-    def test_float8_e5m2_negative_zero(self):
-        x = numpy_helper.float8e5m2_to_float32(0x80)  # -0
-        to = helper.float32_to_float8e5m2(x)
-        self.assertEqual(to, 0x80)
-        back = numpy_helper.float8e4m3_to_float32(to)
-        self.assertEqual(back, 0)
-
-        x = numpy_helper.float8e5m2_to_float32(0x80)  # -0
-        to = helper.float32_to_float8e5m2(x, saturate=False)
-        self.assertEqual(to, 0x80)
-        back = numpy_helper.float8e4m3_to_float32(to)
-        self.assertEqual(back, 0)
-
-    def test_float8_e5m2fnuz_negative_zero(self):
-        x = numpy_helper.float8e5m2_to_float32(0x80)  # -0
-        to = helper.float32_to_float8e5m2(x, fn=True, uz=True)
-        self.assertEqual(to, 0)
-        back = numpy_helper.float8e4m3_to_float32(to, fn=True, uz=True)
-        self.assertEqual(back, 0)
-
-        x = numpy_helper.float8e5m2_to_float32(0x80)  # -0
-        to = helper.float32_to_float8e5m2(x, fn=True, uz=True, saturate=False)
-        self.assertEqual(to, 0)
-        back = numpy_helper.float8e4m3_to_float32(to, fn=True, uz=True)
-        self.assertEqual(back, 0)
-
-    def test_float8_e4m3fn_negative_nan(self):
-        x = numpy_helper.float8e5m2_to_float32(255)  # -nan
-        to = helper.float32_to_float8e4m3(x)
-        self.assertEqual(to, 255)
-        back = numpy_helper.float8e4m3_to_float32(to)
-        self.assertTrue(np.isnan(back))
-
-        x = numpy_helper.float8e5m2_to_float32(255)  # -nan
-        to = helper.float32_to_float8e4m3(x, saturate=False)
-        self.assertEqual(to, 255)
-        back = numpy_helper.float8e4m3_to_float32(to)
-        self.assertTrue(np.isnan(back))
-
-    def test_float8_e4m3fnuz_negative_nan(self):
-        x = numpy_helper.float8e5m2_to_float32(255)  # -nan
-        to = helper.float32_to_float8e4m3(x, uz=True)
-        self.assertEqual(to, 0x80)
-        back = numpy_helper.float8e4m3_to_float32(to, uz=True)
-        self.assertTrue(np.isnan(back))
-
-        x = numpy_helper.float8e5m2_to_float32(255)  # -nan
-        to = helper.float32_to_float8e4m3(x, uz=True, saturate=False)
-        self.assertEqual(to, 0x80)
-        back = numpy_helper.float8e4m3_to_float32(to, uz=True)
-        self.assertTrue(np.isnan(back))
-
-    def test_float8_e5m2_negative_nan(self):
-        x = numpy_helper.float8e5m2_to_float32(255)  # -nan
-        to = helper.float32_to_float8e5m2(x)
-        self.assertEqual(to, 255)
-        back = numpy_helper.float8e4m3_to_float32(to)
-        self.assertTrue(np.isnan(back))
-
-        x = numpy_helper.float8e5m2_to_float32(255)  # -nan
-        to = helper.float32_to_float8e5m2(x, saturate=False)
-        self.assertEqual(to, 255)
-        back = numpy_helper.float8e4m3_to_float32(to)
-        self.assertTrue(np.isnan(back))
-
-    def test_float8_e5m2fnuz_negative_nan(self):
-        x = numpy_helper.float8e5m2_to_float32(255)  # -nan
-        to = helper.float32_to_float8e5m2(x, fn=True, uz=True)
-        self.assertEqual(to, 0x80)
-        back = numpy_helper.float8e4m3_to_float32(to, fn=True, uz=True)
-        self.assertTrue(np.isnan(back))
-
-        x = numpy_helper.float8e5m2_to_float32(255)  # -nan
-        to = helper.float32_to_float8e5m2(x, fn=True, uz=True, saturate=False)
-        self.assertEqual(to, 0x80)
-        back = numpy_helper.float8e4m3_to_float32(to, fn=True, uz=True)
-        self.assertTrue(np.isnan(back))
-
     def test_from_dict_values_are_np_arrays_of_float(self):
         map_proto = numpy_helper.from_dict({0: np.array(0.1), 1: np.array(0.9)})
         self.assertIsInstance(map_proto, onnx.MapProto)
@@ -583,11 +108,6 @@ class TestNumpyHelper(unittest.TestCase):
         self.assertEqual(out_tensor[0], one_array[0])
         self.assertEqual(out_tensor[1], one_array[1])
 
-    def test_from_dict_raises_type_error_when_values_are_not_np_arrays(self):
-        with self.assertRaises(TypeError):
-            # from_dict/from_array expects tensors to be numpy array's or similar.
-            numpy_helper.from_dict({0: 0.1, 1: 0.9})
-
     def test_from_dict_differing_key_types(self):
         with self.assertRaises(TypeError):
             # Differing key types should raise a TypeError
@@ -625,28 +145,35 @@ 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),
+            ("FLOAT8E8M0", onnx.TensorProto.FLOAT8E8M0),
+            ("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: