onnx 1.17.0__cp310-cp310-win32.whl → 1.19.0__cp310-cp310-win32.whl

onnx/test/symbolic_shape_test.py

@@ -56,9 +56,9 @@ class TestSymbolicShape(unittest.TestCase):
         for v in inputs + outputs + valueinfos:
             if v.name == name:
                 if v.type.HasField("tensor_type"):
-                    return v.type.tensor_type.shape  # type: ignore
+                    return v.type.tensor_type.shape
                 if v.type.HasField("sparse_tensor_type"):
-                    return v.type.sparse_tensor_type.shape  # type: ignore
+                    return v.type.sparse_tensor_type.shape
         return None
 
     def test_concat_enable_symbolic(self) -> None:

onnx/test/test_backend_reference.py

@@ -61,7 +61,7 @@ class ReferenceEvaluatorBackend(onnx.backend.base.Backend):
     @classmethod
     def supports_device(cls, device: str) -> bool:
         d = Device(device)
-        return d.type == DeviceType.CPU  # type: ignore[no-any-return]
+        return d.type == DeviceType.CPU
 
     @classmethod
     def create_inference_session(cls, model):
@@ -124,41 +124,6 @@ backend_test.exclude(
 # The following tests are about deprecated operators.
 backend_test.exclude("(test_scatter_with_axis|test_scatter_without)")
 
-# The following tests are using types not supported by numpy.
-# They could be if method to_array is extended to support custom
-# types the same as the reference implementation does
-# (see onnx.reference.op_run.to_array_extended).
-backend_test.exclude(
-    "(test_cast_FLOAT_to_FLOAT8"
-    "|test_cast_FLOAT16_to_FLOAT8"
-    "|test_castlike_FLOAT_to_FLOAT8"
-    "|test_castlike_FLOAT16_to_FLOAT8"
-    "|test_cast_FLOAT_to_UINT4"
-    "|test_cast_FLOAT16_to_UINT4"
-    "|test_cast_FLOAT_to_INT4"
-    "|test_cast_FLOAT16_to_INT4"
-    "|test_cast_no_saturate_FLOAT_to_FLOAT8"
-    "|test_cast_no_saturate_FLOAT16_to_FLOAT8"
-    "|test_cast_BFLOAT16_to_FLOAT"
-    "|test_castlike_BFLOAT16_to_FLOAT"
-    "|test_quantizelinear_e4m3"
-    "|test_quantizelinear_e5m2"
-    "|test_quantizelinear_uint4"
-    "|test_quantizelinear_int4"
-    ")"
-)
-
-# The following tests are using types not supported by NumPy.
-# They could be if method to_array is extended to support custom
-# types the same as the reference implementation does
-# (see onnx.reference.op_run.to_array_extended).
-backend_test.exclude(
-    "(test_cast_FLOAT_to_BFLOAT16"
-    "|test_castlike_FLOAT_to_BFLOAT16"
-    "|test_castlike_FLOAT_to_BFLOAT16_expanded"
-    ")"
-)
-
 # The following tests are too slow with the reference implementation (Conv).
 backend_test.exclude(
     "(test_bvlc_alexnet"
@@ -193,14 +158,14 @@ backend_test.exclude("(test_eyelike_without_dtype)")
 # The following tests fail due to discrepancies (small but still higher than 1e-7).
 backend_test.exclude("test_adam_multiple")  # 1e-2
 
-# Currently google-re2/Pillow is not supported on Win32 and is required for the reference implementation of RegexFullMatch.
+# Currently Pillow is not supported on Win32 and is required for the reference implementation of RegexFullMatch.
 if sys.platform == "win32":
     backend_test.exclude("test_regex_full_match_basic_cpu")
     backend_test.exclude("test_regex_full_match_email_domain_cpu")
     backend_test.exclude("test_regex_full_match_empty_cpu")
     backend_test.exclude("test_image_decoder_decode_")
 
-if sys.version_info <= (3, 10):
+if sys.version_info < (3, 10):
     #  AttributeError: module 'numpy.typing' has no attribute 'NDArray'
     backend_test.exclude("test_image_decoder_decode_")
 
@@ -209,22 +174,27 @@ if sys.platform == "darwin":
     backend_test.exclude("test_qlinearmatmul_3D_int8_float16_cpu")
     backend_test.exclude("test_qlinearmatmul_3D_int8_float32_cpu")
 
-# op_dft and op_stft requires numpy >= 1.21.5
-if version_utils.numpy_older_than("1.21.5"):
-    backend_test.exclude("test_stft")
-    backend_test.exclude("test_stft_with_window")
-    backend_test.exclude("test_stft_cpu")
-    backend_test.exclude("test_dft")
-    backend_test.exclude("test_dft_axis")
-    backend_test.exclude("test_dft_inverse")
-    backend_test.exclude("test_dft_opset19")
-    backend_test.exclude("test_dft_axis_opset19")
-    backend_test.exclude("test_dft_inverse_opset19")
-
 if version_utils.pillow_older_than("10.0"):
     backend_test.exclude("test_image_decoder_decode_webp_rgb")
     backend_test.exclude("test_image_decoder_decode_jpeg2k_rgb")
 
+if version_utils.numpy_older_than("2.0"):
+    # assert_allclose does not support ml_dtypes types in numpy < 2.0
+    backend_test.exclude(r"test_cast.*(FLOAT8|BFLOAT16|FLOAT4|INT4)")
+    backend_test.exclude(r"test_quantizelinear_e4m3fn")
+    backend_test.exclude(r"test_quantizelinear_float4e2m1")
+
+# The documentation does not explicitly say that is_causal=1 and attn_mask is not None
+# is not allowed. The expansion (based on the function definition in ONNX)
+# assumes this case never happens and behaves likes is_causal=0 even if it is 1.
+# The reference implementation and the backend tests have a different behabiour in that case.
+backend_test.exclude(
+    "(test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded"
+    "|test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded"
+    "|test_attention_4d_attn_mask_4d_causal_expanded"
+    "|test_attention_4d_attn_mask_3d_causal_expanded)"
+)
+
 # import all test cases at global scope to make them visible to python.unittest
 globals().update(backend_test.test_cases)
 

onnx/test/test_backend_test.py

@@ -7,9 +7,7 @@ import itertools
 import os
 import platform
 import unittest
-from typing import Any, Sequence
-
-import numpy
+from typing import TYPE_CHECKING, Any
 
 import onnx.backend.base
 import onnx.backend.test
@@ -19,6 +17,11 @@ from onnx import ModelProto, NodeProto, TensorProto
 from onnx.backend.base import Device, DeviceType
 from onnx.backend.test.runner import BackendIsNotSupposedToImplementIt
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    import numpy
+
 # The following just executes the fake backend through the backend test
 # infrastructure. Since we don't have full reference implementation of all ops
 # in ONNX repo, it's impossible to produce the proper results. However, we can
@@ -81,9 +84,7 @@ class DummyBackend(onnx.backend.base.Backend):
     @classmethod
     def supports_device(cls, device: str) -> bool:
         d = Device(device)
-        if d.type == DeviceType.CPU:
-            return True
-        return False
+        return d.type == DeviceType.CPU
 
 
 test_coverage_safelist = {

onnx/test/test_external_data.py

@@ -9,7 +9,7 @@ import pathlib
 import tempfile
 import unittest
 import uuid
-from typing import Any, Sequence
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 import parameterized
@@ -33,6 +33,9 @@ from onnx.external_data_helper import (
 )
 from onnx.numpy_helper import from_array, to_array
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 
 class TestLoadExternalDataBase(unittest.TestCase):
     """Base class for testing external data related behaviors.
@@ -75,13 +78,16 @@ class TestLoadExternalDataBase(unittest.TestCase):
             inputs=[],
             outputs=["values"],
             value=self.create_external_data_tensor(
-                self.attribute_value, "attribute_value"  # type: ignore[arg-type]
+                self.attribute_value,
+                "attribute_value",
             ),
         )
 
         initializers = [
             self.create_external_data_tensor(
-                self.initializer_value, "input_value", location  # type: ignore[arg-type]
+                self.initializer_value,
+                "input_value",
+                location,
             )
         ]
         inputs = [
@@ -293,8 +299,8 @@ class TestSaveAllTensorsAsExternalData(unittest.TestCase):
     def create_test_model_proto(self) -> ModelProto:
         tensors = self.create_data_tensors(
             [
-                (self.attribute_value, "attribute_value"),  # type: ignore[list-item]
-                (self.initializer_value, "input_value"),  # type: ignore[list-item]
+                (self.attribute_value, "attribute_value"),
+                (self.initializer_value, "input_value"),
             ]
         )
 

onnx/test/tools_test.py

@@ -75,14 +75,14 @@ class TestToolsFunctions(unittest.TestCase):
 
         x = np.array([1, 2, 4, 5, 5, 4]).astype(np.float32).reshape((3, 2))
         oinf1 = ReferenceEvaluator(model_def)
-        y1 = oinf1.run(None, {"X": x})[0]  # type: ignore[index]
+        y1 = oinf1.run(None, {"X": x})[0]
         repl = replace_initializer_by_constant_of_shape(model_def)
         node_types = {n.op_type for n in repl.graph.node}
         self.assertIn("ConstantOfShape", node_types)
         oinf2 = ReferenceEvaluator(repl)
         y1[:, :] = 3.5
         y1[0, :] = 0.5
-        y2 = oinf2.run(None, {"X": x})[0]  # type: ignore[index]
+        y2 = oinf2.run(None, {"X": x})[0]
         assert_allclose(y1, y2)
 
     def test_replace_constant(self):
@@ -102,14 +102,14 @@ class TestToolsFunctions(unittest.TestCase):
 
         x = np.array([1, 2, 4, 5, 5, 4]).astype(np.float32).reshape((3, 2))
         oinf1 = ReferenceEvaluator(model_def)
-        y1 = oinf1.run(None, {"X": x})[0]  # type: ignore[index]
+        y1 = oinf1.run(None, {"X": x})[0]
         repl = replace_initializer_by_constant_of_shape(model_def)
         node_types = {n.op_type for n in repl.graph.node}
         self.assertIn("ConstantOfShape", node_types)
         oinf2 = ReferenceEvaluator(repl)
         y1[:, :] = 3.5
         y1[0, :] = 0.5
-        y2 = oinf2.run(None, {"X": x})[0]  # type: ignore[index]
+        y2 = oinf2.run(None, {"X": x})[0]
         assert_allclose(y1, y2)
 
     def test_replace_range(self):
@@ -129,13 +129,13 @@ class TestToolsFunctions(unittest.TestCase):
 
         x = np.array([1, 2, 4, 5, 5, 4]).astype(np.float32).reshape((3, 2))
         oinf1 = ReferenceEvaluator(model_def)
-        y1 = oinf1.run(None, {"X": x})[0]  # type: ignore[index]
+        y1 = oinf1.run(None, {"X": x})[0]
         repl = replace_initializer_by_constant_of_shape(model_def, use_range=True)
         node_types = {n.op_type for n in repl.graph.node}
         self.assertIn("Range", node_types)
         self.assertNotIn("ConstantOfShape", node_types)
         oinf2 = ReferenceEvaluator(repl)
-        y2 = oinf2.run(None, {"X": x})[0]  # type: ignore[index]
+        y2 = oinf2.run(None, {"X": x})[0]
         assert_allclose(y1.shape, y2.shape)
 
     def test_replace_constant_function(self):
@@ -172,14 +172,14 @@ class TestToolsFunctions(unittest.TestCase):
 
         x = np.array([1, 2, 4, 5, 5, 4]).astype(np.float32).reshape((3, 2))
         oinf1 = ReferenceEvaluator(model_def)
-        y1 = oinf1.run(None, {"X": x})[0]  # type: ignore[index]
+        y1 = oinf1.run(None, {"X": x})[0]
         repl = replace_initializer_by_constant_of_shape(model_def)
         node_types = {n.op_type for n in repl.functions[0].node}
         self.assertIn("ConstantOfShape", node_types)
         oinf2 = ReferenceEvaluator(repl)
         y1[:, :] = 3.5
         y1[0, :] = 0.5
-        y2 = oinf2.run(None, {"X": x})[0]  # type: ignore[index]
+        y2 = oinf2.run(None, {"X": x})[0]
         assert_allclose(y1, y2)
 
     def test_replace_range_function(self):
@@ -216,13 +216,13 @@ class TestToolsFunctions(unittest.TestCase):
 
         x = np.array([1, 2, 4, 5, 5, 4]).astype(np.float32).reshape((3, 2))
         oinf1 = ReferenceEvaluator(model_def)
-        y1 = oinf1.run(None, {"X": x})[0]  # type: ignore[index]
+        y1 = oinf1.run(None, {"X": x})[0]
         repl = replace_initializer_by_constant_of_shape(model_def, use_range=True)
         node_types = {n.op_type for n in repl.functions[0].node}
         self.assertIn("Range", node_types)
         self.assertNotIn("ConstantOfShape", node_types)
         oinf2 = ReferenceEvaluator(repl)
-        y2 = oinf2.run(None, {"X": x})[0]  # type: ignore[index]
+        y2 = oinf2.run(None, {"X": x})[0]
         assert_allclose(y1.shape, y2.shape)
 
     def test_replace_constant_graph(self):
@@ -265,11 +265,11 @@ class TestToolsFunctions(unittest.TestCase):
 
         x = np.ones((3, 2), dtype=np.float32)
         oinf1 = ReferenceEvaluator(onnx_model)
-        y1 = oinf1.run(None, {"X": x})[0]  # type: ignore[index]
+        y1 = oinf1.run(None, {"X": x})[0]
         repl = replace_initializer_by_constant_of_shape(onnx_model)
         self.assertIn("ConstantOfShape", str(repl))
         oinf2 = ReferenceEvaluator(repl)
-        y2 = oinf2.run(None, {"X": x})[0]  # type: ignore[index]
+        y2 = oinf2.run(None, {"X": x})[0]
         y1 = y1.copy()
         y1[:] = 0.5
         assert_allclose(y1, y2)
@@ -314,12 +314,12 @@ class TestToolsFunctions(unittest.TestCase):
 
         x = np.ones((3, 2), dtype=np.float32)
         oinf1 = ReferenceEvaluator(onnx_model)
-        y1 = oinf1.run(None, {"X": x})[0]  # type: ignore[index]
+        y1 = oinf1.run(None, {"X": x})[0]
         repl = replace_initializer_by_constant_of_shape(onnx_model, use_range=True)
         self.assertNotIn("ConstantOfShape", str(repl))
         self.assertIn("Range", str(repl))
         oinf2 = ReferenceEvaluator(repl)
-        y2 = oinf2.run(None, {"X": x})[0]  # type: ignore[index]
+        y2 = oinf2.run(None, {"X": x})[0]
         assert_allclose(y1.shape, y2.shape)
 
 

onnx/test/utils_test.py

@@ -14,7 +14,7 @@ from onnx import TensorProto, helper
 
 class TestUtilityFunctions(unittest.TestCase):
     def test_extract_model(self) -> None:
-        def create_tensor(name):  # type: ignore
+        def create_tensor(name):
             return helper.make_tensor_value_info(name, TensorProto.FLOAT, [1, 2])
 
         A0 = create_tensor("A0")

onnx/test/version_converter/automatic_conversion_test_base.py

@@ -5,11 +5,14 @@ from __future__ import annotations
 
 import string
 import unittest
-from typing import Any, List, Sequence, cast
+from typing import TYPE_CHECKING, Any, cast
 
 import onnx
 from onnx import TensorProto, ValueInfoProto, helper, shape_inference, version_converter
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 LATEST_OPSET = onnx.defs.onnx_opset_version()
 
 
@@ -90,7 +93,7 @@ class TestAutomaticConversion(unittest.TestCase):
         # turn empty strings into [0] to ease type analysis, even though those entries
         # will be ignored
         input_shapes_cast = cast(
-            List[List[int]],
+            "list[list[int]]",
             [[0] if isinstance(shape, str) else shape for shape in input_shapes],
         )
         inputs: list[ValueInfoProto] = []
@@ -118,7 +121,7 @@ class TestAutomaticConversion(unittest.TestCase):
             0 if id not in optional_outputs else 1 for id in range(n_outputs)
         ]
         output_shapes_cast = cast(
-            List[List[int]],
+            "list[list[int]]",
             [[0] if isinstance(shape, str) else shape for shape in output_shapes],
         )
         outputs: list[ValueInfoProto] = []

onnx/test/version_converter/automatic_upgrade_test.py

@@ -114,6 +114,94 @@ class TestAutomaticUpgrade(automatic_conversion_test_base.TestAutomaticConversio
     def test_Atan(self) -> None:
         self._test_op_upgrade("Atan", 7)
 
+    def test_Attention_1(self) -> None:
+        self._test_op_upgrade(
+            "Attention",
+            23,
+            [[2, 3, 4, 8], [2, 3, 6, 8], [2, 3, 6, 8]],
+            [[2, 3, 4, 8]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.FLOAT],
+            [TensorProto.FLOAT],
+        )
+
+    def test_Attention_2(self) -> None:
+        self._test_op_upgrade(
+            "Attention",
+            23,
+            [[2, 9, 4, 8], [2, 3, 6, 8], [2, 3, 6, 8]],
+            [[2, 9, 4, 8]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.FLOAT],
+            [TensorProto.FLOAT],
+        )
+
+    def test_Attention_3(self) -> None:
+        self._test_op_upgrade(
+            "Attention",
+            23,
+            [[2, 3, 4, 8], [2, 3, 6, 8], [2, 3, 6, 10]],
+            [[2, 3, 4, 10]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.FLOAT],
+            [TensorProto.FLOAT],
+        )
+
+    def test_Attention_4(self) -> None:
+        self._test_op_upgrade(
+            "Attention",
+            23,
+            [[2, 3, 4, 8], [2, 3, 6, 8], [2, 3, 6, 8]],
+            [[2, 3, 4, 8]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.FLOAT],
+            [TensorProto.FLOAT],
+            attrs={"scale": 2.0},
+        )
+
+    def test_Attention_5(self) -> None:
+        self._test_op_upgrade(
+            "Attention",
+            23,
+            [[2, 3, 4, 8], [2, 3, 6, 8], [2, 3, 6, 8]],
+            [[2, 3, 4, 8]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.FLOAT],
+            [TensorProto.FLOAT],
+            attrs={"is_causal": 1},
+        )
+
+    def test_Attention_6(self) -> None:
+        self._test_op_upgrade(
+            "Attention",
+            23,
+            [[2, 3, 4, 8], [2, 3, 6, 8], [2, 3, 6, 8], [4, 6]],
+            [[2, 3, 4, 8]],
+            [
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+            ],
+            [TensorProto.FLOAT],
+        )
+
+    def test_Attention_7(self) -> None:
+        self._test_op_upgrade(
+            "Attention",
+            23,
+            [[2, 3, 4, 8], [2, 3, 6, 8], [2, 3, 6, 8], [4, 6]],
+            [[2, 3, 4, 8]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.BOOL],
+            [TensorProto.FLOAT],
+        )
+
+    def test_Attention_8(self) -> None:
+        self._test_op_upgrade(
+            "Attention",
+            23,
+            [[2, 3, 4, 8], [2, 3, 6, 8], [2, 3, 6, 8]],
+            [[2, 3, 4, 8]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.FLOAT],
+            [TensorProto.FLOAT],
+            attrs={"softcap": 2.0},
+        )
+
     def test_AveragePool(self) -> None:
         self._test_op_upgrade(
             "AveragePool",
@@ -1096,9 +1184,93 @@ class TestAutomaticUpgrade(automatic_conversion_test_base.TestAutomaticConversio
             attrs={"coordinate_transformation_mode": "half_pixel"},
         )
 
+    def test_RotaryEmbedding_1(self) -> None:
+        self._test_op_upgrade(
+            "RotaryEmbedding",
+            23,
+            [[2, 4, 3, 8], [2, 3, 4], [2, 3, 4]],
+            [[2, 4, 3, 8]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.FLOAT],
+            [TensorProto.FLOAT],
+        )
+
+    def test_RotaryEmbedding_2(self) -> None:
+        self._test_op_upgrade(
+            "RotaryEmbedding",
+            23,
+            [[2, 4, 3, 8], [50, 4], [50, 4], [2, 3]],
+            [[2, 4, 3, 8]],
+            [
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.INT64,
+            ],
+            [TensorProto.FLOAT],
+        )
+
+    def test_RotaryEmbedding_3(self) -> None:
+        self._test_op_upgrade(
+            "RotaryEmbedding",
+            23,
+            [[2, 3, 32], [50, 4], [50, 4], [2, 3]],
+            [[2, 3, 32]],
+            [
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.INT64,
+            ],
+            [TensorProto.FLOAT],
+            attrs={"num_heads": 4},
+        )
+
+    def test_RotaryEmbedding_4(self) -> None:
+        self._test_op_upgrade(
+            "RotaryEmbedding",
+            23,
+            [[2, 4, 3, 8], [50, 4], [50, 4], [2, 3]],
+            [[2, 4, 3, 8]],
+            [
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.INT64,
+            ],
+            [TensorProto.FLOAT],
+            attrs={"interleaved": 1},
+        )
+
+    def test_RotaryEmbedding_5(self) -> None:
+        self._test_op_upgrade(
+            "RotaryEmbedding",
+            23,
+            [[2, 4, 3, 8], [50, 4], [50, 4], [2, 3]],
+            [[2, 4, 3, 8]],
+            [
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.INT64,
+            ],
+            [TensorProto.FLOAT],
+            attrs={"rotary_embedding_dim": 4},
+        )
+
     def test_Round(self) -> None:
         self._test_op_upgrade("Round", 11)
 
+    def test_RMSNormalization(self) -> None:
+        self._test_op_upgrade(
+            "RMSNormalization",
+            23,
+            [[2, 3, 4, 5], [4, 5]],
+            [[2, 3, 4, 5]],
+            input_types=[TensorProto.FLOAT, TensorProto.FLOAT],
+            output_types=[TensorProto.FLOAT],
+            attrs={"axis": 2},
+        )
+
     def test_Scatter(self) -> None:
         self._test_op_upgrade(
             "Scatter",
@@ -1301,6 +1473,9 @@ class TestAutomaticUpgrade(automatic_conversion_test_base.TestAutomaticConversio
             attrs={"consumed_inputs": [0]},
         )
 
+    def test_Swish(self) -> None:
+        self._test_op_upgrade("Swish", 24, attrs={"alpha": 0.2})
+
     def test_Tanh(self) -> None:
         self._test_op_upgrade("Tanh", 1, attrs={"consumed_inputs": [0]})
 
@@ -1718,8 +1893,8 @@ class TestAutomaticUpgrade(automatic_conversion_test_base.TestAutomaticConversio
     def test_GroupNormalization(self) -> None:
         self._test_op_upgrade(
             "GroupNormalization",
-            18,
-            [[3, 4, 2, 2], [1], [1]],
+            21,
+            [[3, 4, 2, 2], [4], [4]],
             [[3, 4, 2, 2]],
             attrs={"epsilon": 1e-5, "num_groups": 2},
         )
@@ -1742,6 +1917,22 @@ class TestAutomaticUpgrade(automatic_conversion_test_base.TestAutomaticConversio
             [TensorProto.BOOL],
         )
 
+    def test_TensorScatter(self) -> None:
+        self._test_op_upgrade(
+            "TensorScatter",
+            24,
+            [
+                [2, 3, 4, 5],
+                [2, 3, 2, 5],
+                [
+                    2,
+                ],
+            ],
+            [[2, 3, 4, 5]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.INT64],
+            [TensorProto.FLOAT],
+        )
+
     def test_ops_tested(self) -> None:
         # NOTE: This test is order dependent and needs to run last in this class
         all_schemas = onnx.defs.get_all_schemas()