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

onnx/reference/ops/op_cast.py

@@ -5,155 +5,45 @@ from __future__ import annotations
 
 import numpy as np
 
-from onnx import subbyte
-from onnx._custom_element_types import (
-    bfloat16,
-    float4e2m1,
-    float8e4m3fn,
-    float8e4m3fnuz,
-    float8e5m2,
-    float8e5m2fnuz,
-    int4,
-    uint4,
-)
-from onnx.helper import (
-    float32_to_bfloat16,
-    float32_to_float8e4m3,
-    float32_to_float8e5m2,
-    tensor_dtype_to_np_dtype,
-)
-from onnx.numpy_helper import (
-    bfloat16_to_float32,
-    float8e4m3_to_float32,
-    float8e5m2_to_float32,
-    unpacked_float4e2m1_to_float32,
-)
-from onnx.onnx_pb import TensorProto
+import onnx
 from onnx.reference.op_run import OpRun
 
 
-def cast_to(x, to, saturate):  # noqa: PLR0911
-    if x.dtype == bfloat16 and x.dtype.descr[0][0] == "bfloat16":
-        if to == TensorProto.BFLOAT16:
-            return x
-        xr = x.ravel()
-        xf = np.empty(xr.shape[0], dtype=np.float32)
-        for i in range(xr.shape[0]):
-            el = bfloat16_to_float32(xr[i])
-            xf[i] = el
-        dtype = tensor_dtype_to_np_dtype(to)
-        return xf.astype(dtype).reshape(x.shape)
-
-    f8 = {
-        (float8e4m3fn, "e4m3fn", TensorProto.FLOAT8E4M3FN): float8e4m3_to_float32,
-        (
-            float8e4m3fnuz,
-            "e4m3fnuz",
-            TensorProto.FLOAT8E4M3FNUZ,
-        ): lambda *args: float8e4m3_to_float32(*args, uz=True),
-        (float8e5m2, "e5m2", TensorProto.FLOAT8E5M2): float8e5m2_to_float32,
-        (
-            float8e5m2fnuz,
-            "e5m2fnuz",
-            TensorProto.FLOAT8E5M2FNUZ,
-        ): lambda *args: float8e5m2_to_float32(*args, fn=True, uz=True),
-    }
-
-    for (dt, st, proto_type), cvt in f8.items():
-        if x.dtype == dt and x.dtype.descr[0][0] == st:
-            if to == proto_type:
-                return x
-            xr = x.ravel()
-            xf = np.empty(xr.shape[0], dtype=np.float32)
-            for i in range(xr.shape[0]):
-                el = cvt(xr[i])
-                xf[i] = el
-            dtype = tensor_dtype_to_np_dtype(to)
-            return xf.astype(dtype).reshape(x.shape)
-
-    if to == TensorProto.BFLOAT16:
-        xf = x.astype(np.float32).ravel()
-        y = np.empty(xf.shape, dtype=bfloat16).ravel()
-        for i in range(y.shape[0]):
-            el = float32_to_bfloat16(xf[i], truncate=True)  # type: ignore[assignment]
-            y[i] = el
-        return y.reshape(x.shape)
-
-    i4 = [
-        (uint4, "uint4", TensorProto.UINT4, False),
-        (int4, "int4", TensorProto.INT4, True),
-    ]
-    for np_type, np_desc, tensor_type, signed in i4:
-        if x.dtype == np_type and x.dtype.descr[0][0] == np_desc:
-            if to == tensor_type:
-                return x
-            to_type = tensor_dtype_to_np_dtype(to)
-            return x.astype(to_type)
-
-        if to == tensor_type:
-            xf = x.astype(np.float32).ravel()
-            y = np.empty(xf.shape, dtype=np_type).ravel()
-            for i in range(y.shape[0]):
-                el = subbyte.float32_to_4bit_unpacked(xf[i], signed=signed)
-                y[i] = el
-            # This operator preduces a tensor with the same shape for INT4.
-            return y.reshape(x.shape)
-
-    f8back = {
-        TensorProto.FLOAT8E4M3FN: (
-            float8e4m3fn,
-            lambda *args: float32_to_float8e4m3(*args, saturate=saturate),
-        ),
-        TensorProto.FLOAT8E4M3FNUZ: (
-            float8e4m3fnuz,
-            lambda *args: float32_to_float8e4m3(*args, uz=True, saturate=saturate),
-        ),
-        TensorProto.FLOAT8E5M2: (
-            float8e5m2,
-            lambda *args: float32_to_float8e5m2(*args, saturate=saturate),
-        ),
-        TensorProto.FLOAT8E5M2FNUZ: (
-            float8e5m2fnuz,
-            lambda *args: float32_to_float8e5m2(
-                *args, fn=True, uz=True, saturate=saturate
-            ),
-        ),
-    }
-    for dt, (npdt, cvt) in f8back.items():
-        if to == dt:
-            xf = x.astype(np.float32).ravel()
-            y = np.empty(xf.shape, dtype=npdt).ravel()
-            for i in range(y.shape[0]):
-                el = cvt(xf[i])  # type: ignore[assignment]
-                y[i] = el
-            return y.reshape(x.shape)
-
-    if x.dtype == float4e2m1 and x.dtype.descr[0][0] == "float4e2m1":
-        if to == TensorProto.FLOAT4E2M1:
-            return x
-        res = unpacked_float4e2m1_to_float32(x)
-        if to == TensorProto.FLOAT:
-            return res.astype(np.float32)
-        elif to == TensorProto.FLOAT16:
-            return res.astype(np.float16)
-
-    if to == TensorProto.FLOAT4E2M1:
-        xf = x.astype(np.float32)
-        y = subbyte.float32_to_float4e2m1_unpacked(xf).astype(float4e2m1)
-        return y.reshape(x.shape)
-
-    if to == TensorProto.STRING:
+def cast_to(
+    x: np.ndarray, to: onnx.TensorProto.DataType, saturate: bool, round_mode: str = "up"
+):
+    if to == onnx.TensorProto.STRING:
         return x.astype(np.str_)
 
-    dtype = tensor_dtype_to_np_dtype(to)
+    dtype = onnx.helper.tensor_dtype_to_np_dtype(to)
+    if (
+        to
+        in {
+            onnx.TensorProto.FLOAT8E4M3FN,
+            onnx.TensorProto.FLOAT8E4M3FNUZ,
+            onnx.TensorProto.FLOAT8E5M2,
+            onnx.TensorProto.FLOAT8E5M2FNUZ,
+        }
+        and saturate
+    ):
+        return onnx.numpy_helper.saturate_cast(x, dtype)
+
+    if to == onnx.TensorProto.FLOAT8E8M0:
+        return onnx.numpy_helper.to_float8e8m0(x, saturate, round_mode).astype(dtype)
+
     return x.astype(dtype)
 
 
 class Cast_1(OpRun):
-    def _run(self, x, to=None):  # type: ignore
-        return (cast_to(x, to, saturate=True),)
+    def _run(self, x, to=None):
+        return (cast_to(x, to, saturate=True, round_mode="up"),)
 
 
 class Cast_19(OpRun):
-    def _run(self, x, to=None, saturate=None):  # type: ignore
-        return (cast_to(x, to, saturate),)
+    def _run(self, x, to=None, saturate=None):
+        return (cast_to(x, to, saturate, round_mode="up"),)
+
+
+class Cast_24(OpRun):
+    def _run(self, x, to=None, saturate=None, round_mode=None):
+        return (cast_to(x, to, saturate, round_mode),)

onnx/reference/ops/op_cast_like.py

@@ -4,49 +4,19 @@
 from __future__ import annotations
 
 from onnx.helper import np_dtype_to_tensor_dtype
-from onnx.onnx_pb import TensorProto
 from onnx.reference.op_run import OpRun
-from onnx.reference.ops.op_cast import (
-    bfloat16,
-    cast_to,
-    float4e2m1,
-    float8e4m3fn,
-    float8e4m3fnuz,
-    float8e5m2,
-    float8e5m2fnuz,
-    int4,
-    uint4,
-)
-
-
-def _cast_like(x, y, saturate):
-    if y.dtype == bfloat16 and y.dtype.descr[0][0] == "bfloat16":
-        # np.uint16 == np.uint16 is True as well as np.uint16 == bfloat16
-        to = TensorProto.BFLOAT16
-    elif y.dtype == float8e4m3fn and y.dtype.descr[0][0] == "e4m3fn":
-        to = TensorProto.FLOAT8E4M3FN
-    elif y.dtype == float8e4m3fnuz and y.dtype.descr[0][0] == "e4m3fnuz":
-        to = TensorProto.FLOAT8E4M3FNUZ
-    elif y.dtype == float8e5m2 and y.dtype.descr[0][0] == "e5m2":
-        to = TensorProto.FLOAT8E5M2
-    elif y.dtype == float8e5m2fnuz and y.dtype.descr[0][0] == "e5m2fnuz":
-        to = TensorProto.FLOAT8E5M2FNUZ
-    elif y.dtype == uint4 and y.dtype.descr[0][0] == "uint4":
-        to = TensorProto.UINT4
-    elif y.dtype == int4 and y.dtype.descr[0][0] == "int4":
-        to = TensorProto.INT4
-    elif y.dtype == float4e2m1 and y.dtype.descr[0][0] == "float4e2m1":
-        to = TensorProto.FLOAT4E2M1
-    else:
-        to = np_dtype_to_tensor_dtype(y.dtype)  # type: ignore
-    return (cast_to(x, to, saturate),)
+from onnx.reference.ops.op_cast import cast_to
+
+
+def _cast_like(x, y, saturate: bool):
+    return (cast_to(x, np_dtype_to_tensor_dtype(y.dtype), saturate),)
 
 
 class CastLike_15(OpRun):
-    def _run(self, x, y):  # type: ignore
+    def _run(self, x, y):
         return _cast_like(x, y, True)
 
 
 class CastLike_19(OpRun):
-    def _run(self, x, y, saturate=None):  # type: ignore
+    def _run(self, x, y, saturate=False):
         return _cast_like(x, y, saturate)

onnx/reference/ops/op_ceil.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Ceil(OpRunUnaryNum):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         return (np.ceil(x),)

onnx/reference/ops/op_celu.py

@@ -11,9 +11,9 @@ from onnx.reference.op_run import OpRun
 def _vcelu1(x: np.ndarray, alpha: float = 1.0) -> np.ndarray:
     positive_input = np.maximum(0, x)
     negative_input = np.minimum(0, alpha * (np.exp(x / alpha) - 1))
-    return positive_input + negative_input  # type: ignore
+    return positive_input + negative_input
 
 
 class Celu(OpRun):
-    def _run(self, x, alpha=None):  # type: ignore
+    def _run(self, x, alpha=None):
         return (_vcelu1(x, alpha).astype(x.dtype),)

onnx/reference/ops/op_center_crop_pad.py

@@ -9,8 +9,8 @@ from onnx.reference.op_run import OpRun
 
 
 class CenterCropPad(OpRun):
-    def _run(self, input_data, shape, axes=None):  # type: ignore
-        axes = axes or self.axes  # type: ignore
+    def _run(self, input_data, shape, axes=None):
+        axes = axes or self.axes
         input_rank = len(input_data.shape)
         if axes is None:
             axes = list(range(input_rank))

onnx/reference/ops/op_clip.py

@@ -12,12 +12,12 @@ class Clip_6(OpRun):
     def _run(self, data, min=None, max=None):  # type: ignore  # noqa: A002
         amin = min
         amax = max
-        res = data if amin is amax is None else np.clip(data, amin, amax)  # type: ignore
+        res = data if amin is amax is None else np.clip(data, amin, amax)
         return (res,) if res.dtype == data.dtype else (res.astype(data.dtype),)
 
 
 class Clip_11(OpRun):
-    def _run(self, data, *minmax):  # type: ignore
+    def _run(self, data, *minmax):
         le = len(minmax)
         amin = minmax[0] if le > 0 else None
         amax = minmax[1] if le > 1 else None

onnx/reference/ops/op_col2im.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 from onnx.reference.ops._op_common_indices import _get_indices, _is_out
 
 
-def _col2im_shape_check_2d(X, output_shape, kernel_shape, dilations, pads, strides):  # type: ignore
+def _col2im_shape_check_2d(X, output_shape, kernel_shape, dilations, pads, strides):
     output_height, output_width = output_shape
     kernel_height, kernel_width = kernel_shape
     dilation_height, dilation_width = dilations
@@ -64,7 +64,7 @@ def _col2im_shape_check_2d(X, output_shape, kernel_shape, dilations, pads, strid
 
 def _col2im_naive_implementation_2d(
     res, image_shape, kernel_shape, dilations, pads, strides
-):  # type: ignore
+):
     # source: https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/native/im2col.h
 
     n_dims = len(pads) // 2
@@ -107,7 +107,7 @@ def _col2im_naive_implementation_2d(
     return data_im.reshape(image_shape)
 
 
-def _col2im_shape_check(X, output_shape, kernel_shape, dilations, pads, strides):  # type: ignore
+def _col2im_shape_check(X, output_shape, kernel_shape, dilations, pads, strides):
     n_input_plane = X.shape[0]
 
     kernel_size = np.prod(kernel_shape)
@@ -146,7 +146,7 @@ def _col2im_shape_check(X, output_shape, kernel_shape, dilations, pads, strides)
 
 def col2im_naive_implementation(
     data, image_shape, kernel_shape, dilations, pads, strides
-):  # type: ignore
+):
     """Naive implementation for `col2im`."""
     n_dims = len(pads) // 2
     new_pads = np.array([(pads[i], pads[i + n_dims]) for i in range(n_dims)])
@@ -187,7 +187,7 @@ def col2im_naive_implementation(
 class Col2Im(OpRun):
     def _run(
         self, data, image_shape, block_shape, dilations=None, pads=None, strides=None
-    ):  # type: ignore
+    ):
         if dilations is None:
             dilations = [1 for s in image_shape]
         if pads is None:
@@ -197,7 +197,7 @@ class Col2Im(OpRun):
 
         bl = np.prod(block_shape)
         C = data.shape[1] // bl
-        data = data.reshape(data.shape[:1] + (C,) + (bl,) + data.shape[2:])
+        data = data.reshape((*data.shape[:1], C, bl, *data.shape[2:]))
 
         ks = tuple(block_shape)
         res = None
@@ -210,4 +210,4 @@ class Col2Im(OpRun):
                     new_shape = data.shape[:2] + out.shape
                     res = np.empty(new_shape, dtype=data.dtype)
                 res[n, c, ...] = out
-        return (res,)  # type: ignore
+        return (res,)

onnx/reference/ops/op_compress.py

@@ -9,5 +9,5 @@ from onnx.reference.op_run import OpRun
 
 
 class Compress(OpRun):
-    def _run(self, x, condition, axis=None):  # type: ignore
-        return (np.compress(condition, x, axis=axis),)  # type: ignore
+    def _run(self, x, condition, axis=None):
+        return (np.compress(condition, x, axis=axis),)

onnx/reference/ops/op_concat.py

@@ -12,11 +12,11 @@ class Concat(OpRun):
     def _preprocess(self, a: np.ndarray, axis: int) -> np.ndarray:
         if len(a.shape) == 0:
             raise RuntimeError(f"Concat: one input has an empty shape: {a!r}.")
-        if axis >= len(a.shape):  # type: ignore
-            new_shape = a.shape + (1,) * (axis + 1 - len(a.shape))  # type: ignore
+        if axis >= len(a.shape):
+            new_shape = a.shape + (1,) * (axis + 1 - len(a.shape))
             return a.reshape(new_shape)
         return a
 
-    def _run(self, *args, axis=None):  # type: ignore
+    def _run(self, *args, axis=None):
         targs = tuple(self._preprocess(a, axis) for a in args)
-        return (np.concatenate(targs, axis),)  # type: ignore
+        return (np.concatenate(targs, axis),)

onnx/reference/ops/op_concat_from_sequence.py

@@ -20,11 +20,11 @@ def _concat_from_sequence(seq: list[Any], axis: int, new_axis: int = 0) -> np.nd
             res = np.concatenate(seq2, axis=axis)
     else:
         res = np.concatenate(seq, axis=axis)
-    return res  # type: ignore
+    return res
 
 
 class ConcatFromSequence(OpRun):
-    def _run(self, seq, axis=None, new_axis=None):  # type: ignore
+    def _run(self, seq, axis=None, new_axis=None):
         if seq is None:
             raise RuntimeError("A sequence cannot be null.")
         res = _concat_from_sequence(seq, axis, new_axis=new_axis)

onnx/reference/ops/op_constant.py

@@ -5,65 +5,31 @@ from __future__ import annotations
 
 import numpy as np
 
-from onnx._custom_element_types import (
-    bfloat16,
-    float4e2m1,
-    float8e4m3fn,
-    float8e4m3fnuz,
-    float8e5m2,
-    float8e5m2fnuz,
-    int4,
-    uint4,
-)
 from onnx.reference.op_run import OpRun, RefAttrName
 
 
-def _check_dtype(val):  # type: ignore
-    a = val.dtype
-    if not isinstance(a, np.dtype) and a not in {
-        bfloat16,
-        float8e4m3fn,
-        float8e4m3fnuz,
-        float8e5m2,
-        float8e5m2fnuz,
-        uint4,
-        int4,
-        float4e2m1,
-        np.int8,
-        np.uint8,
-        np.float16,
-        np.float32,
-        np.float64,
-        np.int32,
-        np.int64,
-        np.int16,
-        np.uint16,
-        np.uint32,
-        np.bool_,
-        np.str_,
-        np.uint64,
-        bool,
-        str,
-    }:
+def _check_dtype(val):
+    dtype = val.dtype
+    if not isinstance(dtype, np.dtype):
         raise TypeError(
-            f"Type ({a}, {type(a)}) is not a numpy type (operator 'Constant')"
+            f"Type ({dtype}, {type(dtype)}) is not a numpy type (operator 'Constant')"
         )
 
 
 class ConstantCommon(OpRun):
-    def _check(self, cst):  # type: ignore
+    def _check(self, cst):
         if isinstance(cst, tuple):
             raise TypeError(f"Unexpected type {type(cst)} for a constant.")
         return cst
 
 
 class Constant_1(ConstantCommon):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         ConstantCommon.__init__(self, onnx_node, run_params)
-        self.cst = self.value  # type: ignore
+        self.cst = self.value
         _check_dtype(self.cst)
 
-    def _run(self, **overridden_attributes):  # type: ignore
+    def _run(self, **overridden_attributes):
         if overridden_attributes and (
             len(overridden_attributes) > 1
             or "value" not in overridden_attributes
@@ -76,20 +42,20 @@ class Constant_1(ConstantCommon):
 
 
 class Constant_9(Constant_1):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         Constant_1.__init__(self, onnx_node, run_params)
 
 
 class Constant_11(ConstantCommon):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         ConstantCommon.__init__(self, onnx_node, run_params)
         if getattr(self, "sparse_value", None) is None:
-            self.cst = self.value  # type: ignore
+            self.cst = self.value
         else:
-            self.cst = self.sparse_value  # type: ignore
+            self.cst = self.sparse_value
         _check_dtype(self.cst)
 
-    def _run(self, **overridden_attributes):  # type: ignore
+    def _run(self, **overridden_attributes):
         if overridden_attributes and (
             len(overridden_attributes) > 1
             or "value" not in overridden_attributes
@@ -102,15 +68,15 @@ class Constant_11(ConstantCommon):
 
 
 class Constant_12(ConstantCommon):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         ConstantCommon.__init__(self, onnx_node, run_params)
-        if hasattr(self, "sparse_value") and self.sparse_value is not None:  # type: ignore
+        if hasattr(self, "sparse_value") and self.sparse_value is not None:
             self.cst_name = "sparse_value"
-            self.cst = self.sparse_value  # type: ignore
+            self.cst = self.sparse_value
             self.cst_convert = lambda v: v
-        elif hasattr(self, "value") and self.value is not None:  # type: ignore
-            self.cst_name = "value"  # type: ignore
-            self.cst = self.value  # type: ignore
+        elif hasattr(self, "value") and self.value is not None:
+            self.cst_name = "value"
+            self.cst = self.value
             self.cst_convert = lambda v: v
         else:
             for attr, np_dtype in {
@@ -121,15 +87,13 @@ class Constant_12(ConstantCommon):
                 "value_string": np.str_,
                 "value_strings": np.str_,
             }.items():
-                if hasattr(self, attr) and getattr(self, attr) is not None:  # type: ignore
+                if hasattr(self, attr) and getattr(self, attr) is not None:
                     self.cst_name = attr
                     v = getattr(self, attr)
                     self.cst = (
-                        v  # type: ignore
-                        if isinstance(v, RefAttrName)  # type: ignore
-                        else np.array(v, dtype=np_dtype)  # type: ignore
+                        v if isinstance(v, RefAttrName) else np.array(v, dtype=np_dtype)
                     )
-                    self.cst_convert = lambda v, np_dtype=np_dtype: np.array(  # type: ignore
+                    self.cst_convert = lambda v, np_dtype=np_dtype: np.array(
                         v, dtype=np_dtype
                     )
                     break
@@ -138,7 +102,7 @@ class Constant_12(ConstantCommon):
                 f"No constant is defined for operator 'Constant', outputs are {onnx_node.output}."
             )
 
-    def _run(self, **overridden_attributes):  # type: ignore
+    def _run(self, **overridden_attributes):
         if self.has_linked_attribute:
             if overridden_attributes is None:
                 raise RuntimeError(

onnx/reference/ops/op_constant_of_shape.py

@@ -9,24 +9,21 @@ from onnx.reference.op_run import OpRun
 
 
 class ConstantOfShape(OpRun):
-    def __init__(self, onnx_node, run_params):  # type: ignore
-        OpRun.__init__(self, onnx_node, run_params)
-        self.cst = (
-            self.value[0] if isinstance(self.value, np.ndarray) else self.value  # type: ignore
-        )
-        if isinstance(self.cst, int):
-            self.cst = np.int64(self.cst)
-        elif isinstance(self.cst, float):
-            self.cst = np.float64(self.cst)
-        elif self.cst is None:
-            self.cst = np.float32(0)
+    def _run(self, data, value: np.array | None = None):
+        if self.value is None:
+            value = np.array(0, dtype=np.float32)
+        else:
+            if self.value.size != 1:
+                raise ValueError(
+                    f"Operator ConstantOfShape ({self.onnx_node.name!r}) expects a single element tensor as value, but the size of 'value' is {len(self.value)}."
+                )
+            value = self.value.flat[0]
 
-    def _run(self, data, value=None):  # type: ignore
         try:
-            res = np.full(tuple(data), self.cst)  # type: ignore
+            res = np.full(tuple(data), value)
         except TypeError as e:
             raise RuntimeError(
-                f"Unable to create a constant of shape {data!r} with value {self.cst!r} "  # type: ignore
-                f"(raw value={value!r})."  # type: ignore
+                f"Unable to create a constant of shape {data!r} with value {value!r} "
+                f"(raw value={self.value!r})."
             ) from e
         return (res,)

onnx/reference/ops/op_conv.py

@@ -8,7 +8,7 @@ import numpy as np
 from onnx.reference.op_run import OpRun
 
 
-def _conv_implementation(  # type: ignore
+def _conv_implementation(
     X, W, B, auto_pad, dilations, group, kernel_shape, pads, strides
 ):
     if dilations is None:
@@ -122,7 +122,7 @@ def _conv_implementation(  # type: ignore
         eh = h_out * sth
         res = np.zeros((X.shape[0], W.shape[0], h_out))  # type: ignore[assignment]
         if B is not None:
-            res[:, :, :] += B.reshape((1, -1, 1))  # type: ignore
+            res[:, :, :] += B.reshape((1, -1, 1))
 
         for n in range(sN):
             for nw in range(W.shape[0]):
@@ -150,7 +150,7 @@ def _conv_implementation(  # type: ignore
                             s = np.dot(img.reshape((1, -1)), w.reshape((-1, 1)))[
                                 0, 0
                             ]  # (img * w).sum()
-                        res[n, nw, hr] += s  # type: ignore
+                        res[n, nw, hr] += s
 
         return res
 
@@ -169,7 +169,7 @@ def _conv_implementation(  # type: ignore
         eh, ew = h_out * sth, w_out * stw
         res = np.zeros((X.shape[0], W.shape[0], h_out, w_out))  # type: ignore[assignment]
         if B is not None:
-            res[:, :, :, :] = B.reshape((1, -1, 1, 1))  # type: ignore
+            res[:, :, :, :] = B.reshape((1, -1, 1, 1))
 
         for n in range(sN):
             for nw in range(W.shape[0]):
@@ -210,7 +210,7 @@ def _conv_implementation(  # type: ignore
                                 s = np.dot(img.reshape((1, -1)), w.reshape((-1, 1)))[
                                     0, 0
                                 ]  # (img * w).sum()
-                            res[n, nw, hr, wr] += s  # type: ignore
+                            res[n, nw, hr, wr] += s
 
         return res
 
@@ -229,7 +229,7 @@ def _conv_implementation(  # type: ignore
         eh, ew, ez = h_out * sth, w_out * stw, z_out * stz
         res = np.zeros((X.shape[0], W.shape[0], h_out, w_out, z_out))  # type: ignore[assignment]
         if B is not None:
-            res[:, :, :, :, :] = B.reshape((1, -1, 1, 1, 1))  # type: ignore
+            res[:, :, :, :, :] = B.reshape((1, -1, 1, 1, 1))
 
         for n in range(sN):
             for nw in range(W.shape[0]):
@@ -281,7 +281,7 @@ def _conv_implementation(  # type: ignore
                                     s = np.dot(
                                         img.reshape((1, -1)), w.reshape((-1, 1))
                                     )[0, 0]  # (img * w).sum()
-                                res[n, nw, hr, wr, zr] += s  # type: ignore
+                                res[n, nw, hr, wr, zr] += s
 
         return res
 
@@ -292,7 +292,7 @@ def _conv_implementation(  # type: ignore
 
 
 class Conv(OpRun):
-    def _run(  # type: ignore
+    def _run(
         self,
         X,
         W,

onnx/reference/ops/op_conv_integer.py

@@ -10,7 +10,7 @@ from onnx.reference.ops.op_conv import _conv_implementation
 
 
 class ConvInteger(OpRun):
-    def _run(  # type: ignore
+    def _run(
         self,
         X,
         W,
@@ -27,12 +27,12 @@ class ConvInteger(OpRun):
             raise ValueError(
                 f"X must have at least 3 dimensions but its shape is {X.shape}."
             )
-        auto_pad = auto_pad or self.auto_pad  # type: ignore
-        dilations = dilations or self.dilations  # type: ignore
-        group = group or self.group  # type: ignore
-        kernel_shape = kernel_shape or self.kernel_shape  # type: ignore
-        pads = pads or self.pads  # type: ignore
-        strides = strides or self.strides  # type: ignore
+        auto_pad = auto_pad or self.auto_pad
+        dilations = dilations or self.dilations
+        group = group or self.group
+        kernel_shape = kernel_shape or self.kernel_shape
+        pads = pads or self.pads
+        strides = strides or self.strides
 
         X = X.astype(np.int32)
         if x_zero_point: