onnx 1.13.0__cp310-cp310-win_amd64.whl → 1.14.0__cp310-cp310-win_amd64.whl

onnx/reference/ops/op_bitwise_and.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 BitwiseAnd(OpRunBinary):

onnx/reference/ops/op_bitwise_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 BitwiseNot(OpRunUnary):

onnx/reference/ops/op_bitwise_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 BitwiseOr(OpRunBinary):

onnx/reference/ops/op_bitwise_xor.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 BitwiseXor(OpRunBinary):

onnx/reference/ops/op_blackman_window.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_common_window import _CommonWindow
+from onnx.reference.ops._op_common_window import _CommonWindow
 
 
 class BlackmanWindow(_CommonWindow):

onnx/reference/ops/op_cast.py

@@ -1,18 +1,34 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
-# pylint: disable=W0221
+# pylint: disable=R0912,W0221
 
 import numpy as np
 
-from onnx.helper import float32_to_bfloat16, tensor_dtype_to_np_dtype
-from onnx.numpy_helper import bfloat16_to_float32
+from onnx.helper import (
+    float32_to_bfloat16,
+    float32_to_float8e4m3,
+    float32_to_float8e5m2,
+    tensor_dtype_to_np_dtype,
+)
+from onnx.numpy_helper import (
+    bfloat16_to_float32,
+    float8e4m3_to_float32,
+    float8e5m2_to_float32,
+)
 from onnx.onnx_pb import TensorProto
+from onnx.reference.custom_element_types import (
+    bfloat16,
+    float8e4m3fn,
+    float8e4m3fnuz,
+    float8e5m2,
+    float8e5m2fnuz,
+)
 from onnx.reference.op_run import OpRun
 
-bfloat16 = np.dtype((np.uint16, {"ui": (np.uint16, 0)}))
-
 
-def cast_to(x, to):
-    if x.dtype == bfloat16:
+def cast_to(x, to, saturate):
+    if x.dtype == bfloat16 and x.dtype.descr[0][0] == "bfloat16":
         if to == TensorProto.BFLOAT16:
             return x
         xr = x.ravel()
@@ -22,18 +38,83 @@ def cast_to(x, to):
             xf[i] = el
         dtype = tensor_dtype_to_np_dtype(to)
         return xf.astype(dtype).reshape(x.shape)
+
+    f8 = {
+        (float8e4m3fn, "e4m3fn", TensorProto.FLOAT8E4M3FN): float8e4m3_to_float32,
+        (
+            float8e4m3fnuz,
+            "e4m3fnuz",
+            TensorProto.FLOAT8E4M3FNUZ,
+        ): lambda *args: float8e4m3_to_float32(*args, uz=True),
+        (float8e5m2, "e5m2", TensorProto.FLOAT8E5M2): float8e5m2_to_float32,
+        (
+            float8e5m2fnuz,
+            "e5m2fnuz",
+            TensorProto.FLOAT8E5M2FNUZ,
+        ): lambda *args: float8e5m2_to_float32(*args, fn=True, uz=True),
+    }
+
+    for (dt, st, proto_type), cvt in f8.items():
+        if x.dtype == dt and x.dtype.descr[0][0] == st:
+            if to == proto_type:
+                return x
+            xr = x.ravel()
+            xf = np.empty(xr.shape[0], dtype=np.float32)
+            for i in range(xr.shape[0]):
+                el = cvt(xr[i])
+                xf[i] = el
+            dtype = tensor_dtype_to_np_dtype(to)
+            return xf.astype(dtype).reshape(x.shape)
+
     if to == TensorProto.BFLOAT16:
         xf = x.astype(np.float32).ravel()
         y = np.empty(xf.shape, dtype=bfloat16).ravel()
         for i in range(y.shape[0]):
-            el = float32_to_bfloat16(xf[i], truncate=True)
+            el = float32_to_bfloat16(xf[i], truncate=True)  # type: ignore[assignment]
             y[i] = el
         return y.reshape(x.shape)
 
+    f8back = {
+        TensorProto.FLOAT8E4M3FN: (
+            float8e4m3fn,
+            lambda *args: float32_to_float8e4m3(*args, saturate=saturate),
+        ),
+        TensorProto.FLOAT8E4M3FNUZ: (
+            float8e4m3fnuz,
+            lambda *args: float32_to_float8e4m3(*args, uz=True, saturate=saturate),
+        ),
+        TensorProto.FLOAT8E5M2: (
+            float8e5m2,
+            lambda *args: float32_to_float8e5m2(*args, saturate=saturate),
+        ),
+        TensorProto.FLOAT8E5M2FNUZ: (
+            float8e5m2fnuz,
+            lambda *args: float32_to_float8e5m2(
+                *args, fn=True, uz=True, saturate=saturate
+            ),
+        ),
+    }
+    for dt, (npdt, cvt) in f8back.items():
+        if to == dt:
+            xf = x.astype(np.float32).ravel()
+            y = np.empty(xf.shape, dtype=npdt).ravel()
+            for i in range(y.shape[0]):
+                el = cvt(xf[i])  # type: ignore[assignment]
+                y[i] = el
+            return y.reshape(x.shape)
+
+    if to == TensorProto.STRING:
+        return x.astype(np.str_)
+
     dtype = tensor_dtype_to_np_dtype(to)
     return x.astype(dtype)
 
 
-class Cast(OpRun):
+class Cast_1(OpRun):
     def _run(self, x, to=None):  # type: ignore
-        return (cast_to(x, to),)
+        return (cast_to(x, to, saturate=True),)
+
+
+class Cast_19(OpRun):
+    def _run(self, x, to=None, saturate=None):  # type: ignore
+        return (cast_to(x, to, saturate),)

onnx/reference/ops/op_cast_like.py

@@ -1,17 +1,42 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
 from onnx.helper import np_dtype_to_tensor_dtype
 from onnx.onnx_pb import TensorProto
 from onnx.reference.op_run import OpRun
+from onnx.reference.ops.op_cast import (
+    bfloat16,
+    cast_to,
+    float8e4m3fn,
+    float8e4m3fnuz,
+    float8e5m2,
+    float8e5m2fnuz,
+)
+
 
-from .op_cast import bfloat16, cast_to
+def _cast_like(x, y, saturate):
+    if y.dtype == bfloat16:
+        to = TensorProto.BFLOAT16
+    elif y.dtype == float8e4m3fn and y.dtype.descr[0][0] == "e4m3fn":
+        to = TensorProto.FLOAT8E4M3FN
+    elif y.dtype == float8e4m3fnuz and y.dtype.descr[0][0] == "e4m3fnuz":
+        to = TensorProto.FLOAT8E4M3FNUZ
+    elif y.dtype == float8e5m2 and y.dtype.descr[0][0] == "e5m2":
+        to = TensorProto.FLOAT8E5M2
+    elif y.dtype == float8e5m2fnuz and y.dtype.descr[0][0] == "e5m2fnuz":
+        to = TensorProto.FLOAT8E5M2FNUZ
+    else:
+        to = np_dtype_to_tensor_dtype(y.dtype)  # type: ignore
+    return (cast_to(x, to, saturate),)
 
 
-class CastLike(OpRun):
+class CastLike_15(OpRun):
     def _run(self, x, y):  # type: ignore
-        if y.dtype == bfloat16:
-            to = TensorProto.BFLOAT16
-        else:
-            to = np_dtype_to_tensor_dtype(y.dtype)  # type: ignore
-        return (cast_to(x, to),)
+        return _cast_like(x, y, True)
+
+
+class CastLike_19(OpRun):
+    def _run(self, x, y, saturate=None):  # type: ignore
+        return _cast_like(x, y, saturate)

onnx/reference/ops/op_ceil.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 Ceil(OpRunUnaryNum):

onnx/reference/ops/op_celu.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -14,4 +16,4 @@ def _vcelu1(x: np.ndarray, alpha: float = 1.0) -> np.ndarray:
 
 class Celu(OpRun):
     def _run(self, x, alpha=None):  # type: ignore
-        return (_vcelu1(x, alpha),)
+        return (_vcelu1(x, alpha).astype(x.dtype),)

onnx/reference/ops/op_center_crop_pad.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0912,R0914,R1702,W0221
 
@@ -9,11 +11,13 @@ from onnx.reference.op_run import OpRun
 class CenterCropPad(OpRun):
     def _run(self, input_data, shape, axes=None):  # type: ignore
         axes = axes or self.axes  # type: ignore
-
+        input_rank = len(input_data.shape)
         if axes is None:
-            axes = list(range(shape.shape[0]))
+            axes = list(range(input_rank))
         else:
-            axes = [(a + len(input_data.shape)) % len(input_data.shape) for a in axes]
+            axes = list(
+                map(lambda axis: axis if axis >= 0 else axis + input_rank, axes)
+            )
         pad_slices = [slice(0, s) for s in input_data.shape]
         crop_slices = [slice(0, s) for s in input_data.shape]
         new_shape = list(input_data.shape)

onnx/reference/ops/op_clip.py

@@ -1,9 +1,10 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0622,W0622,W0221
 
 import numpy as np
 
-from onnx.defs import onnx_opset_version
 from onnx.reference.op_run import OpRun
 
 
@@ -26,9 +27,3 @@ class Clip_11(OpRun):
             return (data,)
         res = np.clip(data, amin, amax)
         return (res,) if res.dtype == data.dtype else (res.astype(data.dtype),)
-
-
-if onnx_opset_version() >= 11:
-    Clip = Clip_11
-else:
-    Clip = Clip_6  # type: ignore

onnx/reference/ops/op_col2im.py

@@ -1,15 +1,15 @@
+# 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_common_indices import _get_indices, _is_out
+from onnx.reference.ops._op_common_indices import _get_indices, _is_out
 
 
 def _col2im_shape_check_2d(X, output_shape, kernel_shape, dilations, pads, strides):  # type: ignore
-
     output_height, output_width = output_shape
     kernel_height, kernel_width = kernel_shape
     dilation_height, dilation_width = dilations
@@ -106,7 +106,6 @@ def _col2im_naive_implementation_2d(res, image_shape, kernel_shape, dilations, p
 
 
 def _col2im_shape_check(X, output_shape, kernel_shape, dilations, pads, strides):  # type: ignore
-
     n_input_plane = X.shape[0]
 
     kernel_size = np.prod(kernel_shape)

onnx/reference/ops/op_compress.py

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

onnx/reference/ops/op_concat.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -7,15 +9,14 @@ from onnx.reference.op_run import OpRun
 
 
 class Concat(OpRun):
-    def _preprocess(self, a: np.ndarray) -> np.ndarray:
+    def _preprocess(self, a: np.ndarray, axis: int) -> np.ndarray:
         if len(a.shape) == 0:
             raise RuntimeError(f"Concat: one input has an empty shape: {a!r}.")
-        if self.axis >= len(a.shape):  # type: ignore
-            new_shape = a.shape + (1,) * (self.axis + 1 - len(a.shape))  # type: ignore
+        if axis >= len(a.shape):  # type: ignore
+            new_shape = a.shape + (1,) * (axis + 1 - len(a.shape))  # type: ignore
             return a.reshape(new_shape)
         return a
 
     def _run(self, *args, axis=None):  # type: ignore
-        axis = axis or self.axis  # type: ignore
-        targs = tuple(self._preprocess(a) for a in args)
+        targs = tuple(self._preprocess(a, axis) for a in args)
         return (np.concatenate(targs, axis),)  # type: ignore

onnx/reference/ops/op_concat_from_sequence.py

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

onnx/reference/ops/op_constant.py

@@ -1,15 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
 import numpy as np
 
-from onnx.defs import onnx_opset_version
-from onnx.reference.op_run import OpRun
+from onnx.reference.custom_element_types import (
+    bfloat16,
+    float8e4m3fn,
+    float8e4m3fnuz,
+    float8e5m2,
+    float8e5m2fnuz,
+)
+from onnx.reference.op_run import OpRun, RefAttrName
 
 
 def _check_dtype(val):  # type: ignore
     a = val.dtype
     if not isinstance(a, np.dtype) and a not in {
+        bfloat16,
+        float8e4m3fn,
+        float8e4m3fnuz,
+        float8e5m2,
+        float8e5m2fnuz,
         np.int8,
         np.uint8,
         np.float16,
@@ -48,7 +61,7 @@ class Constant_1(ConstantCommon):
         if overridden_attributes and (
             len(overridden_attributes) > 1
             or "value" not in overridden_attributes
-            or id(overridden_attributes["value"]) != id(getattr(self, "value"))  # noqa
+            or id(overridden_attributes["value"]) != id(self.value)
         ):
             raise RuntimeError(
                 "Function attributes are not implemented for opset <= 11. Use opset > 12."
@@ -74,7 +87,7 @@ class Constant_11(ConstantCommon):
         if overridden_attributes and (
             len(overridden_attributes) > 1
             or "value" not in overridden_attributes
-            or id(overridden_attributes["value"]) != id(getattr(self, "value"))  # noqa
+            or id(overridden_attributes["value"]) != id(self.value)
         ):
             raise RuntimeError(
                 "Function attributes are not implemented for opset <= 11. Use opset > 12."
@@ -88,28 +101,33 @@ class Constant_12(ConstantCommon):
         if hasattr(self, "sparse_value") and self.sparse_value is not None:  # type: ignore
             self.cst_name = "sparse_value"
             self.cst = self.sparse_value  # type: ignore
-        elif hasattr(self, "value_float") and self.value_float is not None:  # type: ignore
-            self.cst_name = "value_float"
-            self.cst = np.array(self.value_float, dtype=np.float32)  # type: ignore
-        elif hasattr(self, "value_floats") and self.value_floats is not None:  # type: ignore
-            self.cst_name = "value_floats"
-            self.cst = np.array(self.value_floats, dtype=np.float32)  # type: ignore
-        elif hasattr(self, "value_int") and self.value_int is not None:  # type: ignore
-            self.cst_name = "value_int"
-            self.cst = np.array(self.value_int, dtype=np.int64)  # type: ignore
-        elif hasattr(self, "value_ints") and self.value_ints is not None:  # type: ignore
-            self.cst_name = "value_ints"
-            self.cst = np.array(self.value_ints, dtype=np.int64)  # type: ignore
-        elif hasattr(self, "value_string") and self.value_string is not None:  # type: ignore
-            self.cst_name = "value_string"
-            self.cst = np.array(self.value_string)  # type: ignore
-        elif hasattr(self, "value_strings") and self.value_strings is not None:  # type: ignore
-            self.cst_name = "value_strings"
-            self.cst = np.array(self.value_strings)  # type: ignore
+            self.cst_convert = lambda v: v
         elif hasattr(self, "value") and self.value is not None:  # type: ignore
-            self.cst_name = "value"
-            self.cst = self.value  # type: ignore
+            self.cst_name = "value"  # type: ignore
+            self.cst = self.value if isinstance(self.value, RefAttrName) else self.value  # type: ignore
+            self.cst_convert = lambda v: v
         else:
+            for attr, np_dtype in {
+                "value_float": np.float32,
+                "value_floats": np.float32,
+                "value_int": np.int64,
+                "value_ints": np.int64,
+                "value_string": np.str_,
+                "value_strings": np.str_,
+            }.items():
+                if hasattr(self, attr) and getattr(self, attr) is not None:  # type: ignore
+                    self.cst_name = attr
+                    v = getattr(self, attr)
+                    self.cst = (
+                        v  # type: ignore
+                        if isinstance(v, RefAttrName)  # type: ignore
+                        else np.array(v, dtype=np_dtype)  # type: ignore
+                    )
+                    self.cst_convert = lambda v, np_dtype=np_dtype: np.array(  # type: ignore
+                        v, dtype=np_dtype
+                    )
+                    break
+        if not hasattr(self, "cst_name"):
             raise AttributeError("No constant is defined for operator 'Constant'.")
 
     def _run(self, **overridden_attributes):  # type: ignore
@@ -122,15 +140,8 @@ class Constant_12(ConstantCommon):
                 raise RuntimeError(
                     f"Cannot find attribute {self.cst_name!r} in {list(overridden_attributes)!r}."
                 )
-            return (overridden_attributes[self.cst_name],)
+            value = overridden_attributes[self.cst_name]
+            if isinstance(value, np.ndarray):
+                return (value,)
+            return (self.cst_convert(value),)
         return (self._check(self.cst),)
-
-
-if onnx_opset_version() >= 12:
-    Constant = Constant_12
-elif onnx_opset_version() >= 11:
-    Constant = Constant_11  # type: ignore
-elif onnx_opset_version() >= 9:
-    Constant = Constant_9  # type: ignore
-else:
-    Constant = Constant_1  # type: ignore

onnx/reference/ops/op_constant_of_shape.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -16,6 +18,8 @@ class ConstantOfShape(OpRun):
             self.cst = np.int64(self.cst)
         elif isinstance(self.cst, float):
             self.cst = np.float64(self.cst)
+        elif self.cst is None:
+            self.cst = np.float32(0)
         if not isinstance(
             self.cst,
             (