Support ONNX models via OV (#310)

sovrasov · web-flow · commit d9cec5cf9e9b · 2025-06-27T16:05:03.000+02:00
* Add ONNX rt to cmake

* Support onnx via OV

* Update tests

* Merge onnx config to OV model right after loading

* Revert changes in the OV adapter

* Cleanup in cmake

* Link onnxrt publicly
diff --git a/src/cpp/CMakeLists.txt b/src/cpp/CMakeLists.txt
@@ -12,21 +12,39 @@ include(FetchContent)
 FetchContent_Declare(json GIT_REPOSITORY https://github.com/nlohmann/json.git
                           GIT_TAG d41ca94fa85d5119852e2f7a3f94335cc7cb0486  # PR #4709, fixes cmake deprecation warnings
                     )
-
 FetchContent_MakeAvailable(json)
 
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+        FetchContent_Declare(
+                onnxrt
+                URL      https://github.com/microsoft/onnxruntime/releases/download/v1.22.0/onnxruntime-linux-x64-1.22.0.tgz
+                URL_HASH MD5=2b3a728a057226a3d6577335604db9bc
+        )
+        FetchContent_MakeAvailable(onnxrt)
+
+        # fixes onnxrt cmake disabilities
+        set(ONNXRUNTIME_ROOTDIR ${CMAKE_BINARY_DIR}/_deps/onnxrt-src)
+        file(CREATE_LINK "${ONNXRUNTIME_ROOTDIR}/lib" "${ONNXRUNTIME_ROOTDIR}/lib64" SYMBOLIC)
+        file(CREATE_LINK "${ONNXRUNTIME_ROOTDIR}/include" "${ONNXRUNTIME_ROOTDIR}/include/onnxruntime" SYMBOLIC)
+        list(APPEND CMAKE_PREFIX_PATH "${ONNXRUNTIME_ROOTDIR}/lib/cmake")
+else()
+        message(FATAL_ERROR "Unsupported platform: ${CMAKE_SYSTEM_NAME}. Only Linux is supported at the moment.")
+endif()
+
 
 find_package(OpenCV REQUIRED COMPONENTS core imgproc)
 
 find_package(OpenVINO REQUIRED
              COMPONENTS Runtime Threading)
 
+find_package(onnxruntime REQUIRED)
+
 file(GLOB TASK_SOURCES src/tasks/**/*.cpp)
 file(GLOB TASKS_SOURCES src/tasks/*.cpp)
 file(GLOB UTILS_SOURCES src/utils/*.cpp)
 file(GLOB ADAPTERS_SOURCES src/adapters/*.cpp)
 
 add_library(model_api STATIC ${TASK_SOURCES} ${TASKS_SOURCES} ${UTILS_SOURCES} ${ADAPTERS_SOURCES} ${TILERS_SOURCES})
 
-target_link_libraries(model_api PUBLIC openvino::runtime opencv_core opencv_imgproc PRIVATE nlohmann_json::nlohmann_json)
+target_link_libraries(model_api PUBLIC openvino::runtime opencv_core opencv_imgproc onnxruntime::onnxruntime PRIVATE nlohmann_json::nlohmann_json)
 target_include_directories(model_api PUBLIC ${PROJECT_SOURCE_DIR}/include)
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 void serialize(std::shared_ptr<ov::Model> ov_model);
+    static void serialize(std::shared_ptr<ov::Model>& ov_model);
 
     SSDOutputMode output_mode;
 
diff --git a/src/cpp/include/utils/config.h b/src/cpp/include/utils/config.h
@@ -42,6 +42,10 @@ inline bool get_from_any_maps(const std::string& key,
     return low_priority;
 }
 
+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
@@ -48,6 +48,9 @@ void OpenVINOInferenceAdapter::loadModel(const std::string& modelPath,
     model = core.read_model(modelPath);
     if (model->has_rt_info({"model_info"})) {
         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);
diff --git a/src/cpp/src/tasks/detection.cpp b/src/cpp/src/tasks/detection.cpp
@@ -5,6 +5,8 @@
 
 #include "tasks/detection.h"
 
+#include <algorithm>
+
 #include "adapters/openvino_adapter.h"
 #include "tasks/detection/ssd.h"
 #include "utils/config.h"
@@ -17,7 +19,7 @@ DetectionModel DetectionModel::load(const std::string& model_path, const ov::Any
 
     std::string model_type;
     model_type = utils::get_from_any_maps("model_type", adapter->getModelConfig(), {}, model_type);
-    transform(model_type.begin(), model_type.end(), model_type.begin(), ::tolower);
+    std::transform(model_type.begin(), model_type.end(), model_type.begin(), ::tolower);
 
     if (model_type.empty() || model_type != "ssd") {
         throw std::runtime_error("Incorrect or unsupported model_type, expected: ssd");
diff --git a/src/cpp/src/tasks/detection/ssd.cpp b/src/cpp/src/tasks/detection/ssd.cpp
@@ -67,7 +67,7 @@ std::map<std::string, ov::Tensor> SSD::preprocess(cv::Mat image) {
     return input;
 }
 
-void SSD::serialize(std::shared_ptr<ov::Model> ov_model) {
+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;
diff --git a/src/cpp/src/utils/config.cpp b/src/cpp/src/utils/config.cpp
@@ -4,3 +4,57 @@
  */
 
 #include "utils/config.h"
+
+#include <onnxruntime_cxx_api.h>
+
+namespace {
+std::vector<std::string> split(const std::string& str, const std::string& delimiter) {
+    std::vector<std::string> output;
+    size_t start = 0;
+    size_t end = 0;
+    while ((end = str.find(delimiter, start)) != std::string::npos) {
+        output.push_back(str.substr(start, end - start));
+        start = end + delimiter.length();
+    }
+    output.push_back(str.substr(start));
+    return output;
+}
+}  // namespace
+
+ov::AnyMap utils::get_config_from_onnx(const std::string& model_path) {
+    ov::AnyMap config;
+    if (model_path.find("onnx") != std::string::npos || model_path.find("ONNX") != std::string::npos) {
+        Ort::Env env;
+        Ort::SessionOptions ort_session_options;
+        Ort::Session session = Ort::Session(env, model_path.c_str(), ort_session_options);
+        Ort::AllocatorWithDefaultOptions ort_alloc;
+
+        Ort::ModelMetadata model_metadata = session.GetModelMetadata();
+        std::vector<Ort::AllocatedStringPtr> keys = model_metadata.GetCustomMetadataMapKeysAllocated(ort_alloc);
+        for (const auto& key : keys) {
+            std::vector<std::string> attr_names;
+            if (key != nullptr) {
+                const std::array<const char*, 1> list_names = {key.get()};
+
+                Ort::AllocatedStringPtr values_search =
+                    model_metadata.LookupCustomMetadataMapAllocated(list_names[0], ort_alloc);
+                if (values_search != nullptr) {
+                    const std::array<const char*, 1> value = {values_search.get()};
+                    attr_names = split(std::string(list_names[0]), " ");
+                    // only flat metadata is supported
+                    if (attr_names.size() == 2 && attr_names[0] == "model_info")
+                        config[attr_names[1]] = std::string(value[0]);
+                }
+            }
+        }
+    } else {
+        throw std::runtime_error("Model is not ONNX, can't get config from it");
+    }
+    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);
+    }
+}
diff --git a/tests/cpp/test_accuracy.cpp b/tests/cpp/test_accuracy.cpp
@@ -146,6 +146,11 @@ TEST_P(ModelParameterizedTest, SerializedAccuracyTest) {
 
     const std::string& basename = data.name.substr(data.name.find_last_of("/\\") + 1);
     auto model_path = DATA_DIR + "/serialized/" + basename;
+
+    if (model_path.find(".onnx") != std::string::npos) {
+        GTEST_SKIP() << "ONNX models are not serializable";
+    }
+
     if (data.type == "DetectionModel") {
         auto use_tiling = !data.input_res.empty();
         auto model = DetectionModel::load(model_path, {{"tiling", use_tiling}});
@@ -207,6 +212,10 @@ TEST_P(ModelParameterizedTest, AccuracyTestBatch) {
     const std::string& basename = data.name.substr(data.name.find_last_of("/\\") + 1);
     auto model_path = DATA_DIR + "/serialized/" + basename;
 
+    if (model_path.find(".onnx") != std::string::npos) {
+        GTEST_SKIP() << "ONNX models are not serializable";
+    }
+
     if (data.type == "DetectionModel") {
         auto use_tiling = !data.input_res.empty();
         auto model = DetectionModel::load(model_path, {{"tiling", use_tiling}});
diff --git a/tests/python/accuracy/public_scope.json b/tests/python/accuracy/public_scope.json
@@ -23,6 +23,18 @@
       }
     ]
   },
+  {
+    "name": "otx_models/Lite-hrnet-s_mod2.onnx",
+    "type": "SegmentationModel",
+    "test_data": [
+      {
+        "image": "coco128/images/train2017/000000000074.jpg",
+        "reference": [
+          "0: 0.563, 1: 0.437, [426,640,2], [0], [0]; object: 0.520, 26, object: 0.530, 42, object: 0.501, 4, object: 0.507, 27, object: 0.503, 8, object: 0.502, 6, object: 0.505, 18, object: 0.504, 13, object: 0.524, 87, object: 0.521, 89, object: 0.757, 2706, "
+        ]
+      }
+    ]
+  },
   {
     "name": "otx_models/segmentation_model_with_xai_head.xml",
     "type": "SegmentationModel",
@@ -47,6 +59,18 @@
       }
     ]
   },
+  {
+    "name": "otx_models/is_efficientnetb2b_maskrcnn_coco_reduced_onnx.onnx",
+    "type": "MaskRCNNModel",
+    "test_data": [
+      {
+        "image": "coco128/images/train2017/000000000074.jpg",
+        "reference": [
+          "458, 106, 495, 150, 1 (person): 0.818, 852, RotatedRect: 478.119 130.332 28.677 46.408 46.637; 0, 30, 178, 323, 2 (bicycle): 0.753, 26728, RotatedRect: 79.739 177.262 251.785 156.656 87.397; 0; [0]; person: 0.818, 139; bicycle: 0.753, 622; "
+        ]
+      }
+    ]
+  },
   {
     "name": "otx_models/is_resnet50_maskrcnn_coco_reduced.xml",
     "type": "MaskRCNNModel",
@@ -71,6 +95,18 @@
       }
     ]
   },
+  {
+    "name": "otx_models/det_mobilenetv2_atss_bccd_onnx.onnx",
+    "type": "DetectionModel",
+    "test_data": [
+      {
+        "image": "BloodImage_00007.jpg",
+        "reference": [
+          "494, 159, 637, 308, 2 (WBC): 0.697; 28, 139, 135, 228, 1 (RBC): 0.628; 535, 375, 638, 479, 1 (RBC): 0.524; 513, 8, 633, 152, 1 (RBC): 0.430; 21, 291, 143, 399, 1 (RBC): 0.422; 196, 86, 410, 286, 1 (RBC): 0.422; [0]; [0]"
+        ]
+      }
+    ]
+  },
   {
     "name": "otx_models/detection_model_with_xai_head.xml",
     "type": "DetectionModel",
@@ -142,6 +178,16 @@
       }
     ]
   },
+  {
+    "name": "otx_models/cls_mobilenetv3_large_cars.onnx",
+    "type": "ClassificationModel",
+    "test_data": [
+      {
+        "image": "coco128/images/train2017/000000000471.jpg",
+        "reference": ["105 (194): 0.456, [0], [0], [196]"]
+      }
+    ]
+  },
   {
     "name": "otx_models/cls_efficient_b0_cars.xml",
     "type": "ClassificationModel",

Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ std::map<std::string, ov::Tensor> SSD::preprocess(cv::Mat image) {`
`67`	`67`	`return input;`
`68`	`68`	`}`
`69`	`69`
`70`		`-void SSD::serialize(std::shared_ptr<ov::Model> ov_model) {`
	`70`	`+void SSD::serialize(std::shared_ptr<ov::Model>& ov_model) {`
`71`	`71`	`if (utils::model_has_embedded_processing(ov_model)) {`
`72`	`72`	`std::cout << "model already was serialized" << std::endl;`
`73`	`73`	`return;`