onnx 1.17.0__cp312-cp312-macosx_12_0_universal2.whl → 1.19.0__cp312-cp312-macosx_12_0_universal2.whl

onnx/test/version_converter_test.py

@@ -4,7 +4,9 @@
 from __future__ import annotations
 
 import contextlib
+import os
 import struct
+import tempfile
 import unittest
 
 import numpy as np
@@ -1440,7 +1442,6 @@ class TestVersionConverter(unittest.TestCase):
         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,
@@ -2006,6 +2007,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),
@@ -2118,7 +2135,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(
@@ -2166,9 +2183,82 @@ 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)
 
+    def test_external_data_version_conversion(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Create a model with external data
+            shape = (2, 3)
+            random_data = np.random.rand(*shape).astype(np.float32)
+
+            initializer_tensor = onnx.helper.make_tensor(
+                name="initializer_tensor",
+                data_type=onnx.TensorProto.FLOAT,
+                dims=list(shape),
+                vals=random_data.tobytes(),
+                raw=True,
+            )
+            initializer_scalar = onnx.helper.make_tensor(
+                name="initializer_scalar",
+                data_type=onnx.TensorProto.FLOAT,
+                dims=[],
+                vals=[1.0],
+            )
+
+            add_node = onnx.helper.make_node(
+                "Add",
+                inputs=["initializer_tensor", "initializer_scalar"],
+                outputs=["sum_output"],
+            )
+
+            graph_def = onnx.helper.make_graph(
+                name="SimpleAddition",
+                nodes=[add_node],
+                inputs=[],
+                outputs=[
+                    onnx.helper.make_tensor_value_info(
+                        "sum_output", onnx.TensorProto.FLOAT, list(shape)
+                    )
+                ],
+                initializer=[initializer_tensor, initializer_scalar],
+            )
+
+            # Save model to file with external data
+            model_filename = os.path.join(temp_dir, "test_simple_add.onnx")
+            data_filename = "test_simple_add.onnx.data"  # Use relative path
+            opset_imports = [onnx.helper.make_opsetid("", 20)]
+            model_def = onnx.helper.make_model(graph_def, opset_imports=opset_imports)
+            model_def.ir_version = 10
+            onnx.save_model(
+                model_def,
+                model_filename,
+                save_as_external_data=True,
+                all_tensors_to_one_file=True,
+                location=data_filename,
+                size_threshold=0,
+                convert_attribute=False,
+            )
+
+            # Load the model and verify external data
+            converted_model = onnx.version_converter.convert_version(
+                onnx.load(model_filename, load_external_data=False), 21
+            )
+            self.assertEqual(len(converted_model.graph.initializer), 2)
+
+            # Verify the large tensor has external data
+            tensors = {init.name: init for init in converted_model.graph.initializer}
+            self.assertIn("initializer_tensor", tensors)
+            large_tensor = tensors["initializer_tensor"]
+            self.assertEqual(large_tensor.data_location, TensorProto.EXTERNAL)
+            self.assertEqual(len(large_tensor.external_data), 3)
+
+            # Convert external_data to dictionary for order-independent checking
+            external_data_dict = {ed.key: ed.value for ed in large_tensor.external_data}
+            self.assertEqual(external_data_dict["location"], data_filename)
+            self.assertEqual(external_data_dict["offset"], "0")
+            self.assertEqual(external_data_dict["length"], "24")
+
 
 if __name__ == "__main__":
     unittest.main()

onnx/test/version_utils.py

@@ -8,13 +8,13 @@ from packaging.version import parse as version
 
 def numpy_older_than(ver: str) -> bool:
     """Returns True if the numpy version is older than the given version."""
-    import numpy  # pylint: disable=import-outside-toplevel
+    import numpy  # noqa: PLC0415
 
     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
+    import PIL  # noqa: PLC0415
 
     return version(PIL.__version__) < version(ver)

onnx/tools/update_model_dims.py

@@ -53,7 +53,7 @@ def update_inputs_outputs_dims(
             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

onnx/utils.py

@@ -5,82 +5,94 @@ from __future__ import annotations
 
 import os
 import tarfile
+from collections import deque
+from typing import TYPE_CHECKING
 
 import onnx.checker
 import onnx.helper
 import onnx.shape_inference
-from onnx import FunctionProto, ModelProto, NodeProto, TensorProto, ValueInfoProto
+
+if TYPE_CHECKING:
+    from onnx.onnx_pb import (
+        FunctionProto,
+        ModelProto,
+        NodeProto,
+        TensorProto,
+        ValueInfoProto,
+    )
 
 
 class Extractor:
     def __init__(self, model: ModelProto) -> None:
-        self.model = onnx.shape_inference.infer_shapes(model)
+        self.model = model
         self.graph = self.model.graph
-        self.wmap = self._build_name2obj_dict(self.graph.initializer)
-        self.vimap = self._build_name2obj_dict(self.graph.value_info)
+        self.initializers: dict[str, TensorProto] = self._build_name2obj_dict(
+            self.graph.initializer
+        )
+        self.value_infos: dict[str, ValueInfoProto] = self._build_name2obj_dict(
+            self.graph.value_info
+        )
+        # Add input and output values (not included in the value_info for intermediate values)
+        self.value_infos.update(self._build_name2obj_dict(self.graph.input))
+        self.value_infos.update(self._build_name2obj_dict(self.graph.output))
+        self.outmap: dict[str, int] = self._build_output_dict(self.graph)
 
     @staticmethod
-    def _build_name2obj_dict(objs):  # type: ignore
+    def _build_name2obj_dict(objs) -> dict:
         return {obj.name: obj for obj in objs}
 
-    def _collect_new_io_core(self, original_io, io_names_to_extract):  # type: ignore
-        original_io_map = self._build_name2obj_dict(original_io)
-        original_io_names = set(original_io_map)
-        s_io_names_to_extract = set(io_names_to_extract)
-        io_names_to_keep = s_io_names_to_extract & original_io_names
-        new_io_names_to_add = s_io_names_to_extract - original_io_names
-
-        new_io_tensors = [original_io_map[name] for name in io_names_to_keep]
-        # activation become input or output
-        new_io_tensors.extend(self.vimap[name] for name in new_io_names_to_add)
-
-        # adjust sequence
-        new_io_tensors_map = self._build_name2obj_dict(new_io_tensors)
-        return [new_io_tensors_map[name] for name in io_names_to_extract]
-
-    def _collect_new_inputs(self, names: list[str]) -> list[ValueInfoProto]:
-        return self._collect_new_io_core(self.graph.input, names)  # type: ignore
-
-    def _collect_new_outputs(self, names: list[str]) -> list[ValueInfoProto]:
-        return self._collect_new_io_core(self.graph.output, names)  # type: ignore
+    @staticmethod
+    def _build_output_dict(graph) -> dict[str, int]:
+        output_to_index: dict[str, int] = {}
+        for index, node in enumerate(graph.node):
+            for output_name in node.output:
+                if output_name == "":
+                    continue
+                assert output_name not in output_to_index  # output_name is unique
+                output_to_index[output_name] = index
+        return output_to_index
+
+    def _collect_new_io(self, io_names_to_extract: list[str]) -> list[ValueInfoProto]:
+        # Validate that all names exist in self.value_infos
+        missing_names = [
+            name for name in io_names_to_extract if name not in self.value_infos
+        ]
+        if missing_names:
+            raise ValueError(
+                f"The following names were not found in value_infos: {', '.join(missing_names)}"
+            )
+        return [self.value_infos[name] for name in io_names_to_extract]
 
     def _dfs_search_reachable_nodes(
         self,
         node_output_name: str,
         graph_input_names: set[str],
-        nodes: list[NodeProto],
         reachable: set[int],
-        unreachable: set[int],
     ) -> None:
         """Helper function to find nodes which are connected to an output
 
         Arguments:
             node_output_name (str): The name of the output
             graph_input_names (set of string): The names of all inputs of the graph
-            nodes (list of nodes): The list of all nodes of the graph
             reachable (set of int): The set of indexes to reachable nodes in `nodes`
-            unreachable (set of int): The set of indexes to unreachable nodes in `nodes`
         """
-        # finish search at inputs
-        if node_output_name in graph_input_names:
-            return
-
-        # find nodes connected to this output
-        nodes_to_search = [
-            index for index in unreachable if node_output_name in nodes[index].output
-        ]
-
-        # add nodes connected to this output to sets
-        for node_index in nodes_to_search:
-            reachable.add(node_index)
-            unreachable.remove(node_index)
-
-        # recurse on inputs
-        for node_index in nodes_to_search:
-            for name in nodes[node_index].input:
-                self._dfs_search_reachable_nodes(
-                    name, graph_input_names, nodes, reachable, unreachable
-                )
+        stack = [node_output_name]
+        while stack:
+            current_output_name = stack.pop()
+            # finish search at inputs
+            if current_output_name in graph_input_names:
+                continue
+            # find nodes connected to this output
+            if current_output_name in self.outmap:
+                index = self.outmap[current_output_name]
+                if index not in reachable:
+                    # add nodes connected to this output to sets
+                    reachable.add(index)
+                    stack += [
+                        input_name
+                        for input_name in self.graph.node[index].input
+                        if input_name != ""
+                    ]
 
     def _collect_reachable_nodes(
         self,
@@ -88,48 +100,33 @@ class Extractor:
         output_names: list[str],
     ) -> list[NodeProto]:
         _input_names = set(input_names)
-        nodes = list(self.graph.node)
         reachable: set[int] = set()
-        unreachable: set[int] = set(range(len(nodes)))
         for name in output_names:
-            self._dfs_search_reachable_nodes(
-                name, _input_names, nodes, reachable, unreachable
-            )
+            self._dfs_search_reachable_nodes(name, _input_names, reachable)
         # needs to be topologically sorted
-        nodes = [nodes[node_index] for node_index in sorted(reachable)]
-        return nodes
+        return [self.graph.node[index] for index in sorted(reachable)]
 
     def _collect_referred_local_functions(
         self,
-        nodes,  # type: list[NodeProto]
-    ):  # type: (...) -> list[FunctionProto]
+        nodes: list[NodeProto],
+    ) -> list[FunctionProto]:
         # a node in a model graph may refer a function.
         # a function contains nodes, some of which may in turn refer a function.
         # we need to find functions referred by graph nodes and
         # by nodes used to define functions.
-        def find_referred_funcs(nodes, referred_local_functions):  # type: ignore
-            new_nodes = []  # type: list[NodeProto]
-            for node in nodes:
-                # check if the node is a function op
-                match_function = next(
-                    (
-                        f
-                        for f in self.model.functions
-                        if f.name == node.op_type and f.domain == node.domain
-                    ),
-                    None,
-                )
-                if match_function and match_function not in referred_local_functions:
-                    referred_local_functions.append(match_function)
-                    new_nodes.extend(match_function.node)
-
-            return new_nodes
-
-        referred_local_functions = []  # type: list[FunctionProto]
-        new_nodes = find_referred_funcs(nodes, referred_local_functions)
-        while new_nodes:
-            new_nodes = find_referred_funcs(new_nodes, referred_local_functions)
-
+        function_map: dict[tuple[str, str], FunctionProto] = {}
+        for function in self.model.functions:
+            function_map[(function.name, function.domain)] = function
+        referred_local_functions: list[FunctionProto] = []
+        queue = deque(nodes)
+        while queue:
+            node = queue.popleft()
+            # check if the node is a function op
+            if (node.op_type, node.domain) in function_map:
+                function = function_map.pop((node.op_type, node.domain))
+                referred_local_functions.append(function)
+                queue.extend(function.node)
+        # needs to be topologically sorted
         return referred_local_functions
 
     def _collect_reachable_tensors(
@@ -137,13 +134,15 @@ class Extractor:
         nodes: list[NodeProto],
     ) -> tuple[list[TensorProto], list[ValueInfoProto]]:
         all_tensors_names: set[str] = set()
-
         for node in nodes:
             all_tensors_names.update(node.input)
             all_tensors_names.update(node.output)
-
-        initializer = [self.wmap[t] for t in self.wmap if t in all_tensors_names]
-        value_info = [self.vimap[t] for t in self.vimap if t in all_tensors_names]
+        initializer = [
+            self.initializers[t] for t in self.initializers if t in all_tensors_names
+        ]
+        value_info = [
+            self.value_infos[t] for t in self.value_infos if t in all_tensors_names
+        ]
         len_sparse_initializer = len(self.graph.sparse_initializer)
         if len_sparse_initializer != 0:
             raise ValueError(
@@ -169,7 +168,6 @@ class Extractor:
         graph = onnx.helper.make_graph(
             nodes, name, inputs, outputs, initializer=initializer, value_info=value_info
         )
-
         meta = {
             "ir_version": self.model.ir_version,
             "opset_imports": self.model.opset_import,
@@ -183,15 +181,14 @@ class Extractor:
         input_names: list[str],
         output_names: list[str],
     ) -> ModelProto:
-        inputs = self._collect_new_inputs(input_names)
-        outputs = self._collect_new_outputs(output_names)
+        inputs = self._collect_new_io(input_names)
+        outputs = self._collect_new_io(output_names)
         nodes = self._collect_reachable_nodes(input_names, output_names)
         initializer, value_info = self._collect_reachable_tensors(nodes)
         local_functions = self._collect_referred_local_functions(nodes)
         model = self._make_model(
             nodes, inputs, outputs, initializer, value_info, local_functions
         )
-
         return model
 
 
@@ -201,6 +198,7 @@ def extract_model(
     input_names: list[str],
     output_names: list[str],
     check_model: bool = True,
+    infer_shapes: bool = True,
 ) -> None:
     """Extracts sub-model from an ONNX model.
 
@@ -210,27 +208,53 @@ def extract_model(
     which is defined by the input and output tensors, should not _cut through_ the
     subgraph that is connected to the _main graph_ as attributes of these operators.
 
+    Note: When the extracted model size is larger than 2GB, the extra data will be saved in "output_path.data".
+
     Arguments:
         input_path (str | os.PathLike): The path to original ONNX model.
         output_path (str | os.PathLike): The path to save the extracted ONNX model.
         input_names (list of string): The names of the input tensors that to be extracted.
         output_names (list of string): The names of the output tensors that to be extracted.
-        check_model (bool): Whether to run model checker on the extracted model.
+        check_model (bool): Whether to run model checker on the original model and the extracted model.
+        infer_shapes (bool): Whether to infer the shapes of the original model.
     """
     if not os.path.exists(input_path):
         raise ValueError(f"Invalid input model path: {input_path}")
     if not output_path:
         raise ValueError("Output model path shall not be empty!")
+    if not input_names:
+        raise ValueError("Input tensor names shall not be empty!")
     if not output_names:
         raise ValueError("Output tensor names shall not be empty!")
 
-    onnx.checker.check_model(input_path)
-    model = onnx.load(input_path)
+    if len(input_names) != len(set(input_names)):
+        raise ValueError("Duplicate names found in the input tensor names.")
+    if len(output_names) != len(set(output_names)):
+        raise ValueError("Duplicate names found in the output tensor names.")
+
+    if check_model:
+        onnx.checker.check_model(input_path)
+
+    if infer_shapes and os.path.getsize(input_path) > onnx.checker.MAXIMUM_PROTOBUF:
+        onnx.shape_inference.infer_shapes_path(input_path, output_path)
+        model = onnx.load(output_path)
+    elif infer_shapes:
+        model = onnx.load(input_path, load_external_data=False)
+        model = onnx.shape_inference.infer_shapes(model)
+        base_dir = os.path.dirname(input_path)
+        onnx.load_external_data_for_model(model, base_dir)
+    else:
+        model = onnx.load(input_path)
 
     e = Extractor(model)
     extracted = e.extract_model(input_names, output_names)
 
-    onnx.save(extracted, output_path)
+    if extracted.ByteSize() > onnx.checker.MAXIMUM_PROTOBUF:
+        location = os.path.basename(output_path) + ".data"
+        onnx.save(extracted, output_path, save_as_external_data=True, location=location)
+    else:
+        onnx.save(extracted, output_path)
+
     if check_model:
         onnx.checker.check_model(output_path)
 
@@ -257,7 +281,7 @@ def _tar_members_filter(
                 f"The tarball member {member_path} in downloading model contains "
                 f"directory traversal sequence which may contain harmful payload."
             )
-        elif member.issym() or member.islnk():
+        if member.issym() or member.islnk():
             raise RuntimeError(
                 f"The tarball member {member_path} in downloading model contains "
                 f"symbolic links which may contain harmful payload."

onnx/version.py

@@ -1,5 +1,5 @@
 # This file is generated by setup.py. DO NOT EDIT!
 
 
-version = "1.17.0"
-git_version = "b8baa8446686496da4cc8fda09f2b6fe65c2a02c"
+version = "1.19.0"
+git_version = "57b9c6a4f6eebb09ae1b34cfb632078518f72832"

onnx/version_converter/BaseConverter.h

@@ -8,19 +8,14 @@
 
 #pragma once
 
-#include <stdlib.h>
-
-#include <iostream>
-#include <map>
+#include <cstdlib>
 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <utility>
 
 #include "onnx/common/ir.h"
-#include "onnx/common/ir_pb_converter.h"
 #include "onnx/defs/schema.h"
-#include "onnx/proto_utils.h"
 #include "onnx/version_converter/adapters/adapter.h"
 
 namespace ONNX_NAMESPACE {
@@ -67,14 +62,14 @@ class BaseVersionConverter {
         if (adapter_ptr != target_map->second.end()) {
           return *(adapter_ptr->second);
         } else {
-          ONNX_ASSERTM(false, "No Adapter To Version %s for %s", target.c_str(), op_name.c_str());
+          ONNX_ASSERTM(false, "No Adapter To Version %s for %s", target.c_str(), op_name.c_str())
         }
       } else {
-        ONNX_ASSERTM(false, "No Adapter From Version %s for %s", initial.c_str(), op_name.c_str());
+        ONNX_ASSERTM(false, "No Adapter From Version %s for %s", initial.c_str(), op_name.c_str())
       }
     } else {
       // No adapters exist for the given op
-      ONNX_ASSERTM(false, "No Adapter For %s", op_name.c_str());
+      ONNX_ASSERTM(false, "No Adapter For %s", op_name.c_str())
     }
   }
 
@@ -87,7 +82,7 @@ class BaseVersionConverter {
     adapters[a_ptr->name()][iv.toString()][tv.toString()] = std::move(a_ptr);
   }
 
-  void registerAdapter(const char* op, int64_t from, int64_t to, NodeTransformerFunction transformer) {
+  void registerAdapter(const char* op, int64_t from, int64_t to, const NodeTransformerFunction& transformer) {
     registerAdapter(std::make_unique<GenericAdapter>(op, from, to, transformer));
   }
 };

onnx/version_converter/adapters/Attention_24_23.h

@@ -0,0 +1,42 @@
+// Copyright (c) ONNX Project Contributors
+
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Adapter for Attention in default domain from version 24 to 23
+
+#pragma once
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Attention_24_23 final : public Adapter {
+ public:
+  explicit Attention_24_23() : Adapter("Attention", OpSetID(24), OpSetID(23)) {}
+
+  void adapt_attention_24_23(const std::shared_ptr<Graph>&, Node* node) const {
+    const ArrayRef<Value*>& inputs = node->inputs();
+
+    // Check if nonpad_kv_seqlen input is present (input index 6)
+    if (inputs.size() > 6) {
+      ONNX_ASSERTM(
+          false,
+          "%s being converted from %d to %d has nonpad_kv_seqlen input, "
+          "which is not supported in opset 23. This conversion cannot be performed.",
+          name().c_str(),
+          initial_version().version(),
+          target_version().version());
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_attention_24_23(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE

onnx/version_converter/adapters/adapter.h

@@ -11,6 +11,7 @@
 #include <functional>
 #include <memory>
 #include <string>
+#include <utility>
 
 #include "onnx/onnx_pb.h"
 #include "onnx/version_converter/helper.h"
@@ -27,8 +28,10 @@ class Adapter {
  public:
   virtual ~Adapter() noexcept = default;
 
-  explicit Adapter(const std::string& name, const OpSetID& initial_version, const OpSetID& target_version)
-      : name_(name), initial_version_(initial_version), target_version_(target_version) {}
+  Adapter(std::string name, OpSetID initial_version, OpSetID target_version)
+      : name_(std::move(name)),
+        initial_version_(std::move(initial_version)),
+        target_version_(std::move(target_version)) {}
 
   // This will almost always return its own node argument after modifying it in place.
   // The only exception are adapters for deprecated operators: in this case the input
@@ -54,7 +57,7 @@ using NodeTransformerFunction = std::function<Node*(std::shared_ptr<Graph>, Node
 class GenericAdapter final : public Adapter {
  public:
   GenericAdapter(const char* op, int64_t from, int64_t to, NodeTransformerFunction transformer)
-      : Adapter(op, OpSetID(from), OpSetID(to)), transformer_(transformer) {}
+      : Adapter(op, OpSetID(from), OpSetID(to)), transformer_(std::move(transformer)) {}
 
   Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
     return transformer_(graph, node);

onnx/version_converter/adapters/axes_attribute_to_input.h

@@ -22,7 +22,7 @@ class AxesAttributeToInput : public Adapter {
   explicit AxesAttributeToInput(const std::string& op_name, const OpSetID& initial, const OpSetID& target)
       : Adapter(op_name, initial, target) {}
 
-  void attrToInput(std::shared_ptr<Graph> graph, Node* node, std::vector<int64_t> axes) const {
+  void attrToInput(const std::shared_ptr<Graph>& graph, Node* node, const std::vector<int64_t>& axes) const {
     Tensor t;
     t.elem_type() = TensorProto_DataType_INT64;
     t.sizes() = std::vector<int64_t>{static_cast<int64_t>(axes.size())};

onnx/version_converter/adapters/axes_input_to_attribute.h

@@ -37,16 +37,16 @@ class AxesInputToAttribute : public Adapter {
         // Also handle raw data
         std::string raw_data = node_ptr->t(kvalue).raw();
         ONNX_ASSERTM(
-            raw_data.size() != 0 && raw_data.size() % 8 == 0,
-            "Raw Data must be non-empty and size must be a multiple of 8");
-        int64_t* raw = (int64_t*)const_cast<char*>(raw_data.c_str());
+            !raw_data.empty() && raw_data.size() % 8 == 0,
+            "Raw Data must be non-empty and size must be a multiple of 8")
+        int64_t* raw = reinterpret_cast<int64_t*>(raw_data.data());
         node->is_(kaxes, std::vector<int64_t>(raw, raw + node_ptr->t(kvalue).size_from_dim(0)));
       } else {
         node->is_(kaxes, std::forward<const std::vector<int64_t>>(int64s));
       }
       // If Constant node isn't used anywhere else, remove it
       node->removeInput(1);
-      if (const_val->uses().size() < 1) {
+      if (const_val->uses().empty()) {
         node_ptr->destroy();
       }
     } else {
@@ -56,13 +56,13 @@ class AxesInputToAttribute : public Adapter {
           node->is_(kaxes, std::forward<const std::vector<int64_t>>(initializer.int64s()));
           node->removeInput(1);
           // Remove initializer
-          if (const_val->uses().size() < 1)
+          if (const_val->uses().empty())
             graph->eraseInitializerAndInput(const_val);
           break;
         }
       }
     }
-    ONNX_ASSERTM(node->hasAttribute(kaxes), "No initializer or constant input to node found");
+    ONNX_ASSERTM(node->hasAttribute(kaxes), "No initializer or constant input to node found")
     return node;
   }
 };