onnx 1.15.0__cp311-cp311-win_amd64.whl → 1.16.1__cp311-cp311-win_amd64.whl

onnx/reference/ops/_op.py

@@ -11,18 +11,14 @@ from onnx.reference.op_run import OpRun, RuntimeTypeError
 
 
 class OpRunUnary(OpRun):
-    """
-    Ancestor to all unary operators in this subfolder.
+    """Ancestor to all unary operators in this subfolder.
+
     Checks that input and output types are the same.
     """
 
-    def __init__(self, onnx_node: NodeProto, run_params: Dict[str, Any]):
-        OpRun.__init__(self, onnx_node, run_params)
-
     def run(self, x):  # type: ignore
-        """
-        Calls method ``_run``, catches exceptions,
-        displays a longer error message.
+        """Calls method ``_run``, catches exceptions, displays a longer error message.
+
         Supports only unary operators.
         """
         self._log("-- begin %s.run(1 input)", self.__class__.__name__)
@@ -34,23 +30,19 @@ class OpRunUnary(OpRun):
                 f"(unary operator {self.__class__.__name__!r})."
             ) from e
         self._log("-- done %s.run -> %d outputs", self.__class__.__name__, len(res))
-        return res
+        return self._check_and_fix_outputs(res)
 
 
 class OpRunUnaryNum(OpRunUnary):
-    """
-    Ancestor to all unary and numerical operators
-    in this subfolder. Checks that input and output types
-    are the same.
-    """
+    """Ancestor to all unary and numerical operators in this subfolder.
 
-    def __init__(self, onnx_node: NodeProto, run_params: Dict[str, Any]):
-        OpRunUnary.__init__(self, onnx_node, run_params)
+    Checks that input and output types are the same.
+    """
 
     def run(self, x):  # type: ignore
-        """
-        Calls method ``OpRunUnary.run``, catches exceptions,
-        displays a longer error message.
+        """Calls method ``OpRunUnary.run``.
+
+        Catches exceptions, displays a longer error message.
         Checks that the result is not empty.
         """
         res = OpRunUnary.run(self, x)
@@ -61,22 +53,18 @@ class OpRunUnaryNum(OpRunUnary):
                 f"Output type mismatch: input '{x.dtype}' != output '{res[0].dtype}' "
                 f"(operator {self.__class__.__name__!r})."
             )
-        return res
+        return self._check_and_fix_outputs(res)
 
 
 class OpRunBinary(OpRun):
-    """
-    Ancestor to all binary operators in this subfolder.
+    """Ancestor to all binary operators in this subfolder.
+
     Checks that input and output types are the same.
     """
 
-    def __init__(self, onnx_node: NodeProto, run_params: Dict[str, Any]):
-        OpRun.__init__(self, onnx_node, run_params)
-
     def run(self, x, y):  # type: ignore
-        """
-        Calls method ``_run``, catches exceptions,
-        displays a longer error message.
+        """Calls method ``_run``, catches exceptions, displays a longer error message.
+
         Supports only binary operators.
         """
         self._log("-- begin %s.run(2 inputs)", self.__class__.__name__)
@@ -98,33 +86,23 @@ class OpRunBinary(OpRun):
                 f"(binary operator {self.__class__.__name__!r})."
             ) from e
         self._log("-- done %s.run -> %d outputs", self.__class__.__name__, len(res))
-        return res
+        return self._check_and_fix_outputs(res)
 
 
 class OpRunBinaryComparison(OpRunBinary):
-    """
-    Ancestor to all binary operators in this subfolder
-    comparing tensors.
-    """
+    """Ancestor to all binary operators in this subfolder comparing tensors."""
 
-    def __init__(self, onnx_node: NodeProto, run_params: Dict[str, Any]):
-        OpRunBinary.__init__(self, onnx_node, run_params)
+    pass
 
 
 class OpRunBinaryNum(OpRunBinary):
-    """
-    Ancestor to all binary operators in this subfolder.
+    """Ancestor to all binary operators in this subfolder.
+
     Checks that input oud output types are the same.
     """
 
-    def __init__(self, onnx_node: NodeProto, run_params: Dict[str, Any]):
-        OpRunBinary.__init__(self, onnx_node, run_params)
-
     def run(self, x, y):  # type: ignore
-        """
-        Calls method ``OpRunBinary.run``, catches exceptions,
-        displays a longer error message.
-        """
+        """Calls method ``OpRunBinary.run``, catches exceptions, displays a longer error message."""
         res = OpRunBinary.run(self, x, y)
         if res[0].dtype != x.dtype:
             raise RuntimeTypeError(
@@ -132,12 +110,11 @@ class OpRunBinaryNum(OpRunBinary):
                 f"(operator {self.__class__.__name__!r})"
                 f" type(x)={type(x)} type(y)={type(y)}"
             )
-        return res
+        return self._check_and_fix_outputs(res)
 
 
 class OpRunBinaryNumpy(OpRunBinaryNum):
-    """
-    *numpy_fct* is a binary numpy function which
+    """*numpy_fct* is a binary numpy function which
     takes two matrices.
     """
 
@@ -148,12 +125,12 @@ class OpRunBinaryNumpy(OpRunBinaryNum):
         self.numpy_fct = numpy_fct
 
     def _run(self, a, b):  # type: ignore
-        return (self.numpy_fct(a, b),)
+        res = (self.numpy_fct(a, b),)
+        return self._check_and_fix_outputs(res)
 
 
 class OpRunReduceNumpy(OpRun):  # type: ignore
-    """
-    Implements the reduce logic.
+    """Implements the reduce logic.
     It must have a parameter *axes*.
     """
 

onnx/reference/ops/_op_list.py

@@ -1,9 +1,8 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
-
-"""
-Every class imported in this module defines an implementation of
+# pylint: disable=C0415,R0912,R0913,R0914,R0915,W0611,W0603
+"""Every class imported in this module defines an implementation of
 an operator of the main domain. Any class name uses `_` to specify a
 version defined in a specific opset. The class name without `_`
 defines the current implementation. If an operator has no class
@@ -83,7 +82,10 @@ from onnx.reference.ops.op_cosh import Cosh
 from onnx.reference.ops.op_cum_sum import CumSum
 from onnx.reference.ops.op_deform_conv import DeformConv
 from onnx.reference.ops.op_depth_to_space import DepthToSpace
-from onnx.reference.ops.op_dequantize_linear import DequantizeLinear
+from onnx.reference.ops.op_dequantize_linear import (
+    DequantizeLinear_19,
+    DequantizeLinear_21,
+)
 from onnx.reference.ops.op_det import Det
 from onnx.reference.ops.op_dft import DFT_17, DFT_20
 from onnx.reference.ops.op_div import Div
@@ -154,7 +156,11 @@ from onnx.reference.ops.op_pow import Pow
 from onnx.reference.ops.op_prelu import PRelu
 from onnx.reference.ops.op_qlinear_conv import QLinearConv
 from onnx.reference.ops.op_qlinear_matmul import QLinearMatMul
-from onnx.reference.ops.op_quantize_linear import QuantizeLinear_10, QuantizeLinear_19
+from onnx.reference.ops.op_quantize_linear import (
+    QuantizeLinear_10,
+    QuantizeLinear_19,
+    QuantizeLinear_21,
+)
 from onnx.reference.ops.op_random_normal import RandomNormal
 from onnx.reference.ops.op_random_normal_like import RandomNormalLike
 from onnx.reference.ops.op_random_uniform import RandomUniform
@@ -246,21 +252,25 @@ def load_op(
     node: Union[None, NodeProto] = None,
     input_types: Union[None, List[TypeProto]] = None,
     expand: bool = False,
+    evaluator_cls: TOptional[type] = None,
 ) -> Any:
-    """
-    Loads the implemented for a specified operator.
+    """Loads the implemented for a specified operator.
+
+    Args:
+        domain: domain
+        op_type: oprator type
+        version: requested version
+        custom: custom implementation (like a function)
+        node: used if no implementation was found and the operator
+            defines a function which is context dependant
+        input_types: used if no implementation was found and the
+            operator defines a function which is context dependant
+        expand: use the function implemented in the schema instead of
+            its reference implementation
+        evaluator_cls: evaluator to use
 
-    :param domain: domain
-    :param op_type: oprator type
-    :param version: requested version
-    :param custom: custom implementation (like a function)
-    :param node: used if no implementation was found and the operator defines a function
-        which is context dependant
-    :param input_types: used if no implementation was found and the operator defines a function
-        which is context dependant
-    :param expand: use the function implemented in the schema instead
-        of its reference implementation
-    :return: class
+    Returns:
+        class
     """
     global _registered_operators  # noqa: PLW0603
     schema = None
@@ -284,10 +294,11 @@ def load_op(
                 f"and domain {domain!r}. Did you recompile the sources after updating the repository?"
             ) from None
         if schema.has_function:  # type: ignore
-            from onnx.reference import ReferenceEvaluator
-
             body = schema.function_body  # type: ignore
-            sess = ReferenceEvaluator(body)
+            assert (
+                evaluator_cls is not None
+            ), f"evaluator_cls must be specified to implement operator {op_type!r} from domain {domain!r}"
+            sess = evaluator_cls(body)
             return lambda *args, sess=sess: OpFunction(*args, impl=sess)  # type: ignore
         if schema.has_context_dependent_function:  # type: ignore
             if node is None or input_types is None:
@@ -296,14 +307,15 @@ def load_op(
                     f"and domain {domain!r}, the operator has a context dependent function. "
                     f"but argument node or input_types is not defined (input_types={input_types})."
                 )
-            from onnx.reference import ReferenceEvaluator
-
             body = schema.get_context_dependent_function(  # type: ignore
                 node.SerializeToString(), [it.SerializeToString() for it in input_types]
             )
             proto = FunctionProto()
             proto.ParseFromString(body)
-            sess = ReferenceEvaluator(proto)
+            assert (
+                evaluator_cls is not None
+            ), f"evaluator_cls must be specified to evaluate function {proto.name!r}"
+            sess = evaluator_cls(proto)
             return lambda *args, sess=sess: OpFunction(*args, impl=sess)  # type: ignore
         found = False
     if not found:

onnx/reference/ops/aionnx_preview_training/_op_list.py

@@ -21,16 +21,23 @@ def _build_registered_operators() -> Dict[str, Dict[Union[int, None], OpRunTrain
 
 
 def load_op(
-    domain: str, op_type: str, version: Union[None, int], custom: Any = None
+    domain: str,
+    op_type: str,
+    version: Union[None, int],
+    custom: Any = None,
+    evaluator_cls: TOptional[type] = None,
 ) -> Any:
-    """
-    Loads the implemented for a specified operator.
+    """Loads the implemented for a specified operator.
+
+    Args:
+        domain: domain
+        op_type: oprator type
+        version: requested version
+        custom: custom implementation (like a function)
+        evaluator_cls: unused
 
-    :param domain: domain
-    :param op_type: oprator type
-    :param version: requested version
-    :param custom: custom implementation (like a function)
-    :return: class
+    Returns:
+        class
     """
     global _registered_operators  # noqa: PLW0603
     if _registered_operators is None:

onnx/reference/ops/aionnxml/_common_classifier.py

@@ -12,9 +12,7 @@ logistic = np.vectorize(compute_logistic)
 
 
 def compute_softmax_zero(values: np.ndarray) -> np.ndarray:
-    """
-    The function modifies the input inplace.
-    """
+    """The function modifies the input inplace."""
     v_max = values.max()
     exp_neg_v_max = np.exp(-v_max)
     s = 0
@@ -33,7 +31,7 @@ def compute_softmax_zero(values: np.ndarray) -> np.ndarray:
 
 
 def softmax_zero(values: np.ndarray) -> np.ndarray:
-    "Modifications in place."
+    """Modifications in place."""
     if len(values.shape) == 1:
         compute_softmax_zero(values)
         return values
@@ -43,7 +41,7 @@ def softmax_zero(values: np.ndarray) -> np.ndarray:
 
 
 def softmax(values: np.ndarray) -> np.ndarray:
-    "Modifications in place."
+    """Modifications in place."""
     if len(values.shape) == 2:
         v_max = values.max(axis=1, keepdims=1)  # type: ignore
         values -= v_max

onnx/reference/ops/aionnxml/_op_list.py

@@ -25,6 +25,7 @@ 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 import TreeEnsemble
 from onnx.reference.ops.aionnxml.op_tree_ensemble_classifier import (
     TreeEnsembleClassifier,
 )
@@ -36,16 +37,23 @@ def _build_registered_operators() -> Dict[str, Dict[Union[int, None], OpRunAiOnn
 
 
 def load_op(
-    domain: str, op_type: str, version: Union[None, int], custom: Any = None
+    domain: str,
+    op_type: str,
+    version: Union[None, int],
+    custom: Any = None,
+    evaluator_cls: TOptional[type] = None,
 ) -> Any:
-    """
-    Loads the implemented for a specified operator.
+    """Loads the implemented for a specified operator.
+
+    Args:
+        domain: domain
+        op_type: oprator type
+        version: requested version
+        custom: custom implementation (like a function)
+        evaluator_cls: unused
 
-    :param domain: domain
-    :param op_type: oprator type
-    :param version: requested version
-    :param custom: custom implementation (like a function)
-    :return: class
+    Returns:
+        class
     """
     global _registered_operators  # noqa: PLW0603
     if _registered_operators is None:

onnx/reference/ops/aionnxml/op_array_feature_extractor.py

@@ -7,9 +7,7 @@ from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
 
 
 def _array_feature_extrator(data, indices):  # type: ignore
-    """
-    Implementation of operator *ArrayFeatureExtractor*.
-    """
+    """Implementation of operator *ArrayFeatureExtractor*."""
     if len(indices.shape) == 2 and indices.shape[0] == 1:
         index = indices.ravel().tolist()
         add = len(index)
@@ -35,9 +33,9 @@ def _array_feature_extrator(data, indices):  # type: ignore
 
 class ArrayFeatureExtractor(OpRunAiOnnxMl):
     def _run(self, data, indices):  # type: ignore
-        """
-        Runtime for operator *ArrayFeatureExtractor*.
-        .. warning::
+        """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.

onnx/reference/ops/aionnxml/op_linear_classifier.py

@@ -16,8 +16,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
-        """
-        Replaces int64 predicted labels by the corresponding
+        """Replaces int64 predicted labels by the corresponding
         strings.
         """
         if classlabels_ints_string is not None:

onnx/reference/ops/aionnxml/op_normalizer.py

@@ -11,19 +11,19 @@ from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
 class Normalizer(OpRunAiOnnxMl):
     @staticmethod
     def norm_max(x):  # type: ignore
-        "max normalization"
+        """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"
+        """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"
+        """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)

onnx/reference/ops/aionnxml/op_svm_helper.py

@@ -28,9 +28,7 @@ class SVMAttributes:
 
 
 class SVMCommon:
-    """
-    Base class for SVM.
-    """
+    """Base class for SVM."""
 
     def __init__(self, **kwargs):  # type: ignore
         self.atts = SVMAttributes()

onnx/reference/ops/aionnxml/op_svm_regressor.py

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