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

onnx/reference/ops/aionnxml/op_tree_ensemble_helper.py

@@ -41,17 +41,14 @@ class TreeEnsemble:
         for name, value in kwargs.items():
             self.atts.add(name, value)
 
-        self.tree_ids = sorted(set(self.atts.nodes_treeids))  # type: ignore
-        self.root_index = {
-            tid: len(self.atts.nodes_treeids)
-            for tid in self.tree_ids  # type: ignore
-        }
-        for index, tree_id in enumerate(self.atts.nodes_treeids):  # type: ignore
+        self.tree_ids = sorted(set(self.atts.nodes_treeids))
+        self.root_index = {tid: len(self.atts.nodes_treeids) for tid in self.tree_ids}
+        for index, tree_id in enumerate(self.atts.nodes_treeids):
             self.root_index[tree_id] = min(self.root_index[tree_id], index)
         self.node_index = {
             (tid, nid): i
             for i, (tid, nid) in enumerate(
-                zip(self.atts.nodes_treeids, self.atts.nodes_nodeids)  # type: ignore
+                zip(self.atts.nodes_treeids, self.atts.nodes_nodeids)
             )
         }
 
@@ -62,13 +59,13 @@ class TreeEnsemble:
     def leaf_index_tree(self, X: np.ndarray, tree_id: int) -> int:
         """Computes the leaf index for one tree."""
         index = self.root_index[tree_id]
-        while self.atts.nodes_modes[index] != "LEAF":  # type: ignore
-            x = X[self.atts.nodes_featureids[index]]  # type: ignore
+        while self.atts.nodes_modes[index] != "LEAF":
+            x = X[self.atts.nodes_featureids[index]]
             if np.isnan(x):
-                r = self.atts.nodes_missing_value_tracks_true[index] >= 1  # type: ignore
+                r = self.atts.nodes_missing_value_tracks_true[index] >= 1
             else:
-                rule = self.atts.nodes_modes[index]  # type: ignore
-                th = self.atts.nodes_values[index]  # type: ignore
+                rule = self.atts.nodes_modes[index]
+                th = self.atts.nodes_values[index]
                 if rule == "BRANCH_LEQ":
                     r = x <= th
                 elif rule == "BRANCH_LT":
@@ -86,15 +83,15 @@ class TreeEnsemble:
                         f"Unexpected rule {rule!r} for node index {index}."
                     )
             nid = (
-                self.atts.nodes_truenodeids[index]  # type: ignore
+                self.atts.nodes_truenodeids[index]
                 if r
-                else self.atts.nodes_falsenodeids[index]  # type: ignore
+                else self.atts.nodes_falsenodeids[index]
             )
             index = self.node_index[tree_id, nid]
         return index
 
     def leave_index_tree(self, X: np.ndarray) -> np.ndarray:
-        """Computes the leave index for all trees."""
+        """Computes the leaf index for all trees."""
         if len(X.shape) == 1:
             X = X.reshape((1, -1))
         outputs = []

onnx/reference/ops/aionnxml/op_tree_ensemble_regressor.py

@@ -12,7 +12,7 @@ from onnx.reference.ops.aionnxml.op_tree_ensemble_helper import TreeEnsemble
 class TreeEnsembleRegressor(OpRunAiOnnxMl):
     """`nodes_hitrates` and `nodes_hitrates_as_tensor` are not used."""
 
-    def _run(  # type: ignore
+    def _run(
         self,
         X,
         aggregate_function=None,
@@ -59,9 +59,9 @@ class TreeEnsembleRegressor(OpRunAiOnnxMl):
         self._tree = tr
         leaves_index = tr.leave_index_tree(X)
         res = np.zeros((leaves_index.shape[0], n_targets), dtype=X.dtype)
-        n_trees = len(set(tr.atts.nodes_treeids))  # type: ignore
+        n_trees = len(set(tr.atts.nodes_treeids))
 
-        target_index = {}  # type: ignore
+        target_index = {}
         for i, (tid, nid) in enumerate(zip(target_treeids, target_nodeids)):
             if (tid, nid) not in target_index:
                 target_index[tid, nid] = []
@@ -74,14 +74,14 @@ class TreeEnsembleRegressor(OpRunAiOnnxMl):
             if aggregate_function in ("SUM", "AVERAGE"):
                 for its in t_index:
                     for it in its:
-                        res[i, target_ids[it]] += tr.atts.target_weights[it]  # type: ignore
+                        res[i, target_ids[it]] += tr.atts.target_weights[it]
             elif aggregate_function == "MIN":
                 res[i, :] = np.finfo(res.dtype).max
                 for its in t_index:
                     for it in its:
                         res[i, target_ids[it]] = min(
                             res[i, target_ids[it]],
-                            tr.atts.target_weights[it],  # type: ignore
+                            tr.atts.target_weights[it],
                         )
             elif aggregate_function == "MAX":
                 res[i, :] = np.finfo(res.dtype).min
@@ -89,7 +89,7 @@ class TreeEnsembleRegressor(OpRunAiOnnxMl):
                     for it in its:
                         res[i, target_ids[it]] = max(
                             res[i, target_ids[it]],
-                            tr.atts.target_weights[it],  # type: ignore
+                            tr.atts.target_weights[it],
                         )
             else:
                 raise NotImplementedError(

onnx/reference/ops/experimental/__init__.py

@@ -3,4 +3,6 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
+__all__ = ["load_op"]
+
 from onnx.reference.ops.experimental._op_list import load_op

onnx/reference/ops/experimental/_op_list.py

@@ -25,7 +25,7 @@ def load_op(
 
     Args:
         domain: domain
-        op_type: oprator type
+        op_type: operator type
         version: requested version
         custom: custom implementation (like a function)
 
@@ -40,7 +40,7 @@ def load_op(
     if domain != "experimental":
         raise ValueError(f"Domain must be '' not {domain!r}.")
     if op_type not in _registered_operators:
-        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))  # type: ignore
+        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))
         raise NotImplementedError(
             f"No registered implementation for operator {op_type!r} "
             f"and domain {domain!r} in\n{available}"

onnx/reference/ops/experimental/op_im2col.py

@@ -8,7 +8,7 @@ from onnx.reference.ops_optimized.op_conv_optimized import im2col_fast
 
 
 class Im2Col(OpRunExperimental):
-    def _run(self, img, kernel_shape, dilations=None, pads=None, strides=None):  # type: ignore
+    def _run(self, img, kernel_shape, dilations=None, pads=None, strides=None):
         if dilations is None:
             dilations = [1 for s in img.shape[2:]]
         if pads is None:
@@ -17,7 +17,7 @@ class Im2Col(OpRunExperimental):
             strides = [1 for s in img.shape[2:]]
 
         if min(dilations) == max(dilations) == 1:
-            return (im2col_fast(img, tuple(kernel_shape[2:]), pads, strides)[0],)  # type: ignore
+            return (im2col_fast(img, tuple(kernel_shape[2:]), pads, strides)[0],)
 
         if dilations[0] != 1 or min(dilations) != max(dilations):
             # Let's compute the dilated kernel.
@@ -32,4 +32,4 @@ class Im2Col(OpRunExperimental):
                 )
             kernel_shape = new_kernel_shape
 
-        return (im2col_fast(img, tuple(kernel_shape[2:]), pads, strides),)  # type: ignore
+        return (im2col_fast(img, tuple(kernel_shape[2:]), pads, strides),)

onnx/reference/ops/op_abs.py

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

onnx/reference/ops/op_acos.py

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

onnx/reference/ops/op_acosh.py

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

onnx/reference/ops/op_add.py

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

onnx/reference/ops/op_affine_grid.py

@@ -83,8 +83,8 @@ def apply_affine_transform(theta_n, original_grid_homo):
 
 
 class AffineGrid(OpRun):
-    def _run(self, theta, size, align_corners=None):  # type: ignore
-        align_corners = align_corners or self.align_corners  # type: ignore
+    def _run(self, theta, size, align_corners=None):
+        align_corners = align_corners or self.align_corners
         _, _, *data_size = size
         original_grid = construct_original_grid(data_size, align_corners)
         grid = apply_affine_transform(theta, original_grid)

onnx/reference/ops/op_and.py

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

onnx/reference/ops/op_argmax.py

@@ -8,14 +8,14 @@ import numpy as np
 from onnx.reference.op_run import OpRun
 
 
-def _argmax(data, axis=0, keepdims=True):  # type: ignore
+def _argmax(data, axis=0, keepdims=True):
     result = np.argmax(data, axis=axis)
     if keepdims and len(result.shape) < len(data.shape):
         result = np.expand_dims(result, axis)
     return result.astype(np.int64)
 
 
-def _argmax_use_numpy_select_last_index(data, axis=0, keepdims=True):  # type: ignore
+def _argmax_use_numpy_select_last_index(data, axis=0, keepdims=True):
     data = np.flip(data, axis)
     result = np.argmax(data, axis=axis)
     result = data.shape[axis] - result - 1
@@ -25,7 +25,7 @@ def _argmax_use_numpy_select_last_index(data, axis=0, keepdims=True):  # type: i
 
 
 class _ArgMax(OpRun):
-    def _run(self, data, axis=None, keepdims=None):  # type: ignore
+    def _run(self, data, axis=None, keepdims=None):
         return (_argmax(data, axis=axis, keepdims=keepdims),)
 
 
@@ -34,8 +34,8 @@ class ArgMax_1(_ArgMax):
 
 
 class ArgMax_12(_ArgMax):
-    def _run(self, data, axis=None, keepdims=None, select_last_index=None):  # type: ignore
-        if select_last_index == 0:  # type: ignore
+    def _run(self, data, axis=None, keepdims=None, select_last_index=None):
+        if select_last_index == 0:
             return _ArgMax._run(self, data, axis=axis, keepdims=keepdims)
         return (
             _argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims),

onnx/reference/ops/op_argmin.py

@@ -8,14 +8,14 @@ import numpy as np
 from onnx.reference.op_run import OpRun
 
 
-def _argmin(data, axis=0, keepdims=True):  # type: ignore
+def _argmin(data, axis=0, keepdims=True):
     result = np.argmin(data, axis=axis)
     if keepdims and len(result.shape) < len(data.shape):
         result = np.expand_dims(result, axis)
     return result.astype(np.int64)
 
 
-def _argmin_use_numpy_select_last_index(data, axis=0, keepdims=True):  # type: ignore
+def _argmin_use_numpy_select_last_index(data, axis=0, keepdims=True):
     data = np.flip(data, axis)
     result = np.argmin(data, axis=axis)
     result = data.shape[axis] - result - 1
@@ -25,7 +25,7 @@ def _argmin_use_numpy_select_last_index(data, axis=0, keepdims=True):  # type: i
 
 
 class _ArgMin(OpRun):
-    def _run(self, data, axis=None, keepdims=None):  # type: ignore
+    def _run(self, data, axis=None, keepdims=None):
         return (_argmin(data, axis=axis, keepdims=keepdims),)
 
 
@@ -34,8 +34,8 @@ class ArgMin_1(_ArgMin):
 
 
 class ArgMin_12(_ArgMin):
-    def _run(self, data, axis=None, keepdims=None, select_last_index=None):  # type: ignore
-        if select_last_index == 0:  # type: ignore
+    def _run(self, data, axis=None, keepdims=None, select_last_index=None):
+        if select_last_index == 0:
             return _ArgMin._run(self, data, axis=axis, keepdims=keepdims)
         return (
             _argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims),

onnx/reference/ops/op_asin.py

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

onnx/reference/ops/op_asinh.py

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

onnx/reference/ops/op_atan.py

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

onnx/reference/ops/op_atanh.py

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

onnx/reference/ops/op_attention.py

@@ -21,8 +21,26 @@ def _softcap(X, softcap):
         Y = X / softcap
         Y = np.tanh(Y)
         return Y * softcap
-    else:
-        return X
+    return X
+
+
+def _apply_causal(mask, past_sequence_length):
+    """Applies a causal mask on the input `mask`:
+    ``mask[i, j] = -inf if past_sequence_length + i > j else 0``.
+    Because a softmax is applied on the mask, -inf becomes 0 and 0 becomes 1.
+    The modification is done inplace.
+    """
+    q_sequence_length, total_sequence_length = mask.shape[-2:]
+    triu = np.triu(
+        np.ones(
+            (q_sequence_length, total_sequence_length - past_sequence_length),
+            dtype=mask.dtype,
+        ),
+        k=1,
+    )
+    triu[triu == 1] = -np.inf
+    mask[..., :, past_sequence_length:] += triu
+    return mask
 
 
 def _compute_attention(
@@ -32,6 +50,7 @@ def _compute_attention(
     attn_mask: np.ndarray | None = None,
     past_key: np.ndarray | None = None,
     past_value: np.ndarray | None = None,
+    nonpad_kv_seqlen: np.ndarray | None = None,
     scale=None,
     is_causal=False,
     q_num_heads=None,
@@ -54,16 +73,25 @@ def _compute_attention(
         assert q_num_heads is not None and kv_num_heads is not None
 
         head_size_q = int(hidden_size_q / q_num_heads)
-        new_shape_q = [batch_size, q_num_heads, Q.shape[1], head_size_q]
-        Q = np.reshape(Q, new_shape_q)
+        # First reshape to [batch_size, q_sequence_length, q_num_heads, head_size]
+        intermediate_shape_q = [batch_size, Q.shape[1], q_num_heads, head_size_q]
+        Q = np.reshape(Q, intermediate_shape_q)
+        # Then transpose to [batch_size, q_num_heads, q_sequence_length, head_size]
+        Q = np.transpose(Q, (0, 2, 1, 3))
 
         head_size_k = int(hidden_size_k / kv_num_heads)
-        new_shape_k = [batch_size, kv_num_heads, K.shape[1], head_size_k]
-        K = np.reshape(K, new_shape_k)
+        # First reshape to [batch_size, kv_sequence_length, kv_num_heads, head_size]
+        intermediate_shape_k = [batch_size, K.shape[1], kv_num_heads, head_size_k]
+        K = np.reshape(K, intermediate_shape_k)
+        # Then transpose to [batch_size, kv_num_heads, kv_sequence_length, head_size]
+        K = np.transpose(K, (0, 2, 1, 3))
 
         head_size_v = int(hidden_size_v / kv_num_heads)
-        new_shape_v = [batch_size, kv_num_heads, V.shape[1], head_size_v]
-        V = np.reshape(V, new_shape_v)
+        # First reshape to [batch_size, kv_sequence_length, kv_num_heads, head_size]
+        intermediate_shape_v = [batch_size, V.shape[1], kv_num_heads, head_size_v]
+        V = np.reshape(V, intermediate_shape_v)
+        # Then transpose to [batch_size, kv_num_heads, kv_sequence_length, head_size]
+        V = np.transpose(V, (0, 2, 1, 3))
     assert len(Q.shape) == 4 and len(K.shape) == 4 and len(V.shape) == 4
 
     # Calculate Scaling Factor if not provided
@@ -88,25 +116,49 @@ def _compute_attention(
     q_sequence_length = Q.shape[2]
     kv_sequence_length = K.shape[2]
     attn_bias = np.zeros((q_sequence_length, kv_sequence_length), dtype=Q.dtype)
+
+    # The attn_mask can be less than kv_sequence_length, we need to pad it with -inf or 0
+    if attn_mask is not None:
+        pad_width = kv_sequence_length - attn_mask.shape[-1]
+        if pad_width > 0:
+            pad_shape = [(0, 0)] * (attn_mask.ndim - 1) + [(0, pad_width)]
+            pad_value = False if attn_mask.dtype == np.bool_ else -np.inf
+            attn_mask = np.pad(
+                attn_mask, pad_shape, mode="constant", constant_values=pad_value
+            )
+
     # First case: If is_causal is provided
     # If set to true, the attention masking is a lower triangular matrix when the mask
     # is a square matrix. The attention masking has the form of the upper left causal
     # bias due to the alignment when the mask is a non-square matrix.
-    if is_causal == 1:
-        assert attn_mask is None
-        temp_mask = np.ones((q_sequence_length, kv_sequence_length), dtype=bool)
-        temp_mask = np.tril(temp_mask, k=0)
-        temp_mask = np.logical_not(temp_mask)
-        attn_bias_ma = np.ma.array(attn_bias, mask=temp_mask)
-        attn_bias = attn_bias_ma.filled(fill_value=float("-inf"))
-    if attn_mask is not None:
-        assert is_causal != 1
-        if attn_mask.dtype == bool:
-            attn_mask = np.logical_not(attn_mask)
-            attn_bias_ma = np.ma.array(attn_bias, mask=attn_mask)
-            attn_bias = attn_bias_ma.filled(fill_value=float("-inf"))
+    if is_causal:
+        if attn_mask is None:
+            temp_mask = np.zeros((q_sequence_length, kv_sequence_length), dtype=Q.dtype)
+            attn_bias = _apply_causal(
+                temp_mask,
+                past_sequence_length=past_key.shape[2] if past_key is not None else 0,
+            )
         else:
-            attn_bias += attn_mask
+            if attn_mask.dtype == np.bool_:
+                attn_mask = (1 - attn_mask).astype(Q.dtype) * (-np.inf)
+            attn_bias = _apply_causal(
+                attn_mask.copy(),
+                past_sequence_length=past_key.shape[2] if past_key is not None else 0,
+            )
+    elif attn_mask is not None:
+        if attn_mask.dtype == np.bool_:
+            attn_mask = (1 - attn_mask).astype(Q.dtype)
+            attn_mask[attn_mask == 1] = -np.inf
+        attn_bias = attn_bias + attn_mask
+
+    if nonpad_kv_seqlen is not None:
+        attn_bias = attn_bias.reshape(
+            (1,) * (4 - attn_bias.ndim) + attn_bias.shape
+        )  # broadcast to 4D
+        padding_mask = np.arange(kv_sequence_length) < nonpad_kv_seqlen[:, np.newaxis]
+        padding_mask = padding_mask.reshape(batch_size, 1, 1, kv_sequence_length)
+        padding_mask = np.where(padding_mask, 0, -np.inf)
+        attn_bias += padding_mask
 
     # Group Query Attention is applied if the following are satisfied
     # 1) q_num_heads != kv_num_heads
@@ -125,10 +177,10 @@ def _compute_attention(
         and (q_num_heads % k_num_heads == 0)
         and (k_num_heads == v_num_heads)
     ):
-        seq_reps = int(q_num_heads / k_num_heads)
-        reps = [1, seq_reps, 1, 1]
-        K = np.tile(K, reps)
-        V = np.tile(V, reps)
+        seq_reps = q_num_heads // k_num_heads
+        # Interleave-repeat each KV head: [h0, h0, h1, h1, ...]
+        K = np.repeat(K, repeats=seq_reps, axis=1)
+        V = np.repeat(V, repeats=seq_reps, axis=1)
 
     # The following pattern is applied
     #      Q          K          V
@@ -152,7 +204,7 @@ def _compute_attention(
     qk_matmul_output = np.matmul(Q * scale, k_transpose * scale)
     qk_with_bias = qk_matmul_output + attn_bias
     if qk_matmul_output_mode == 1:
-        qk_matmul_output = qk_matmul_output + attn_bias
+        qk_matmul_output = qk_with_bias.copy()
 
     # Apply softcap
     if softcap is not None:
@@ -185,6 +237,7 @@ class Attention(OpRun):
         attn_mask: np.ndarray | None = None,
         past_key: np.ndarray | None = None,
         past_value: np.ndarray | None = None,
+        nonpad_kv_seqlen: np.ndarray | None = None,
         scale=None,
         is_causal=False,
         q_num_heads=None,
@@ -200,6 +253,7 @@ class Attention(OpRun):
             attn_mask=attn_mask,
             past_key=past_key,
             past_value=past_value,
+            nonpad_kv_seqlen=nonpad_kv_seqlen,
             scale=scale,
             is_causal=is_causal,
             q_num_heads=q_num_heads,

onnx/reference/ops/op_attribute_has_value.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class AttributeHasValue(OpRun):
-    def _run(  # type: ignore
+    def _run(
         self,
         value_float=None,  # noqa: ARG002
         value_floats=None,  # noqa: ARG002

onnx/reference/ops/op_average_pool.py

@@ -7,7 +7,7 @@ from onnx.reference.ops.op_pool_common import CommonPool
 
 
 class AveragePool_1(CommonPool):
-    def _run(  # type: ignore
+    def _run(
         self,
         x,
         auto_pad=None,
@@ -32,7 +32,7 @@ class AveragePool_1(CommonPool):
 
 
 class AveragePool_7(CommonPool):
-    def _run(  # type: ignore
+    def _run(
         self,
         x,
         auto_pad=None,
@@ -57,7 +57,7 @@ class AveragePool_7(CommonPool):
 
 
 class AveragePool_11(CommonPool):
-    def _run(  # type: ignore
+    def _run(
         self,
         x,
         auto_pad=None,
@@ -82,7 +82,7 @@ class AveragePool_11(CommonPool):
 
 
 class AveragePool_19(CommonPool):
-    def _run(  # type: ignore
+    def _run(
         self,
         x,
         auto_pad=None,

onnx/reference/ops/op_batch_normalization.py

@@ -23,7 +23,7 @@ def _batchnorm_test_mode(
     mean = mean.reshape(-1, *dim_ones)
     var = var.reshape(-1, *dim_ones)
     y = s * (x - mean) / np.sqrt(var + epsilon) + bias
-    return y.astype(x.dtype)  # type: ignore
+    return y.astype(x.dtype)
 
 
 def _batchnorm_training_mode(
@@ -41,7 +41,7 @@ def _batchnorm_training_mode(
     output_mean = mean * momentum + saved_mean * (1 - momentum)
     output_var = var * momentum + saved_var * (1 - momentum)
     y = _batchnorm_test_mode(x, s, bias, saved_mean, saved_var, epsilon=epsilon)
-    return (  # type: ignore
+    return (
         y.astype(x.dtype),
         saved_mean.astype(x.dtype),
         saved_var.astype(x.dtype),
@@ -62,7 +62,7 @@ class BatchNormalization_6(OpRun):
         is_test=None,
         momentum=None,
         spatial=None,  # noqa: ARG002
-    ):  # type: ignore
+    ):
         if is_test:
             res = _batchnorm_test_mode(x, scale, bias, mean, var, epsilon=epsilon)
         else:
@@ -73,7 +73,7 @@ class BatchNormalization_6(OpRun):
 
 
 class BatchNormalization_9(OpRun):
-    def _run(self, x, scale, bias, mean, var, epsilon=None, momentum=None):  # type: ignore
+    def _run(self, x, scale, bias, mean, var, epsilon=None, momentum=None):
         if momentum is None:
             res = _batchnorm_test_mode(x, scale, bias, mean, var, epsilon=epsilon)
             return (res,)
@@ -89,10 +89,10 @@ class BatchNormalization_9(OpRun):
 
 
 class BatchNormalization_14(OpRun):
-    def _run(  # type: ignore
+    def _run(
         self, x, scale, bias, mean, var, epsilon=None, momentum=None, training_mode=None
     ):
-        if training_mode == 0:  # type: ignore
+        if training_mode == 0:
             res = _batchnorm_test_mode(x, scale, bias, mean, var, epsilon=epsilon)
             return (res,)
         res, __, _, output_mean, output_var = _batchnorm_training_mode(

onnx/reference/ops/op_bernoulli.py

@@ -8,7 +8,7 @@ from onnx.reference.ops._op_common_random import _CommonRandom
 
 
 class Bernoulli(_CommonRandom):
-    def _run(self, x, dtype=None, seed=None):  # type: ignore
+    def _run(self, x, dtype=None, seed=None):
         if dtype is None:
             dtype = np_dtype_to_tensor_dtype(x.dtype)
         dtype = self._dtype(x, dtype=dtype, dtype_first=True)

onnx/reference/ops/op_bitshift.py

@@ -9,9 +9,9 @@ from onnx.reference.ops._op import OpRunBinaryNumpy
 
 
 class BitShift(OpRunBinaryNumpy):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRunBinaryNumpy.__init__(self, np.right_shift, onnx_node, run_params)
-        if self.direction not in ("LEFT", "RIGHT"):  # type: ignore
-            raise ValueError(f"Unexpected value for direction ({self.direction!r}).")  # type: ignore
-        if self.direction == "LEFT":  # type: ignore
+        if self.direction not in ("LEFT", "RIGHT"):
+            raise ValueError(f"Unexpected value for direction ({self.direction!r}).")
+        if self.direction == "LEFT":
             self.numpy_fct = np.left_shift

onnx/reference/ops/op_bitwise_and.py

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

onnx/reference/ops/op_bitwise_or.py

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

onnx/reference/ops/op_bitwise_xor.py

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

onnx/reference/ops/op_blackman_window.py

@@ -17,7 +17,7 @@ class BlackmanWindow(_CommonWindow):
     See `blackman_window <https://pytorch.org/docs/stable/generated/torch.blackman_window.html>`_
     """
 
-    def _run(self, size, output_datatype=None, periodic=None):  # type: ignore
+    def _run(self, size, output_datatype=None, periodic=None):
         ni, N_1 = np.arange(size), size
         if periodic == 0:
             N_1 = N_1 - 1