onnx 1.18.0__cp313-cp313-macosx_12_0_universal2.whl → 1.19.1rc1__cp313-cp313-macosx_12_0_universal2.whl

onnx/backend/test/case/node/castlike.py

@@ -3,22 +3,23 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
-import sys
+import itertools
 
 import numpy as np
 
 import onnx
-from onnx import TensorProto, helper
+from onnx import TensorProto
 from onnx.backend.test.case.base import Base
 from onnx.backend.test.case.node import expect
-from onnx.helper import float32_to_float8e4m3, float32_to_float8e5m2, make_tensor
-from onnx.numpy_helper import float8e4m3_to_float32, float8e5m2_to_float32
+from onnx.helper import make_tensor, tensor_dtype_to_np_dtype
+
+F8_TYPES = frozenset({"FLOAT8E4M3FN", "FLOAT8E4M3FNUZ", "FLOAT8E5M2", "FLOAT8E5M2FNUZ"})
+FOUR_BIT_TYPES = frozenset({"UINT4", "INT4", "FLOAT4E2M1"})
 
 
 class CastLike(Base):
     @staticmethod
     def export() -> None:
-        shape = (3, 4)
         test_cases = [
             ("FLOAT", "FLOAT16"),
             ("FLOAT", "DOUBLE"),
@@ -26,26 +27,51 @@ class CastLike(Base):
             ("FLOAT16", "DOUBLE"),
             ("DOUBLE", "FLOAT"),
             ("DOUBLE", "FLOAT16"),
-            ("FLOAT", "STRING"),
-            ("STRING", "FLOAT"),
             ("FLOAT", "BFLOAT16"),
             ("BFLOAT16", "FLOAT"),
             ("FLOAT", "FLOAT8E4M3FN"),
+            ("FLOAT16", "FLOAT8E4M3FN"),
             ("FLOAT", "FLOAT8E4M3FNUZ"),
+            ("FLOAT16", "FLOAT8E4M3FNUZ"),
             ("FLOAT8E4M3FN", "FLOAT"),
+            ("FLOAT8E4M3FN", "FLOAT16"),
             ("FLOAT8E4M3FNUZ", "FLOAT"),
+            ("FLOAT8E4M3FNUZ", "FLOAT16"),
             ("FLOAT", "FLOAT8E5M2"),
+            ("FLOAT16", "FLOAT8E5M2"),
             ("FLOAT", "FLOAT8E5M2FNUZ"),
+            ("FLOAT16", "FLOAT8E5M2FNUZ"),
             ("FLOAT8E5M2", "FLOAT"),
+            ("FLOAT8E5M2", "FLOAT16"),
             ("FLOAT8E5M2FNUZ", "FLOAT"),
+            ("FLOAT8E5M2FNUZ", "FLOAT16"),
+            ("FLOAT", "UINT4"),
+            ("FLOAT16", "UINT4"),
+            ("FLOAT", "INT4"),
+            ("FLOAT16", "INT4"),
+            ("UINT4", "FLOAT"),
+            ("UINT4", "FLOAT16"),
+            ("UINT4", "UINT8"),
+            ("INT4", "FLOAT"),
+            ("INT4", "FLOAT16"),
+            ("INT4", "INT8"),
+            ("FLOAT4E2M1", "FLOAT"),
+            ("FLOAT4E2M1", "FLOAT16"),
+            ("FLOAT", "FLOAT4E2M1"),
+            ("FLOAT16", "FLOAT4E2M1"),
         ]
 
-        vect_float32_to_float8e4m3 = np.vectorize(float32_to_float8e4m3)
-        vect_float32_to_float8e5m2 = np.vectorize(float32_to_float8e5m2)
+        f8_types = {"FLOAT8E4M3FN", "FLOAT8E4M3FNUZ", "FLOAT8E5M2", "FLOAT8E5M2FNUZ"}
 
         for from_type, to_type in test_cases:
-            input_type_proto = None
-            output_type_proto = None
+            if from_type == to_type:
+                # Skip cases where from_type and to_type are the same
+                continue
+            from_dtype = getattr(TensorProto, from_type)
+            to_dtype = getattr(TensorProto, to_type)
+            from_np_dtype = tensor_dtype_to_np_dtype(from_dtype)
+            to_np_dtype = tensor_dtype_to_np_dtype(to_dtype)
+
             if from_type == "BFLOAT16" or to_type == "BFLOAT16":
                 np_fp32 = np.array(
                     [
@@ -64,50 +90,9 @@ class CastLike(Base):
                     ],
                     dtype=np.float32,
                 )
-                little_endisan = sys.byteorder == "little"
-                np_uint16_view = np_fp32.view(dtype=np.uint16)
-                np_bfp16 = (
-                    np_uint16_view[1::2] if little_endisan else np_uint16_view[0::2]
-                )
-                if to_type == "BFLOAT16":
-                    assert from_type == "FLOAT"
-                    input = np_fp32.reshape([3, 4])
-                    output = np_bfp16.reshape([3, 4])
-                    input_type_proto = onnx.helper.make_tensor_type_proto(
-                        int(TensorProto.FLOAT), input.shape
-                    )
-                    output_type_proto = onnx.helper.make_tensor_type_proto(
-                        int(TensorProto.BFLOAT16), output.shape
-                    )
-                else:
-                    assert to_type == "FLOAT"
-                    input = np_bfp16.reshape([3, 4])
-                    # convert bfloat to FLOAT
-                    np_fp32_zeros = np.zeros((len(np_bfp16) * 2,), dtype=np.uint16)
-                    if little_endisan:
-                        np_fp32_zeros[1::2] = np_bfp16
-                    else:
-                        np_fp32_zeros[0::2] = np_bfp16
-                    np_fp32_from_bfloat = np_fp32_zeros.view(dtype=np.float32)
-                    output = np_fp32_from_bfloat.reshape([3, 4])
-                    input_type_proto = onnx.helper.make_tensor_type_proto(
-                        int(TensorProto.BFLOAT16), input.shape
-                    )
-                    output_type_proto = onnx.helper.make_tensor_type_proto(
-                        int(TensorProto.FLOAT), output.shape
-                    )
-                like = output.flatten()[0:1]
-            elif from_type in (
-                "FLOAT8E4M3FN",
-                "FLOAT8E4M3FNUZ",
-                "FLOAT8E5M2",
-                "FLOAT8E5M2FNUZ",
-            ) or to_type in (
-                "FLOAT8E4M3FN",
-                "FLOAT8E4M3FNUZ",
-                "FLOAT8E5M2",
-                "FLOAT8E5M2FNUZ",
-            ):
+                input_shape = (3, 4)
+
+            elif from_type in f8_types or to_type in f8_types:
                 np_fp32 = np.array(
                     [
                         "0.47892547",
@@ -115,87 +100,48 @@ class CastLike(Base):
                         "0.49968487",
                         "0.81910545",
                         "0.47031248",
-                        "0.816468",
-                        "0.21087195",
                         "0.7229038",
+                        "1000000",
+                        "1e-7",
                         "NaN",
                         "INF",
                         "+INF",
                         "-INF",
+                        "-0.0000001",
+                        "0.0000001",
+                        "-1000000",
                     ],
                     dtype=np.float32,
                 )
-                if to_type == "FLOAT8E4M3FN":
-                    expected = float8e4m3_to_float32(
-                        vect_float32_to_float8e4m3(np_fp32)
-                    )
-                    expected_tensor = make_tensor(
-                        "x", TensorProto.FLOAT8E4M3FN, [3, 4], expected.tolist()
-                    )
-                    like_tensor = make_tensor(
-                        "x", TensorProto.FLOAT8E4M3FN, [1], expected[:1]
-                    )
-                elif to_type == "FLOAT8E4M3FNUZ":
-                    expected = float8e4m3_to_float32(
-                        vect_float32_to_float8e4m3(np_fp32, uz=True), uz=True
-                    )
-                    expected_tensor = make_tensor(
-                        "x", TensorProto.FLOAT8E4M3FNUZ, [3, 4], expected.tolist()
-                    )
-                    like_tensor = make_tensor(
-                        "x", TensorProto.FLOAT8E4M3FNUZ, [1], expected[:1]
-                    )
-                elif to_type == "FLOAT8E5M2":
-                    expected = float8e5m2_to_float32(
-                        vect_float32_to_float8e5m2(np_fp32)
-                    )
-                    expected_tensor = make_tensor(
-                        "x", TensorProto.FLOAT8E5M2, [3, 4], expected.tolist()
-                    )
-                    like_tensor = make_tensor(
-                        "x", TensorProto.FLOAT8E5M2, [1], expected[:1]
-                    )
-                elif to_type == "FLOAT8E5M2FNUZ":
-                    expected = float8e5m2_to_float32(
-                        vect_float32_to_float8e5m2(np_fp32, fn=True, uz=True),
-                        fn=True,
-                        uz=True,
-                    )
-                    expected_tensor = make_tensor(
-                        "x", TensorProto.FLOAT8E5M2FNUZ, [3, 4], expected.tolist()
-                    )
-                    like_tensor = make_tensor(
-                        "x", TensorProto.FLOAT8E5M2FNUZ, [1], expected[:1]
-                    )
-                if from_type == "FLOAT":
-                    input = np_fp32.reshape((3, 4))
-                    output = expected_tensor
-                    like = like_tensor
-                else:
-                    assert to_type == "FLOAT"
-                    input = expected_tensor
-                    output = expected.reshape((3, 4))
-                    like = output.flatten()[:1]
-            elif from_type != "STRING":
-                input = np.random.random_sample(shape).astype(
-                    helper.tensor_dtype_to_np_dtype(getattr(TensorProto, from_type))
+                input_shape = (3, 5)
+            elif from_type in ("UINT4", "INT4") or to_type in ("UINT4", "INT4"):
+                np_fp32 = np.arange(-9, 16).astype(np.float32)
+                input_shape = (5, 5)
+            elif from_type == "FLOAT4E2M1" or to_type == "FLOAT4E2M1":
+                np_fp32 = np.array(
+                    [
+                        "0.48",
+                        "0.25",
+                        "1.05",
+                        "-3.5",
+                        "-8",
+                        "9",
+                        "1000000",
+                        "1e-7",
+                        "NaN",
+                        "INF",
+                        "+INF",
+                        "-INF",
+                        "-4",
+                        "0.01",
+                        "-0.0",
+                    ],
+                    dtype=np.float32,
                 )
-                if to_type == "STRING":
-                    # Converting input to str, then give it object dtype for generating script
-                    ss = []
-                    for i in input.flatten():
-                        s = str(i).encode("utf-8")
-                        su = s.decode("utf-8")
-                        ss.append(su)
-
-                    output = np.array(ss).astype(object).reshape([3, 4])
-                else:
-                    output = input.astype(
-                        helper.tensor_dtype_to_np_dtype(getattr(TensorProto, to_type))
-                    )
-                like = output.flatten()[0:1]
+                input_shape = (3, 5)
+
             else:
-                input = np.array(
+                np_fp32 = np.array(
                     [
                         "0.47892547",
                         "0.48033667",
@@ -210,34 +156,136 @@ class CastLike(Base):
                         "+INF",
                         "-INF",
                     ],
-                    dtype=np.dtype(object),
+                    dtype=np.float32,
                 ).reshape([3, 4])
-                output = input.astype(
-                    helper.tensor_dtype_to_np_dtype(getattr(TensorProto, to_type))
+                input_shape = (3, 4)
+
+            if from_type in F8_TYPES:
+                np_from = onnx.numpy_helper.saturate_cast(np_fp32, from_np_dtype)
+                input = make_tensor(
+                    "input",
+                    from_dtype,
+                    input_shape,
+                    vals=np_from,
+                    raw=True,
+                )
+            elif from_type in FOUR_BIT_TYPES:
+                np_from = np_fp32.astype(from_np_dtype)
+                packed = onnx.numpy_helper._pack_4bitx2(np_from)
+                input = make_tensor(
+                    "input", from_dtype, input_shape, vals=packed.tobytes(), raw=True
+                )
+            else:
+                np_from = np_fp32.astype(from_np_dtype)
+                input = make_tensor(
+                    "input", from_dtype, input_shape, vals=np_from, raw=True
+                )
+
+            if to_type in F8_TYPES:
+                output = make_tensor(
+                    "output",
+                    to_dtype,
+                    input_shape,
+                    vals=onnx.numpy_helper.saturate_cast(np_from, to_np_dtype),
+                    raw=True,
                 )
-                like = output.flatten()[0:1]
+            elif to_type in FOUR_BIT_TYPES:
+                packed = onnx.numpy_helper._pack_4bitx2(np_from.astype(to_np_dtype))
+                output = make_tensor(
+                    "output", to_dtype, input_shape, vals=packed.tobytes(), raw=True
+                )
+            else:
+                output = make_tensor(
+                    "output",
+                    to_dtype,
+                    input_shape,
+                    vals=np_from.astype(to_np_dtype),
+                    raw=True,
+                )
+
+            like = make_tensor("like", to_dtype, (0,), vals=[])
+
             node = onnx.helper.make_node(
                 "CastLike",
                 inputs=["input", "like"],
                 outputs=["output"],
             )
-            if input_type_proto and output_type_proto:
-                like_type_proto = onnx.helper.make_tensor_type_proto(
-                    output_type_proto.tensor_type.elem_type, like.shape
-                )
 
-                expect(
-                    node,
-                    inputs=[input, like],
-                    outputs=[output],
-                    name="test_castlike_" + from_type + "_to_" + to_type,
-                    input_type_protos=[input_type_proto, like_type_proto],
-                    output_type_protos=[output_type_proto],
-                )
-            else:
-                expect(
-                    node,
-                    inputs=[input, like],
-                    outputs=[output],
-                    name="test_castlike_" + from_type + "_to_" + to_type,
-                )
+            expect(
+                node,
+                inputs=[input, like],
+                outputs=[output],
+                name="test_castlike_" + from_type + "_to_" + to_type,
+            )
+
+    @staticmethod
+    def export_saturate_false() -> None:
+        test_cases = itertools.product(
+            [
+                "FLOAT",
+                "FLOAT16",
+            ],
+            [
+                "FLOAT8E4M3FN",
+                "FLOAT8E4M3FNUZ",
+                "FLOAT8E5M2",
+                "FLOAT8E5M2FNUZ",
+            ],
+        )
+        input_shape = (3, 5)
+        for from_type, to_type in test_cases:
+            from_dtype = getattr(TensorProto, from_type)
+            to_dtype = getattr(TensorProto, to_type)
+            from_np_dtype = tensor_dtype_to_np_dtype(from_dtype)
+            to_np_dtype = tensor_dtype_to_np_dtype(to_dtype)
+            np_fp32 = np.array(
+                [
+                    "0.47892547",
+                    "0.48033667",
+                    "0.49968487",
+                    "0.81910545",
+                    "0.47031248",
+                    "0.7229038",
+                    "1000000",
+                    "1e-7",
+                    "NaN",
+                    "INF",
+                    "+INF",
+                    "-INF",
+                    "-0.0000001",
+                    "0.0000001",
+                    "-1000000",
+                ],
+                dtype=np.float32,
+            )
+
+            input = make_tensor(
+                "input",
+                from_dtype,
+                input_shape,
+                vals=np_fp32.astype(from_np_dtype),
+                raw=True,
+            )
+            output = make_tensor(
+                "output",
+                to_dtype,
+                input_shape,
+                vals=np_fp32.astype(from_np_dtype).astype(to_np_dtype),
+                raw=True,
+            )
+
+            like = make_tensor("like", to_dtype, (0,), vals=[])
+
+            node = onnx.helper.make_node(
+                "CastLike",
+                inputs=["input", "like"],
+                outputs=["output"],
+                saturate=0,
+            )
+
+            expect(
+                node,
+                inputs=[input, like],
+                outputs=[output],
+                name="test_castlike_no_saturate_" + from_type + "_to_" + to_type,
+            )

onnx/backend/test/case/node/einsum.py

@@ -79,3 +79,15 @@ class Einsum(Base):
         Z = einsum_reference_implementation(Eqn, (X, Y))
 
         expect(node, inputs=[X, Y], outputs=[Z], name="test_einsum_batch_matmul")
+
+    @staticmethod
+    def export_einsum_scalar() -> None:
+        Eqn = "->"
+        node = onnx.helper.make_node(
+            "Einsum", inputs=["x"], outputs=["y"], equation=Eqn
+        )
+
+        X = np.array(5.0)  # scalar input
+        Z = einsum_reference_implementation(Eqn, (X,))
+
+        expect(node, inputs=[X], outputs=[Z], name="test_einsum_scalar")

onnx/backend/test/case/node/gathernd.py

@@ -25,7 +25,7 @@ def gather_nd_impl(
     # The number of elements in the batch_dims for data/indice array
     batch_dims_size = 1
 
-    # Check the shape of indice and data are identicial for batch dims.
+    # Check the shape of indice and data are identical for batch dims.
     for i in range(batch_dims):
         batch_dims_shape.append(indices.shape[i])
         batch_dims_size *= indices.shape[i]
@@ -48,7 +48,7 @@ def gather_nd_impl(
     reshaped_indices = indices.reshape(batch_dims_size, -1, indices.shape[-1])
 
     # Flatten 'data' to array of shape (batch_dim_size, data.shape[batch_dimes:])
-    reshaped_data = data.reshape((batch_dims_size,) + data.shape[batch_dims:])
+    reshaped_data = data.reshape((batch_dims_size, *data.shape[batch_dims:]))
 
     # gather each scalar value from 'data'
     for batch_dim in range(reshaped_indices.shape[0]):

onnx/backend/test/case/node/image_decoder.py

@@ -50,7 +50,7 @@ def _generate_test_data(
     tile_sz: int = 5,
 ) -> tuple[np.ndarray, np.ndarray]:
     try:
-        import PIL.Image
+        import PIL.Image  # noqa: PLC0415
     except ImportError:
         # Since pillow is not installed to generate test data for the ImageDecoder operator
         # directly use the frozen data from _image_decoder_data.py.

onnx/backend/test/case/node/layernormalization.py

@@ -23,7 +23,7 @@ def _layer_normalization(X, W, B, axis=-1, epsilon=1e-5):
     reduction_shape = X_shape[0:axis] + (1,) * unsqueezed_rank
 
     # Parameter used to convert N-D tensor layer
-    # normalization to equivalent 2-D matirx operations.
+    # normalization to equivalent 2-D matrix operations.
     row_number = 1
     col_number = 1
     for i in range(X_rank):

onnx/backend/test/case/node/lpnormalization.py

@@ -0,0 +1,79 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class LpNormalization(Base):
+    @staticmethod
+    def export_l2normalization_axis_0() -> None:
+        node = onnx.helper.make_node(
+            "LpNormalization", inputs=["x"], outputs=["y"], axis=0, p=2
+        )
+        x = np.array(
+            [[[1.0, 2.0, 2.0], [3.0, 4.0, 0.0]], [[0.0, 5.0, 5.0], [6.0, 8.0, 0.0]]],
+            dtype=np.float32,
+        )
+        l2_norm_axis_0 = np.sqrt(np.sum(x**2, axis=0, keepdims=True))
+        y = x / l2_norm_axis_0
+        expect(node, inputs=[x], outputs=[y], name="test_l2normalization_axis_0")
+
+    @staticmethod
+    def export_l2normalization_axis_1() -> None:
+        node = onnx.helper.make_node(
+            "LpNormalization", inputs=["x"], outputs=["y"], axis=1, p=2
+        )
+        x = np.array([[3.0, 4.0], [6.0, 8.0]], dtype=np.float32)
+        l2_norm_axis_1 = np.sqrt(np.sum(x**2, axis=1, keepdims=True))
+        y = x / l2_norm_axis_1
+        expect(node, inputs=[x], outputs=[y], name="test_l2normalization_axis_1")
+
+    @staticmethod
+    def export_l1normalization_axis_0() -> None:
+        node = onnx.helper.make_node(
+            "LpNormalization", inputs=["x"], outputs=["y"], axis=0, p=1
+        )
+        x = np.array([3.0, 4.0], dtype=np.float32)
+        l1_norm_axis_0 = np.sum(abs(x), axis=0, keepdims=True)
+        y = x / l1_norm_axis_0
+        expect(node, inputs=[x], outputs=[y], name="test_l1normalization_axis_0")
+
+    @staticmethod
+    def export_l1normalization_axis_1() -> None:
+        node = onnx.helper.make_node(
+            "LpNormalization", inputs=["x"], outputs=["y"], axis=1, p=1
+        )
+        x = np.array([[3.0, 4.0], [6.0, 8.0]], dtype=np.float32)
+        l1_norm_axis_1 = np.sum(abs(x), axis=1, keepdims=True)
+        y = x / l1_norm_axis_1
+        expect(node, inputs=[x], outputs=[y], name="test_l1normalization_axis_1")
+
+    @staticmethod
+    def export_l1normalization_axis_last() -> None:
+        node = onnx.helper.make_node(
+            "LpNormalization", inputs=["x"], outputs=["y"], axis=-1, p=1
+        )
+        x = np.array(
+            [[[1.0, 2.0, 2.0], [3.0, 4.0, 0.0]], [[0.0, 5.0, 5.0], [6.0, 8.0, 0.0]]],
+            dtype=np.float32,
+        )
+        l1_norm_axis_last = np.sum(abs(x), axis=-1, keepdims=True)
+        y = x / l1_norm_axis_last
+        expect(node, inputs=[x], outputs=[y], name="test_l1normalization_axis_last")
+
+    @staticmethod
+    def export_default() -> None:
+        node = onnx.helper.make_node("LpNormalization", inputs=["x"], outputs=["y"])
+        x = np.array(
+            [[[1.0, 2.0, 2.0], [3.0, 4.0, 0.0]], [[0.0, 5.0, 5.0], [6.0, 8.0, 0.0]]],
+            dtype=np.float32,
+        )
+        lp_norm_default = np.sqrt(np.sum(x**2, axis=-1, keepdims=True))
+        y = x / lp_norm_default
+        expect(node, inputs=[x], outputs=[y], name="test_lpnormalization_default")

onnx/backend/test/case/node/lrn.py

@@ -34,8 +34,8 @@ class LRN(Base):
             square_sum[n, c, h, w] = sum(
                 x[
                     n,
-                    max(0, c - int(math.floor((nsize - 1) / 2))) : min(
-                        5, c + int(math.ceil((nsize - 1) / 2)) + 1
+                    max(0, c - math.floor((nsize - 1) / 2)) : min(
+                        5, c + math.ceil((nsize - 1) / 2) + 1
                     ),
                     h,
                     w,
@@ -58,8 +58,8 @@ class LRN(Base):
             square_sum[n, c, h, w] = sum(
                 x[
                     n,
-                    max(0, c - int(math.floor((nsize - 1) / 2))) : min(
-                        5, c + int(math.ceil((nsize - 1) / 2)) + 1
+                    max(0, c - math.floor((nsize - 1) / 2)) : min(
+                        5, c + math.ceil((nsize - 1) / 2) + 1
                     ),
                     h,
                     w,

onnx/backend/test/case/node/quantizelinear.py

@@ -234,7 +234,7 @@ class QuantizeLinear(Base):
             "y_zero_point", TensorProto.UINT4, y_scale.shape, np.ones_like(y_scale)
         )
         y = make_tensor(
-            "y", TensorProto.UINT4, x.shape, [1, 2, 3, 5, -1, -1, 3, 4, 4, 5, 5, 11]
+            "y", TensorProto.UINT4, x.shape, [1, 2, 3, 5, 0, 0, 3, 4, 4, 5, 5, 11]
         )
 
         expect(

onnx/backend/test/case/node/rotaryembedding.py

@@ -106,8 +106,8 @@ class RotaryEmbedding(Base):
 
         input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
         position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64)
-        sin_cache_data = np.random.rand(50, 4).astype(np.float32)
-        cos_cache_data = np.random.rand(50, 4).astype(np.float32)
+        sin_cache_data = np.random.rand(50, 2).astype(np.float32)
+        cos_cache_data = np.random.rand(50, 2).astype(np.float32)
 
         expected_output = rotary_embedding(
             input_data,
@@ -136,8 +136,8 @@ class RotaryEmbedding(Base):
 
         input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
         position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64)
-        sin_cache_data = np.random.rand(50, 4).astype(np.float32)
-        cos_cache_data = np.random.rand(50, 4).astype(np.float32)
+        sin_cache_data = np.random.rand(50, 2).astype(np.float32)
+        cos_cache_data = np.random.rand(50, 2).astype(np.float32)
 
         expected_output = rotary_embedding(
             input_data,
@@ -213,8 +213,8 @@ class RotaryEmbedding(Base):
         )
 
         input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
-        sin_cache_data = np.random.rand(2, 3, 4).astype(np.float32)
-        cos_cache_data = np.random.rand(2, 3, 4).astype(np.float32)
+        sin_cache_data = np.random.rand(2, 3, 2).astype(np.float32)
+        cos_cache_data = np.random.rand(2, 3, 2).astype(np.float32)
 
         expected_output = rotary_embedding(
             input_data,

onnx/backend/test/case/node/shape.py

@@ -56,3 +56,5 @@ class Shape(Base):
         test_shape("_clip_start", x, start=-10)
 
         test_shape("_clip_end", x, end=10)
+
+        test_shape("_start_greater_than_end", x, start=2, end=1)

onnx/backend/test/case/node/split.py

@@ -145,7 +145,7 @@ class Split(Base):
         # 1-dimensional tensor with dimension_size=0
         node_input = np.array([]).astype(np.float32)
 
-        # Split emtpy tensor to tensors of size zero
+        # Split empty tensor to tensors of size zero
         split = np.array([0, 0, 0]).astype(np.int64)
         node = onnx.helper.make_node(
             "Split",
@@ -302,7 +302,7 @@ class Split(Base):
         # 1-dimensional tensor with dimension_size=0
         node_input = np.array([]).astype(np.float32)
 
-        # Split emtpy tensor to tensors of size zero
+        # Split empty tensor to tensors of size zero
         split = np.array([0, 0, 0]).astype(np.int64)
         node = onnx.helper.make_node(
             "Split",