onnx 1.16.2__cp311-cp311-win32.whl → 1.18.0__cp311-cp311-win32.whl

onnx/test/version_converter/automatic_upgrade_test.py

@@ -1,6 +1,8 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
 import unittest
 
 import automatic_conversion_test_base
@@ -112,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",
@@ -1094,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",
@@ -1716,8 +1890,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},
         )

onnx/test/version_converter_test.py

@@ -1,11 +1,11 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import contextlib
 import struct
 import unittest
-from typing import Optional, Tuple
 
 import numpy as np
 import parameterized
@@ -1439,6 +1439,24 @@ class TestVersionConverter(unittest.TestCase):
         assert converted_model.graph.node[0].op_type == "Split"
         assert converted_model.opset_import[0].version == 12
 
+    def test_split_with_optional_input(self) -> None:
+        nodes = [helper.make_node("Split", ["X"], ["Y1", "Y2"], axis=1)]
+        graph = helper.make_graph(
+            nodes,
+            "test_split_optional_input",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (6,))],
+            [
+                helper.make_tensor_value_info("Y1", TensorProto.FLOAT, (3,)),
+                helper.make_tensor_value_info("Y2", TensorProto.FLOAT, (3,)),
+            ],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 12), 18)
+
+        assert converted_model.graph.node[0].op_type == "Split"
+        assert converted_model.opset_import[0].version == 18
+
+        assert len(converted_model.graph.node[0].output) == 2
+
     # Test Split Adapter: 12 -> 13
     def test_split_12_13(self) -> None:
         nodes = [helper.make_node("Split", ["X"], ["Y1", "Y2"], split=[2, 3])]
@@ -1987,6 +2005,22 @@ class TestVersionConverter(unittest.TestCase):
         assert converted_model.graph.node[3].op_type == "Reshape"
         assert converted_model.opset_import[0].version == 13
 
+    def test_softmax_13_12(self) -> None:
+        axis = -1
+        nodes = [helper.make_node("Softmax", ["X"], ["Y"], axis=axis)]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (1, 2, 3))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (1, 2, 3))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 13), 12)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Softmax"
+        assert converted_model.graph.node[0].attribute[0].name == "axis"
+        assert converted_model.graph.node[0].attribute[0].i == 2
+        assert converted_model.opset_import[0].version == 12
+
     @parameterized.parameterized.expand(
         [
             ("per_tensor", (16, 3), (1,), None, None, None, TensorProto.INT8, True),
@@ -2057,12 +2091,12 @@ class TestVersionConverter(unittest.TestCase):
     def test_quantize_21_20(
         self,
         _: str,
-        x_shape: Tuple[int, ...],
-        scale_shape: Tuple[int, ...],
+        x_shape: tuple[int, ...],
+        scale_shape: tuple[int, ...],
         axis: int,
         block_size: int,
-        output_dtype: Optional[int],
-        zero_point_dtype: Optional[int],
+        output_dtype: int | None,
+        zero_point_dtype: int | None,
         compatible: bool,
     ) -> None:
         def test(
@@ -2099,7 +2133,7 @@ class TestVersionConverter(unittest.TestCase):
         context_manager = (
             contextlib.nullcontext() if compatible else self.assertRaises(RuntimeError)
         )
-        with context_manager:  # type: ignore[attr-defined]
+        with context_manager:
             test(x_shape, scale_shape, axis, block_size, output_dtype, zero_point_dtype)
 
     @parameterized.parameterized.expand(
@@ -2116,8 +2150,8 @@ class TestVersionConverter(unittest.TestCase):
     def test_dequantize_21_20(
         self,
         _: str,
-        y_shape: Tuple[int, ...],
-        scale_shape: Tuple[int, ...],
+        y_shape: tuple[int, ...],
+        scale_shape: tuple[int, ...],
         axis: int,
         block_size: int,
         compatible: bool,
@@ -2147,7 +2181,7 @@ class TestVersionConverter(unittest.TestCase):
         context_manager = (
             contextlib.nullcontext() if compatible else self.assertRaises(RuntimeError)
         )
-        with context_manager:  # type: ignore[attr-defined]
+        with context_manager:
             test(y_shape, scale_shape, axis, block_size)
 
 

onnx/test/version_utils.py

@@ -1,6 +1,7 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 from packaging.version import parse as version
 
@@ -10,3 +11,10 @@ def numpy_older_than(ver: str) -> bool:
     import numpy  # pylint: disable=import-outside-toplevel
 
     return version(numpy.__version__) < version(ver)
+
+
+def pillow_older_than(ver: str) -> bool:
+    """Returns True if the pillow version is older than the given version."""
+    import PIL  # pylint: disable=import-outside-toplevel
+
+    return version(PIL.__version__) < version(ver)

onnx/tools/net_drawer.py

@@ -13,11 +13,12 @@
 # with the graphviz `dot` utility, like so:
 #
 #   $ dot -Tsvg my_output.dot -o my_output.svg
+from __future__ import annotations
 
 import argparse
 import json
 from collections import defaultdict
-from typing import Any, Callable, Dict, Optional
+from typing import Any, Callable
 
 import pydot
 
@@ -70,16 +71,16 @@ def GetOpNodeProducer(  # noqa: N802
 
 def GetPydotGraph(  # noqa: N802
     graph: GraphProto,
-    name: Optional[str] = None,
+    name: str | None = None,
     rankdir: str = "LR",
-    node_producer: Optional[_NodeProducer] = None,
+    node_producer: _NodeProducer | None = None,
     embed_docstring: bool = False,
 ) -> pydot.Dot:
     if node_producer is None:
         node_producer = GetOpNodeProducer(embed_docstring=embed_docstring, **OP_STYLE)
     pydot_graph = pydot.Dot(name, rankdir=rankdir)
-    pydot_nodes: Dict[str, pydot.Node] = {}
-    pydot_node_counts: Dict[str, int] = defaultdict(int)
+    pydot_nodes: dict[str, pydot.Node] = {}
+    pydot_node_counts: dict[str, int] = defaultdict(int)
     for op_id, op in enumerate(graph.node):
         op_node = node_producer(op, op_id)
         pydot_graph.add_node(op_node)

onnx/tools/replace_constants.py

@@ -1,7 +1,7 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
-from typing import List, Optional, Union
+from __future__ import annotations
 
 import numpy as np
 
@@ -30,7 +30,7 @@ from onnx.numpy_helper import from_array
 
 def _replace_constant(
     node: NodeProto, threshold: int, value_constant_of_shape: float
-) -> List[NodeProto]:
+) -> list[NodeProto]:
     """Replaces a Constant node with a large tensor (with more than threshold elements) by a sequence of nodes that produces a dummy constant of same shape as original tensor."""
     if node.op_type != "Constant":
         raise TypeError(f"Node type must be 'Constant' not {node.op_type!r}.")
@@ -69,8 +69,8 @@ def _replace_constant(
 
 
 def _replace_constant_of_shape_with_range(
-    onx: Union[GraphProto, FunctionProto]
-) -> Union[GraphProto, FunctionProto]:
+    onx: GraphProto | FunctionProto,
+) -> GraphProto | FunctionProto:
     """Replaces all *ConstantOfShape* by node *Range* to avoid constant tensors.
 
     The function is not recursive. The recursivity is done by
@@ -157,8 +157,8 @@ def _replace_constant_of_shape_with_range(
 
 
 def _replace_constant_of_shape_value(
-    onx: Union[GraphProto, FunctionProto], value_constant_of_shape: float
-) -> Union[GraphProto, FunctionProto]:
+    onx: GraphProto | FunctionProto, value_constant_of_shape: float
+) -> GraphProto | FunctionProto:
     """Replaces all fill value of all nodes *ConstantOfShape*."""
     if isinstance(onx, GraphProto):
         nodes = list(onx.node)
@@ -212,9 +212,9 @@ def _replace_constant_of_shape_value(
 
 
 def replace_initializer_by_constant_of_shape(  # noqa: PLR0911
-    onx: Union[FunctionProto, GraphProto, ModelProto],
+    onx: FunctionProto | GraphProto | ModelProto,
     threshold: int = 128,
-    ir_version: Optional[int] = None,
+    ir_version: int | None = None,
     use_range: bool = False,
     value_constant_of_shape: float = 0.5,
 ):
@@ -244,7 +244,7 @@ def replace_initializer_by_constant_of_shape(  # noqa: PLR0911
     """
     if isinstance(onx, FunctionProto):
         modified = False
-        new_nodes: List[NodeProto] = []
+        new_nodes: list[NodeProto] = []
         for node in onx.node:
             if node.op_type == "Constant":
                 cst_nodes = _replace_constant(node, threshold, value_constant_of_shape)
@@ -331,7 +331,7 @@ def replace_initializer_by_constant_of_shape(  # noqa: PLR0911
     removed = set()
     additional_inputs = []
 
-    new_inits: List[TensorProto] = []
+    new_inits: list[TensorProto] = []
     for init in onx.initializer:
         dims = tuple(init.dims)
         size = np.prod(dims)
@@ -357,7 +357,7 @@ def replace_initializer_by_constant_of_shape(  # noqa: PLR0911
                 make_tensor_value_info(new_name, TensorProto.INT64, [len(dims)])
             )
 
-    new_sparse_inits: List[SparseTensorProto] = []
+    new_sparse_inits: list[SparseTensorProto] = []
     for sp_init in onx.sparse_initializer:
         dims = tuple(sp_init.dims)
         size = np.prod(dims)

onnx/tools/update_model_dims.py

@@ -1,8 +1,9 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
-from typing import Any, Dict, List, Set
+from typing import Any
 
 import onnx.checker
 from onnx import ModelProto, ValueInfoProto
@@ -10,8 +11,8 @@ from onnx import ModelProto, ValueInfoProto
 
 def update_inputs_outputs_dims(
     model: ModelProto,
-    input_dims: Dict[str, List[Any]],
-    output_dims: Dict[str, List[Any]],
+    input_dims: dict[str, list[Any]],
+    output_dims: dict[str, list[Any]],
 ) -> ModelProto:
     """This function updates the dimension sizes of the model's inputs and outputs to the values
     provided in input_dims and output_dims. if the dim value provided is negative, a unique dim_param
@@ -43,16 +44,16 @@ def update_inputs_outputs_dims(
         updated_model = update_inputs_outputs_dims(model, input_dims, output_dims)
         onnx.save(updated_model, 'model.onnx')
     """
-    dim_param_set: Set[str] = set()
+    dim_param_set: set[str] = set()
 
     def init_dim_param_set(
-        dim_param_set: Set[str], value_infos: List[ValueInfoProto]
+        dim_param_set: set[str], value_infos: list[ValueInfoProto]
     ) -> None:
         for info in value_infos:
             shape = info.type.tensor_type.shape
             for dim in shape.dim:
                 if dim.HasField("dim_param"):
-                    dim_param_set.add(dim.dim_param)  # type: ignore
+                    dim_param_set.add(dim.dim_param)
 
     init_dim_param_set(dim_param_set, model.graph.input)  # type: ignore
     init_dim_param_set(dim_param_set, model.graph.output)  # type: ignore
@@ -77,7 +78,7 @@ def update_inputs_outputs_dims(
         elif isinstance(dim, str):
             dim_proto.dim_param = dim
         else:
-            raise ValueError(
+            raise ValueError(  # noqa: TRY004
                 f"Only int or str is accepted as dimension value, incorrect type: {type(dim)}"
             )