onnx 1.13.1__cp310-cp310-win32.whl → 1.14.0__cp310-cp310-win32.whl

onnx/reference/ops/op_conv.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0912,R0913,R0914,R0915,R1702,W0221
 
@@ -146,7 +148,7 @@ def _conv_implementation_im2col(  # type: ignore
                     td += cv.shape[1]
                 res.append((b, cv))
 
-        new_shape = [X.shape[0]] + list(res[0][1].shape[1:])
+        new_shape = [X.shape[0], *list(res[0][1].shape[1:])]
         new_shape[1] = td
         final = np.zeros(tuple(new_shape), dtype=res[0][1].dtype)
         p = 0
@@ -165,7 +167,7 @@ def _conv_implementation_im2col(  # type: ignore
     c2 = im2col(X, kernel_shape, dilations, pads, strides)
     w_shape = W.shape[: -len(kernel_shape) :] + (-1,)
     w_reshaped = W.reshape(w_shape)
-    perm = [len(w_shape) - 1] + list(range(len(w_shape) - 1))
+    perm = [len(w_shape) - 1, *list(range(len(w_shape) - 1))]
     w_perm = np.transpose(w_reshaped, perm)
     mul = np.matmul(c2, w_perm)
     if B is not None:
@@ -223,7 +225,7 @@ def _conv_implementation(  # type: ignore
                     td += cv.shape[1]
                 res.append((b, cv))
 
-        new_shape = [X.shape[0]] + list(res[0][1].shape[1:])
+        new_shape = [X.shape[0], *list(res[0][1].shape[1:])]
         new_shape[1] = td
         final = np.zeros(tuple(new_shape), dtype=res[0][1].dtype)
         p = 0
@@ -285,13 +287,14 @@ def _conv_implementation(  # type: ignore
         oh = -1 * (kh % 2)
         bh = -h0
         eh = h_out * sth
-        res = np.zeros((X.shape[0], W.shape[0]) + (h_out,))
+        res = np.zeros((X.shape[0], W.shape[0]) + (h_out,))  # type: ignore[assignment]
         if B is not None:
             res[:, :, :] += B.reshape((1, -1, 1))  # type: ignore
 
         for n in range(0, sN):
             for nw in range(W.shape[0]):
                 for c in range(0, sC):
+                    w = W[nw : nw + 1, c : c + 1]
                     for io in range(bh, eh, sth):
                         hr = (io - bh) // sth
                         if hr >= h_out:
@@ -299,18 +302,21 @@ def _conv_implementation(  # type: ignore
                         i = io + kh % 2
                         ih1, ih2 = max(0, i + oh), min(i + oh + kh, sH)
                         img = X[n : n + 1, c : c + 1, ih1:ih2]
-                        w = W[nw : nw + 1, c : c + 1]
                         if img.shape != w.shape:
                             jh1, jh2 = max(-oh - i, 0), min(kh, kh + sH - (i + oh + kh))
-                            w = w[:1, :1, jh1:jh2]
-                            if img.shape != w.shape:
+                            w_ = w[:1, :1, jh1:jh2]
+                            if img.shape != w_.shape:
                                 raise RuntimeError(
-                                    f"Unexpected shape {img.shape} != {w.shape}, oh={oh}, "
+                                    f"Unexpected shape {img.shape} != {w_.shape}, oh={oh}, "
                                     f"i={i}, kh={kh}, sH={sH}, sth={sth}."
                                 )
-                            s = (img * w).sum()
+                            s = np.dot(img.reshape((1, -1)), w_.reshape((-1, 1)))[
+                                0, 0
+                            ]  # (img * w_).sum()
                         else:
-                            s = (img * w).sum()
+                            s = np.dot(img.reshape((1, -1)), w.reshape((-1, 1)))[
+                                0, 0
+                            ]  # (img * w).sum()
                         res[n, nw, hr] += s  # type: ignore
 
         return res
@@ -328,24 +334,27 @@ def _conv_implementation(  # type: ignore
         oh, ow = -1 * (kh % 2), -1 * (kw % 2)
         bh, bw = -h0, -w0
         eh, ew = h_out * sth, w_out * stw
-        res = np.zeros((X.shape[0], W.shape[0]) + (h_out, w_out))
+        res = np.zeros((X.shape[0], W.shape[0]) + (h_out, w_out))  # type: ignore[assignment]
         if B is not None:
             res[:, :, :, :] = B.reshape((1, -1, 1, 1))  # type: ignore
 
         for n in range(0, sN):
             for nw in range(W.shape[0]):
                 for c in range(0, sC):
+                    w = W[nw : nw + 1, c : c + 1]
                     for io in range(bh, eh, sth):
+                        hr = (io - bh) // sth
+                        if hr >= h_out:
+                            continue
+                        i = io + kh % 2
+                        ih1, ih2 = max(0, i + oh), min(i + oh + kh, sH)
                         for jo in range(bw, ew, stw):
-                            hr, wr = (io - bh) // sth, (jo - bw) // stw
-                            if hr >= h_out or wr >= w_out:
+                            wr = (jo - bw) // stw
+                            if wr >= w_out:
                                 continue
-                            i = io + kh % 2
                             j = jo + kw % 2
-                            ih1, ih2 = max(0, i + oh), min(i + oh + kh, sH)
                             iw1, iw2 = max(0, j + ow), min(j + ow + kw, sW)
                             img = X[n : n + 1, c : c + 1, ih1:ih2, iw1:iw2]
-                            w = W[nw : nw + 1, c : c + 1]
                             if img.shape != w.shape:
                                 jh1, jh2 = max(-oh - i, 0), min(
                                     kh, kh + sH - (i + oh + kh)
@@ -353,15 +362,19 @@ def _conv_implementation(  # type: ignore
                                 jw1, jw2 = max(-ow - j, 0), min(
                                     kw, kw + sW - (j + ow + kw)
                                 )
-                                w = w[:1, :1, jh1:jh2, jw1:jw2]
-                                if img.shape != w.shape:
+                                w_ = w[:1, :1, jh1:jh2, jw1:jw2]
+                                if img.shape != w_.shape:
                                     raise RuntimeError(
-                                        f"Unexpected shape {img.shape} != {w.shape}, oh={oh}, ow={ow}, "
+                                        f"Unexpected shape {img.shape} != {w_.shape}, oh={oh}, ow={ow}, "
                                         f"i={i}, j={j}, kh={kh}, kw={kw}, sH={sH}, sW={sW}, sth={sth}, stw={stw}."
                                     )
-                                s = (img * w).sum()
+                                s = np.dot(img.reshape((1, -1)), w_.reshape((-1, 1)))[
+                                    0, 0
+                                ]  # (img * w_).sum()
                             else:
-                                s = (img * w).sum()
+                                s = np.dot(img.reshape((1, -1)), w.reshape((-1, 1)))[
+                                    0, 0
+                                ]  # (img * w).sum()
                             res[n, nw, hr, wr] += s  # type: ignore
 
         return res
@@ -379,31 +392,33 @@ def _conv_implementation(  # type: ignore
         oh, ow, oz = -1 * (kh % 2), -1 * (kw % 2), -1 * (kz % 2)
         bh, bw, bz = -h0, -w0, -z0
         eh, ew, ez = h_out * sth, w_out * stw, z_out * stz
-        res = np.zeros((X.shape[0], W.shape[0]) + (h_out, w_out, z_out))
+        res = np.zeros((X.shape[0], W.shape[0]) + (h_out, w_out, z_out))  # type: ignore[assignment]
         if B is not None:
             res[:, :, :, :, :] = B.reshape((1, -1, 1, 1, 1))  # type: ignore
 
         for n in range(0, sN):
             for nw in range(W.shape[0]):
                 for c in range(0, sC):
+                    w = W[nw : nw + 1, c : c + 1]
                     for io in range(bh, eh, sth):
+                        hr = (io - bh) // sth
+                        if hr >= h_out:
+                            continue
+                        i = io + kh % 2
+                        ih1, ih2 = max(0, i + oh), min(i + oh + kh, sH)
                         for jo in range(bw, ew, stw):
+                            wr = (jo - bw) // stw
+                            if wr >= w_out:
+                                continue
+                            j = jo + kw % 2
+                            iw1, iw2 = max(0, j + ow), min(j + ow + kw, sW)
                             for zo in range(bz, ez, stz):
-                                hr, wr, zr = (
-                                    (io - bh) // sth,
-                                    (jo - bw) // stw,
-                                    (zo - bz) // stz,
-                                )
-                                if hr >= h_out or wr >= w_out or zr >= z_out:
+                                zr = (zo - bz) // stz
+                                if zr >= z_out:
                                     continue
-                                i = io + kh % 2
-                                j = jo + kw % 2
                                 z = zo + kz % 2
-                                ih1, ih2 = max(0, i + oh), min(i + oh + kh, sH)
-                                iw1, iw2 = max(0, j + ow), min(j + ow + kw, sW)
                                 iz1, iz2 = max(0, z + oz), min(z + oz + kz, sZ)
                                 img = X[n : n + 1, c : c + 1, ih1:ih2, iw1:iw2, iz1:iz2]
-                                w = W[nw : nw + 1, c : c + 1]
                                 if img.shape != w.shape:
                                     jh1, jh2 = max(-oh - i, 0), min(
                                         kh, kh + sH - (i + oh + kh)
@@ -414,16 +429,24 @@ def _conv_implementation(  # type: ignore
                                     jz1, jz2 = max(-oz - z, 0), min(
                                         kz, kz + sZ - (z + oz + kz)
                                     )
-                                    w = w[:1, :1, jh1:jh2, jw1:jw2, jz1:jz2]
-                                    if img.shape != w.shape:
+                                    w_ = w[:1, :1, jh1:jh2, jw1:jw2, jz1:jz2]
+                                    if img.shape != w_.shape:
                                         raise RuntimeError(
-                                            f"Unexpected shape {img.shape} != {w.shape}, oh={oh}, ow={ow}, oz={oz}, "
+                                            f"Unexpected shape {img.shape} != {w_.shape}, oh={oh}, ow={ow}, oz={oz}, "
                                             f"i={i}, j={j}, z={z}, kh={kh}, kw={kw}, kz={kz}, "
                                             f"sH={sH}, sW={sW}, sZ={sZ}, sth={sth}, stw={stw}, stz={stz}."
                                         )
-                                    s = (img * w).sum()
+                                    s = np.dot(
+                                        img.reshape((1, -1)), w_.reshape((-1, 1))
+                                    )[
+                                        0, 0
+                                    ]  # (img * w_).sum()
                                 else:
-                                    s = (img * w).sum()
+                                    s = np.dot(
+                                        img.reshape((1, -1)), w.reshape((-1, 1))
+                                    )[
+                                        0, 0
+                                    ]  # (img * w).sum()
                                 res[n, nw, hr, wr, zr] += s  # type: ignore
 
         return res
@@ -454,5 +477,5 @@ class Conv(OpRun):
         return (
             _conv_implementation(
                 X, W, B, auto_pad, dilations, group, kernel_shape, pads, strides
-            ),
+            ).astype(X.dtype),
         )

onnx/reference/ops/op_conv_integer.py

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0913,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 ConvInteger(OpRun):

onnx/reference/ops/op_conv_transpose.py

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0912,R0913,R0914,R0915,R1702,W0221
 
 import numpy as np
 
 from onnx.reference.op_run import OpRun
-
-from .op_col2im import col2im_naive_implementation
+from onnx.reference.ops.op_col2im import col2im_naive_implementation
 
 
 class ConvTranspose(OpRun):
@@ -106,4 +107,4 @@ class ConvTranspose(OpRun):
                 f"Implementation for group={group} > 1 is not available yet."
             )
 
-        return (final,)
+        return (final.astype(X.dtype),)  # type: ignore[union-attr]

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

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

onnx/reference/ops/op_cum_sum.py

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

onnx/reference/ops/op_deform_conv.py

@@ -0,0 +1,178 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+# pylint: disable=R0912,R0913,R0914,R0915,R1702,W0221
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _deform_conv_implementation(  # type: ignore
+    X, W, offset, B, mask, dilations, group, kernel_shape, offset_group, pads, strides
+):
+    if dilations is None:
+        dilations = [1 for s in X.shape[2:]]
+    if kernel_shape is None:
+        kernel_shape = W.shape[2:]
+    if pads is None:
+        pads = [0 for s in X.shape[2:]] * 2
+    if strides is None:
+        strides = [1 for s in X.shape[2:]]
+    if group is None:
+        group = 1
+    if offset_group is None:
+        offset_group = 1
+
+    n, ic = X.shape[:2]
+    oc = W.shape[0]
+    output_shape = offset.shape[2:]
+
+    if ic != W.shape[1] * group or oc % group != 0:
+        raise ValueError(
+            f"Shape inconsistencies, X.shape={X.shape}, W.shape={W.shape}, group={group}."
+        )
+    ics_per_group, ocs_per_group = W.shape[1], oc // group
+
+    if ic % offset_group != 0:
+        raise ValueError("Number of input channels must be divisible by offset_group.")
+    ics_per_offset_group = ic // offset_group
+
+    if offset_group * np.prod(kernel_shape) * len(kernel_shape) != offset.shape[1]:
+        raise ValueError(
+            f"Offset shape {offset.shape} is inconsistent with offset_group {offset_group} "
+            f"and kernel shape {kernel_shape}."
+        )
+    offset = offset.reshape(
+        (n, offset_group, *kernel_shape, len(kernel_shape), *output_shape)
+    )
+
+    if mask is None:
+        mask = np.ones((n, offset_group * np.prod(kernel_shape), *output_shape))
+    mask = mask.reshape((n, offset_group, *kernel_shape, *output_shape))
+
+    # pylint: disable=import-outside-toplevel
+    from onnx.reference.ops._op_list import GridSample
+
+    if len(X.shape) == 4:
+        ih, iw = X.shape[2:]
+        oh, ow = offset.shape[-2:]
+        kh, kw = kernel_shape
+        sth, stw = strides
+        dh, dw = dilations
+        kh_new, kw_new = (kh - 1) * dh + 1, (kw - 1) * dw + 1
+
+        if oh != int(((ih - kh_new + pads[0] + pads[2]) / sth) + 1) or ow != int(
+            ((iw - kw_new + pads[1] + pads[3]) / stw) + 1
+        ):
+            raise RuntimeError(
+                "Padding, dilation, stride, and kernel shape incompatible with output shape."
+            )
+
+        bh, bw = -pads[0], -pads[1]
+
+        res = np.zeros((n, oc, oh, ow), dtype=X.dtype)
+        if B is not None:
+            res[:, :, :, :] = B.reshape((1, -1, 1, 1))
+
+        # Calculate coordinates of sampling points within kernel
+        kernel_pos_w, kernel_pos_h = np.meshgrid(
+            np.arange(0, kw_new, dw), np.arange(0, kh_new, dh)
+        )
+        kernel_pos_wrt_first_elem = np.stack(
+            (kernel_pos_h, kernel_pos_w), axis=2
+        )  # shape (kH, kW, 2)
+
+        for batch_idx in range(n):
+            for oc_idx in range(oc):
+                for ic_idx in range(ic):
+                    # Group convolution logic
+                    if ic_idx // ics_per_group != oc_idx // ocs_per_group:
+                        # Input channel and output channel don't belong to same group
+                        continue
+
+                    # Offset group logic
+                    offset_group_idx = ic_idx // ics_per_offset_group
+
+                    for i in range(oh):
+                        h_coord = bh + sth * i
+                        for j in range(ow):
+                            w_coord = bw + stw * j
+                            # (h_coord, w_coord) is coord of top left elem of kernel
+
+                            kernel = np.copy(kernel_pos_wrt_first_elem).astype(float)
+                            kernel[:, :, 0] += (
+                                h_coord
+                                + offset[batch_idx, offset_group_idx, :, :, 0, i, j]
+                            )
+                            kernel[:, :, 1] += (
+                                w_coord
+                                + offset[batch_idx, offset_group_idx, :, :, 1, i, j]
+                            )
+
+                            # GridSample expects normalized grid coordinates
+                            kernel[:, :, 0] = kernel[:, :, 0] / (ih - 1) * 2 - 1
+                            kernel[:, :, 1] = kernel[:, :, 1] / (iw - 1) * 2 - 1
+
+                            kernel = np.expand_dims(kernel, 0)  # add batch dimension
+                            kernel = np.flip(
+                                kernel, 3
+                            )  # spatial GridSample expects (x, y) input
+                            grid_sample_output = GridSample.eval(
+                                X[batch_idx : batch_idx + 1, ic_idx : ic_idx + 1],
+                                kernel,
+                                align_corners=1,
+                            )
+
+                            conv_value = np.multiply(
+                                grid_sample_output,
+                                W[oc_idx, ic_idx % ics_per_group, :, :],
+                            )
+                            conv_value = np.multiply(
+                                conv_value,
+                                mask[batch_idx, offset_group_idx, :, :, i, j],
+                            )
+                            res[batch_idx, oc_idx, i, j] += np.sum(conv_value)
+
+        return res
+
+    raise RuntimeError(
+        f"The convolution for X.shape={X.shape}, W.shape={W.shape}, "
+        f"kernel_shape={kernel_shape} is not implemented yet."
+    )
+
+
+class DeformConv(OpRun):
+    def _run(  # type: ignore
+        self,
+        X,
+        W,
+        offset,
+        B=None,
+        mask=None,
+        dilations=None,
+        group=None,
+        kernel_shape=None,
+        offset_group=None,
+        pads=None,
+        strides=None,
+    ):
+        if len(X.shape) < 3:
+            raise ValueError(
+                f"X must have at least 3 dimensions but its shape is {X.shape}."
+            )
+        return (
+            _deform_conv_implementation(
+                X,
+                W,
+                offset,
+                B,
+                mask,
+                dilations,
+                group,
+                kernel_shape,
+                offset_group,
+                pads,
+                strides,
+            ),
+        )

onnx/reference/ops/op_depth_to_space.py

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

onnx/reference/ops/op_dequantize_linear.py

@@ -1,37 +1,88 @@
+# 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 np_dtype_to_tensor_dtype
+from onnx.numpy_helper import float8e4m3_to_float32, float8e5m2_to_float32
+from onnx.reference.custom_element_types import (
+    float8e4m3fn,
+    float8e4m3fnuz,
+    float8e5m2,
+    float8e5m2fnuz,
+)
 from onnx.reference.op_run import OpRun
 
 
 class DequantizeLinear(OpRun):
-    def _run(self, *args, axis=None):  # type: ignore
-        if len(args[1].shape) > 1:
+    def get_x_type(self, x: np.ndarray) -> int:
+        if x.dtype == float8e4m3fn and x.dtype.descr[0][0] == "e4m3fn":
+            return TensorProto.FLOAT8E4M3FN
+        if x.dtype == float8e4m3fnuz and x.dtype.descr[0][0] == "e4m3fnuz":
+            return TensorProto.FLOAT8E4M3FNUZ
+        if x.dtype == float8e5m2 and x.dtype.descr[0][0] == "e5m2":
+            return TensorProto.FLOAT8E5M2
+        if x.dtype == float8e5m2fnuz and x.dtype.descr[0][0] == "e5m2fnuz":
+            return TensorProto.FLOAT8E5M2FNUZ
+        return np_dtype_to_tensor_dtype(x.dtype)
+
+    @staticmethod
+    def reshape_input(
+        value: np.ndarray, shape: Tuple[int, ...], axis: Optional[int]
+    ) -> np.ndarray:
+        if axis is None:
+            raise ValueError("axis cannot be None.")
+        if len(value.shape) == 0:
+            return value
+        dims = [1] * len(shape)
+        dims[axis] = value.size
+        return value.reshape(tuple(dims))
+
+    def _run(
+        self,
+        x: np.ndarray,
+        x_scale: np.ndarray,
+        x_zero_point: Optional[np.ndarray] = None,
+        axis: Optional[int] = None,
+    ):  # type: ignore
+        if len(x_scale.shape) > 1:
             raise RuntimeError("Input 2 must be a vector or a number.")
 
-        x_scale = args[2]
-        if len(x_scale.shape) > 0 and x_scale.size == 1:
-            x_scale = x_scale[0]
-        if len(args) > 2:
-            if x_scale.dtype != args[0].dtype:
+        x_type = self.get_x_type(x)
+        if x_zero_point is not None:
+            zero_type = self.get_x_type(x_zero_point)
+            if x_type != zero_type:
                 raise RuntimeError(
-                    f"Type mismatch {args[0].dtype} != {x_scale.dtype} in DequantizeLinear."
+                    f"Type mismatch {x_type} != {zero_type} in DequantizeLinear."
+                )
+            if x_type in (
+                TensorProto.FLOAT8E4M3FN,
+                TensorProto.FLOAT8E4M3FNUZ,
+                TensorProto.FLOAT8E5M2,
+                TensorProto.FLOAT8E5M2FNUZ,
+            ):
+                raise RuntimeError(
+                    f"x_zero_point not supported for float 8 type {x_type}."
                 )
 
-            if len(x_scale.shape) > 0:
-                new_shape = [1 for s in args[0].shape]
-                new_shape[axis] = len(x_scale)
-                x = args[0].astype(np.float32) - x_scale.reshape(new_shape)
-                y = x * args[1].reshape(new_shape)
-            else:
-                x = args[0].astype(np.float32) - x_scale
-                y = x * args[1]
-        elif len(args[1].shape) > 0:
-            new_shape = [1 for s in args[0].shape]
-            new_shape[axis] = len(x_scale)
-            y = args[0].astype(np.float32) * x_scale.reshape(new_shape)
+            dx = x.astype(np.float32) - DequantizeLinear.reshape_input(
+                x_zero_point, x.shape, axis
+            )
         else:
-            y = args[0].astype(np.float32) * x_scale
+            if x_type == TensorProto.FLOAT8E4M3FN:
+                dx = float8e4m3_to_float32(x)
+            elif x_type == TensorProto.FLOAT8E4M3FNUZ:
+                dx = float8e4m3_to_float32(x, uz=True)
+            elif x_type == TensorProto.FLOAT8E5M2:
+                dx = float8e5m2_to_float32(x)
+            elif x_type == TensorProto.FLOAT8E5M2FNUZ:
+                dx = float8e5m2_to_float32(x, fn=True, uz=True)
+            else:
+                dx = x.astype(np.float32)
+        y = dx * DequantizeLinear.reshape_input(x_scale, x.shape, axis)
         return (y.astype(np.float32),)

onnx/reference/ops/op_det.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -8,7 +10,4 @@ from onnx.reference.op_run import OpRun
 
 class Det(OpRun):
     def _run(self, x):  # type: ignore
-        res = np.linalg.det(x)
-        if not isinstance(res, np.ndarray):
-            res = np.array([res])
-        return (res,)
+        return (np.linalg.det(x),)

onnx/reference/ops/op_dft.py

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

onnx/reference/ops/op_div.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 Div(OpRunBinaryNumpy):

onnx/reference/ops/op_dropout.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -6,7 +8,6 @@ from typing import Optional, Tuple
 import numpy as np
 from numpy.random import RandomState  # type: ignore
 
-from onnx.defs import onnx_opset_version
 from onnx.reference.op_run import OpRun
 
 
@@ -62,9 +63,3 @@ class Dropout_12(DropoutBase):
         return self._private_run(
             X, seed=seed, ratio=ratio, training_mode=training_mode  # type: ignore
         )
-
-
-if onnx_opset_version() >= 12:
-    Dropout = Dropout_12
-else:
-    Dropout = Dropout_7  # type: ignore

onnx/reference/ops/op_dynamic_quantize_linear.py

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

onnx/reference/ops/op_einsum.py

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

onnx/reference/ops/op_elu.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 Elu(OpRunUnaryNum):
     def _run(self, x, alpha=None):  # type: ignore
         alpha = alpha or self.alpha  # type: ignore
-        return (np.where(x > 0, x, alpha * (np.exp(x) - 1)),)
+        return (np.where(x > 0, x, alpha * (np.exp(x) - 1)).astype(x.dtype),)