onnx 1.17.0__cp311-cp311-macosx_12_0_universal2.whl → 1.19.0__cp311-cp311-macosx_12_0_universal2.whl

onnx/reference/ops/op_qlinear_conv.py

@@ -10,7 +10,7 @@ from onnx.reference.ops.op_conv import _conv_implementation
 
 
 class QLinearConv(OpRun):
-    def _run(  # type: ignore
+    def _run(
         self,
         x,
         x_scale,
@@ -28,12 +28,12 @@ class QLinearConv(OpRun):
         pads=None,
         strides=None,
     ):
-        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 is not None:
@@ -50,6 +50,19 @@ class QLinearConv(OpRun):
             X, W, B, auto_pad, dilations, group, kernel_shape, pads, strides
         ).astype(np.int32)
 
+        # w_scale could be a scalar or a 1-D tensor. A 1-D tensor means a per
+        # output channel quantization.
+        if np.size(w_scale) > 1:
+            if np.ndim(w_scale) != 1:
+                raise ValueError(
+                    f"w_scale must be a scalar or a 1-D tensor. Got shape {np.shape(w_scale)}."
+                )
+            if np.size(w_scale) != np.shape(w)[0]:
+                raise ValueError(
+                    f"w_scale elements must match output channels: {np.size(w_scale)} != {np.shape(w)[0]}"
+                )
+            w_scale = np.expand_dims(w_scale, (0, 2, 3))
+
         R = res * (x_scale * w_scale / y_scale)
         if y_zero_point is not None:
             R += y_zero_point

onnx/reference/ops/op_qlinear_matmul.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class QLinearMatMul(OpRun):
-    def _run(  # type: ignore
+    def _run(
         self, a, a_scale, a_zero_point, b, b_scale, b_zero_point, y_scale, y_zero_point
     ):
         A = a.astype(np.int32)

onnx/reference/ops/op_quantize_linear.py

@@ -5,39 +5,51 @@
 
 from __future__ import annotations
 
-from typing import ClassVar
-
 import numpy as np
 
-from onnx import TensorProto, subbyte
-from onnx._custom_element_types import (
-    float8e4m3fn,
-    float8e4m3fnuz,
-    float8e5m2,
-    float8e5m2fnuz,
-    int4,
-    uint4,
-)
+import onnx
+from onnx import TensorProto
 from onnx.helper import (
-    float32_to_float8e4m3,
-    float32_to_float8e5m2,
     np_dtype_to_tensor_dtype,
     tensor_dtype_to_np_dtype,
 )
 from onnx.reference.op_run import OpRun
 
-
-def reshape_input(
+_QUANT_TYPES = {
+    TensorProto.UINT8,
+    TensorProto.INT8,
+    TensorProto.UINT16,
+    TensorProto.INT16,
+    TensorProto.UINT4,
+    TensorProto.INT4,
+    TensorProto.FLOAT8E4M3FN,
+    TensorProto.FLOAT8E4M3FNUZ,
+    TensorProto.FLOAT8E5M2,
+    TensorProto.FLOAT8E5M2FNUZ,
+    TensorProto.FLOAT4E2M1,
+}
+
+_QUANT_INTEGER_RANGES = {
+    TensorProto.UINT8: (0, 255),
+    TensorProto.INT8: (-128, 127),
+    TensorProto.UINT16: (0, 65535),
+    TensorProto.INT16: (-32768, 32767),
+    TensorProto.UINT4: (0, 15),
+    TensorProto.INT4: (-8, 7),
+}
+
+
+def _reshape_input(
     value: np.ndarray,
     shape: tuple[int, ...],
-    axis: int | None = None,
+    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 rarget shape
+        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
 
@@ -63,7 +75,7 @@ def reshape_input(
     if block_size <= 0:
         raise ValueError("block_size must be a positive integer.")
 
-    # repeat scale to get elementwise scale
+    # repeat scale to get element-wise scale
     value = np.repeat(value, repeats=block_size, axis=axis)
     if (
         shape[axis] != value.shape[axis]
@@ -78,54 +90,6 @@ def reshape_input(
 
 
 class _CommonQuantizeLinear(OpRun):
-    float32_to_float8e4m3 = np.vectorize(float32_to_float8e4m3)
-    float32_to_float8e5m2 = np.vectorize(float32_to_float8e5m2)
-    quant_integer_ranges: ClassVar[dict[TensorProto.DataType, tuple[int]]] = {
-        TensorProto.UINT8: (0, 255),
-        TensorProto.INT8: (-128, 127),
-        TensorProto.UINT16: (0, 65535),
-        TensorProto.INT16: (-32768, 32767),
-    }
-    quant_types = (
-        TensorProto.UINT8,
-        TensorProto.INT8,
-        TensorProto.UINT16,
-        TensorProto.INT16,
-        TensorProto.UINT4,
-        TensorProto.INT4,
-        TensorProto.FLOAT8E4M3FN,
-        TensorProto.FLOAT8E4M3FNUZ,
-        TensorProto.FLOAT8E5M2,
-        TensorProto.FLOAT8E5M2FNUZ,
-    )
-
-    def get_zero_point_type(self, zero_point: np.ndarray) -> int:
-        zero_point_type = None
-        if (
-            zero_point.dtype == float8e4m3fn
-            and zero_point.dtype.descr[0][0] == "e4m3fn"
-        ):
-            zero_point_type = TensorProto.FLOAT8E4M3FN
-        elif (
-            zero_point.dtype == float8e4m3fnuz
-            and zero_point.dtype.descr[0][0] == "e4m3fnuz"
-        ):
-            zero_point_type = TensorProto.FLOAT8E4M3FNUZ
-        elif zero_point.dtype == float8e5m2 and zero_point.dtype.descr[0][0] == "e5m2":
-            zero_point_type = TensorProto.FLOAT8E5M2
-        elif (
-            zero_point.dtype == float8e5m2fnuz
-            and zero_point.dtype.descr[0][0] == "e5m2fnuz"
-        ):
-            zero_point_type = TensorProto.FLOAT8E5M2FNUZ
-        elif zero_point.dtype == uint4 and zero_point.dtype.descr[0][0] == "uint4":
-            zero_point_type = TensorProto.UINT4
-        elif zero_point.dtype == int4 and zero_point.dtype.descr[0][0] == "int4":
-            zero_point_type = TensorProto.INT4
-        else:
-            zero_point_type = np_dtype_to_tensor_dtype(zero_point.dtype)
-        return zero_point_type
-
     def _run(
         self,
         x: np.ndarray,
@@ -134,14 +98,15 @@ class _CommonQuantizeLinear(OpRun):
         axis: int = 1,
         saturate: bool = True,
         block_size: int | None = None,
-        output_dtype: np.dtype | None = None,
+        output_dtype: TensorProto.DataType | None = None,
+        precision: int | None = None,
     ) -> tuple[np.ndarray]:
-        y_scale = reshape_input(y_scale, x.shape, axis, block_size)
+        y_scale = _reshape_input(y_scale, x.shape, axis, block_size)
 
         # Determine output data type
         tensor_type = output_dtype
         if zero_point is not None:
-            zero_point_type = self.get_zero_point_type(zero_point)
+            zero_point_type = np_dtype_to_tensor_dtype(zero_point.dtype)
             if output_dtype and output_dtype != zero_point_type:
                 raise ValueError(
                     f"Mismatched output data-types: output_dtype={output_dtype}, zero_point type={zero_point_type}"
@@ -149,55 +114,48 @@ class _CommonQuantizeLinear(OpRun):
             tensor_type = zero_point_type
         tensor_type = tensor_type or TensorProto.UINT8
 
-        if tensor_type not in _CommonQuantizeLinear.quant_types:
+        if tensor_type not in _QUANT_TYPES:
             raise ValueError(
                 f"Unexpected type: output_dtype={tensor_type} is not a supported quantized type."
             )
 
         # Compute
         zero_point = (
-            reshape_input(zero_point, x.shape, axis, block_size)
+            _reshape_input(zero_point, x.shape, axis, block_size)
             if zero_point is not None
             else 0
         )
-        x = x / y_scale
+        if precision:
+            precision_np = tensor_dtype_to_np_dtype(precision)
+            x = x.astype(precision_np) / y_scale.astype(precision_np)
+        else:
+            x = x / y_scale
 
-        if tensor_type in _CommonQuantizeLinear.quant_integer_ranges:
+        if tensor_type in _QUANT_INTEGER_RANGES:
             xi = np.rint(x).astype(np.int32)
             xi += zero_point
             dtype = tensor_dtype_to_np_dtype(tensor_type)
-            quant_range = _CommonQuantizeLinear.quant_integer_ranges[tensor_type]
+            quant_range = _QUANT_INTEGER_RANGES[tensor_type]
             return (np.clip(xi, quant_range[0], quant_range[1]).astype(dtype),)
 
-        if tensor_type == TensorProto.FLOAT8E4M3FN:
-            f8 = _CommonQuantizeLinear.float32_to_float8e4m3(x, saturate=saturate)
-            return (f8.astype(float8e4m3fn),)  # type: ignore[attr-defined]
-
-        if tensor_type == TensorProto.FLOAT8E4M3FNUZ:
-            f8 = _CommonQuantizeLinear.float32_to_float8e4m3(
-                x, uz=True, saturate=saturate
-            )
-            return (f8.astype(float8e4m3fnuz),)  # type: ignore[attr-defined]
+        if tensor_type in {
+            TensorProto.FLOAT8E4M3FN,
+            TensorProto.FLOAT8E4M3FNUZ,
+            TensorProto.FLOAT8E5M2,
+            TensorProto.FLOAT8E5M2FNUZ,
+        }:
+            if saturate:
+                return (
+                    onnx.numpy_helper.saturate_cast(
+                        x, dtype=tensor_dtype_to_np_dtype(tensor_type)
+                    ),
+                )
+            else:
+                return (x.astype(tensor_dtype_to_np_dtype(tensor_type)),)
 
-        if tensor_type == TensorProto.FLOAT8E5M2:
-            f8 = _CommonQuantizeLinear.float32_to_float8e5m2(x, saturate=saturate)
-            return (f8.astype(float8e5m2),)  # type: ignore[attr-defined]
-
-        if tensor_type == TensorProto.FLOAT8E5M2FNUZ:
-            f8 = _CommonQuantizeLinear.float32_to_float8e5m2(
-                x, fn=True, uz=True, saturate=saturate
-            )
-            return (f8.astype(float8e5m2fnuz),)  # type: ignore[attr-defined]
-
-        if tensor_type in (TensorProto.UINT4, TensorProto.INT4):
-            xi = np.rint(x).astype(np.int32)
-            xi += zero_point
-            single_func = lambda x: subbyte.float32_to_4bit_unpacked(  # noqa: E731
-                x, signed=(tensor_type == TensorProto.INT4)
-            )
-            func = np.vectorize(single_func)
-            i4 = func(xi)
-            return (i4,)  # type: ignore[attr-defined]
+        if tensor_type == TensorProto.FLOAT4E2M1:
+            x += zero_point
+            return (x.astype(tensor_dtype_to_np_dtype(tensor_type)),)
 
         raise ValueError(
             f"Unexpected type: output_dtype={tensor_type} is not a supported quantized type."
@@ -205,21 +163,48 @@ class _CommonQuantizeLinear(OpRun):
 
 
 class QuantizeLinear_10(_CommonQuantizeLinear):
-    def _run(self, x, y_scale, zero_point=None, axis=None):  # type: ignore
+    def _run(self, x, y_scale, zero_point=None, axis: int = 1):
         if len(y_scale.shape) > 1:
             raise ValueError("Input 2 must be a vector or a number.")
-        return super()._run(x, y_scale, zero_point, axis=axis)  # type: ignore
+        return super()._run(x, y_scale, zero_point, axis=axis)
 
 
 class QuantizeLinear_19(_CommonQuantizeLinear):
-    def _run(self, x, y_scale, zero_point=None, axis=None, saturate=None):  # type: ignore
+    def _run(self, x, y_scale, zero_point=None, axis: int = 1, saturate: bool = True):
         if len(y_scale.shape) > 1:
             raise ValueError("Input 2 must be a vector or a number.")
-        return super()._run(x, y_scale, zero_point, axis=axis, saturate=saturate)  # type: ignore
+        return super()._run(x, y_scale, zero_point, axis=axis, saturate=saturate)
 
 
 class QuantizeLinear_21(_CommonQuantizeLinear):
-    def _run(self, *args, axis=None, saturate=None, block_size=None, output_dtype=None):  # type: ignore
+    def _run(
+        self,
+        *args,
+        axis: int = 1,
+        saturate: bool = True,
+        block_size: int = 0,
+        output_dtype=None,
+    ):
+        # args: x, y_scale, zero_point
+        return super()._run(
+            *args,
+            axis=axis,
+            saturate=saturate,
+            block_size=block_size,
+            output_dtype=output_dtype,
+        )
+
+
+class QuantizeLinear_23(_CommonQuantizeLinear):
+    def _run(
+        self,
+        *args,
+        axis: int = 1,
+        saturate: bool = True,
+        block_size: int = 0,
+        output_dtype=None,
+        precision=None,
+    ):
         # args: x, y_scale, zero_point
         return super()._run(
             *args,
@@ -227,4 +212,5 @@ class QuantizeLinear_21(_CommonQuantizeLinear):
             saturate=saturate,
             block_size=block_size,
             output_dtype=output_dtype,
-        )  # type: ignore
+            precision=precision,
+        )

onnx/reference/ops/op_random_normal.py

@@ -7,10 +7,10 @@ from onnx.reference.ops._op_common_random import _CommonRandom
 
 
 class RandomNormal(_CommonRandom):
-    def _run(self, dtype=None, mean=None, scale=None, seed=None, shape=None):  # type: ignore
+    def _run(self, dtype=None, mean=None, scale=None, seed=None, shape=None):
         state = self._get_state(seed)
         numpy_type = self.numpy_type(dtype)
-        res = state.randn(*shape).astype(numpy_type)  # type: ignore
-        res *= scale  # type: ignore
-        res += mean  # type: ignore
+        res = state.randn(*shape).astype(numpy_type)
+        res *= scale
+        res += mean
         return (res.astype(numpy_type),)

onnx/reference/ops/op_random_normal_like.py

@@ -8,12 +8,12 @@ from onnx.reference.ops._op_common_random import _CommonRandom
 
 
 class RandomNormalLike(_CommonRandom):
-    def _run(self, x, dtype=None, mean=None, scale=None, seed=None):  # type: ignore
+    def _run(self, x, dtype=None, mean=None, scale=None, seed=None):
         if dtype is None:
             dtype = np_dtype_to_tensor_dtype(x.dtype)
         dtype = self._dtype(x, dtype=dtype)
         state = self._get_state(seed)
         res = state.randn(*x.shape).astype(dtype)
-        res *= scale  # type: ignore
-        res += mean  # type: ignore
+        res *= scale
+        res += mean
         return (res.astype(dtype),)

onnx/reference/ops/op_random_uniform.py

@@ -7,10 +7,10 @@ from onnx.reference.ops._op_common_random import _CommonRandom
 
 
 class RandomUniform(_CommonRandom):
-    def _run(self, dtype=None, high=None, low=None, seed=None, shape=None):  # type: ignore
+    def _run(self, dtype=None, high=None, low=None, seed=None, shape=None):
         dtype = self._dtype(dtype=dtype)
         state = self._get_state(seed)
-        res = state.rand(*shape).astype(dtype)  # type: ignore
-        res *= high - low  # type: ignore
-        res += low  # type: ignore
+        res = state.rand(*shape).astype(dtype)
+        res *= high - low
+        res += low
         return (res.astype(dtype),)

onnx/reference/ops/op_random_uniform_like.py

@@ -8,12 +8,12 @@ from onnx.reference.ops._op_common_random import _CommonRandom
 
 
 class RandomUniformLike(_CommonRandom):
-    def _run(self, x, dtype=None, high=None, low=None, seed=None):  # type: ignore
+    def _run(self, x, dtype=None, high=None, low=None, seed=None):
         if dtype is None:
             dtype = np_dtype_to_tensor_dtype(x.dtype)
         dtype = self._dtype(x, dtype=dtype)
         state = self._get_state(seed)
         res = state.rand(*x.shape).astype(dtype)
-        res *= high - low  # type: ignore
-        res += low  # type: ignore
+        res *= high - low
+        res += low
         return (res.astype(dtype),)

onnx/reference/ops/op_range.py

@@ -9,5 +9,5 @@ from onnx.reference.op_run import OpRun
 
 
 class Range(OpRun):
-    def _run(self, starts, ends, steps):  # type: ignore
+    def _run(self, starts, ends, steps):
         return (np.arange(starts, ends, steps).astype(starts.dtype),)

onnx/reference/ops/op_reciprocal.py

@@ -9,6 +9,6 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Reciprocal(OpRunUnaryNum):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         with np.errstate(divide="ignore"):
             return (np.reciprocal(x).astype(x.dtype),)

onnx/reference/ops/op_reduce_l1.py

@@ -9,7 +9,7 @@ from onnx.reference.ops._op import OpRunReduceNumpy
 
 
 class ReduceL1_1(OpRunReduceNumpy):
-    def _run(self, data, axes=None, keepdims=None):  # type: ignore
+    def _run(self, data, axes=None, keepdims=None):
         axes = tuple(axes) if axes is not None else None
         res = np.sum(np.abs(data), axis=axes, keepdims=keepdims).astype(
             dtype=data.dtype
@@ -21,12 +21,12 @@ class ReduceL1_1(OpRunReduceNumpy):
 
 
 class ReduceL1_18(OpRunReduceNumpy):
-    def _run(self, data, axes=None, keepdims=1, noop_with_empty_axes=0):  # type: ignore
-        if self.is_axes_empty(axes) and noop_with_empty_axes:  # type: ignore
+    def _run(self, data, axes=None, keepdims=1, noop_with_empty_axes=0):
+        if self.is_axes_empty(axes) and noop_with_empty_axes:
             return (data,)
 
         axes = self.handle_axes(axes)
-        keepdims = keepdims != 0  # type: ignore
+        keepdims = keepdims != 0
         res = np.sum(np.abs(data), axis=axes, keepdims=keepdims).astype(
             dtype=data.dtype
         )

onnx/reference/ops/op_reduce_l2.py

@@ -9,7 +9,7 @@ from onnx.reference.ops._op import OpRunReduceNumpy
 
 
 class ReduceL2_1(OpRunReduceNumpy):
-    def _run(self, data, axes=None, keepdims=None):  # type: ignore
+    def _run(self, data, axes=None, keepdims=None):
         axes = tuple(axes) if axes is not None else None
         res = np.sqrt(np.sum(np.square(data), axis=axes, keepdims=keepdims)).astype(
             dtype=data.dtype
@@ -21,12 +21,12 @@ class ReduceL2_1(OpRunReduceNumpy):
 
 
 class ReduceL2_18(OpRunReduceNumpy):
-    def _run(self, data, axes=None, keepdims=1, noop_with_empty_axes=0):  # type: ignore
-        if self.is_axes_empty(axes) and noop_with_empty_axes:  # type: ignore
+    def _run(self, data, axes=None, keepdims=1, noop_with_empty_axes=0):
+        if self.is_axes_empty(axes) and noop_with_empty_axes:
             return (data,)
 
         axes = self.handle_axes(axes)
-        keepdims = keepdims != 0  # type: ignore
+        keepdims = keepdims != 0
         res = np.sqrt(np.sum(np.square(data), axis=axes, keepdims=keepdims)).astype(
             dtype=data.dtype
         )

onnx/reference/ops/op_reduce_log_sum.py

@@ -9,7 +9,7 @@ from onnx.reference.ops._op import OpRunReduceNumpy
 
 
 class ReduceLogSum_1(OpRunReduceNumpy):
-    def _run(self, data, axes=None, keepdims=True):  # type: ignore
+    def _run(self, data, axes=None, keepdims=True):
         tax = tuple(axes) if axes is not None else None
         if data.size == 0:
             return self.reduce_constant(data, -np.inf, tax, keepdims)
@@ -20,12 +20,12 @@ class ReduceLogSum_1(OpRunReduceNumpy):
 
 
 class ReduceLogSum_18(OpRunReduceNumpy):
-    def _run(self, data, axes=None, keepdims=1, noop_with_empty_axes=0):  # type: ignore
-        if self.is_axes_empty(axes) and noop_with_empty_axes:  # type: ignore
+    def _run(self, data, axes=None, keepdims=1, noop_with_empty_axes=0):
+        if self.is_axes_empty(axes) and noop_with_empty_axes:
             return (data,)
 
         axes = self.handle_axes(axes)
-        keepdims = keepdims != 0  # type: ignore
+        keepdims = keepdims != 0
 
         if data.size == 0:
             return self.reduce_constant(data, -np.inf, axes, keepdims)

onnx/reference/ops/op_reduce_log_sum_exp.py

@@ -17,13 +17,13 @@ def compute_log_sum_exp(data, axes, keepdims):
     exp = np.exp(sub, out=sub)
     mxs = np.sum(exp, axis=axes, keepdims=True, dtype=data.dtype)
     res = np.log(mxs) + mx
-    if not keepdims:  # type: ignore
+    if not keepdims:
         res = np.squeeze(res, axis=axes)
     return (res,)
 
 
 class ReduceLogSumExp_1(OpRunReduceNumpy):
-    def _run(self, data, axes=None, keepdims=None):  # type: ignore
+    def _run(self, data, axes=None, keepdims=None):
         tax = tuple(axes) if axes is not None else None
 
         if data.size == 0:
@@ -32,12 +32,12 @@ class ReduceLogSumExp_1(OpRunReduceNumpy):
 
 
 class ReduceLogSumExp_18(OpRunReduceNumpy):
-    def _run(self, data, axes=None, keepdims=1, noop_with_empty_axes=0):  # type: ignore
-        if self.is_axes_empty(axes) and noop_with_empty_axes:  # type: ignore
+    def _run(self, data, axes=None, keepdims=1, noop_with_empty_axes=0):
+        if self.is_axes_empty(axes) and noop_with_empty_axes:
             return (data,)
 
         axes = self.handle_axes(axes)
-        keepdims = keepdims != 0  # type: ignore
+        keepdims = keepdims != 0
 
         if data.size == 0:
             return self.reduce_constant(data, -np.inf, axes, keepdims)

onnx/reference/ops/op_reduce_max.py

@@ -9,7 +9,7 @@ from onnx.reference.ops._op import OpRunReduceNumpy
 
 
 class ReduceMax_1(OpRunReduceNumpy):
-    def _run(self, data, axes=None, keepdims=None):  # type: ignore
+    def _run(self, data, axes=None, keepdims=None):
         axes = tuple(axes) if axes is not None else None
         if data.size == 0:
             minvalue = (
@@ -27,12 +27,12 @@ class ReduceMax_1(OpRunReduceNumpy):
 
 
 class ReduceMax_18(OpRunReduceNumpy):
-    def _run(self, data, axes=None, keepdims: int = 1, noop_with_empty_axes: int = 0):  # type: ignore
-        if self.is_axes_empty(axes) and noop_with_empty_axes != 0:  # type: ignore
+    def _run(self, data, axes=None, keepdims: int = 1, noop_with_empty_axes: int = 0):
+        if self.is_axes_empty(axes) and noop_with_empty_axes != 0:
             return (data,)
 
         axes = self.handle_axes(axes)
-        keepdims = keepdims != 0  # type: ignore
+        keepdims = keepdims != 0
         if data.size == 0:
             minvalue = (
                 np.iinfo(data.dtype).min

onnx/reference/ops/op_reduce_mean.py

@@ -9,7 +9,7 @@ from onnx.reference.ops._op import OpRunReduceNumpy
 
 
 class ReduceMean_1(OpRunReduceNumpy):
-    def _run(self, data, axes=None, keepdims=None):  # type: ignore
+    def _run(self, data, axes=None, keepdims=None):
         axes = tuple(axes) if axes is not None else None
         res = np.mean(data, axis=axes, keepdims=keepdims, dtype=data.dtype)
         if keepdims == 0 and not isinstance(res, np.ndarray):
@@ -19,14 +19,14 @@ class ReduceMean_1(OpRunReduceNumpy):
 
 
 class ReduceMean_18(OpRunReduceNumpy):
-    def _run(self, data, axes=None, keepdims=1, noop_with_empty_axes=0):  # type: ignore
-        if self.is_axes_empty(axes) and noop_with_empty_axes:  # type: ignore
+    def _run(self, data, axes=None, keepdims=1, noop_with_empty_axes=0):
+        if self.is_axes_empty(axes) and noop_with_empty_axes:
             return (data,)
 
         axes = self.handle_axes(axes)
-        keepdims = keepdims != 0  # type: ignore
+        keepdims = keepdims != 0
         try:
-            res = np.mean(data, axis=axes, keepdims=keepdims, dtype=data.dtype)  # type: ignore
+            res = np.mean(data, axis=axes, keepdims=keepdims, dtype=data.dtype)
             if keepdims == 0 and not isinstance(res, np.ndarray):
                 # The runtime must return a numpy array of a single float.
                 res = np.array(res)
@@ -34,4 +34,4 @@ class ReduceMean_18(OpRunReduceNumpy):
             raise TypeError(
                 f"Unable to reduce shape {data.shape!r} with axes={axes!r} and keepdims={keepdims}."
             ) from e
-        return (res,)  # type: ignore
+        return (res,)

onnx/reference/ops/op_reduce_min.py

@@ -9,7 +9,7 @@ from onnx.reference.ops._op import OpRunReduceNumpy
 
 
 class ReduceMin_1(OpRunReduceNumpy):
-    def _run(self, data, axes=None, keepdims=None):  # type: ignore
+    def _run(self, data, axes=None, keepdims=None):
         axes = tuple(axes) if axes is not None else None
         if data.size == 0:
             maxvalue = (
@@ -31,12 +31,12 @@ class ReduceMin_11(ReduceMin_1):
 
 
 class ReduceMin_18(OpRunReduceNumpy):
-    def _run(self, data, axes=None, keepdims: int = 1, noop_with_empty_axes: int = 0):  # type: ignore
-        if self.is_axes_empty(axes) and noop_with_empty_axes != 0:  # type: ignore
+    def _run(self, data, axes=None, keepdims: int = 1, noop_with_empty_axes: int = 0):
+        if self.is_axes_empty(axes) and noop_with_empty_axes != 0:
             return (data,)
 
         axes = self.handle_axes(axes)
-        keepdims = keepdims != 0  # type: ignore
+        keepdims = keepdims != 0
         if data.size == 0:
             maxvalue = (
                 np.iinfo(data.dtype).max

onnx/reference/ops/op_reduce_prod.py

@@ -9,7 +9,7 @@ from onnx.reference.ops._op import OpRunReduceNumpy
 
 
 class ReduceProd_1(OpRunReduceNumpy):
-    def _run(self, data, axes=None, keepdims=None):  # type: ignore
+    def _run(self, data, axes=None, keepdims=None):
         axes = tuple(axes) if axes is not None else None
         res = np.prod(data, axis=axes, keepdims=keepdims, dtype=data.dtype)
         if keepdims == 0 and not isinstance(res, np.ndarray):
@@ -19,12 +19,12 @@ class ReduceProd_1(OpRunReduceNumpy):
 
 
 class ReduceProd_18(OpRunReduceNumpy):
-    def _run(self, data, axes=None, keepdims=1, noop_with_empty_axes=0):  # type: ignore
-        if self.is_axes_empty(axes) and noop_with_empty_axes:  # type: ignore
+    def _run(self, data, axes=None, keepdims=1, noop_with_empty_axes=0):
+        if self.is_axes_empty(axes) and noop_with_empty_axes:
             return (data,)
 
         axes = self.handle_axes(axes)
-        keepdims = keepdims != 0  # type: ignore
+        keepdims = keepdims != 0
         res = np.prod(data, axis=axes, keepdims=keepdims, dtype=data.dtype)
         if not keepdims and not isinstance(res, np.ndarray):
             # The runtime must return a numpy array of a single float.