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

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

@@ -1,11 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np  # type: ignore
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.numpy_helper import create_random_int
 
 
 class BitwiseOr(Base):
@@ -17,14 +19,14 @@ class BitwiseOr(Base):
             outputs=["bitwiseor"],
         )
         # 2d
-        x = np.random.randn(3, 4).astype(np.int32)
-        y = np.random.randn(3, 4).astype(np.int32)
+        x = create_random_int((3, 4), np.int32)
+        y = create_random_int((3, 4), np.int32)
         z = np.bitwise_or(x, y)
         expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_i32_2d")
 
         # 4d
-        x = np.random.randn(3, 4, 5, 6).astype(np.int8)
-        y = np.random.randn(3, 4, 5, 6).astype(np.int8)
+        x = create_random_int((3, 4, 5, 6), np.int8)
+        y = create_random_int((3, 4, 5, 6), np.int8)
         z = np.bitwise_or(x, y)
         expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_i16_4d")
 
@@ -37,13 +39,13 @@ class BitwiseOr(Base):
         )
 
         # 3d vs 1d
-        x = np.random.randn(3, 4, 5).astype(np.uint64)
-        y = np.random.randn(5).astype(np.uint64)
+        x = create_random_int((3, 4, 5), np.uint64)
+        y = create_random_int((5,), np.uint64)
         z = np.bitwise_or(x, y)
         expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_ui64_bcast_3v1d")
 
         # 4d vs 3d
-        x = np.random.randn(3, 4, 5, 6).astype(np.uint8)
-        y = np.random.randn(4, 5, 6).astype(np.uint8)
+        x = create_random_int((3, 4, 5, 6), np.uint8)
+        y = create_random_int((4, 5, 6), np.uint8)
         z = np.bitwise_or(x, y)
         expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_ui8_bcast_4v3d")

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

@@ -1,11 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np  # type: ignore
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.numpy_helper import create_random_int
 
 
 class BitwiseXor(Base):
@@ -18,14 +20,14 @@ class BitwiseXor(Base):
         )
 
         # 2d
-        x = np.random.randn(3, 4).astype(np.int32)
-        y = np.random.randn(3, 4).astype(np.int32)
+        x = create_random_int((3, 4), np.int32)
+        y = create_random_int((3, 4), np.int32)
         z = np.bitwise_xor(x, y)
         expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_i32_2d")
 
         # 3d
-        x = np.random.randn(3, 4, 5).astype(np.int16)
-        y = np.random.randn(3, 4, 5).astype(np.int16)
+        x = create_random_int((3, 4, 5), np.int16)
+        y = create_random_int((3, 4, 5), np.int16)
         z = np.bitwise_xor(x, y)
         expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_i16_3d")
 
@@ -38,15 +40,15 @@ class BitwiseXor(Base):
         )
 
         # 3d vs 1d
-        x = np.random.randn(3, 4, 5).astype(np.uint64)
-        y = np.random.randn(5).astype(np.uint64)
+        x = create_random_int((3, 4, 5), np.uint64)
+        y = create_random_int((5,), np.uint64)
         z = np.bitwise_xor(x, y)
         expect(
             node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_ui64_bcast_3v1d"
         )
 
         # 4d vs 3d
-        x = np.random.randn(3, 4, 5, 6).astype(np.uint8)
-        y = np.random.randn(4, 5, 6).astype(np.uint8)
+        x = create_random_int((3, 4, 5, 6), np.uint8)
+        y = create_random_int((4, 5, 6), np.uint8)
         z = np.bitwise_xor(x, y)
         expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_ui8_bcast_4v3d")

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

@@ -1,12 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
-
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
 
 class BlackmanWindow(Base):

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

@@ -1,15 +1,22 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
-
 import sys
 
 import numpy as np
 
 import onnx
 from onnx import TensorProto, helper
-
-from ..base import Base
-from . import expect
+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,
+    tensor_dtype_to_field,
+)
+from onnx.numpy_helper import float8e4m3_to_float32, float8e5m2_to_float32
 
 
 class Cast(Base):
@@ -27,12 +34,32 @@ class Cast(Base):
             ("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"),
         ]
 
+        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 "BFLOAT16" == from_type or "BFLOAT16" == to_type:
+            if from_type == "BFLOAT16" or to_type == "BFLOAT16":
                 np_fp32 = np.array(
                     [
                         "0.47892547",
@@ -55,7 +82,7 @@ class Cast(Base):
                 np_bfp16 = (
                     np_uint16_view[1::2] if little_endisan else np_uint16_view[0::2]
                 )
-                if "BFLOAT16" == to_type:
+                if to_type == "BFLOAT16":
                     assert from_type == "FLOAT"
                     input = np_fp32.reshape([3, 4])
                     output = np_bfp16.reshape([3, 4])
@@ -82,11 +109,106 @@ class Cast(Base):
                     output_type_proto = onnx.helper.make_tensor_type_proto(
                         int(TensorProto.FLOAT), output.shape
                     )
-            elif "STRING" != from_type:
+            elif from_type in f8_types or to_type in f8_types:
+                np_fp32 = np.array(
+                    [
+                        "0.47892547",
+                        "0.48033667",
+                        "0.49968487",
+                        "0.81910545",
+                        "0.47031248",
+                        "0.7229038",
+                        "1000000",
+                        "1e-7",
+                        "NaN",
+                        "INF",
+                        "+INF",
+                        "-INF",
+                    ],
+                    dtype=np.float32,
+                )
+
+                if from_type == "FLOAT":
+                    input_values = np_fp32
+                    input = make_tensor(
+                        "x", TensorProto.FLOAT, [3, 4], np_fp32.tolist()
+                    )
+                elif from_type == "FLOAT16":
+                    input_values = np_fp32.astype(np.float16).astype(np.float32)
+                    input = make_tensor(
+                        "x", TensorProto.FLOAT16, [3, 4], input_values.tolist()
+                    )
+                elif from_type == "FLOAT8E4M3FN":
+                    input_values = float8e4m3_to_float32(
+                        vect_float32_to_float8e4m3(np_fp32)
+                    )
+                    input = make_tensor(
+                        "x", TensorProto.FLOAT8E4M3FN, [3, 4], input_values.tolist()
+                    )
+                elif from_type == "FLOAT8E4M3FNUZ":
+                    input_values = float8e4m3_to_float32(
+                        vect_float32_to_float8e4m3(np_fp32, uz=True), uz=True
+                    )
+                    input = make_tensor(
+                        "x", TensorProto.FLOAT8E4M3FNUZ, [3, 4], input_values.tolist()
+                    )
+                elif from_type == "FLOAT8E5M2":
+                    input_values = float8e5m2_to_float32(
+                        vect_float32_to_float8e5m2(np_fp32)
+                    )
+                    input = make_tensor(
+                        "x", TensorProto.FLOAT8E5M2, [3, 4], input_values.tolist()
+                    )
+                elif from_type == "FLOAT8E5M2FNUZ":
+                    input_values = float8e5m2_to_float32(
+                        vect_float32_to_float8e5m2(np_fp32, fn=True, uz=True),
+                        fn=True,
+                        uz=True,
+                    )
+                    input = make_tensor(
+                        "x", TensorProto.FLOAT8E5M2FNUZ, [3, 4], input_values.tolist()
+                    )
+                else:
+                    raise ValueError(
+                        "Conversion from {from_type} to {to_type} is not tested."
+                    )
+
+                if to_type == "FLOAT8E4M3FN":
+                    expected = float8e4m3_to_float32(
+                        vect_float32_to_float8e4m3(input_values)
+                    )
+                elif to_type == "FLOAT8E4M3FNUZ":
+                    expected = float8e4m3_to_float32(
+                        vect_float32_to_float8e4m3(input_values, uz=True), uz=True
+                    )
+                elif to_type == "FLOAT8E5M2":
+                    expected = float8e5m2_to_float32(
+                        vect_float32_to_float8e5m2(input_values)
+                    )
+                elif to_type == "FLOAT8E5M2FNUZ":
+                    expected = float8e5m2_to_float32(
+                        vect_float32_to_float8e5m2(input_values, fn=True, uz=True),
+                        fn=True,
+                        uz=True,
+                    )
+                elif to_type == "FLOAT16":
+                    expected = input_values.astype(np.float16).astype(np.float32)
+                elif to_type == "FLOAT":
+                    expected = input_values
+                else:
+                    raise ValueError(
+                        "Conversion from {from_type} to {to_type} is not tested."
+                    )
+                expected_tensor = make_tensor(
+                    "x", getattr(TensorProto, to_type), [3, 4], expected.tolist()
+                )
+                output = expected_tensor
+
+            elif from_type != "STRING":
                 input = np.random.random_sample(shape).astype(
                     helper.tensor_dtype_to_np_dtype(getattr(TensorProto, from_type))
                 )
-                if "STRING" == to_type:
+                if to_type == "STRING":
                     # Converting input to str, then give it object dtype for generating script
                     ss = []
                     for i in input.flatten():
@@ -142,3 +264,91 @@ class Cast(Base):
                     outputs=[output],
                     name="test_cast_" + from_type + "_to_" + to_type,
                 )
+
+    @staticmethod
+    def export_saturate_false() -> None:
+        test_cases = [
+            ("FLOAT", "FLOAT8E4M3FN"),
+            ("FLOAT16", "FLOAT8E4M3FN"),
+            ("FLOAT", "FLOAT8E4M3FNUZ"),
+            ("FLOAT16", "FLOAT8E4M3FNUZ"),
+            ("FLOAT", "FLOAT8E5M2"),
+            ("FLOAT16", "FLOAT8E5M2"),
+            ("FLOAT", "FLOAT8E5M2FNUZ"),
+            ("FLOAT16", "FLOAT8E5M2FNUZ"),
+        ]
+        vect_float32_to_float8e4m3 = np.vectorize(float32_to_float8e4m3)
+        vect_float32_to_float8e5m2 = np.vectorize(float32_to_float8e5m2)
+
+        for from_type, to_type in test_cases:
+            np_fp32 = np.array(
+                [
+                    "0.47892547",
+                    "0.48033667",
+                    "0.49968487",
+                    "0.81910545",
+                    "0.47031248",
+                    "0.7229038",
+                    "1000000",
+                    "1e-7",
+                    "NaN",
+                    "INF",
+                    "+INF",
+                    "-INF",
+                ],
+                dtype=np.float32,
+            )
+
+            if from_type == "FLOAT":
+                input_values = np_fp32
+                input = make_tensor("x", TensorProto.FLOAT, [3, 4], np_fp32.tolist())
+            elif from_type == "FLOAT16":
+                input_values = np_fp32.astype(np.float16).astype(np.float32)
+                input = make_tensor(
+                    "x", TensorProto.FLOAT16, [3, 4], input_values.tolist()
+                )
+            else:
+                raise ValueError(
+                    "Conversion from {from_type} to {to_type} is not tested."
+                )
+
+            if to_type == "FLOAT8E4M3FN":
+                expected = vect_float32_to_float8e4m3(input_values, saturate=False)
+            elif to_type == "FLOAT8E4M3FNUZ":
+                expected = vect_float32_to_float8e4m3(
+                    input_values, uz=True, saturate=False
+                )
+            elif to_type == "FLOAT8E5M2":
+                expected = vect_float32_to_float8e5m2(input_values, saturate=False)
+            elif to_type == "FLOAT8E5M2FNUZ":
+                expected = vect_float32_to_float8e5m2(
+                    input_values, fn=True, uz=True, saturate=False
+                )
+            else:
+                raise ValueError(
+                    "Conversion from {from_type} to {to_type} is not tested."
+                )
+
+            ivals = bytes([int(i) for i in expected])
+            tensor = TensorProto()
+            tensor.data_type = getattr(TensorProto, to_type)
+            tensor.name = "x"
+            tensor.dims.extend([3, 4])
+            field = tensor_dtype_to_field(tensor.data_type)
+            getattr(tensor, field).extend(ivals)
+
+            output = tensor
+
+            node = onnx.helper.make_node(
+                "Cast",
+                inputs=["input"],
+                outputs=["output"],
+                to=getattr(TensorProto, to_type),
+                saturate=0,
+            )
+            expect(
+                node,
+                inputs=[input],
+                outputs=[output],
+                name="test_cast_no_saturate_" + from_type + "_to_" + to_type,
+            )

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

@@ -1,15 +1,17 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
-
 import sys
 
 import numpy as np
 
 import onnx
 from onnx import TensorProto, helper
-
-from ..base import Base
-from . import expect
+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
 
 
 class CastLike(Base):
@@ -27,12 +29,23 @@ class CastLike(Base):
             ("STRING", "FLOAT"),
             ("FLOAT", "BFLOAT16"),
             ("BFLOAT16", "FLOAT"),
+            ("FLOAT", "FLOAT8E4M3FN"),
+            ("FLOAT", "FLOAT8E4M3FNUZ"),
+            ("FLOAT8E4M3FN", "FLOAT"),
+            ("FLOAT8E4M3FNUZ", "FLOAT"),
+            ("FLOAT", "FLOAT8E5M2"),
+            ("FLOAT", "FLOAT8E5M2FNUZ"),
+            ("FLOAT8E5M2", "FLOAT"),
+            ("FLOAT8E5M2FNUZ", "FLOAT"),
         ]
 
+        vect_float32_to_float8e4m3 = np.vectorize(float32_to_float8e4m3)
+        vect_float32_to_float8e5m2 = np.vectorize(float32_to_float8e5m2)
+
         for from_type, to_type in test_cases:
             input_type_proto = None
             output_type_proto = None
-            if "BFLOAT16" == from_type or "BFLOAT16" == to_type:
+            if from_type == "BFLOAT16" or to_type == "BFLOAT16":
                 np_fp32 = np.array(
                     [
                         "0.47892547",
@@ -55,7 +68,7 @@ class CastLike(Base):
                 np_bfp16 = (
                     np_uint16_view[1::2] if little_endisan else np_uint16_view[0::2]
                 )
-                if "BFLOAT16" == to_type:
+                if to_type == "BFLOAT16":
                     assert from_type == "FLOAT"
                     input = np_fp32.reshape([3, 4])
                     output = np_bfp16.reshape([3, 4])
@@ -82,23 +95,104 @@ class CastLike(Base):
                     output_type_proto = onnx.helper.make_tensor_type_proto(
                         int(TensorProto.FLOAT), output.shape
                     )
-            elif "STRING" != from_type:
+                like = output.flatten()[0:1]
+            elif from_type in (
+                "FLOAT8E4M3FN",
+                "FLOAT8E4M3FNUZ",
+                "FLOAT8E5M2",
+                "FLOAT8E5M2FNUZ",
+            ) or to_type in (
+                "FLOAT8E4M3FN",
+                "FLOAT8E4M3FNUZ",
+                "FLOAT8E5M2",
+                "FLOAT8E5M2FNUZ",
+            ):
+                np_fp32 = np.array(
+                    [
+                        "0.47892547",
+                        "0.48033667",
+                        "0.49968487",
+                        "0.81910545",
+                        "0.47031248",
+                        "0.816468",
+                        "0.21087195",
+                        "0.7229038",
+                        "NaN",
+                        "INF",
+                        "+INF",
+                        "-INF",
+                    ],
+                    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))
                 )
-                if "STRING" == to_type:
-                    # Converting input to str, then give it np.object dtype for generating script
+                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(np.object).reshape([3, 4])
+                    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]
             else:
                 input = np.array(
                     [
@@ -115,12 +209,12 @@ class CastLike(Base):
                         "+INF",
                         "-INF",
                     ],
-                    dtype=np.dtype(np.object),
+                    dtype=np.dtype(object),
                 ).reshape([3, 4])
                 output = input.astype(
                     helper.tensor_dtype_to_np_dtype(getattr(TensorProto, to_type))
                 )
-            like = output.flatten()[0:1]
+                like = output.flatten()[0:1]
             node = onnx.helper.make_node(
                 "CastLike",
                 inputs=["input", "like"],

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

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
 
 class Ceil(Base):

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

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
 
 class Celu(Base):

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

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
 
 class CenterCropPad(Base):
@@ -83,6 +84,28 @@ class CenterCropPad(Base):
             name="test_center_crop_pad_crop_axes_hwc",
         )
 
+    @staticmethod
+    def export_center_crop_pad_crop_negative_axes_hwc() -> None:
+        node = onnx.helper.make_node(
+            "CenterCropPad",
+            inputs=["x", "shape"],
+            outputs=["y"],
+            axes=[-3, -2],
+        )
+
+        # Cropping on first dim, padding on second, third stays the same
+        x = np.random.randn(20, 8, 3).astype(np.float32)
+        shape = np.array([10, 9], dtype=np.int64)
+        y = np.zeros([10, 9, 3], dtype=np.float32)
+        y[:, :8, :] = x[5:15, :, :]
+
+        expect(
+            node,
+            inputs=[x, shape],
+            outputs=[y],
+            name="test_center_crop_pad_crop_negative_axes_hwc",
+        )
+
     @staticmethod
     def export_center_crop_pad_crop_axes_chw() -> None:
         node = onnx.helper.make_node(

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

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
 
 
 class Clip(Base):