OpenVINO™ C# API部署YOLOv9目标检测和实例分割模型

YOLOv9模型是YOLO系列实时目标检测算法中的最新版本，代表着该系列在准确性、速度和效率方面的又一次重大飞跃。它通过引入先进的深度学习技术和创新的架构设计，如通用ELAN（GELAN）和可编程梯度信息（PGI），显著提升了物体检测的性能。在本文中，我们将结合OpenVINO C# API使用最新发布的OpenVINO 2024.0部署YOLOv9目标检测和实例分割模型。

1. 前言

1.1

OpenVINO C# API

英特尔发行版 OpenVINO 工具套件基于 oneAPI 而开发，可以加快高性能计算机视觉和深度学习视觉应用开发速度工具套件，适用于从边缘到云的各种英特尔平台上，帮助用户更快地将更准确的真实世界结果部署到生产系统中。通过简化的开发工作流程，OpenVINO 可赋能开发者在现实世界中部署高性能应用程序和算法。

2024年3月7日，英特尔发布了开源OpenVINO 2024.0工具包，用于在各种硬件上优化和部署人工智能推理。OpenVINO是英特尔出色的开源AI工具包，不仅可以在x86_64 CPU上加速AI推断，还可以在ARM CPU和其他架构、英特尔集成显卡和独立显卡等硬件上加速AI推断，包括最近推出的NPU插件，用于利用新酷睿超 “Meteor Lake”系统芯片中的英特尔神经处理单元。OpenVINO 2024.0更注重生成式人工智能（GenAI），为TensorFlow句子编码模型提供了更好的开箱即用体验，支持专家混合（MoE）。同时还提高了LLM的INT4权重压缩质量，增强了LLM在英特尔CPU上的性能，简化了Hugging Face模型的优化和转换，并改进了其他Hugging Face集成。

OpenVINO C# API是一个OpenVINO的.Net wrapper，应用最新的OpenVINO库开发，通过OpenVINO C API实现.Net对OpenVINO Runtime调用，使用习惯与OpenVINO C++ API一致。OpenVINO C# API由于是基于OpenVINO开发，所支持的平台与OpenVINO完全一致，具体信息可以参考OpenVINO。通过使用OpenVINO C# API，可以在.NET、.NET Framework等框架下使用C#语言实现深度学习模型在指定平台推理加速。

下表为当前发布的OpenVINO C# API NuGet Package，支持多个目标平台，可以通过NuGet一键安装所有依赖。

Core Managed Libraries

Native Runtime Libraries

1.2

YOLOv9

YOLOv9模型是YOLO系列实时目标检测算法中的最新版本，代表着该系列在准确性、速度和效率方面的又一次重大飞跃。它通过引入先进的深度学习技术和创新的架构设计，如通用ELAN（GELAN）和可编程梯度信息（PGI），显著提升了物体检测的性能。

具体来说，YOLOv9解决了深度神经网络中信息丢失的问题，通过整合PGI和GELAN架构，不仅增强了模型的学习能力，还确保了在整个检测过程中保留关键信息。此外，它采用更深的网络结构以提取更丰富的特征，同时引入残差连接和跨层连接等机制以优化训练过程。为了提高模型的泛化能力并降低过拟合风险，YOLOv9还使用了正则化技术，如权重衰减和Dropout。

由于YOLOv9在模型架构、训练策略以及数据处理等方面的改进，它在COCO数据集上能够获得更高的AP值，显示出其在复杂和多样化场景下的卓越性能。此外，YOLOv9还注重实时性能，通过优化网络结构和计算效率，实现了在保持高性能的同时减少计算量和提高处理速度。这使得YOLOv9在实时目标检测任务中具有显著优势，能够满足各种应用场景的需求。

2. 模型获取

2.1

源码下载

YOLOv9模型可以通过源码进行下载，首先克隆GitHub上的源码，输入以下指令：

 

git clone https://github.com/WongKinYiu/yolov9.git
cd yolov9

 

2.2

配置环境

接下来安装模型下载以及转换环境，此处使用Anaconda进行程序集管理，输入以下指令创建一个yolov9环境：

 

conda create -n yolov9 python=3.10
conda activate yolov9

 

然后安装yolov9模型下载以及转换所必需的环境，输入以下指令：

 

pip install -r requirements.txt
pip install openvino==2024.0.0

 

2.3

下载模型

首先导出目标识别模型，此处以官方预训练模型为例，首先下载预训练模型文件，然后调用export.py文件导出ONBNX格式的模型文件，最后使用OpenVINO的模型转换命令将模型转为IR格式，依次输入以下指令即可：

 

wget https://github.com/WongKinYiu/yolov9/releases/download/v0.1/yolov9-c.p
python export.py --weights ./yolov9-c.pt --imgsz 640 --include onnx
ovc yolov9-c.onnx

 

同样的方式可以导出实例分割模型：

wget https://github.com/WongKinYiu/yolov9/releases/download/v0.1/gelan-c-seg.ptt
python export.py --weights ./gelan-c-seg.pt --imgsz 640 --include onnx
ovc gelan-c-seg.onnx

模型的结构如下图所示：

3. Yolov9项目配置

3.1

项目创建与环境配置

在Windows平台开发者可以使用Visual Studio平台开发程序，但无法跨平台实现，为了实现跨平台，此处采用dotnet指令进行项目的创建和配置。

首先使用dotnet创建一个测试项目，在终端中输入一下指令：

 

dotnet new console --framework net6.0 --use-program-main -o yolov9

 

此处以Windows平台为例安装项目依赖，首先是安装OpenVINO C# API项目依赖，在命令行中输入以下指令即可：

 

dotnet add package OpenVINO.CSharp.API
dotnet add package OpenVINO.runtime.win
dotnet add package OpenVINO.CSharp.API.Extensions
dotnet add package OpenVINO.CSharp.API.Extensions.OpenCvSharp

 

接下来安装使用到的图像处理库OpenCvSharp，在命令行中输入以下指令即可：

 

dotnet add package OpenCvSharp4
dotnet add package OpenCvSharp4.Extensions
dotnet add package OpenCvSharp4.runtime.win

 

添加完成项目依赖后，项目的配置文件如下所示：

 

  
    Exe
    net6.0
    enable
    enable
  
  
  
    
    
    
    
    
    
  
  

 

3.2

定义模型预测方法

使用OpenVINO C# API部署模型主要包括以下几个步骤：

初始化 OpenVINO Runtime Core

读取本地模型（将图片数据预处理方式编译到模型）

将模型编译到指定设备

创建推理通道

处理图像输入数据

设置推理输入数据

模型推理

获取推理结果

处理结果数据

01

定义目标检测模型方法

按照OpenVINO C# API部署深度学习模型的步骤，编写YOLOv9模型部署流程，在之前的项目里，我们已经部署了YOLOv5~8等一系列模型，其部署流程是基本一致的，YOLOv9模型部署代码如下所示：

 

static void yolov9_det(string model_path, string image_path, string device)
{
    // -------- Step 1. Initialize OpenVINO Runtime Core --------
    Core core = new Core();
    // -------- Step 2. Read inference model --------
    Model model = core.read_model(model_path);
    // -------- Step 3. Loading a model to the device --------
    CompiledModel compiled_model = core.compile_model(model, device);
    // -------- Step 4. Create an infer request --------
    InferRequest infer_request = compiled_model.create_infer_request();
    // -------- Step 5. Process input images --------
    Mat image = new Mat(image_path); // Read image by opencvsharp
    int max_image_length = image.Cols > image.Rows ? image.Cols : image.Rows;
    Mat max_image = Mat.Zeros(new OpenCvSharp.Size(max_image_length, max_image_length), MatType.CV_8UC3);
    Rect roi = new Rect(0, 0, image.Cols, image.Rows);
    image.CopyTo(new Mat(max_image, roi));
    float factor = (float)(max_image_length / 640.0);
    // -------- Step 6. Set up input data --------
    Tensor input_tensor = infer_request.get_input_tensor();
    Shape input_shape = input_tensor.get_shape();
    Mat input_mat = CvDnn.BlobFromImage(max_image, 1.0 / 255.0, new OpenCvSharp.Size(input_shape[2], input_shape[3]), 0, true, false);
    float[] input_data = new float[input_shape[1] * input_shape[2] * input_shape[3]];
    Marshal.Copy(input_mat.Ptr(0), input_data, 0, input_data.Length);
    input_tensor.set_data(input_data);
    // -------- Step 7. Do inference synchronously --------
    infer_request.infer();
    // -------- Step 8. Get infer result data --------
    start = DateTime.Now;
    Tensor output_tensor = new Tensor();
    if (model.get_outputs_size() > 1)
    {
        output_tensor = infer_request.get_output_tensor(1);
    }
    else
    {
        output_tensor = infer_request.get_output_tensor();
    }
    int output_length = (int)output_tensor.get_size();
    float[] output_data = output_tensor.get_data(output_length);
    // -------- Step 9. Process reault  --------
    Mat result_data = new Mat(84, 8400, MatType.CV_32F, output_data);
    result_data = result_data.T();
    // Storage results list
    List position_boxes = new List();
    List class_ids = new List();
    List confidences = new List();
    // Preprocessing output results
    for (int i = 0; i < result_data.Rows; i++)
    {
        Mat classes_scores = new Mat(result_data, new Rect(4, i, 80, 1));
        OpenCvSharp.Point max_classId_point, min_classId_point;
        double max_score, min_score;
        // Obtain the maximum value and its position in a set of data
        Cv2.MinMaxLoc(classes_scores, out min_score, out max_score,
            out min_classId_point, out max_classId_point);
        // Confidence level between 0 ~ 1
        // Obtain identification box information
        if (max_score > 0.25)
        {
            float cx = result_data.At(i, 0);
            float cy = result_data.At(i, 1);
            float ow = result_data.At(i, 2);
            float oh = result_data.At(i, 3);
            int x = (int)((cx - 0.5 * ow) * factor);
            int y = (int)((cy - 0.5 * oh) * factor);
            int width = (int)(ow * factor);
            int height = (int)(oh * factor);
            Rect box = new Rect();
            box.X = x;
            box.Y = y;
            box.Width = width;
            box.Height = height;


            position_boxes.Add(box);
            class_ids.Add(max_classId_point.X);
            confidences.Add((float)max_score);
        }
    }
    // NMS non maximum suppression
    int[] indexes = new int[position_boxes.Count];
    CvDnn.NMSBoxes(position_boxes, confidences, 0.5f, 0.5f, out indexes);
    for (int i = 0; i < indexes.Length; i++)
    {
        int index = indexes[i];
        Cv2.Rectangle(image, position_boxes[index], new Scalar(0, 0, 255), 2, LineTypes.Link8);
        Cv2.Rectangle(image, new OpenCvSharp.Point(position_boxes[index].TopLeft.X, position_boxes[index].TopLeft.Y + 30),
            new OpenCvSharp.Point(position_boxes[index].BottomRight.X, position_boxes[index].TopLeft.Y), new Scalar(0, 255, 255), -1);
        Cv2.PutText(image, class_ids[index] + "-" + confidences[index].ToString("0.00"),
            new OpenCvSharp.Point(position_boxes[index].X, position_boxes[index].Y + 25),
            HersheyFonts.HersheySimplex, 0.8, new Scalar(0, 0, 0), 2);
    }
    string output_path = Path.Combine(Path.GetDirectoryName(Path.GetFullPath(image_path)),
        Path.GetFileNameWithoutExtension(image_path) + "_result.jpg");
    Cv2.ImWrite(output_path, image);
    Slog.INFO("The result save to " + output_path);
    Cv2.ImShow("Result", image);
    Cv2.WaitKey(0);
}

 

02

定义实例分割模型方法

实例分割模型部署流程与目标检测基本一致，主要不同点是模型结果的后处理方式，此处只展示了模型结果后处理代码，其他代码与YOLOv9目标检测代码一致，YOLOv9实例分割模型部署代码如下所示：

 

static void yolov9_seg(string model_path, string image_path, string device)
{
    ... ...(代码与上文一致)
    // -------- Step 8. Get infer result data --------
    Tensor output_tensor_0 = infer_request.get_output_tensor(0);
    float[] result_detect = output_tensor_0.get_data((int)output_tensor_0.get_size());
    Tensor output_tensor_1 = infer_request.get_output_tensor(1);
    float[] result_proto = output_tensor_1.get_data((int)output_tensor_1.get_size());
    Mat detect_data = new Mat(116, 8400, MatType.CV_32FC1, result_detect);
    Mat proto_data = new Mat(32, 25600, MatType.CV_32F, result_proto);
    detect_data = detect_data.T();
    List position_boxes = new List();
    List class_ids = new List();
    List confidences = new List();
    List masks = new List();
    for (int i = 0; i < detect_data.Rows; i++)
    {
        Mat classes_scores = new Mat(detect_data, new Rect(4, i, 80, 1));//GetArray(i, 5, classes_scores);
        Point max_classId_point, min_classId_point;
        double max_score, min_score;
        Cv2.MinMaxLoc(classes_scores, out min_score, out max_score,
            out min_classId_point, out max_classId_point);
        if (max_score > 0.25)
        {
            Mat mask = new Mat(detect_data, new Rect(4 + 80, i, 32, 1));//detect_data.Row(i).ColRange(4 + categ_nums, categ_nums + 36);
            float cx = detect_data.At(i, 0);
            float cy = detect_data.At(i, 1);
            float ow = detect_data.At(i, 2);
            float oh = detect_data.At(i, 3);
            int x = (int)((cx - 0.5 * ow) * factor);
            int y = (int)((cy - 0.5 * oh) * factor);
            int width = (int)(ow * factor);
            int height = (int)(oh * factor);
            Rect box = new Rect();
            box.X = x;
            box.Y = y;
            box.Width = width;
            box.Height = height;
            position_boxes.Add(box);
            class_ids.Add(max_classId_point.X);
            confidences.Add((float)max_score);
            masks.Add(mask);
        }
    }
    int[] indexes = new int[position_boxes.Count];
    CvDnn.NMSBoxes(position_boxes, confidences, 0.5f, 0.5f, out indexes);
    SegResult result = new SegResult();
    Mat rgb_mask = Mat.Zeros(new Size((int)image.Size().Width, (int)image.Size().Height), MatType.CV_8UC3);
    Random rd = new Random(); // Generate Random Numbers
    for (int i = 0; i < indexes.Length; i++)
    {
        int index = indexes[i];
        // Division scope
        Rect box = position_boxes[index];
        int box_x1 = Math.Max(0, box.X);
        int box_y1 = Math.Max(0, box.Y);
        int box_x2 = Math.Max(0, box.BottomRight.X);
        int box_y2 = Math.Max(0, box.BottomRight.Y);
        // Segmentation results
        Mat original_mask = masks[index] * proto_data;
        for (int col = 0; col < original_mask.Cols; col++)
        {
            original_mask.Set(0, col, sigmoid(original_mask.At(0, col)));
        }
        // 1x25600 -> 160x160 Convert to original size
        Mat reshape_mask = original_mask.Reshape(1, 160);
        // Split size after scaling
        int mx1 = Math.Max(0, (int)((box_x1 / factor) * 0.25));
        int mx2 = Math.Min(160, (int)((box_x2 / factor) * 0.25));
        int my1 = Math.Max(0, (int)((box_y1 / factor) * 0.25));
        int my2 = Math.Min(160, (int)((box_y2 / factor) * 0.25));
        // Crop Split Region
        Mat mask_roi = new Mat(reshape_mask, new OpenCvSharp.Range(my1, my2), new OpenCvSharp.Range(mx1, mx2));
        // Convert the segmented area to the actual size of the image
        Mat actual_maskm = new Mat();
        Cv2.Resize(mask_roi, actual_maskm, new Size(box_x2 - box_x1, box_y2 - box_y1));
        // Binary segmentation region
        for (int r = 0; r < actual_maskm.Rows; r++)
        {
            for (int c = 0; c < actual_maskm.Cols; c++)
            {
                float pv = actual_maskm.At(r, c);
                if (pv > 0.5)
                {
                    actual_maskm.Set(r, c, 1.0f);
                }
                else
                {
                    actual_maskm.Set(r, c, 0.0f);
                }
            }
        }
        // 预测
        Mat bin_mask = new Mat();
        actual_maskm = actual_maskm * 200;
        actual_maskm.ConvertTo(bin_mask, MatType.CV_8UC1);
        if ((box_y1 + bin_mask.Rows) >= (int)image.Size().Height)
        {
            box_y2 = (int)image.Size().Height - 1;
        }
        if ((box_x1 + bin_mask.Cols) >= (int)image.Size().Width)
        {
            box_x2 = (int)image.Size().Width - 1;
        }
        // Obtain segmentation area
        Mat mask = Mat.Zeros(new Size((int)image.Size().Width, (int)image.Size().Height), MatType.CV_8UC1);
        bin_mask = new Mat(bin_mask, new OpenCvSharp.Range(0, box_y2 - box_y1), new OpenCvSharp.Range(0, box_x2 - box_x1));
        Rect roi1 = new Rect(box_x1, box_y1, box_x2 - box_x1, box_y2 - box_y1);
        bin_mask.CopyTo(new Mat(mask, roi1));
        // Color segmentation area
        Cv2.Add(rgb_mask, new Scalar(rd.Next(0, 255), rd.Next(0, 255), rd.Next(0, 255)), rgb_mask, mask);
        result.add(class_ids[index], confidences[index], position_boxes[index], rgb_mask.Clone());
    }
    Mat masked_img = new Mat();
    // Draw recognition results on the image
    for (int i = 0; i < result.count; i++)
    {
        Cv2.Rectangle(image, result.datas[i].box, new Scalar(0, 0, 255), 2, LineTypes.Link8);
        Cv2.Rectangle(image, new Point(result.datas[i].box.TopLeft.X, result.datas[i].box.TopLeft.Y + 30),
            new Point(result.datas[i].box.BottomRight.X, result.datas[i].box.TopLeft.Y), new Scalar(0, 255, 255), -1);
        Cv2.PutText(image, CocoOption.lables[result.datas[i].index] + "-" + result.datas[i].score.ToString("0.00"),
            new Point(result.datas[i].box.X, result.datas[i].box.Y + 25),
            HersheyFonts.HersheySimplex, 0.8, new Scalar(0, 0, 0), 2);
        Cv2.AddWeighted(image, 0.5, result.datas[i].mask, 0.5, 0, masked_img);
    }
    string output_path = Path.Combine(Path.GetDirectoryName(Path.GetFullPath(image_path)),
        Path.GetFileNameWithoutExtension(image_path) + "_result.jpg");
    Cv2.ImWrite(output_path, masked_img);
    Slog.INFO("The result save to " + output_path);
    Cv2.ImShow("Result", masked_img);
    Cv2.WaitKey(0);
}

 

03

使用OpenVINO预处理接口编译模型

OpenVINO提供了推理数据预处理接口，用户可以更具模型的输入数据预处理方式进行设置。在读取本地模型后，调用数据预处理接口，按照模型要求的数据预处理方式进行输入配置，然后再将配置好的预处理接口与模型编译到一起，这样便实现了将模型预处理与模型结合在一起，实现OpenVINO对于处理过程的加速。主要是现在代码如下所示：

 

static void yolov9_seg_with_process(string model_path, string image_path, string device)
{
    // -------- Step 1. Initialize OpenVINO Runtime Core --------
    Core core = new Core();
    // -------- Step 2. Read inference model --------
    Model model = core.read_model(model_path);
    OvExtensions.printf_model_info(model);
    PrePostProcessor processor = new PrePostProcessor(model);
    Tensor input_tensor_pro = new Tensor(new OvType(ElementType.U8), new Shape(1, 640, 640, 3));
    InputInfo input_info = processor.input(0);
    InputTensorInfo input_tensor_info = input_info.tensor();
    input_tensor_info.set_from(input_tensor_pro).set_layout(new Layout("NHWC")).set_color_format(ColorFormat.BGR);


    PreProcessSteps process_steps = input_info.preprocess();
    process_steps.convert_color(ColorFormat.RGB).resize(ResizeAlgorithm.RESIZE_LINEAR)
        .convert_element_type(new OvType(ElementType.F32)).scale(255.0f).convert_layout(new Layout("NCHW"));
    Model new_model = processor.build();
    // -------- Step 3. Loading a model to the device --------
    CompiledModel compiled_model = core.compile_model(new_model, device);
    // -------- Step 4. Create an infer request --------
    InferRequest infer_request = compiled_model.create_infer_request();
    // -------- Step 5. Process input images --------
    Mat image = new Mat(image_path); // Read image by opencvsharp
    int max_image_length = image.Cols > image.Rows ? image.Cols : image.Rows;
    Mat max_image = Mat.Zeros(new OpenCvSharp.Size(max_image_length, max_image_length), MatType.CV_8UC3);
    Rect roi = new Rect(0, 0, image.Cols, image.Rows);
    image.CopyTo(new Mat(max_image, roi));
    Cv2.Resize(max_image, max_image, new OpenCvSharp.Size(640, 640));
    float factor = (float)(max_image_length / 640.0);
    // -------- Step 6. Set up input data --------
    start = DateTime.Now;
    Tensor input_tensor = infer_request.get_input_tensor();
    Shape input_shape = input_tensor.get_shape();
    byte[] input_data = new byte[input_shape[1] * input_shape[2] * input_shape[3]];
    //max_image.GetArray(out input_data);
    Marshal.Copy(max_image.Ptr(0), input_data, 0, input_data.Length);
    IntPtr destination = input_tensor.data();
    Marshal.Copy(input_data, 0, destination, input_data.Length);
    // -------- Step 7. Do inference synchronously --------
  ... ...(后续与上文代码一致)
}

 

4. 模型预测方法调用

定义完模型推理接口后，便可以在主函数里进行调用。此处为了让大家更好的复现本文代码，提供了在线模型，用户只需要运行以下代码，便可以直接下载转换好的模型进行模型推理，无需再自行转换，主函数代码如下所示：

 

static void Main(string[] args)
{
    string model_path = "";
    string image_path = "";
    string device = "AUTO";
    if (args.Length == 0)
    {
        if (!Directory.Exists("./model"))
        {
            Directory.CreateDirectory("./model");
        }
        if (!File.Exists("./model/yolov9-c-converted.xml") && !File.Exists("./model/yolov9-c-converted.bin"))
        {
            if (!File.Exists("./model/yolov9-c-converted.tar"))
            {
                _ = Download.download_file_async("https://github.com/guojin-yan/OpenVINO-CSharp-API-Samples/releases/download/Model/yolov9-c-converted.tar",
                    "./model/yolov9-c-converted.tar").Result;
            }
            Download.unzip("./model/yolov9-c-converted.tar", "./model/");
        }
        if (!File.Exists("./model/test_det_01.jpg"))
        {
            _ = Download.download_file_async("https://github.com/guojin-yan/OpenVINO-CSharp-API-Samples/releases/download/Image/test_det_01.jpg",
                "./model/test_det_01.jpg").Result;
        }
        model_path = "./model/yolov9-c-converted.xml";
        image_path = "./model/test_det_01.jpg";
    }
    else if (args.Length >= 2)
    {
        model_path = args[0];
        image_path = args[1];
        device = args[2];
    }
    else
    {
        Console.WriteLine("Please enter the correct command parameters, for example:");
        Console.WriteLine("> 1. dotnet run");
        Console.WriteLine("> 2. dotnet run   ");
    }
    // -------- Get OpenVINO runtime version --------
    OpenVinoSharp.Version version = Ov.get_openvino_version();
    Slog.INFO("---- OpenVINO INFO----");
    Slog.INFO("Description : " + version.description);
    Slog.INFO("Build number: " + version.buildNumber);
    Slog.INFO("Predict model files: " + model_path);
    Slog.INFO("Predict image  files: " + image_path);
    Slog.INFO("Inference device: " + device);
    Slog.INFO("Start yolov9 model inference.");
    yolov9_det(model_path, image_path, device);
    yolov9_det_with_process(model_path, image_path, device);
}

 

5. 项目运行与演示

5.1

项目编译和运行

接下来输入项目编译指令进行项目编译，输入以下指令即可：

 

dotnet build

 

接下来运行编译后的程序文件，在CMD中输入以下指令，运行编译后的项目文件：

 

dotnet run --no-build

 

5.2

YOLOv9目标检测模型运行结果

下图为YOLOv9 目标检测模型运行输出信息，此处我们使用在线转换好的模型进行推理。，首先会下载指定模型以及推理数据到本地，这样避免了开发者在自己配置环境和下载模型；接下来是输出打印 OpenVINO 版本信息，此处我们使用NuGet安装的依赖项，已经是OpenVINO 2024.0最新版本；接下来就是打印相关的模型信息，并输出每个过程所消耗时间。

下图为使用YOLOv9目标检测模型推理结果：

5.3

YOLOv9实例分割模型运行结果

下图为YOLOv9实例分割模型运行输出信息，此处我们使用在线转换好的模型进行推理。首先会下载指定模型以及推理数据到本地，这样避免了开发者在自己配置环境和下载模型；接下来是输出打印OpenVINO版本信息，此处我们使用NuGet安装的依赖项，已经是OpenVINO 2024.0最新版本；接下来就是打印相关的模型信息，并输出每个过程所消耗时间。

下图为使用YOLOv9实例分割模型推理结果：

6. 总结

在该项目中，我们结合之前开发的OpenVINO C# API 项目部署YOLOv9模型，成功实现了对象目标检测与实例分割，并且根据不同开发者的使用习惯，同时提供了OpenCvSharp以及Emgu.CV两种版本，供各位开发者使用。


 

审核编辑：刘清