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

onnx/reference/ops/op_min.py

@@ -9,10 +9,10 @@ from onnx.reference.ops._op import OpRunBinaryNumpy
 
 
 class Min(OpRunBinaryNumpy):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRunBinaryNumpy.__init__(self, np.minimum, 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_mod.py

@@ -9,9 +9,9 @@ from onnx.reference.op_run import OpRun
 
 
 class Mod(OpRun):
-    def _run(self, a, b, fmod=None):  # type: ignore
-        fmod = fmod or self.fmod  # type: ignore
-        if fmod == 1:  # type: ignore
+    def _run(self, a, b, fmod=None):
+        fmod = fmod or self.fmod
+        if fmod == 1:
             return (np.fmod(a, b),)
         if a.dtype in (np.float16, np.float32, np.float64):
             return (np.nan_to_num(np.fmod(a, b)),)

onnx/reference/ops/op_mul.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunBinaryNumpy
 
 
 class Mul(OpRunBinaryNumpy):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRunBinaryNumpy.__init__(self, np.multiply, onnx_node, run_params)

onnx/reference/ops/op_neg.py

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

onnx/reference/ops/op_negative_log_likelihood_loss.py

@@ -10,7 +10,7 @@ from onnx.reference.op_run import OpRun
 
 def _compute_negative_log_likelihood_loss(
     x, target, weight=None, reduction="mean", ignore_index=None
-):  # type: ignore
+):
     input_shape = x.shape
     if len(input_shape) == 1:
         raise RuntimeError(f"Unsupported shape {input_shape!r}.")
@@ -74,7 +74,7 @@ def _compute_negative_log_likelihood_loss(
 
 
 class NegativeLogLikelihoodLoss(OpRun):
-    def _run(self, x, target, weight=None, ignore_index=None, reduction=None):  # type: ignore
+    def _run(self, x, target, weight=None, ignore_index=None, reduction=None):
         return _compute_negative_log_likelihood_loss(
             x,
             target,

onnx/reference/ops/op_non_max_suppression.py

@@ -116,8 +116,8 @@ class BoxInfo:
         self.score_ = score
         self.idx_ = idx
 
-    def __lt__(self, rhs) -> bool:  # type: ignore
-        return self.score_ < rhs.score_ or (  # type: ignore
+    def __lt__(self, rhs) -> bool:
+        return self.score_ < rhs.score_ or (
             self.score_ == rhs.score_ and self.idx_ > rhs.idx_
         )
 
@@ -144,7 +144,7 @@ class NonMaxSuppression(OpRun):
 
         return max_output_boxes_per_class, iou_threshold, score_threshold
 
-    def prepare_compute(  # type: ignore
+    def prepare_compute(
         self,
         pc: PrepareContext,
         boxes_tensor: np.ndarray,  # float
@@ -173,7 +173,7 @@ class NonMaxSuppression(OpRun):
         pc.num_classes_ = scores_dims[1]
         pc.num_boxes_ = boxes_dims[1]
 
-    def _run(  # type: ignore
+    def _run(
         self,
         boxes,
         scores,
@@ -212,13 +212,13 @@ class NonMaxSuppression(OpRun):
         for batch_index in range(pc.num_batches_):
             for class_index in range(pc.num_classes_):
                 box_score_offset = (batch_index, class_index)
-                batch_boxes = boxes_data[batch_index]  # type: ignore
+                batch_boxes = boxes_data[batch_index]
                 # std::vector<BoxInfo> candidate_boxes;
                 # candidate_boxes.reserve(pc.num_boxes_);
 
                 # Filter by score_threshold_
                 candidate_boxes = []
-                class_scores = scores_data[box_score_offset]  # type: ignore
+                class_scores = scores_data[box_score_offset]
                 if pc.score_threshold_ is not None:
                     for box_index in range(pc.num_boxes_):
                         if class_scores[box_index] > score_threshold:
@@ -233,7 +233,7 @@ class NonMaxSuppression(OpRun):
 
                 sorted_boxes = sorted(candidate_boxes)
 
-                selected_boxes_inside_class = []  # type: ignore
+                selected_boxes_inside_class = []
                 # Get the next box with top score, filter by iou_threshold.
                 while (
                     len(sorted_boxes) > 0

onnx/reference/ops/op_non_zero.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class NonZero(OpRun):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         # Specify np.int64 for Windows x86 machines
         res = np.vstack(np.nonzero(x)).astype(np.int64)
         return (res,)

onnx/reference/ops/op_not.py

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

onnx/reference/ops/op_one_hot.py

@@ -8,7 +8,7 @@ import numpy as np
 from onnx.reference.op_run import OpRun
 
 
-def _one_hot(indices, depth, axis=-1, dtype=np.float32):  # type: ignore
+def _one_hot(indices, depth, axis=-1, dtype=np.float32):
     values = np.asarray(indices)
     rank = len(values.shape)
     depth_range = np.arange(depth)
@@ -23,8 +23,8 @@ def _one_hot(indices, depth, axis=-1, dtype=np.float32):  # type: ignore
 
 
 class OneHot(OpRun):
-    def _run(self, indices, depth, values, axis=None):  # type: ignore
+    def _run(self, indices, depth, values, axis=None):
         off_value, on_value = values
-        y = _one_hot(indices, depth, axis=axis, dtype=values.dtype)  # type: ignore
+        y = _one_hot(indices, depth, axis=axis, dtype=values.dtype)
         y = y * (on_value - off_value) + off_value
         return (y,)

onnx/reference/ops/op_optional_get_element.py

@@ -7,7 +7,7 @@ from onnx.reference.op_run import OpRun
 
 
 class OptionalGetElement(OpRun):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         if x is None:
             raise ValueError("The requested optional input has no value.")
         return (x,)

onnx/reference/ops/op_optional_has_element.py

@@ -9,5 +9,5 @@ from onnx.reference.op_run import OpRun
 
 
 class OptionalHasElement(OpRun):
-    def _run(self, x=None):  # type: ignore
+    def _run(self, x=None):
         return (np.array(x is not None),)

onnx/reference/ops/op_or.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunBinary
 
 
 class Or(OpRunBinary):
-    def _run(self, x, y):  # type: ignore
+    def _run(self, x, y):
         return (np.logical_or(x, y),)

onnx/reference/ops/op_pad.py

@@ -8,7 +8,7 @@ import numpy as np
 from onnx.reference.op_run import OpRun
 
 
-def _pad_impl(data, raw_pads, mode, constant_values=0.0, axes=None):  # type: ignore
+def _pad_impl(data, raw_pads, mode, constant_values=0.0, axes=None):
     input_rank = data.ndim
     if axes is None:
         axes = list(range(input_rank))
@@ -34,21 +34,21 @@ def _pad_impl(data, raw_pads, mode, constant_values=0.0, axes=None):  # type: ig
 
 
 class Pad_1(OpRun):
-    def _run(self, data, paddings=None, mode=None, value=None):  # type: ignore
+    def _run(self, data, paddings=None, mode=None, value=None):
         if value is None:
             value = 0
         return (_pad_impl(data, paddings, mode=mode, constant_values=value),)
 
 
 class Pad_2(OpRun):
-    def _run(self, data, pads=None, mode=None, value=None):  # type: ignore
+    def _run(self, data, pads=None, mode=None, value=None):
         if value is None:
             value = 0
         return (_pad_impl(data, pads, mode=mode, constant_values=value),)
 
 
 class Pad_11(OpRun):
-    def _run(self, data, pads, constant_value=None, mode=None):  # type: ignore
+    def _run(self, data, pads, constant_value=None, mode=None):
         if constant_value is None:
             constant_value = 0
         return (
@@ -57,7 +57,7 @@ class Pad_11(OpRun):
 
 
 class Pad_18(OpRun):
-    def _run(self, data, pads, constant_value=None, axes=None, mode=None):  # type: ignore
+    def _run(self, data, pads, constant_value=None, axes=None, mode=None):
         if constant_value is None:
             constant_value = 0
         return (

onnx/reference/ops/op_pow.py

@@ -11,7 +11,7 @@ from onnx.reference.op_run import OpRun
 
 
 class Pow(OpRun):
-    def _run(self, a, b):  # type: ignore
+    def _run(self, a, b):
         with catch_warnings():
             simplefilter("ignore")
             return (np.power(a, b).astype(a.dtype),)

onnx/reference/ops/op_prelu.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class PRelu(OpRun):
-    def _run(self, x, slope):  # type: ignore
+    def _run(self, x, slope):
         try:
             return (np.where(x > 0, x, x * slope).astype(x.dtype),)
         except ValueError:

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:

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,30 +5,41 @@
 
 from __future__ import annotations
 
-from typing import ClassVar
-
 import numpy as np
 
-from onnx import TensorProto, subbyte
-from onnx._custom_element_types import (
-    float4e2m1,
-    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,
@@ -38,7 +49,7 @@ def reshape_input(
 
     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
 
@@ -64,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]
@@ -79,61 +90,7 @@ 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,
-        TensorProto.FLOAT4E2M1,
-    )
-
-    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
-        elif (
-            zero_point.dtype == float4e2m1
-            and zero_point.dtype.descr[0][0] == "float4e2m1"
-        ):
-            zero_point_type = TensorProto.FLOAT4E2M1
-        else:
-            zero_point_type = np_dtype_to_tensor_dtype(zero_point.dtype)
-        return zero_point_type
-
-    def _run(  # noqa: PLR0911
+    def _run(
         self,
         x: np.ndarray,
         y_scale: np.ndarray,
@@ -141,15 +98,15 @@ class _CommonQuantizeLinear(OpRun):
         axis: int = 1,
         saturate: bool = True,
         block_size: int | None = None,
-        output_dtype: int | 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}"
@@ -157,14 +114,14 @@ 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
         )
@@ -174,47 +131,31 @@ class _CommonQuantizeLinear(OpRun):
         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 == 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 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.FLOAT4E2M1:
             x += zero_point
-            f4 = subbyte.float32_to_float4e2m1_unpacked(x)
-            return (f4.astype(float4e2m1),)  # type: ignore[attr-defined]
+            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."
@@ -222,21 +163,28 @@ 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,
@@ -244,19 +192,19 @@ class QuantizeLinear_21(_CommonQuantizeLinear):
             saturate=saturate,
             block_size=block_size,
             output_dtype=output_dtype,
-        )  # type: ignore
+        )
 
 
 class QuantizeLinear_23(_CommonQuantizeLinear):
     def _run(
         self,
         *args,
-        axis=None,
-        saturate=None,
-        block_size=None,
+        axis: int = 1,
+        saturate: bool = True,
+        block_size: int = 0,
         output_dtype=None,
         precision=None,
-    ):  # type: ignore
+    ):
         # args: x, y_scale, zero_point
         return super()._run(
             *args,
@@ -265,4 +213,4 @@ class QuantizeLinear_23(_CommonQuantizeLinear):
             block_size=block_size,
             output_dtype=output_dtype,
             precision=precision,
-        )  # type: ignore
+        )

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),)