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

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.

onnx/reference/ops/op_reduce_sum.py

@@ -9,7 +9,7 @@ from onnx.reference.ops._op import OpRunReduceNumpy
 
 
 class ReduceSum_1(OpRunReduceNumpy):
-    def _run(self, x, axes=None, keepdims=None):  # type: ignore
+    def _run(self, x, axes=None, keepdims=None):
         axes = tuple(axes) if axes is not None else None
         res = np.sum(x, axis=axes, keepdims=keepdims, dtype=x.dtype)
         if keepdims == 0 and not isinstance(res, np.ndarray):
@@ -19,7 +19,7 @@ class ReduceSum_1(OpRunReduceNumpy):
 
 
 class ReduceSum_13(OpRunReduceNumpy):
-    def _run(self, x, axes=None, keepdims=None, noop_with_empty_axes=None):  # type: ignore
+    def _run(self, x, axes=None, keepdims=None, noop_with_empty_axes=None):
         if (axes is None or axes.shape == (0,)) and noop_with_empty_axes:
             return (x,)
         axes = self.handle_axes(axes)

onnx/reference/ops/op_reduce_sum_square.py

@@ -9,7 +9,7 @@ from onnx.reference.ops._op import OpRunReduceNumpy
 
 
 class ReduceSumSquare_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.square(data), axis=axes, keepdims=keepdims)
         if keepdims == 0 and not isinstance(res, np.ndarray):
@@ -19,12 +19,12 @@ class ReduceSumSquare_1(OpRunReduceNumpy):
 
 
 class ReduceSumSquare_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 != 0:  # 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 != 0:
             return (np.square(data),)
 
         axes = self.handle_axes(axes)
-        keepdims = keepdims != 0  # type: ignore
+        keepdims = keepdims != 0
         res = np.sum(np.square(data), axis=axes, keepdims=keepdims)
         if keepdims == 0 and not isinstance(res, np.ndarray):
             # The runtime must return a numpy array of a single float.

onnx/reference/ops/op_regex_full_match.py

@@ -3,6 +3,8 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
+import re
+
 import numpy as np
 
 from onnx.reference.op_run import OpRun
@@ -12,19 +14,20 @@ _acceptable_str_dtypes = ("U", "O")
 
 class RegexFullMatch(OpRun):
     def _run(self, x, pattern=None):
-        try:
-            import re2
-        except ImportError as e:
-            raise ImportError(
-                "re2 must be installed to use the reference implementation of the RegexFullMatch operator"
-            ) from e
-
-            # As per onnx/mapping.py, object numpy dtype corresponds to TensorProto.STRING
+        # Note: The ONNX specification states that the pattern MUST
+        # follow the re2 syntax. Python's own re package appears to
+        # cover a superset of re2's functionality, albeit definitive
+        # sources are difficult to find. Since the Python bindings to
+        # re2 appear unmaintained, this operator is implemented using
+        # the re module for the time being. This may change if
+        # discrepancies surface in the future.
+
+        # As per onnx/mapping.py, object numpy dtype corresponds to TensorProto.STRING
         if x.dtype.kind not in _acceptable_str_dtypes:
             raise TypeError(f"Input must be string tensor, received dtype {x.dtype}")
         try:
-            regex = re2.compile(pattern)
-        except re2.error as e:
+            regex = re.compile(pattern)
+        except re.error as e:
             raise ValueError(f"Invalid regex pattern {pattern!r}") from e
 
         fullmatch_func = np.vectorize(

onnx/reference/ops/op_relu.py

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

onnx/reference/ops/op_reshape.py

@@ -22,7 +22,7 @@ def reshape_reference_implementation(
 
 
 class CommonReshape(OpRun):
-    def _run(self, data, shape):  # type: ignore
+    def _run(self, data, shape):
         return (reshape_reference_implementation(data, shape, 0),)
 
 
@@ -31,7 +31,7 @@ class Reshape_5(CommonReshape):
 
 
 class Reshape_14(CommonReshape):
-    def _run(self, data, shape, allowzero=None):  # type: ignore
+    def _run(self, data, shape, allowzero=None):
         if allowzero is None:
             allowzero = getattr(self, "allowzero", 0) == 1
         else:

onnx/reference/ops/op_resize.py

@@ -7,6 +7,7 @@ from typing import Any, Callable
 
 import numpy as np
 
+import onnx
 from onnx.reference.op_run import OpRun
 
 
@@ -390,7 +391,7 @@ def _interpolate_nd(
 
 
 class Resize(OpRun):
-    def _run(  # type: ignore
+    def _run(
         self,
         X,
         roi,
@@ -431,17 +432,20 @@ class Resize(OpRun):
             raise ValueError(f"Unexpected value {mode!r} for mode.")
 
         if axes is None:
-            output = _interpolate_nd(
-                X,
-                fct,
-                scale_factors=scales,
-                output_size=sizes,
-                roi=roi,
-                keep_aspect_ratio_policy=keep_aspect_ratio_policy,
-                exclude_outside=exclude_outside,
-                coordinate_transformation_mode=coordinate_transformation_mode,  # type: ignore
-                extrapolation_value=extrapolation_value,  # type: ignore
-            ).astype(X.dtype)
+            output = onnx.numpy_helper.saturate_cast(
+                _interpolate_nd(
+                    X,
+                    fct,
+                    scale_factors=scales,
+                    output_size=sizes,
+                    roi=roi,
+                    keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+                    exclude_outside=exclude_outside,
+                    coordinate_transformation_mode=coordinate_transformation_mode,
+                    extrapolation_value=extrapolation_value,
+                ),
+                X.dtype,
+            )
             return (output,)
 
         # axes is not None
@@ -460,14 +464,14 @@ class Resize(OpRun):
                 roi=roi,
                 keep_aspect_ratio_policy=keep_aspect_ratio_policy,
                 exclude_outside=exclude_outside,
-                coordinate_transformation_mode=coordinate_transformation_mode,  # type: ignore
-                extrapolation_value=extrapolation_value,  # type: ignore
-            ).astype(X.dtype)
+                coordinate_transformation_mode=coordinate_transformation_mode,
+                extrapolation_value=extrapolation_value,
+            )
             if res is None:
-                res = np.empty((reshaped.shape[0], *output.shape), dtype=output.dtype)
-            res[i] = output
+                res = np.empty((reshaped.shape[0], *output.shape), dtype=X.dtype)
+            res[i] = onnx.numpy_helper.saturate_cast(output, X.dtype)
 
-        res_reshaped = res.reshape(tuple(X.shape[a] for a in not_axes) + res[0].shape)  # type: ignore
+        res_reshaped = res.reshape(tuple(X.shape[a] for a in not_axes) + res[0].shape)
         new_perm = list(perm)
         for i, a in enumerate(perm):
             new_perm[a] = i

onnx/reference/ops/op_reverse_sequence.py

@@ -7,14 +7,14 @@ from onnx.reference.op_run import OpRun
 
 
 class ReverseSequence(OpRun):
-    def _run(self, data, sequence_lens, batch_axis=None, time_axis=None):  # type: ignore
+    def _run(self, data, sequence_lens, batch_axis=None, time_axis=None):
         index = [slice(0, s) for s in data.shape]
         index_data = [slice(0, s) for s in data.shape]
         result = data.copy()
         for i, sl in enumerate(sequence_lens):
-            index[batch_axis] = i  # type: ignore
+            index[batch_axis] = i
             index[time_axis] = slice(0, sl)
-            index_data[batch_axis] = i  # type: ignore
-            index_data[time_axis] = slice(sl - 1, None, -1)  # type: ignore
+            index_data[batch_axis] = i
+            index_data[time_axis] = slice(sl - 1, None, -1)
             result[tuple(index)] = data[tuple(index_data)]
         return (result,)

onnx/reference/ops/op_rms_normalization.py

@@ -40,10 +40,10 @@ def _rms_normalization(
 
 
 class RMSNormalization(OpRun):
-    def _run(self, X, Scale, axis=None, epsilon=None, stash_type=None):  # type: ignore
+    def _run(self, X, Scale, axis=None, epsilon=None, stash_type=None):
         if stash_type != 1:
             raise NotImplementedError(
                 f"RMSNormalization not implemented for stash_type={stash_type} != 1."
             )
         res = _rms_normalization(X, Scale, axis=axis, epsilon=epsilon)
-        return (res,)  # type: ignore
+        return (res,)

onnx/reference/ops/op_rnn.py

@@ -9,73 +9,73 @@ from onnx.reference.op_run import OpRun
 
 
 class CommonRNN(OpRun):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRun.__init__(self, onnx_node, run_params)
 
-        if self.direction in ("forward", "reverse"):  # type: ignore
-            self.num_directions = 1  # type: ignore
-        elif self.direction == "bidirectional":  # type: ignore
-            self.num_directions = 2  # type: ignore
+        if self.direction in ("forward", "reverse"):
+            self.num_directions = 1
+        elif self.direction == "bidirectional":
+            self.num_directions = 2
         else:
-            raise RuntimeError(f"Unknown direction {self.direction!r}.")  # type: ignore
+            raise RuntimeError(f"Unknown direction {self.direction!r}.")
 
         if (
-            self.activation_alpha is not None  # type: ignore
-            and len(self.activation_alpha) != self.num_directions  # type: ignore
+            self.activation_alpha is not None
+            and len(self.activation_alpha) != self.num_directions
         ):
             raise RuntimeError(
-                f"activation_alpha must have the same size as num_directions={self.num_directions}."  # type: ignore
+                f"activation_alpha must have the same size as num_directions={self.num_directions}."
             )
         if (
-            self.activation_beta is not None  # type: ignore
-            and len(self.activation_beta) != self.num_directions  # type: ignore
+            self.activation_beta is not None
+            and len(self.activation_beta) != self.num_directions
         ):
             raise RuntimeError(
-                f"activation_beta must have the same size as num_directions={self.num_directions}."  # type: ignore
+                f"activation_beta must have the same size as num_directions={self.num_directions}."
             )
 
         self.f1 = self.choose_act(
-            self.activations[0],  # type: ignore
+            self.activations[0],
             (
-                self.activation_alpha[0]  # type: ignore
-                if self.activation_alpha is not None and len(self.activation_alpha) > 0  # type: ignore
+                self.activation_alpha[0]
+                if self.activation_alpha is not None and len(self.activation_alpha) > 0
                 else None
             ),
             (
-                self.activation_beta[0]  # type: ignore
-                if self.activation_beta is not None and len(self.activation_beta) > 0  # type: ignore
+                self.activation_beta[0]
+                if self.activation_beta is not None and len(self.activation_beta) > 0
                 else None
             ),
         )
-        if len(self.activations) > 1:  # type: ignore
+        if len(self.activations) > 1:
             self.f2 = self.choose_act(
-                self.activations[1],  # type: ignore
+                self.activations[1],
                 (
-                    self.activation_alpha[1]  # type: ignore
+                    self.activation_alpha[1]
                     if self.activation_alpha is not None
-                    and len(self.activation_alpha) > 1  # type: ignore
+                    and len(self.activation_alpha) > 1
                     else None
                 ),
                 (
-                    self.activation_beta[1]  # type: ignore
+                    self.activation_beta[1]
                     if self.activation_beta is not None
-                    and len(self.activation_beta) > 1  # type: ignore
+                    and len(self.activation_beta) > 1
                     else None
                 ),
             )
         self.n_outputs = len(onnx_node.output)
 
-    def choose_act(self, name, alpha, beta):  # type: ignore
+    def choose_act(self, name, alpha, beta):
         if name in ("Tanh", "tanh"):
             return self._f_tanh
         if name in ("Affine", "affine"):
             return lambda x: x * alpha + beta
         raise RuntimeError(f"Unknown activation function {name!r}.")
 
-    def _f_tanh(self, x):  # type: ignore
+    def _f_tanh(self, x):
         return np.tanh(x)
 
-    def _step(self, X, R, B, W, H_0):  # type: ignore
+    def _step(self, X, R, B, W, H_0):
         h_list = []
         H_t = H_0
         for x in np.split(X, X.shape[0], axis=0):
@@ -91,7 +91,7 @@ class CommonRNN(OpRun):
             output = np.expand_dims(concatenated, 1)
         return output, h_list[-1]
 
-    def _run(  # type: ignore
+    def _run(
         self,
         X,
         W,

onnx/reference/ops/op_roi_align.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class PreCalc:
-    def __init__(self, pos1=0, pos2=0, pos3=0, pos4=0, w1=0, w2=0, w3=0, w4=0):  # type: ignore
+    def __init__(self, pos1=0, pos2=0, pos3=0, pos4=0, w1=0, w2=0, w3=0, w4=0):
         self.pos1 = pos1
         self.pos2 = pos2
         self.pos3 = pos3
@@ -25,7 +25,7 @@ class PreCalc:
 
 class RoiAlign(OpRun):
     @staticmethod
-    def pre_calc_for_bilinear_interpolate(  # type: ignore
+    def pre_calc_for_bilinear_interpolate(
         height: int,
         width: int,
         pooled_height: int,
@@ -99,7 +99,7 @@ class RoiAlign(OpRun):
                         w3 = ly * hx
                         w4 = ly * lx
 
-                        # save weights and indeces
+                        # save weights and indices
                         pc = PreCalc()
                         pc.pos1 = y_low * width + x_low
                         pc.pos2 = y_low * width + x_high
@@ -114,7 +114,7 @@ class RoiAlign(OpRun):
                         pre_calc_index += 1
 
     @staticmethod
-    def roi_align_forward(  # type: ignore
+    def roi_align_forward(
         output_shape: tuple[int, int, int, int],
         bottom_data,
         spatial_scale,
@@ -133,7 +133,7 @@ class RoiAlign(OpRun):
         pooled_height = output_shape[2]
         pooled_width = output_shape[3]
 
-        # 100 is a random chosed value, need be tuned
+        # 100 is a random chosen value, need be tuned
         for n in range(n_rois):
             index_n = n * channels * pooled_width * pooled_height
 
@@ -251,7 +251,7 @@ class RoiAlign(OpRun):
 
                         top_data[index] = output_val
 
-    def _run(  # type: ignore
+    def _run(
         self,
         X,
         rois,
@@ -265,12 +265,12 @@ class RoiAlign(OpRun):
     ):
         coordinate_transformation_mode = (
             coordinate_transformation_mode or self.coordinate_transformation_mode
-        )  # type: ignore
-        mode = mode or self.mode  # type: ignore
-        output_height = output_height or self.output_height  # type: ignore
-        output_width = output_width or self.output_width  # type: ignore
-        sampling_ratio = sampling_ratio or self.sampling_ratio  # type: ignore
-        spatial_scale = spatial_scale or self.spatial_scale  # type: ignore
+        )
+        mode = mode or self.mode
+        output_height = output_height or self.output_height
+        output_width = output_width or self.output_width
+        sampling_ratio = sampling_ratio or self.sampling_ratio
+        spatial_scale = spatial_scale or self.spatial_scale
 
         num_channels = X.shape[1]
         num_rois = batch_indices.shape[0]