Support for model reshape in protopipe

src/plugins/intel_npu/tools/protopipe/README.md

@@ -60,6 +60,7 @@ log_level: INFO
 - `ol` - **Optional**. Output layer layout.
 - `iml` - **Optional**. Input model layout.
 - `oml` - **Optional**. Output model layout.
+- `reshape` - **Optional**. Set shape for input layers. For example, "input1: [1,3,224,224], input2: [1,4]" or "[1,3,224,224]" in case of one input layer.
 
 Examples:
 ```

src/plugins/intel_npu/tools/protopipe/src/parser/config.cpp

@@ -345,6 +345,10 @@ struct convert<OpenVINOParams> {
             params.output_model_layout = node["oml"].as<LayerVariantAttr<std::string>>();
         }
 
+        if (node["reshape"]) {
+            params.reshape = node["reshape"].as<LayerVariantAttr<std::vector<size_t>>> ();
+        }
+
         if (node["config"]) {
             params.config = node["config"].as<std::map<std::string, std::string>>();
         }

src/plugins/intel_npu/tools/protopipe/src/scenario/inference.hpp

@@ -91,6 +91,7 @@ struct OpenVINOParams {
     LayerVariantAttr<std::string> output_layout;
     LayerVariantAttr<std::string> input_model_layout;
     LayerVariantAttr<std::string> output_model_layout;
+    LayerVariantAttr<std::vector<size_t>> reshape;
     std::map<std::string, std::string> config;
     size_t nireq = 1u;
 };

src/plugins/intel_npu/tools/protopipe/src/simulation/layers_reader.cpp

@@ -31,6 +31,25 @@ static std::string getModelFileName(const InferenceParams& params) {
     ASSERT(false);
 }
 
+static void adjustDynamicDims(LayersInfo& layers, std::string layer_type) {
+    for (auto& layer : layers) {
+        auto& dims = layer.dims;
+        if (std::find(dims.begin(), dims.end(), -1) == dims.end()) continue;
+
+        std::stringstream info_msg;
+        info_msg
+            << "Dynamic shape: [";
+            std::copy(dims.begin(), dims.end(), std::ostream_iterator<int>(info_msg, " "));
+        info_msg << "] has been detected for layer "
+            << layer.name
+            << ". Data with shape [";
+        std::for_each(dims.begin(), dims.end(), [](int &v) { v = v == -1 ? -v : v; });
+        std::copy(dims.begin(), dims.end(), std::ostream_iterator<int>(info_msg, " "));
+        info_msg << "] will be provided as "<< layer_type <<" for this layer.";
+        LOG_INFO() << info_msg.str() << std::endl;
+    }
+}
+
 InOutLayers LayersReader::readLayers(const InferenceParams& params) {
     LOG_INFO() << "Reading model " << getModelFileName(params) << std::endl;
     if (std::holds_alternative<OpenVINOParams>(params)) {
@@ -42,5 +61,9 @@ InOutLayers LayersReader::readLayers(const InferenceParams& params) {
     // NB: Using OpenVINO to read the i/o layers information for *.onnx model
     OpenVINOParams ov;
     ov.path = OpenVINOParams::ModelPath{ort.model_path, ""};
-    return getOVReader().readLayers(ov, true /* use_results_names */);
+    auto inOutLayers = getOVReader().readLayers(ov, true /* use_results_names */);
+    adjustDynamicDims(inOutLayers.in_layers, "input");
+    adjustDynamicDims(inOutLayers.out_layers, "output");
+
+    return inOutLayers;
 }

src/plugins/intel_npu/tools/protopipe/src/simulation/ov_layers_reader.cpp

@@ -44,13 +44,12 @@ static ov::element::Type toElementType(int cvdepth) {
     throw std::logic_error("Failed to convert opencv depth to ov::element::Type");
 }
 
-static std::vector<int> toDims(const std::vector<size_t>& sz_vec) {
+static std::vector<int> toDims(const ov::PartialShape& partial_shape) {
     std::vector<int> result;
-    result.reserve(sz_vec.size());
-    for (auto sz : sz_vec) {
-        // FIXME: Probably requires some check...
-        result.push_back(static_cast<int>(sz));
-    }
+
+    result.reserve(partial_shape.size());
+    auto to_int = [](auto dim) { return dim.is_dynamic() ? -1 : static_cast<int>(dim.get_length()); };
+    std::transform(partial_shape.begin(), partial_shape.end(), std::back_inserter(result), to_int);
     return result;
 }
 
@@ -75,7 +74,7 @@ std::vector<LayerInfo> ovToLayersInfo(const InfoVec& vec) {
     std::vector<LayerInfo> layers;
     layers.reserve(vec.size());
     std::transform(vec.begin(), vec.end(), std::back_inserter(layers), [](const auto& node) {
-        return LayerInfo{node.get_any_name(), toDims(node.get_shape()), toPrecision(node.get_element_type())};
+        return LayerInfo{node.get_any_name(), toDims(node.get_partial_shape()), toPrecision(node.get_element_type())};
     });
     return layers;
 };
@@ -128,6 +127,15 @@ static void cfgOutputPostproc(ov::preprocess::PrePostProcessor& ppp, const std::
     }
 }
 
+static void cfgReshape(const std::shared_ptr<ov::Model>& model, 
+                       const AttrMap<std::vector<size_t>> reshape_map) {
+    std::map<std::string, ov::PartialShape> partial_shapes;
+    for (const auto& [layer_name, shape] : reshape_map) {
+        partial_shapes.emplace(layer_name, shape);
+    }
+    model->reshape(partial_shapes);
+}
+
 static std::vector<std::string> extractLayerNames(const std::vector<ov::Output<ov::Node>>& nodes) {
     std::vector<std::string> names;
     std::transform(nodes.begin(), nodes.end(), std::back_inserter(names), [](const auto& node) {
@@ -148,6 +156,9 @@ InOutLayers OpenVINOLayersReader::Impl::readFromModel(const std::string& model_p
         const auto iml_map = unpackLayerAttr(params.input_model_layout, input_names, "input model layout");
         cfgInputPreproc(ppp, model, ip_map, il_map, iml_map);
 
+        const auto reshape_map = unpackLayerAttr(params.reshape, input_names, "reshape");
+        cfgReshape(model, reshape_map);
+
         const auto& output_names = extractLayerNames(model->outputs());
         const auto op_map = unpackLayerAttr(params.output_precision, output_names, "output precision");
         const auto ol_map = unpackLayerAttr(params.output_layout, output_names, "output layout");

src/plugins/intel_npu/tools/protopipe/src/simulation/simulation.cpp

@@ -22,6 +22,11 @@ static cv::gapi::GNetPackage getNetPackage(const std::string& tag, const OpenVIN
         const auto& blob_path = std::get<OpenVINOParams::BlobPath>(params.path);
         network = std::make_unique<P>(tag, blob_path.blob, params.device);
     }
+    if (std::holds_alternative<AttrMap<std::vector<size_t>>>(params.reshape)) {
+        network->cfgReshape(std::get<AttrMap<std::vector<size_t>>>(params.reshape));
+    } else {
+        network->cfgReshape(std::get<std::vector<size_t>>(params.reshape));
+    }
 
     network->cfgPluginConfig(params.config);
     network->cfgNumRequests(params.nireq);