onnx 1.17.0__cp311-cp311-win32.whl → 1.19.0__cp311-cp311-win32.whl

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 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_(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,13 +55,13 @@ 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_ASSERTM(node->hasAttribute(ksplit), "No initializer or constant input to node found");
+    ONNX_ASSERTM(node->hasAttribute(ksplit), "No initializer or constant input to node found")
     return node;
   }
 };

onnx/version_converter/adapters/split_17_18.h

@@ -20,7 +20,7 @@ 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();
     node->i_(knum_outputs, num_outputs);
   }

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 {
@@ -32,7 +34,7 @@ inline NodeTransformerFunction RemoveAttribute(Symbol attr) {
 inline NodeTransformerFunction RemoveAttribute(Symbol attr, int64_t value) {
   return NODE_TRANSFORMER(node) {
     if (node->hasAttribute(attr)) {
-      ONNX_ASSERTM(node->i(attr) == value, "Attribute %s must have value %" PRId64, attr.toString(), value);
+      ONNX_ASSERTM(node->i(attr) == value, "Attribute %s must have value %" PRId64, attr.toString(), value)
       node->removeAttribute(attr);
     }
     return node;
@@ -42,7 +44,7 @@ inline NodeTransformerFunction RemoveAttribute(Symbol attr, int64_t value) {
 inline NodeTransformerFunction RemoveAttributeNotEq(Symbol attr, int64_t value) {
   return NODE_TRANSFORMER(node) {
     if (node->hasAttribute(attr)) {
-      ONNX_ASSERTM(node->i(attr) != value, "Attribute %s must not have value %" PRId64, attr.toString(), value);
+      ONNX_ASSERTM(node->i(attr) != value, "Attribute %s must not have value %" PRId64, attr.toString(), value)
       node->removeAttribute(attr);
     }
     return node;
@@ -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_),
@@ -53,7 +53,7 @@ class TypeRestriction : public Adapter {
         " of operator '%s' is unallowed for Opset Version %d.",
         val->elemType(),
         name().c_str(),
-        target_version().version());
+        target_version().version())
   }
 };
 

onnx/version_converter/adapters/upsample_6_7.h

@@ -20,18 +20,18 @@ 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(
         node->hasAttribute(width_scale_symbol) && node->hasAttribute(height_scale_symbol),
-        "Upsample in opset 1 needs to have width_scale and height_scale attributes");
+        "Upsample in opset 1 needs to have width_scale and height_scale attributes")
 
     auto width_scale = node->f(width_scale_symbol);
     auto height_scale = node->f(height_scale_symbol);
 
     auto input_shape = node->inputs()[0]->sizes();
-    ONNX_ASSERTM(input_shape.size() == 4, "Upsample in opset 1 supports only 4D input tensor");
+    ONNX_ASSERTM(input_shape.size() == 4, "Upsample in opset 1 supports only 4D input tensor")
     std::vector<double> scales = {1.0, 1.0, height_scale, width_scale};
 
     node->fs_(kscales, std::move(scales));

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.");
+    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,17 +56,17 @@ 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_ASSERTM(false, "Unsuppported conversion due to unavailable input: scale");
+    ONNX_ASSERTM(false, "Unsuppported conversion due to unavailable input: scale")
   }
 
   Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {

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);
@@ -129,7 +132,7 @@ ModelProto DefaultVersionConverter::convert_version(
   for (auto it = mp_in.opset_import().begin(); it != mp_in.opset_import().end(); ++it) {
     if (it->domain() == initial_version.domain()) {
       ONNX_ASSERTM(
-          initial_version.version() == it->version(), "initial_version does not reflect current state of model");
+          initial_version.version() == it->version(), "initial_version does not reflect current state of model")
     }
   }
 

onnx/version_converter/convert.h

@@ -9,6 +9,7 @@
 
 #pragma once
 
+#include <iostream>
 #include <map>
 #include <memory>
 #include <string>
@@ -17,6 +18,7 @@
 #include <vector>
 
 #include "onnx/version_converter/BaseConverter.h"
+#include "onnx/version_converter/adapters/Attention_24_23.h"
 #include "onnx/version_converter/adapters/axes_attribute_to_input.h"
 #include "onnx/version_converter/adapters/axes_input_to_attribute.h"
 #include "onnx/version_converter/adapters/axis_attribute_to_input.h"
@@ -45,6 +47,7 @@
 #include "onnx/version_converter/adapters/scatter_10_11.h"
 #include "onnx/version_converter/adapters/slice_9_10.h"
 #include "onnx/version_converter/adapters/softmax_12_13.h"
+#include "onnx/version_converter/adapters/softmax_13_12.h"
 #include "onnx/version_converter/adapters/split_12_13.h"
 #include "onnx/version_converter/adapters/split_13_12.h"
 #include "onnx/version_converter/adapters/split_17_18.h"
@@ -79,7 +82,7 @@ class DefaultVersionConverter : public BaseVersionConverter {
 
   void debug(const std::string& str) const {
     if (DEBUG)
-      std::cerr << str << std::endl;
+      std::cerr << str << '\n';
   }
 
   void assertInVersionRange(int64_t version) const {
@@ -87,18 +90,20 @@ class DefaultVersionConverter : public BaseVersionConverter {
         version >= version_range.first && version <= version_range.second,
         "Warning: invalid version (must be between %d and %d)",
         version_range.first,
-        version_range.second);
+        version_range.second)
   }
 
   void assertDefaultDomain(const std::string& initial_domain, const std::string& target_domain) const {
     ONNX_ASSERTM(
-        (initial_domain == "" || initial_domain == "ai.onnx") && (target_domain == "" || target_domain == "ai.onnx"),
+        (initial_domain.empty() || initial_domain == "ai.onnx") &&
+            (target_domain.empty() || target_domain == "ai.onnx"),
         "Warning: default onnx version converter can only convert "
-        " between default domain opset versions ('' or 'ai.onnx')\n");
-    ONNX_ASSERTM(initial_domain == target_domain, "initial_version and target_version must have the same domains");
+        " between default domain opset versions ('' or 'ai.onnx')\n")
+    ONNX_ASSERTM(initial_domain == target_domain, "initial_version and target_version must have the same domains")
   }
 
-  void convert_graph(std::shared_ptr<Graph> g, const OpSetID& initial_version, const OpSetID& target_version) const;
+  void convert_graph(const std::shared_ptr<Graph>& g, const OpSetID& initial_version, const OpSetID& target_version)
+      const;
 
  public:
   DefaultVersionConverter() {
@@ -123,8 +128,9 @@ class DefaultVersionConverter : public BaseVersionConverter {
           }
         }
         if (min_version > 1) {
-          registerAdapter(std::make_unique<NoPreviousVersionAdapter>(
-              op_pair.first, OpSetID(min_version), OpSetID(min_version - 1)));
+          registerAdapter(
+              std::make_unique<NoPreviousVersionAdapter>(
+                  op_pair.first, OpSetID(min_version), OpSetID(min_version - 1)));
         }
       }
     }
@@ -491,6 +497,8 @@ class DefaultVersionConverter : public BaseVersionConverter {
     registerAdapter(std::make_unique<AxesInputToAttribute>("Squeeze", OpSetID(13), OpSetID(12)));
     registerAdapter(std::make_unique<AxesInputToAttribute>("Unsqueeze", OpSetID(13), OpSetID(12)));
     registerAdapter(std::make_unique<Split_13_12>());
+    registerAdapter(std::make_unique<Softmax_13_12>("Softmax"));
+    registerAdapter(std::make_unique<Softmax_13_12>("LogSoftmax"));
 
     /******** 13 -> 14 ********/
     registerAdapter(std::make_unique<CompatibleAdapter>("Add", OpSetID(13), OpSetID(14)));
@@ -776,12 +784,110 @@ class DefaultVersionConverter : public BaseVersionConverter {
     registerAdapter(std::make_unique<TypeRestriction>("GRU", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
     registerAdapter(std::make_unique<TypeRestriction>("LSTM", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
     registerAdapter(std::make_unique<TypeRestriction>("GridSample", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+
+    /******** 22 -> 23 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("Cast", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("CastLike", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Constant", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ConstantOfShape", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("DequantizeLinear", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Flatten", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Identity", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("If", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Loop", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Pad", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("QuantizeLinear", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Reshape", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Scan", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Shape", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Size", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Squeeze", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Transpose", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Unsqueeze", OpSetID(22), OpSetID(23)));
+
+    /******** 23 -> 22 ********/
+    const std::vector<TensorProto_DataType> ir11_types_not_in_ir10 = {TensorProto_DataType_FLOAT4E2M1};
+    registerAdapter(std::make_unique<TypeRestriction>("Cast", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("CastLike", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Constant", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("ConstantOfShape", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("DequantizeLinear", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Flatten", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Identity", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("If", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Loop", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Pad", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("QuantizeLinear", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Reshape", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Scan", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Shape", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Size", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Squeeze", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Transpose", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Unsqueeze", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+
+    /******** 23 -> 24 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("Attention", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Cast", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("CastLike", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Constant", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ConstantOfShape", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("DequantizeLinear", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Flatten", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Identity", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("If", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Loop", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Pad", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("QuantizeLinear", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Reshape", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Scan", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Shape", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Size", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Squeeze", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Transpose", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Unsqueeze", OpSetID(23), OpSetID(24)));
+
+    // TopK and SplitToSequence 23=>24 update adds bfloat16 support
+    registerAdapter(std::make_unique<CompatibleAdapter>("TopK", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("SplitToSequence", OpSetID(23), OpSetID(24)));
+
+    /******** 24 -> 23 ********/
+    registerAdapter(std::make_unique<Attention_24_23>());
+    const std::vector<TensorProto_DataType> ir12_types_not_in_ir11 = {TensorProto_DataType_FLOAT8E8M0};
+    registerAdapter(std::make_unique<TypeRestriction>("Cast", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("CastLike", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Constant", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("ConstantOfShape", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("DequantizeLinear", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Flatten", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Identity", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("If", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Loop", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Pad", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("QuantizeLinear", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Reshape", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Scan", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Shape", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Size", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Squeeze", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Transpose", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Unsqueeze", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+
+    registerAdapter(std::make_unique<TypeRestriction>("TopK", OpSetID(24), OpSetID(23), bfloat16_not_allowed));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("SplitToSequence", OpSetID(24), OpSetID(23), bfloat16_not_allowed));
   }
 
   ModelProto convert_version(const ModelProto& mp_in, const OpSetID& initial_version, const OpSetID& target_version)
       const override;
 };
 
-ModelProto ConvertVersion(const ModelProto& mp_in, int target_version);
+ONNX_API ModelProto ConvertVersion(const ModelProto& mp_in, int target_version);
 } // namespace version_conversion
 } // namespace ONNX_NAMESPACE

onnx/version_converter/helper.cc

@@ -36,20 +36,15 @@ void assert_numpy_multibroadcastable(
     const std::vector<Dimension>& input1_sizes,
     const std::vector<Dimension>& input2_sizes) {
   // Generalize above for multibroadcastable case
-  const std::vector<Dimension>* A_ptr;
-  const std::vector<Dimension>* B_ptr;
-  int A;
-  int B;
+  const std::vector<Dimension>* A_ptr = &input1_sizes;
+  const std::vector<Dimension>* B_ptr = &input2_sizes;
+  int A = 1;
+  int B = 2;
   if (input1_sizes.size() < input2_sizes.size()) {
     A_ptr = &input2_sizes;
     B_ptr = &input1_sizes;
     A = 2;
     B = 1;
-  } else {
-    A_ptr = &input1_sizes;
-    B_ptr = &input2_sizes;
-    A = 1;
-    B = 2;
   }
   const std::vector<Dimension>& A_sizes = *A_ptr;
   const std::vector<Dimension>& B_sizes = *B_ptr;
@@ -62,13 +57,13 @@ void assert_numpy_multibroadcastable(
         i,
         B,
         axis + i,
-        A);
+        A)
   }
 }
 
 void assertNotParams(const std::vector<Dimension>& sizes) {
   for (const Dimension& dim : sizes) {
-    ONNX_ASSERTM(dim.is_int, "%s Dimension is a param instead of an int.", dim.param.c_str());
+    ONNX_ASSERTM(dim.is_int, "%s Dimension is a param instead of an int.", dim.param.c_str())
   }
 }
 
@@ -78,9 +73,9 @@ void assertInputsAvailable(const ArrayRef<Value*>& inputs, const char* name, uin
       "%s in opset version 6 can only broadcast"
       " between %d inputs",
       name,
-      num_inputs);
+      num_inputs)
   for (int i = 0; i < (int)num_inputs; i++) {
-    ONNX_ASSERTM(inputs[i]->has_sizes(), "Shape of input %d is not available.", num_inputs);
+    ONNX_ASSERTM(inputs[i]->has_sizes(), "Shape of input %d is not available.", num_inputs)
     assertNotParams(inputs[i]->sizes());
   }
 }

onnx/version_converter.py

@@ -6,6 +6,7 @@
 This enables users to convert their models between different opsets within the
 default domain ("" or "ai.onnx").
 """
+
 from __future__ import annotations
 
 import onnx