onnx 1.18.0__cp310-cp310-win_amd64.whl → 1.19.1rc1__cp310-cp310-win_amd64.whl

onnx/reference/ops/op_grid_sample.py

@@ -13,7 +13,7 @@ from onnx.reference.ops.op_resize import _get_all_coords
 
 class GridSample(OpRun):
     # https://github.com/pytorch/pytorch/blob/v2.0.0/aten/src/ATen/native/GridSampler.h#L26
-    def _gs_denormalize(self, n, length: int, align_corners: bool):  # type: ignore
+    def _gs_denormalize(self, n, length: int, align_corners: bool):
         # n is the normalized coordinate (float)
         # x is the unormalized coordinate (float)
         if align_corners:
@@ -49,7 +49,7 @@ class GridSample(OpRun):
             x[i] = self._gs_denormalize(n=v, length=dim, align_corners=align_corners)
         return x
 
-    def _gs_reflect(self, x, x_min, x_max):  # type: ignore
+    def _gs_reflect(self, x, x_min, x_max):
         """Reflect by the near border till within the borders
         Use float for borders to avoid potential issues with integer T
         """
@@ -73,7 +73,7 @@ class GridSample(OpRun):
                 fx = x_min + r
         return fx
 
-    def _gs_get_cubic_coeffs(self, x, coeffs):  # type: ignore
+    def _gs_get_cubic_coeffs(self, x, coeffs):
         """Calculate cubic convolution interpolation coefficients
         ROBERT G. KEYS https://ieeexplore.ieee.org/document/1163711
         Use float to avoid potential issues with integer.
@@ -96,7 +96,7 @@ class GridSample(OpRun):
         coeffs[0] = 1 - x
         coeffs[1] = x
 
-    def _gs_bicubic_interpolate(self, p, x, y):  # type: ignore
+    def _gs_bicubic_interpolate(self, p, x, y):
         v = np.empty((4,), dtype=p.dtype)
         coeffs = np.empty((4,), dtype=p.dtype)
         self._gs_get_cubic_coeffs(x, coeffs)
@@ -197,14 +197,14 @@ class GridSample(OpRun):
             padding_mode=padding_mode,
         )
 
-    def _clamp(self, val, lo, hi):  # type: ignore
+    def _clamp(self, val, lo, hi):
         if val < lo:
             return lo
         if val > hi:
             return hi
         return val
 
-    def _pixel_at_ndarray(self, ndarray, x: list, border, padding_mode):  # type: ignore
+    def _pixel_at_ndarray(self, ndarray, x: list, border, padding_mode):
         # boarder: [x_1_min, x_2_min, ..., x_1_max, x_2_max, ...]
         num_dims = ndarray.ndim
         assert num_dims == len(x) == int(len(border) / 2)
@@ -235,7 +235,7 @@ class GridSample(OpRun):
             padding_mode=padding_mode,
         )
 
-    def _pixel_at_array(self, array, i: int, border, padding_mode):  # type: ignore
+    def _pixel_at_array(self, array, i: int, border, padding_mode):
         assert array.ndim == 1
         d = array.shape[0]
         if padding_mode == "zeros":
@@ -289,9 +289,9 @@ class GridSample(OpRun):
     def _run(self, X, grid, mode=None, padding_mode=None, align_corners=None):
         # This implementation supports GridSample arbitrary dimensions.
 
-        mode = mode or self.mode  # type: ignore
-        padding_mode = padding_mode or self.padding_mode  # type: ignore
-        align_corners = align_corners or self.align_corners  # type: ignore
+        mode = mode or self.mode
+        padding_mode = padding_mode or self.padding_mode
+        align_corners = align_corners or self.align_corners
 
         x_dims = X.shape
         grid_dims = grid.shape

onnx/reference/ops/op_gru.py

@@ -9,18 +9,18 @@ from onnx.reference.op_run import OpRun
 
 
 class CommonGRU(OpRun):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRun.__init__(self, onnx_node, run_params)
         self.n_outputs = len(onnx_node.output)
         self.number_of_gates = 3
 
-    def f(self, x):  # type: ignore
+    def f(self, x):
         return 1 / (1 + np.exp(-x))
 
-    def g(self, x):  # type: ignore
+    def g(self, x):
         return np.tanh(x)
 
-    def _step(self, X, R, B, W, H_0, num_directions):  # type: ignore
+    def _step(self, X, R, B, W, H_0, num_directions):
         seq_length = X.shape[0]
         hidden_size = H_0.shape[-1]
         batch_size = X.shape[1]
@@ -52,7 +52,7 @@ class CommonGRU(OpRun):
                 + r * (np.dot(H_t, np.transpose(r_h)) + r_bh)
                 + w_bh
             )
-            h = h_linear if self.linear_before_reset else h_default  # type: ignore
+            h = h_linear if self.linear_before_reset else h_default
             H = (1 - z) * h + z * H_t
             h_list.append(H)
             H_t = H
@@ -61,7 +61,7 @@ class CommonGRU(OpRun):
         if num_directions == 1:
             Y[:, 0, :, :] = concatenated
 
-        if self.layout == 0:  # type: ignore
+        if self.layout == 0:
             Y_h = Y[-1]
         else:
             Y = np.transpose(Y, [2, 0, 1, 3])
@@ -69,7 +69,7 @@ class CommonGRU(OpRun):
 
         return Y, Y_h
 
-    def _run(  # type: ignore
+    def _run(
         self,
         X,
         W,
@@ -128,5 +128,5 @@ class CommonGRU(OpRun):
 
 
 class GRU(CommonGRU):
-    def __init__(self, onnx_node, run_params):  # type: ignore
-        CommonGRU.__init__(self, onnx_node, run_params)  # type: ignore
+    def __init__(self, onnx_node, run_params):
+        CommonGRU.__init__(self, onnx_node, run_params)

onnx/reference/ops/op_hamming_window.py

@@ -15,7 +15,7 @@ class HammingWindow(_CommonWindow):
     `alpha=0.54, beta=0.46`
     """
 
-    def _run(self, size, output_datatype=None, periodic=None):  # type: ignore
+    def _run(self, size, output_datatype=None, periodic=None):
         ni, N_1 = self._begin(size, periodic, output_datatype)
         alpha = 25.0 / 46.0
         beta = 1 - alpha

onnx/reference/ops/op_hann_window.py

@@ -14,7 +14,7 @@ class HannWindow(_CommonWindow):
     See `hann_window <https://pytorch.org/docs/stable/generated/torch.hann_window.html>`_
     """
 
-    def _run(self, size, output_datatype=None, periodic=None):  # type: ignore
+    def _run(self, size, output_datatype=None, periodic=None):
         ni, N_1 = self._begin(size, periodic, output_datatype)
         res = np.sin(ni * np.pi / N_1) ** 2
         return self._end(size, res, output_datatype)

onnx/reference/ops/op_hard_sigmoid.py

@@ -9,8 +9,8 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class HardSigmoid(OpRunUnaryNum):
-    def _run(self, x, alpha=None, beta=None):  # type: ignore
-        alpha = alpha or self.alpha  # type: ignore
-        beta = beta or self.beta  # type: ignore
-        y = np.maximum(0, np.minimum(1, x * alpha + beta))
+    def _run(self, x, alpha=None, beta=None):
+        alpha = alpha or self.alpha
+        beta = beta or self.beta
+        y = np.maximum(0, np.minimum(1, x * alpha + beta)).astype(x.dtype)
         return (y,)

onnx/reference/ops/op_hardmax.py

@@ -9,14 +9,16 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Hardmax(OpRunUnaryNum):
-    def _run(self, x, axis=None):  # type: ignore
-        axis = axis or self.axis  # type: ignore
-        x_argmax = np.argmax(x, axis=axis)  # type: ignore
+    def _run(self, x, axis=None):
+        axis = axis or self.axis
+        if x.size == 0:
+            return (x,)
+        x_argmax = np.argmax(x, axis=axis)
         y = np.zeros_like(x)
         np.put_along_axis(
             y,
             np.expand_dims(x_argmax, axis=axis),
             1,
-            axis=axis,  # type: ignore
+            axis=axis,
         )
         return (y,)

onnx/reference/ops/op_identity.py

@@ -7,7 +7,7 @@ from onnx.reference.op_run import OpRun
 
 
 class Identity(OpRun):
-    def _run(self, a):  # type: ignore
+    def _run(self, a):
         if a is None:
             return (None,)
         return (a.copy(),)

onnx/reference/ops/op_if.py

@@ -13,7 +13,7 @@ if TYPE_CHECKING:
 
 
 class If(OpRun):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRun.__init__(self, onnx_node, run_params)
         if "opsets" not in self.run_params:
             raise KeyError("run_params must contains key 'opsets'.")
@@ -42,16 +42,16 @@ class If(OpRun):
             raise ValueError(
                 f"Operator If ({self.onnx_node.name!r}) expects a single element as condition, but the size of 'cond' is {len(cond)}."
             )
-        cond_ = cond.item(0)
+        cond_ = cond.item()
         if cond_:
             self._log("  -- then> {%r}", context)
-            outputs = self._run_then_branch(context, attributes=attributes)  # type: ignore
+            outputs = self._run_then_branch(context, attributes=attributes)
             self._log("  -- then<")
             final = tuple(outputs)
             branch = "then"
         else:
             self._log("  -- else> {%r}", context)
-            outputs = self._run_else_branch(context, attributes=attributes)  # type: ignore
+            outputs = self._run_else_branch(context, attributes=attributes)
             self._log("  -- else<")
             final = tuple(outputs)
             branch = "else"
@@ -62,7 +62,7 @@ class If(OpRun):
             )
         for i, f in enumerate(final):
             if f is None:
-                br = self.then_branch if branch == "then" else self.else_branch  # type: ignore
+                br = self.then_branch if branch == "then" else self.else_branch
                 names = br.output_names
                 inits = [i.name for i in br.obj.graph.initializer]
                 raise RuntimeError(

onnx/reference/ops/op_image_decoder.py

@@ -12,9 +12,9 @@ from onnx.reference.op_run import OpRun
 
 
 class ImageDecoder(OpRun):
-    def _run(self, encoded: np.ndarray, pixel_format="RGB") -> tuple[np.ndarray]:  # type: ignore
+    def _run(self, encoded: np.ndarray, pixel_format="RGB") -> tuple[np.ndarray]:
         try:
-            import PIL.Image
+            import PIL.Image  # noqa: PLC0415
         except ImportError as e:
             raise ImportError(
                 "Pillow must be installed to use the reference implementation of the ImageDecoder operator"

onnx/reference/ops/op_instance_normalization.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class InstanceNormalization(OpRun):
-    def _run(self, x, s, bias, epsilon=None):  # type: ignore
+    def _run(self, x, s, bias, epsilon=None):
         dims_x = len(x.shape)
         axis = tuple(range(2, dims_x))
         mean = np.mean(x, axis=axis, keepdims=True)

onnx/reference/ops/op_isinf.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class IsInf(OpRun):
-    def _run(self, data, detect_negative=None, detect_positive=None):  # type: ignore
+    def _run(self, data, detect_negative=None, detect_positive=None):
         if detect_negative:
             if detect_positive:
                 return (np.isinf(data),)

onnx/reference/ops/op_isnan.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunUnary
 
 
 class IsNaN(OpRunUnary):
-    def _run(self, data):  # type: ignore
+    def _run(self, data):
         return (np.isnan(data),)

onnx/reference/ops/op_layer_normalization.py

@@ -26,7 +26,7 @@ def _layer_normalization(
     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):
@@ -65,7 +65,7 @@ def _layer_normalization(
 
 
 class LayerNormalization(OpRun):
-    def _run(self, X, Scale, B=None, axis=None, epsilon=None, stash_type=None):  # type: ignore
+    def _run(self, X, Scale, B=None, axis=None, epsilon=None, stash_type=None):
         if stash_type != 1:
             raise NotImplementedError(
                 f"LayerNormalization not implemented for stash_type={stash_type} != 1."

onnx/reference/ops/op_leaky_relu.py

@@ -14,10 +14,10 @@ if TYPE_CHECKING:
 def _leaky_relu(x: np.ndarray, alpha: float) -> np.ndarray:
     sign = (x > 0).astype(x.dtype)
     sign -= ((sign - 1) * alpha).astype(x.dtype)
-    return x * sign  # type: ignore
+    return x * sign
 
 
 class LeakyRelu(OpRunUnaryNum):
-    def _run(self, x, alpha=None):  # type: ignore
-        alpha = alpha or self.alpha  # type: ignore
+    def _run(self, x, alpha=None):
+        alpha = alpha or self.alpha
         return (_leaky_relu(x, alpha).astype(x.dtype),)

onnx/reference/ops/op_less.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunBinaryComparison
 
 
 class Less(OpRunBinaryComparison):
-    def _run(self, a, b):  # type: ignore
+    def _run(self, a, b):
         return (np.less(a, b),)

onnx/reference/ops/op_less_or_equal.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunBinaryComparison
 
 
 class LessOrEqual(OpRunBinaryComparison):
-    def _run(self, a, b):  # type: ignore
+    def _run(self, a, b):
         return (np.less_equal(a, b),)

onnx/reference/ops/op_log.py

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

onnx/reference/ops/op_log_softmax.py

@@ -9,7 +9,7 @@ from onnx.reference.ops.op_softmax import Softmax
 
 
 class LogSoftmax(Softmax):
-    def _run(self, X):  # type: ignore
+    def _run(self, X):
         Y = Softmax._run(self, X)[0]
         np.log(Y, out=Y)
         return (Y,)

onnx/reference/ops/op_loop.py

@@ -9,15 +9,15 @@ from onnx.reference.op_run import OpRun
 
 
 class Loop(OpRun):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRun.__init__(self, onnx_node, run_params)
         if "opsets" not in self.run_params:
             raise KeyError("run_params must contains key 'opsets'.")
         if "verbose" not in run_params:
             raise KeyError("run_params must contains key 'verbose'.")
-        self.output_index = {n: i for i, n in enumerate(self.body.output_names)}  # type: ignore
-        self.N = len(self.body.input_names) - 2  # type: ignore
-        self.K = len(self.body.output_names) - self.N - 1  # type: ignore
+        self.output_index = {n: i for i, n in enumerate(self.body.output_names)}
+        self.N = len(self.body.input_names) - 2
+        self.K = len(self.body.output_names) - self.N - 1
 
     def need_context(self) -> bool:
         """The operator Loop needs to know all results produced
@@ -27,7 +27,7 @@ class Loop(OpRun):
         """
         return True
 
-    def _run(self, M, cond, *args, context=None, body=None, attributes=None):  # type: ignore
+    def _run(self, M, cond, *args, context=None, body=None, attributes=None):
         if args:
             v_initial = args[0]
             args = args[1:]
@@ -35,9 +35,9 @@ class Loop(OpRun):
             v_initial = None
         if M is not None and not hasattr(M, "dtype"):
             raise TypeError(f"M must be empty or an array but its type is {type(M)}.")
-        body = self.body  # type: ignore
+        body = self.body
         loop_inputs = body.input_names
-        inputs = {name: None for name in loop_inputs}
+        inputs = dict.fromkeys(loop_inputs)
         if v_initial is not None:
             inputs[loop_inputs[2]] = v_initial
         cond_name = body.output_names[0]
@@ -45,22 +45,22 @@ class Loop(OpRun):
             begin = len(loop_inputs) - len(args)
             all_inputs = loop_inputs[begin:]
             for name, val in zip(all_inputs, args):
-                inputs[name] = val  # noqa: PERF403
+                inputs[name] = val
         if context is not None:
             for a in context:
                 inputs[a] = context[a]
 
-        k_carried_away = [[] for i in range(self.K)]  # type: ignore
+        k_carried_away = [[] for i in range(self.K)]
         it = 0
         while cond and (M is None or it < M):
             self._log("  -- loop> {%r}", context)
             if len(body.input_names) > 0 and body.input_names[0] is not None:
                 inputs[body.input_names[0]] = np.array(
                     it, dtype=None if M is None else M.dtype
-                )  # type: ignore
+                )
             if len(body.input_names) > 1 and body.input_names[1] is not None:
                 inputs[body.input_names[1]] = cond
-            outputs = self._run_body(inputs, attributes=attributes)  # type: ignore
+            outputs = self._run_body(inputs, attributes=attributes)
             if self.K > 0:
                 for k in range(self.K):
                     k_carried_away[k].append(outputs[-self.K + k])

onnx/reference/ops/op_lp_normalization.py

@@ -9,9 +9,9 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class LpNormalization(OpRunUnaryNum):
-    def _run(self, x, axis=None, p=None):  # type: ignore
-        axis = axis or self.axis  # type: ignore
-        p = p or self.p  # type: ignore
-        norm = np.power(np.power(x, p).sum(axis=axis), 1.0 / p)  # type: ignore
-        norm = np.expand_dims(norm, axis)  # type: ignore
+    def _run(self, x, axis=None, p=None):
+        axis = axis or self.axis
+        p = p or self.p
+        norm = np.power(np.power(x, p).sum(axis=axis), 1.0 / p)
+        norm = np.expand_dims(norm, axis)
         return ((x / norm).astype(x.dtype),)

onnx/reference/ops/op_lp_pool.py

@@ -9,7 +9,7 @@ from onnx.reference.ops.op_pool_common import CommonPool
 
 
 class LpPool(CommonPool):
-    def _run(  # type: ignore
+    def _run(
         self,
         x,
         auto_pad=None,

onnx/reference/ops/op_lrn.py

@@ -11,15 +11,15 @@ from onnx.reference.op_run import OpRun
 
 
 class LRN(OpRun):
-    def _run(self, x, alpha=None, beta=None, bias=None, size=None):  # type: ignore
+    def _run(self, x, alpha=None, beta=None, bias=None, size=None):
         if len(x.shape) != 4:
             raise RuntimeError(
                 f"LRN only applies on 4D tensors but shape is {x.shape!r}."
             )
         square_sum = np.zeros(x.shape).astype(x.dtype)
         minc = x.shape[1]
-        c1 = int(math.floor((size - 1) / 2))
-        c2 = int(math.ceil((size - 1) / 2)) + 1
+        c1 = math.floor((size - 1) / 2)
+        c2 = math.ceil((size - 1) / 2) + 1
         for c in range(x.shape[0]):
             begin = max(0, c - c1)
             end = min(minc, c + c2)

onnx/reference/ops/op_lstm.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class CommonLSTM(OpRun):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRun.__init__(self, onnx_node, run_params)
         self.n_outputs = len(onnx_node.output)
         self.n_gates = 3
@@ -65,15 +65,15 @@ class CommonLSTM(OpRun):
         if num_directions == 1:
             Y[:, 0, :, :] = concatenated
 
-        if self.layout == 0:  # type: ignore
+        if self.layout == 0:
             Y_h = Y[-1]
         else:
             Y = np.transpose(Y, [2, 0, 1, 3])
             Y_h = Y[:, :, -1, :]
 
-        return Y, Y_h  # type: ignore
+        return Y, Y_h
 
-    def _run(  # type: ignore
+    def _run(
         self,
         X,
         W,
@@ -127,7 +127,7 @@ class CommonLSTM(OpRun):
             hidden_size = R.shape[-1]
             batch_size = X.shape[1]
 
-            if self.layout != 0:  # type: ignore
+            if self.layout != 0:
                 X = np.swapaxes(X, 0, 1)
             if B is None:
                 B = np.zeros(2 * n_gates * hidden_size, dtype=np.float32)
@@ -147,9 +147,9 @@ class CommonLSTM(OpRun):
             X, R, B, W, initial_h, initial_c, P, num_directions=num_directions
         )
         Y = Y.astype(X.dtype)
-        return (Y,) if self.n_outputs == 1 else (Y, Y_h.astype(X.dtype))  # type: ignore
+        return (Y,) if self.n_outputs == 1 else (Y, Y_h.astype(X.dtype))
 
 
 class LSTM(CommonLSTM):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         CommonLSTM.__init__(self, onnx_node, run_params)

onnx/reference/ops/op_matmul.py

@@ -8,7 +8,7 @@ import numpy as np
 from onnx.reference.ops._op import OpRunBinaryNum
 
 
-def numpy_matmul(a, b):  # type: ignore
+def numpy_matmul(a, b):
     """Implements a matmul product. See :func:`np.matmul`.
     Handles sparse matrices.
     """
@@ -21,5 +21,5 @@ def numpy_matmul(a, b):  # type: ignore
 
 
 class MatMul(OpRunBinaryNum):
-    def _run(self, a, b):  # type: ignore
+    def _run(self, a, b):
         return (numpy_matmul(a, b),)

onnx/reference/ops/op_matmul_integer.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class MatMulInteger(OpRun):
-    def _run(self, A, B, a_zero_point=None, b_zero_point=None):  # type: ignore
+    def _run(self, A, B, a_zero_point=None, b_zero_point=None):
         A32 = A.astype(np.int32)
         if a_zero_point is not None:
             A32 -= a_zero_point

onnx/reference/ops/op_max.py

@@ -9,10 +9,10 @@ from onnx.reference.ops._op import OpRunBinaryNumpy
 
 
 class Max(OpRunBinaryNumpy):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRunBinaryNumpy.__init__(self, np.maximum, onnx_node, run_params)
 
-    def run(self, *data):  # type: ignore
+    def run(self, *data):
         if len(data) == 2:
             return OpRunBinaryNumpy.run(self, *data)
         if len(data) == 1:

onnx/reference/ops/op_max_pool.py

@@ -9,7 +9,7 @@ from onnx.reference.ops._op_common_pool import CommonPool
 
 
 class MaxPool(CommonPool):
-    def _run(  # type: ignore
+    def _run(
         self,
         x,
         auto_pad=None,
@@ -51,7 +51,7 @@ class MaxPool(CommonPool):
             strides=strides,
         )
 
-    def _max_pool(  # type: ignore
+    def _max_pool(
         self,
         x,
         auto_pad,
@@ -179,7 +179,7 @@ class MaxPool(CommonPool):
 
         raise RuntimeError(f"Not implemented yet for shape {x.shape}.")
 
-    def _max_pool_1d(  # type: ignore
+    def _max_pool_1d(
         self,
         x,
         auto_pad,  # noqa: ARG002
@@ -231,11 +231,11 @@ class MaxPool(CommonPool):
         for c in range(total_channels):
             iteration(c)
 
-        if len(self.output) == 1:  # type: ignore
+        if len(self.output) == 1:
             return (Y_data.reshape(y_dims),)
         return (Y_data.reshape(y_dims), I_data.reshape(y_dims))
 
-    def _max_pool_2d(  # type: ignore
+    def _max_pool_2d(
         self,
         x,
         auto_pad,  # noqa: ARG002
@@ -270,7 +270,7 @@ class MaxPool(CommonPool):
         Y_data = y.ravel()
         I_data = indices.ravel()
 
-        def iteration(c):  # type: ignore
+        def iteration(c):
             x_d = c * x_step  # X_data
             y_d = c * y_step  # Y_data
             for ph in range(pooled_height):
@@ -308,11 +308,11 @@ class MaxPool(CommonPool):
         for c in range(total_channels):
             iteration(c)
 
-        if len(self.output) == 1:  # type: ignore
+        if len(self.output) == 1:
             return (Y_data.reshape(y_dims),)
         return (Y_data.reshape(y_dims), I_data.reshape(y_dims))
 
-    def _max_pool_3d(  # type: ignore
+    def _max_pool_3d(
         self,
         x,
         auto_pad,  # noqa: ARG002
@@ -408,6 +408,6 @@ class MaxPool(CommonPool):
         for c in range(total_channels):
             iteration(c)
 
-        if len(self.output) == 1:  # type: ignore
+        if len(self.output) == 1:
             return (Y_data.reshape(y_dims),)
         return (Y_data.reshape(y_dims), I_data.reshape(y_dims))

onnx/reference/ops/op_max_unpool.py

@@ -11,15 +11,15 @@ from onnx.reference.op_run import OpRun
 class MaxUnpool(OpRun):
     def _run(
         self, X, indices, output_shape=None, kernel_shape=None, pads=None, strides=None
-    ):  # type: ignore
+    ):
         pooling_dims = len(X.shape) - 2
         if pooling_dims > 3:
             raise NotImplementedError(
                 f"Unsupported pooling size {pooling_dims} for operator MaxUnpool."
             )
-        kernel_shape = kernel_shape or self.kernel_shape  # type: ignore
-        pads = pads or self.pads  # type: ignore
-        strides = strides or self.strides  # type: ignore
+        kernel_shape = kernel_shape or self.kernel_shape
+        pads = pads or self.pads
+        strides = strides or self.strides
 
         if strides is None:
             strides = [1 for d in kernel_shape]

onnx/reference/ops/op_mean.py

@@ -7,7 +7,7 @@ from onnx.reference.op_run import OpRun
 
 
 class Mean(OpRun):
-    def _run(self, *args):  # type: ignore
+    def _run(self, *args):
         res = args[0].copy()
         for m in args[1:]:
             res += m

onnx/reference/ops/op_mel_weight_matrix.py

@@ -10,7 +10,7 @@ from onnx.reference.op_run import OpRun
 
 
 class MelWeightMatrix(OpRun):
-    def _run(  # type: ignore
+    def _run(
         self,
         num_mel_bins,
         dft_length,