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

onnx/version_converter/adapters/pad_10_11.h

@@ -11,6 +11,8 @@
 #include <memory>
 #include <vector>
 
+#include "onnx/version_converter/adapters/adapter.h"
+
 namespace ONNX_NAMESPACE {
 namespace version_conversion {
 
@@ -18,7 +20,7 @@ class Pad_10_11 final : public Adapter {
  public:
   explicit Pad_10_11() : Adapter("Pad", OpSetID(10), OpSetID(11)) {}
 
-  void adapt_pad_10_11(std::shared_ptr<Graph> graph, Node* node) const {
+  void adapt_pad_10_11(const std::shared_ptr<Graph>& graph, Node* node) const {
     // Turn pads attribute into input
     Tensor t_pads;
     t_pads.elem_type() = TensorProto_DataType_INT64;

onnx/version_converter/adapters/q_dq_21_20.h

@@ -27,7 +27,7 @@ class QuantizeLinear_21_20 final : public TypeRestriction {
   explicit QuantizeLinear_21_20()
       : TypeRestriction("QuantizeLinear", OpSetID(21), OpSetID(20), q_dq_20_unallowed_types) {}
 
-  void adapt_quantize_linear_21_20(std::shared_ptr<Graph>, Node* node) const {
+  void adapt_quantize_linear_21_20(const std::shared_ptr<Graph>&, Node* node) const {
     if (node->hasAttribute(kblock_size)) {
       if ((node->i(kblock_size) != 0)) {
         ONNX_ASSERTM(false, "Blocked quantization is not supported for Opset Version %d.", target_version().version())
@@ -57,7 +57,7 @@ class DequantizeLinear_21_20 final : public TypeRestriction {
   explicit DequantizeLinear_21_20()
       : TypeRestriction("DequantizeLinear", OpSetID(21), OpSetID(20), q_dq_20_unallowed_types) {}
 
-  void adapt_dequantize_linear_21_20(std::shared_ptr<Graph>, Node* node) const {
+  void adapt_dequantize_linear_21_20(const std::shared_ptr<Graph>&, Node* node) const {
     if (node->hasAttribute(kblock_size)) {
       if ((node->i(kblock_size) != 0)) {
         ONNX_ASSERTM(false, "Blocked quantization is not supported for Opset Version %d.", target_version().version())

onnx/version_converter/adapters/reshape_4_5.h

@@ -19,7 +19,7 @@ class Reshape_4_5 final : public RemoveConsumedInputs {
  public:
   explicit Reshape_4_5() : RemoveConsumedInputs("Reshape", OpSetID(4), OpSetID(5)) {}
 
-  void adapt_reshape_4_5(std::shared_ptr<Graph> graph, Node* node) const {
+  void adapt_reshape_4_5(const std::shared_ptr<Graph>& graph, Node* node) const {
     // Create Input from Attribute - add as Initializer
     // Create tensor for value attribute
     Tensor t;

onnx/version_converter/adapters/reshape_5_4.h

@@ -21,7 +21,7 @@ class Reshape_5_4 final : public Adapter {
  public:
   explicit Reshape_5_4() : Adapter("Reshape", OpSetID(5), OpSetID(4)) {}
 
-  void adapt_reshape_5_4(std::shared_ptr<Graph> graph, Node* node) const {
+  void adapt_reshape_5_4(const std::shared_ptr<Graph>& graph, Node* node) const {
     // Identify if shape is statically determined; if so, feed as attribute
     const ArrayRef<Value*>& inputs = node->inputs();
     // Get shape from initializer or constant operator, not actual shape
@@ -35,16 +35,16 @@ class Reshape_5_4 final : 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_(kshape, std::vector<int64_t>(raw, raw + node_ptr->t(kvalue).size_from_dim(0)));
       } else {
         node->is_(kshape, 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 {
@@ -54,7 +54,7 @@ class Reshape_5_4 final : public Adapter {
           node->is_(kshape, 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/resize_10_11.h

@@ -11,6 +11,8 @@
 #include <memory>
 #include <vector>
 
+#include "onnx/version_converter/adapters/adapter.h"
+
 namespace ONNX_NAMESPACE {
 namespace version_conversion {
 
@@ -18,7 +20,7 @@ class Resize_10_11 final : public Adapter {
  public:
   explicit Resize_10_11() : Adapter("Resize", OpSetID(10), OpSetID(11)) {}
 
-  void adapt_resize_10_11(std::shared_ptr<Graph> graph, Node* node) const {
+  void adapt_resize_10_11(const std::shared_ptr<Graph>& graph, Node* node) const {
     int input_rank = node->inputs()[0]->sizes().size();
 
     Value* scales_input = node->inputs()[1];

onnx/version_converter/adapters/scan_8_9.h

@@ -19,7 +19,7 @@ namespace version_conversion {
 struct Scan_8_9 final : public Adapter {
   explicit Scan_8_9() : Adapter("Scan", OpSetID(8), OpSetID(9)) {}
 
-  void adapt_scan_8_9(std::shared_ptr<Graph>, Node* node) const {
+  void adapt_scan_8_9(const std::shared_ptr<Graph>&, Node* node) const {
     const std::vector<Value*> inputs(node->inputs().vec());
     const std::vector<Value*> outputs(node->outputs().vec());
 
@@ -27,7 +27,7 @@ struct Scan_8_9 final : public Adapter {
 
     Symbol dirs = Symbol("directions");
     if (node->hasAttribute(dirs)) {
-      const std::vector<int64_t> directions(node->is(dirs));
+      std::vector<int64_t> directions(node->is(dirs));
       node->removeAttribute(dirs);
       node->is_(Symbol("scan_input_directions"), std::move(directions));
     }
@@ -36,7 +36,7 @@ struct Scan_8_9 final : public Adapter {
 
     node->removeAllInputs();
 
-    ONNX_ASSERTM(inputs[0]->uniqueName() == "", "Unsupported conversion to opset 9");
+    ONNX_ASSERTM(inputs[0]->uniqueName().empty(), "Unsupported conversion to opset 9");
 
     for (Value* input : inputs) {
       if (!input->sizes().empty()) {

onnx/version_converter/adapters/scan_9_8.h

@@ -20,7 +20,7 @@ namespace version_conversion {
 struct Scan_9_8 final : public Adapter {
   explicit Scan_9_8() : Adapter("Scan", OpSetID(9), OpSetID(8)) {}
 
-  void adapt_scan_9_8(std::shared_ptr<Graph>, Node* node) const {
+  void adapt_scan_9_8(const std::shared_ptr<Graph>&, Node* node) const {
     const std::vector<Value*> inputs(node->inputs().vec());
     const std::vector<Value*> outputs(node->outputs().vec());
 
@@ -28,7 +28,7 @@ struct Scan_9_8 final : public Adapter {
 
     Symbol input_dirs = Symbol("scan_input_directions");
     if (node->hasAttribute(input_dirs)) {
-      const std::vector<int64_t> scan_input_directions(node->is(input_dirs));
+      std::vector<int64_t> scan_input_directions(node->is(input_dirs));
       node->removeAttribute(input_dirs);
       node->is_(Symbol("directions"), std::move(scan_input_directions));
     }

onnx/version_converter/adapters/scatter_10_11.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 Scatter_10_11 final : public Adapter {
  public:
   explicit Scatter_10_11() : Adapter("Scatter", OpSetID(10), OpSetID(11)) {}
 
-  Node* adapt_scatter_10_11(std::shared_ptr<Graph> graph, Node* node) const {
+  Node* adapt_scatter_10_11(const std::shared_ptr<Graph>& graph, Node* node) const {
     int axis = node->hasAttribute(kaxis) ? node->i(kaxis) : 0;
 
     // Replace the node with an equivalent ScatterElements node

onnx/version_converter/adapters/slice_9_10.h

@@ -11,6 +11,8 @@
 #include <memory>
 #include <vector>
 
+#include "onnx/version_converter/adapters/adapter.h"
+
 namespace ONNX_NAMESPACE {
 namespace version_conversion {
 
@@ -18,7 +20,7 @@ class Slice_9_10 final : public Adapter {
  public:
   explicit Slice_9_10() : Adapter("Slice", OpSetID(9), OpSetID(10)) {}
 
-  void attrToInput(std::shared_ptr<Graph> graph, Node* node, const std::vector<int64_t>& attr) const {
+  void attrToInput(const std::shared_ptr<Graph>& graph, Node* node, const std::vector<int64_t>& attr) const {
     Tensor t;
     t.elem_type() = TensorProto_DataType_INT64;
     t.sizes() = std::vector<int64_t>{static_cast<int64_t>(attr.size())};
@@ -32,7 +34,7 @@ class Slice_9_10 final : public Adapter {
     node->addInput(constant->output());
   }
 
-  void adapt_slice_9_10(std::shared_ptr<Graph> graph, Node* node) const {
+  void adapt_slice_9_10(const std::shared_ptr<Graph>& graph, Node* node) const {
     attrToInput(graph, node, node->is(kstarts));
     node->removeAttribute(kstarts);
     attrToInput(graph, node, node->is(kends));

onnx/version_converter/adapters/softmax_12_13.h

@@ -20,7 +20,7 @@ class Softmax_12_13 final : public Adapter {
  public:
   explicit Softmax_12_13(const std::string& op_name) : Adapter(op_name, OpSetID(12), OpSetID(13)) {}
 
-  void adapt_softmax_12_13(std::shared_ptr<Graph> graph, Node* node) const {
+  void adapt_softmax_12_13(const std::shared_ptr<Graph>& graph, Node* node) const {
     int old_axis = node->hasAttribute(kaxis) ? node->i(kaxis) : 1;
     int input_rank = node->inputs()[0]->sizes().size();
 
@@ -61,7 +61,7 @@ class Softmax_12_13 final : public Adapter {
       reshape->insertAfter(node);
 
       // Fix outputs & wiring
-      if (node->output()->sizes().size() != 0) {
+      if (!node->output()->sizes().empty()) {
         reshape->output()->setSizes(node->output()->sizes());
       }
       reshape->output()->setElemType(node->output()->elemType());

onnx/version_converter/adapters/softmax_13_12.h

@@ -0,0 +1,66 @@
+// Copyright (c) ONNX Project Contributors
+
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Adapter for Softmax and LogSoftmax in default domain from version 13 to 12
+
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Softmax_13_12 final : public Adapter {
+ public:
+  explicit Softmax_13_12(const std::string& op_name) : Adapter(op_name, OpSetID(13), OpSetID(12)) {}
+
+  void adapt_softmax_13_12(const std::shared_ptr<Graph>& graph, Node* node) const {
+    (void)graph; // Suppress unused parameter warning
+
+    int new_axis = node->hasAttribute(kaxis) ? node->i(kaxis) : -1;
+
+    // Handle Softmax on the last axis (default behavior in opset 13)
+    if (new_axis == -1) {
+      new_axis = node->inputs()[0]->sizes().size() - 1;
+      node->i_(kaxis, new_axis);
+    } else if (new_axis < 0) {
+      // Handle negative axis by converting it to positive
+      int input_rank = node->inputs()[0]->sizes().size();
+      new_axis = input_rank + new_axis;
+      node->i_(kaxis, new_axis);
+    }
+
+    // Flatten and Reshape nodes added in opset 13 must be removed
+    // Check for Flatten node before Softmax and Reshape node after Softmax
+    if (node->inputs()[0]->node()->kind() == kFlatten) {
+      Node* flatten = node->inputs()[0]->node();
+      const auto flatten_input = flatten->inputs()[0];
+      node->replaceInput(0, flatten_input);
+      flatten->destroy();
+    }
+
+    for (Use u : node->output()->uses()) {
+      if (u.user->kind() == kReshape) {
+        Node* reshape = u.user;
+        const auto reshape_output = reshape->outputs()[0];
+        node->output()->replaceAllUsesWith(reshape_output);
+        reshape->destroy();
+        break;
+      }
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_softmax_13_12(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE

onnx/version_converter/adapters/split_12_13.h

@@ -20,7 +20,7 @@ class Split_12_13 : public Adapter {
  public:
   explicit Split_12_13() : Adapter("Split", OpSetID(12), OpSetID(13)) {}
 
-  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/split_13_12.h

@@ -36,16 +36,16 @@ class Split_13_12 : 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_(ksplit, std::vector<int64_t>(raw, raw + node_ptr->t(kvalue).size_from_dim(0)));
       } else {
         node->is_(ksplit, 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 {
@@ -55,7 +55,7 @@ class Split_13_12 : public Adapter {
           node->is_(ksplit, 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/split_17_18.h

@@ -20,9 +20,9 @@ class Split_17_18 : public Adapter {
  public:
   explicit Split_17_18() : Adapter("Split", OpSetID(17), OpSetID(18)) {}
 
-  void adapt_split_17_18(std::shared_ptr<Graph>, Node* node) const {
+  void adapt_split_17_18(const std::shared_ptr<Graph>&, Node* node) const {
     const auto num_outputs = node->outputs().size();
-    SetAttribute(knum_outputs, num_outputs);
+    node->i_(knum_outputs, num_outputs);
   }
 
   Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {

onnx/version_converter/adapters/sum_8_7.h

@@ -20,7 +20,7 @@ class Sum_8_7 final : public Adapter {
  public:
   explicit Sum_8_7() : Adapter("Sum", OpSetID(8), OpSetID(7)) {}
 
-  void adapt_sum_8_7(std::shared_ptr<Graph>, Node* node) const {
+  void adapt_sum_8_7(const std::shared_ptr<Graph>&, Node* node) const {
     // Throw an exception if any broadcasting occurs
     const ArrayRef<Value*>& inputs = node->inputs();
     // Determine if inputs are of different sizes

onnx/version_converter/adapters/topk_9_10.h

@@ -11,6 +11,8 @@
 #include <memory>
 #include <vector>
 
+#include "onnx/version_converter/adapters/adapter.h"
+
 namespace ONNX_NAMESPACE {
 namespace version_conversion {
 
@@ -18,7 +20,7 @@ class TopK_9_10 final : public Adapter {
  public:
   explicit TopK_9_10() : Adapter("TopK", OpSetID(9), OpSetID(10)) {}
 
-  void adapt_topk_9_10(std::shared_ptr<Graph> graph, Node* node) const {
+  void adapt_topk_9_10(const std::shared_ptr<Graph>& graph, Node* node) const {
     Tensor t;
     t.elem_type() = TensorProto_DataType_INT64;
     t.sizes() = std::vector<int64_t>{1};

onnx/version_converter/adapters/transformers.h

@@ -8,14 +8,16 @@
 
 #include <cinttypes>
 #include <string>
-#include <utility>
 #include <vector>
 
+#include "onnx/common/interned_strings.h"
+#include "onnx/version_converter/adapters/adapter.h"
+
 // Node transformers commonly used in version-adapters:
 
 // Capture context by copying values; the graph is unused by these transformers.
 
-#define NODE_TRANSFORMER(node) [=](std::shared_ptr<Graph>, Node * node)
+#define NODE_TRANSFORMER(node) [=](const std::shared_ptr<Graph>&, Node* node)
 
 namespace ONNX_NAMESPACE {
 namespace version_conversion {
@@ -63,10 +65,9 @@ inline NodeTransformerFunction SetAttribute(Symbol attr, const std::string& valu
   };
 }
 
-inline NodeTransformerFunction SetAttribute(Symbol attr, std::vector<int64_t> value) {
+inline NodeTransformerFunction SetAttribute(Symbol attr, const std::vector<int64_t>& value) {
   return NODE_TRANSFORMER(node) {
-    std::vector<int64_t> local(value);
-    node->is_(attr, std::move(local));
+    node->is_(attr, std::vector<int64_t>(value));
     return node;
   };
 }

onnx/version_converter/adapters/type_restriction.h

@@ -26,13 +26,13 @@ class TypeRestriction : public Adapter {
       const std::vector<TensorProto_DataType>& unallowed_types)
       : Adapter(op_name, initial, target), unallowed_types_(unallowed_types) {}
 
-  void adapt_type_restriction(std::shared_ptr<Graph>, Node* node) const {
+  void adapt_type_restriction(const std::shared_ptr<Graph>&, const Node* node) const {
     // Since consumed_inputs is optional, no need to add it (as in batchnorm)
     // Iterate over all inputs and outputs
-    for (Value* input : node->inputs()) {
+    for (const Value* input : node->inputs()) {
       isUnallowed(input);
     }
-    for (Value* output : node->outputs()) {
+    for (const Value* output : node->outputs()) {
       isUnallowed(output);
     }
   }
@@ -45,7 +45,7 @@ class TypeRestriction : public Adapter {
  private:
   std::vector<TensorProto_DataType> unallowed_types_;
 
-  void isUnallowed(Value* val) const {
+  void isUnallowed(const Value* val) const {
     ONNX_ASSERTM(
         std::find(std::begin(unallowed_types_), std::end(unallowed_types_), val->elemType()) ==
             std::end(unallowed_types_),

onnx/version_converter/adapters/upsample_6_7.h

@@ -20,7 +20,7 @@ namespace version_conversion {
 struct Upsample_6_7 final : public Adapter {
   explicit Upsample_6_7() : Adapter("Upsample", OpSetID(6), OpSetID(7)) {}
 
-  void adapt_upsample_6_7(std::shared_ptr<Graph>, Node* node) const {
+  void adapt_upsample_6_7(const std::shared_ptr<Graph>&, Node* node) const {
     Symbol width_scale_symbol = Symbol("width_scale");
     Symbol height_scale_symbol = Symbol("height_scale");
     ONNX_ASSERTM(

onnx/version_converter/adapters/upsample_8_9.h

@@ -19,7 +19,7 @@ namespace version_conversion {
 struct Upsample_8_9 final : public Adapter {
   explicit Upsample_8_9() : Adapter("Upsample", OpSetID(8), OpSetID(9)) {}
 
-  void adapt_upsample_8_9(std::shared_ptr<Graph> graph, Node* node) const {
+  void adapt_upsample_8_9(const std::shared_ptr<Graph>& graph, Node* node) const {
     Symbol input_dirs = Symbol("scales");
     int dim = (int)(node->fs(kscales).size());
     Tensor t;

onnx/version_converter/adapters/upsample_9_10.h

@@ -10,6 +10,9 @@
 
 #include <memory>
 #include <string>
+
+#include "onnx/common/ir.h"
+#include "onnx/version_converter/adapters/adapter.h"
 namespace ONNX_NAMESPACE {
 namespace version_conversion {
 
@@ -17,7 +20,7 @@ class Upsample_9_10 final : public Adapter {
  public:
   explicit Upsample_9_10() : Adapter("Upsample", OpSetID(9), OpSetID(10)) {}
 
-  Node* adapt_upsample_9_10(std::shared_ptr<Graph> graph, Node* node) const {
+  Node* adapt_upsample_9_10(const std::shared_ptr<Graph>& graph, Node* node) const {
     std::string mode = node->hasAttribute(kmode) ? node->s(kmode) : "nearest";
 
     // Replace the node with an equivalent Resize node

onnx/version_converter/adapters/upsample_9_8.h

@@ -22,25 +22,25 @@ namespace version_conversion {
 struct Upsample_9_8 final : public Adapter {
   explicit Upsample_9_8() : Adapter("Upsample", OpSetID(9), OpSetID(8)) {}
 
-  void adapt_upsample_9_8(std::shared_ptr<Graph> graph, Node* node) const {
+  void adapt_upsample_9_8(const std::shared_ptr<Graph>& graph, Node* node) const {
     const ArrayRef<Value*>& inputs = node->inputs();
     const std::vector<Tensor>& initializers = graph->initializers();
 
     ONNX_ASSERTM(inputs.size() == 2, "Upsample in opset 9 needs to have 2 inputs.");
     std::string scale_input_name = node->inputs()[1]->uniqueName();
 
-    for (size_t i = 0; i < initializers.size(); i++) {
-      if (initializers[i].name() == inputs[1]->uniqueName()) {
-        std::vector<float> value = ParseData<float>(&initializers[i]);
+    for (const auto& initializer : initializers) {
+      if (initializer.name() == inputs[1]->uniqueName()) {
+        std::vector<float> value = ParseData<float>(&initializer);
         std::vector<double> d_values;
         d_values.reserve(value.size());
-        for (size_t j = 0; j < value.size(); j++) {
-          d_values.push_back(static_cast<double>(value[j]));
+        for (float j : value) {
+          d_values.push_back(static_cast<double>(j));
         }
-        node->fs_(kscales, const_cast<std::vector<double>&&>(d_values));
+        node->fs_(kscales, std::move(d_values));
 
         node->removeInput(1);
-        graph->eraseInitializer(initializers[i].name());
+        graph->eraseInitializer(initializer.name());
         for (size_t j = 0; j < graph->inputs().size(); j++) {
           if (graph->inputs()[j]->uniqueName() == scale_input_name) {
             graph->eraseInput(j);
@@ -56,10 +56,10 @@ struct Upsample_9_8 final : public Adapter {
         std::vector<float> value = ParseData<float>(&op->t(kvalue));
         std::vector<double> d_values;
         d_values.reserve(value.size());
-        for (size_t j = 0; j < value.size(); j++) {
-          d_values.push_back(static_cast<double>(value[j]));
+        for (float j : value) {
+          d_values.push_back(static_cast<double>(j));
         }
-        node->fs_(kscales, const_cast<std::vector<double>&&>(d_values));
+        node->fs_(kscales, std::move(d_values));
         node->removeInput(1);
         op->destroy();
         return;

onnx/version_converter/convert.cc

@@ -6,18 +6,21 @@
 
 #include "onnx/version_converter/convert.h"
 
+#include <iostream>
 #include <memory>
 #include <string>
 
+#include "onnx/common/ir_pb_converter.h"
+
 namespace ONNX_NAMESPACE {
 namespace version_conversion {
 
 ModelProto ConvertVersion(const ModelProto& mp_in, int target_version) {
   // Get initial_opsetid from mp_in
   OpSetID initial_struct(0);
-  for (auto it = mp_in.opset_import().begin(); it != mp_in.opset_import().end(); ++it) {
-    if (it->domain() == "" || it->domain() == "ai.onnx") {
-      initial_struct.setVersion(it->version());
+  for (const auto& it : mp_in.opset_import()) {
+    if (it.domain().empty() || it.domain() == "ai.onnx") {
+      initial_struct.setVersion(it.version());
       break;
     }
   }
@@ -27,7 +30,7 @@ ModelProto ConvertVersion(const ModelProto& mp_in, int target_version) {
 }
 
 void DefaultVersionConverter::convert_graph(
-    std::shared_ptr<Graph> g,
+    const std::shared_ptr<Graph>& g,
     const OpSetID& initial_version,
     const OpSetID& target_version) const {
   assertNonNull(g);
@@ -49,7 +52,7 @@ void DefaultVersionConverter::convert_graph(
 
   // Iterate over all versions to target_version for specified
   int64_t curr_version = initial_version.version();
-  int64_t step;
+  int64_t step = 0;
   if (target_version.version() > initial_version.version()) {
     step = 1;
   } else {
@@ -58,7 +61,7 @@ void DefaultVersionConverter::convert_graph(
   // Identify index of this domain in g.opset_versions
   unsigned int domain_index = 0;
   for (unsigned int i = 0; i < g->opset_versions_mutable().size(); i++) {
-    if (g->opset_versions_mutable()[i].domain() == "") {
+    if (g->opset_versions_mutable()[i].domain().empty()) {
       domain_index = i;
     }
   }
@@ -66,7 +69,7 @@ void DefaultVersionConverter::convert_graph(
     debug(
         "curr_version: " + ONNX_NAMESPACE::to_string(curr_version) +
         ", next_version: " + ONNX_NAMESPACE::to_string(curr_version + step));
-    Node* cur_op;
+    Node* cur_op = nullptr;
     graph_node_list_iterator it = g->begin();
     // Iterate through and call adapter returned by adapter_lookup for ops from
     // current_version opset. We have to manipulate the iterator explicitly because cur_op
@@ -81,11 +84,11 @@ void DefaultVersionConverter::convert_graph(
               << "Warning: skipping schema search for experimental op 'ConstantFill' and keeping the op as is. "
                  "Please be advised the converted model may not be working properly if target runtime does not support this "
                  "experimental op."
-              << std::endl;
+              << '\n';
         }
-      } else if (cur_op->domain() != "" && cur_op->domain() != "ai.onnx") {
+      } else if (!cur_op->domain().empty() && cur_op->domain() != "ai.onnx") {
         if (DEBUG) {
-          std::cerr << "Warning: opset domain '" << cur_op->domain() << "' is not supported." << std::endl;
+          std::cerr << "Warning: opset domain '" << cur_op->domain() << "' is not supported." << '\n';
         }
       } else if (op_name != "Undefined" && op_name != "Captured") {
         auto& op_domain_map = all_schemas.at(op_name);
@@ -97,7 +100,7 @@ void DefaultVersionConverter::convert_graph(
           // If adapter_lookup returns null, no adapter is present.
           // Error thrown by adapter_lookup
           if (DEBUG) {
-            std::cerr << "Applying adapter" << std::endl;
+            std::cerr << "Applying adapter" << '\n';
           }
           // adapt should handle replacing node in graph
           cur_op = op_adapter.adapt(g, cur_op);