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

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

@@ -287,7 +287,16 @@ class AveragePool(Base):
             constant_values=np.nan,
         )
         pads = (pad_top, pad_left, pad_bottom, pad_right)
-        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "AVG", pads)
+        y = pool(
+            padded,
+            x_shape,
+            kernel_shape,
+            strides,
+            out_shape,
+            "AVG",
+            pads_required=pads,
+            pads=pads,
+        )
 
         expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_same_upper")
 
@@ -325,7 +334,16 @@ class AveragePool(Base):
             constant_values=np.nan,
         )
         pads = (pad_top, pad_left, pad_bottom, pad_right)
-        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "AVG", pads)
+        y = pool(
+            padded,
+            x_shape,
+            kernel_shape,
+            strides,
+            out_shape,
+            "AVG",
+            pads_required=pads,
+            pads=pads,
+        )
 
         expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_same_lower")
 
@@ -351,16 +369,30 @@ class AveragePool(Base):
         pad_right = 2
         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, ceil_mode=False
         )
         padded = np.pad(
             x,
-            ((0, 0), (0, 0), (pads[0], pads[2]), (pads[1], pads[3])),
+            (
+                (0, 0),
+                (0, 0),
+                (extra_pads[0], extra_pads[2]),
+                (extra_pads[1], extra_pads[3]),
+            ),
             mode="constant",
             constant_values=np.nan,
         )
-        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "AVG", pads)
+        y = pool(
+            padded,
+            x_shape,
+            kernel_shape,
+            strides,
+            out_shape,
+            "AVG",
+            pads_required=extra_pads,
+            pads=pads,
+        )
 
         expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_pads")
 
@@ -388,12 +420,17 @@ class AveragePool(Base):
         pad_right = 2
         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, dilations, ceil_mode=False
         )
         padded = np.pad(
             x,
-            ((0, 0), (0, 0), (pads[0], pads[2]), (pads[1], pads[3])),
+            (
+                (0, 0),
+                (0, 0),
+                (extra_pads[0], extra_pads[2]),
+                (extra_pads[1], extra_pads[3]),
+            ),
             mode="constant",
             constant_values=0,
         )
@@ -404,7 +441,8 @@ class AveragePool(Base):
             strides,
             out_shape,
             "AVG",
-            pads,
+            pads_required=extra_pads,
+            pads=pads,
             count_include_pad=1,
         )
 
@@ -435,7 +473,16 @@ class AveragePool(Base):
             None, x_shape[2:], kernel_shape, strides, ceil_mode=False
         )
         padded = x
-        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "AVG", pads)
+        y = pool(
+            padded,
+            x_shape,
+            kernel_shape,
+            strides,
+            out_shape,
+            "AVG",
+            pads_required=pads,
+            pads=None,
+        )
 
         expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_strides")
 
@@ -468,6 +515,39 @@ class AveragePool(Base):
 
         expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_ceil")
 
+    @staticmethod
+    def export_averagepool_2d_ceil_last_window_starts_on_pad() -> None:
+        """input_shape: [1, 3, 2, 2]
+        output_shape: [1, 3, 1, 1]
+        """
+        node = onnx.helper.make_node(
+            "AveragePool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[3, 3],
+            strides=[3, 3],
+            pads=[1, 1, 1, 1],
+            ceil_mode=True,
+            count_include_pad=1,
+        )
+        x = np.array(
+            [
+                [
+                    [[0.8580, 0.0786], [0.2692, 0.1537]],
+                    [[0.8816, 0.4353], [0.5772, 0.6623]],
+                    [[0.9067, 0.9483], [0.5970, 0.7630]],
+                ]
+            ]
+        ).astype(np.float32)
+        y = np.array([[[[0.1511]], [[0.2841]], [[0.3572]]]]).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_averagepool_2d_ceil_last_window_starts_on_pad",
+        )
+
     @staticmethod
     def export_averagepool_2d_dilations() -> None:
         """input_shape: [1, 1, 4, 4]
@@ -578,7 +658,7 @@ class AveragePool(Base):
                 )
 
                 x = np.random.randn(1, 1, *x_shape).astype(np.float32)
-                out_shape, pads = get_output_shape_explicit_padding(
+                out_shape, extra_pads = get_output_shape_explicit_padding(
                     None,
                     x_shape,
                     kernel_shape,
@@ -591,9 +671,9 @@ class AveragePool(Base):
                     (
                         (0, 0),
                         (0, 0),
-                        (pads[0], pads[3]),
-                        (pads[1], pads[4]),
-                        (pads[2], pads[5]),
+                        (extra_pads[0], extra_pads[3]),
+                        (extra_pads[1], extra_pads[4]),
+                        (extra_pads[2], extra_pads[5]),
                     ),
                     mode="constant",
                     constant_values=0 if count_include_pad == 1 else np.nan,
@@ -605,7 +685,8 @@ class AveragePool(Base):
                     strides,
                     out_shape,
                     "AVG",
-                    pads=pads,
+                    pads_required=extra_pads,
+                    pads=None,
                     dilations=dilations,
                     count_include_pad=count_include_pad,
                 )

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

@@ -10,7 +10,7 @@ from onnx.backend.test.case.base import Base
 from onnx.backend.test.case.node import expect
 
 
-def _batchnorm_test_mode(x, s, bias, mean, var, epsilon=1e-5):  # type: ignore
+def _batchnorm_test_mode(x, s, bias, mean, var, epsilon=1e-5):
     dims_x = len(x.shape)
     dim_ones = (1,) * (dims_x - 2)
     s = s.reshape(-1, *dim_ones)
@@ -20,7 +20,7 @@ def _batchnorm_test_mode(x, s, bias, mean, var, epsilon=1e-5):  # type: ignore
     return s * (x - mean) / np.sqrt(var + epsilon) + bias
 
 
-def _batchnorm_training_mode(x, s, bias, mean, var, momentum=0.9, epsilon=1e-5):  # type: ignore
+def _batchnorm_training_mode(x, s, bias, mean, var, momentum=0.9, epsilon=1e-5):
     axis = tuple(np.delete(np.arange(len(x.shape)), 1))
     saved_mean = x.mean(axis=axis)
     saved_var = x.var(axis=axis)

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

@@ -10,7 +10,7 @@ from onnx.backend.test.case.base import Base
 from onnx.backend.test.case.node import expect
 
 
-def bernoulli_reference_implementation(x, dtype):  # type: ignore
+def bernoulli_reference_implementation(x, dtype):
     # binomial n = 1 equal bernoulli
     # This example and test-case is for informational purpose. The generator operator is
     # non-deterministic and may not produce the same values in different implementations

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

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
-import numpy as np  # type: ignore
+import numpy as np
 
 import onnx
 from onnx.backend.test.case.base import Base

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

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
-import numpy as np  # type: ignore
+import numpy as np
 
 import onnx
 from onnx.backend.test.case.base import Base

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

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
-import numpy as np  # type: ignore
+import numpy as np
 
 import onnx
 from onnx.backend.test.case.base import Base

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

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
-import numpy as np  # type: ignore
+import numpy as np
 
 import onnx
 from onnx.backend.test.case.base import Base

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

@@ -18,7 +18,11 @@ from onnx.helper import (
     make_tensor,
     tensor_dtype_to_field,
 )
-from onnx.numpy_helper import float8e4m3_to_float32, float8e5m2_to_float32
+from onnx.numpy_helper import (
+    float8e4m3_to_float32,
+    float8e5m2_to_float32,
+    unpacked_float4e2m1_to_float32,
+)
 
 
 class Cast(Base):
@@ -62,6 +66,10 @@ class Cast(Base):
             ("INT4", "FLOAT"),
             ("INT4", "FLOAT16"),
             ("INT4", "INT8"),
+            ("FLOAT4E2M1", "FLOAT"),
+            ("FLOAT4E2M1", "FLOAT16"),
+            ("FLOAT", "FLOAT4E2M1"),
+            ("FLOAT16", "FLOAT4E2M1"),
         ]
 
         vect_float32_to_float8e4m3 = np.vectorize(float32_to_float8e4m3)
@@ -278,7 +286,57 @@ class Cast(Base):
                 output_type_proto = onnx.helper.make_tensor_type_proto(
                     getattr(TensorProto, to_type), input_shape
                 )
+            elif from_type == "FLOAT4E2M1" or to_type == "FLOAT4E2M1":
+                np_fp32 = np.array(
+                    [
+                        "0.48",
+                        "0.25",
+                        "1.05",
+                        "-3.5",
+                        "-8",
+                        "9",
+                        "1000000",
+                        "1e-7",
+                        "NaN",
+                        "INF",
+                        "+INF",
+                        "-INF",
+                        "-4",
+                        "0.01",
+                        "-0.0",
+                    ],
+                    dtype=np.float32,
+                )
+                input_shape = (3, 5)
+                if from_type == "FLOAT":
+                    input_values = np_fp32
+                    input = make_tensor(
+                        "x", TensorProto.FLOAT, input_shape, input_values.tolist()
+                    )
+                elif from_type == "FLOAT16":
+                    input_values = np_fp32.astype(np.float16).astype(np.float32)
+                    input = make_tensor(
+                        "x", TensorProto.FLOAT16, input_shape, input_values.tolist()
+                    )
+                elif from_type == "FLOAT4E2M1":
+                    input = make_tensor(
+                        "x", TensorProto.FLOAT4E2M1, input_shape, np_fp32.tolist()
+                    )
+                else:
+                    raise ValueError(
+                        f"Conversion from {from_type} to {to_type} is not tested."
+                    )
 
+                if to_type not in ("FLOAT", "FLOAT16", "FLOAT4E2M1"):
+                    raise ValueError(
+                        f"Conversion from {from_type} to {to_type} is not tested."
+                    )
+                expected = unpacked_float4e2m1_to_float32(
+                    subbyte.float32_to_float4e2m1_unpacked(np_fp32)
+                )
+                output = make_tensor(
+                    "y", getattr(TensorProto, to_type), input_shape, expected.tolist()
+                )
             elif from_type != "STRING":
                 input = np.random.random_sample(shape).astype(
                     helper.tensor_dtype_to_np_dtype(getattr(TensorProto, from_type))

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

@@ -60,6 +60,17 @@ class Clip(Base):
             name="test_clip_splitbounds",
         )
 
+        x = np.array([-2, 0, 6]).astype(np.float32)
+        y = np.array([1, 1, 1]).astype(np.float32)
+        min_val = np.float32(2)
+        max_val = np.float32(1)
+        expect(
+            node,
+            inputs=[x, min_val, max_val],
+            outputs=[y],
+            name="test_clip_min_greater_than_max",
+        )
+
     @staticmethod
     def export_clip_default() -> None:
         node = onnx.helper.make_node(

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

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
-from typing import Any, Sequence
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 
@@ -11,6 +11,9 @@ import onnx
 from onnx.backend.test.case.base import Base
 from onnx.backend.test.case.node import expect
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 
 class Concat(Base):
     @staticmethod

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

@@ -86,3 +86,27 @@ class CumSum(Base):
         axis = np.int32(-1)
         y = np.array([1.0, 3.0, 6.0, 4.0, 9.0, 15.0]).astype(np.float64).reshape((2, 3))
         expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_negative_axis")
+
+    @staticmethod
+    def export_cumsum_2d_int32() -> None:
+        node = onnx.helper.make_node(
+            "CumSum",
+            inputs=["x", "axis"],
+            outputs=["y"],
+        )
+        x = np.array([1, 2, 3, 4, 5, 6]).astype(np.int32).reshape((2, 3))
+        axis = np.int32(0)
+        y = np.array([1, 2, 3, 5, 7, 9]).astype(np.int32).reshape((2, 3))
+        expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_int32")
+
+    @staticmethod
+    def export_cumsum_1d_int32_exclusive() -> None:
+        node = onnx.helper.make_node(
+            "CumSum", inputs=["x", "axis"], outputs=["y"], exclusive=1
+        )
+        x = np.array([1, 2, 3, 4, 5]).astype(np.int32)
+        axis = np.int32(0)
+        y = np.array([0, 1, 3, 6, 10]).astype(np.int32)
+        expect(
+            node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d_int32_exclusive"
+        )

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

@@ -235,6 +235,28 @@ class DequantizeLinear(Base):
             name="test_dequantizelinear_int4",
         )
 
+    @staticmethod
+    def export_float4e2m1() -> None:
+        node = onnx.helper.make_node(
+            "DequantizeLinear",
+            inputs=["x", "x_scale", "x_zero_point"],
+            outputs=["y"],
+            axis=0,
+        )
+
+        # scalar zero point and scale
+        x = make_tensor("x", TensorProto.FLOAT4E2M1, [5], [0, 1, -1, 1.5, -4])
+        x_scale = np.float32(2)
+        x_zero_point = make_tensor("x_zero_point", TensorProto.FLOAT4E2M1, (1,), [0])
+        y = np.array([0, 2, -2, 3, -8], dtype=np.float32)
+
+        expect(
+            node,
+            inputs=[x, x_scale, x_zero_point],
+            outputs=[y],
+            name="test_dequantizelinear_float4e2m1",
+        )
+
     @staticmethod
     def export_blocked() -> None:
         node = onnx.helper.make_node(

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

@@ -29,11 +29,36 @@ class Div(Base):
         z = x / y
         expect(node, inputs=[x, y], outputs=[z], name="test_div")
 
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.int8)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.int8) + 1
+        z = x // y
+        expect(node, inputs=[x, y], outputs=[z], name="test_div_int8")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.int16)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.int16) + 1
+        z = x // y
+        expect(node, inputs=[x, y], outputs=[z], name="test_div_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) + 1
         z = x // y
         expect(node, inputs=[x, y], outputs=[z], name="test_div_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) + 1
+        z = x // y
+        expect(node, inputs=[x, y], outputs=[z], name="test_div_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) + 1
+        z = x // y
+        expect(node, inputs=[x, y], outputs=[z], name="test_div_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) + 1
+        z = x // y
+        expect(node, inputs=[x, y], outputs=[z], name="test_div_uint64")
+
     @staticmethod
     def export_div_broadcast() -> None:
         node = onnx.helper.make_node(

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

@@ -11,7 +11,7 @@ from onnx.backend.test.case.base import Base
 from onnx.backend.test.case.node import expect
 
 
-def dropout(X, drop_probability=0.5, seed=0, training_mode=False, return_mask=False):  # type: ignore
+def dropout(X, drop_probability=0.5, seed=0, training_mode=False, return_mask=False):
     if drop_probability == 0 or training_mode is False:
         if return_mask is True:
             return X, np.ones(X.shape, dtype=bool)

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

@@ -24,6 +24,36 @@ class Equal(Base):
         z = np.equal(x, y)
         expect(node, inputs=[x, y], outputs=[z], name="test_equal")
 
+        x = (np.random.randn(3, 4, 5) * 10).astype(np.int8)
+        y = (np.random.randn(3, 4, 5) * 10).astype(np.int8)
+        z = np.equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_equal_int8")
+
+        x = (np.random.randn(3, 4, 5) * 10).astype(np.int16)
+        y = (np.random.randn(3, 4, 5) * 10).astype(np.int16)
+        z = np.equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_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.equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_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.equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_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.equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_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.equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_equal_uint64")
+
     @staticmethod
     def export_equal_broadcast() -> None:
         node = onnx.helper.make_node(

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

@@ -11,7 +11,7 @@ from onnx.backend.test.case.node import expect
 
 
 # The below GatherElements' numpy implementation is from https://stackoverflow.com/a/46204790/11767360
-def gather_elements(data, indices, axis=0):  # type: ignore
+def gather_elements(data, indices, axis=0):
     data_swaped = np.swapaxes(data, 0, axis)
     index_swaped = np.swapaxes(indices, 0, axis)
     gathered = np.choose(index_swaped, data_swaped, mode="wrap")

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/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:
@@ -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