onnx 1.13.1__cp311-cp311-win_amd64.whl → 1.14.1__cp311-cp311-win_amd64.whl

onnx/reference/ops/op_max_pool.py

@@ -1,9 +1,11 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=C0200,R0912,R0913,R0914,R0915,R0916,R1702,W0221
 
 import numpy as np
 
-from ._op_common_pool import CommonPool
+from onnx.reference.ops._op_common_pool import CommonPool
 
 
 class MaxPool(CommonPool):

onnx/reference/ops/op_max_unpool.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=C0200,R0913,R0914,W0221
 

onnx/reference/ops/op_mean.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -9,4 +11,4 @@ class Mean(OpRun):
         res = args[0].copy()
         for m in args[1:]:
             res += m
-        return (res / len(args),)
+        return ((res / len(args)).astype(args[0].dtype),)

onnx/reference/ops/op_mel_weight_matrix.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0913,R0914,W0221
 

onnx/reference/ops/op_min.py

@@ -1,9 +1,11 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
 import numpy as np
 
-from ._op import OpRunBinaryNumpy
+from onnx.reference.ops._op import OpRunBinaryNumpy
 
 
 class Min(OpRunBinaryNumpy):

onnx/reference/ops/op_mod.py

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

onnx/reference/ops/op_mul.py

@@ -1,9 +1,11 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
 import numpy as np
 
-from ._op import OpRunBinaryNumpy
+from onnx.reference.ops._op import OpRunBinaryNumpy
 
 
 class Mul(OpRunBinaryNumpy):

onnx/reference/ops/op_neg.py

@@ -1,9 +1,11 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
 import numpy as np
 
-from ._op import OpRunUnaryNum
+from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Neg(OpRunUnaryNum):

onnx/reference/ops/op_negative_log_likelihood_loss.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0912,R0913,W0221
 
@@ -66,7 +68,7 @@ def _compute_negative_log_likelihood_loss(x, target, weight=None, reduction="mea
         loss = np.mean(loss)
     elif reduction == "sum":
         loss = np.sum(loss)
-    return (loss,)
+    return (loss.astype(x.dtype),)
 
 
 class NegativeLogLikelihoodLoss(OpRun):

onnx/reference/ops/op_non_max_suppression.py

@@ -1,25 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0902,R0911,R0912,R0913,R0914,W0221
 
-from typing import Tuple
+import dataclasses
+from typing import Optional, Tuple
 
 import numpy as np
 
 from onnx.reference.op_run import OpRun
 
 
+@dataclasses.dataclass
 class PrepareContext:
-    def __init__(self) -> None:
-        self.boxes_data_ = None
-        self.boxes_size_ = 0
-        self.scores_data_ = None
-        self.scores_size_ = 0
-        self.max_output_boxes_per_class_ = None
-        self.score_threshold_ = None
-        self.iou_threshold_ = None
-        self.num_batches_ = 0
-        self.num_classes_ = 0
-        self.num_boxes_ = 0
+    boxes_data_: Optional[np.ndarray] = None
+    boxes_size_: int = 0
+    scores_data_: Optional[np.ndarray] = None
+    scores_size_: int = 0
+    max_output_boxes_per_class_: Optional[np.ndarray] = None
+    score_threshold_: Optional[np.ndarray] = None
+    iou_threshold_: Optional[np.ndarray] = None
+    num_batches_: int = 0
+    num_classes_: int = 0
+    num_boxes_: int = 0
 
 
 class SelectedIndex:
@@ -39,7 +42,7 @@ def max_min(lhs: float, rhs: float) -> Tuple[float, float]:
     return lhs, rhs
 
 
-def SuppressByIOU(
+def suppress_by_iou(
     boxes_data: np.ndarray,
     box_index1: int,
     box_index2: int,
@@ -49,7 +52,7 @@ def SuppressByIOU(
     box1 = boxes_data[box_index1]
     box2 = boxes_data[box_index2]
     # center_point_box_ only support 0 or 1
-    if 0 == center_point_box:
+    if center_point_box == 0:
         # boxes data format [y1, x1, y2, x2]
         x1_min, x1_max = max_min(box1[1], box1[3])
         x2_min, x2_max = max_min(box2[1], box2[3])
@@ -175,10 +178,10 @@ class NonMaxSuppression(OpRun):
         self,
         boxes,
         scores,
-        max_output_boxes_per_class=None,
-        iou_threshold=None,
-        score_threshold=None,
-        center_point_box=None,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+        center_point_box,
     ):
         center_point_box = center_point_box or self.center_point_box  # type: ignore
 
@@ -245,7 +248,7 @@ class NonMaxSuppression(OpRun):
                     # Check with existing selected boxes for this class,
                     # suppress if exceed the IOU (Intersection Over Union) threshold.
                     for selected_index in selected_boxes_inside_class:
-                        if SuppressByIOU(
+                        if suppress_by_iou(
                             batch_boxes,
                             next_top_score.idx_,
                             selected_index.idx_,

onnx/reference/ops/op_non_zero.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -8,5 +10,6 @@ from onnx.reference.op_run import OpRun
 
 class NonZero(OpRun):
     def _run(self, x):  # type: ignore
-        res = np.vstack(np.nonzero(x))
+        # Specify np.int64 for Windows x86 machines
+        res = np.vstack(np.nonzero(x)).astype(np.int64)
         return (res,)

onnx/reference/ops/op_not.py

@@ -1,9 +1,11 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
 import numpy as np
 
-from ._op import OpRunUnary
+from onnx.reference.ops._op import OpRunUnary
 
 
 class Not(OpRunUnary):

onnx/reference/ops/op_one_hot.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -16,7 +18,7 @@ def _one_hot(indices, depth, axis=-1, dtype=np.float32):  # type: ignore
     rs = values.shape[axis:rank]
     new_shape = (1,) * len(ls) + depth_range.shape + (1,) * len(rs)
     targets = np.reshape(depth_range, new_shape)
-    values = np.reshape(np.mod(values, depth), ls + (1,) + rs)
+    values = np.reshape(np.mod(values, depth), (*ls, 1, *rs))
     return np.asarray(targets == values, dtype=dtype)
 
 

onnx/reference/ops/op_optional.py

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

onnx/reference/ops/op_optional_get_element.py

@@ -1,17 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
-import numpy as np
-
 from onnx.reference.op_run import OpRun
 
 
 class OptionalGetElement(OpRun):
     def _run(self, x):  # type: ignore
         if x is None:
-            return ([],)
-        if isinstance(x, list):
-            return (x,)
-        if isinstance(x, np.ndarray):
-            return (x,)
-        raise RuntimeError("Input is empty.")
+            raise ValueError("The requested optional input has no value.")
+        return (x,)

onnx/reference/ops/op_optional_has_element.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -8,12 +10,4 @@ from onnx.reference.op_run import OpRun
 
 class OptionalHasElement(OpRun):
     def _run(self, x=None):  # type: ignore
-        if x is None:
-            return ([],)
-        if isinstance(x, list):
-            if len(x) > 0:
-                return (np.array([e is not None for e in x]),)
-        elif isinstance(x, np.ndarray):
-            if len(x.shape) > 0 and x.shape[0] > 0:
-                return (np.array([e is not None for e in x]),)
-        return ([],)
+        return (np.array(x is not None),)

onnx/reference/ops/op_or.py

@@ -1,9 +1,11 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
 import numpy as np
 
-from ._op import OpRunBinary
+from onnx.reference.ops._op import OpRunBinary
 
 
 class Or(OpRunBinary):

onnx/reference/ops/op_pad.py

@@ -1,37 +1,36 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0913,W0221
 
 import numpy as np
 
-from onnx.defs import onnx_opset_version
 from onnx.reference.op_run import OpRun
 
 
 def _pad_impl(data, raw_pads, mode, constant_values=0.0, axes=None):  # type: ignore
-    if raw_pads is not None:
-        old_raw_pads = raw_pads
-        raw_pads = []
-        pos = 0
-        for i in range(len(data.shape)):
-            if axes is None or i in axes:
-                raw_pads.extend(old_raw_pads[pos : pos + 2])
-                pos += 2
-            else:
-                raw_pads.extend([0, 0])
-        raw_pads = np.array(raw_pads)
-
     input_rank = data.ndim
-    if input_rank * 2 != raw_pads.size:
-        raise RuntimeError("The number of elements in raw_pads should be 2 * data_rank")
+    if axes is None:
+        axes = list(range(input_rank))
+    else:
+        axes = list(map(lambda axis: axis if axis >= 0 else axis + input_rank, axes))
+    num_axes = len(axes)
+    if num_axes * 2 != len(raw_pads):
+        raise RuntimeError(
+            "The number of elements in raw_pads should be 2 times the number of axes"
+        )
 
-    half = raw_pads.shape[0] // 2
-    pad_width = tuple((raw_pads[i], raw_pads[i + half]) for i in range(0, half))
+    pad_width = [(0, 0)] * input_rank
+    for i, axis in enumerate(axes):
+        pad_begin = raw_pads[i]
+        pad_end = raw_pads[num_axes + i]
+        pad_width[axis] = (pad_begin, pad_end)
 
     if mode == "constant":
         return np.pad(
             data, pad_width=pad_width, mode=mode, constant_values=constant_values
-        )
-    return np.pad(data, pad_width=pad_width, mode=mode)
+        ).astype(data.dtype)
+    return np.pad(data, pad_width=pad_width, mode=mode).astype(data.dtype)
 
 
 class Pad_1(OpRun):
@@ -64,13 +63,3 @@ class Pad_18(OpRun):
         return (
             _pad_impl(data, pads, mode=mode, constant_values=constant_value, axes=axes),
         )
-
-
-if onnx_opset_version() >= 18:
-    Pad = Pad_18
-elif onnx_opset_version() >= 11:
-    Pad = Pad_11  # type: ignore
-elif onnx_opset_version() >= 2:
-    Pad = Pad_2  # type: ignore
-else:
-    Pad = Pad_1  # type: ignore

onnx/reference/ops/op_pow.py

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

onnx/reference/ops/op_prelu.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -9,7 +11,7 @@ from onnx.reference.op_run import OpRun
 class PRelu(OpRun):
     def _run(self, x, slope):  # type: ignore
         try:
-            return (np.where(x > 0, x, x * slope),)
+            return (np.where(x > 0, x, x * slope).astype(x.dtype),)
         except ValueError as e:
             # Broadcast did not work according to numpy.
             # The logic is then the following, if slope has d elements,
@@ -28,5 +30,5 @@ class PRelu(OpRun):
                         new_shape.append(1)
                 if n == 1:
                     xs = x * slope.reshape(tuple(new_shape))
-                    return (np.where(x > 0, x, xs),)
+                    return (np.where(x > 0, x, xs).astype(x.dtype),)
             raise e

onnx/reference/ops/op_qlinear_conv.py

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0913,R0914,W0221
 
 import numpy as np
 
 from onnx.reference.op_run import OpRun
-
-from .op_conv import _conv_implementation
+from onnx.reference.ops.op_conv import _conv_implementation
 
 
 class QLinearConv(OpRun):

onnx/reference/ops/op_qlinear_matmul.py

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

onnx/reference/ops/op_quantize_linear.py

@@ -1,13 +1,60 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
+from typing import Optional, Tuple
+
 import numpy as np
 
+from onnx import TensorProto
+from onnx.helper import (
+    float32_to_float8e4m3,
+    float32_to_float8e5m2,
+    np_dtype_to_tensor_dtype,
+    tensor_dtype_to_np_dtype,
+)
+from onnx.reference.custom_element_types import (
+    float8e4m3fn,
+    float8e4m3fnuz,
+    float8e5m2,
+    float8e5m2fnuz,
+)
 from onnx.reference.op_run import OpRun
 
 
 class _CommonQuantizeLinear(OpRun):
-    def common_run(self, x, y_scale, zero_point=None, axis=1):  # type: ignore
+    float32_to_float8e4m3 = np.vectorize(float32_to_float8e4m3)
+    float32_to_float8e5m2 = np.vectorize(float32_to_float8e5m2)
+
+    def get_zero_point_type(self, zero_point: np.ndarray) -> int:
+        if (
+            zero_point.dtype == float8e4m3fn
+            and zero_point.dtype.descr[0][0] == "e4m3fn"
+        ):
+            return TensorProto.FLOAT8E4M3FN
+        if (
+            zero_point.dtype == float8e4m3fnuz
+            and zero_point.dtype.descr[0][0] == "e4m3fnuz"
+        ):
+            return TensorProto.FLOAT8E4M3FNUZ
+        if zero_point.dtype == float8e5m2 and zero_point.dtype.descr[0][0] == "e5m2":
+            return TensorProto.FLOAT8E5M2
+        if (
+            zero_point.dtype == float8e5m2fnuz
+            and zero_point.dtype.descr[0][0] == "e5m2fnuz"
+        ):
+            return TensorProto.FLOAT8E5M2FNUZ
+        return np_dtype_to_tensor_dtype(zero_point.dtype)
+
+    def common_run(  # pylint: disable=too-many-branches
+        self,
+        x: np.ndarray,
+        y_scale: np.ndarray,
+        zero_point: Optional[np.ndarray] = None,
+        axis: int = 1,
+        saturate: bool = True,
+    ) -> Tuple[np.ndarray]:
         if len(y_scale.shape) > 1:
             raise RuntimeError("Input 2 must be a vector or a number.")
         if len(y_scale.shape) > 0 and y_scale.size == 1:
@@ -20,29 +67,67 @@ class _CommonQuantizeLinear(OpRun):
             x = x / y_scale
             new_shape = x.shape  # unused
         if zero_point is not None:
-            dtype = zero_point.dtype
-            if len(y_scale.shape) > 0:
-                x += zero_point.reshape(new_shape)
-            else:
-                x += zero_point
-            # np.around(x, 0, out=x)
-            np.floor(x + 0.5, out=x)
-            if dtype == np.uint8:
+            tensor_type = self.get_zero_point_type(zero_point)
+
+            if tensor_type == TensorProto.UINT8:
+                if len(y_scale.shape) > 0:
+                    x += zero_point.reshape(new_shape)
+                else:
+                    x += zero_point
+                np.floor(x + 0.5, out=x)
                 np.clip(x, 0, 255, out=x)
-            elif dtype == np.int8:
+                dtype = tensor_dtype_to_np_dtype(tensor_type)
+                return (np.ceil(x).astype(dtype),)
+
+            if tensor_type == TensorProto.INT8:
+                if len(y_scale.shape) > 0:
+                    x += zero_point.reshape(new_shape)
+                else:
+                    x += zero_point
+                np.floor(x + 0.5, out=x)
                 np.clip(x, -128, 127, out=x)
-            else:
-                raise RuntimeError(f"Unexpected dtype for input 2 {dtype}.")
-            return (np.ceil(x).astype(dtype),)
+                dtype = tensor_dtype_to_np_dtype(tensor_type)
+                return (np.ceil(x).astype(dtype),)
+
+            if tensor_type == TensorProto.FLOAT8E4M3FN:
+                f8 = _CommonQuantizeLinear.float32_to_float8e4m3(x, saturate=saturate)
+                return (f8.astype(float8e4m3fn),)  # type: ignore[attr-defined]
 
-        dtype = np.uint8
+            if tensor_type == TensorProto.FLOAT8E4M3FNUZ:
+                f8 = _CommonQuantizeLinear.float32_to_float8e4m3(
+                    x, uz=True, saturate=saturate
+                )
+                return (f8.astype(float8e4m3fnuz),)  # type: ignore[attr-defined]
+
+            if tensor_type == TensorProto.FLOAT8E5M2:
+                f8 = _CommonQuantizeLinear.float32_to_float8e5m2(x, saturate=saturate)
+                return (f8.astype(float8e5m2),)  # type: ignore[attr-defined]
+
+            if tensor_type == TensorProto.FLOAT8E5M2FNUZ:
+                f8 = _CommonQuantizeLinear.float32_to_float8e5m2(
+                    x, fn=True, uz=True, saturate=saturate
+                )
+                return (f8.astype(float8e5m2fnuz),)  # type: ignore[attr-defined]
+
+            raise RuntimeError(
+                f"Unexpected tensor_type for input 2: tensor_type={tensor_type}, "
+                f"zero_point.dtype={zero_point.dtype}."
+            )
+
+        dtype = np.uint8  # type: ignore[assignment]
         # np.around(x, 0, out=x)
         np.floor(x + 0.5, out=x)
         np.clip(x, 0, 255, out=x)
         return (x.astype(dtype),)
 
 
-class QuantizeLinear(_CommonQuantizeLinear):
+class QuantizeLinear_10(_CommonQuantizeLinear):
     def _run(self, *args, axis=None):  # type: ignore
         # args: x, y_scale, zero_point
         return self.common_run(*args, axis=axis)  # type: ignore
+
+
+class QuantizeLinear_19(_CommonQuantizeLinear):
+    def _run(self, *args, axis=None, saturate=None):  # type: ignore
+        # args: x, y_scale, zero_point
+        return self.common_run(*args, axis=axis, saturate=saturate)  # type: ignore

onnx/reference/ops/op_random_normal.py

@@ -1,7 +1,9 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0913,W0221
 
-from ._op_common_random import _CommonRandom
+from onnx.reference.ops._op_common_random import _CommonRandom
 
 
 class RandomNormal(_CommonRandom):

onnx/reference/ops/op_random_normal_like.py

@@ -1,9 +1,10 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0913,W0221
 
 from onnx.helper import np_dtype_to_tensor_dtype
-
-from ._op_common_random import _CommonRandom
+from onnx.reference.ops._op_common_random import _CommonRandom
 
 
 class RandomNormalLike(_CommonRandom):

onnx/reference/ops/op_random_uniform.py

@@ -1,7 +1,9 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0913,W0221
 
-from ._op_common_random import _CommonRandom
+from onnx.reference.ops._op_common_random import _CommonRandom
 
 
 class RandomUniform(_CommonRandom):

onnx/reference/ops/op_random_uniform_like.py

@@ -1,9 +1,10 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0913,W0221
 
 from onnx.helper import np_dtype_to_tensor_dtype
-
-from ._op_common_random import _CommonRandom
+from onnx.reference.ops._op_common_random import _CommonRandom
 
 
 class RandomUniformLike(_CommonRandom):

onnx/reference/ops/op_range.py

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

onnx/reference/ops/op_reciprocal.py

@@ -1,12 +1,14 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
 import numpy as np
 
-from ._op import OpRunUnaryNum
+from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Reciprocal(OpRunUnaryNum):
     def _run(self, x):  # type: ignore
         with np.errstate(divide="ignore"):
-            return (np.reciprocal(x),)
+            return (np.reciprocal(x).astype(x.dtype),)