onnx 1.13.1__cp39-cp39-win_amd64.whl → 1.14.1__cp39-cp39-win_amd64.whl

onnx/reference/ops/aionnxml/_common_classifier.py

@@ -0,0 +1,81 @@
+# SPDX-License-Identifier: Apache-2.0
+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
+
+
+logistic = np.vectorize(compute_logistic)
+
+
+def compute_softmax_zero(values: np.ndarray) -> np.ndarray:
+    """
+    The function modifies the input inplace.
+    """
+    v_max = values.max()
+    exp_neg_v_max = np.exp(-v_max)
+    s = 0
+    for i in range(len(values)):  # pylint: disable=C0200
+        v = values[i]
+        if v > 0.0000001 or v < -0.0000001:
+            values[i] = np.exp(v - v_max)
+        else:
+            values[i] *= exp_neg_v_max
+        s += values[i]
+    if s == 0:
+        values[:] = 0.5
+    else:
+        values[:] /= s
+    return values
+
+
+def softmax_zero(values: np.ndarray) -> np.ndarray:
+    "Modifications in place."
+    if len(values.shape) == 1:
+        compute_softmax_zero(values)
+        return values
+    for row in values:
+        compute_softmax_zero(row)
+    return values
+
+
+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
+        values -= v_max
+        np.exp(values, out=values)
+        s = values.sum(axis=1, keepdims=1)  # type: ignore
+        values /= s
+        return values
+    v_max = values.max()
+    values[:] = np.exp(values - v_max)
+    this_sum = values.sum()
+    values /= this_sum
+    return values
+
+
+def erf_inv(x: float) -> float:
+    sgn = -1.0 if x < 0 else 1.0
+    x = (1.0 - x) * (1 + x)
+    if x == 0:
+        return 0
+    log = np.log(x)
+    v = 2.0 / (3.14159 * 0.147) + 0.5 * log
+    v2 = 1.0 / 0.147 * log
+    v3 = -v + np.sqrt(v * v - v2)
+    x = sgn * np.sqrt(v3)
+    return x
+
+
+def compute_probit(val: float) -> float:
+    return 1.41421356 * erf_inv(val * 2 - 1)
+
+
+probit = np.vectorize(compute_probit)
+
+
+def expit(x: np.ndarray) -> np.ndarray:
+    return (1.0 / (1.0 + np.exp(-x))).astype(x.dtype)

onnx/reference/ops/aionnxml/_op_list.py

@@ -0,0 +1,97 @@
+# SPDX-License-Identifier: Apache-2.0
+# pylint: disable=C0415,R0912,W0611,W0603
+# Operator ZipMap is not implemented. Its use should
+# be discouraged. It is just a different way to output
+# probabilites not consumed by any operator.
+
+import textwrap
+from typing import Any, Dict
+from typing import Optional as TOptional
+from typing import Union
+
+from onnx.reference.op_run import OpFunction
+from onnx.reference.ops._helpers import build_registered_operators_any_domain
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+from onnx.reference.ops.aionnxml.op_array_feature_extractor import ArrayFeatureExtractor
+from onnx.reference.ops.aionnxml.op_binarizer import Binarizer
+from onnx.reference.ops.aionnxml.op_dict_vectorizer import DictVectorizer
+from onnx.reference.ops.aionnxml.op_feature_vectorizer import FeatureVectorizer
+from onnx.reference.ops.aionnxml.op_imputer import Imputer
+from onnx.reference.ops.aionnxml.op_label_encoder import LabelEncoder
+from onnx.reference.ops.aionnxml.op_linear_classifier import LinearClassifier
+from onnx.reference.ops.aionnxml.op_linear_regressor import LinearRegressor
+from onnx.reference.ops.aionnxml.op_normalizer import Normalizer
+from onnx.reference.ops.aionnxml.op_one_hot_encoder import OneHotEncoder
+from onnx.reference.ops.aionnxml.op_scaler import Scaler
+from onnx.reference.ops.aionnxml.op_svm_classifier import SVMClassifier
+from onnx.reference.ops.aionnxml.op_svm_regressor import SVMRegressor
+from onnx.reference.ops.aionnxml.op_tree_ensemble_classifier import (
+    TreeEnsembleClassifier,
+)
+from onnx.reference.ops.aionnxml.op_tree_ensemble_regressor import TreeEnsembleRegressor
+
+
+def _build_registered_operators() -> Dict[str, Dict[Union[int, None], OpRunAiOnnxMl]]:
+    return build_registered_operators_any_domain(globals().copy())  # type: ignore[return-value]
+
+
+def load_op(
+    domain: str, op_type: str, version: Union[None, int], custom: Any = None
+) -> Any:
+    """
+    Loads the implemented for a specified operator.
+
+    :param domain: domain
+    :param op_type: oprator type
+    :param version: requested version
+    :param custom: custom implementation (like a function)
+    :return: class
+    """
+    global _registered_operators
+    if _registered_operators is None:
+        _registered_operators = _build_registered_operators()  # type: ignore[assignment]
+    if custom is not None:
+        return lambda *args: OpFunction(*args, impl=custom)  # type: ignore
+    if domain != "ai.onnx.ml":
+        raise ValueError(f"Domain must be '' not {domain!r}.")
+    if op_type not in _registered_operators:  # type: ignore
+        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))  # type: ignore
+        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
+    if None not in impl:
+        raise RuntimeError(
+            f"No default implementation for operator {op_type!r} "
+            f"and domain {domain!r}, found "
+            f"{', '.join(map(str, impl))}."
+        )
+    if version is None or len(impl) == 1:
+        cl = impl[None]
+    else:
+        best = -1
+        for v in impl:
+            if v is None:
+                continue
+            if best < v <= version:
+                best = v
+        if best == -1:
+            raise RuntimeError(
+                f"No implementation for operator {op_type!r} "
+                f"domain {domain!r} and version {version!r}, found "
+                f"{', '.join(map(str, impl))}."
+            )
+        cl = impl[best]
+    if cl is None:
+        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))  # type: ignore
+        raise ValueError(
+            f"Not registered implementation for operator {op_type!r}, "
+            f"domain {domain!r}, and {version!r} in\n{available}"
+        )
+    return cl
+
+
+# Python 3.7 does not support this annotation for a global variable.
+# _registered_operators: TOptional[Dict[str, Dict[Union[int, None], OpRunAiOnnxMl]]] = None
+_registered_operators = None  # type: ignore

onnx/reference/ops/aionnxml/_op_run_aionnxml.py

@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: Apache-2.0
+# pylint: disable=R0913,W0221
+
+from onnx.reference.op_run import OpRun
+
+
+class OpRunAiOnnxMl(OpRun):
+    op_domain = "ai.onnx.ml"

onnx/reference/ops/aionnxml/op_array_feature_extractor.py

@@ -0,0 +1,50 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+# pylint: disable=R0913,R0914,W0221
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+
+def _array_feature_extrator(data, indices):  # type: ignore
+    """
+    Implementation of operator *ArrayFeatureExtractor*.
+    """
+    if len(indices.shape) == 2 and indices.shape[0] == 1:
+        index = indices.ravel().tolist()
+        add = len(index)
+    elif len(indices.shape) == 1:
+        index = indices.tolist()
+        add = len(index)
+    else:
+        add = 1
+        for s in indices.shape:
+            add *= s
+        index = indices.ravel().tolist()
+    if len(data.shape) == 1:
+        new_shape = (1, add)
+    else:
+        new_shape = [*data.shape[:-1], add]
+    try:
+        tem = data[..., index]
+    except IndexError as e:
+        raise RuntimeError(f"data.shape={data.shape}, indices={indices}") from e
+    res = tem.reshape(new_shape)
+    return res
+
+
+class ArrayFeatureExtractor(OpRunAiOnnxMl):
+    def _run(self, data, indices):  # type: ignore
+        """
+        Runtime for operator *ArrayFeatureExtractor*.
+        .. warning::
+            ONNX specifications may be imprecise in some cases.
+            When the input data is a vector (one dimension),
+            the output has still two like a matrix with one row.
+            The implementation follows what onnxruntime does in
+            `array_feature_extractor.cc
+            <https://github.com/microsoft/onnxruntime/blob/main/
+            onnxruntime/core/providers/cpu/ml/array_feature_extractor.cc#L84>`_.
+        """
+        res = _array_feature_extrator(data, indices)
+        return (res,)

onnx/reference/ops/aionnxml/op_binarizer.py

@@ -0,0 +1,15 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+# pylint: disable=R0913,R0914,W0221
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+
+def compute_binarizer(x, threshold=None):
+    return ((x > threshold).astype(x.dtype),)
+
+
+class Binarizer(OpRunAiOnnxMl):
+    def _run(self, x, threshold=None):  # type: ignore
+        return compute_binarizer(x, threshold)

onnx/reference/ops/aionnxml/op_dict_vectorizer.py

@@ -0,0 +1,56 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+# pylint: disable=R0913,R0914,W0221
+
+import numpy as np
+
+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
+        if isinstance(x, (np.ndarray, list)):
+            dict_labels = {}
+            if int64_vocabulary:
+                for i, v in enumerate(int64_vocabulary):
+                    dict_labels[v] = i
+            else:
+                for i, v in enumerate(string_vocabulary):
+                    dict_labels[v] = i
+            if len(dict_labels) == 0:
+                raise RuntimeError(
+                    "int64_vocabulary and string_vocabulary cannot be both empty."
+                )
+
+            values_list = []
+            rows_list = []
+            cols_list = []
+            for i, row in enumerate(x):
+                for k, v in row.items():
+                    values_list.append(v)
+                    rows_list.append(i)
+                    cols_list.append(dict_labels[k])
+            values = np.array(values_list)
+            rows = np.array(rows_list)
+            cols = np.array(cols_list)
+
+            res = np.zeros((len(x), len(dict_labels)), dtype=values.dtype)  # type: ignore
+            for r, c, v in zip(rows, cols, values):
+                res[r, c] = v
+            return (res,)
+
+            # return (
+            #     coo_matrix(
+            #         (values, (rows, cols)), shape=(len(x), len(dict_labels))
+            #     ).todense(),
+            # )
+
+        if isinstance(x, dict):
+            keys = int64_vocabulary or string_vocabulary
+            result = []
+            for k in keys:
+                result.append(x.get(k, 0))
+            return (np.array(result),)
+
+        raise TypeError(f"x must be iterable not {type(x)}.")

onnx/reference/ops/aionnxml/op_feature_vectorizer.py

@@ -0,0 +1,30 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+# pylint: disable=R0913,R0914,W0221
+
+import numpy as np
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+
+class FeatureVectorizer(OpRunAiOnnxMl):
+    def _preprocess(self, a, cut):  # type: ignore
+        if len(a.shape) == 1:
+            a = a.reshape((-1, 1))
+        if len(a.shape) != 2:
+            raise ValueError(f"Every input must have 1 or 2 dimensions not {a.shape}.")
+        if cut < a.shape[1]:
+            return a[:, :cut]
+        if cut > a.shape[1]:
+            b = np.zeros((a.shape[0], cut), dtype=a.dtype)
+            b[:, : a.shape[1]] = a
+            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)
+        ]
+        res = np.concatenate(args, axis=1)
+        return (res,)

onnx/reference/ops/aionnxml/op_imputer.py

@@ -0,0 +1,47 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+# pylint: disable=R0913,R0914,W0221
+
+import numpy as np
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+
+class Imputer(OpRunAiOnnxMl):
+    def _run(  # type: ignore
+        self,
+        x,
+        imputed_value_floats=None,
+        imputed_value_int64s=None,
+        replaced_value_float=None,
+        replaced_value_int64=None,
+    ):
+        if imputed_value_floats is not None and len(imputed_value_floats) > 0:
+            values = imputed_value_floats
+            replace = replaced_value_float
+        elif imputed_value_int64s is not None and len(imputed_value_int64s) > 0:
+            values = imputed_value_int64s
+            replace = replaced_value_int64
+        else:
+            raise ValueError("Missing are not defined.")
+
+        if isinstance(values, list):
+            values = np.array(values)
+        if len(x.shape) != 2:
+            raise TypeError(f"x must be a matrix but shape is {x.shape}")
+        if values.shape[0] not in (x.shape[1], 1):
+            raise TypeError(  # pragma: no cover
+                f"Dimension mismatch {values.shape[0]} != {x.shape[1]}"
+            )
+        x = x.copy()
+        if np.isnan(replace):
+            for i in range(0, x.shape[1]):
+                val = values[min(i, values.shape[0] - 1)]
+                x[np.isnan(x[:, i]), i] = val
+        else:
+            for i in range(0, x.shape[1]):
+                val = values[min(i, values.shape[0] - 1)]
+                x[x[:, i] == replace, i] = val
+
+        return (x,)

onnx/reference/ops/aionnxml/op_label_encoder.py

@@ -0,0 +1,52 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+# pylint: disable=R0913,R0914,W0221
+
+import numpy as np
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+
+class LabelEncoder(OpRunAiOnnxMl):
+    def _run(  # type: ignore
+        self,
+        x,
+        default_float=None,
+        default_int64=None,
+        default_string=None,
+        keys_floats=None,
+        keys_int64s=None,
+        keys_strings=None,
+        values_floats=None,
+        values_int64s=None,
+        values_strings=None,
+    ):
+        keys = keys_floats or keys_int64s or keys_strings
+        values = values_floats or values_int64s or values_strings
+        classes = dict(zip(keys, values))
+        if id(keys) == id(keys_floats):
+            cast = float
+        elif id(keys) == id(keys_int64s):
+            cast = int  # type: ignore
+        else:
+            cast = str  # type: ignore
+        if id(values) == id(values_floats):
+            defval = default_float
+            dtype = np.float32
+        elif id(values) == id(values_int64s):
+            defval = default_int64
+            dtype = np.int64  # type: ignore
+        else:
+            defval = default_string
+            if not isinstance(defval, str):
+                defval = ""
+            dtype = np.str_  # type: ignore
+        shape = x.shape
+        if len(x.shape) > 1:
+            x = x.flatten()
+        res = []
+        for i in range(0, x.shape[0]):
+            v = classes.get(cast(x[i]), defval)
+            res.append(v)
+        return (np.array(res, dtype=dtype).reshape(shape),)

onnx/reference/ops/aionnxml/op_linear_classifier.py

@@ -0,0 +1,99 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+# pylint: disable=R0912,R0913,R0914,W0221
+
+import numpy as np
+
+from onnx.reference.ops.aionnxml._common_classifier import (
+    compute_probit,
+    compute_softmax_zero,
+    expit,
+)
+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
+        """
+        Replaces int64 predicted labels by the corresponding
+        strings.
+        """
+        if classlabels_ints_string is not None:
+            label = np.array([classlabels_ints_string[i] for i in label])
+        return label, scores
+
+    def _run(  # type: ignore
+        self,
+        x,
+        classlabels_ints=None,
+        classlabels_strings=None,
+        coefficients=None,
+        intercepts=None,
+        multi_class=None,  # pylint: disable=W0613
+        post_transform=None,
+    ):
+        # multi_class is unused
+        dtype = x.dtype
+        if dtype != np.float64:
+            x = x.astype(np.float32)
+        coefficients = np.array(coefficients).astype(x.dtype)
+        intercepts = np.array(intercepts).astype(x.dtype)
+        coefficients = coefficients.reshape((-1, x.shape[1])).T
+        scores = np.dot(x, coefficients)
+        if intercepts is not None:
+            scores += intercepts
+
+        n_classes = max(len(classlabels_ints or []), len(classlabels_strings or []))
+        if coefficients.shape[1] == 1 and n_classes == 2:
+            new_scores = np.empty((scores.shape[0], 2), dtype=np.float32)
+            new_scores[:, 0] = -scores[:, 0]
+            new_scores[:, 1] = scores[:, 0]
+            scores = new_scores
+
+        if post_transform == "NONE":
+            pass
+        elif post_transform == "LOGISTIC":
+            scores = expit(scores)
+        elif post_transform == "SOFTMAX":
+            np.subtract(
+                scores,
+                scores.max(axis=1, keepdims=1),  # pylint: disable=E1123
+                out=scores,
+            )
+            scores = np.exp(scores)
+            scores = np.divide(scores, scores.sum(axis=1, keepdims=1))
+        elif post_transform == "SOFTMAX_ZERO":
+            for i in range(scores.shape[0]):
+                scores[i, :] = compute_softmax_zero(scores[i, :])
+        elif post_transform == "PROBIT":
+            for i in range(scores.shape[0]):
+                for j in range(scores.shape[1]):
+                    scores[i, j] = compute_probit(scores[i, j])
+        else:
+            raise NotImplementedError("Unknown post_transform: '{post_transform}'.")
+
+        if scores.shape[1] > 1:
+            labels = np.argmax(scores, axis=1)
+            if classlabels_ints is not None:
+                labels = np.array([classlabels_ints[i] for i in labels], dtype=np.int64)
+            elif classlabels_strings is not None:
+                labels = np.array([classlabels_strings[i] for i in labels])
+        else:
+            threshold = 0 if post_transform == "NONE" else 0.5
+            if classlabels_ints is not None:
+                labels = (
+                    np.where(scores >= threshold, classlabels_ints[0], 0)
+                    .astype(np.int64)
+                    .ravel()
+                )
+            elif classlabels_strings is not None:
+                labels = (
+                    np.where(scores >= threshold, classlabels_strings[0], "")
+                    .astype(np.int64)
+                    .ravel()
+                )
+            else:
+                labels = (scores >= threshold).astype(np.int64).ravel()
+        return (labels, scores)

onnx/reference/ops/aionnxml/op_linear_regressor.py

@@ -0,0 +1,26 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+# pylint: disable=R0913,R0914,W0221
+
+import numpy as np
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+
+class LinearRegressor(OpRunAiOnnxMl):
+    def _run(  # type: ignore
+        self, x, coefficients=None, intercepts=None, targets=1, post_transform=None
+    ):
+        coefficients = np.array(coefficients).astype(x.dtype)
+        intercepts = np.array(intercepts).astype(x.dtype)
+        n = coefficients.shape[0] // targets
+        coefficients = coefficients.reshape(targets, n).T
+        score = np.dot(x, coefficients)
+        if intercepts is not None:
+            score += intercepts
+        if post_transform == "NONE":
+            return (score,)
+        raise NotImplementedError(
+            f"post_transform: {post_transform!r} is not implemented."
+        )

onnx/reference/ops/aionnxml/op_normalizer.py

@@ -0,0 +1,41 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+# pylint: disable=R0913,R0914,W0221
+
+import numpy as np
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+
+class Normalizer(OpRunAiOnnxMl):
+    @staticmethod
+    def norm_max(x):  # type: ignore
+        "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
+        "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
+        "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
+        if norm == "MAX":
+            _norm = Normalizer.norm_max
+        elif norm == "L1":
+            _norm = Normalizer.norm_l1
+        elif norm == "L2":
+            _norm = Normalizer.norm_l2
+        else:
+            raise ValueError(f"Unexpected value for norm='{norm}'.")
+        return (_norm(x),)

onnx/reference/ops/aionnxml/op_one_hot_encoder.py

@@ -0,0 +1,55 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+# pylint: disable=R0912,R0913,R0914,W0221
+
+import numpy as np
+
+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
+        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:
+            classes = {v: i for i, v in enumerate(cats_strings)}
+        else:
+            raise RuntimeError("No encoding was defined.")
+
+        shape = x.shape
+        new_shape = (*shape, len(classes))
+        res = np.zeros(new_shape, dtype=np.float32)
+        if len(x.shape) == 1:
+            for i, v in enumerate(x):
+                j = classes.get(v, -1)
+                if j >= 0:
+                    res[i, j] = 1.0
+        elif len(x.shape) == 2:
+            for a, row in enumerate(x):
+                for i, v in enumerate(row):
+                    j = classes.get(v, -1)
+                    if j >= 0:
+                        res[a, i, j] = 1.0
+        else:
+            raise RuntimeError(
+                f"This operator is not implemented " f"for " f"shape {x.shape}."
+            )
+
+        if not zeros:
+            red = res.sum(axis=len(res.shape) - 1)
+            if np.min(red) == 0:
+                rows = []
+                for i, val in enumerate(red):
+                    if val == 0:
+                        rows.append(dict(row=i, value=x[i]))
+                        if len(rows) > 5:
+                            break
+                msg = "\n".join(str(_) for _ in rows)
+                raise RuntimeError(
+                    f"One observation did not have any defined category.\n"
+                    f"classes: {classes}\nfirst rows:\n"
+                    f"{msg}\nres:\n{res[:5]}\nx:\n{x[:5]}"
+                )
+
+        return (res,)

onnx/reference/ops/aionnxml/op_scaler.py

@@ -0,0 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+# pylint: disable=R0913,R0914,W0221
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+
+class Scaler(OpRunAiOnnxMl):
+    def _run(self, x, offset=None, scale=None):  # type: ignore
+        dx = x - offset
+        return ((dx * scale).astype(x.dtype),)