onnx 1.18.0__cp313-cp313-macosx_12_0_universal2.whl → 1.19.1rc1__cp313-cp313-macosx_12_0_universal2.whl

onnx/test/numpy_helper_test.py

@@ -4,9 +4,7 @@
 from __future__ import annotations
 
 import unittest
-from typing import Any
 
-import ml_dtypes
 import numpy as np
 import parameterized
 
@@ -15,68 +13,6 @@ import onnx.reference
 from onnx import helper, numpy_helper
 
 
-def bfloat16_to_float32(ival: int) -> Any:
-    return np.int16(ival).view(ml_dtypes.bfloat16).astype(np.float32)
-
-
-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)
@@ -138,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)
@@ -574,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
@@ -637,6 +166,7 @@ class TestNumpyHelper(unittest.TestCase):
             ("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),