onnx 1.13.1__cp37-cp37m-win_amd64.whl → 1.14.1__cp37-cp37m-win_amd64.whl

onnx/reference/ops/op_equal.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 OpRunBinaryComparison
+from onnx.reference.ops._op import OpRunBinaryComparison
 
 
 class Equal(OpRunBinaryComparison):

onnx/reference/ops/op_erf.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -5,7 +7,7 @@ from math import erf
 
 import numpy as np
 
-from ._op import OpRunUnaryNum
+from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Erf(OpRunUnaryNum):

onnx/reference/ops/op_exp.py

@@ -1,11 +1,13 @@
+# 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 Exp(OpRunUnaryNum):
     def _run(self, x):  # type: ignore
-        return (np.exp(x),)
+        return (np.exp(x).astype(x.dtype),)

onnx/reference/ops/op_expand.py

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

onnx/reference/ops/op_eyelike.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -9,13 +11,16 @@ from onnx.reference.op_run import OpRun
 
 
 class EyeLike(OpRun):
-    def _run(self, data, *args, dtype=None, k=None):  # type: ignore
+    def _run(self, data, *args, dtype=None, k=None):
         if dtype is None:
-            _dtype = np.float32
+            if data is None:
+                _dtype = np.float32
+            else:
+                _dtype = data.dtype
         elif dtype == TensorProto.STRING:
-            _dtype = np.str_
+            _dtype = np.str_  # type: ignore[assignment]
         else:
-            _dtype = tensor_dtype_to_np_dtype(dtype)
+            _dtype = tensor_dtype_to_np_dtype(dtype)  # type: ignore[assignment]
         shape = data.shape
         if len(shape) == 1:
             sh = (shape[0], shape[0])

onnx/reference/ops/op_flatten.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 Flatten(OpRunUnary):

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

onnx/reference/ops/op_gather.py

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

onnx/reference/ops/op_gather_elements.py

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

onnx/reference/ops/op_gathernd.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -49,7 +51,7 @@ def _gather_nd_impl(
     for batch_dim in range(reshaped_indices.shape[0]):
         for outer_dim in range(reshaped_indices.shape[1]):
             gather_index = tuple(reshaped_indices[batch_dim][outer_dim])
-            output_data_buffer.append(reshaped_data[(batch_dim,) + gather_index])
+            output_data_buffer.append(reshaped_data[(batch_dim, *gather_index)])
     return (np.asarray(output_data_buffer, dtype=data.dtype).reshape(output_shape),)
 
 

onnx/reference/ops/op_gemm.py

@@ -1,9 +1,10 @@
+# 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
 
 
@@ -44,7 +45,7 @@ class Gemm_6(OpRun):
                 _meth = _gemm01 if transB else _gemm00
             res = _meth(a, b, None, alpha, beta)
             if c is None:
-                return (res,)
+                return (res.astype(a.dtype),)
             if c.shape != res.shape:
                 raise ValueError(
                     f"Unable to add shape {c.shape} to shape {res.shape} without broadcast."
@@ -54,7 +55,7 @@ class Gemm_6(OpRun):
             _meth = _gemm11 if transB else _gemm10
         else:
             _meth = _gemm01 if transB else _gemm00
-        return (_meth(a, b, c, alpha, beta),)
+        return (_meth(a, b, c, alpha, beta).astype(a.dtype),)
 
 
 class Gemm_7(OpRun):
@@ -63,10 +64,4 @@ class Gemm_7(OpRun):
             _meth = _gemm11 if transB else _gemm10
         else:
             _meth = _gemm01 if transB else _gemm00
-        return (_meth(a, b, c, alpha, beta),)
-
-
-if onnx_opset_version() >= 7:
-    Gemm = Gemm_7
-else:
-    Gemm = Gemm_6  # type: ignore
+        return (_meth(a, b, c, alpha, beta).astype(a.dtype),)

onnx/reference/ops/op_global_average_pool.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -7,14 +9,13 @@ from onnx.reference.op_run import OpRun
 
 
 def _global_average_pool(x: np.ndarray) -> np.ndarray:
-    spatial_shape = np.ndim(x) - 2
-    y = np.average(x, axis=tuple(range(spatial_shape, spatial_shape + 2)))
-    for _ in range(spatial_shape):
+    axis = tuple(range(2, np.ndim(x)))
+    y = np.average(x, axis=axis)
+    for _ in axis:
         y = np.expand_dims(y, -1)
     return y  # type: ignore
 
 
 class GlobalAveragePool(OpRun):
     def _run(self, x):  # type: ignore
-        res = _global_average_pool(x)
-        return (res,)
+        return (_global_average_pool(x).astype(x.dtype),)

onnx/reference/ops/op_global_max_pool.py

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

onnx/reference/ops/op_greater.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 OpRunBinaryComparison
+from onnx.reference.ops._op import OpRunBinaryComparison
 
 
 class Greater(OpRunBinaryComparison):

onnx/reference/ops/op_greater_or_equal.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 OpRunBinaryComparison
+from onnx.reference.ops._op import OpRunBinaryComparison
 
 
 class GreaterOrEqual(OpRunBinaryComparison):

onnx/reference/ops/op_grid_sample.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0912,R0913,R0914,R0915,R1702,R1716,W0221
 
@@ -212,4 +214,4 @@ class GridSample(OpRun):
                             dx = x - x0 - 1
                             dy = y - y0 - 1
                             Y[n, c, oy, ox] = self._gs_bicubic_interpolate(p, dx, dy)
-        return (Y,)
+        return (Y.astype(X.dtype),)

onnx/reference/ops/op_gru.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0913,R0914,W0221,W0613
 
@@ -121,7 +123,8 @@ class CommonGRU(OpRun):
             )
 
         Y, Y_h = self._step(X, R, B, W, H_0, num_directions=num_directions)
-        return (Y,) if self.n_outputs == 1 else (Y, Y_h)
+        Y = Y.astype(X.dtype)
+        return (Y,) if self.n_outputs == 1 else (Y, Y_h.astype(X.dtype))
 
 
 class GRU(CommonGRU):

onnx/reference/ops/op_hamming_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 HammingWindow(_CommonWindow):

onnx/reference/ops/op_hann_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 HannWindow(_CommonWindow):

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

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

onnx/reference/ops/op_identity.py

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

onnx/reference/ops/op_if.py

@@ -1,5 +1,7 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
-# pylint: disable=W0221,W0613
+# pylint: disable=R0913,R0914,W0221,W0613
 
 from onnx.reference.op_run import OpRun
 
@@ -21,29 +23,36 @@ class If(OpRun):
         """
         return True
 
-    def _run(self, cond, context=None, else_branch=None, then_branch=None):  # type: ignore
+    def _run(self, cond, context=None, else_branch=None, then_branch=None, attributes=None):  # type: ignore
         if len(cond.shape) > 0:
-            if all(cond):
+            try:
+                evaluated_condition = all(cond)
+            except ValueError as e:
+                raise ValueError(
+                    f"Unable to evaluate the condition with {type(cond)}, "
+                    f"shape={cond.shape}, dtype={cond.dtype}."
+                ) from e
+            if evaluated_condition:
                 self._log("  -- then> {%r}", context)
-                outputs = self._run_then_branch(context)  # type: ignore
+                outputs = self._run_then_branch(context, attributes=attributes)  # type: ignore
                 self._log("  -- then<")
                 final = tuple(outputs)
                 branch = "then"
             else:
                 self._log("  -- else> {%r}", context)
-                outputs = self._run_else_branch(context)  # type: ignore
+                outputs = self._run_else_branch(context, attributes=attributes)  # type: ignore
                 self._log("  -- else<")
                 final = tuple(outputs)
                 branch = "else"
         elif cond:
             self._log("  -- then> {%r}", context)
-            outputs = self._run_then_branch(context)  # type: ignore
+            outputs = self._run_then_branch(context, attributes=attributes)  # type: ignore
             self._log("  -- then<")
             final = tuple(outputs)
             branch = "then"
         else:
             self._log("  -- else> {%r}", context)
-            outputs = self._run_else_branch(context)  # type: ignore
+            outputs = self._run_else_branch(context, attributes=attributes)  # type: ignore
             self._log("  -- else<")
             final = tuple(outputs)
             branch = "else"

onnx/reference/ops/op_instance_normalization.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_isinf.py

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

onnx/reference/ops/op_isnan.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 IsNaN(OpRunUnary):

onnx/reference/ops/op_layer_normalization.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_leaky_relu.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
 
 
 def _leaky_relu(x: np.ndarray, alpha: float) -> np.ndarray:
@@ -15,4 +17,4 @@ def _leaky_relu(x: np.ndarray, alpha: float) -> np.ndarray:
 class LeakyRelu(OpRunUnaryNum):
     def _run(self, x, alpha=None):  # type: ignore
         alpha = alpha or self.alpha  # type: ignore
-        return (_leaky_relu(x, alpha),)
+        return (_leaky_relu(x, alpha).astype(x.dtype),)

onnx/reference/ops/op_less.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 OpRunBinaryComparison
+from onnx.reference.ops._op import OpRunBinaryComparison
 
 
 class Less(OpRunBinaryComparison):

onnx/reference/ops/op_less_or_equal.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 OpRunBinaryComparison
+from onnx.reference.ops._op import OpRunBinaryComparison
 
 
 class LessOrEqual(OpRunBinaryComparison):

onnx/reference/ops/op_log.py

@@ -1,11 +1,13 @@
+# 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 Log(OpRunUnaryNum):
     def _run(self, x):  # type: ignore
-        return (np.log(x),)
+        return (np.log(x).astype(x.dtype),)

onnx/reference/ops/op_log_softmax.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_softmax import Softmax
+from onnx.reference.ops.op_softmax import Softmax
 
 
 class LogSoftmax(Softmax):

onnx/reference/ops/op_loop.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0912,R0914,W0221
 
@@ -26,7 +28,7 @@ class Loop(OpRun):
         """
         return True
 
-    def _run(self, M, cond, *args, context=None, body=None):  # type: ignore
+    def _run(self, M, cond, *args, context=None, body=None, attributes=None):  # type: ignore
         if len(args) > 0:
             v_initial = args[0]
             args = args[1:]
@@ -57,7 +59,7 @@ class Loop(OpRun):
                 inputs[body.input_names[0]] = np.array(it, dtype=M.dtype)  # type: ignore
             if len(body.input_names) > 1 and body.input_names[1] is not None:
                 inputs[body.input_names[1]] = cond
-            outputs = self._run_body(inputs)  # type: ignore
+            outputs = self._run_body(inputs, attributes=attributes)  # type: ignore
             if self.K > 0:
                 for k in range(self.K):
                     k_carried_away[k].append(outputs[-self.K + k])

onnx/reference/ops/op_lp_normalization.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 LpNormalization(OpRunUnaryNum):
@@ -12,4 +14,4 @@ class LpNormalization(OpRunUnaryNum):
         p = p or self.p  # type: ignore
         norm = np.power(np.power(x, p).sum(axis=axis), 1.0 / p)  # type: ignore
         norm = np.expand_dims(norm, axis)  # type: ignore
-        return (x / norm,)
+        return ((x / norm).astype(x.dtype),)

onnx/reference/ops/op_lp_pool.py

@@ -0,0 +1,41 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+# pylint: disable=W0221,R0913,R0914
+
+import numpy as np
+
+from onnx.reference.ops._op_common_pool import CommonPool
+
+
+class LpPool(CommonPool):
+    def _run(  # type: ignore
+        self,
+        x,
+        auto_pad=None,
+        ceil_mode=None,
+        dilations=None,
+        kernel_shape=None,
+        p=2,
+        pads=None,
+        strides=None,
+        count_include_pad=None,
+    ):
+        # utilize AvgPool the same fashion Pytorch does. Note that there is a difference in computation.
+        # it needs another PR to address.
+        # https://github.com/pytorch/pytorch/blob/f58ba553b78db7f88477f9ba8c9333bd1590e30a/torch/nn/functional.py#L1015
+        power_average = CommonPool._run(
+            self,
+            "AVG",
+            count_include_pad,
+            np.power(np.absolute(x), p),
+            auto_pad=auto_pad,
+            ceil_mode=ceil_mode,
+            dilations=dilations,
+            kernel_shape=kernel_shape,
+            pads=pads,
+            strides=strides,
+        )
+
+        kernel_element_count = np.prod(kernel_shape)
+        return (np.power(kernel_element_count * power_average[0], 1.0 / p),)

onnx/reference/ops/op_lrn.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0913,W0221
 
@@ -15,10 +17,12 @@ class LRN(OpRun):
                 f"LRN only applies on 4D tensors but shape is {x.shape!r}."
             )
         square_sum = np.zeros(x.shape).astype(x.dtype)
-        for ind in np.ndindex(x.shape):
-            n, c, h, w = ind
-            begin = max(0, c - int(math.floor((size - 1) / 2)))
-            end = min(5, c + int(math.ceil((size - 1) / 2)) + 1)
-            square_sum[n, c, h, w] = np.sum(x[n, begin:end, h, w] ** 2)
+        minc = x.shape[1]
+        c1 = int(math.floor((size - 1) / 2))
+        c2 = int(math.ceil((size - 1) / 2)) + 1
+        for c in range(x.shape[0]):
+            begin = max(0, c - c1)
+            end = min(minc, c + c2)
+            square_sum[:, c, :, :] = np.sum(x[:, begin:end, :, :] ** 2, axis=1)
         y = x / ((bias + (alpha / size) * square_sum) ** beta)
         return (y.astype(x.dtype),)

onnx/reference/ops/op_lstm.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0913,R0914,W0221,W0613
 
@@ -146,8 +148,8 @@ class CommonLSTM(OpRun):
         Y, Y_h = self._step(
             X, R, B, W, initial_h, initial_c, P, num_directions=num_directions
         )
-
-        return (Y,) if self.n_outputs == 1 else (Y, Y_h)  # type: ignore
+        Y = Y.astype(X.dtype)
+        return (Y,) if self.n_outputs == 1 else (Y, Y_h.astype(X.dtype))  # type: ignore
 
 
 class LSTM(CommonLSTM):

onnx/reference/ops/op_matmul.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 OpRunBinaryNum
+from onnx.reference.ops._op import OpRunBinaryNum
 
 
 def numpy_matmul(a, b):  # type: ignore

onnx/reference/ops/op_matmul_integer.py

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

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