onnx 1.17.0__cp39-cp39-win_amd64.whl → 1.19.0__cp39-cp39-win_amd64.whl

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

@@ -0,0 +1,126 @@
+# 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
+from onnx.reference.ops.op_rms_normalization import _rms_normalization
+
+
+def calculate_normalized_shape(x_shape, axis):
+    rank = len(x_shape)
+    if axis < 0:
+        axis = axis + rank
+    return x_shape[axis:]
+
+
+class RMSNormalization(Base):
+    @staticmethod
+    def export() -> None:
+        X = np.random.randn(2, 3, 4, 5).astype(np.float32)
+
+        def case(axis: int) -> None:
+            normalized_shape = calculate_normalized_shape(X.shape, axis)
+            W = np.random.randn(*normalized_shape).astype(np.float32)
+            Y = _rms_normalization(X, W, axis=axis)
+
+            node = onnx.helper.make_node(
+                "RMSNormalization",
+                inputs=["X", "W"],
+                outputs=["Y"],
+                axis=axis,
+            )
+
+            if axis < 0:
+                name = f"test_rms_normalization_4d_axis_negative_{-axis}"
+            else:
+                name = f"test_rms_normalization_4d_axis{axis}"
+
+            expect(node, inputs=[X, W], outputs=[Y], name=name)
+
+        for i in range(len(X.shape)):
+            case(i)
+            case(i - len(X.shape))
+
+    @staticmethod
+    def export_default_axis() -> None:
+        X = np.random.randn(2, 3, 4, 5).astype(np.float32)
+
+        # Default axis in RMSNormalization is -1.
+        normalized_shape = calculate_normalized_shape(X.shape, -1)
+        W = np.random.randn(*normalized_shape).astype(np.float32)
+        # Axis is default to -1 in the reference implementation.
+        Y = _rms_normalization(X, W)
+
+        # Not specifying axis attribute means -1.
+        node = onnx.helper.make_node(
+            "RMSNormalization",
+            inputs=["X", "W"],
+            outputs=["Y"],
+        )
+
+        expect(
+            node,
+            inputs=[X, W],
+            outputs=[Y],
+            name="test_rms_normalization_default_axis",
+        )
+
+    @staticmethod
+    def export2d() -> None:
+        X = np.random.randn(3, 4).astype(np.float32)
+
+        def case(axis: int) -> None:
+            normalized_shape = calculate_normalized_shape(X.shape, axis)
+            W = np.random.randn(*normalized_shape).astype(np.float32)
+            Y = _rms_normalization(X, W, axis=axis)
+
+            node = onnx.helper.make_node(
+                "RMSNormalization",
+                inputs=["X", "W"],
+                outputs=["Y"],
+                axis=axis,
+            )
+
+            if axis < 0:
+                name = f"test_rms_normalization_2d_axis_negative_{-axis}"
+            else:
+                name = f"test_rms_normalization_2d_axis{axis}"
+
+            expect(node, inputs=[X, W], outputs=[Y], name=name)
+
+        for i in range(len(X.shape)):
+            case(i)
+            case(i - len(X.shape))
+
+    @staticmethod
+    def export3d_epsilon() -> None:
+        epsilon = 1e-1
+        X = np.random.randn(2, 3, 5).astype(np.float32)
+
+        def case(axis: int) -> None:
+            normalized_shape = calculate_normalized_shape(X.shape, axis)
+            W = np.random.randn(*normalized_shape).astype(np.float32)
+            Y = _rms_normalization(X, W, axis=axis, epsilon=epsilon)
+            node = onnx.helper.make_node(
+                "RMSNormalization",
+                inputs=["X", "W"],
+                outputs=["Y"],
+                axis=axis,
+                epsilon=epsilon,
+            )
+
+            if axis < 0:
+                name = f"test_rms_normalization_3d_axis_negative_{-axis}_epsilon"
+            else:
+                name = f"test_rms_normalization_3d_axis{axis}_epsilon"
+
+            expect(node, inputs=[X, W], outputs=[Y], name=name)
+
+        for i in range(len(X.shape)):
+            case(i)
+            case(i - len(X.shape))

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

@@ -29,9 +29,9 @@ class RNNHelper:
         self.num_directions = params[str(W)].shape[0]
 
         if self.num_directions == 1:
-            for k in params:
+            for k, v in params.items():
                 if k != X:
-                    params[k] = np.squeeze(params[k], axis=0)
+                    params[k] = np.squeeze(v, axis=0)
 
             hidden_size = params[R].shape[-1]
             batch_size = params[X].shape[1]

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

@@ -10,7 +10,7 @@ from onnx.backend.test.case.base import Base
 from onnx.backend.test.case.node import expect
 
 
-def get_roi_align_input_values():  # type: ignore
+def get_roi_align_input_values():
     X = np.array(
         [
             [

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

@@ -0,0 +1,231 @@
+# 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
+from onnx.reference.ops.op_rotary_embedding import rotary_embedding
+
+
+class RotaryEmbedding(Base):
+    @staticmethod
+    def export_rotary_embedding() -> None:
+        node = onnx.helper.make_node(
+            "RotaryEmbedding",
+            inputs=["input", "cos_cache", "sin_cache", "position_ids"],
+            outputs=["output"],
+        )
+
+        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)
+
+        expected_output = rotary_embedding(
+            input_data, cos_cache_data, sin_cache_data, position_ids=position_ids_data
+        )
+
+        expect(
+            node,
+            inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data],
+            outputs=[expected_output],
+            name="test_rotary_embedding",
+        )
+
+    @staticmethod
+    def export_rotary_embedding_3d_input() -> None:
+        num_heads = 4
+        node = onnx.helper.make_node(
+            "RotaryEmbedding",
+            inputs=["input", "cos_cache", "sin_cache", "position_ids"],
+            outputs=["output"],
+            num_heads=num_heads,
+        )
+
+        input_data = np.random.rand(2, 3, 32).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)
+
+        expected_output = rotary_embedding(
+            input_data,
+            cos_cache_data,
+            sin_cache_data,
+            position_ids=position_ids_data,
+            num_heads=num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data],
+            outputs=[expected_output],
+            name="test_rotary_embedding_3d_input",
+        )
+
+    @staticmethod
+    def export_rotary_embedding_interleaved() -> None:
+        node = onnx.helper.make_node(
+            "RotaryEmbedding",
+            inputs=["input", "cos_cache", "sin_cache", "position_ids"],
+            outputs=["output"],
+            interleaved=1,
+        )
+
+        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)
+
+        expected_output = rotary_embedding(
+            input_data,
+            cos_cache_data,
+            sin_cache_data,
+            position_ids=position_ids_data,
+            interleaved=1,
+        )
+
+        expect(
+            node,
+            inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data],
+            outputs=[expected_output],
+            name="test_rotary_embedding_interleaved",
+        )
+
+    @staticmethod
+    def export_rotary_embedding_with_rotary_dim() -> None:
+        node = onnx.helper.make_node(
+            "RotaryEmbedding",
+            inputs=["input", "cos_cache", "sin_cache", "position_ids"],
+            outputs=["output"],
+            rotary_embedding_dim=4,
+        )
+
+        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)
+
+        expected_output = rotary_embedding(
+            input_data,
+            cos_cache_data,
+            sin_cache_data,
+            position_ids=position_ids_data,
+            rotary_embedding_dim=4,
+        )
+
+        expect(
+            node,
+            inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data],
+            outputs=[expected_output],
+            name="test_rotary_embedding_with_rotary_dim",
+        )
+
+    @staticmethod
+    def export_rotary_embedding_with_interleaved_rotary_dim() -> None:
+        node = onnx.helper.make_node(
+            "RotaryEmbedding",
+            inputs=["input", "cos_cache", "sin_cache", "position_ids"],
+            outputs=["output"],
+            rotary_embedding_dim=4,
+            interleaved=1,
+        )
+
+        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)
+
+        expected_output = rotary_embedding(
+            input_data,
+            cos_cache_data,
+            sin_cache_data,
+            position_ids=position_ids_data,
+            interleaved=1,
+            rotary_embedding_dim=4,
+        )
+
+        expect(
+            node,
+            inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data],
+            outputs=[expected_output],
+            name="test_rotary_embedding_with_interleaved_rotary_dim",
+        )
+
+    @staticmethod
+    def export_rotary_embedding_no_position_ids() -> None:
+        node = onnx.helper.make_node(
+            "RotaryEmbedding",
+            inputs=["input", "cos_cache", "sin_cache"],
+            outputs=["output"],
+        )
+
+        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)
+
+        expected_output = rotary_embedding(input_data, cos_cache_data, sin_cache_data)
+
+        expect(
+            node,
+            inputs=[input_data, cos_cache_data, sin_cache_data],
+            outputs=[expected_output],
+            name="test_rotary_embedding_no_position_ids",
+        )
+
+    @staticmethod
+    def export_rotary_embedding_no_position_ids_interleaved() -> None:
+        node = onnx.helper.make_node(
+            "RotaryEmbedding",
+            inputs=["input", "cos_cache", "sin_cache"],
+            outputs=["output"],
+            interleaved=1,
+        )
+
+        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)
+
+        expected_output = rotary_embedding(
+            input_data,
+            cos_cache_data,
+            sin_cache_data,
+            interleaved=1,
+        )
+
+        expect(
+            node,
+            inputs=[input_data, cos_cache_data, sin_cache_data],
+            outputs=[expected_output],
+            name="test_rotary_embedding_no_position_ids_interleaved",
+        )
+
+    @staticmethod
+    def export_rotary_embedding_no_position_ids_rotary_dim() -> None:
+        node = onnx.helper.make_node(
+            "RotaryEmbedding",
+            inputs=["input", "cos_cache", "sin_cache"],
+            outputs=["output"],
+            rotary_embedding_dim=4,
+        )
+
+        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)
+
+        expected_output = rotary_embedding(
+            input_data,
+            cos_cache_data,
+            sin_cache_data,
+            rotary_embedding_dim=4,
+        )
+
+        expect(
+            node,
+            inputs=[input_data, cos_cache_data, sin_cache_data],
+            outputs=[expected_output],
+            name="test_rotary_embedding_no_position_ids_rotary_dim",
+        )

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",

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

@@ -29,11 +29,36 @@ class Sub(Base):
         z = x - y
         expect(node, inputs=[x, y], outputs=[z], name="test_sub")
 
+        x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.int8)
+        y = np.random.randint(12, size=(3, 4, 5), dtype=np.int8)
+        z = x - y
+        expect(node, inputs=[x, y], outputs=[z], name="test_sub_int8")
+
+        x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.int16)
+        y = np.random.randint(12, size=(3, 4, 5), dtype=np.int16)
+        z = x - y
+        expect(node, inputs=[x, y], outputs=[z], name="test_sub_int16")
+
         x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.uint8)
         y = np.random.randint(12, size=(3, 4, 5), dtype=np.uint8)
         z = x - y
         expect(node, inputs=[x, y], outputs=[z], name="test_sub_uint8")
 
+        x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.uint16)
+        y = np.random.randint(12, size=(3, 4, 5), dtype=np.uint16)
+        z = x - y
+        expect(node, inputs=[x, y], outputs=[z], name="test_sub_uint16")
+
+        x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.uint32)
+        y = np.random.randint(12, size=(3, 4, 5), dtype=np.uint32)
+        z = x - y
+        expect(node, inputs=[x, y], outputs=[z], name="test_sub_uint32")
+
+        x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.uint64)
+        y = np.random.randint(12, size=(3, 4, 5), dtype=np.uint64)
+        z = x - y
+        expect(node, inputs=[x, y], outputs=[z], name="test_sub_uint64")
+
     @staticmethod
     def export_sub_broadcast() -> None:
         node = onnx.helper.make_node(

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

@@ -0,0 +1,36 @@
+# 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
+
+
+def swish(x: np.ndarray, alpha: float) -> np.ndarray:
+    return x * (1 / (1 + np.exp(-alpha * x)))
+
+
+class Swish(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Swish",
+            inputs=["x"],
+            outputs=["y"],
+            alpha=1.0,  # pass alpha as attribute
+        )
+
+        x = np.array([3, 4, 5], dtype=np.float32)
+        y = swish(x, alpha=1.0)
+
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_swish",
+            opset_imports=[onnx.helper.make_opsetid("", 24)],
+        )

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

@@ -0,0 +1,174 @@
+# 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 TensorScatter(Base):
+    @staticmethod
+    def export_tensorscatter() -> None:
+        node = onnx.helper.make_node(
+            "TensorScatter",
+            inputs=["past_cache", "update", "write_indices"],
+            outputs=["present_cache"],
+            mode="linear",
+        )
+        past_cache = np.array(
+            [
+                [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]],
+                [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]],
+            ],
+            dtype=np.float32,
+        )
+        update = np.array(
+            [
+                [[[5, 5, 5, 5, 5]]],
+                [[[1, 1, 1, 1, 1]]],
+            ],
+            dtype=np.float32,
+        )
+        write_indices = np.array([1, 2], dtype=np.int64)
+        present_cache = np.array(
+            [
+                [[[1, 2, 3, 4, 5], [5, 5, 5, 5, 5], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]],
+                [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [1, 1, 1, 1, 1], [4, 3, 2, 1, 0]]],
+            ],
+            dtype=np.float32,
+        )
+        expect(
+            node,
+            inputs=[past_cache, update, write_indices],
+            outputs=[present_cache],
+            name="test_tensorscatter",
+        )
+
+    @staticmethod
+    def export_tensorscatter_circular() -> None:
+        node = onnx.helper.make_node(
+            "TensorScatter",
+            inputs=["past_cache", "update", "write_indices"],
+            outputs=["present_cache"],
+            mode="circular",
+        )
+        past_cache = np.array(
+            [
+                [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]],
+                [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]],
+            ],
+            dtype=np.float32,
+        )
+        update = np.array(
+            [
+                [
+                    [
+                        [5, 5, 5, 5, 5],
+                        [6, 6, 6, 6, 6],
+                    ]
+                ],
+                [
+                    [
+                        [1, 1, 1, 1, 1],
+                        [2, 2, 2, 2, 2],
+                    ]
+                ],
+            ],
+            dtype=np.float32,
+        )
+        write_indices = np.array([1, 3], dtype=np.int64)
+        present_cache = np.array(
+            [
+                [[[1, 2, 3, 4, 5], [5, 5, 5, 5, 5], [6, 6, 6, 6, 6], [4, 3, 2, 1, 0]]],
+                [[[2, 2, 2, 2, 2], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [1, 1, 1, 1, 1]]],
+            ],
+            dtype=np.float32,
+        )
+        expect(
+            node,
+            inputs=[past_cache, update, write_indices],
+            outputs=[present_cache],
+            name="test_tensorscatter_circular",
+        )
+
+    @staticmethod
+    def export_tensorscatter_3d() -> None:
+        node = onnx.helper.make_node(
+            "TensorScatter",
+            inputs=["past_cache", "update", "write_indices"],
+            outputs=["present_cache"],
+        )
+        past_cache = np.array(
+            [
+                [
+                    [1, 2, 3, 4, 5],
+                    [5, 6, 7, 8, 9],
+                    [8, 7, 6, 5, 4],
+                    [5, 4, 3, 2, 1],
+                ],
+                [
+                    [1, 2, 3, 4, 5],
+                    [5, 6, 7, 8, 9],
+                    [8, 7, 6, 5, 4],
+                    [5, 4, 3, 2, 1],
+                ],
+                [
+                    [1, 2, 3, 4, 5],
+                    [5, 6, 7, 8, 9],
+                    [8, 7, 6, 5, 4],
+                    [5, 4, 3, 2, 1],
+                ],
+            ],
+            dtype=np.float32,
+        )
+        update = np.array(
+            [
+                [
+                    [4, 4, 4, 4, 4],
+                    [5, 5, 5, 5, 5],
+                ],
+                [
+                    [6, 6, 6, 6, 6],
+                    [7, 7, 7, 7, 7],
+                ],
+                [
+                    [2, 2, 2, 2, 2],
+                    [3, 3, 3, 3, 3],
+                ],
+            ],
+            dtype=np.float32,
+        )
+        write_indices = np.array([1, 2, 0], dtype=np.int64)
+        present_cache = np.array(
+            [
+                [
+                    [1, 2, 3, 4, 5],
+                    [4, 4, 4, 4, 4],
+                    [5, 5, 5, 5, 5],
+                    [5, 4, 3, 2, 1],
+                ],
+                [
+                    [1, 2, 3, 4, 5],
+                    [5, 6, 7, 8, 9],
+                    [6, 6, 6, 6, 6],
+                    [7, 7, 7, 7, 7],
+                ],
+                [
+                    [2, 2, 2, 2, 2],
+                    [3, 3, 3, 3, 3],
+                    [8, 7, 6, 5, 4],
+                    [5, 4, 3, 2, 1],
+                ],
+            ],
+            dtype=np.float32,
+        )
+        expect(
+            node,
+            inputs=[past_cache, update, write_indices],
+            outputs=[present_cache],
+            name="test_tensorscatter_3d",
+        )