weixin_40725706

这个屌丝很懒，什么也没留下！

热门标签

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

作者：weixin_40725706 | 2024-04-18 19:41:16

踩

c# yolo

作者：英特尔创新大使颜国进

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

OpenVINO™ C# API项目链接：

https://github.com/guojin-yan/OpenVINO-CSharp-API.git

使用 OpenVINO™ C# API 部署 YOLOv9 全部源码：

https://github.com/guojin-yan/OpenVINO-CSharp-API-Samples/tree/master/model_samples/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

关于在不同平台上搭建 OpenVINO™ C# API 开发环境请参考以下文章：《在Windows上搭建OpenVINO™C#开发环境》、《在Linux上搭建OpenVINO™C#开发环境》、《在MacOS上搭建OpenVINO™C#开发环境》

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


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

关于在其他平台上搭建 OpenCvSharp 开发环境请参考以下文章：《【OpenCV】在Linux上使用OpenCvSharp》、《【OpenCV】在MacOS上使用OpenCvSharp》

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


<Project Sdk="Microsoft.NET.Sdk">
 
 
 
  <PropertyGroup>
 
    <OutputType>Exe</OutputType>
 
    <TargetFramework>net6.0</TargetFramework>
 
    <ImplicitUsings>enable</ImplicitUsings>
 
    <Nullable>enable</Nullable>
 
  </PropertyGroup>
 
 
 
  <ItemGroup>
 
    <PackageReference Include="OpenCvSharp4" Version="4.9.0.20240103" />
 
    <PackageReference Include="OpenCvSharp4.Extensions" Version="4.9.0.20240103" />
 
    <PackageReference Include="OpenCvSharp4.runtime.win" Version="4.9.0.20240103" />
 
    <PackageReference Include="OpenVINO.CSharp.API" Version="2024.0.0.1" />
 
    <PackageReference Include="OpenVINO.CSharp.API.Extensions.OpenCvSharp" Version="1.0.4" />
 
    <PackageReference Include="OpenVINO.runtime.win" Version="2024.0.0.1" />
 
  </ItemGroup>
 
 
 
</Project>

3.2 定义模型预测方法

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

初始化 OpenVINO Runtime Core
读取本地模型（将图片数据预处理方式编译到模型）
将模型编译到指定设备
创建推理通道
处理图像输入数据
设置推理输入数据
模型推理
获取推理结果
处理结果数据

1. 定义目标检测模型方法

按照 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<float>(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<float>(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<Rect> position_boxes = new List<Rect>();
 
    List<int> class_ids = new List<int>();
 
    List<float> confidences = new List<float>();
 
    // 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<float>(i, 0);
 
            float cy = result_data.At<float>(i, 1);
 
            float ow = result_data.At<float>(i, 2);
 
            float oh = result_data.At<float>(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);
 
}

2. 定义实例分割模型方法

实例分割模型部署流程与目标检测基本一致，主要不同点是模型结果的后处理方式，此处只展示了模型结果后处理代码，其他代码与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<float>((int)output_tensor_0.get_size());
 
    Tensor output_tensor_1 = infer_request.get_output_tensor(1);
 
    float[] result_proto = output_tensor_1.get_data<float>((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<Rect> position_boxes = new List<Rect>();
 
    List<int> class_ids = new List<int>();
 
    List<float> confidences = new List<float>();
 
    List<Mat> masks = new List<Mat>();
 
    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<float>(i, 0);
 
            float cy = detect_data.At<float>(i, 1);
 
            float ow = detect_data.At<float>(i, 2);
 
            float oh = detect_data.At<float>(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<float>(0, col, sigmoid(original_mask.At<float>(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<float>(r, c);
 
                if (pv > 0.5)
 
                {
 
                    actual_maskm.Set<float>(r, c, 1.0f);
 
                }
 
                else
 
                {
 
                    actual_maskm.Set<float>(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);
 
}

3. 使用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<int>(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 <model path> <image path> <device name>");
 
    }
 
    // -------- 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);
 
}

备注：

由于篇幅限制，上文中只展示了部分代码，想要获取全部源码，请访问项目GitHub自行下载：

使用OpenVINO™ C# API部署YOLOv9目标检测模型：

https://github.com/guojin-yan/OpenVINO-CSharp-API-Samples/blob/master/model_samples/yolov9/yolov9_det_opencvsharp/Program.cs

使用OpenVINO™ C# API部署YOLOv9实力分割模型：

https://github.com/guojin-yan/OpenVINO-CSharp-API-Samples/blob/master/model_samples/yolov9/yolov9_seg_opencvsharp/Program.cs

此外为了满足习惯使用EmguCV处理图像数据的开发者，此处我们也提供了EmguCV版本代码：

使用OpenVINO™ C# API部署YOLOv9目标检测模型：

https://github.com/guojin-yan/OpenVINO-CSharp-API-Samples/blob/master/model_samples/yolov9/yolov9_det_emgucv/Program.cs

使用OpenVINO™ C# API部署YOLOv9实力分割模型：

https://github.com/guojin-yan/OpenVINO-CSharp-API-Samples/blob/master/model_samples/yolov9/yolov9_seg_emgucv/Program.cs

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两种版本，供各位开发者使用。最后如果各位开发者在使用中有任何问题，欢迎大家与我联系。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/447885