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

onnx/reference/ops/aionnx_preview_training/op_adam.py

@@ -8,9 +8,9 @@ import numpy as np
 from onnx.reference.ops.aionnx_preview_training._op_run_training import OpRunTraining
 
 
-def _apply_adam(  # type: ignore
+def _apply_adam(
     r, t, x, g, v, h, norm_coefficient, norm_coefficient_post, alpha, beta, epsilon
-):  # type: ignore
+):
     # Add gradient of regularization term.
     g_regularized = norm_coefficient * x + g
     # Update momentum.
@@ -35,7 +35,7 @@ def _apply_adam(  # type: ignore
 
 
 class Adam(OpRunTraining):
-    def _run(  # type: ignore
+    def _run(
         self,
         *data,
         alpha=None,
@@ -45,7 +45,7 @@ class Adam(OpRunTraining):
         norm_coefficient_post=None,
     ):
         if len(data) == 6:
-            return self._run1(  # type: ignore
+            return self._run1(
                 *data,
                 alpha=alpha,
                 beta=beta,
@@ -58,7 +58,7 @@ class Adam(OpRunTraining):
         vs = []
         hs = []
         for i in range(n):
-            a, b, c = self._run1(  # type: ignore
+            a, b, c = self._run1(
                 *data[:2],
                 data[2 + i],
                 data[2 + n + i],
@@ -75,7 +75,7 @@ class Adam(OpRunTraining):
             hs.append(c.astype(np.float32))
         return tuple(xs + vs + hs)
 
-    def _run1(  # type: ignore
+    def _run1(
         self,
         r,
         t,

onnx/reference/ops/aionnx_preview_training/op_momentum.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 from onnx.reference.ops.aionnx_preview_training._op_run_training import OpRunTraining
 
 
-def _apply_momentum(r, t, x, g, v, norm_coefficient, alpha, beta):  # type: ignore
+def _apply_momentum(r, t, x, g, v, norm_coefficient, alpha, beta):
     # Add gradient of regularization term.
     g_regularized = norm_coefficient * x + g
     # Coefficient of gradient should be 1 at the first iteration.
@@ -18,7 +18,7 @@ def _apply_momentum(r, t, x, g, v, norm_coefficient, alpha, beta):  # type: igno
     return x_new, v_new
 
 
-def _apply_nesterov(r, t, x, g, v, norm_coefficient, alpha, beta):  # type: ignore
+def _apply_nesterov(r, t, x, g, v, norm_coefficient, alpha, beta):
     # Add gradient of regularization term.
     g_regularized = norm_coefficient * x + g
     # Coefficient of gradient should be 1 at the first iteration.
@@ -31,10 +31,10 @@ def _apply_nesterov(r, t, x, g, v, norm_coefficient, alpha, beta):  # type: igno
 
 
 class Momentum(OpRunTraining):
-    def _run(self, *data, alpha=None, beta=None, mode=None, norm_coefficient=None):  # type: ignore
+    def _run(self, *data, alpha=None, beta=None, mode=None, norm_coefficient=None):
         if len(data) == 5:
             r, t, x, g, v = data
-            return self._run1(  # type: ignore
+            return self._run1(
                 r,
                 t,
                 x,
@@ -49,7 +49,7 @@ class Momentum(OpRunTraining):
         xs = []
         vs = []
         for i in range(n):
-            a, b = self._run1(  # type: ignore
+            a, b = self._run1(
                 *data[:2],
                 data[2 + i],
                 data[2 + n + i],
@@ -74,7 +74,7 @@ class Momentum(OpRunTraining):
         norm_coefficient=None,
         alpha=None,
         beta=None,
-    ):  # type: ignore
+    ):
         if mode == "standard":
             x_new, v_new = _apply_momentum(r, t, x, g, v, norm_coefficient, alpha, beta)
         else:

onnx/reference/ops/aionnxml/__init__.py

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

onnx/reference/ops/aionnxml/_common_classifier.py

@@ -6,7 +6,7 @@ import numpy as np
 
 def compute_logistic(val: float) -> float:
     v = 1.0 / (1.0 + np.exp(-np.abs(val)))
-    return (1.0 - v) if val < 0 else v  # type: ignore
+    return (1.0 - v) if val < 0 else v
 
 
 logistic = np.vectorize(compute_logistic)
@@ -17,8 +17,7 @@ def compute_softmax_zero(values: np.ndarray) -> np.ndarray:
     v_max = values.max()
     exp_neg_v_max = np.exp(-v_max)
     s = 0
-    for i in range(len(values)):
-        v = values[i]
+    for i, v in enumerate(values):
         if v > 0.0000001 or v < -0.0000001:
             values[i] = np.exp(v - v_max)
         else:
@@ -44,10 +43,10 @@ def softmax_zero(values: np.ndarray) -> np.ndarray:
 def softmax(values: np.ndarray) -> np.ndarray:
     """Modifications in place."""
     if len(values.shape) == 2:
-        v_max = values.max(axis=1, keepdims=1)  # type: ignore
+        v_max = values.max(axis=1, keepdims=1)
         values -= v_max
         np.exp(values, out=values)
-        s = values.sum(axis=1, keepdims=1)  # type: ignore
+        s = values.sum(axis=1, keepdims=1)
         values /= s
         return values
     v_max = values.max()

onnx/reference/ops/aionnxml/_op_list.py

@@ -2,9 +2,30 @@
 
 # Operator ZipMap is not implemented. Its use should
 # be discouraged. It is just a different way to output
-# probabilites not consumed by any operator.
+# probabilities not consumed by any operator.
 from __future__ import annotations
 
+__all__ = [
+    "load_op",
+    "ArrayFeatureExtractor",
+    "Binarizer",
+    "DictVectorizer",
+    "FeatureVectorizer",
+    "Imputer",
+    "LabelEncoder",
+    "LinearClassifier",
+    "LinearRegressor",
+    "Normalizer",
+    "OneHotEncoder",
+    "Scaler",
+    "SVMClassifier",
+    "SVMRegressor",
+    "TreeEnsemble",
+    "TreeEnsembleClassifier",
+    "TreeEnsembleRegressor",
+    "OpRunAiOnnxMl",
+]
+
 import textwrap
 from typing import Any
 
@@ -45,7 +66,7 @@ def load_op(
 
     Args:
         domain: domain
-        op_type: oprator type
+        op_type: operator type
         version: requested version
         custom: custom implementation (like a function)
 
@@ -56,16 +77,16 @@ def load_op(
     if _registered_operators is None:
         _registered_operators = _build_registered_operators()
     if custom is not None:
-        return lambda *args: OpFunction(*args, impl=custom)  # type: ignore
+        return lambda *args: OpFunction(*args, impl=custom)
     if domain != "ai.onnx.ml":
         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}"
         )
-    impl = _registered_operators[op_type]  # type: ignore
+    impl = _registered_operators[op_type]
     if None not in impl:
         raise RuntimeError(
             f"No default implementation for operator {op_type!r} "
@@ -89,7 +110,7 @@ def load_op(
             )
         cl = impl[best]
     if cl is None:
-        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))  # type: ignore
+        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))
         raise ValueError(
             f"Not registered implementation for operator {op_type!r}, "
             f"domain {domain!r}, and {version!r} in\n{available}"

onnx/reference/ops/aionnxml/op_array_feature_extractor.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
 
 
-def _array_feature_extrator(data, indices):  # type: ignore
+def _array_feature_extrator(data, indices):
     """Implementation of operator *ArrayFeatureExtractor*."""
     if len(indices.shape) == 2 and indices.shape[0] == 1:
         index = indices.ravel().tolist()
@@ -32,7 +32,7 @@ def _array_feature_extrator(data, indices):  # type: ignore
 
 
 class ArrayFeatureExtractor(OpRunAiOnnxMl):
-    def _run(self, data, indices):  # type: ignore
+    def _run(self, data, indices):
         """Runtime for operator *ArrayFeatureExtractor*.
 
         Warning:

onnx/reference/ops/aionnxml/op_binarizer.py

@@ -11,5 +11,5 @@ def compute_binarizer(x, threshold=None):
 
 
 class Binarizer(OpRunAiOnnxMl):
-    def _run(self, x, threshold=None):  # type: ignore
+    def _run(self, x, threshold=None):
         return compute_binarizer(x, threshold)

onnx/reference/ops/aionnxml/op_dict_vectorizer.py

@@ -9,7 +9,7 @@ from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
 
 
 class DictVectorizer(OpRunAiOnnxMl):
-    def _run(self, x, int64_vocabulary=None, string_vocabulary=None):  # type: ignore
+    def _run(self, x, int64_vocabulary=None, string_vocabulary=None):
         if isinstance(x, (np.ndarray, list)):
             if int64_vocabulary is None and string_vocabulary is None:
                 raise ValueError(
@@ -33,7 +33,7 @@ class DictVectorizer(OpRunAiOnnxMl):
             rows = np.array(rows_list)
             cols = np.array(cols_list)
 
-            res = np.zeros((len(x), len(dict_labels)), dtype=values.dtype)  # type: ignore
+            res = np.zeros((len(x), len(dict_labels)), dtype=values.dtype)
             for r, c, v in zip(rows, cols, values):
                 res[r, c] = v
             return (res,)

onnx/reference/ops/aionnxml/op_feature_vectorizer.py

@@ -9,7 +9,7 @@ from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
 
 
 class FeatureVectorizer(OpRunAiOnnxMl):
-    def _preprocess(self, a, cut):  # type: ignore
+    def _preprocess(self, a, cut):
         if len(a.shape) == 1:
             a = a.reshape((-1, 1))
         if len(a.shape) != 2:
@@ -22,9 +22,7 @@ class FeatureVectorizer(OpRunAiOnnxMl):
             return b
         return a
 
-    def _run(self, *args, inputdimensions=None):  # type: ignore
-        args = [  # type: ignore
-            self._preprocess(a, axis) for a, axis in zip(args, inputdimensions)
-        ]
+    def _run(self, *args, inputdimensions=None):
+        args = [self._preprocess(a, axis) for a, axis in zip(args, inputdimensions)]
         res = np.concatenate(args, axis=1)
         return (res,)

onnx/reference/ops/aionnxml/op_imputer.py

@@ -9,7 +9,7 @@ from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
 
 
 class Imputer(OpRunAiOnnxMl):
-    def _run(  # type: ignore
+    def _run(
         self,
         x,
         imputed_value_floats=None,

onnx/reference/ops/aionnxml/op_label_encoder.py

@@ -9,7 +9,7 @@ from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
 
 
 class LabelEncoder(OpRunAiOnnxMl):
-    def _run(  # type: ignore
+    def _run(
         self,
         x,
         default_float=None,

onnx/reference/ops/aionnxml/op_linear_classifier.py

@@ -15,7 +15,7 @@ from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
 
 class LinearClassifier(OpRunAiOnnxMl):
     @staticmethod
-    def _post_process_predicted_label(label, scores, classlabels_ints_string):  # type: ignore
+    def _post_process_predicted_label(label, scores, classlabels_ints_string):
         """Replaces int64 predicted labels by the corresponding
         strings.
         """
@@ -23,7 +23,7 @@ class LinearClassifier(OpRunAiOnnxMl):
             label = np.array([classlabels_ints_string[i] for i in label])
         return label, scores
 
-    def _run(  # type: ignore
+    def _run(
         self,
         x,
         classlabels_ints=None,

onnx/reference/ops/aionnxml/op_linear_regressor.py

@@ -9,7 +9,7 @@ from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
 
 
 class LinearRegressor(OpRunAiOnnxMl):
-    def _run(  # type: ignore
+    def _run(
         self, x, coefficients=None, intercepts=None, targets=1, post_transform=None
     ):
         coefficients = np.array(coefficients).astype(x.dtype)

onnx/reference/ops/aionnxml/op_normalizer.py

@@ -10,26 +10,26 @@ from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
 
 class Normalizer(OpRunAiOnnxMl):
     @staticmethod
-    def norm_max(x):  # type: ignore
+    def norm_max(x):
         """Max normalization"""
         div = np.abs(x).max(axis=1).reshape((x.shape[0], -1))
         return x / np.maximum(div, 1e-30)
 
     @staticmethod
-    def norm_l1(x):  # type: ignore
+    def norm_l1(x):
         """L1 normalization"""
         div = np.abs(x).sum(axis=1).reshape((x.shape[0], -1))
         return x / np.maximum(div, 1e-30)
 
     @staticmethod
-    def norm_l2(x):  # type: ignore
+    def norm_l2(x):
         """L2 normalization"""
         xn = np.square(x).sum(axis=1)
         np.sqrt(xn, out=xn)
         norm = np.maximum(xn.reshape((x.shape[0], -1)), 1e-30)
         return x / norm
 
-    def _run(self, x, norm=None):  # type: ignore
+    def _run(self, x, norm=None):
         if norm == "MAX":
             _norm = Normalizer.norm_max
         elif norm == "L1":

onnx/reference/ops/aionnxml/op_one_hot_encoder.py

@@ -9,7 +9,7 @@ from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
 
 
 class OneHotEncoder(OpRunAiOnnxMl):
-    def _run(self, x, cats_int64s=None, cats_strings=None, zeros=None):  # type: ignore
+    def _run(self, x, cats_int64s=None, cats_strings=None, zeros=None):
         if cats_int64s is not None and len(cats_int64s) > 0:
             classes = {v: i for i, v in enumerate(cats_int64s)}
         elif len(cats_strings) > 0:

onnx/reference/ops/aionnxml/op_scaler.py

@@ -7,6 +7,6 @@ from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
 
 
 class Scaler(OpRunAiOnnxMl):
-    def _run(self, x, offset=None, scale=None):  # type: ignore
+    def _run(self, x, offset=None, scale=None):
         dx = x - offset
         return ((dx * scale).astype(x.dtype),)

onnx/reference/ops/aionnxml/op_svm_classifier.py

@@ -125,7 +125,7 @@ class SVMClassifier(OpRunAiOnnxMl):
         scores = []
         for j in range(class_count_):
             d = self._svm.kernel_dot(X, coefs[j], kernel_type_)
-            score = self._svm.atts.rho[0] + d  # type: ignore
+            score = self._svm.atts.rho[0] + d
             scores.append(score)
         return np.array(scores, dtype=X.dtype)
 
@@ -143,11 +143,11 @@ class SVMClassifier(OpRunAiOnnxMl):
         scores = []
         for i in range(class_count_):
             si_i = starting_vector_[i]
-            class_i_sc = self._svm.atts.vectors_per_class[i]  # type: ignore
+            class_i_sc = self._svm.atts.vectors_per_class[i]
 
             for j in range(i + 1, class_count_):
                 si_j = starting_vector_[j]
-                class_j_sc = self._svm.atts.vectors_per_class[j]  # type: ignore
+                class_j_sc = self._svm.atts.vectors_per_class[j]
 
                 s1 = np.dot(
                     coefs[j - 1, si_i : si_i + class_i_sc],
@@ -158,7 +158,7 @@ class SVMClassifier(OpRunAiOnnxMl):
                     kernels[si_j : si_j + class_j_sc],
                 )
 
-                s = self._svm.atts.rho[evals] + s1 + s2  # type: ignore
+                s = self._svm.atts.rho[evals] + s1 + s2
                 scores.append(s)
                 if s > 0:
                     votes[i] += 1
@@ -175,8 +175,8 @@ class SVMClassifier(OpRunAiOnnxMl):
             for j in range(i + 1, class_count_):
                 val1 = sigmoid_probability(
                     scores[index],
-                    self._svm.atts.prob_a[index],  # type: ignore
-                    self._svm.atts.prob_b[index],  # type: ignore
+                    self._svm.atts.prob_a[index],
+                    self._svm.atts.prob_b[index],
                 )
                 val2 = max(val1, 1.0e-7)
                 val2 = min(val2, (1 - 1.0e-7))
@@ -197,7 +197,7 @@ class SVMClassifier(OpRunAiOnnxMl):
             max_weight = scores[max_class]
 
         write_additional_scores = -1
-        if self._svm.atts.rho.size == 1:  # type: ignore
+        if self._svm.atts.rho.size == 1:
             label, write_additional_scores = set_score_svm(
                 max_weight,
                 max_class,
@@ -216,11 +216,11 @@ class SVMClassifier(OpRunAiOnnxMl):
             scores.size,
             scores,
             self._svm.atts.post_transform,
-            write_additional_scores,  # type: ignore
+            write_additional_scores,
         )
         return label, new_scores
 
-    def _run(  # type: ignore
+    def _run(
         self,
         X,
         classlabels_ints=None,
@@ -252,24 +252,24 @@ class SVMClassifier(OpRunAiOnnxMl):
         vector_count_ = 0
         class_count_ = max(len(classlabels_ints or classlabels_strings or []), 1)
         starting_vector_ = []
-        if svm.atts.vectors_per_class is not None:  # type: ignore
-            for vc in svm.atts.vectors_per_class:  # type: ignore
+        if svm.atts.vectors_per_class is not None:
+            for vc in svm.atts.vectors_per_class:
                 starting_vector_.append(vector_count_)
                 vector_count_ += vc
 
         if vector_count_ > 0:
             # length of each support vector
             mode = "SVM_SVC"
-            sv = svm.atts.support_vectors.reshape((vector_count_, -1))  # type: ignore
-            kernel_type_ = svm.atts.kernel_type  # type: ignore
-            coefs = svm.atts.coefficients.reshape((-1, vector_count_))  # type: ignore
+            sv = svm.atts.support_vectors.reshape((vector_count_, -1))
+            kernel_type_ = svm.atts.kernel_type
+            coefs = svm.atts.coefficients.reshape((-1, vector_count_))
         else:
             # liblinear mode
             mode = "SVM_LINEAR"
             kernel_type_ = "LINEAR"
-            coefs = svm.atts.coefficients.reshape((class_count_, -1))  # type: ignore
+            coefs = svm.atts.coefficients.reshape((class_count_, -1))
 
-        weights_are_all_positive_ = min(svm.atts.coefficients) >= 0  # type: ignore
+        weights_are_all_positive_ = min(svm.atts.coefficients) >= 0
 
         # SVM part
         if vector_count_ == 0 and mode == "SVM_LINEAR":
@@ -298,8 +298,8 @@ class SVMClassifier(OpRunAiOnnxMl):
 
         # proba
         if (
-            svm.atts.prob_a is not None  # type: ignore
-            and len(svm.atts.prob_a) > 0  # type: ignore
+            svm.atts.prob_a is not None
+            and len(svm.atts.prob_a) > 0
             and mode == "SVM_SVC"
         ):
             scores = np.empty((res.shape[0], class_count_), dtype=X.dtype)

onnx/reference/ops/aionnxml/op_svm_helper.py

@@ -30,23 +30,23 @@ class SVMAttributes:
 class SVMCommon:
     """Base class for SVM."""
 
-    def __init__(self, **kwargs):  # type: ignore
+    def __init__(self, **kwargs):
         self.atts = SVMAttributes()
 
         for name, value in kwargs.items():
             self.atts.add(name, value)
 
-        if self.atts.kernel_params:  # type: ignore
-            self.gamma_ = self.atts.kernel_params[0]  # type: ignore
-            self.coef0_ = self.atts.kernel_params[1]  # type: ignore
-            self.degree_ = int(self.atts.kernel_params[2])  # type: ignore
+        if self.atts.kernel_params:
+            self.gamma_ = self.atts.kernel_params[0]
+            self.coef0_ = self.atts.kernel_params[1]
+            self.degree_ = int(self.atts.kernel_params[2])
         else:
             self.gamma_ = 0.0
             self.coef0_ = 0.0
             self.degree_ = 0
 
     def __str__(self) -> str:
-        rows = ["TreeEnsemble", f"root_index={self.root_index}", str(self.atts)]  # type: ignore
+        rows = ["TreeEnsemble", f"root_index={self.root_index}", str(self.atts)]
         return "\n".join(rows)
 
     def kernel_dot(self, pA: np.ndarray, pB: np.ndarray, kernel: str) -> np.ndarray:
@@ -54,25 +54,25 @@ class SVMCommon:
         if k == "poly":
             s = np.dot(pA, pB)
             s = s * self.gamma_ + self.coef0_
-            return s**self.degree_  # type: ignore
+            return s**self.degree_
         if k == "sigmoid":
             s = np.dot(pA, pB)
             s = s * self.gamma_ + self.coef0_
-            return np.tanh(s)  # type: ignore
+            return np.tanh(s)
         if k == "rbf":
             diff = pA - pB
             s = (diff * diff).sum()
-            return np.exp(-self.gamma_ * s)  # type: ignore
+            return np.exp(-self.gamma_ * s)
         if k == "linear":
-            return np.dot(pA, pB)  # type: ignore
+            return np.dot(pA, pB)
         raise ValueError(f"Unexpected kernel={kernel!r}.")
 
     def run_reg(self, X: np.ndarray) -> np.ndarray:
-        if self.atts.n_supports > 0:  # type: ignore
+        if self.atts.n_supports > 0:
             # length of each support vector
             mode_ = "SVM_SVC"
-            kernel_type_ = self.atts.kernel_type  # type: ignore
-            sv = self.atts.support_vectors.reshape((self.atts.n_supports, -1))  # type: ignore
+            kernel_type_ = self.atts.kernel_type
+            sv = self.atts.support_vectors.reshape((self.atts.n_supports, -1))
         else:
             mode_ = "SVM_LINEAR"
             kernel_type_ = "LINEAR"
@@ -82,15 +82,15 @@ class SVMCommon:
             s = 0.0
 
             if mode_ == "SVM_SVC":
-                for j in range(self.atts.n_supports):  # type: ignore
+                for j in range(self.atts.n_supports):
                     d = self.kernel_dot(X[n], sv[j], kernel_type_)
-                    s += self.atts.coefficients[j] * d  # type: ignore
-                s += self.atts.rho[0]  # type: ignore
+                    s += self.atts.coefficients[j] * d
+                s += self.atts.rho[0]
             elif mode_ == "SVM_LINEAR":
-                s = self.kernel_dot(X[n], self.atts.coefficients, kernel_type_)  # type: ignore
-                s += self.atts.rho[0]  # type: ignore
+                s = self.kernel_dot(X[n], self.atts.coefficients, kernel_type_)
+                s += self.atts.rho[0]
 
-            if self.atts.one_class:  # type: ignore
+            if self.atts.one_class:
                 z[n, 0] = 1 if s > 0 else -1
             else:
                 z[n, 0] = s

onnx/reference/ops/aionnxml/op_svm_regressor.py

@@ -10,7 +10,7 @@ from onnx.reference.ops.aionnxml.op_svm_helper import SVMCommon
 class SVMRegressor(OpRunAiOnnxMl):
     """The class only implements `POST_TRANSFORM="NONE"`."""
 
-    def _run(  # type: ignore
+    def _run(
         self,
         X,
         coefficients=None,

onnx/reference/ops/aionnxml/op_tree_ensemble_classifier.py

@@ -16,7 +16,7 @@ from onnx.reference.ops.aionnxml.op_tree_ensemble_helper import TreeEnsemble
 
 
 class TreeEnsembleClassifier(OpRunAiOnnxMl):
-    def _run(  # type: ignore
+    def _run(
         self,
         X,
         base_values=None,
@@ -66,12 +66,12 @@ class TreeEnsembleClassifier(OpRunAiOnnxMl):
         leaves_index = tr.leave_index_tree(X)
         n_classes = max(len(classlabels_int64s or []), len(classlabels_strings or []))
         res = np.empty((leaves_index.shape[0], n_classes), dtype=np.float32)
-        if tr.atts.base_values is None:  # type: ignore
+        if tr.atts.base_values is None:
             res[:, :] = 0
         else:
-            res[:, :] = np.array(tr.atts.base_values).reshape((1, -1))  # type: ignore
+            res[:, :] = np.array(tr.atts.base_values).reshape((1, -1))
 
-        class_index = {}  # type: ignore
+        class_index = {}
         for i, (tid, nid) in enumerate(zip(class_treeids, class_nodeids)):
             if (tid, nid) not in class_index:
                 class_index[tid, nid] = []
@@ -81,7 +81,7 @@ class TreeEnsembleClassifier(OpRunAiOnnxMl):
             t_index = [class_index[nodes_treeids[i], nodes_nodeids[i]] for i in indices]
             for its in t_index:
                 for it in its:
-                    res[i, class_ids[it]] += tr.atts.class_weights[it]  # type: ignore
+                    res[i, class_ids[it]] += tr.atts.class_weights[it]
 
         # post_transform
         binary = len(set(class_ids)) == 1
@@ -105,7 +105,7 @@ class TreeEnsembleClassifier(OpRunAiOnnxMl):
                 res[:, 0] = 1 - res[:, 1]
             else:
                 res[:, 0] = -res[:, 1]
-        new_scores = post_function[post_transform](res)  # type: ignore
+        new_scores = post_function[post_transform](res)
         labels = np.argmax(new_scores, axis=1)
 
         # labels