onnx 1.16.2__cp312-cp312-win_amd64.whl → 1.18.0__cp312-cp312-win_amd64.whl

onnx/utils.py

@@ -5,111 +5,125 @@ 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 google.protobuf.internal.containers import RepeatedCompositeFieldContainer
+
 
 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.outmap = 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
+    @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_core(
+        self,
+        original_io: RepeatedCompositeFieldContainer[ValueInfoProto],
+        io_names_to_extract: list[str],
+    ) -> list[ValueInfoProto]:
         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 = []
-        for name in io_names_to_keep:
-            new_io_tensors.append(original_io_map[name])
-        for name in new_io_names_to_add:
-            # activation become input or output
-            new_io_tensors.append(self.vimap[name])
-
-        # 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]
+        for io_name_to_extract in io_names_to_extract:
+            if io_name_to_extract in original_io_map:
+                new_io_tensors.append(original_io_map[io_name_to_extract])
+            else:
+                new_io_tensors.append(self.vimap[io_name_to_extract])
+        return new_io_tensors  # same order as 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
+        return self._collect_new_io_core(self.graph.input, names)
 
     def _collect_new_outputs(self, names: list[str]) -> list[ValueInfoProto]:
-        return self._collect_new_io_core(self.graph.output, names)  # type: ignore
+        return self._collect_new_io_core(self.graph.output, names)
 
     def _dfs_search_reachable_nodes(
         self,
         node_output_name: str,
-        graph_input_names: list[str],
-        reachable_nodes: list[NodeProto],
+        graph_input_names: set[str],
+        reachable: set[int],
     ) -> None:
-        if node_output_name in graph_input_names:
-            return
-        for node in self.graph.node:
-            # check output_name first to reduce run time
-            if node_output_name not in node.output:
-                continue
-            if node in reachable_nodes:
+        """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
+            reachable (set of int): The set of indexes to reachable nodes in `nodes`
+        """
+        stack = [node_output_name]
+        while stack:
+            current_output_name = stack.pop()
+            # finish search at inputs
+            if current_output_name in graph_input_names:
                 continue
-            reachable_nodes.append(node)
-            for name in node.input:
-                self._dfs_search_reachable_nodes(
-                    name, graph_input_names, reachable_nodes
-                )
+            # 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,
         input_names: list[str],
         output_names: list[str],
     ) -> list[NodeProto]:
-        reachable_nodes = []  # type: ignore[var-annotated]
+        _input_names = set(input_names)
+        reachable: set[int] = set()
         for name in output_names:
-            self._dfs_search_reachable_nodes(name, input_names, reachable_nodes)
-        # needs to be topology sorted.
-        nodes = [n for n in self.graph.node if n in reachable_nodes]
-        return nodes
+            self._dfs_search_reachable_nodes(name, _input_names, reachable)
+        # needs to be topologically sorted
+        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(
@@ -117,11 +131,9 @@ 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]
         len_sparse_initializer = len(self.graph.sparse_initializer)
@@ -149,7 +161,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,
@@ -171,7 +182,6 @@ class Extractor:
         model = self._make_model(
             nodes, inputs, outputs, initializer, value_info, local_functions
         )
-
         return model
 
 
@@ -181,6 +191,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.
 
@@ -190,27 +201,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)
 
@@ -237,7 +274,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.16.2"
-git_version = "3bf92c03a9f27eba3bda1e5b9e63ea20ec213557"
+version = "1.18.0"
+git_version = "e709452ef2bbc1d113faf678c24e6d3467696e83"

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 {
@@ -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/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.empty() && 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());
+        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,7 +56,7 @@ 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/version_converter/adapters/axis_attribute_to_input.h

@@ -41,7 +41,7 @@ class AxisAttributeToInput : public Adapter {
   size_t axis_index;
   int64_t default_axis;
 
-  void AttrToInput(std::shared_ptr<Graph> graph, Node* node, int64_t axis, size_t axis_index) const {
+  void AttrToInput(const std::shared_ptr<Graph>& graph, Node* node, int64_t axis, size_t axis_index) const {
     const ArrayRef<Value*>& inputs = node->inputs();
 
     // Add the optional inputs if they don't exist
@@ -56,7 +56,7 @@ class AxisAttributeToInput : public Adapter {
     node->addInput(constant->output());
   }
 
-  Node* CreateAxisInput(std::shared_ptr<Graph> graph, Node* node, int64_t axis) const {
+  Node* CreateAxisInput(const std::shared_ptr<Graph>& graph, Node* node, int64_t axis) const {
     Tensor t;
     t.elem_type() = TensorProto_DataType_INT64;
     t.sizes() = std::vector<int64_t>{};

onnx/version_converter/adapters/axis_input_to_attribute.h

@@ -8,7 +8,6 @@
 
 #include <memory>
 #include <string>
-#include <utility>
 #include <vector>
 
 #include "onnx/version_converter/adapters/adapter.h"
@@ -62,27 +61,26 @@ class AxisInputToAttribute : public Adapter {
     if (int64s.empty()) {
       std::string raw_data = axis_node->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");
+          !raw_data.empty() && raw_data.size() % 8 == 0, "Raw Data must be non-empty and size must be a multiple of 8");
       const int64_t* raw = reinterpret_cast<const int64_t*>(raw_data.c_str());
       node->i_(kaxis, raw[0]);
     } else {
       node->i_(kaxis, int64s.at(0));
     }
     node->removeInput(this->axis_index);
-    if (axis_val->uses().size() < 1) {
+    if (axis_val->uses().empty()) {
       axis_node->destroy();
     }
   }
 
-  void HandleInitializerNode(std::shared_ptr<Graph> graph, Node* node, Value* axis_val) const {
+  void HandleInitializerNode(const std::shared_ptr<Graph>& graph, Node* node, Value* axis_val) const {
     const std::string initializer_name = axis_val->uniqueName();
     for (const auto& initializer : graph->initializers()) {
       if (initializer.name() == initializer_name) {
         node->i_(kaxis, initializer.int64s().at(0));
         node->removeInput(this->axis_index);
         // Remove initializer
-        if (axis_val->uses().size() < 1)
+        if (axis_val->uses().empty())
           graph->eraseInitializer(initializer_name);
         break;
       }

onnx/version_converter/adapters/broadcast_backward_compatibility.h

@@ -22,7 +22,7 @@ class BroadcastBackwardCompatibility final : public Adapter {
   explicit BroadcastBackwardCompatibility(const std::string& op_name, const OpSetID& initial, const OpSetID& target)
       : Adapter(op_name, initial, target) {}
 
-  void adapt_broadcast_backward_compatibility(std::shared_ptr<Graph>, Node* node) const {
+  void adapt_broadcast_backward_compatibility(const std::shared_ptr<Graph>&, Node* node) const {
     // Verify that broadcasts are allowed in limited spec of opset version 6
     // Multidirectional broadcasting, as defined in Broadcasting.md
     // MathDocGenerator provides differences

onnx/version_converter/adapters/broadcast_forward_compatibility.h

@@ -23,7 +23,7 @@ class BroadcastForwardCompatibility final : public Adapter {
   explicit BroadcastForwardCompatibility(const std::string& op_name, const OpSetID& initial, const OpSetID& target)
       : Adapter(op_name, initial, target) {}
 
-  void adapt_broadcast_forward_compatibility(std::shared_ptr<Graph> graph, Node* node) const {
+  void adapt_broadcast_forward_compatibility(const std::shared_ptr<Graph>& graph, Node* node) const {
     // Remove axis and broadcast attributes
     // Assess whether axis requires reshaping
     if (node->hasAttribute(kbroadcast)) {
@@ -44,7 +44,7 @@ class BroadcastForwardCompatibility final : public Adapter {
           new_sizes.reserve(new_sizes.size() + size);
           for (size_t i = 0; i < size; i++) {
             axes.emplace_back(B_sizes.size() + i);
-            new_sizes.emplace_back(Dimension(1));
+            new_sizes.emplace_back(1);
           }
           if (target_version().version() >= 13) { // Unsqueeze takes 'axes' input
             Tensor t;

onnx/version_converter/adapters/cast_9_8.h

@@ -19,7 +19,7 @@ class Cast_9_8 final : public Adapter {
  public:
   explicit Cast_9_8() : Adapter("Cast", OpSetID(9), OpSetID(8)) {}
 
-  void adapt_cast_9_8(std::shared_ptr<Graph>, Node* node) const {
+  void adapt_cast_9_8(const std::shared_ptr<Graph>&, Node* node) const {
     if (node->inputs()[0]->elemType() == TensorProto_DataType_STRING || node->i(kto) == TensorProto_DataType_STRING)
       ONNX_ASSERTM(false, "Casting From/To STRING data type is not supported")
   }

onnx/version_converter/adapters/clip_10_11.h

@@ -10,6 +10,8 @@
 #include <limits>
 #include <memory>
 
+#include "onnx/version_converter/adapters/adapter.h"
+
 namespace ONNX_NAMESPACE {
 namespace version_conversion {
 
@@ -17,7 +19,7 @@ class Clip_10_11 final : public Adapter {
  public:
   explicit Clip_10_11() : Adapter("Clip", OpSetID(10), OpSetID(11)) {}
 
-  void adapt_clip_10_11(std::shared_ptr<Graph> graph, Node* node) const {
+  void adapt_clip_10_11(const std::shared_ptr<Graph>& graph, Node* node) const {
     bool has_min = node->hasAttribute(kmin);
     bool has_max = node->hasAttribute(kmax);
 
@@ -35,7 +37,7 @@ class Clip_10_11 final : public Adapter {
     }
   }
 
-  void attrToInput(std::shared_ptr<Graph> graph, Node* node, float val) const {
+  void attrToInput(const std::shared_ptr<Graph>& graph, Node* node, float val) const {
     Tensor t;
     t.elem_type() = TensorProto_DataType_FLOAT;
     auto& data = t.floats();

onnx/version_converter/adapters/dropout_11_12.h

@@ -8,8 +8,11 @@
 
 #pragma once
 
+#include <cmath>
 #include <memory>
 
+#include "onnx/version_converter/adapters/adapter.h"
+
 namespace ONNX_NAMESPACE {
 namespace version_conversion {
 
@@ -17,8 +20,8 @@ class Dropout_11_12 final : public Adapter {
  public:
   explicit Dropout_11_12() : Adapter("Dropout", OpSetID(11), OpSetID(12)) {}
 
-  void adapt_dropout_11_12(std::shared_ptr<Graph> graph, Node* node) const {
-    float ratio;
+  void adapt_dropout_11_12(const std::shared_ptr<Graph>& graph, Node* node) const {
+    float ratio = NAN;
     if (node->hasAttribute(kratio)) {
       ratio = node->f(kratio);
       node->removeAttribute(kratio);

onnx/version_converter/adapters/extend_supported_types.h

@@ -24,7 +24,7 @@ struct ExtendSupportedTypes final : public Adapter {
       : Adapter(op_name, initial, target) {}
 
   Node* create_cast_op(
-      std::shared_ptr<Graph> graph,
+      const std::shared_ptr<Graph>& graph,
       ArrayRef<Value*> inputs,
       const int to_type,
       const std::vector<Dimension>& output_shape,
@@ -37,12 +37,12 @@ struct ExtendSupportedTypes final : public Adapter {
     return node;
   }
 
-  void adapt_type_extension(std::shared_ptr<Graph> graph, Node* node) const {
+  void adapt_type_extension(const std::shared_ptr<Graph>& graph, Node* node) const {
     const ArrayRef<Value*>& inputs = node->inputs();
     const ArrayRef<Value*>& outputs = node->outputs();
     const std::string original_output_name = node->output()->uniqueName();
 
-    const int input_type = inputs.size() > 0 ? inputs[0]->elemType() : -1;
+    const int input_type = !inputs.empty() ? inputs[0]->elemType() : -1;
     const int output_type = outputs[0]->elemType();
 
     const std::unordered_set<int>& supported_version8_types = {

onnx/version_converter/adapters/gemm_6_7.h

@@ -20,7 +20,7 @@ class Gemm_6_7 final : public Adapter {
  public:
   explicit Gemm_6_7() : Adapter("Gemm", OpSetID(6), OpSetID(7)) {}
 
-  void adapt_gemm_6_7(std::shared_ptr<Graph>, Node* node) const {
+  void adapt_gemm_6_7(const std::shared_ptr<Graph>&, Node* node) const {
     const ArrayRef<Value*>& inputs = node->inputs();
     assertInputsAvailable(inputs, name().c_str(), 3);
     const auto& A_shape = inputs[0]->sizes();

onnx/version_converter/adapters/gemm_7_6.h

@@ -20,7 +20,7 @@ class Gemm_7_6 final : public Adapter {
  public:
   explicit Gemm_7_6() : Adapter("Gemm", OpSetID(7), OpSetID(6)) {}
 
-  void adapt_gemm_7_6(std::shared_ptr<Graph>, Node* node) const {
+  void adapt_gemm_7_6(const std::shared_ptr<Graph>&, Node* node) const {
     const ArrayRef<Value*>& inputs = node->inputs();
     assertInputsAvailable(inputs, name().c_str(), 3);
     const auto& A_shape = inputs[0]->sizes();

onnx/version_converter/adapters/gridsample_19_20.h

@@ -10,6 +10,8 @@
 
 #include <memory>
 
+#include "onnx/version_converter/adapters/adapter.h"
+
 namespace ONNX_NAMESPACE {
 namespace version_conversion {
 
@@ -17,7 +19,7 @@ class GridSample_19_20 final : public Adapter {
  public:
   explicit GridSample_19_20() : Adapter("GridSample", OpSetID(19), OpSetID(20)) {}
 
-  void adapt_gridsample_19_20(std::shared_ptr<Graph>, Node* node) const {
+  void adapt_gridsample_19_20(const std::shared_ptr<Graph>&, Node* node) const {
     if (node->hasAttribute(kmode) && (node->s(kmode) == "bilinear")) {
       node->s_(kmode, "linear");
     }

onnx/version_converter/adapters/group_normalization_20_21.h

@@ -20,7 +20,7 @@ class GroupNormalization_20_21 final : public Adapter {
   explicit GroupNormalization_20_21() : Adapter("GroupNormalization", OpSetID(20), OpSetID(21)) {}
 
   void transform_input(
-      std::shared_ptr<Graph> graph,
+      const std::shared_ptr<Graph>& graph,
       Node* node,
       int64_t input_id,
       Value* reshape0_shape,
@@ -44,7 +44,7 @@ class GroupNormalization_20_21 final : public Adapter {
     node->replaceInput(input_id, reshape1->output());
   }
 
-  void adapt_group_normalization_20_21(std::shared_ptr<Graph> graph, Node* node) const {
+  void adapt_group_normalization_20_21(const std::shared_ptr<Graph>& graph, Node* node) const {
     // Perform following sequence of ops on scale/bias, effect is similar to numpy.repeat()
     //
     //   Shape<start=1,end=2>(input0) -- Div(Shape_out (C), num_groups)

onnx/version_converter/adapters/maxpool_8_7.h

@@ -19,7 +19,7 @@ class MaxPool_8_7 final : public Adapter {
  public:
   explicit MaxPool_8_7() : Adapter("MaxPool", OpSetID(8), OpSetID(7)) {}
 
-  void adapt_maxpool_8_7(std::shared_ptr<Graph>, Node* node) const {
+  void adapt_maxpool_8_7(const std::shared_ptr<Graph>&, Node* node) const {
     const ArrayRef<Value*>& outputs = node->outputs();
     ONNX_ASSERTM(outputs.size() != 2, "Opset version 7 of MaxPool cannot include Indices output");
     if (node->hasAttribute(kstorage_order))