CVS-176847 Reshape Input to apply to OVIR models as well (#864)

n1harika · web-flow · commit e0779f2959ba · 2025-12-09T10:14:10.000+05:30
To prevent recompilation of epctx models, a check was introduced to prevent the provider option 'reshape_input' from being used with epctx graphs. However, this also prevents OVIR models from compiling with the reshape input.
This PR modifies the check on epctx graphs to allow reshape for OVIR models and also adds a method to reshape it within the ImportEPCtxOVIREncapsulation() function.

Test:

onnxruntime_perf_test -m times -r 1 -e openvino -v -C "ep.context_enable|1 ep.context_file_path|ov_encoder_30_40_ctx.onnx" -i "device_type|NPU reshape_input|input_features[30..40,80,3000]" "openvino_encoder_model.onnx"

This should fail if input data&gt;40 is provided.

Also removed redundant validation and checks on the OVEP side, to let OV handle reshape validation completely.
diff --git a/onnxruntime/core/providers/openvino/backend_manager.cc b/onnxruntime/core/providers/openvino/backend_manager.cc
@@ -96,7 +96,7 @@ BackendManager::BackendManager(SessionContext& session_context,
   ptr_stream_t model_stream;
   std::unique_ptr<onnx::ModelProto> model_proto;
   if (subgraph_context_.is_ep_ctx_graph) {
-    if (!session_context_.reshape.empty()) {
+    if (!session_context_.reshape.empty() && !subgraph_context_.is_ep_ctx_ovir_encapsulated) {
       std::string exception_str =
           "[OpenVINO-EP] Bounded dynamic model execution using provider option reshape_input is not supported for OVEP EPContext model";
       ORT_THROW(exception_str);
@@ -231,21 +231,8 @@ bool BackendManager::ModelHasBatchedInputs(const ONNX_NAMESPACE::ModelProto& mod
 bool BackendManager::ModelHasSymbolicInputDims(const onnxruntime::GraphViewer& subgraph) const {
   const auto& graph_inputs = subgraph.GetInputs();
 
-  // First validate shapes if provided by user
-  bool shapes_valid = true;
-  if (!session_context_.reshape.empty()) {
-    try {
-      ValidateInputShapes(session_context_.reshape, graph_inputs);
-    } catch (const std::exception& e) {
-      LOGS_DEFAULT(ERROR) << "[OpenVINO-EP] Shape validation failed: " << e.what();
-      session_context_.reshape.clear();  // Clear the shape map as it's invalid
-      shapes_valid = false;
-    }
-  }
-
   // Count dynamic inputs and check if reshape covers all of them
   size_t dynamic_input_count = 0;
-  bool all_dynamic_inputs_covered = true;
 
   for (const auto* input : graph_inputs) {
     // Skip dangling inputs (no consumers)
@@ -273,14 +260,6 @@ bool BackendManager::ModelHasSymbolicInputDims(const onnxruntime::GraphViewer& s
     // If dynamic, count it and check if reshape covers it
     if (has_dynamic_dim) {
       dynamic_input_count++;
-
-      // Check if this dynamic input is covered by reshape input
-      if (!session_context_.reshape.empty() &&
-          session_context_.reshape.find(input->Name()) == session_context_.reshape.end()) {
-        all_dynamic_inputs_covered = false;
-        LOGS_DEFAULT(WARNING) << "[OpenVINO-EP] reshape_input is provided but doesn't cover dynamic input: "
-                              << input->Name();
-      }
     }
   }
 
@@ -290,22 +269,8 @@ bool BackendManager::ModelHasSymbolicInputDims(const onnxruntime::GraphViewer& s
   if (session_context_.reshape.empty()) {
     return has_symbolic_dims;  // Return based on whether model has symbolic dims
   }
+  else return false;
 
-  // For dynamic models with incomplete reshape coverage, clear shapes
-  if (has_symbolic_dims && !all_dynamic_inputs_covered) {
-    session_context_.reshape.clear();
-    LOGS_DEFAULT(WARNING) << "reshape_input does not cover all dynamic dimensions, "
-                          << "ignoring all provided shapes";
-    return true;  // Model is dynamic
-  }
-
-  // If shapes are valid with complete coverage for dynamic model, treat as concrete
-  if (has_symbolic_dims && shapes_valid && all_dynamic_inputs_covered) {
-    LOGS_DEFAULT(INFO) << "All dynamic dimensions successfully covered by reshape_input";
-    return false;  // Model is now effectively static with concrete shapes
-  }
-
-  return has_symbolic_dims;  // Return dynamic status based on symbolic dimensions
 }
 
 // Check to see if the graph is QDQ
@@ -690,40 +655,6 @@ BackendManager::ReWriteBatchDimWithOne(const ONNX_NAMESPACE::ModelProto& model_p
   return model_copy;
 }
 
-void BackendManager::ValidateInputShapes(const reshape_t& shapes,
-                                         const std::vector<const NodeArg*>& graph_inputs) const {
-  for (const auto& [tensor_name, requested_shape] : shapes) {
-    // Find matching input in graph
-    const NodeArg* graph_input = nullptr;
-    for (const auto* input : graph_inputs) {
-      if (input->Name() == tensor_name) {
-        graph_input = input;
-        break;
-      }
-    }
-
-    if (!graph_input) {
-      ORT_THROW("Input '" + tensor_name + "' specified in reshape_input does not exist in the graph");
-    }
-
-    const ONNX_NAMESPACE::TensorShapeProto* graph_shape = graph_input->Shape();
-    if (!graph_shape) {
-      ORT_THROW("Graph input '" + tensor_name + "' has no shape information");
-    }
-
-    // Check dimensions count matches
-    size_t graph_dim_count = graph_shape->dim_size();
-    size_t requested_dim_count = requested_shape.get_max_shape().size();
-
-    if (graph_dim_count != requested_dim_count) {
-      ORT_THROW("Dimensions mismatch for input '" + tensor_name +
-                "': graph expects " + std::to_string(graph_dim_count) +
-                " dimensions but reshape_input specifies " +
-                std::to_string(requested_dim_count) + " dimensions");
-    }
-  }
-}
-
 void BackendManager::Compute(OrtKernelContext* context) {
   Ort::KernelContext ctx(context);
   std::chrono::high_resolution_clock::time_point start_compute, end_compute;
diff --git a/onnxruntime/core/providers/openvino/backend_manager.h b/onnxruntime/core/providers/openvino/backend_manager.h
@@ -42,8 +42,6 @@ class BackendManager {
   std::unordered_set<std::string> IdentifyDynamicInputs(const onnxruntime::GraphViewer& subgraph,
                                                         const std::vector<const NodeArg*>& graph_inputs) const;
   bool ModelHasBatchedInputs(const ONNX_NAMESPACE::ModelProto& model_proto) const;
-  void ValidateInputShapes(const reshape_t& shapes,
-                           const std::vector<const NodeArg*>& graph_inputs) const;
 
   std::shared_ptr<ONNX_NAMESPACE::ModelProto>
   ReWriteBatchDimWithOne(const ONNX_NAMESPACE::ModelProto& model_proto);
diff --git a/onnxruntime/core/providers/openvino/backends/basic_backend.cc b/onnxruntime/core/providers/openvino/backends/basic_backend.cc
@@ -63,7 +63,8 @@ BasicBackend::BasicBackend(std::unique_ptr<ONNX_NAMESPACE::ModelProto>& model_pr
                                                                    hw_target,
                                                                    device_config,
                                                                    enable_causallm,
-                                                                   model_file_path());
+                                                                   model_file_path(),
+                                                                   session_context_);
       } else {
         // If the blob is held in an EPContext node, then skip FE+Compile
         // and directly move on to creating a backend with the executable blob
@@ -308,26 +309,6 @@ void BasicBackend::SetOVDeviceConfiguration(ov::AnyMap& device_config) {
   }
 }
 
-void BasicBackend::ValidateOrtDimsAgainstPartialShape(const std::vector<int64_t>& ort_dims,
-                                                      const ov::PartialShape& partial_shape) const {
-  // Check if the number of dimensions matches
-  if (static_cast<int64_t>(ort_dims.size()) != partial_shape.rank().get_length()) {
-    ORT_THROW("Mismatch in number of dimensions between ORT tensor and OpenVINO PartialShape.");
-  }
-  // Validate each dimension
-  for (size_t i = 0; i < ort_dims.size(); ++i) {
-    const auto& ov_dim = partial_shape[i];  // OpenVINO dimension at index i
-    int64_t ort_dim = ort_dims[i];          // ORT dimension at index i
-
-    // Check if the ORT dimension is within the specified range
-    int64_t min_dim = ov_dim.get_min_length();
-    int64_t max_dim = ov_dim.get_max_length();
-    if (ort_dim < min_dim || ort_dim > max_dim) {
-      ORT_THROW(" ORT Dimension is out of range");
-    }
-  }
-}
-
 void BasicBackend::RewindKVCache(size_t index) {
   infer_req_pool_->forEachIdleRequest([&](OVInferRequestPtr& infer_request) {
     infer_request->RewindKVCache(index);
@@ -374,9 +355,6 @@ void BasicBackend::Infer(OrtKernelContext* ctx) const {
       // Set the input shape based on the input tensor from ort
       auto tensor = context.GetInput(input_info.onnx_index);
       auto ort_shape = tensor.GetTensorTypeAndShapeInfo().GetShape();
-      if (input_info.IsBoundedDynamic()) {
-        ValidateOrtDimsAgainstPartialShape(ort_shape, input_info.shape);
-      }
       auto input_shape = ParameterShape(ort_shape);
 
       infer_request->SetTensor(input_info.name,
diff --git a/onnxruntime/core/providers/openvino/backends/basic_backend.h b/onnxruntime/core/providers/openvino/backends/basic_backend.h
@@ -36,7 +36,6 @@ struct ParameterInfo {
   // Query methods
   bool IsStatic() const { return dynamic_flags == 0; }
   bool IsFullyDynamic() const { return dynamic_flags & 1; }
-  bool IsBoundedDynamic() const { return dynamic_flags & 2; }
   bool IsMixed() const { return (dynamic_flags & 3) == 3; }
 
   // Setter methods
@@ -147,8 +146,6 @@ class BasicBackend : public IBackend {
   void EnableStreams(ov::AnyMap& device_config);
   void SetNumThreads(ov::AnyMap& device_config);
   void SetOVDeviceConfiguration(ov::AnyMap& device_config);
-  void ValidateOrtDimsAgainstPartialShape(const std::vector<int64_t>& ort_dims,
-                                          const ov::PartialShape& partial_shape) const;
 
   SessionContext& session_context_;
   SubGraphContext subgraph_context_;
diff --git a/onnxruntime/core/providers/openvino/ov_interface.cc b/onnxruntime/core/providers/openvino/ov_interface.cc
@@ -226,7 +226,8 @@ OVExeNetwork OVCore::ImportEPCtxOVIREncapsulation(std::istream& model_stream,
                                                   std::string& hw_target,
                                                   const ov::AnyMap& device_config,
                                                   bool enable_causallm,
-                                                  std::filesystem::path model_file_path) {
+                                                  std::filesystem::path model_file_path,
+                                                  const SessionContext& session_context) {
   return OvExceptionBoundary<false>([&]() {
     OVExeNetwork exe;
 
@@ -259,6 +260,11 @@ OVExeNetwork OVCore::ImportEPCtxOVIREncapsulation(std::istream& model_stream,
       // Load the model explicitly with XML contents
       std::shared_ptr<ov::Model> model = core.read_model(xml_file_path.string());
 
+      if (!session_context.reshape.empty()) {
+        LOGS_DEFAULT(INFO) << log_tag << "Reshaping OV-IR model to specified shape";
+        model->reshape(session_context.reshape);
+      }
+
       if (enable_causallm) {
         exe = OVCore::Get()->StatefulCompileModel(model, hw_target, device_config);
       } else {
diff --git a/onnxruntime/core/providers/openvino/ov_interface.h b/onnxruntime/core/providers/openvino/ov_interface.h
@@ -39,6 +39,7 @@ class OVCore;
 class OVInferRequest;
 class OVExeNetwork;
 struct ModelBlobWrapper;
+struct SessionContext;
 
 typedef ov::Tensor OVTensor;
 typedef ov::ProfilingInfo OVProfilingInfo;
@@ -77,7 +78,8 @@ struct OVCore : WeakSingleton<OVCore> {
                                             std::string& hw_target,
                                             const ov::AnyMap& device_config,
                                             bool enable_causallm,
-                                            std::filesystem::path model_file_path);
+                                            std::filesystem::path model_file_path,
+                                            const SessionContext& session_context);
 
   std::vector<std::string> GetAvailableDevices() const;
   std::vector<std::string> GetAvailableDevices(const std::string& device_type) const;
