onnx 1.17.0__cp310-cp310-macosx_12_0_universal2.whl → 1.19.0__cp310-cp310-macosx_12_0_universal2.whl

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,

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

@@ -25,7 +25,7 @@ class PrepareContext:
 
 
 class SelectedIndex:
-    __slots__ = ("batch_index_", "class_index_", "box_index_")
+    __slots__ = ("batch_index_", "box_index_", "class_index_")
 
     def __init__(
         self, batch_index: int = 0, class_index: int = 0, box_index: int = 0
@@ -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
@@ -160,7 +160,7 @@ class NonMaxSuppression(OpRun):
             pc.max_output_boxes_per_class_ = max_output_boxes_per_class_tensor
         if iou_threshold_tensor.size != 0:
             pc.iou_threshold_ = iou_threshold_tensor
-        if score_threshold_tensor.size != 0:
+        if score_threshold_tensor is not None and score_threshold_tensor.size != 0:
             pc.score_threshold_ = score_threshold_tensor
 
         pc.boxes_size_ = boxes_tensor.size
@@ -173,17 +173,15 @@ class NonMaxSuppression(OpRun):
         pc.num_classes_ = scores_dims[1]
         pc.num_boxes_ = boxes_dims[1]
 
-    def _run(  # type: ignore
+    def _run(
         self,
         boxes,
         scores,
-        max_output_boxes_per_class,
-        iou_threshold,
-        score_threshold,
-        center_point_box,
+        max_output_boxes_per_class=None,
+        iou_threshold=None,
+        score_threshold=None,
+        center_point_box=None,
     ):
-        center_point_box = center_point_box or self.center_point_box  # type: ignore
-
         pc = PrepareContext()
         self.prepare_compute(
             pc,
@@ -214,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:
@@ -235,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_pool_common.py

@@ -5,12 +5,15 @@ from __future__ import annotations
 
 import itertools
 import math
-from typing import Sequence
+from typing import TYPE_CHECKING
 
 import numpy as np
 
 from onnx.reference.op_run import OpRun
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 
 def get_pad_shape(
     auto_pad: str,
@@ -51,7 +54,7 @@ def get_pad_with_auto_pad(auto_pad: str, pad_shape: Sequence[int]) -> Sequence[i
 
 
 def get_output_shape_explicit_padding(
-    pads: Sequence[int],
+    pads: Sequence[int] | None,
     input_spatial_shape: Sequence[int],
     kernel_spatial_shape: Sequence[int],
     strides_spatial: Sequence[int],
@@ -93,6 +96,11 @@ def get_output_shape_explicit_padding(
 
         if ceil_mode:
             output_spatial_shape[dim] = int(np.ceil(dim_size))
+            # NOTE: ensure that the last pooling starts inside the image
+            if (output_spatial_shape[dim] - 1) * strides_spatial[
+                dim
+            ] >= input_spatial_shape[dim] + pads[dim]:
+                output_spatial_shape[dim] -= 1
         else:
             output_spatial_shape[dim] = int(np.floor(dim_size))
 
@@ -152,13 +160,6 @@ def get_output_shape_auto_pad(
     return out_shape
 
 
-def lp_pool(x: np.array, p: int) -> float:
-    y = 0
-    for v in np.nditer(x):
-        y += abs(v) ** p
-    return y ** (1.0 / p)
-
-
 def pool(
     padded: np.ndarray,
     x_shape: Sequence[int],
@@ -166,6 +167,7 @@ def pool(
     strides: Sequence[int],
     out_shape: Sequence[int],
     pooling_type: str,
+    pads_required: Sequence[int] | None = None,
     pads: Sequence[int] | None = None,
     dilations: Sequence[int] | None = None,
     count_include_pad: int = 0,
@@ -178,6 +180,7 @@ def pool(
     strides: the strides
     out_shape: the shape of the output tensor
     pooling_type: the pooling type, can be "AVG", "LPPOOL", or "MAX"
+    pads_required: the required padding to make sure the sliding window does not go out-of-bound
     pads: the padding in an order of head_pad_1, head_pad_2, ..., tail_pad_1, tail_pad_2, ...
     dilations: the dilation
     count_include_pad: whether to include the padding in the calculation of average and lp pooling
@@ -187,25 +190,27 @@ def pool(
     y = np.zeros([x_shape[0], x_shape[1], *list(out_shape)], dtype=padded.dtype)
     if dilations is None:
         dilations = np.ones([spatial_size], dtype=np.int64)
+    if pads_required is None:
+        pads_required = np.zeros([spatial_size * 2], dtype=np.int64)
+    elif len(pads_required) == 1:
+        pads_required = pads_required * spatial_size * 2
     if pads is None:
         pads = np.zeros([spatial_size * 2], dtype=np.int64)
     elif len(pads) == 1:
         pads = pads * spatial_size * 2
     strides = strides or [1] * spatial_size
 
-    def lp_pool_p(x):
-        return lp_pool(x, p)
-
+    # Iterate all the possible sliding windows
     for shape in itertools.product(
-        range(x_shape[0]),
-        range(x_shape[1]),
+        range(x_shape[0]),  # e.g. dim=0: [0]
+        range(x_shape[1]),  # e.g. dim=1: [0, 1]
         *[
             range(
                 int(
                     (
                         x_shape[i + 2]
-                        + pads[i]
-                        + pads[i + spatial_size]
+                        + pads_required[i]
+                        + pads_required[i + spatial_size]
                         - (1 + (kernel[i] - 1) * dilations[i])
                     )
                     / strides[i]
@@ -222,24 +227,34 @@ def pool(
                 for i in list(
                     itertools.product(
                         *[
-                            range(
-                                strides[i] * shape[i + 2],
-                                strides[i] * shape[i + 2]
-                                + (1 + (kernel[i] - 1) * dilations[i]),
-                                dilations[i],
-                            )
+                            [
+                                pixel
+                                for pixel in range(
+                                    strides[i] * shape[i + 2],
+                                    strides[i] * shape[i + 2]
+                                    + (1 + (kernel[i] - 1) * dilations[i]),
+                                    dilations[i],
+                                )
+                                if pixel
+                                < x_shape[i + 2] + pads[i] + pads[spatial_size + i]
+                            ]
                             for i in range(spatial_size)
                         ]
                     )
                 )
             ]
         )
+
         if pooling_type == "AVG":
             f = np.average
         elif pooling_type == "MAX":
             f = np.max
         elif pooling_type == "LPPOOL":
-            f = lp_pool_p
+
+            def lp_pool(x: np.array, p: int = p) -> float:
+                return np.sum(np.abs(x) ** p) ** (1.0 / p)
+
+            f = lp_pool
         else:
             raise NotImplementedError(
                 f"Pooling type {pooling_type} does not support. Should be AVG, MAX"
@@ -270,9 +285,9 @@ class CommonPool(OpRun):
         pading_value = np.nan if pooling_type == "MAX" or count_include_pad == 0 else 0
 
         if auto_pad in ["SAME_UPPER", "SAME_LOWER", "VALID"]:
-            assert (
-                ceil_mode is None or ceil_mode == 0
-            ), "ceil_mode is not supported with auto_pad"
+            assert ceil_mode is None or ceil_mode == 0, (
+                "ceil_mode is not supported with auto_pad"
+            )
             out_shape = get_output_shape_auto_pad(
                 auto_pad, x.shape[2:], kernel_shape, strides
             )
@@ -296,18 +311,19 @@ class CommonPool(OpRun):
                 out_shape,
                 pooling_type,
                 pads,
+                pads,
                 dilations,
                 count_include_pad,
                 p,
             )
             return (y,)
         else:
-            out_shape, pads = get_output_shape_explicit_padding(
+            out_shape, extra_pads = get_output_shape_explicit_padding(
                 pads, x_shape[2:], kernel_shape, strides, dilations, ceil_mode
             )
             # convert pads from [x1_begin, x2_begin,...,x1_end, x2_end,...] to [(x1_begin, x1_end), (x2_begin, x2_end),...]
-            n_dims = len(pads) // 2
-            pads_np = [(pads[i], pads[i + n_dims]) for i in range(n_dims)]
+            n_dims = len(extra_pads) // 2
+            pads_np = [(extra_pads[i], extra_pads[i + n_dims]) for i in range(n_dims)]
             padded = np.pad(
                 x,
                 ((0, 0), (0, 0), *pads_np),
@@ -321,6 +337,7 @@ class CommonPool(OpRun):
                 strides,
                 out_shape,
                 pooling_type,
+                extra_pads,
                 pads,
                 dilations,
                 count_include_pad,

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: