onnx 1.18.0__cp313-cp313-macosx_12_0_universal2.whl → 1.19.1rc1__cp313-cp313-macosx_12_0_universal2.whl

onnx/common/ir.h

@@ -82,8 +82,8 @@ class ResourceGuard final {
 
 struct Dimension final {
   Dimension() : is_unknown(true), is_int(false), dim(-1) {}
-  Dimension(std::string param) : is_unknown(false), is_int(false), dim(-1), param(std::move(param)) {} // NOLINT
-  Dimension(int64_t dim) : is_unknown(false), is_int(true), dim(dim) {} // NOLINT
+  explicit Dimension(std::string param) : is_unknown(false), is_int(false), dim(-1), param(std::move(param)) {}
+  explicit Dimension(int64_t dim) : is_unknown(false), is_int(true), dim(dim) {}
 
   bool is_unknown;
   bool is_int;
@@ -109,8 +109,9 @@ enum class AttributeKind : uint8_t {
 };
 
 static inline const char* toString(AttributeKind kind) {
+  // NOLINTNEXTLINE(modernize-avoid-c-arrays)
   static constexpr const char* names[] = {"f", "fs", "i", "is", "s", "ss", "t", "ts", "g", "gs", "tp", "tps"};
-  ONNX_ASSERT(size_t(kind) < sizeof(names) / sizeof(const char*));
+  ONNX_ASSERT(size_t(kind) < sizeof(names) / sizeof(const char*))
   return names[int(kind)];
 }
 
@@ -127,7 +128,7 @@ template <typename T, AttributeKind Kind>
 struct ScalarAttributeValue final : public AttributeValue {
   using ConstructorType = const T&;
   using ValueType = T;
-  ScalarAttributeValue(Symbol name, ConstructorType value_) : AttributeValue(name), value_(value_) {}
+  ScalarAttributeValue(Symbol name, ConstructorType value_) : AttributeValue(name), value_(std::move(value_)) {}
   ValueType& value() {
     return value_;
   }
@@ -180,6 +181,7 @@ using TypeProtosAttr = VectorAttributeValue<TypeProto, AttributeKind::tps>;
 // we return Derived* pointers because Nodes are normally held as pointers.
 template <typename Derived>
 struct Attributes {
+  // NOLINTNEXTLINE(bugprone-crtp-constructor-accessibility)
   Attributes() = default;
 
   void copyAttributes(const Attributes& rhs) {
@@ -262,7 +264,7 @@ struct Attributes {
   using iterator = std::vector<AVPtr>::iterator;
   iterator find(Symbol name, bool required) {
     auto it = std::find_if(values_.begin(), values_.end(), [&](const AVPtr& v) { return v->name == name; });
-    ONNX_ASSERT(!required || it != values_.end());
+    ONNX_ASSERT(!required || it != values_.end())
     return it;
   }
   using const_iterator = std::vector<AVPtr>::const_iterator;
@@ -274,7 +276,7 @@ struct Attributes {
         __FILE__,
         __LINE__,
         __func__,
-        name.toString());
+        name.toString())
     return it;
   }
 };
@@ -540,7 +542,7 @@ struct Node : public Attributes<Node> {
     return false;
   }
   void replaceAllUsesWith(Node* n) {
-    ONNX_ASSERT(outputs().size() == n->outputs().size());
+    ONNX_ASSERT(outputs().size() == n->outputs().size())
     size_t nOutputs = outputs().size();
     for (size_t i = 0; i < nOutputs; i++) {
       outputs()[i]->replaceAllUsesWith(n->outputs()[i]);
@@ -549,19 +551,19 @@ struct Node : public Attributes<Node> {
   // lots of things like chunk have a single input or single output, so we have a
   // helper to make accessing it easier
   Value* input() {
-    ONNX_ASSERT(inputs_.size() == 1);
+    ONNX_ASSERT(inputs_.size() == 1)
     return inputs_.at(0);
   }
   Value* output() {
-    ONNX_ASSERT(outputs_.size() == 1);
+    ONNX_ASSERT(outputs_.size() == 1)
     return outputs_.at(0);
   }
   const Value* input() const {
-    ONNX_ASSERT(inputs_.size() == 1);
+    ONNX_ASSERT(inputs_.size() == 1)
     return inputs_.at(0);
   }
   Value* output() const {
-    ONNX_ASSERT(outputs_.size() == 1);
+    ONNX_ASSERT(outputs_.size() == 1)
     return outputs_.at(0);
   }
   // Access a particular input.  This is a checked index.
@@ -593,7 +595,7 @@ struct Node : public Attributes<Node> {
   // Execute: %3.addInput(%4)
   // Result:  %3 = f(%1, %2, %4)
   Value* addInput(Value* node) {
-    ONNX_ASSERT(graph_ == node->owningGraph());
+    ONNX_ASSERT(graph_ == node->owningGraph())
     node->uses_in_current_graph_.emplace_back(this, inputs_.size());
     inputs_.push_back(node);
     return node;
@@ -606,7 +608,7 @@ struct Node : public Attributes<Node> {
   // Execute: %3.replaceInput(1, %4)
   // Result:  %3 = f(%1, %4)
   Value* replaceInput(size_t i, Value* newValue) {
-    ONNX_ASSERT(newValue->owningGraph() == graph_);
+    ONNX_ASSERT(newValue->owningGraph() == graph_)
     Value* old = dropInput(i);
     inputs_[i] = newValue;
     newValue->uses_in_current_graph_.emplace_back(this, i);
@@ -620,8 +622,8 @@ struct Node : public Attributes<Node> {
   // Execute: %3.replaceInputWith(%1, %4)
   // Result:  %3 = f(%4, %2, %4)
   void replaceInputWith(Value* from, Value* to) {
-    ONNX_ASSERT(from->owningGraph() == graph_);
-    ONNX_ASSERT(to->owningGraph() == graph_);
+    ONNX_ASSERT(from->owningGraph() == graph_)
+    ONNX_ASSERT(to->owningGraph() == graph_)
     size_t i = 0;
     for (auto input : inputs()) {
       if (input == from)
@@ -648,7 +650,7 @@ struct Node : public Attributes<Node> {
   //          %5 = h(%1)
   //          %4 = g(%3)
   Node* insertBefore(Node* n) {
-    ONNX_ASSERT(n->inGraphList());
+    ONNX_ASSERT(n->inGraphList())
     insertAfter(n->prev());
     return this;
   }
@@ -664,7 +666,7 @@ struct Node : public Attributes<Node> {
   //          %4 = g(%3)
   //          %5 = h(%1)
   Node* insertAfter(Node* n) {
-    ONNX_ASSERT(!inGraphList() && n->inGraphList());
+    ONNX_ASSERT(!inGraphList() && n->inGraphList())
     Node* next = n->next();
     n->next() = this;
     this->prev() = n;
@@ -762,7 +764,7 @@ struct Node : public Attributes<Node> {
   }
   template <typename T>
   T* expect() {
-    ONNX_ASSERTM(T::Kind == kind(), "expected a %s but found a %s", T::Kind.toString(), kind().toString());
+    ONNX_ASSERTM(T::Kind == kind(), "expected a %s but found a %s", T::Kind.toString(), kind().toString())
     return static_cast<T*>(this);
   }
 
@@ -775,7 +777,7 @@ struct Node : public Attributes<Node> {
     // O(N) on the use list, but unless we get nodes with +100 uses
     // vector traversal still is probably faster than linked list
     auto use_it = std::find(input_uses.begin(), input_uses.end(), Use(this, i));
-    ONNX_ASSERT(use_it != input_uses.end());
+    ONNX_ASSERT(use_it != input_uses.end())
     return use_it;
   }
 
@@ -783,7 +785,7 @@ struct Node : public Attributes<Node> {
   // is only used internally to Node before setting it to a new value
   // or erasing the entry from the list.
   Value* dropInput(size_t i) {
-    ONNX_ASSERT(i < inputs_.size());
+    ONNX_ASSERT(i < inputs_.size())
     auto input_node = inputs_[i];
     auto use_it = findUseForInput(i);
     input_node->uses_in_current_graph_.erase(use_it);
@@ -792,11 +794,11 @@ struct Node : public Attributes<Node> {
   }
 
   bool inGraphList() const {
-    ONNX_ASSERT(next() != nullptr || prev() == nullptr);
+    ONNX_ASSERT(next() != nullptr || prev() == nullptr)
     return next() != nullptr;
   }
   void removeFromList() {
-    ONNX_ASSERT(inGraphList());
+    ONNX_ASSERT(inGraphList())
     Node* next = this->next();
     Node* prev = this->prev();
     prev->next() = next;
@@ -854,7 +856,7 @@ class OpSetID final {
       return OpSetID(new_domain, new_version);
     }
     ONNX_CATCH(const std::runtime_error& e) {
-      ONNX_HANDLE_EXCEPTION([&]() { ONNX_ASSERTM(false, "Error in fromString: %s", e.what()); });
+      ONNX_HANDLE_EXCEPTION([&]() { ONNX_ASSERTM(false, "Error in fromString: %s", e.what()) });
     }
 
     // The control will never reach here.
@@ -1129,13 +1131,13 @@ struct Graph final {
   }
 
   Node* appendNode(Node* n) {
-    ONNX_ASSERT(n->graph_ == this && !n->inGraphList());
+    ONNX_ASSERT(n->graph_ == this && !n->inGraphList())
     n->insertBefore(output_);
     return n;
   }
 
   Node* prependNode(Node* n) {
-    ONNX_ASSERT(n->graph_ == this && !n->inGraphList());
+    ONNX_ASSERT(n->graph_ == this && !n->inGraphList())
     n->insertAfter(output_);
     return n;
   }
@@ -1242,13 +1244,13 @@ struct Graph final {
 
   void freeNode(Node* n) {
     auto it = all_nodes.find(n);
-    ONNX_ASSERT(it != all_nodes.end());
+    ONNX_ASSERT(it != all_nodes.end())
     delete *it;
     all_nodes.erase(it);
   }
   void freeValue(Value* v) {
     auto it = all_values.find(v);
-    ONNX_ASSERT(it != all_values.end());
+    ONNX_ASSERT(it != all_values.end())
     delete *it;
     all_values.erase(it);
   }
@@ -1303,7 +1305,7 @@ inline Value* Value::setUniqueName(const std::string& name, bool update_related_
 
 inline void Value::replaceAllUsesWith(Value* newValue) {
   auto* graph = owningGraph();
-  ONNX_ASSERT(graph == newValue->owningGraph());
+  ONNX_ASSERT(graph == newValue->owningGraph())
   // propagate sizes and elem type
   if (this->has_sizes()) {
     newValue->setSizes(this->sizes());
@@ -1345,8 +1347,8 @@ inline Node::Node(Graph* graph_, NodeKind kind_) : kind_(kind_), graph_(graph_),
 }
 
 inline void Node::eraseOutput(size_t i) {
-  ONNX_ASSERT(i < outputs_.size());
-  ONNX_ASSERT(outputs_[i]->uses().empty());
+  ONNX_ASSERT(i < outputs_.size())
+  ONNX_ASSERT(outputs_[i]->uses().empty())
   Value* n = outputs_[i];
   outputs_.erase(outputs_.begin() + i);
   owningGraph()->freeValue(n);
@@ -1368,7 +1370,7 @@ inline bool Node::isBefore(const Node* n) {
   if (n->kind() == kParam) {
     return false;
   }
-  ONNX_ASSERT(n->inGraphList());
+  ONNX_ASSERT(n->inGraphList())
   for (Node* p = next(); p != *graph_->end(); p = p->next()) {
     if (p == n) {
       return true;
@@ -1378,7 +1380,7 @@ inline bool Node::isBefore(const Node* n) {
 }
 
 inline void Node::destroy() {
-  ONNX_ASSERT(inGraphList());
+  ONNX_ASSERT(inGraphList())
   while (!outputs().empty())
     eraseOutput(outputs().size() - 1);
   removeAllInputs();

onnx/common/ir_pb_converter.cc

@@ -43,6 +43,8 @@ static Tensor tensorProtoToTensor(const ONNX_NAMESPACE::TensorProto& tp) {
     case ONNX_NAMESPACE::TensorProto_DataType_FLOAT16:
     case ONNX_NAMESPACE::TensorProto_DataType_BFLOAT16:
     case ONNX_NAMESPACE::TensorProto_DataType_BOOL:
+    case ONNX_NAMESPACE::TensorProto_DataType_UINT4:
+    case ONNX_NAMESPACE::TensorProto_DataType_INT4:
     case ONNX_NAMESPACE::TensorProto_DataType_INT8:
     case ONNX_NAMESPACE::TensorProto_DataType_INT16:
     case ONNX_NAMESPACE::TensorProto_DataType_INT32:
@@ -52,6 +54,7 @@ static Tensor tensorProtoToTensor(const ONNX_NAMESPACE::TensorProto& tp) {
     case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E4M3FNUZ:
     case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E5M2:
     case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E5M2FNUZ:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E8M0:
     case ONNX_NAMESPACE::TensorProto_DataType_FLOAT4E2M1: {
       ret.int32s().reserve(tp.int32_data_size());
       for (int i = 0; i < tp.int32_data_size(); i++) {
@@ -90,6 +93,8 @@ static Tensor tensorProtoToTensor(const ONNX_NAMESPACE::TensorProto& tp) {
       break;
     }
     case ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED:
+      [[fallthrough]];
+    default:
       fail_convert("Unknown tensor data type");
   }
 
@@ -105,6 +110,13 @@ static Tensor tensorProtoToTensor(const ONNX_NAMESPACE::TensorProto& tp) {
   if (tp.has_segment()) {
     ret.set_segment_begin_and_end(tp.segment().begin(), tp.segment().end());
   }
+
+  for (int i = 0; i < tp.external_data_size(); i++) {
+    ret.external_data().push_back(std::make_pair(tp.external_data(i).key(), tp.external_data(i).value()));
+  }
+  if (tp.has_data_location()) {
+    ret.data_location() = tp.data_location();
+  }
   return ret;
 }
 
@@ -241,7 +253,7 @@ std::unique_ptr<Graph> graphProtoToGraph(const ONNX_NAMESPACE::GraphProto& gp, b
   // several stages.
   //
   // 1) add all input (to the graph) Values, owned by the sentinel Param node
-  // 2) add all Nodes and their output Values, but don't intialize inputs
+  // 2) add all Nodes and their output Values, but don't initialize inputs
   // 3) initialize inputs of all Nodes
   // 4) initialize inputs of the Return sentinel node
   // 5) fill in type info for graph outputs, and register them as outputs
@@ -391,7 +403,8 @@ std::unique_ptr<Graph> graphProtoToGraph(const ONNX_NAMESPACE::GraphProto& gp, b
 std::unique_ptr<Graph> ImportModelProto(const ModelProto& mp) {
   if (!mp.has_ir_version()) {
     return nullptr;
-  } else if (mp.ir_version() <= 1) {
+  }
+  if (mp.ir_version() <= 1) {
     // ir_version=1 is not supported and ir_version=0 is illegal
     return nullptr;
   }
@@ -436,7 +449,14 @@ static void encodeTensor(ONNX_NAMESPACE::TensorProto* p, const Tensor& tensor) {
     }
     case ONNX_NAMESPACE::TensorProto_DataType_FLOAT16:
     case ONNX_NAMESPACE::TensorProto_DataType_BFLOAT16:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E4M3FN:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E4M3FNUZ:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E5M2:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E5M2FNUZ:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT4E2M1:
     case ONNX_NAMESPACE::TensorProto_DataType_BOOL:
+    case ONNX_NAMESPACE::TensorProto_DataType_INT4:
+    case ONNX_NAMESPACE::TensorProto_DataType_UINT4:
     case ONNX_NAMESPACE::TensorProto_DataType_INT8:
     case ONNX_NAMESPACE::TensorProto_DataType_INT16:
     case ONNX_NAMESPACE::TensorProto_DataType_INT32:
@@ -474,11 +494,23 @@ static void encodeTensor(ONNX_NAMESPACE::TensorProto* p, const Tensor& tensor) {
       break;
     }
     case ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED:
+      [[fallthrough]];
+    default:
       fail_convert("Unknown tensor data type");
   }
   if (tensor.is_raw_data()) {
     p->set_raw_data(tensor.raw());
   }
+  if (!tensor.external_data().empty()) {
+    for (const auto& entry : tensor.external_data()) {
+      auto* external_data = p->add_external_data();
+      external_data->set_key(entry.first);
+      external_data->set_value(entry.second);
+    }
+  }
+  if (tensor.has_data_location()) {
+    p->set_data_location(tensor.data_location());
+  }
 }
 
 static void addAttribute(ONNX_NAMESPACE::NodeProto* n_p, Node* n, Symbol name) {
@@ -580,7 +612,7 @@ static void encodeValueInfo(ONNX_NAMESPACE::ValueInfoProto* v, Value* n) {
 }
 
 void encodeGraph(GraphProto* p_g, const std::shared_ptr<Graph>& g) {
-  ONNX_ASSERT(p_g != nullptr);
+  ONNX_ASSERT(p_g != nullptr)
 
   if (g->has_name()) {
     p_g->set_name(g->name());
@@ -716,7 +748,7 @@ void assertNonNull(const std::shared_ptr<Graph>& g) {
   ONNX_ASSERTM(
       g.get() != nullptr,
       "Warning: onnx version converter is unable to parse input model. "
-      "(The IR version of the ONNX model may be too old.)");
+      "(The IR version of the ONNX model may be too old.)")
 }
 
 } // namespace ONNX_NAMESPACE

onnx/common/path.h

@@ -6,7 +6,6 @@
 
 #pragma once
 
-#include <string>
 #ifdef _WIN32
 // windows.h has preproc definitions for min and max, which prevents from using std::min and std::max.
 //  defining NOMINMAX disables the preproc macro.
@@ -15,23 +14,12 @@
 #endif
 #include <windows.h>
 
-#include <filesystem>
-
 #include "onnx/checker.h"
 #endif
 
 namespace ONNX_NAMESPACE {
 
 #ifdef _WIN32
-constexpr const char k_preferred_path_separator = '\\';
-#else // POSIX
-constexpr const char k_preferred_path_separator = '/';
-#endif
-
-#ifdef _WIN32
-inline std::wstring path_join(const std::wstring& origin, const std::wstring& append) {
-  return (std::filesystem::path(origin) / std::filesystem::path(append)).wstring();
-}
 inline std::wstring utf8str_to_wstring(const std::string& utf8str, bool try_decode = false) {
   if (utf8str.empty()) {
     return std::wstring();
@@ -82,12 +70,6 @@ inline std::string wstring_to_utf8str(const std::wstring& ws_str) {
   return utf8str;
 }
 
-#else
-std::string path_join(const std::string& origin, const std::string& append);
-// TODO: also use std::filesystem::path for clean_relative_path after ONNX has supported C++17 for POSIX
-// Clean up relative path when there is ".." in the path, e.g.: a/b/../c -> a/c
-// It cannot work with absolute path
-std::string clean_relative_path(const std::string& path);
 #endif
 
 } // namespace ONNX_NAMESPACE

onnx/common/status.h

@@ -6,21 +6,24 @@
 
 #pragma once
 
+#include <cstdint>
 #include <memory>
 #include <ostream>
 #include <string>
 #include <utility>
 
+#include "onnx/onnx_pb.h"
+
 namespace ONNX_NAMESPACE {
 namespace Common {
 
-enum class StatusCategory {
+enum class StatusCategory : std::uint8_t {
   NONE = 0,
   CHECKER = 1,
   OPTIMIZER = 2,
 };
 
-enum class StatusCode {
+enum class StatusCode : std::uint8_t {
   OK = 0,
   FAIL = 1,
   INVALID_ARGUMENT = 2,
@@ -54,15 +57,15 @@ class Status {
   Status& operator=(Status&&) = default;
   ~Status() = default;
 
-  bool IsOK() const noexcept;
+  ONNX_API bool IsOK() const noexcept;
 
-  StatusCode Code() const noexcept;
+  ONNX_API StatusCode Code() const noexcept;
 
-  StatusCategory Category() const noexcept;
+  ONNX_API StatusCategory Category() const noexcept;
 
-  const std::string& ErrorMessage() const;
+  ONNX_API const std::string& ErrorMessage() const;
 
-  std::string ToString() const;
+  ONNX_API std::string ToString() const;
 
   bool operator==(const Status& other) const {
     return (this->state_ == other.state_) || (ToString() == other.ToString());
@@ -72,7 +75,7 @@ class Status {
     return !(*this == other);
   }
 
-  static const Status& OK() noexcept;
+  ONNX_API static const Status& OK() noexcept;
 
  private:
   struct State {

onnx/common/tensor.h

@@ -41,6 +41,9 @@ struct Tensor final {
   bool is_raw_data_{false};
   std::string raw_data_;
 
+  std::vector<std::pair<std::string, std::string>> external_data_;
+  ONNX_NAMESPACE::TensorProto_DataLocation data_location_{ONNX_NAMESPACE::TensorProto_DataLocation_DEFAULT};
+
  public:
   const std::vector<int64_t>& sizes() const {
     return sizes_;
@@ -57,7 +60,7 @@ struct Tensor final {
     if (dim < 0) {
       dim += (int)sizes_.size();
     }
-    ONNX_ASSERT(dim >= 0 && (size_t)dim < sizes_.size());
+    ONNX_ASSERT(dim >= 0 && (size_t)dim < sizes_.size())
     return std::accumulate(sizes_.begin() + dim, sizes_.end(), (int64_t)1, std::multiplies<int64_t>{});
   }
 
@@ -166,6 +169,26 @@ struct Tensor final {
   bool is_raw_data() const {
     return is_raw_data_;
   }
+
+  const std::vector<std::pair<std::string, std::string>>& external_data() const {
+    return external_data_;
+  }
+
+  std::vector<std::pair<std::string, std::string>>& external_data() {
+    return external_data_;
+  }
+
+  bool has_data_location() const {
+    return data_location_ != ONNX_NAMESPACE::TensorProto_DataLocation_DEFAULT;
+  }
+
+  const ONNX_NAMESPACE::TensorProto_DataLocation& data_location() const {
+    return data_location_;
+  }
+
+  ONNX_NAMESPACE::TensorProto_DataLocation& data_location() {
+    return data_location_;
+  }
 };
 
 template <>
@@ -173,7 +196,7 @@ inline std::string* Tensor::data<std::string>() {
   ONNX_ASSERTM(
       !is_raw_data(),
       "data type is string. string content is required to be stored in repeated bytes string_data field."
-      "raw_data type cannot be string.");
+      "raw_data type cannot be string.")
   return string_data_.data();
 }
 template <>
@@ -181,7 +204,7 @@ inline const std::string* Tensor::data<std::string>() const {
   ONNX_ASSERTM(
       !is_raw_data(),
       "data type is string. string content is required to be stored in repeated bytes string_data field."
-      "raw_data type cannot be string.");
+      "raw_data type cannot be string.")
   return string_data_.data();
 }
 

onnx/common/version.h

@@ -9,6 +9,6 @@
 namespace ONNX_NAMESPACE {
 
 // Represents the most recent release version. Updated with every release.
-constexpr const char* LAST_RELEASE_VERSION = "1.18.0";
+constexpr const char* LAST_RELEASE_VERSION = "1.19.0";
 
 } // namespace ONNX_NAMESPACE

onnx/compose.py

@@ -119,7 +119,7 @@ def merge_graphs(
         prefix1 (string): Optional prefix to be added to all names in g1
         prefix2 (string): Optional prefix to be added to all names in g2
         name (string): Optional name for the combined graph
-                       By default, the name is g1.name and g2.name concatenated with an undescore delimiter
+                       By default, the name is g1.name and g2.name concatenated with an underscore delimiter
         doc_string (string): Optional docstring for the combined graph
                              If not provided, a default docstring with the concatenation of g1 and g2 docstrings is used
 
@@ -321,7 +321,7 @@ def merge_models(
         prefix1 (string): Optional prefix to be added to all names in m1
         prefix2 (string): Optional prefix to be added to all names in m2
         name (string): Optional name for the combined graph
-                       By default, the name is g1.name and g2.name concatenated with an undescore delimiter
+                       By default, the name is g1.name and g2.name concatenated with an underscore delimiter
         doc_string (string): Optional docstring for the combined graph
                              If not provided, a default docstring with the concatenation of g1 and g2 docstrings is used
         producer_name (string): Optional producer name for the combined model. Default: 'onnx.compose'
@@ -477,12 +477,16 @@ def add_prefix_graph(
 
     if name_map is None:
         name_map = {}
+
     if rename_edges:
+        # See https://github.com/onnx/onnx/pull/6869#issuecomment-2852719536.
+        # Consider only intermediate nodes, that are not connected to graph outputs.
+        # Rename graph inputs or outputs separately based on rename_inputs/rename_outputs flags.
+        graph_output_names = {o.name for o in g.output}
         for n in g.node:
-            for e in n.input:
-                name_map[e] = _prefixed(prefix, e)
             for e in n.output:
-                name_map[e] = _prefixed(prefix, e)
+                if e not in graph_output_names:
+                    name_map[e] = _prefixed(prefix, e)
 
     if rename_inputs:
         for entry in g.input: