Adds preload tests back in.

RHeckerIntel · RHeckerIntel · commit 8168c276177f · 2025-06-30T11:12:35.000+02:00
Also fix the way the model loads
Preload is basically calling the compileModel so dont pass it in
initially unless we're sure that it doesnt need transforming
diff --git a/src/cpp/include/tasks/anomaly.h b/src/cpp/include/tasks/anomaly.h
@@ -40,7 +40,7 @@ class Anomaly {
     }
 
     static void serialize(std::shared_ptr<ov::Model>& ov_model);
-    static Anomaly create_model(const std::string& model_path, const ov::AnyMap& user_config = {});
+    static Anomaly create_model(const std::string& model_path, const ov::AnyMap& user_config = {}, bool preload = true, const std::string& device = "AUTO");
 
     AnomalyResult infer(cv::Mat image);
     std::vector<AnomalyResult> inferBatch(std::vector<cv::Mat> image);
diff --git a/src/cpp/include/tasks/classification.h b/src/cpp/include/tasks/classification.h
@@ -58,7 +58,7 @@ class Classification {
     }
 
     static void serialize(std::shared_ptr<ov::Model>& ov_model);
-    static Classification create_model(const std::string& model_path, const ov::AnyMap& user_config = {});
+    static Classification create_model(const std::string& model_path, const ov::AnyMap& user_config = {}, bool preload = true, const std::string& device = "AUTO");
 
     ClassificationResult infer(cv::Mat image);
     std::vector<ClassificationResult> inferBatch(std::vector<cv::Mat> image);
diff --git a/src/cpp/include/tasks/detection.h b/src/cpp/include/tasks/detection.h
@@ -67,7 +67,7 @@ class DetectionModel {
                                    const std::vector<cv::Rect>& tile_coords,
                                    const utils::TilingInfo& tiling_info);
 
-    static DetectionModel create_model(const std::string& model_path, const ov::AnyMap& user_config = {});
+    static DetectionModel create_model(const std::string& model_path, const ov::AnyMap& user_config = {}, bool preload = true, const std::string& device = "AUTO");
 
     DetectionResult infer(cv::Mat image);
     std::vector<DetectionResult> inferBatch(std::vector<cv::Mat> image);
diff --git a/src/cpp/include/tasks/instance_segmentation.h b/src/cpp/include/tasks/instance_segmentation.h
@@ -37,7 +37,7 @@ class InstanceSegmentation {
     }
 
     static void serialize(std::shared_ptr<ov::Model>& ov_model);
-    static InstanceSegmentation create_model(const std::string& model_path, const ov::AnyMap& user_config = {});
+    static InstanceSegmentation create_model(const std::string& model_path, const ov::AnyMap& user_config = {}, bool preload = true, const std::string& device = "AUTO");
 
     InstanceSegmentationResult infer(cv::Mat image);
     std::vector<InstanceSegmentationResult> inferBatch(std::vector<cv::Mat> image);
diff --git a/src/cpp/include/tasks/semantic_segmentation.h b/src/cpp/include/tasks/semantic_segmentation.h
@@ -34,7 +34,7 @@ class SemanticSegmentation {
     }
 
     static void serialize(std::shared_ptr<ov::Model>& ov_model);
-    static SemanticSegmentation create_model(const std::string& model_path, const ov::AnyMap& user_config = {});
+    static SemanticSegmentation create_model(const std::string& model_path, const ov::AnyMap& user_config = {}, bool preload = true, const std::string& device = "AUTO");
 
     std::map<std::string, ov::Tensor> preprocess(cv::Mat);
     SemanticSegmentationResult postprocess(InferenceResult& infResult);
diff --git a/src/cpp/src/tasks/anomaly.cpp b/src/cpp/src/tasks/anomaly.cpp
@@ -51,9 +51,9 @@ void Anomaly::serialize(std::shared_ptr<ov::Model>& ov_model) {
     ov_model->set_rt_info(input_shape[1], "model_info", "orig_height");
 }
 
-Anomaly Anomaly::create_model(const std::string& model_path, const ov::AnyMap& user_config) {
+Anomaly Anomaly::create_model(const std::string& model_path, const ov::AnyMap& user_config, bool preload, const std::string& device) {
     auto adapter = std::make_shared<OpenVINOInferenceAdapter>();
-    adapter->loadModel(model_path, "", user_config, false);
+    adapter->loadModel(model_path, device, user_config, false);
 
     std::string model_type;
     model_type = utils::get_from_any_maps("model_type", adapter->getModelConfig(), user_config, model_type);
@@ -65,7 +65,9 @@ Anomaly Anomaly::create_model(const std::string& model_path, const ov::AnyMap& u
     }
 
     adapter->applyModelTransform(Anomaly::serialize);
-    adapter->compileModel("AUTO", user_config);
+    if (preload) {
+        adapter->compileModel(device, user_config);
+    }
 
     return Anomaly(adapter, user_config);
 }
diff --git a/src/cpp/src/tasks/classification.cpp b/src/cpp/src/tasks/classification.cpp
@@ -180,9 +180,9 @@ void Classification::serialize(std::shared_ptr<ov::Model>& ov_model) {
     ov_model->set_rt_info(input_shape[1], "model_info", "orig_height");
 }
 
-Classification Classification::create_model(const std::string& model_path, const ov::AnyMap& user_config) {
+Classification Classification::create_model(const std::string& model_path, const ov::AnyMap& user_config, bool preload, const std::string& device) {
     auto adapter = std::make_shared<OpenVINOInferenceAdapter>();
-    adapter->loadModel(model_path, "", user_config, false);
+    adapter->loadModel(model_path, device, user_config, false);
 
     std::string model_type;
     model_type = utils::get_from_any_maps("model_type", adapter->getModelConfig(), user_config, model_type);
@@ -191,7 +191,9 @@ Classification Classification::create_model(const std::string& model_path, const
         throw std::runtime_error("Incorrect or unsupported model_type, expected: Classification");
     }
     adapter->applyModelTransform(Classification::serialize);
-    adapter->compileModel("AUTO", user_config);
+    if (preload) {
+        adapter->compileModel(device, user_config);
+    }
 
     return Classification(adapter, user_config);
 }
diff --git a/src/cpp/src/tasks/detection.cpp b/src/cpp/src/tasks/detection.cpp
@@ -13,9 +13,9 @@
 #include "utils/nms.h"
 #include "utils/tensor.h"
 
-DetectionModel DetectionModel::create_model(const std::string& model_path, const ov::AnyMap& user_config) {
+DetectionModel DetectionModel::create_model(const std::string& model_path, const ov::AnyMap& user_config, bool preload, const std::string& device) {
     auto adapter = std::make_shared<OpenVINOInferenceAdapter>();
-    adapter->loadModel(model_path, "", user_config, false);
+    adapter->loadModel(model_path, device, user_config, false);
 
     std::string model_type;
     model_type = utils::get_from_any_maps("model_type", adapter->getModelConfig(), user_config, model_type);
@@ -25,7 +25,9 @@ DetectionModel DetectionModel::create_model(const std::string& model_path, const
         throw std::runtime_error("Incorrect or unsupported model_type, expected: ssd");
     }
     adapter->applyModelTransform(SSD::serialize);
-    adapter->compileModel("AUTO", user_config);
+    if (preload) {
+        adapter->compileModel(device, user_config);
+    }
 
     return DetectionModel(std::make_unique<SSD>(adapter), user_config);
 }
diff --git a/src/cpp/src/tasks/instance_segmentation.cpp b/src/cpp/src/tasks/instance_segmentation.cpp
@@ -190,9 +190,9 @@ void InstanceSegmentation::serialize(std::shared_ptr<ov::Model>& ov_model) {
     ov_model->set_rt_info(input_shape.height, "model_info", "orig_height");
 }
 
-InstanceSegmentation InstanceSegmentation::create_model(const std::string& model_path, const ov::AnyMap& user_config) {
+InstanceSegmentation InstanceSegmentation::create_model(const std::string& model_path, const ov::AnyMap& user_config, bool preload, const std::string& device) {
     auto adapter = std::make_shared<OpenVINOInferenceAdapter>();
-    adapter->loadModel(model_path, "", user_config, false);
+    adapter->loadModel(model_path, device, user_config, false);
 
     std::string model_type;
     model_type = utils::get_from_any_maps("model_type", user_config, adapter->getModelConfig(), model_type);
@@ -201,7 +201,9 @@ InstanceSegmentation InstanceSegmentation::create_model(const std::string& model
         throw std::runtime_error("Incorrect or unsupported model_type, expected: MaskRCNN");
     }
     adapter->applyModelTransform(InstanceSegmentation::serialize);
-    adapter->compileModel("AUTO", user_config);
+    if (preload) {
+        adapter->compileModel(device, user_config);
+    }
 
     return InstanceSegmentation(adapter, user_config);
 }
diff --git a/src/cpp/src/tasks/semantic_segmentation.cpp b/src/cpp/src/tasks/semantic_segmentation.cpp
@@ -20,9 +20,9 @@ cv::Mat get_activation_map(const cv::Mat& features) {
     return int_act_map;
 }
 
-SemanticSegmentation SemanticSegmentation::create_model(const std::string& model_path, const ov::AnyMap& user_config) {
+SemanticSegmentation SemanticSegmentation::create_model(const std::string& model_path, const ov::AnyMap& user_config, bool preload, const std::string& device) {
     auto adapter = std::make_shared<OpenVINOInferenceAdapter>();
-    adapter->loadModel(model_path, "", user_config, false);
+    adapter->loadModel(model_path, device, user_config, false);
 
     std::string model_type;
     model_type = utils::get_from_any_maps("model_type", user_config, adapter->getModelConfig(), model_type);
@@ -31,7 +31,9 @@ SemanticSegmentation SemanticSegmentation::create_model(const std::string& model
         throw std::runtime_error("Incorrect or unsupported model_type, expected: Segmentation");
     }
     adapter->applyModelTransform(SemanticSegmentation::serialize);
-    adapter->compileModel("AUTO", user_config);
+    if (preload) {
+        adapter->compileModel(device, user_config);
+    }
 
     return SemanticSegmentation(adapter, user_config);
 }
diff --git a/tests/cpp/CMakeLists.txt b/tests/cpp/CMakeLists.txt
@@ -20,6 +20,3 @@ find_package(OpenCV REQUIRED COMPONENTS imgcodecs)
 
 add_executable(test_accuracy test_accuracy.cpp)
 target_link_libraries(test_accuracy gtest_main nlohmann_json::nlohmann_json model_api ${OpenCV_LIBRARIES})
-
-#include(GoogleTest)
-#gtest_discover_tests(test_accuracy)
diff --git a/tests/cpp/precommit/CMakeLists.txt b/tests/cpp/precommit/CMakeLists.txt
@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.26)
+
+
+project(tests)
+
+add_subdirectory(../../../src/cpp ${tests_BINARY_DIR}/src/cpp)
+
+include(FetchContent)
+
+FetchContent_Declare(json GIT_REPOSITORY https://github.com/nlohmann/json.git
+                          GIT_TAG d41ca94fa85d5119852e2f7a3f94335cc7cb0486  # PR #4709, fixes cmake deprecation warnings
+                    )
+FetchContent_Declare(googletest
+    GIT_REPOSITORY https://github.com/google/googletest.git
+    GIT_TAG a7f443b80b105f940225332ed3c31f2790092f47  # latest main
+)
+FetchContent_MakeAvailable(json googletest)
+
+find_package(OpenCV REQUIRED COMPONENTS imgcodecs)
+
+add_executable(test_sanity test_sanity.cpp)
+target_link_libraries(test_sanity gtest_main nlohmann_json::nlohmann_json model_api ${OpenCV_LIBRARIES})
diff --git a/tests/cpp/precommit/test_sanity.cpp b/tests/cpp/precommit/test_sanity.cpp
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2020-2024 Intel Corporation
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <gtest/gtest.h>
+#include <tasks/classification.h>
+#include <tasks/detection.h>
+#include <tasks/results.h>
+#include <tasks/semantic_segmentation.h>
+#include <stddef.h>
+
+#include <cstdint>
+#include <exception>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <nlohmann/json.hpp>
+#include <opencv2/core.hpp>
+#include <stdexcept>
+#include <string>
+
+using json = nlohmann::json;
+
+std::string PUBLIC_SCOPE_PATH = "../../tests/cpp/precommit/public_scope.json";
+std::string DATA_DIR = "../data";
+std::string MODEL_PATH_TEMPLATE = "public/%s/FP16/%s.xml";
+std::string IMAGE_PATH = "coco128/images/train2017/000000000074.jpg";
+
+struct ModelData {
+    std::string name;
+    std::string type;
+};
+
+class ModelParameterizedTest : public testing::TestWithParam<ModelData> {};
+
+template <typename... Args>
+std::string string_format(const std::string& fmt, Args... args) {
+    size_t size = snprintf(nullptr, 0, fmt.c_str(), args...);
+    std::string buf;
+    buf.reserve(size + 1);
+    buf.resize(size);
+    snprintf(&buf[0], size + 1, fmt.c_str(), args...);
+    return buf;
+}
+
+inline void from_json(const nlohmann::json& j, ModelData& test) {
+    test.name = j.at("name").get<std::string>();
+    test.type = j.at("type").get<std::string>();
+}
+
+std::vector<ModelData> GetTestData(const std::string& path) {
+    std::ifstream input(path);
+    nlohmann::json j;
+    input >> j;
+    return j;
+}
+TEST_P(ModelParameterizedTest, SynchronousInference) {
+    cv::Mat image = cv::imread(DATA_DIR + "/" + IMAGE_PATH);
+    if (!image.data) {
+        throw std::runtime_error{"Failed to read the image"};
+    }
+
+    std::string model_path;
+    const std::string& name = GetParam().name;
+    if (name.substr(name.size() - 4) == ".xml") {
+        model_path = name;
+    } else {
+        model_path = string_format(MODEL_PATH_TEMPLATE, name.c_str(), name.c_str());
+    }
+
+    if ("DetectionModel" == GetParam().type) {
+        bool preload = true;
+        auto model = DetectionModel::create_model(DATA_DIR + "/" + model_path, {}, preload, "CPU");
+        auto result = model.infer(image);
+        EXPECT_GT(result.objects.size(), 0);
+    } else if ("ClassificationModel" == GetParam().type) {
+        bool preload = true;
+        auto model = Classification::create_model(DATA_DIR + "/" + model_path, {}, preload, "CPU");
+        auto result = model.infer(image);
+        ASSERT_GT(result.topLabels.size(), 0);
+        EXPECT_GT(result.topLabels.front().score, 0.0f);
+    } else if ("SegmentationModel" == GetParam().type) {
+        bool preload = true;
+        auto model = SemanticSegmentation::create_model(DATA_DIR + "/" + model_path, {}, preload, "CPU");
+        auto result = model.infer(image);
+        ASSERT_GT(model.getContours(result).size(), 0);
+    }
+}
+
+INSTANTIATE_TEST_SUITE_P(TestSanityPublic, ModelParameterizedTest, testing::ValuesIn(GetTestData(PUBLIC_SCOPE_PATH)));
+
+class InputParser {
+public:
+    InputParser(int& argc, char** argv) {
+        for (int i = 1; i < argc; ++i)
+            this->tokens.push_back(std::string(argv[i]));
+    }
+
+    const std::string& getCmdOption(const std::string& option) const {
+        std::vector<std::string>::const_iterator itr;
+        itr = std::find(this->tokens.begin(), this->tokens.end(), option);
+        if (itr != this->tokens.end() && ++itr != this->tokens.end()) {
+            return *itr;
+        }
+        static const std::string empty_string("");
+        return empty_string;
+    }
+
+    bool cmdOptionExists(const std::string& option) const {
+        return std::find(this->tokens.begin(), this->tokens.end(), option) != this->tokens.end();
+    }
+
+private:
+    std::vector<std::string> tokens;
+};
+
+void print_help(const char* program_name) {
+    std::cout << "Usage: " << program_name << " -p <path_to_public_scope.json> -d <path_to_data>" << std::endl;
+}
+
+int main(int argc, char** argv) {
+    InputParser input(argc, argv);
+
+    if (input.cmdOptionExists("-h")) {
+        print_help(argv[0]);
+        return 1;
+    }
+    const std::string& public_scope = input.getCmdOption("-p");
+    if (!public_scope.empty()) {
+        PUBLIC_SCOPE_PATH = public_scope;
+    } else {
+        print_help(argv[0]);
+        return 1;
+    }
+    const std::string& data_dir = input.getCmdOption("-d");
+    if (!data_dir.empty()) {
+        DATA_DIR = data_dir;
+    } else {
+        print_help(argv[0]);
+        return 1;
+    }
+
+    testing::InitGoogleTest(&argc, argv);
+
+    return RUN_ALL_TESTS();
+}

Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ class Anomaly {`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`static void serialize(std::shared_ptr<ov::Model>& ov_model);`
`43`		`- static Anomaly create_model(const std::string& model_path, const ov::AnyMap& user_config = {});`
	`43`	`+ static Anomaly create_model(const std::string& model_path, const ov::AnyMap& user_config = {}, bool preload = true, const std::string& device = "AUTO");`
`44`	`44`
`45`	`45`	`AnomalyResult infer(cv::Mat image);`
`46`	`46`	`std::vector<AnomalyResult> inferBatch(std::vector<cv::Mat> image);`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ class Classification {`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`static void serialize(std::shared_ptr<ov::Model>& ov_model);`
`61`		`- static Classification create_model(const std::string& model_path, const ov::AnyMap& user_config = {});`
	`61`	`+ static Classification create_model(const std::string& model_path, const ov::AnyMap& user_config = {}, bool preload = true, const std::string& device = "AUTO");`
`62`	`62`
`63`	`63`	`ClassificationResult infer(cv::Mat image);`
`64`	`64`	`std::vector<ClassificationResult> inferBatch(std::vector<cv::Mat> image);`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ class InstanceSegmentation {`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`static void serialize(std::shared_ptr<ov::Model>& ov_model);`
`40`		`- static InstanceSegmentation create_model(const std::string& model_path, const ov::AnyMap& user_config = {});`
	`40`	`+ static InstanceSegmentation create_model(const std::string& model_path, const ov::AnyMap& user_config = {}, bool preload = true, const std::string& device = "AUTO");`
`41`	`41`
`42`	`42`	`InstanceSegmentationResult infer(cv::Mat image);`
`43`	`43`	`std::vector<InstanceSegmentationResult> inferBatch(std::vector<cv::Mat> image);`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ class SemanticSegmentation {`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`static void serialize(std::shared_ptr<ov::Model>& ov_model);`
`37`		`- static SemanticSegmentation create_model(const std::string& model_path, const ov::AnyMap& user_config = {});`
	`37`	`+ static SemanticSegmentation create_model(const std::string& model_path, const ov::AnyMap& user_config = {}, bool preload = true, const std::string& device = "AUTO");`
`38`	`38`
`39`	`39`	`std::map<std::string, ov::Tensor> preprocess(cv::Mat);`
`40`	`40`	`SemanticSegmentationResult postprocess(InferenceResult& infResult);`
Original file line number	Diff line number	Diff line change
`@@ -51,9 +51,9 @@ void Anomaly::serialize(std::shared_ptr<ov::Model>& ov_model) {`
`51`	`51`	`ov_model->set_rt_info(input_shape[1], "model_info", "orig_height");`
`52`	`52`	`}`
`53`	`53`
`54`		`-Anomaly Anomaly::create_model(const std::string& model_path, const ov::AnyMap& user_config) {`
	`54`	`+Anomaly Anomaly::create_model(const std::string& model_path, const ov::AnyMap& user_config, bool preload, const std::string& device) {`
`55`	`55`	`auto adapter = std::make_shared<OpenVINOInferenceAdapter>();`
`56`		`- adapter->loadModel(model_path, "", user_config, false);`
	`56`	`+ adapter->loadModel(model_path, device, user_config, false);`
`57`	`57`
`58`	`58`	`std::string model_type;`
`59`	`59`	`model_type = utils::get_from_any_maps("model_type", adapter->getModelConfig(), user_config, model_type);`
`@@ -65,7 +65,9 @@ Anomaly Anomaly::create_model(const std::string& model_path, const ov::AnyMap& u`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`adapter->applyModelTransform(Anomaly::serialize);`
`68`		`- adapter->compileModel("AUTO", user_config);`
	`68`	`+ if (preload) {`
	`69`	`+ adapter->compileModel(device, user_config);`
	`70`	`+ }`
`69`	`71`
`70`	`72`	`return Anomaly(adapter, user_config);`
`71`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -180,9 +180,9 @@ void Classification::serialize(std::shared_ptr<ov::Model>& ov_model) {`
`180`	`180`	`ov_model->set_rt_info(input_shape[1], "model_info", "orig_height");`
`181`	`181`	`}`
`182`	`182`
`183`		`-Classification Classification::create_model(const std::string& model_path, const ov::AnyMap& user_config) {`
	`183`	`+Classification Classification::create_model(const std::string& model_path, const ov::AnyMap& user_config, bool preload, const std::string& device) {`
`184`	`184`	`auto adapter = std::make_shared<OpenVINOInferenceAdapter>();`
`185`		`- adapter->loadModel(model_path, "", user_config, false);`
	`185`	`+ adapter->loadModel(model_path, device, user_config, false);`
`186`	`186`
`187`	`187`	`std::string model_type;`
`188`	`188`	`model_type = utils::get_from_any_maps("model_type", adapter->getModelConfig(), user_config, model_type);`
`@@ -191,7 +191,9 @@ Classification Classification::create_model(const std::string& model_path, const`
`191`	`191`	`throw std::runtime_error("Incorrect or unsupported model_type, expected: Classification");`
`192`	`192`	`}`
`193`	`193`	`adapter->applyModelTransform(Classification::serialize);`
`194`		`- adapter->compileModel("AUTO", user_config);`
	`194`	`+ if (preload) {`
	`195`	`+ adapter->compileModel(device, user_config);`
	`196`	`+ }`
`195`	`197`
`196`	`198`	`return Classification(adapter, user_config);`
`197`	`199`	`}`
Original file line number	Diff line number	Diff line change
`@@ -190,9 +190,9 @@ void InstanceSegmentation::serialize(std::shared_ptr<ov::Model>& ov_model) {`
`190`	`190`	`ov_model->set_rt_info(input_shape.height, "model_info", "orig_height");`
`191`	`191`	`}`
`192`	`192`
`193`		`-InstanceSegmentation InstanceSegmentation::create_model(const std::string& model_path, const ov::AnyMap& user_config) {`
	`193`	`+InstanceSegmentation InstanceSegmentation::create_model(const std::string& model_path, const ov::AnyMap& user_config, bool preload, const std::string& device) {`
`194`	`194`	`auto adapter = std::make_shared<OpenVINOInferenceAdapter>();`
`195`		`- adapter->loadModel(model_path, "", user_config, false);`
	`195`	`+ adapter->loadModel(model_path, device, user_config, false);`
`196`	`196`
`197`	`197`	`std::string model_type;`
`198`	`198`	`model_type = utils::get_from_any_maps("model_type", user_config, adapter->getModelConfig(), model_type);`
`@@ -201,7 +201,9 @@ InstanceSegmentation InstanceSegmentation::create_model(const std::string& model`
`201`	`201`	`throw std::runtime_error("Incorrect or unsupported model_type, expected: MaskRCNN");`
`202`	`202`	`}`
`203`	`203`	`adapter->applyModelTransform(InstanceSegmentation::serialize);`
`204`		`- adapter->compileModel("AUTO", user_config);`
	`204`	`+ if (preload) {`
	`205`	`+ adapter->compileModel(device, user_config);`
	`206`	`+ }`
`205`	`207`
`206`	`208`	`return InstanceSegmentation(adapter, user_config);`
`207`	`209`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,9 +20,9 @@ cv::Mat get_activation_map(const cv::Mat& features) {`
`20`	`20`	`return int_act_map;`
`21`	`21`	`}`
`22`	`22`
`23`		`-SemanticSegmentation SemanticSegmentation::create_model(const std::string& model_path, const ov::AnyMap& user_config) {`
	`23`	`+SemanticSegmentation SemanticSegmentation::create_model(const std::string& model_path, const ov::AnyMap& user_config, bool preload, const std::string& device) {`
`24`	`24`	`auto adapter = std::make_shared<OpenVINOInferenceAdapter>();`
`25`		`- adapter->loadModel(model_path, "", user_config, false);`
	`25`	`+ adapter->loadModel(model_path, device, user_config, false);`
`26`	`26`
`27`	`27`	`std::string model_type;`
`28`	`28`	`model_type = utils::get_from_any_maps("model_type", user_config, adapter->getModelConfig(), model_type);`
`@@ -31,7 +31,9 @@ SemanticSegmentation SemanticSegmentation::create_model(const std::string& model`
`31`	`31`	`throw std::runtime_error("Incorrect or unsupported model_type, expected: Segmentation");`
`32`	`32`	`}`
`33`	`33`	`adapter->applyModelTransform(SemanticSegmentation::serialize);`
`34`		`- adapter->compileModel("AUTO", user_config);`
	`34`	`+ if (preload) {`
	`35`	`+ adapter->compileModel(device, user_config);`
	`36`	`+ }`
`35`	`37`
`36`	`38`	`return SemanticSegmentation(adapter, user_config);`
`37`	`39`	`}`