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

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"
@@ -45,7 +44,7 @@ class AxisInputToAttribute : public Adapter {
       return EnsureAndReturnNode(node);
     }
 
-    ONNX_ASSERTM(false, "Axis input must be a constant or initializer for promotion to attribute.");
+    ONNX_ASSERTM(false, "Axis input must be a constant or initializer for promotion to attribute.")
   }
 
  private:
@@ -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;
       }
@@ -90,7 +88,7 @@ class AxisInputToAttribute : public Adapter {
   }
 
   inline Node* EnsureAndReturnNode(Node* node) const {
-    ONNX_ASSERTM(node->hasAttribute(kaxis), "Axis attribute not created. This may be a bug.");
+    ONNX_ASSERTM(node->hasAttribute(kaxis), "Axis attribute not created. This may be a bug.")
     return node;
   }
 };

onnx/version_converter/adapters/batch_normalization_13_14.h

@@ -17,12 +17,10 @@ class BatchNormalization_13_14 final : public Adapter {
  public:
   explicit BatchNormalization_13_14() : Adapter("BatchNormalization", OpSetID(13), OpSetID(14)) {}
 
-  void adapt_batch_normalization_13_14(Node* node) const {
-    ONNX_ASSERTM(
-        node->outputs().size() < 4,
-        "BatchNormalization outputs 4 and 5 are not "
-        "supported in Opset 14.");
-  }
+  void adapt_batch_normalization_13_14(Node* node) const {ONNX_ASSERTM(
+      node -> outputs().size() < 4,
+      "BatchNormalization outputs 4 and 5 are not "
+      "supported in Opset 14.")}
 
   Node* adapt(std::shared_ptr<Graph>, Node* node) const override {
     adapt_batch_normalization_13_14(node);

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
@@ -42,7 +42,7 @@ class BroadcastBackwardCompatibility final : public Adapter {
         "not have broadcastable inputs.",
         name().c_str(),
         initial_version().version(),
-        target_version().version());
+        target_version().version())
     if (req_broadcast == 1) {
       // If conditional is not fulfilled, we have a default broadcast
       // Add broadcast attribute

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 = {
@@ -58,9 +58,9 @@ struct ExtendSupportedTypes final : public Adapter {
     };
 
     ONNX_ASSERTM(
-        unsupported_version9_types.find(input_type) == unsupported_version9_types.end(), "Unsupported Input Type");
+        unsupported_version9_types.find(input_type) == unsupported_version9_types.end(), "Unsupported Input Type")
     ONNX_ASSERTM(
-        unsupported_version9_types.find(output_type) == unsupported_version9_types.end(), "Unsupported Output Type");
+        unsupported_version9_types.find(output_type) == unsupported_version9_types.end(), "Unsupported Output Type")
 
     bool castInput = (node->kind() != kConstant);
     bool castOutput = (node->kind() != kGreater && node->kind() != kLess);

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();
@@ -42,7 +42,7 @@ class Gemm_6_7 final : public Adapter {
     ONNX_ASSERTM(
         check_numpy_unibroadcastable_and_require_broadcast(MN, C_shape) != -1,
         "Gemm being converted from 6 to 7 does not have "
-        "broadcastable inputs.");
+        "broadcastable inputs.")
     if (node->hasAttribute(kbroadcast))
       node->removeAttribute(kbroadcast);
   }

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();
@@ -47,7 +47,7 @@ class Gemm_7_6 final : public Adapter {
         "not have broadcastable inputs.",
         name().c_str(),
         initial_version().version(),
-        target_version().version());
+        target_version().version())
     if (req_broadcast == 1) {
       node->i_(kbroadcast, 1);
     }

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,9 +19,9 @@ 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");
+    ONNX_ASSERTM(outputs.size() != 2, "Opset version 7 of MaxPool cannot include Indices output")
     if (node->hasAttribute(kstorage_order))
       node->removeAttribute(kstorage_order);
   }

onnx/version_converter/adapters/no_previous_version.h

@@ -23,7 +23,7 @@ class NoPreviousVersionAdapter final : public Adapter {
       : Adapter(op_name, initial, target) {}
 
   Node* adapt(std::shared_ptr<Graph>, Node* node) const override {
-    ONNX_ASSERTM(false, "No Previous Version of %s exists", name().c_str());
+    ONNX_ASSERTM(false, "No Previous Version of %s exists", name().c_str())
     return node;
   }
 };

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 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_(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,13 +54,13 @@ 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_ASSERTM(node->hasAttribute(kshape), "No initializer or constant input to Reshape node found");
+    ONNX_ASSERTM(node->hasAttribute(kshape), "No initializer or constant input to Reshape node found")
   }
 
   Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {

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,8 +20,8 @@ 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 {
-    int input_rank = node->inputs()[0]->sizes().size();
+  void adapt_resize_10_11(const std::shared_ptr<Graph>& graph, Node* node) const {
+    int64_t input_rank = node->inputs()[0]->sizes().size();
 
     Value* scales_input = node->inputs()[1];
     node->addInput(scales_input);

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));
     }
@@ -37,7 +37,7 @@ struct Scan_9_8 final : public Adapter {
     if (node->hasAttribute(output_dirs)) {
       const std::vector<int64_t> scan_output_directions(node->is(output_dirs));
       for (int64_t x : scan_output_directions) {
-        ONNX_ASSERTM(x == 0, "Unsupported output direction for Version 8");
+        ONNX_ASSERTM(x == 0, "Unsupported output direction for Version 8")
       }
       node->removeAttribute(output_dirs);
     }
@@ -46,7 +46,7 @@ struct Scan_9_8 final : public Adapter {
     if (node->hasAttribute(input_axes)) {
       const std::vector<int64_t> scan_input_axes(node->is(input_axes));
       for (int64_t x : scan_input_axes) {
-        ONNX_ASSERTM(x == 0, "Unsupported input axes for Version 8");
+        ONNX_ASSERTM(x == 0, "Unsupported input axes for Version 8")
       }
       node->removeAttribute(input_axes);
     }
@@ -55,7 +55,7 @@ struct Scan_9_8 final : public Adapter {
     if (node->hasAttribute(output_axes)) {
       const std::vector<int64_t> scan_output_axes(node->is(output_axes));
       for (int64_t x : scan_output_axes) {
-        ONNX_ASSERTM(x == 0, "Unsupported output axes for Version 8");
+        ONNX_ASSERTM(x == 0, "Unsupported output axes for Version 8")
       }
       node->removeAttribute(output_axes);
     }

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