onnx 1.17.0__cp310-cp310-win_amd64.whl → 1.19.0__cp310-cp310-win_amd64.whl

onnx/backend/test/case/node/greater.py

@@ -24,6 +24,36 @@ class Greater(Base):
         z = np.greater(x, y)
         expect(node, inputs=[x, y], outputs=[z], name="test_greater")
 
+        x = np.random.randn(3, 4, 5).astype(np.int8)
+        y = np.random.randn(3, 4, 5).astype(np.int8)
+        z = np.greater(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_int8")
+
+        x = np.random.randn(3, 4, 5).astype(np.int16)
+        y = np.random.randn(3, 4, 5).astype(np.int16)
+        z = np.greater(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_int16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        z = np.greater(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_uint8")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        z = np.greater(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_uint16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        z = np.greater(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_uint32")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        z = np.greater(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_uint64")
+
     @staticmethod
     def export_greater_broadcast() -> None:
         node = onnx.helper.make_node(

onnx/backend/test/case/node/greater_equal.py

@@ -24,6 +24,36 @@ class Greater(Base):
         z = np.greater_equal(x, y)
         expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal")
 
+        x = np.random.randn(3, 4, 5).astype(np.int8)
+        y = np.random.randn(3, 4, 5).astype(np.int8)
+        z = np.greater_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_int8")
+
+        x = np.random.randn(3, 4, 5).astype(np.int16)
+        y = np.random.randn(3, 4, 5).astype(np.int16)
+        z = np.greater_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_int16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        z = np.greater_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_uint8")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        z = np.greater_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_uint16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        z = np.greater_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_uint32")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        z = np.greater_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_uint64")
+
     @staticmethod
     def export_greater_broadcast() -> None:
         node = onnx.helper.make_node(

onnx/backend/test/case/node/gru.py

@@ -31,9 +31,9 @@ class GRUHelper:
         self.num_directions = params[W].shape[0]
 
         if self.num_directions == 1:
-            for k in params:
+            for k, v in params.items():
                 if k != X:
-                    params[k] = np.squeeze(params[k], axis=0)
+                    params[k] = np.squeeze(v, axis=0)
 
             hidden_size = params[R].shape[-1]
             batch_size = params[X].shape[1]

onnx/backend/test/case/node/if.py

@@ -10,7 +10,7 @@ from onnx.backend.test.case.base import Base
 from onnx.backend.test.case.node import expect
 
 
-def compute_if_outputs(x, cond):  # type: ignore
+def compute_if_outputs(x, cond):
     if cond:
         return []
     else:

onnx/backend/test/case/node/image_decoder.py

@@ -50,7 +50,7 @@ def _generate_test_data(
     tile_sz: int = 5,
 ) -> tuple[np.ndarray, np.ndarray]:
     try:
-        import PIL.Image
+        import PIL.Image  # noqa: PLC0415
     except ImportError:
         # Since pillow is not installed to generate test data for the ImageDecoder operator
         # directly use the frozen data from _image_decoder_data.py.

onnx/backend/test/case/node/layernormalization.py

@@ -11,7 +11,7 @@ from onnx.backend.test.case.node import expect
 
 
 # Layer normalization's reference implementation
-def _layer_normalization(X, W, B, axis=-1, epsilon=1e-5):  # type: ignore
+def _layer_normalization(X, W, B, axis=-1, epsilon=1e-5):
     X_shape = X.shape
     X_rank = len(X_shape)
     if axis < 0:
@@ -23,7 +23,7 @@ def _layer_normalization(X, W, B, axis=-1, epsilon=1e-5):  # type: ignore
     reduction_shape = X_shape[0:axis] + (1,) * unsqueezed_rank
 
     # Parameter used to convert N-D tensor layer
-    # normalization to equivalent 2-D matirx operations.
+    # normalization to equivalent 2-D matrix operations.
     row_number = 1
     col_number = 1
     for i in range(X_rank):
@@ -59,7 +59,7 @@ def _layer_normalization(X, W, B, axis=-1, epsilon=1e-5):  # type: ignore
     return Y, X_mean, X_inv_std_dev
 
 
-def calculate_normalized_shape(X_shape, axis):  # type: ignore
+def calculate_normalized_shape(X_shape, axis):
     X_rank = len(X_shape)
     if axis < 0:
         axis = axis + X_rank

onnx/backend/test/case/node/less.py

@@ -24,6 +24,36 @@ class Less(Base):
         z = np.less(x, y)
         expect(node, inputs=[x, y], outputs=[z], name="test_less")
 
+        x = np.random.randn(3, 4, 5).astype(np.int8)
+        y = np.random.randn(3, 4, 5).astype(np.int8)
+        z = np.less(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_int8")
+
+        x = np.random.randn(3, 4, 5).astype(np.int16)
+        y = np.random.randn(3, 4, 5).astype(np.int16)
+        z = np.less(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_int16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        z = np.less(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_uint8")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        z = np.less(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_uint16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        z = np.less(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_uint32")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        z = np.less(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_uint64")
+
     @staticmethod
     def export_less_broadcast() -> None:
         node = onnx.helper.make_node(

onnx/backend/test/case/node/less_equal.py

@@ -24,6 +24,36 @@ class Less(Base):
         z = np.less_equal(x, y)
         expect(node, inputs=[x, y], outputs=[z], name="test_less_equal")
 
+        x = np.random.randn(3, 4, 5).astype(np.int8)
+        y = np.random.randn(3, 4, 5).astype(np.int8)
+        z = np.less_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_int8")
+
+        x = np.random.randn(3, 4, 5).astype(np.int16)
+        y = np.random.randn(3, 4, 5).astype(np.int16)
+        z = np.less_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_int16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        z = np.less_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_uint8")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        z = np.less_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_uint16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        z = np.less_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_uint32")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        z = np.less_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_uint64")
+
     @staticmethod
     def export_less_broadcast() -> None:
         node = onnx.helper.make_node(

onnx/backend/test/case/node/loop.py

@@ -12,7 +12,7 @@ from onnx.backend.test.case.base import Base
 from onnx.backend.test.case.node import expect
 
 
-def compute_loop_outputs(x, seq, trip_count):  # type: ignore
+def compute_loop_outputs(x, seq, trip_count):
     for i in range(trip_count):
         if seq is None:
             seq = []

onnx/backend/test/case/node/lpnormalization.py

@@ -0,0 +1,79 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class LpNormalization(Base):
+    @staticmethod
+    def export_l2normalization_axis_0() -> None:
+        node = onnx.helper.make_node(
+            "LpNormalization", inputs=["x"], outputs=["y"], axis=0, p=2
+        )
+        x = np.array(
+            [[[1.0, 2.0, 2.0], [3.0, 4.0, 0.0]], [[0.0, 5.0, 5.0], [6.0, 8.0, 0.0]]],
+            dtype=np.float32,
+        )
+        l2_norm_axis_0 = np.sqrt(np.sum(x**2, axis=0, keepdims=True))
+        y = x / l2_norm_axis_0
+        expect(node, inputs=[x], outputs=[y], name="test_l2normalization_axis_0")
+
+    @staticmethod
+    def export_l2normalization_axis_1() -> None:
+        node = onnx.helper.make_node(
+            "LpNormalization", inputs=["x"], outputs=["y"], axis=1, p=2
+        )
+        x = np.array([[3.0, 4.0], [6.0, 8.0]], dtype=np.float32)
+        l2_norm_axis_1 = np.sqrt(np.sum(x**2, axis=1, keepdims=True))
+        y = x / l2_norm_axis_1
+        expect(node, inputs=[x], outputs=[y], name="test_l2normalization_axis_1")
+
+    @staticmethod
+    def export_l1normalization_axis_0() -> None:
+        node = onnx.helper.make_node(
+            "LpNormalization", inputs=["x"], outputs=["y"], axis=0, p=1
+        )
+        x = np.array([3.0, 4.0], dtype=np.float32)
+        l1_norm_axis_0 = np.sum(abs(x), axis=0, keepdims=True)
+        y = x / l1_norm_axis_0
+        expect(node, inputs=[x], outputs=[y], name="test_l1normalization_axis_0")
+
+    @staticmethod
+    def export_l1normalization_axis_1() -> None:
+        node = onnx.helper.make_node(
+            "LpNormalization", inputs=["x"], outputs=["y"], axis=1, p=1
+        )
+        x = np.array([[3.0, 4.0], [6.0, 8.0]], dtype=np.float32)
+        l1_norm_axis_1 = np.sum(abs(x), axis=1, keepdims=True)
+        y = x / l1_norm_axis_1
+        expect(node, inputs=[x], outputs=[y], name="test_l1normalization_axis_1")
+
+    @staticmethod
+    def export_l1normalization_axis_last() -> None:
+        node = onnx.helper.make_node(
+            "LpNormalization", inputs=["x"], outputs=["y"], axis=-1, p=1
+        )
+        x = np.array(
+            [[[1.0, 2.0, 2.0], [3.0, 4.0, 0.0]], [[0.0, 5.0, 5.0], [6.0, 8.0, 0.0]]],
+            dtype=np.float32,
+        )
+        l1_norm_axis_last = np.sum(abs(x), axis=-1, keepdims=True)
+        y = x / l1_norm_axis_last
+        expect(node, inputs=[x], outputs=[y], name="test_l1normalization_axis_last")
+
+    @staticmethod
+    def export_default() -> None:
+        node = onnx.helper.make_node("LpNormalization", inputs=["x"], outputs=["y"])
+        x = np.array(
+            [[[1.0, 2.0, 2.0], [3.0, 4.0, 0.0]], [[0.0, 5.0, 5.0], [6.0, 8.0, 0.0]]],
+            dtype=np.float32,
+        )
+        lp_norm_default = np.sqrt(np.sum(x**2, axis=-1, keepdims=True))
+        y = x / lp_norm_default
+        expect(node, inputs=[x], outputs=[y], name="test_lpnormalization_default")

onnx/backend/test/case/node/lppool.py

@@ -132,7 +132,9 @@ class LpPool(Base):
             constant_values=0,
         )
         pads = [pad_top, pad_left, pad_bottom, pad_right]
-        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", pads, p=p)
+        y = pool(
+            padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", pads, pads, p=p
+        )
 
         expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_same_upper")
 
@@ -172,7 +174,9 @@ class LpPool(Base):
             constant_values=0,
         )
         pads = [pad_top, pad_left, pad_bottom, pad_right]
-        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", pads, p=p)
+        y = pool(
+            padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", pads, pads, p=p
+        )
 
         expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_same_lower")
 
@@ -197,16 +201,31 @@ class LpPool(Base):
         strides = (1, 1)
         pad_bottom = pad_top = pad_right = pad_left = 2
         pads = [pad_top, pad_left, pad_bottom, pad_right]
-        out_shape, pads = get_output_shape_explicit_padding(
+        out_shape, extra_pads = get_output_shape_explicit_padding(
             pads, x_shape[2:], kernel_shape, strides
         )
         padded = np.pad(
             x,
-            ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+            (
+                (0, 0),
+                (0, 0),
+                (extra_pads[0], extra_pads[2]),
+                (extra_pads[1], extra_pads[3]),
+            ),
             mode="constant",
             constant_values=0,
         )
-        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", pads, p=p)
+        y = pool(
+            padded,
+            x_shape,
+            kernel_shape,
+            strides,
+            out_shape,
+            "LPPOOL",
+            pads_required=extra_pads,
+            pads=pads,
+            p=p,
+        )
 
         expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_pads")
 

onnx/backend/test/case/node/lrn.py

@@ -34,8 +34,8 @@ class LRN(Base):
             square_sum[n, c, h, w] = sum(
                 x[
                     n,
-                    max(0, c - int(math.floor((nsize - 1) / 2))) : min(
-                        5, c + int(math.ceil((nsize - 1) / 2)) + 1
+                    max(0, c - math.floor((nsize - 1) / 2)) : min(
+                        5, c + math.ceil((nsize - 1) / 2) + 1
                     ),
                     h,
                     w,
@@ -58,8 +58,8 @@ class LRN(Base):
             square_sum[n, c, h, w] = sum(
                 x[
                     n,
-                    max(0, c - int(math.floor((nsize - 1) / 2))) : min(
-                        5, c + int(math.ceil((nsize - 1) / 2)) + 1
+                    max(0, c - math.floor((nsize - 1) / 2)) : min(
+                        5, c + math.ceil((nsize - 1) / 2) + 1
                     ),
                     h,
                     w,

onnx/backend/test/case/node/lstm.py

@@ -33,9 +33,9 @@ class LSTMHelper:
         self.num_directions = params[W].shape[0]
 
         if self.num_directions == 1:
-            for k in params:
+            for k, v in params.items():
                 if k != X:
-                    params[k] = np.squeeze(params[k], axis=0)
+                    params[k] = np.squeeze(v, axis=0)
 
             hidden_size = params[R].shape[-1]
             batch_size = params[X].shape[1]

onnx/backend/test/case/node/maxpool.py

@@ -363,7 +363,7 @@ class MaxPool(Base):
             constant_values=np.nan,
         )
         pads = [pad_top, pad_left, pad_bottom, pad_right]
-        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX", pads)
+        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX", pads, pads)
 
         expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_same_upper")
 
@@ -401,7 +401,7 @@ class MaxPool(Base):
             constant_values=np.nan,
         )
         pads = [pad_top, pad_left, pad_bottom, pad_right]
-        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX", pads)
+        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX", pads, pads)
 
         expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_same_lower")
 
@@ -424,7 +424,7 @@ class MaxPool(Base):
         strides = (1, 1)
         pad_bottom = pad_top = pad_right = pad_left = 2
         pads = [pad_top, pad_left, pad_bottom, pad_right]
-        out_shape, pads = get_output_shape_explicit_padding(
+        out_shape, extra_pads = get_output_shape_explicit_padding(
             pads, x_shape[2:], kernel_shape, strides
         )
         padded = np.pad(
@@ -434,7 +434,16 @@ class MaxPool(Base):
             constant_values=np.nan,
         )
 
-        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX", pads)
+        y = pool(
+            padded,
+            x_shape,
+            kernel_shape,
+            strides,
+            out_shape,
+            "MAX",
+            pads_required=extra_pads,
+            pads=pads,
+        )
 
         expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_pads")
 
@@ -653,7 +662,8 @@ class MaxPool(Base):
             strides,
             out_shape,
             "MAX",
-            pads,
+            pads_required=pads,
+            pads=None,
             dilations=dilations,
         )
 
@@ -702,7 +712,8 @@ class MaxPool(Base):
             strides,
             out_shape,
             "MAX",
-            pads,
+            pads_required=pads,
+            pads=None,
             dilations=dilations,
         )
 

onnx/backend/test/case/node/momentum.py

@@ -11,7 +11,7 @@ from onnx.backend.test.case.node import expect
 from onnx.defs import AI_ONNX_PREVIEW_TRAINING_DOMAIN
 
 
-def apply_momentum(r, t, x, g, v, norm_coefficient, alpha, beta):  # type: ignore
+def apply_momentum(r, t, x, g, v, norm_coefficient, alpha, beta):
     # Add gradient of regularization term.
     g_regularized = norm_coefficient * x + g
     # Coefficient of gradient should be 1 at the first iteration.
@@ -23,7 +23,7 @@ def apply_momentum(r, t, x, g, v, norm_coefficient, alpha, beta):  # type: ignor
     return x_new, v_new
 
 
-def apply_nesterov(r, t, x, g, v, norm_coefficient, alpha, beta):  # type: ignore
+def apply_nesterov(r, t, x, g, v, norm_coefficient, alpha, beta):
     # Add gradient of regularization term.
     g_regularized = norm_coefficient * x + g
     # Coefficient of gradient should be 1 at the first iteration.

onnx/backend/test/case/node/mul.py

@@ -29,11 +29,36 @@ class Mul(Base):
         z = x * y
         expect(node, inputs=[x, y], outputs=[z], name="test_mul")
 
+        x = np.random.randint(4, size=(3, 4, 5), dtype=np.int8)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.int8)
+        z = x * y
+        expect(node, inputs=[x, y], outputs=[z], name="test_mul_int8")
+
+        x = np.random.randint(4, size=(3, 4, 5), dtype=np.int16)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.int16)
+        z = x * y
+        expect(node, inputs=[x, y], outputs=[z], name="test_mul_int16")
+
         x = np.random.randint(4, size=(3, 4, 5), dtype=np.uint8)
         y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
         z = x * y
         expect(node, inputs=[x, y], outputs=[z], name="test_mul_uint8")
 
+        x = np.random.randint(4, size=(3, 4, 5), dtype=np.uint16)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        z = x * y
+        expect(node, inputs=[x, y], outputs=[z], name="test_mul_uint16")
+
+        x = np.random.randint(4, size=(3, 4, 5), dtype=np.uint32)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        z = x * y
+        expect(node, inputs=[x, y], outputs=[z], name="test_mul_uint32")
+
+        x = np.random.randint(4, size=(3, 4, 5), dtype=np.uint64)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        z = x * y
+        expect(node, inputs=[x, y], outputs=[z], name="test_mul_uint64")
+
     @staticmethod
     def export_mul_broadcast() -> None:
         node = onnx.helper.make_node(

onnx/backend/test/case/node/negativeloglikelihoodloss.py

@@ -12,7 +12,7 @@ from onnx.backend.test.case.node import expect
 
 def compute_negative_log_likelihood_loss(
     input, target, weight=None, reduction="mean", ignore_index=None
-):  # type: ignore
+):
     input_shape = input.shape
     if len(input_shape) == 1:
         raise RuntimeError("Unsupported shape")

onnx/backend/test/case/node/onehot.py

@@ -10,7 +10,7 @@ from onnx.backend.test.case.base import Base
 from onnx.backend.test.case.node import expect
 
 
-def one_hot(indices, depth, axis=-1, dtype=np.float32):  # type: ignore
+def one_hot(indices, depth, axis=-1, dtype=np.float32):
     """Compute one hot from indices at a specific axis"""
     values = np.asarray(indices)
     rank = len(values.shape)

onnx/backend/test/case/node/pad.py

@@ -10,7 +10,7 @@ from onnx.backend.test.case.base import Base
 from onnx.backend.test.case.node import expect
 
 
-def pad_impl(data, raw_pads, mode, constant_values=0.0, axes=None):  # type: ignore
+def pad_impl(data, raw_pads, mode, constant_values=0.0, axes=None):
     input_rank = data.ndim
     if axes is None:
         axes = list(range(input_rank))

onnx/backend/test/case/node/quantizelinear.py

@@ -234,7 +234,7 @@ class QuantizeLinear(Base):
             "y_zero_point", TensorProto.UINT4, y_scale.shape, np.ones_like(y_scale)
         )
         y = make_tensor(
-            "y", TensorProto.UINT4, x.shape, [1, 2, 3, 5, -1, -1, 3, 4, 4, 5, 5, 11]
+            "y", TensorProto.UINT4, x.shape, [1, 2, 3, 5, 0, 0, 3, 4, 4, 5, 5, 11]
         )
 
         expect(
@@ -276,6 +276,44 @@ class QuantizeLinear(Base):
             name="test_quantizelinear_int4",
         )
 
+    @staticmethod
+    def export_float4e2m1() -> None:
+        node = onnx.helper.make_node(
+            "QuantizeLinear",
+            inputs=["x", "y_scale", "y_zero_point"],
+            outputs=["y"],
+            axis=0,
+        )
+
+        x = np.array(
+            [
+                [0.0, 2.5, 4.8, 8.6],
+                [-30, -20, 6, 9],
+                [-0.0, -2.5, -4.8, -8.6],
+            ]
+        ).astype(np.float32)
+
+        y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32)
+        y_zero_point = make_tensor(
+            "y_zero_point",
+            TensorProto.FLOAT4E2M1,
+            y_scale.shape,
+            np.zeros_like(y_scale),
+        )
+        y = make_tensor(
+            "y",
+            TensorProto.FLOAT4E2M1,
+            x.shape,
+            [0, 1, 2, 4, -6, -6, 2, 3, 0, -0.5, -1, -2],
+        )
+
+        expect(
+            node,
+            inputs=[x, y_scale, y_zero_point],
+            outputs=[y],
+            name="test_quantizelinear_float4e2m1",
+        )
+
     @staticmethod
     def export_blocked_asymmetric() -> None:
         node = onnx.helper.make_node(