onnx 1.13.0__cp311-cp311-macosx_10_12_universal2.whl → 1.14.0__cp311-cp311-macosx_10_12_universal2.whl

onnx/reference/ops/op_reduce_sum_square.py

@@ -1,46 +1,32 @@
+# 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 ._op import OpRunReduceNumpy
+from onnx.reference.ops._op import OpRunReduceNumpy
 
 
 class ReduceSumSquare_1(OpRunReduceNumpy):
     def _run(self, data, axes=None, keepdims=None):  # type: ignore
-        return (np.sum(np.square(data), axis=axes, keepdims=keepdims),)
-
-
-class ReduceSumSquare_11(ReduceSumSquare_1):
-    pass
-
-
-class ReduceSumSquare_13(ReduceSumSquare_1):
-    pass
+        axes = tuple(axes) if axes is not None else None
+        res = np.sum(np.square(data), axis=axes, keepdims=keepdims)
+        if keepdims == 0 and not isinstance(res, np.ndarray):
+            # The runtime must return a numpy array of a single float.
+            res = np.array(res)
+        return (res,)
 
 
 class ReduceSumSquare_18(OpRunReduceNumpy):
-    def run(self, data, axes=None, keepdims=None, noop_with_empty_axes=None):  # type: ignore
-        keepdims = keepdims or self.keepdims  # type: ignore
-        noop_with_empty_axes = noop_with_empty_axes or self.noop_with_empty_axes  # type: ignore
-        return self._run(data, axes, keepdims, noop_with_empty_axes)
-
-    def _run(self, data, axes, keepdims=1, noop_with_empty_axes=0):  # type: ignore
+    def _run(self, data, axes=None, keepdims=1, noop_with_empty_axes=0):  # type: ignore
         if self.is_axes_empty(axes) and noop_with_empty_axes != 0:  # type: ignore
             return (np.square(data),)
 
         axes = self.handle_axes(axes)
         keepdims = keepdims != 0  # type: ignore
-        return (np.sum(np.square(data), axis=axes, keepdims=keepdims),)
-
-
-if onnx_opset_version() >= 18:
-    ReduceSumSquare = ReduceSumSquare_18
-elif onnx_opset_version() >= 13:
-    ReduceSumSquare = ReduceSumSquare_13  # type: ignore
-elif onnx_opset_version() >= 11:
-    ReduceSumSquare = ReduceSumSquare_11  # type: ignore
-else:
-    ReduceSumSquare = ReduceSumSquare_1  # type: ignore
+        res = np.sum(np.square(data), axis=axes, keepdims=keepdims)
+        if keepdims == 0 and not isinstance(res, np.ndarray):
+            # The runtime must return a numpy array of a single float.
+            res = np.array(res)
+        return (res,)

onnx/reference/ops/op_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
 
 
 class Relu(OpRunUnaryNum):

onnx/reference/ops/op_reshape.py

@@ -1,9 +1,10 @@
+# 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
 
 
@@ -26,7 +27,6 @@ class CommonReshape(OpRun):
 
 
 class Reshape_5(CommonReshape):
-
     pass
 
 
@@ -37,9 +37,3 @@ class Reshape_14(CommonReshape):
         else:
             allowzero = allowzero == 1
         return (reshape_reference_implementation(data, shape, allowzero),)
-
-
-if onnx_opset_version() >= 14:
-    Reshape = Reshape_14
-else:
-    Reshape = Reshape_5  # type: ignore

onnx/reference/ops/op_resize.py

@@ -1,14 +1,18 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=C0123,C3001,R0912,R0913,R0914,R1730,W0221,W0613
 
-from typing import Any, Callable, List, Optional
+from typing import Any, Callable, List, Optional, Tuple
 
 import numpy as np
 
 from onnx.reference.op_run import OpRun
 
 
-def _cartesian(arrays: List[np.ndarray], out: np.ndarray = None) -> np.ndarray:
+def _cartesian(
+    arrays: List[np.ndarray], out: Optional[np.ndarray] = None
+) -> np.ndarray:
     """
     From https://stackoverflow.com/a/1235363
     Generate a cartesian product of input arrays.
@@ -70,7 +74,9 @@ def _nearest_coeffs(ratio: float, mode: str = "round_prefer_floor") -> np.ndarra
     raise ValueError(f"Unexpected value {mode!r}.")
 
 
-def _cubic_coeffs(ratio: float, scale: float, A: float = -0.75) -> np.ndarray:
+def _cubic_coeffs(
+    ratio: float, scale: Optional[float] = None, A: float = -0.75
+) -> np.ndarray:
     # scale is unused
     coeffs = [
         ((A * (ratio + 1) - 5 * A) * (ratio + 1) + 8 * A) * (ratio + 1) - 4 * A,
@@ -87,7 +93,7 @@ def _cubic_coeffs_antialias(ratio: float, scale: float, A: float = -0.75) -> np.
     if scale > 1.0:  # Antialias is applied when downsampling
         scale = 1.0
 
-    def W(x: float) -> float:
+    def compute_coeff(x: float) -> float:
         x = abs(x)
         x_2 = x * x
         x_3 = x * x_2
@@ -100,11 +106,11 @@ def _cubic_coeffs_antialias(ratio: float, scale: float, A: float = -0.75) -> np.
     i_start = int(np.floor(-2 / scale) + 1)
     i_end = 2 - i_start
     args = [scale * (i - ratio) for i in range(i_start, i_end)]
-    coeffs = [W(x) for x in args]
+    coeffs = [compute_coeff(x) for x in args]
     return np.array(coeffs) / sum(coeffs)
 
 
-def _linear_coeffs(ratio: float, scale: float) -> np.ndarray:
+def _linear_coeffs(ratio: float, scale: Optional[float] = None) -> np.ndarray:
     # scale is unused
     return np.array([1 - ratio, ratio])
 
@@ -116,7 +122,7 @@ def _linear_coeffs_antialias(ratio: float, scale: float) -> np.ndarray:
     footprint = 2 - 2 * start
     args = (np.arange(start, start + footprint) - ratio) * scale
     coeffs = np.clip(1 - np.abs(args), 0, 1)
-    return np.array(coeffs) / sum(coeffs)
+    return np.array(coeffs) / sum(coeffs)  # type: ignore[no-any-return]
 
 
 def _get_neighbor_idxes(x: float, n: int, limit: int) -> np.ndarray:
@@ -145,7 +151,7 @@ def _get_neighbor_idxes(x: float, n: int, limit: int) -> np.ndarray:
     return np.array(idxes)
 
 
-def _get_neighbor(x: float, n: int, data: np.ndarray) -> np.ndarray:
+def _get_neighbor(x: float, n: int, data: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
     """
     Pad `data` in 'edge' mode, and get n nearest elements in the padded array
     and their indexes in the original array.
@@ -169,14 +175,14 @@ def _get_neighbor(x: float, n: int, data: np.ndarray) -> np.ndarray:
 def _interpolate_1d_with_x(
     data: np.ndarray,
     scale_factor: float,
+    output_width_int: int,
     x: float,
     get_coeffs: Callable[[float, float], np.ndarray],
-    roi: np.ndarray = None,
+    roi: Optional[np.ndarray] = None,
     extrapolation_value: float = 0.0,
     coordinate_transformation_mode: str = "half_pixel",
     exclude_outside: bool = False,
 ) -> np.ndarray:
-
     input_width = len(data)
     output_width = scale_factor * input_width
     if coordinate_transformation_mode == "align_corners":
@@ -187,6 +193,8 @@ def _interpolate_1d_with_x(
     elif coordinate_transformation_mode == "asymmetric":
         x_ori = x / scale_factor
     elif coordinate_transformation_mode == "tf_crop_and_resize":
+        if roi is None:
+            raise ValueError("roi cannot be None.")
         if output_width == 1:
             x_ori = (roi[1] - roi[0]) * (input_width - 1) / 2
         else:
@@ -194,7 +202,7 @@ def _interpolate_1d_with_x(
         x_ori += roi[0] * (input_width - 1)
         # Return extrapolation_value directly as what TF CropAndResize does
         if x_ori < 0 or x_ori > input_width - 1:
-            return extrapolation_value
+            return np.array(extrapolation_value)
     elif coordinate_transformation_mode == "pytorch_half_pixel":
         if output_width == 1:
             x_ori = -0.5
@@ -202,6 +210,14 @@ def _interpolate_1d_with_x(
             x_ori = (x + 0.5) / scale_factor - 0.5
     elif coordinate_transformation_mode == "half_pixel":
         x_ori = (x + 0.5) / scale_factor - 0.5
+    elif coordinate_transformation_mode == "half_pixel_symmetric":
+        # Maps the center of the implicit ROI to the center of the output canvas.
+        # The difference with `half_pixel` will be only relevant
+        # when output_width_int != output_width
+        adjustment = output_width_int / output_width
+        center = input_width / 2
+        offset = center * (1 - adjustment)
+        x_ori = offset + (x + 0.5) / scale_factor - 0.5
     else:
         raise ValueError(
             f"Invalid coordinate_transformation_mode: {coordinate_transformation_mode!r}."
@@ -225,16 +241,17 @@ def _interpolate_1d_with_x(
                 coeffs[i] = 0
         coeffs /= sum(coeffs)
 
-    return np.dot(coeffs, points).item()
+    return np.dot(coeffs, points).item()  # type: ignore[no-any-return]
 
 
 def _interpolate_nd_with_x(
     data: np.ndarray,
     n: int,
     scale_factors: List[float],
+    output_size: List[int],
     x: List[float],
     get_coeffs: Callable[[float, float], np.ndarray],
-    roi: np.ndarray = None,
+    roi: Optional[np.ndarray] = None,
     exclude_outside: bool = False,
     **kwargs: Any,
 ) -> np.ndarray:
@@ -242,6 +259,7 @@ def _interpolate_nd_with_x(
         return _interpolate_1d_with_x(
             data,
             scale_factors[0],
+            output_size[0],
             x[0],
             get_coeffs,
             roi=roi,
@@ -254,6 +272,7 @@ def _interpolate_nd_with_x(
             data[i],
             n - 1,
             scale_factors[1:],
+            output_size[1:],
             x[1:],
             get_coeffs,
             roi=None if roi is None else np.concatenate([roi[1:n], roi[n + 1 :]]),
@@ -263,18 +282,22 @@ def _interpolate_nd_with_x(
         res1d.append(r)
 
     return _interpolate_1d_with_x(
-        res1d,
+        res1d,  # type: ignore[arg-type]  # FIXME
         scale_factors[0],
+        output_size[0],
         x[0],
         get_coeffs,
-        roi=None if roi is None else [roi[0], roi[n]],
+        roi=None if roi is None else [roi[0], roi[n]],  # type: ignore[arg-type]  # FIXME
         exclude_outside=exclude_outside,
         **kwargs,
     )
 
 
 def _get_all_coords(data: np.ndarray) -> np.ndarray:
-    return _cartesian([list(range(data.shape[i])) for i in range(len(data.shape))])
+    # FIXME: Fix input type
+    return _cartesian(
+        [list(range(data.shape[i])) for i in range(len(data.shape))]  # type: ignore[arg-type,misc]
+    )
 
 
 def _interpolate_nd(
@@ -283,13 +306,13 @@ def _interpolate_nd(
     output_size: Optional[List[int]] = None,
     scale_factors: Optional[List[float]] = None,
     axes: Optional[List[int]] = None,
-    roi: np.ndarray = None,
+    roi: Optional[np.ndarray] = None,
     keep_aspect_ratio_policy: Optional[str] = "stretch",
     exclude_outside: bool = False,
     **kwargs: Any,
 ) -> np.ndarray:
-
-    assert output_size is not None or scale_factors is not None
+    if output_size is None and scale_factors is None:
+        raise ValueError("output_size is None and scale_factors is None.")
 
     r = len(data.shape)
     if axes is not None:
@@ -311,7 +334,7 @@ def _interpolate_nd(
             for i, d in enumerate(axes):
                 new_roi[d] = roi[i]
                 new_roi[r + d] = roi[naxes + i]
-            roi = new_roi
+            roi = new_roi  # type: ignore[assignment]  # FIXME
     else:
         axes = list(range(r))
 
@@ -338,9 +361,12 @@ def _interpolate_nd(
             ]
 
     else:
-        output_size = (scale_factors * np.array(data.shape)).astype(int)
+        output_size = (scale_factors * np.array(data.shape)).astype(int)  # type: ignore[union-attr]
 
-    assert scale_factors is not None
+    if scale_factors is None:
+        raise ValueError("scale_factors is None.")
+    if output_size is None:
+        raise ValueError("output_size is None.")
 
     ret = np.zeros(output_size)
     for x in _get_all_coords(ret):
@@ -348,6 +374,7 @@ def _interpolate_nd(
             data,
             len(data.shape),
             scale_factors,
+            output_size,
             x,
             get_coeffs,
             roi=roi,
@@ -380,14 +407,18 @@ class Resize(OpRun):
                     f"antilias={antialias!r} is not supported for mode={mode!r}."
                 )
             if nearest_mode is not None:
-                fct = lambda x, scale_factor: _nearest_coeffs(  # noqa
-                    x, mode=nearest_mode
-                )
+
+                def fct(x, scale_factor):
+                    return _nearest_coeffs(x, mode=nearest_mode)
+
             else:
                 fct = _nearest_coeffs
         elif mode == "cubic":
             fct_ = _cubic_coeffs_antialias if antialias else _cubic_coeffs
-            fct = lambda x, scale: fct_(x, scale, A=cubic_coeff_a)  # noqa
+
+            def fct(x, scale):
+                return fct_(x, scale, A=cubic_coeff_a)
+
         elif mode == "linear":
             fct = _linear_coeffs_antialias if antialias else _linear_coeffs
         else:
@@ -411,7 +442,7 @@ class Resize(OpRun):
         not_axes = [a for a in range(len(X.shape)) if a not in axes]
         perm = tuple(not_axes + axes)
         permuted = np.transpose(X, perm)
-        new_shape = (-1,) + tuple(X.shape[a] for a in axes)
+        new_shape = (-1, *tuple(X.shape[a] for a in axes))
         reshaped = permuted.reshape(new_shape)
         res = None
         for i in range(reshaped.shape[0]):
@@ -427,7 +458,7 @@ class Resize(OpRun):
                 extrapolation_value=extrapolation_value,  # type: ignore
             ).astype(X.dtype)
             if res is None:
-                res = np.empty((reshaped.shape[0],) + output.shape, dtype=output.dtype)
+                res = np.empty((reshaped.shape[0], *output.shape), dtype=output.dtype)
             res[i] = output
 
         res_reshaped = res.reshape((tuple(X.shape[a] for a in not_axes) + res[0].shape))  # type: ignore

onnx/reference/ops/op_reverse_sequence.py

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

onnx/reference/ops/op_rnn.py

@@ -1,9 +1,10 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0913,R0914,W0221,W0613
 
 import numpy as np
 
-from onnx.defs import onnx_opset_version
 from onnx.reference.op_run import OpRun
 
 
@@ -132,20 +133,13 @@ class CommonRNN(OpRun):
             Y = np.transpose(Y, [2, 0, 1, 3])
             Y_h = Y[:, :, -1, :]
 
+        Y = Y.astype(X.dtype)
         return (Y,) if self.n_outputs == 1 else (Y, Y_h)
 
 
 class RNN_7(CommonRNN):
-
     pass
 
 
 class RNN_14(CommonRNN):
-
     pass
-
-
-if onnx_opset_version() >= 14:
-    RNN = RNN_14
-else:
-    RNN = RNN_7  # type: ignore

onnx/reference/ops/op_roi_align.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0902,R0912,R0913,R0914,R0915,R1702,W0221
 
@@ -25,7 +27,7 @@ class PreCalc:
 
 class RoiAlign(OpRun):
     @staticmethod
-    def PreCalcForBilinearInterpolate(  # type: ignore
+    def pre_calc_for_bilinear_interpolate(  # type: ignore
         height: int,
         width: int,
         pooled_height: int,
@@ -114,7 +116,7 @@ class RoiAlign(OpRun):
                         pre_calc_index += 1
 
     @staticmethod
-    def RoiAlignForward(  # type: ignore
+    def roi_align_forward(  # type: ignore
         output_shape: Tuple[int, int, int, int],
         bottom_data,
         spatial_scale,
@@ -181,7 +183,7 @@ class RoiAlign(OpRun):
                     roi_bin_grid_h * roi_bin_grid_w * pooled_width * pooled_height
                 )
             ]
-            RoiAlign.PreCalcForBilinearInterpolate(
+            RoiAlign.pre_calc_for_bilinear_interpolate(
                 height,
                 width,
                 pooled_height,
@@ -285,7 +287,7 @@ class RoiAlign(OpRun):
         y_dims = (num_rois, num_channels, output_height, output_width)
         Y = np.empty(y_dims, dtype=X.dtype).flatten()
 
-        self.RoiAlignForward(
+        self.roi_align_forward(
             y_dims,
             X.flatten(),
             spatial_scale,
@@ -299,4 +301,4 @@ class RoiAlign(OpRun):
             coordinate_transformation_mode.lower() == "half_pixel",
             batch_indices.flatten(),
         )
-        return (Y.reshape((y_dims)),)
+        return (Y.reshape((y_dims)).astype(X.dtype),)

onnx/reference/ops/op_round.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 Round(OpRunUnaryNum):
     def _run(self, x):  # type: ignore
-        return (np.round(x),)
+        return (np.round(x).astype(x.dtype),)

onnx/reference/ops/op_scan.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0912,R0914,W0221,W0613
 
@@ -94,7 +96,8 @@ class Scan(OpRun):
         scan_input_axes=None,
         scan_input_directions=None,
         scan_output_axes=None,
-        scan_output_directions,
+        scan_output_directions=None,
+        attributes=None,
     ):
         # TODO: support overridden attributes.
         (

onnx/reference/ops/op_scatter_elements.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=C3001,R0912,R0913,R0914,R0915,W0108,W0221
 
@@ -16,13 +18,24 @@ def scatter_elements(data, indices, updates, axis=0, reduction=None):  # type: i
         // and so on
     """
     if reduction == "add":
-        f = lambda x, y: x + y  # noqa
+
+        def f(x, y):
+            return x + y
+
     elif reduction == "min":
-        f = lambda x, y: min(x, y)  # noqa
+
+        def f(x, y):
+            return min(x, y)
+
     elif reduction == "max":
-        f = lambda x, y: max(x, y)  # noqa
+
+        def f(x, y):
+            return max(x, y)
+
     else:
-        f = lambda x, y: y  # noqa
+
+        def f(x, y):  # pylint: disable=unused-argument
+            return y
 
     if axis < 0:
         axis = data.ndim + axis

onnx/reference/ops/op_scatternd.py

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

onnx/reference/ops/op_selu.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -8,4 +10,6 @@ from onnx.reference.op_run import OpRun
 
 class Selu(OpRun):
     def _run(self, x, alpha=None, gamma=None):  # type: ignore
-        return (np.where(x > 0, x, np.exp(x) * alpha - alpha) * gamma,)
+        return (
+            (np.where(x > 0, x, np.exp(x) * alpha - alpha) * gamma).astype(x.dtype),
+        )

onnx/reference/ops/op_sequence_at.py

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

onnx/reference/ops/op_sequence_construct.py

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

onnx/reference/ops/op_sequence_empty.py

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

onnx/reference/ops/op_sequence_erase.py

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

onnx/reference/ops/op_sequence_insert.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -40,11 +42,11 @@ class SequenceInsert(OpRun):
         if ind is None:
             res = sequence_insert_reference_implementation(S, T)
         elif isinstance(ind, int):
-            res = sequence_insert_reference_implementation(S, T, [ind])
+            res = sequence_insert_reference_implementation(S, T, [ind])  # type: ignore[arg-type]
         elif len(ind.shape) > 0:
             res = sequence_insert_reference_implementation(S, T, ind)
         elif len(ind.shape) == 0:
-            res = sequence_insert_reference_implementation(S, T, [int(ind)])
+            res = sequence_insert_reference_implementation(S, T, [int(ind)])  # type: ignore[arg-type]
         else:
             res = sequence_insert_reference_implementation(S, T)
         return (res,)

onnx/reference/ops/op_sequence_length.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -8,4 +10,8 @@ from onnx.reference.op_run import OpRun
 
 class SequenceLength(OpRun):
     def _run(self, input_sequence):  # type: ignore
-        return (np.array(len(input_sequence)),)
+        if not isinstance(input_sequence, list):
+            raise TypeError(
+                f"input_sequence must be a list not {type(input_sequence)}."
+            )
+        return (np.array(len(input_sequence), dtype=np.int64),)

onnx/reference/ops/op_sequence_map.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -5,7 +7,7 @@ from onnx.reference.op_run import OpRun
 
 
 class SequenceMap(OpRun):
-    def _run(self, input_sequence, *additional_inputs, body=None):  # type: ignore
+    def _run(self, input_sequence, *additional_inputs, body=None, attributes=None):  # type: ignore
         if len(additional_inputs) == 1 and isinstance(additional_inputs[0], list):
             res = None
             for obj1, obj2 in zip(input_sequence, additional_inputs[0]):
@@ -22,7 +24,7 @@ class SequenceMap(OpRun):
         res = None
         for obj in input_sequence:
             feeds[body.input_names[0]] = obj
-            r = body.run(None, feeds)
+            r = body.run(None, feeds, attributes=attributes)
             if res is None:
                 res = [[i] for i in r]
             else:

onnx/reference/ops/op_shape.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -5,7 +7,6 @@ from typing import Optional, Tuple
 
 import numpy as np
 
-from onnx.defs import onnx_opset_version
 from onnx.reference.op_run import OpRun
 
 
@@ -36,9 +37,3 @@ class Shape_15(Shape_1):
         if ab is None:
             return (np.array(data.shape, dtype=np.int64),)
         return (np.array(data.shape[ab[0] : ab[1]], dtype=np.int64),)
-
-
-if onnx_opset_version() >= 15:
-    Shape = Shape_15
-else:
-    Shape = Shape_1  # type: ignore

onnx/reference/ops/op_shrink.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=E1130,W0221
 
@@ -13,5 +15,5 @@ class Shrink(OpRun):
                 x < -lambd,
                 x + bias,
                 np.where(x > lambd, x - bias, 0),
-            ),
+            ).astype(x.dtype),
         )