Merge onnx config to OV model right after loading

sovrasov · sovrasov · commit 9e449b15c81b · 2025-06-26T23:31:58.000+09:00
diff --git a/src/cpp/include/adapters/openvino_adapter.h b/src/cpp/include/adapters/openvino_adapter.h
@@ -39,7 +39,7 @@ class OpenVINOInferenceAdapter : public InferenceAdapter {
     virtual std::vector<std::string> getOutputNames() const override;
     virtual const ov::AnyMap& getModelConfig() const override;
 
-    void applyModelTransform(std::function<ov::AnyMap(std::shared_ptr<ov::Model>&, const ov::AnyMap&)> t);
+    void applyModelTransform(std::function<void(std::shared_ptr<ov::Model>&)> t);
 
 protected:
     void initInputsOutputs();
diff --git a/src/cpp/include/tasks/anomaly.h b/src/cpp/include/tasks/anomaly.h
@@ -38,7 +38,7 @@ class Anomaly {
         input_shape.height = utils::get_from_any_maps("orig_height", config, {}, input_shape.height);
     }
 
-    static ov::AnyMap serialize(std::shared_ptr<ov::Model>& ov_model, const ov::AnyMap& input_config);
+    static void serialize(std::shared_ptr<ov::Model>& ov_model);
     static Anomaly load(const std::string& model_path);
 
     AnomalyResult infer(cv::Mat image);
diff --git a/src/cpp/include/tasks/classification.h b/src/cpp/include/tasks/classification.h
@@ -54,7 +54,7 @@ class Classification {
         }
     }
 
-    static ov::AnyMap serialize(std::shared_ptr<ov::Model>& ov_model, const ov::AnyMap& input_config);
+    static void serialize(std::shared_ptr<ov::Model>& ov_model);
     static Classification load(const std::string& model_path);
 
     ClassificationResult infer(cv::Mat image);
diff --git a/src/cpp/include/tasks/detection/ssd.h b/src/cpp/include/tasks/detection/ssd.h
@@ -38,7 +38,7 @@ class SSD {
     std::map<std::string, ov::Tensor> preprocess(cv::Mat);
     DetectionResult postprocess(InferenceResult& infResult);
 
-    static ov::AnyMap serialize(std::shared_ptr<ov::Model>& ov_model, const ov::AnyMap& input_config);
+    static void serialize(std::shared_ptr<ov::Model>& ov_model);
 
     SSDOutputMode output_mode;
 
diff --git a/src/cpp/include/tasks/instance_segmentation.h b/src/cpp/include/tasks/instance_segmentation.h
@@ -35,7 +35,7 @@ class InstanceSegmentation {
         input_shape.height = utils::get_from_any_maps("orig_height", config, {}, input_shape.width);
     }
 
-    static ov::AnyMap serialize(std::shared_ptr<ov::Model>& ov_model, const ov::AnyMap& input_config);
+    static void serialize(std::shared_ptr<ov::Model>& ov_model);
     static InstanceSegmentation load(const std::string& model_path);
 
     InstanceSegmentationResult infer(cv::Mat image);
diff --git a/src/cpp/include/tasks/semantic_segmentation.h b/src/cpp/include/tasks/semantic_segmentation.h
@@ -33,7 +33,7 @@ class SemanticSegmentation {
         blur_strength = utils::get_from_any_maps("blur_strength", config, {}, blur_strength);
     }
 
-    static ov::AnyMap serialize(std::shared_ptr<ov::Model>& ov_model, const ov::AnyMap& input_config);
+    static void serialize(std::shared_ptr<ov::Model>& ov_model);
     static SemanticSegmentation load(const std::string& model_path);
 
     std::map<std::string, ov::Tensor> preprocess(cv::Mat);
diff --git a/src/cpp/include/utils/config.h b/src/cpp/include/utils/config.h
@@ -44,6 +44,8 @@ inline bool get_from_any_maps(const std::string& key,
 
 ov::AnyMap get_config_from_onnx(const std::string& model_path);
 
+void add_ov_model_info(std::shared_ptr<ov::Model> model, const ov::AnyMap& config);
+
 inline bool model_has_embedded_processing(std::shared_ptr<ov::Model> model) {
     if (model->has_rt_info("model_info")) {
         auto model_info = model->get_rt_info<ov::AnyMap>("model_info");
diff --git a/src/cpp/src/adapters/openvino_adapter.cpp b/src/cpp/src/adapters/openvino_adapter.cpp
@@ -50,18 +50,18 @@ void OpenVINOInferenceAdapter::loadModel(const std::string& modelPath,
         modelConfig = model->get_rt_info<ov::AnyMap>("model_info");
     } else if (modelPath.find("onnx") != std::string::npos || modelPath.find("ONNX") != std::string::npos) {
         modelConfig = utils::get_config_from_onnx(modelPath);
+        utils::add_ov_model_info(model, modelConfig);
     }
     if (preCompile) {
         compileModel(device, adapterConfig);
     }
 }
 
-void OpenVINOInferenceAdapter::applyModelTransform(
-    std::function<ov::AnyMap(std::shared_ptr<ov::Model>&, const ov::AnyMap&)> t) {
+void OpenVINOInferenceAdapter::applyModelTransform(std::function<void(std::shared_ptr<ov::Model>&)> t) {
     if (!model) {
         throw std::runtime_error("Model is not loaded");
     }
-    modelConfig = t(model, modelConfig);
+    t(model);
 }
 
 void OpenVINOInferenceAdapter::infer(const InferenceInput& input, InferenceOutput& output) {
diff --git a/src/cpp/src/tasks/anomaly.cpp b/src/cpp/src/tasks/anomaly.cpp
@@ -4,10 +4,10 @@
 #include "utils/preprocessing.h"
 #include "utils/tensor.h"
 
-ov::AnyMap Anomaly::serialize(std::shared_ptr<ov::Model>& ov_model, const ov::AnyMap& input_config) {
+void Anomaly::serialize(std::shared_ptr<ov::Model>& ov_model) {
     if (utils::model_has_embedded_processing(ov_model)) {
         std::cout << "model already was serialized" << std::endl;
-        return input_config;
+        return;
     }
 
     auto input = ov_model->inputs().front();
@@ -26,13 +26,13 @@ ov::AnyMap Anomaly::serialize(std::shared_ptr<ov::Model>& ov_model, const ov::An
 
     std::vector<float> scale_values;
     std::vector<float> mean_values;
-
-    auto config(input_config);
-
-    reverse_input_channels =
-        utils::get_from_any_maps("reverse_input_channels", config, ov::AnyMap{}, reverse_input_channels);
-    scale_values = utils::get_from_any_maps("scale_values", config, ov::AnyMap{}, scale_values);
-    mean_values = utils::get_from_any_maps("mean_values", config, ov::AnyMap{}, mean_values);
+    if (ov_model->has_rt_info("model_info")) {
+        auto config = ov_model->get_rt_info<ov::AnyMap>("model_info");
+        reverse_input_channels =
+            utils::get_from_any_maps("reverse_input_channels", config, ov::AnyMap{}, reverse_input_channels);
+        scale_values = utils::get_from_any_maps("scale_values", config, ov::AnyMap{}, scale_values);
+        mean_values = utils::get_from_any_maps("mean_values", config, ov::AnyMap{}, mean_values);
+    }
 
     auto input_shape = ov::Shape{shape[ov::layout::width_idx(layout)], shape[ov::layout::height_idx(layout)]};
 
@@ -47,10 +47,8 @@ ov::AnyMap Anomaly::serialize(std::shared_ptr<ov::Model>& ov_model, const ov::An
                                       mean_values,
                                       scale_values);
 
-    config["orig_width"] = std::to_string(input_shape[0]);
-    config["orig_height"] = std::to_string(input_shape[1]);
-
-    return config;
+    ov_model->set_rt_info(input_shape[0], "model_info", "orig_width");
+    ov_model->set_rt_info(input_shape[1], "model_info", "orig_height");
 }
 
 Anomaly Anomaly::load(const std::string& model_path) {
diff --git a/src/cpp/src/tasks/classification.cpp b/src/cpp/src/tasks/classification.cpp
@@ -82,14 +82,14 @@ std::vector<size_t> get_non_xai_output_indices(const std::vector<ov::Output<ov::
 }
 }  // namespace
 
-ov::AnyMap Classification::serialize(std::shared_ptr<ov::Model>& ov_model, const ov::AnyMap& input_config) {
+void Classification::serialize(std::shared_ptr<ov::Model>& ov_model) {
     if (utils::model_has_embedded_processing(ov_model)) {
         std::cout << "model already was serialized" << std::endl;
-        return input_config;
+        return;
     }
     // --------------------------- Configure input & output -------------------------------------------------
     // --------------------------- Prepare input  ------------------------------------------------------
-    auto config(input_config);
+    auto config = ov_model->has_rt_info("model_info") ? ov_model->get_rt_info<ov::AnyMap>("model_info") : ov::AnyMap{};
     std::string layout = "";
     layout = utils::get_from_any_maps("layout", config, {}, layout);
     auto inputsLayouts = utils::parseLayoutString(layout);
@@ -176,10 +176,8 @@ ov::AnyMap Classification::serialize(std::shared_ptr<ov::Model>& ov_model, const
         addOrFindSoftmaxAndTopkOutputs(ov_model, topk, output_raw_scores);
     }
 
-    config["orig_width"] = std::to_string(input_shape[0]);
-    config["orig_height"] = std::to_string(input_shape[1]);
-
-    return config;
+    ov_model->set_rt_info(input_shape[0], "model_info", "orig_width");
+    ov_model->set_rt_info(input_shape[1], "model_info", "orig_height");
 }
 
 Classification Classification::load(const std::string& model_path) {
diff --git a/src/cpp/src/tasks/detection/ssd.cpp b/src/cpp/src/tasks/detection/ssd.cpp
@@ -67,10 +67,10 @@ std::map<std::string, ov::Tensor> SSD::preprocess(cv::Mat image) {
     return input;
 }
 
-ov::AnyMap SSD::serialize(std::shared_ptr<ov::Model>& ov_model, const ov::AnyMap& input_config) {
+void SSD::serialize(std::shared_ptr<ov::Model>& ov_model) {
     if (utils::model_has_embedded_processing(ov_model)) {
         std::cout << "model already was serialized" << std::endl;
-        return input_config;
+        return;
     }
     auto output_mode = ov_model->outputs().size() > 1 ? SSDOutputMode::multi : SSDOutputMode::single;
 
@@ -89,7 +89,7 @@ ov::AnyMap SSD::serialize(std::shared_ptr<ov::Model>& ov_model, const ov::AnyMap
     auto input_shape = ov::Shape{shape[ov::layout::width_idx(layout)], shape[ov::layout::height_idx(layout)]};
     uint8_t pad_value = 0;
 
-    auto config(input_config);
+    auto config = ov_model->has_rt_info("model_info") ? ov_model->get_rt_info<ov::AnyMap>("model_info") : ov::AnyMap{};
 
     std::vector<float> scale_values;
     std::vector<float> mean_values;
@@ -115,10 +115,8 @@ ov::AnyMap SSD::serialize(std::shared_ptr<ov::Model>& ov_model, const ov::AnyMap
         // prepareMultipleOutputs(ov_model); //This does nothing from what I can see.
     }
 
-    config["orig_width"] = std::to_string(input_shape[0]);
-    config["orig_height"] = std::to_string(input_shape[1]);
-
-    return config;
+    ov_model->set_rt_info(input_shape[0], "model_info", "orig_width");
+    ov_model->set_rt_info(input_shape[1], "model_info", "orig_height");
 }
 
 void SSD::prepareSingleOutput(std::shared_ptr<ov::Model> ov_model) {
diff --git a/src/cpp/src/tasks/instance_segmentation.cpp b/src/cpp/src/tasks/instance_segmentation.cpp
@@ -121,16 +121,16 @@ cv::Mat segm_postprocess(const SegmentedObject& box, const cv::Mat& unpadded, in
     return im_mask;
 }
 
-ov::AnyMap InstanceSegmentation::serialize(std::shared_ptr<ov::Model>& ov_model, const ov::AnyMap& input_config) {
+void InstanceSegmentation::serialize(std::shared_ptr<ov::Model>& ov_model) {
     if (utils::model_has_embedded_processing(ov_model)) {
         std::cout << "model already was serialized" << std::endl;
-        return input_config;
+        return;
     }
     if (ov_model->inputs().size() != 1) {
         throw std::logic_error("MaskRCNNModel model wrapper supports topologies with only 1 input");
     }
     const auto& input = ov_model->input();
-    auto config(input_config);
+    auto config = ov_model->has_rt_info("model_info") ? ov_model->get_rt_info<ov::AnyMap>("model_info") : ov::AnyMap{};
     std::string layout = "";
     layout = utils::get_from_any_maps("layout", config, {}, layout);
     auto inputsLayouts = utils::parseLayoutString(layout);
@@ -186,10 +186,8 @@ ov::AnyMap InstanceSegmentation::serialize(std::shared_ptr<ov::Model>& ov_model,
                                saliency_map_name + ", " + feature_vector_name + " and 3 or 4 other outputs");
     }
 
-    config["orig_width"] = std::to_string(input_shape.width);
-    config["orig_height"] = std::to_string(input_shape.height);
-
-    return config;
+    ov_model->set_rt_info(input_shape.width, "model_info", "orig_width");
+    ov_model->set_rt_info(input_shape.height, "model_info", "orig_height");
 }
 
 InstanceSegmentation InstanceSegmentation::load(const std::string& model_path) {
diff --git a/src/cpp/src/tasks/semantic_segmentation.cpp b/src/cpp/src/tasks/semantic_segmentation.cpp
@@ -36,10 +36,10 @@ SemanticSegmentation SemanticSegmentation::load(const std::string& model_path) {
     return SemanticSegmentation(adapter);
 }
 
-ov::AnyMap SemanticSegmentation::serialize(std::shared_ptr<ov::Model>& ov_model, const ov::AnyMap& input_config) {
+void SemanticSegmentation::serialize(std::shared_ptr<ov::Model>& ov_model) {
     if (utils::model_has_embedded_processing(ov_model)) {
         std::cout << "model already was serialized" << std::endl;
-        return input_config;
+        return;
     }
     if (ov_model->inputs().size() != 1) {
         throw std::logic_error("Segmentation model wrapper supports topologies with only 1 input");
@@ -80,7 +80,7 @@ ov::AnyMap SemanticSegmentation::serialize(std::shared_ptr<ov::Model>& ov_model,
     uint8_t pad_value = 0;
     bool reverse_input_channels = false;
 
-    auto config(input_config);
+    auto config = ov_model->has_rt_info("model_info") ? ov_model->get_rt_info<ov::AnyMap>("model_info") : ov::AnyMap{};
 
     std::vector<float> scale_values;
     std::vector<float> mean_values;
@@ -112,10 +112,8 @@ ov::AnyMap SemanticSegmentation::serialize(std::shared_ptr<ov::Model>& ov_model,
     ov_model = ppp.build();
 
     cv::Size input_shape(shape[ov::layout::width_idx(layout)], shape[ov::layout::height_idx(layout)]);
-    config["orig_width"] = std::to_string(input_shape.width);
-    config["orig_height"] = std::to_string(input_shape.height);
-
-    return config;
+    ov_model->set_rt_info(input_shape.width, "model_info", "orig_width");
+    ov_model->set_rt_info(input_shape.height, "model_info", "orig_height");
 }
 
 std::map<std::string, ov::Tensor> SemanticSegmentation::preprocess(cv::Mat image) {
diff --git a/src/cpp/src/utils/config.cpp b/src/cpp/src/utils/config.cpp
@@ -52,3 +52,9 @@ ov::AnyMap utils::get_config_from_onnx(const std::string& model_path) {
     }
     return config;
 }
+
+void utils::add_ov_model_info(std::shared_ptr<ov::Model> model, const ov::AnyMap& config) {
+    for (const auto& k : config) {
+        model->set_rt_info(k.second, "model_info", k.first);
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ class Anomaly {`
`38`	`38`	`input_shape.height = utils::get_from_any_maps("orig_height", config, {}, input_shape.height);`
`39`	`39`	`}`
`40`	`40`
`41`		`- static ov::AnyMap serialize(std::shared_ptr<ov::Model>& ov_model, const ov::AnyMap& input_config);`
	`41`	`+ static void serialize(std::shared_ptr<ov::Model>& ov_model);`
`42`	`42`	`static Anomaly load(const std::string& model_path);`
`43`	`43`
`44`	`44`	`AnomalyResult infer(cv::Mat image);`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ class Classification {`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`
`57`		`- static ov::AnyMap serialize(std::shared_ptr<ov::Model>& ov_model, const ov::AnyMap& input_config);`
	`57`	`+ static void serialize(std::shared_ptr<ov::Model>& ov_model);`
`58`	`58`	`static Classification load(const std::string& model_path);`
`59`	`59`
`60`	`60`	`ClassificationResult infer(cv::Mat image);`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ class InstanceSegmentation {`
`35`	`35`	`input_shape.height = utils::get_from_any_maps("orig_height", config, {}, input_shape.width);`
`36`	`36`	`}`
`37`	`37`
`38`		`- static ov::AnyMap serialize(std::shared_ptr<ov::Model>& ov_model, const ov::AnyMap& input_config);`
	`38`	`+ static void serialize(std::shared_ptr<ov::Model>& ov_model);`
`39`	`39`	`static InstanceSegmentation load(const std::string& model_path);`
`40`	`40`
`41`	`41`	`InstanceSegmentationResult infer(cv::Mat image);`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ class SemanticSegmentation {`
`33`	`33`	`blur_strength = utils::get_from_any_maps("blur_strength", config, {}, blur_strength);`
`34`	`34`	`}`
`35`	`35`
`36`		`- static ov::AnyMap serialize(std::shared_ptr<ov::Model>& ov_model, const ov::AnyMap& input_config);`
	`36`	`+ static void serialize(std::shared_ptr<ov::Model>& ov_model);`
`37`	`37`	`static SemanticSegmentation load(const std::string& model_path);`
`38`	`38`
`39`	`39`	`std::map<std::string, ov::Tensor> preprocess(cv::Mat);`
Original file line number	Diff line number	Diff line change
`@@ -50,18 +50,18 @@ void OpenVINOInferenceAdapter::loadModel(const std::string& modelPath,`
`50`	`50`	`modelConfig = model->get_rt_info<ov::AnyMap>("model_info");`
`51`	`51`	`} else if (modelPath.find("onnx") != std::string::npos \|\| modelPath.find("ONNX") != std::string::npos) {`
`52`	`52`	`modelConfig = utils::get_config_from_onnx(modelPath);`
	`53`	`+ utils::add_ov_model_info(model, modelConfig);`
`53`	`54`	`}`
`54`	`55`	`if (preCompile) {`
`55`	`56`	`compileModel(device, adapterConfig);`
`56`	`57`	`}`
`57`	`58`	`}`
`58`	`59`
`59`		`-void OpenVINOInferenceAdapter::applyModelTransform(`
`60`		`- std::function<ov::AnyMap(std::shared_ptr<ov::Model>&, const ov::AnyMap&)> t) {`
	`60`	`+void OpenVINOInferenceAdapter::applyModelTransform(std::function<void(std::shared_ptr<ov::Model>&)> t) {`
`61`	`61`	`if (!model) {`
`62`	`62`	`throw std::runtime_error("Model is not loaded");`
`63`	`63`	`}`
`64`		`- modelConfig = t(model, modelConfig);`
	`64`	`+ t(model);`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`void OpenVINOInferenceAdapter::infer(const InferenceInput& input, InferenceOutput& output) {`