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

onnx/reference/ops/op_conv_transpose.py

@@ -10,7 +10,7 @@ from onnx.reference.ops.op_col2im import col2im_naive_implementation
 
 
 class ConvTranspose(OpRun):
-    def _run(  # type: ignore
+    def _run(
         self,
         X,
         W,
@@ -94,7 +94,7 @@ class ConvTranspose(OpRun):
                     )
                     if final is None:
                         final = np.empty(
-                            X.shape[:1] + (num_output_channels,) + res.shape,
+                            (*X.shape[:1], num_output_channels, *res.shape),
                             dtype=X.dtype,
                         )
                     if B is not None:

onnx/reference/ops/op_cos.py

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

onnx/reference/ops/op_cosh.py

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

onnx/reference/ops/op_cum_sum.py

@@ -9,27 +9,27 @@ from onnx.reference.op_run import OpRun
 
 
 class CumSum(OpRun):
-    def _run(self, x, axis, exclusive=None, reverse=None):  # type: ignore
+    def _run(self, x, axis, exclusive=None, reverse=None):
         if not isinstance(axis, (np.int32, np.int64)):
-            if len(axis.shape) > 1 or (len(axis.shape) > 0 and axis.shape[0] != 1):  # type: ignore
+            if len(axis.shape) > 1 or (len(axis.shape) > 0 and axis.shape[0] != 1):
                 raise RuntimeError(
-                    f"axis must be an array of one number not {axis} (shape {axis.shape})."  # type: ignore
+                    f"axis must be an array of one number not {axis} (shape {axis.shape})."
                 )
-            if len(axis.shape) > 0:  # type: ignore
+            if len(axis.shape) > 0:
                 axis = axis[0]
         if reverse:
             rev_indices = [slice(0, s) for s in x.shape]
-            rev_indices[axis] = slice(None, None, -1)  # type: ignore
+            rev_indices[axis] = slice(None, None, -1)
             x = x[tuple(rev_indices)]
         if exclusive:
             indices_c = [slice(0, s) for s in x.shape]
             indices_d = [slice(0, s) for s in x.shape]
-            indices_c[axis] = slice(0, -1)  # type: ignore
-            indices_d[axis] = slice(1, x.shape[axis])  # type: ignore
+            indices_c[axis] = slice(0, -1)
+            indices_d[axis] = slice(1, x.shape[axis])
             res = np.zeros(x.shape, dtype=x.dtype)
-            np.cumsum(x[tuple(indices_c)], axis=axis, out=res[tuple(indices_d)])  # type: ignore
+            np.cumsum(x[tuple(indices_c)], axis=axis, out=res[tuple(indices_d)])
         else:
-            res = np.cumsum(x, axis=axis, dtype=x.dtype)  # type: ignore
+            res = np.cumsum(x, axis=axis, dtype=x.dtype)
         if reverse:
             res = res[tuple(rev_indices)]
         return (res,)

onnx/reference/ops/op_deform_conv.py

@@ -6,9 +6,10 @@ from __future__ import annotations
 import numpy as np
 
 from onnx.reference.op_run import OpRun
+from onnx.reference.ops import op_grid_sample
 
 
-def _deform_conv_implementation(  # type: ignore
+def _deform_conv_implementation(
     X, W, offset, B, mask, dilations, group, kernel_shape, offset_group, pads, strides
 ):
     if dilations is None:
@@ -51,8 +52,6 @@ def _deform_conv_implementation(  # type: ignore
         mask = np.ones((n, offset_group * np.prod(kernel_shape), *output_shape))
     mask = mask.reshape((n, offset_group, *kernel_shape, *output_shape))
 
-    from onnx.reference.ops._op_list import GridSample
-
     if len(X.shape) == 4:
         ih, iw = X.shape[2:]
         oh, ow = offset.shape[-2:]
@@ -117,7 +116,7 @@ def _deform_conv_implementation(  # type: ignore
                             kernel = np.flip(
                                 kernel, 3
                             )  # spatial GridSample expects (x, y) input
-                            grid_sample_output = GridSample.eval(
+                            grid_sample_output = op_grid_sample.GridSample.eval(
                                 X[batch_idx : batch_idx + 1, ic_idx : ic_idx + 1],
                                 kernel,
                                 align_corners=1,
@@ -142,7 +141,7 @@ def _deform_conv_implementation(  # type: ignore
 
 
 class DeformConv(OpRun):
-    def _run(  # type: ignore
+    def _run(
         self,
         X,
         W,

onnx/reference/ops/op_depth_to_space.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class DepthToSpace(OpRun):
-    def _run(self, data, blocksize=None, mode=None):  # type: ignore
+    def _run(self, data, blocksize=None, mode=None):
         if len(data.shape) != 4:
             raise RuntimeError(f"Unexpected shape {data.shape!r}.")
         b, c, h, w = data.shape

onnx/reference/ops/op_dequantize_linear.py

@@ -6,56 +6,71 @@ from __future__ import annotations
 import numpy as np
 
 from onnx import TensorProto
-from onnx._custom_element_types import (
-    float4e2m1,
-    float8e4m3fn,
-    float8e4m3fnuz,
-    float8e5m2,
-    float8e5m2fnuz,
-    int4,
-    uint4,
-)
 from onnx.helper import np_dtype_to_tensor_dtype, tensor_dtype_to_np_dtype
-from onnx.numpy_helper import (
-    float8e4m3_to_float32,
-    float8e5m2_to_float32,
-    unpacked_float4e2m1_to_float32,
-)
 from onnx.reference.op_run import OpRun
-from onnx.reference.ops.op_quantize_linear import reshape_input
 
 
-class _CommonDequantizeLinear(OpRun):
-    def get_x_type(self, x: np.ndarray) -> int:
-        tensor_dtype = None
-        if x.dtype == float8e4m3fn and x.dtype.descr[0][0] == "e4m3fn":
-            tensor_dtype = TensorProto.FLOAT8E4M3FN
-        elif x.dtype == float8e4m3fnuz and x.dtype.descr[0][0] == "e4m3fnuz":
-            tensor_dtype = TensorProto.FLOAT8E4M3FNUZ
-        elif x.dtype == float8e5m2 and x.dtype.descr[0][0] == "e5m2":
-            tensor_dtype = TensorProto.FLOAT8E5M2
-        elif x.dtype == float8e5m2fnuz and x.dtype.descr[0][0] == "e5m2fnuz":
-            tensor_dtype = TensorProto.FLOAT8E5M2FNUZ
-        elif x.dtype == uint4 and x.dtype.descr[0][0] == "uint4":
-            tensor_dtype = TensorProto.UINT4
-        elif x.dtype == int4 and x.dtype.descr[0][0] == "int4":
-            tensor_dtype = TensorProto.INT4
-        elif x.dtype == float4e2m1 and x.dtype.descr[0][0] == "float4e2m1":
-            tensor_dtype = TensorProto.FLOAT4E2M1
-        else:
-            tensor_dtype = np_dtype_to_tensor_dtype(x.dtype)
-        return tensor_dtype
+def _reshape_input(
+    value: np.ndarray,
+    shape: tuple[int, ...],
+    axis: int,
+    block_size: int | None = None,
+) -> np.ndarray:
+    """Reshape/Replicate scale/zero-point to be broadcastable to shape.
+
+    Args:
+        value: the array to be reshaped/replicated
+        shape: the target shape
+        axis: quantization axis, applicable for per-axis and blocked quantization
+        block_size: size of quantization block, applicable only for blocked quantization
+
+    Returns:
+        value array after reshape/replicate according to quantization mode.
+    """
+    if len(value.shape) == 0:
+        return value
+    if len(value.shape) > 0 and value.size == 1:
+        return value[0]
+    if not block_size:
+        assert len(value.shape) == 1
+        dims = [1] * len(shape)
+        try:
+            dims[axis] = value.size
+            return value.reshape(tuple(dims))
+        except IndexError as e:
+            raise IndexError(
+                f"axis is out of boundary, axis={axis}, "
+                f"value.shape={value.shape}, shape={shape}."
+            ) from e
+
+    if block_size <= 0:
+        raise ValueError("block_size must be a positive integer.")
 
+    # repeat scale to get element-wise scale
+    value = np.repeat(value, repeats=block_size, axis=axis)
+    if (
+        shape[axis] != value.shape[axis]
+    ):  # block_size does not divide x, handle the remainder block
+        value = value.take(indices=range(shape[axis]), axis=axis)
+    if value.shape != shape:
+        raise ValueError(
+            "Invalid shapes for Blocked Quantization. Input 2 shape should identical to Input 1 shape, except for one dimension, in which blocking is performed"
+        )
+    assert np.broadcast_shapes(shape, value.shape) == shape
+    return value
+
+
+class _CommonDequantizeLinear(OpRun):
     def _run(
         self,
         x: np.ndarray,
         x_scale: np.ndarray,
         x_zero_point: np.ndarray | None = None,
-        axis: int | None = None,
-        block_size: int | None = None,
+        axis: int = 1,
+        block_size: int = 0,
         output_dtype: int | None = None,
-    ):  # type: ignore
-        x_type = self.get_x_type(x)
+    ):
+        x_type = np_dtype_to_tensor_dtype(x.dtype)
         fp8_type = x_type in {
             TensorProto.FLOAT8E4M3FN,
             TensorProto.FLOAT8E4M3FNUZ,
@@ -67,13 +82,13 @@ class _CommonDequantizeLinear(OpRun):
             and not fp8_type
             and x_type != TensorProto.FLOAT4E2M1
         ):
-            zero_type = self.get_x_type(x_zero_point)
+            zero_type = np_dtype_to_tensor_dtype(x_zero_point.dtype)
             if x_type != zero_type:
                 raise ValueError(
                     f"Type mismatch {x_type} != {zero_type} in DequantizeLinear."
                 )
 
-            dx = x.astype(np.float32) - reshape_input(
+            dx = x.astype(np.float32) - _reshape_input(
                 x_zero_point, x.shape, axis, block_size
             )
         else:
@@ -85,19 +100,8 @@ class _CommonDequantizeLinear(OpRun):
                     raise ValueError(
                         "x_zero_point is not null but should be zero for float8 types."
                     )
-            if x_type == TensorProto.FLOAT8E4M3FN:
-                dx = float8e4m3_to_float32(x)
-            elif x_type == TensorProto.FLOAT8E4M3FNUZ:
-                dx = float8e4m3_to_float32(x, uz=True)
-            elif x_type == TensorProto.FLOAT8E5M2:
-                dx = float8e5m2_to_float32(x)
-            elif x_type == TensorProto.FLOAT8E5M2FNUZ:
-                dx = float8e5m2_to_float32(x, fn=True, uz=True)
-            elif x_type == TensorProto.FLOAT4E2M1:
-                dx = unpacked_float4e2m1_to_float32(x)
-            else:
-                dx = x.astype(np.float32)
-        y = dx * reshape_input(x_scale, x.shape, axis, block_size)
+            dx = x.astype(np.float32)
+        y = dx * _reshape_input(x_scale, x.shape, axis, block_size)
         return (
             y.astype(
                 tensor_dtype_to_np_dtype(output_dtype)
@@ -108,21 +112,21 @@ class _CommonDequantizeLinear(OpRun):
 
 
 class DequantizeLinear_19(_CommonDequantizeLinear):
-    def _run(self, x, x_scale, x_zero_point=None, axis=None):
+    def _run(self, x, x_scale, x_zero_point=None, axis: int = 1):
         if len(x_scale.shape) > 1:
             raise ValueError("Input 2 must be a vector or a number.")
         return super()._run(x, x_scale, x_zero_point, axis)
 
 
 class DequantizeLinear_21(_CommonDequantizeLinear):
-    def _run(self, *args, axis=None, block_size=None):  # type: ignore
+    def _run(self, *args, axis: int = 1, block_size: int = 0):
         # args: x, y_scale, zero_point
-        return super()._run(*args, axis=axis, block_size=block_size)  # type: ignore
+        return super()._run(*args, axis=axis, block_size=block_size)
 
 
 class DequantizeLinear_23(_CommonDequantizeLinear):
-    def _run(self, *args, axis=None, block_size=None, output_dtype=None):  # type: ignore
+    def _run(self, *args, axis: int = 1, block_size: int = 0, output_dtype=None):
         # args: x, y_scale, zero_point
         return super()._run(
             *args, axis=axis, block_size=block_size, output_dtype=output_dtype
-        )  # type: ignore
+        )

onnx/reference/ops/op_det.py

@@ -9,5 +9,5 @@ from onnx.reference.op_run import OpRun
 
 
 class Det(OpRun):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         return (np.array(np.linalg.det(x)),)

onnx/reference/ops/op_dft.py

@@ -89,12 +89,12 @@ class DFT_17(OpRun):
         axis: int = 1,
         inverse: bool = False,
         onesided: bool = False,
-    ) -> tuple[np.ndarray]:  # type: ignore
+    ) -> tuple[np.ndarray]:
         # Convert to positive axis
         axis = axis % len(x.shape)
         if dft_length is None:
             dft_length = x.shape[axis]
-        if inverse:  # type: ignore
+        if inverse:
             result = _cifft(x, dft_length, axis=axis, onesided=onesided)
         else:
             result = _cfft(x, dft_length, axis=axis, onesided=onesided, normalize=False)
@@ -109,12 +109,12 @@ class DFT_20(OpRun):
         axis: int = -2,
         inverse: bool = False,
         onesided: bool = False,
-    ) -> tuple[np.ndarray]:  # type: ignore
+    ) -> tuple[np.ndarray]:
         # Convert to positive axis
         axis = axis % len(x.shape)
         if dft_length is None:
             dft_length = x.shape[axis]
-        if inverse:  # type: ignore
+        if inverse:
             result = _cifft(x, dft_length, axis=axis, onesided=onesided)
         else:
             result = _cfft(x, dft_length, axis=axis, onesided=onesided, normalize=False)

onnx/reference/ops/op_div.py

@@ -9,10 +9,10 @@ from onnx.reference.ops._op import OpRunBinaryNumpy
 
 
 class Div(OpRunBinaryNumpy):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRunBinaryNumpy.__init__(self, np.divide, onnx_node, run_params)
 
-    def _run(self, a, b):  # type: ignore
+    def _run(self, a, b):
         res = OpRunBinaryNumpy._run(self, a, b)
         if res[0].dtype != a.dtype:
             return (res[0].astype(a.dtype),)

onnx/reference/ops/op_dropout.py

@@ -4,7 +4,7 @@
 from __future__ import annotations
 
 import numpy as np
-from numpy.random import RandomState  # type: ignore
+from numpy.random import RandomState
 
 from onnx.reference.op_run import OpRun
 
@@ -18,17 +18,17 @@ def _dropout(
 ) -> tuple[np.ndarray]:
     if drop_probability == 0 or not training_mode:
         if return_mask:
-            return X, np.ones(X.shape, dtype=bool)  # type: ignore
+            return X, np.ones(X.shape, dtype=bool)
         return (X,)
 
     rnd = RandomState(seed)
     mask = rnd.uniform(0, 1.0, X.shape) >= drop_probability
     scale = 1.0 / (1.0 - drop_probability)
-    return (mask * X * scale, mask.astype(bool)) if return_mask else (mask * X * scale,)  # type: ignore
+    return (mask * X * scale, mask.astype(bool)) if return_mask else (mask * X * scale,)
 
 
 class DropoutBase(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)
 
@@ -42,19 +42,19 @@ class DropoutBase(OpRun):
         return _dropout(
             X,
             ratio,
-            seed=seed,  # type: ignore
+            seed=seed,
             return_mask=self.n_outputs == 2,
             training_mode=training_mode,
         )
 
 
 class Dropout_7(DropoutBase):
-    def _run(self, X, ratio=None):  # type: ignore
+    def _run(self, X, ratio=None):
         return self._private_run(X, ratio)
 
 
 class Dropout_12(DropoutBase):
-    def _run(self, *inputs, seed=None):  # type: ignore
+    def _run(self, *inputs, seed=None):
         X = inputs[0]
         ratio = 0.5 if len(inputs) <= 1 else inputs[1]
         training_mode = False if len(inputs) <= 2 else inputs[2]
@@ -62,5 +62,5 @@ class Dropout_12(DropoutBase):
             X,
             seed=seed,
             ratio=ratio,
-            training_mode=training_mode,  # type: ignore
+            training_mode=training_mode,
         )

onnx/reference/ops/op_dynamic_quantize_linear.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class DynamicQuantizeLinear(OpRun):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         # args: x, y_scale, zero_point
         dtype, qmin, qmax = np.uint8, 0, 255
         maxx = np.float32(np.maximum(0, np.max(x)))

onnx/reference/ops/op_einsum.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class Einsum(OpRun):
-    def _run(self, *args, equation=None):  # type: ignore
+    def _run(self, *args, equation=None):
         if not isinstance(equation, str):
             raise TypeError(f"equation must be string but is {type(equation)!r}.")
         equation = equation.strip()

onnx/reference/ops/op_elu.py

@@ -9,6 +9,6 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Elu(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 (np.where(x > 0, x, alpha * (np.exp(x) - 1)).astype(x.dtype),)

onnx/reference/ops/op_equal.py

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

onnx/reference/ops/op_erf.py

@@ -11,9 +11,9 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Erf(OpRunUnaryNum):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRunUnaryNum.__init__(self, onnx_node, run_params)
-        self._erf = np.vectorize(erf)
+        self._erf = np.vectorize(erf, otypes=["f"])
 
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         return (self._erf(x).astype(x.dtype),)

onnx/reference/ops/op_exp.py

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

onnx/reference/ops/op_expand.py

@@ -10,9 +10,9 @@ from onnx.reference.op_run import OpRun
 
 def common_reference_implementation(data: np.ndarray, shape: np.ndarray) -> np.ndarray:
     ones = np.ones(shape, dtype=data.dtype)
-    return data * ones  # type: ignore
+    return data * ones
 
 
 class Expand(OpRun):
-    def _run(self, data, shape):  # type: ignore
+    def _run(self, data, shape):
         return (common_reference_implementation(data, shape),)

onnx/reference/ops/op_eyelike.py

@@ -28,4 +28,4 @@ class EyeLike(OpRun):
             sh = shape
         else:
             raise RuntimeError(f"EyeLike only accept 1D or 2D tensors not {shape!r}.")
-        return (np.eye(*sh, k=k, dtype=_dtype),)  # type: ignore
+        return (np.eye(*sh, k=k, dtype=_dtype),)

onnx/reference/ops/op_flatten.py

@@ -9,8 +9,8 @@ from onnx.reference.ops._op import OpRunUnary
 
 
 class Flatten(OpRunUnary):
-    def _run(self, x, axis=None):  # type: ignore
-        i = axis or self.axis  # type: ignore
+    def _run(self, x, axis=None):
+        i = axis or self.axis
         shape = x.shape
         new_shape = (1, -1) if i == 0 else (np.prod(shape[:i]).astype(int), -1)
-        return (x.reshape(new_shape),)  # type: ignore
+        return (x.reshape(new_shape),)

onnx/reference/ops/op_floor.py

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

onnx/reference/ops/op_gather.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class Gather(OpRun):
-    def _run(self, x, indices, axis=None):  # type: ignore
+    def _run(self, x, indices, axis=None):
         if not x.flags["C_CONTIGUOUS"]:
             x = np.ascontiguousarray(x)
         if not indices.flags["C_CONTIGUOUS"]:

onnx/reference/ops/op_gather_elements.py

@@ -37,7 +37,7 @@ def gather_numpy(self: np.ndarray, dim: int, index: np.ndarray) -> np.ndarray:
 
 
 class GatherElements(OpRun):
-    def _run(self, data, indices, axis=None):  # type: ignore
+    def _run(self, data, indices, axis=None):
         if indices.size == 0:
             return (np.empty((0,), dtype=data.dtype),)
         try:

onnx/reference/ops/op_gathernd.py

@@ -43,7 +43,7 @@ def _gather_nd_impl(
 
     # Flatten 'data' to array of shape
     # (batch_dim_size, data.shape[batch_dimes:]).
-    reshaped_data = data.reshape((batch_dims_size,) + data.shape[batch_dims:])
+    reshaped_data = data.reshape((batch_dims_size, *data.shape[batch_dims:]))
 
     # Gather each scalar value from 'data'.
     for batch_dim in range(reshaped_indices.shape[0]):
@@ -54,5 +54,5 @@ def _gather_nd_impl(
 
 
 class GatherND(OpRun):
-    def _run(self, data, indices, batch_dims=None):  # type: ignore
-        return _gather_nd_impl(data, indices, batch_dims)  # type: ignore
+    def _run(self, data, indices, batch_dims=None):
+        return _gather_nd_impl(data, indices, batch_dims)

onnx/reference/ops/op_gemm.py

@@ -8,28 +8,28 @@ import numpy as np
 from onnx.reference.op_run import OpRun
 
 
-def _gemm00(a, b, c, alpha, beta):  # type: ignore
+def _gemm00(a, b, c, alpha, beta):
     o = np.dot(a, b) * alpha
     if c is not None and beta != 0:
         o += c * beta
     return o
 
 
-def _gemm01(a, b, c, alpha, beta):  # type: ignore
+def _gemm01(a, b, c, alpha, beta):
     o = np.dot(a, b.T) * alpha
     if c is not None and beta != 0:
         o += c * beta
     return o
 
 
-def _gemm10(a, b, c, alpha, beta):  # type: ignore
+def _gemm10(a, b, c, alpha, beta):
     o = np.dot(a.T, b) * alpha
     if c is not None and beta != 0:
         o += c * beta
     return o
 
 
-def _gemm11(a, b, c, alpha, beta):  # type: ignore
+def _gemm11(a, b, c, alpha, beta):
     o = np.dot(a.T, b.T) * alpha
     if c is not None and beta != 0:
         o += c * beta
@@ -47,7 +47,7 @@ class Gemm_6(OpRun):
         transA=None,
         transB=None,
         broadcast=None,
-    ):  # type: ignore
+    ):
         if broadcast == 0:
             if transA:
                 _meth = _gemm11 if transB else _gemm10
@@ -69,7 +69,7 @@ class Gemm_6(OpRun):
 
 
 class Gemm_7(OpRun):
-    def _run(self, a, b, c=None, alpha=None, beta=None, transA=None, transB=None):  # type: ignore
+    def _run(self, a, b, c=None, alpha=None, beta=None, transA=None, transB=None):
         if transA:
             _meth = _gemm11 if transB else _gemm10
         else:

onnx/reference/ops/op_global_average_pool.py

@@ -13,9 +13,9 @@ def _global_average_pool(x: np.ndarray) -> np.ndarray:
     y = np.average(x, axis=axis)
     for _ in axis:
         y = np.expand_dims(y, -1)
-    return y  # type: ignore
+    return y
 
 
 class GlobalAveragePool(OpRun):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         return (_global_average_pool(x).astype(x.dtype),)

onnx/reference/ops/op_global_max_pool.py

@@ -13,10 +13,10 @@ def _global_max_pool(x: np.ndarray) -> np.ndarray:
     y = x.max(axis=tuple(range(spatial_shape, spatial_shape + 2)))
     for _ in range(spatial_shape):
         y = np.expand_dims(y, -1)
-    return y  # type: ignore
+    return y
 
 
 class GlobalMaxPool(OpRun):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         res = _global_max_pool(x)
         return (res,)

onnx/reference/ops/op_greater.py

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

onnx/reference/ops/op_greater_or_equal.py

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