onnx 1.18.0__cp313-cp313-win_amd64.whl → 1.19.0__cp313-cp313-win_amd64.whl

onnx/reference/ops/op_swish.py

@@ -0,0 +1,14 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Swish(OpRunUnaryNum):
+    def _run(self, x, alpha=None):
+        alpha = self.alpha if alpha is None else alpha
+        return (x * (1 / (1 + np.exp(-alpha * x))).astype(x.dtype),)

onnx/reference/ops/op_tan.py

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

onnx/reference/ops/op_tanh.py

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

onnx/reference/ops/op_tensor_scatter.py

@@ -0,0 +1,50 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class TensorScatter(OpRun):
+    def _run(self, past_cache, update, write_indices=None, mode="linear", axis=-2):
+        if mode not in {"linear", "circular"}:
+            raise ValueError(f"Unsupported mode: {mode}")
+
+        if write_indices is None:
+            write_indices = np.zeros((past_cache.shape[0],), dtype=np.int64)
+
+        input_shape = past_cache.shape
+        update_shape = update.shape
+        axis = axis % len(input_shape)
+
+        for i in range(len(input_shape)):
+            if i != axis:
+                if input_shape[i] != update_shape[i]:
+                    raise ValueError(
+                        f"Input shape {input_shape} and update shape {update_shape} are not compatible in dimension {i}"
+                    )
+            if i == axis:
+                if input_shape[i] < update_shape[i]:
+                    raise ValueError(
+                        f"Input shape {input_shape} and update shape {update_shape} are not compatible in axis dimension"
+                    )
+
+        max_sequence_length = input_shape[axis]
+        sequence_length = update_shape[axis]
+        present_cache = np.copy(past_cache)
+
+        for prefix_idx in np.ndindex(input_shape[:axis]):
+            batch_idx = prefix_idx[0]
+            for sequence_idx in range(sequence_length):
+                cache_idx = (*prefix_idx, write_indices[batch_idx] + sequence_idx)
+                if mode == "circular":
+                    cache_idx = tuple(
+                        np.mod(np.asarray(cache_idx), max_sequence_length)
+                    )
+                update_idx = (*prefix_idx, sequence_idx)
+                present_cache[cache_idx] = update[update_idx]
+
+        return (present_cache.reshape(input_shape),)

onnx/reference/ops/op_tfidf_vectorizer.py

@@ -3,6 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
+import collections
 from enum import IntEnum
 
 import numpy as np
@@ -10,9 +11,9 @@ import numpy as np
 from onnx.reference.op_run import OpRun
 
 
-class IntMap(dict):  # type: ignore
+class IntMap(collections.UserDict):
     def __init__(self):
-        dict.__init__(self)
+        super().__init__()
         self.added_keys = []
 
     def emplace(self, key, value):
@@ -22,8 +23,8 @@ class IntMap(dict):  # type: ignore
             raise TypeError(f"value must be a NGramPart not {type(value)}.")
         if key not in self:
             self.added_keys.append(key)
-            self[key] = value
-        return self[key]
+            self.data[key] = value
+        return self.data[key]
 
     def __repr__(self):
         vals = {k: repr(v) for k, v in self.items()}
@@ -59,7 +60,7 @@ class NgramPart:
         self._leafs_ = None
 
     def init(self):
-        self._leafs_ = IntMap()  # type: ignore
+        self._leafs_ = IntMap()
 
     def __repr__(self):
         if self.empty():
@@ -81,7 +82,7 @@ class NgramPart:
     def find(self, key):
         if not self.has_leaves():
             return None
-        if key in self._leafs_:  # type: ignore
+        if key in self._leafs_:
             return key
         return None
 
@@ -89,7 +90,7 @@ class NgramPart:
         return self.leafs_.emplace(key, value)
 
     def __getitem__(self, key):
-        return self._leafs_[key]  # type: ignore
+        return self._leafs_[key]
 
 
 class WeightingCriteria(IntEnum):
@@ -126,9 +127,9 @@ def populate_grams(
 
 
 class TfIdfVectorizer(OpRun):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRun.__init__(self, onnx_node, run_params)
-        mode = self.mode  # type: ignore
+        mode = self.mode
 
         if mode == "TF":
             self.weighting_criteria_ = WeightingCriteria.TF
@@ -137,16 +138,16 @@ class TfIdfVectorizer(OpRun):
         elif mode == "TFIDF":
             self.weighting_criteria_ = WeightingCriteria.TFIDF
 
-        self.min_gram_length_ = self.min_gram_length  # type: ignore
-        self.max_gram_length_ = self.max_gram_length  # type: ignore
-        self.max_skip_count_ = self.max_skip_count  # type: ignore
-        self.ngram_counts_ = self.ngram_counts  # type: ignore
-        self.max_gram_length_ = self.max_gram_length  # type: ignore
-        self.ngram_indexes_ = self.ngram_indexes  # type: ignore
+        self.min_gram_length_ = self.min_gram_length
+        self.max_gram_length_ = self.max_gram_length
+        self.max_skip_count_ = self.max_skip_count
+        self.ngram_counts_ = self.ngram_counts
+        self.max_gram_length_ = self.max_gram_length
+        self.ngram_indexes_ = self.ngram_indexes
         self.output_size_ = max(self.ngram_indexes_) + 1
-        self.weights_ = self.weights  # type: ignore
-        self.pool_int64s_ = self.pool_int64s  # type: ignore
-        self.pool_strings_ = self.pool_strings  # type: ignore
+        self.weights_ = self.weights
+        self.pool_int64s_ = self.pool_int64s
+        self.pool_strings_ = self.pool_strings
 
         self.int64_map_ = NgramPart(-10)
         self.int64_map_.init()
@@ -237,7 +238,7 @@ class TfIdfVectorizer(OpRun):
             raise RuntimeError("Unexpected weighting_criteria.")
         return Y.reshape(output_dims)
 
-    def compute_impl(  # type: ignore
+    def compute_impl(
         self,
         X: np.ndarray,
         row_num: int,
@@ -300,7 +301,7 @@ class TfIdfVectorizer(OpRun):
                 if start_ngram_size > max_gram_length:
                     break
 
-    def _run(  # type: ignore
+    def _run(
         self,
         X,
         max_gram_length=None,

onnx/reference/ops/op_thresholded_relu.py

@@ -9,6 +9,6 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class ThresholdedRelu(OpRunUnaryNum):
-    def _run(self, x, alpha=None):  # type: ignore
-        alpha = alpha or self.alpha  # type: ignore
-        return (np.where(x > alpha, x, 0).astype(x.dtype),)  # type: ignore
+    def _run(self, x, alpha=None):
+        alpha = alpha or self.alpha
+        return (np.where(x > alpha, x, 0).astype(x.dtype),)

onnx/reference/ops/op_tile.py

@@ -9,5 +9,5 @@ from onnx.reference.op_run import OpRun
 
 
 class Tile(OpRun):
-    def _run(self, x, repeats):  # type: ignore
+    def _run(self, x, repeats):
         return (np.tile(x, repeats),)

onnx/reference/ops/op_topk.py

@@ -8,7 +8,7 @@ import numpy as np
 from onnx.reference.op_run import OpRun
 
 
-def topk_sorted_implementation(X, k, axis, largest):  # type: ignore
+def topk_sorted_implementation(X, k, axis, largest):
     """See function `_kneighbors_reduce_func
     <https://github.com/scikit-learn/scikit-learn/blob/main/
     sklearn/neighbors/_base.py#L304>`_.
@@ -35,7 +35,7 @@ def topk_sorted_implementation(X, k, axis, largest):  # type: ignore
 
 
 class _CommonTopK(OpRun):
-    def _common_run(self, data, ink, axis, largest=1):  # type: ignore
+    def _common_run(self, data, ink, axis, largest=1):
         """Runtime for operator *TopK*.
         The implementation is not the most efficient
         as it sorts everything then extracts the top *k*
@@ -48,13 +48,13 @@ class _CommonTopK(OpRun):
             <https://github.com/Microsoft/onnxruntime/blob/main/onnxruntime/core/providers/cpu/math/top_k.cc#L63>`_.
         """
         k = ink[0]
-        axis = axis if axis >= 0 else (axis + len(data.shape))  # type: ignore
+        axis = axis if axis >= 0 else (axis + len(data.shape))
         sort, sorti = topk_sorted_implementation(data, k, axis, largest)
         return (sort, sorti.astype(np.int64))
 
 
 class TopK_1(_CommonTopK):
-    def _run(self, data, k=None, axis=None):  # type: ignore
+    def _run(self, data, k=None, axis=None):
         """Runtime for operator *TopK*.
         The implementation is not the most efficient
         as it sorts everything then extracts the top *k*
@@ -66,11 +66,11 @@ class TopK_1(_CommonTopK):
             does in `top_k.cc
             <https://github.com/Microsoft/onnxruntime/blob/main/onnxruntime/core/providers/cpu/math/top_k.cc#L63>`_.
         """
-        return _CommonTopK._common_run(self, data, [k], axis=axis)  # type: ignore
+        return _CommonTopK._common_run(self, data, [k], axis=axis)
 
 
 class TopK_10(_CommonTopK):
-    def _run(self, data, ink, axis=None):  # type: ignore
+    def _run(self, data, ink, axis=None):
         """Runtime for operator *TopK*.
         The implementation is not the most efficient
         as it sorts everything then extracts the top *k*
@@ -93,7 +93,7 @@ class TopK_11(_CommonTopK):
         axis=None,
         largest=None,
         sorted=None,  # noqa: A002
-    ):  # type: ignore
+    ):
         """Runtime for operator *TopK*.
 
         The implementation is not the most efficient

onnx/reference/ops/op_transpose.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class Transpose(OpRun):
-    def _run(self, data, perm=None):  # type: ignore
+    def _run(self, data, perm=None):
         perm_ = None if (perm is None or len(perm) == 0) else perm
         if perm_ is None:
             return (np.transpose(data),)

onnx/reference/ops/op_trilu.py

@@ -9,8 +9,8 @@ from onnx.reference.op_run import OpRun
 
 
 class Trilu(OpRun):
-    def _run(self, x, k=None, upper=None):  # type: ignore
-        k = 0 if k is None else int(k)
-        if upper:  # type: ignore
+    def _run(self, x, k=None, upper=None):
+        k = 0 if k is None else k.item()
+        if upper:
             return (np.triu(x, k),)
         return (np.tril(x, k).astype(x.dtype),)

onnx/reference/ops/op_unique.py

@@ -8,7 +8,7 @@ import numpy as np
 from onnx.reference.op_run import OpRun
 
 
-def _specify_int64(indices, inverse_indices, counts):  # type: ignore
+def _specify_int64(indices, inverse_indices, counts):
     return (
         np.array(indices, dtype=np.int64),
         np.array(inverse_indices, dtype=np.int64),

onnx/reference/ops/op_unsqueeze.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class Unsqueeze_1(OpRun):
-    def _run(self, data, axes=None):  # type: ignore
+    def _run(self, data, axes=None):
         if isinstance(axes, np.ndarray):
             axes = tuple(axes)
         elif axes in ([], ()):
@@ -32,7 +32,7 @@ class Unsqueeze_11(Unsqueeze_1):
 
 
 class Unsqueeze_13(OpRun):
-    def _run(self, data, axes=None):  # type: ignore
+    def _run(self, data, axes=None):
         if axes is not None:
             if hasattr(axes, "__iter__") and len(axes.shape) > 0:
                 try:

onnx/reference/ops/op_upsample.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class Upsample(OpRun):
-    def _run(self, x, scale, mode=None):  # type: ignore
+    def _run(self, x, scale, mode=None):
         if mode == "nearest" and scale.astype(np.int64).tolist() == scale.tolist():
             r = x
             for axis, s in enumerate(scale):

onnx/reference/ops/op_where.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class Where(OpRun):
-    def _run(self, condition, x, y):  # type: ignore
+    def _run(self, condition, x, y):
         if (
             x.dtype != y.dtype
             and x.dtype not in (object,)

onnx/reference/ops/op_xor.py

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

onnx/reference/ops_optimized/__init__.py

@@ -1,5 +1,3 @@
-# Copyright (c) ONNX Project Contributors
-
 # Copyright (c) ONNX Project Contributors
 #
 # SPDX-License-Identifier: Apache-2.0

onnx/reference/ops_optimized/op_conv_optimized.py

@@ -47,7 +47,7 @@ def im2col_fast(X, kernel_shape, pads, strides):
     return conc_cols, tuple(shape_out)
 
 
-def _conv_implementation_im2col(  # type: ignore
+def _conv_implementation_im2col(
     X, W, B, auto_pad, dilations, group, kernel_shape, pads, strides
 ):
     if dilations is None:
@@ -165,7 +165,7 @@ def _conv_implementation_im2col(  # type: ignore
 
 
 class Conv(OpRun):
-    def _run(  # type: ignore
+    def _run(
         self,
         X,
         W,

onnx/reference/reference_evaluator.py

@@ -8,10 +8,8 @@ from typing import Any
 
 import numpy as np
 
-from onnx import load
-from onnx.defs import onnx_opset_version
-from onnx.external_data_helper import ExternalDataInfo, uses_external_data
-from onnx.model_container import ModelContainer
+import onnx
+import onnx.model_container
 from onnx.onnx_pb import (
     FunctionProto,
     GraphProto,
@@ -20,13 +18,7 @@ from onnx.onnx_pb import (
     TensorProto,
     TypeProto,
 )
-from onnx.reference.op_run import (
-    OpFunctionContextDependant,
-    OpRun,
-    OpRunExpand,
-    RuntimeContextError,
-    to_array_extended,
-)
+from onnx.reference import op_run
 from onnx.reference.ops_optimized import optimized_operators
 
 
@@ -114,7 +106,7 @@ class ReferenceEvaluator:
 
             op_domain = "custom"
 
-            def _run(self, x, alpha=None):  # type: ignore
+            def _run(self, x, alpha=None):
                 # None must be the default value, it is automatically
                 # replaced by class OpRun with either the default value
                 # specified in the NodeProto or an attribute value defined
@@ -204,9 +196,9 @@ class ReferenceEvaluator:
         self,
         proto: Any,
         opsets: dict[str, int] | None = None,
-        functions: list[ReferenceEvaluator | FunctionProto] | None = None,  # type: ignore
+        functions: list[ReferenceEvaluator | FunctionProto] | None = None,
         verbose: int = 0,
-        new_ops: list[type[OpRun]] | None = None,
+        new_ops: list[type[op_run.OpRun]] | None = None,
         optimized: bool = True,
     ) -> None:
         if optimized:
@@ -220,17 +212,17 @@ class ReferenceEvaluator:
         self.output_types_ = None
         self.input_types_ = None
 
-        if isinstance(proto, ModelContainer):
-            self.container_: ModelContainer | None = proto
+        if isinstance(proto, onnx.model_container.ModelContainer):
+            self.container_: onnx.model_container.ModelContainer | None = proto
             proto = self.container_.model_proto
         else:
             self.container_ = None
 
         if isinstance(proto, str):
             with open(proto, "rb") as f:
-                proto = load(f)
+                proto = onnx.load(f)
         elif isinstance(proto, bytes):
-            proto = load(BytesIO(proto))
+            proto = onnx.load(BytesIO(proto))
         self.proto_ = proto
         self.functions_: dict[tuple[str, str], ReferenceEvaluator] = {}
         self.attributes_: list[str] = []
@@ -248,15 +240,17 @@ class ReferenceEvaluator:
                 raise TypeError("opsets must be a dictionary if proto is GraphProto.")
             self.opsets_ = opsets
         elif isinstance(proto, FunctionProto):
-            self.onnx_graph_ = None  # type: ignore
+            self.onnx_graph_ = None
             self.opsets_ = {d.domain: d.version for d in proto.opset_import}
             if opsets is not None:
                 raise ValueError("opsets must be None if proto is FunctionProto.")
             self.attributes_ = list(proto.attribute)
         elif isinstance(proto, NodeProto):
-            self.onnx_graph_ = None  # type: ignore
+            self.onnx_graph_ = None
             self.opsets_ = {
-                proto.domain: 1 if proto.domain != "" else onnx_opset_version()
+                proto.domain: 1
+                if proto.domain != ""
+                else onnx.defs.onnx_opset_version()
             }
         else:
             raise TypeError(f"Unexpected type {type(proto)} for proto.")
@@ -266,7 +260,7 @@ class ReferenceEvaluator:
             self.output_names_ = [o.name for o in self.onnx_graph_.output]
             self.output_types_ = [i.type for i in self.onnx_graph_.output]
             self.inits_ = list(self.onnx_graph_.initializer) + list(
-                self.onnx_graph_.sparse_initializer  # type: ignore
+                self.onnx_graph_.sparse_initializer
             )
             self.nodes_ = self.onnx_graph_.node
             all_types = {i.name: i.type for i in self.onnx_graph_.input}
@@ -283,27 +277,27 @@ class ReferenceEvaluator:
             else:
                 self.nodes_ = proto.node
         if functions is not None:
-            for f in functions:  # type: ignore
+            for f in functions:
                 if isinstance(f, FunctionProto):
                     self.functions_[f.domain, f.name] = self.__class__(
                         f, verbose=verbose, functions=list(self.functions_.values())
                     )
                 elif isinstance(f, ReferenceEvaluator):
-                    onx = f.proto_  # type: ignore
+                    onx = f.proto_
                     self.functions_[onx.domain, onx.name] = f
                 else:
                     raise TypeError(f"Unexpected type {type(f)!r} for a function.")
         self.verbose = verbose
-        self.new_ops_: dict[tuple[str, str], type[OpRun]] = {}
+        self.new_ops_: dict[tuple[str, str], type[op_run.OpRun]] = {}
         if new_ops is not None:
             for cl in new_ops:
                 if not hasattr(cl, "op_domain"):
                     raise AttributeError(
                         f"Class {cl} must define attribute 'op_domain'."
                     )
-                if not issubclass(cl, OpRun):  # type: ignore
+                if not issubclass(cl, op_run.OpRun):
                     raise TypeError(f"Class {cl} must inherit from OpRun (in new_ops).")
-                key = cl.op_domain, cl.__name__  # type: ignore
+                key = cl.op_domain, cl.__name__
                 if key in self.new_ops_:
                     # Already an implementation, the first one is used.
                     continue
@@ -312,7 +306,7 @@ class ReferenceEvaluator:
 
     def retrieve_external_data(self, initializer: TensorProto) -> np.ndarray:
         """Returns a tensor saved as external."""
-        info = ExternalDataInfo(initializer)
+        info = onnx.external_data_helper.ExternalDataInfo(initializer)
         location = info.location
         if self.container_ and self.container_.is_in_memory_external_initializer(
             location
@@ -349,27 +343,27 @@ class ReferenceEvaluator:
             print(pattern % tuple(new_args))
 
     @property
-    def input_names(self):  # type: ignore
+    def input_names(self):
         """Returns the input names."""
         return self.input_names_
 
     @property
-    def input_types(self):  # type: ignore
+    def input_types(self):
         """Returns the input types if any specified."""
         return self.input_types_
 
     @property
-    def output_names(self):  # type: ignore
+    def output_names(self):
         """Returns the output names."""
         return self.output_names_
 
     @property
-    def output_types(self):  # type: ignore
+    def output_types(self):
         """Returns the output types."""
         return self.output_types_
 
     @property
-    def opsets(self):  # type: ignore
+    def opsets(self):
         """Returns the opsets."""
         return self.opsets_
 
@@ -403,8 +397,8 @@ class ReferenceEvaluator:
         for init in self.inits_:
             self.rt_inits_[init.name] = (
                 self.retrieve_external_data(init)
-                if uses_external_data(init)
-                else to_array_extended(init)
+                if onnx.external_data_helper.uses_external_data(init)
+                else onnx.numpy_helper.to_array(init)
             )
         run_params = {
             "log": lambda pattern, *args: self._log(10, pattern, *args),
@@ -421,25 +415,26 @@ class ReferenceEvaluator:
                     all_types[shape_type.name] = shape_type.type
             self.all_types_ = all_types
         else:
-            self.all_types_ = None  # type: ignore
+            self.all_types_ = None
 
         for node in self.nodes_:
             try:
                 cl = self._load_impl(node)
-            except RuntimeContextError as e:
+            except op_run.RuntimeContextError as e:
                 # A node has a context dependent implementation.
                 # Shape inference must be run to get the input types.
                 if self.all_types_:
                     it = [self.get_result_types(i, exc=False) for i in node.input]
                     if None in it:
                         # One input does not exist. It must be done while executing the graph.
-                        cl = lambda *args, parent=self: OpFunctionContextDependant(  # noqa: E731
-                            *args, parent=parent
-                        )
+                        def cl(*args, parent=self):
+                            return op_run.OpFunctionContextDependant(
+                                *args, parent=parent
+                            )
                     else:
-                        cl = self._load_impl(node, it)  # type: ignore
+                        cl = self._load_impl(node, it)
                 else:
-                    raise RuntimeContextError(
+                    raise op_run.RuntimeContextError(
                         f"No implementation was found for node type {node.op_type!r} from domain {node.domain!r}. "
                         f"If this node has a context dependent implementation, you should run function infer_shapes "
                         f"before calling ReferenceEvaluator."
@@ -470,13 +465,13 @@ class ReferenceEvaluator:
             # This mechanism can be used to implement a custom onnx node
             # or to overwrite an existing one.
             cl = self.new_ops_[key]
-            if not issubclass(cl, OpRunExpand):
+            if not issubclass(cl, op_run.OpRunExpand):
                 return cl
             # It must be replaced by its implementation defined in its schema.
             expand = True
 
         if node.domain == "":
-            from onnx.reference.ops import load_op
+            from onnx.reference.ops import load_op  # noqa: PLC0415
 
             try:
                 return load_op(
@@ -486,7 +481,7 @@ class ReferenceEvaluator:
                     expand=expand,
                     evaluator_cls=self.__class__,
                 )
-            except RuntimeContextError:
+            except op_run.RuntimeContextError:
                 if input_types is None:
                     raise
                 return load_op(
@@ -506,23 +501,29 @@ class ReferenceEvaluator:
                 f"{node.domain},{node.op_type} from the list of inlined operator."
             )
         if node.domain == "ai.onnx.preview.training":
-            from onnx.reference.ops.aionnx_preview_training import load_op as load_op_pt
+            from onnx.reference.ops.aionnx_preview_training import (  # noqa: PLC0415
+                load_op as load_op_pt,
+            )
 
             return load_op_pt(node.domain, node.op_type, version)
 
         if node.domain == "experimental":
-            from onnx.reference.ops.experimental import load_op as load_op_exp
+            from onnx.reference.ops.experimental import (  # noqa: PLC0415
+                load_op as load_op_exp,
+            )
 
             return load_op_exp(node.domain, node.op_type, version)
 
         if node.domain == "ai.onnx.ml":
-            from onnx.reference.ops.aionnxml import load_op as load_op_ml
+            from onnx.reference.ops.aionnxml import (  # noqa: PLC0415
+                load_op as load_op_ml,
+            )
 
             return load_op_ml(node.domain, node.op_type, version)
 
         # It has to be a function.
         if key in self.functions_:
-            from onnx.reference.ops import load_op
+            from onnx.reference.ops import load_op  # noqa: PLC0415
 
             impl = self.functions_[key]
             return load_op(
@@ -543,7 +544,7 @@ class ReferenceEvaluator:
         feed_inputs: dict[str, Any],
         attributes: dict[str, Any] | None = None,
         intermediate: bool = False,
-    ) -> dict[str, Any] | list[Any]:  # type: ignore
+    ) -> dict[str, Any] | list[Any]:
         """Executes the onnx model.
 
         Args: