Merge pull request #1189 from intel/sync_msft_07072026

Sync with Microsoft ONNX Runtime - 07072026

Author: hdharpure9922

include/onnxruntime/core/session/onnxruntime_session_options_config_keys.h

@@ -355,9 +355,12 @@ static const char* const kOrtSessionOptionsOptimizedModelExternalInitializersFil
 static const char* const kOrtSessionOptionsOptimizedModelExternalInitializersMinSizeInBytes =
     "session.optimized_model_external_initializers_min_size_in_bytes";
 
-// When loading model from memory buffer and the model has external initializers
-// Use this config to set the external data file folder path
-// All external data files should be in the same folder
+// Specifies the folder path used to resolve a model's external initializer data files.
+// When set, external initializers are loaded from this folder instead of the model's own
+// directory, overriding the model directory. This applies whether the model is loaded from a
+// file path or from a memory buffer/stream. All external data files must be in the same folder.
+// Typical uses include loading models with external data from memory, sharing a weights file
+// across models, and weightless/cache models whose weights live outside the model directory.
 static const char* const kOrtSessionOptionsModelExternalInitializersFileFolderPath =
     "session.model_external_initializers_file_folder_path";
 

onnxruntime/core/graph/model.cc

@@ -711,6 +711,19 @@ Status Model::Load(const PathString& file_path, std::shared_ptr<Model>& p_model,
   return LoadModel(file_path, p_model, local_registries, logger, options);
 }
 
+GSL_SUPPRESS(r .30)  // spurious warnings. p_model is potentially reset in the internal call to Load
+GSL_SUPPRESS(r .35)
+Status Model::Load(const PathString& file_path, const PathString& graph_model_path,
+                   std::shared_ptr<Model>& p_model,
+                   const IOnnxRuntimeOpSchemaRegistryList* local_registries,
+                   const logging::Logger& logger, const ModelOptions& options) {
+  const auto loader = [&graph_model_path, &p_model, local_registries, &logger, &options](int fd) {
+    return Model::Load(fd, graph_model_path, p_model, local_registries, logger, options);
+  };
+
+  return LoadModelHelper(file_path, loader);
+}
+
 Status Model::SaveWithExternalInitializers(Model& model, const std::filesystem::path& file_path,
                                            const std::filesystem::path& external_file_name,
                                            const ModelSavingOptions& save_options) {

onnxruntime/core/graph/model.h

@@ -251,6 +251,16 @@ class Model {
                              const logging::Logger& logger,
                              const ModelOptions& options = {});
 
+  // Reads the model bytes from file_path but stores graph_model_path as the graph's model path.
+  // graph_model_path is used as the base directory for resolving external initializers, so this
+  // overload lets callers load a model file while resolving its external data from a different folder.
+  static common::Status Load(const PathString& file_path,
+                             const PathString& graph_model_path,
+                             /*out*/ std::shared_ptr<Model>& p_model,
+                             const IOnnxRuntimeOpSchemaRegistryList* local_registries,
+                             const logging::Logger& logger,
+                             const ModelOptions& options = {});
+
   static common::Status Load(int fd, /*out*/ ONNX_NAMESPACE::ModelProto& model_proto);
 
   static common::Status Load(int fd, /*out*/ std::shared_ptr<Model>& p_model,

onnxruntime/core/session/inference_session.cc

@@ -129,6 +129,21 @@ int ParseSpinDurationUs(std::string_view str, const char* config_key,
   return spin_us;
 }
 
+#if !defined(ORT_MINIMAL_BUILD)
+// Returns the virtual model path derived from the
+// kOrtSessionOptionsModelExternalInitializersFileFolderPath config option, or an empty
+// PathString when the option is not set. When set, external initializers are resolved
+// relative to this folder, overriding the model's own directory.
+PathString GetExternalInitializersFolderModelPath(const ConfigOptions& config_options) {
+  const std::string external_data_folder_path = config_options.GetConfigOrDefault(
+      kOrtSessionOptionsModelExternalInitializersFileFolderPath, "");
+  if (external_data_folder_path.empty()) {
+    return PathString{};
+  }
+  return ToPathString(external_data_folder_path + "/virtual_model.onnx");
+}
+#endif  // !defined(ORT_MINIMAL_BUILD)
+
 // Parse a spin backoff max config value (exponential-backoff cap). Defaults to
 // 1 (no backoff, one SpinPause() per iteration). Values >= 2 enable backoff.
 unsigned int ParseSpinBackoffMax(std::string_view str, const char* config_key,
@@ -1171,7 +1186,7 @@ common::Status InferenceSession::LoadWithLoader(std::function<common::Status(std
 
 common::Status InferenceSession::LoadOnnxModel(const PathString& model_uri) {
   model_location_ = model_uri;
-  auto loader = [this](std::shared_ptr<onnxruntime::Model>& model) {
+  auto loader = [this, model_uri](std::shared_ptr<onnxruntime::Model>& model) {
 #ifdef ENABLE_LANGUAGE_INTEROP_OPS
     LoadInterOp(model_location_, interop_domains_, [&](const char* msg) { LOGS(*session_logger_, WARNING) << msg; });
     InlinedVector<OrtCustomOpDomain*> domain_ptrs;
@@ -1182,10 +1197,19 @@ common::Status InferenceSession::LoadOnnxModel(const PathString& model_uri) {
 
     const bool strict_shape_type_inference = session_options_.config_options.GetConfigOrDefault(
                                                  kOrtSessionOptionsConfigStrictShapeTypeInference, "0") == "1";
+    ModelOptions model_opts(true, strict_shape_type_inference, check_load_cancellation_fn_);
+
+    // When set, the external initializers folder overrides the model's own directory as the
+    // base for resolving external data. The model bytes are still read from model_uri.
+    PathString external_data_model_path = GetExternalInitializersFolderModelPath(session_options_.config_options);
+    if (!external_data_model_path.empty()) {
+      model_location_ = external_data_model_path;
+      return onnxruntime::Model::Load(model_uri, model_location_, model,
+                                      HasLocalSchema() ? &custom_schema_registries_ : nullptr,
+                                      *session_logger_, model_opts);
+    }
     return onnxruntime::Model::Load(model_location_, model, HasLocalSchema() ? &custom_schema_registries_ : nullptr,
-                                    *session_logger_,
-                                    ModelOptions(true, strict_shape_type_inference,
-                                                 check_load_cancellation_fn_));
+                                    *session_logger_, model_opts);
   };
 
   common::Status st = LoadWithLoader(loader, "model_loading_uri");
@@ -1270,10 +1294,9 @@ common::Status InferenceSession::Load(const void* model_data, int model_data_len
     const bool strict_shape_type_inference = session_options_.config_options.GetConfigOrDefault(
                                                  kOrtSessionOptionsConfigStrictShapeTypeInference, "0") == "1";
 
-    std::string external_data_folder_path = session_options_.config_options.GetConfigOrDefault(
-        kOrtSessionOptionsModelExternalInitializersFileFolderPath, "");
-    if (!external_data_folder_path.empty() && model_location_.empty()) {
-      model_location_ = ToPathString(external_data_folder_path + "/virtual_model.onnx");
+    PathString external_data_model_path = GetExternalInitializersFolderModelPath(session_options_.config_options);
+    if (!external_data_model_path.empty()) {
+      model_location_ = external_data_model_path;
     }
 
     return onnxruntime::Model::Load(std::move(model_proto), model_location_, model,
@@ -1308,10 +1331,9 @@ common::Status InferenceSession::LoadOnnxModel(ModelProto model_proto) {
     const bool strict_shape_type_inference = session_options_.config_options.GetConfigOrDefault(
                                                  kOrtSessionOptionsConfigStrictShapeTypeInference, "0") == "1";
 
-    std::string external_data_folder_path = session_options_.config_options.GetConfigOrDefault(
-        kOrtSessionOptionsModelExternalInitializersFileFolderPath, "");
-    if (!external_data_folder_path.empty() && model_location_.empty()) {
-      model_location_ = ToPathString(external_data_folder_path + "/virtual_model.onnx");
+    PathString external_data_model_path = GetExternalInitializersFolderModelPath(session_options_.config_options);
+    if (!external_data_model_path.empty()) {
+      model_location_ = external_data_model_path;
     }
 
     // This call will move model_proto to the constructed model instance
@@ -1354,10 +1376,9 @@ common::Status InferenceSession::Load(std::istream& model_istream, bool allow_re
                             strict_shape_type_inference,
                             check_load_cancellation_fn_);
 
-    std::string external_data_folder_path = session_options_.config_options.GetConfigOrDefault(
-        kOrtSessionOptionsModelExternalInitializersFileFolderPath, "");
-    if (!external_data_folder_path.empty() && model_location_.empty()) {
-      model_location_ = ToPathString(external_data_folder_path + "/virtual_model.onnx");
+    PathString external_data_model_path = GetExternalInitializersFolderModelPath(session_options_.config_options);
+    if (!external_data_model_path.empty()) {
+      model_location_ = external_data_model_path;
     }
 
     return onnxruntime::Model::Load(std::move(model_proto), model_location_, model,
@@ -1388,6 +1409,11 @@ common::Status InferenceSession::Load() {
     const bool allow_released_opsets_only = session_options_.config_options.GetConfigOrDefault(
                                                 kOrtSessionOptionsConfigStrictAllowReleasedOpsetsOnly, "1") == "1";
 
+    PathString external_data_model_path = GetExternalInitializersFolderModelPath(session_options_.config_options);
+    if (!external_data_model_path.empty()) {
+      model_location_ = external_data_model_path;
+    }
+
     // Pass on ownership of the parsed ModelProto to the Model instance (its job here is done by this stage)
     return Model::Load(std::move(this->model_proto_), model_location_, model,
                        HasLocalSchema() ? &custom_schema_registries_ : nullptr, *session_logger_,

onnxruntime/test/shared_lib/test_model_loading.cc

@@ -6,6 +6,7 @@
 #include "core/common/narrow.h"
 #include "test/util/include/asserts.h"
 #include <fstream>
+#include <filesystem>
 #include <limits>
 #include "test_fixture.h"
 #include "file_util.h"
@@ -275,6 +276,38 @@ TEST(CApiTest, TestLoadModelFromArrayWithExternalInitializersViaSetExternalDataP
   ASSERT_EQ(std::remove(generated_bin_path.c_str()), 0);
 }
 
+// The model has external data. Load the model from a file path whose directory does NOT contain
+// the external data file, and set model_external_initializers_file_folder_path to the folder that
+// does. This verifies the option is honored for file-path loads and overrides the model directory.
+TEST(CApiTest, TestLoadModelFromPathWithExternalInitializersViaSetExternalDataPath) {
+  const std::string model_file_name = "conv_qdq_external_ini.onnx";
+  const std::string test_folder = "testdata/";
+
+  // Copy just the model file (not the external .bin) into a subfolder so the model's own directory
+  // cannot resolve the external initializers.
+  const std::string model_only_folder = test_folder + "ext_ini_path_override/";
+  std::error_code ec;
+  std::filesystem::create_directories(model_only_folder, ec);
+  ASSERT_FALSE(ec);
+  const std::string copied_model_path = model_only_folder + model_file_name;
+  std::filesystem::copy_file(test_folder + model_file_name, copied_model_path,
+                             std::filesystem::copy_options::overwrite_existing, ec);
+  ASSERT_FALSE(ec) << "Failed to copy model file: " << ec.message();
+
+  Ort::SessionOptions so;
+  so.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_DISABLE_ALL);
+  // Point external initializers at the original folder, overriding the copied model's directory.
+  so.AddConfigEntry(kOrtSessionOptionsModelExternalInitializersFileFolderPath, test_folder.c_str());
+
+  // Loading succeeds only if the external initializers are resolved from the override folder.
+  const PathString copied_model_path_t(copied_model_path.begin(), copied_model_path.end());
+  Ort::Session session(*ort_env.get(), copied_model_path_t.c_str(), so);
+
+  // Cleanup.
+  std::filesystem::remove_all(model_only_folder, ec);
+  ASSERT_FALSE(ec) << "Failed to remove temp folder: " << ec.message();
+}
+
 #ifndef _WIN32
 struct FileDescriptorTraits {
   using Handle = int;