IT评测·应用市场-qidao123.com

标题: 在 Intel Ultra AI PC 装备上使用 OpenVINO™ C# API本地部署YOLOv11与YOLO [打印本页]

作者: 农民    时间: 2025-3-2 17:32
标题: 在 Intel Ultra AI PC 装备上使用 OpenVINO™ C# API本地部署YOLOv11与YOLO
​    最新的英特尔® 酷睿™ Ultra 处理器(第二代)让我们能够在台式机、移动装备和边缘中实现大多数 AI 体验,将 AI 加速提升到新程度,在 AI 时代为边缘盘算提供动力。英特尔® 酷睿™ Ultra 处理器提供了一套全面的专为 AI 定制的集成盘算引擎,包括 CPU、GPU 和 NPU,提供高达 99 总平台 TOPS。近期,YOLO系列模型发布了YOLOv12, 对 YOLO 框架举行了全面增强,特别注意集成注意力机制,同时又不牺牲 YOLO 模型所期望的及时处理能力,是 YOLO 系列的一次进化,突破了人工视觉的极限。本文中,我们将使用英特尔® 酷睿™ Ultra 处理器AI PC装备,结合OpenVINO™ C# API 使用最新发布的OpenVINO™ 2025.0 部署YOLOv11 和 YOLOv12 目的检测模型,并在AIPC装备上,举行速度测试:
     OpenVINO™ C# API项目链接:
  1. https://github.com/guojin-yan/OpenVINO-CSharp-API.git
复制代码
     本文使用的项目源码链接为:
  1. https://github.com/guojin-yan/YoloDeployCsharp/blob/yolov1/demo/yolo_openvino_demo/
复制代码
1. 媒介

1.1 英特尔® 酷睿™ Ultra 处理器(第二代)

全新英特尔酷睿Ultra 200V系列处理器对比上代Meteor Lake,升级了模块化结构、封装工艺,采用全新性能核与能效核、英特尔硬件线程调理器、Xe2微架构锐炫GPU、第四代NPU…由此也带来了CPU性能提升18%,GPU性能提升30%,团体功耗降低50%,以及120TOPS平台AI算力。
酷睿Ultra 200V系列处理器共有9款SKU,包括1款酷睿Ultra 9、4款酷睿Ultra 7以及4款酷睿Ultra 5,全系8核心8线程(4个性能核与4个能效核),具体规格如下。

作为新一代旗舰,酷睿Ultra 9 288V性能核频率最高5.1GHz、能效核频率最高3.7GHz,拥有12MB三级缓存。GPU方面,集成锐炫140V显卡,拥有8个全新Xe2核心、8个光线追踪单位,频率最高2.05GHz,可以实现67TOPSAI算力。而NPU集成6个第四代神经盘算引擎,AI算力提升至48TOPS。

在当前项目测试,使用的是Intel® Core™ Ultra 9 288V装备,处理器信息如下表所示:
装备规格参数CPU名称Intel® Core™ Ultra 9 288V内核数8(4个性能核+4个低功耗高效内核)总线程数8最大睿频频率5.1 GHz缓存12 MB Intel® Smart Cache支持的人工智能软件框OpenVINO™, WindowsML, DirectML, ONNX RT, WebNNGPU名称Intel® Arc™ Graphics 140V显卡最大动态频率2.05 GHzGPU 峰值 TOPS(Int8)67  TOPS支持的人工智能软件框架OpenVINO™, WindowsML, DirectML, ONNX RT, WebGPU, WebNNNPU名称Intel® AI BoostNPU 峰值 TOPS(Int8)48  TOPS支持的人工智能软件框架OpenVINO™, WindowsML, DirectML, ONNX RT, WebNN1.2 OpenVINO™ C# API

     英特尔发行版 OpenVINO™ 工具套件基于 oneAPI 而开发,可以加速高性能盘算机视觉和深度学习视觉应用开发速度工具套件,实用于从边缘到云的各种英特尔平台上,帮助用户更快地将更准确的真实天下结果部署到生产系统中。通过简化的开发工作流程,OpenVINO™ 可赋能开发者在现实天下中部署高性能应用程序和算法。
      OpenVINO™ 2025.0版本在生成式AI和硬件支持方面实现了多项庞大突破。生成式AI推理速度大幅提升,特别是Whisper语音模型和图像修复技能的加速,让AI应用的及时性和效率得到显著改善。同时,新增支持Qwen 2.5和DeepSeek-R1等中文大模型,优化了长文本处理和7B模型的推理吞吐量。在硬件方面,新一代Intel Core Ultra和Xeon处理器带来了更强的FP16推理能力,同时OpenVINO还推出了全球首个支持torch.compile的NPU后端,提升了异构盘算能力。GPU优化和Windows Server原生支持也让硬件性能得到更大开释,边缘盘算范畴的优化使IoT装备能效大幅提高。
     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

PackageDescriptionLinkOpenVINO.CSharp.APIOpenVINO C# API core libraries
OpenVINO.CSharp.API.ExtensionsOpenVINO C# API core extensions libraries
OpenVINO.CSharp.API.Extensions.OpenCvSharpOpenVINO C# API core extensions libraries use OpenCvSharp
OpenVINO.CSharp.API.Extensions.EmguCVOpenVINO C# API core extensions libraries use EmguCV
Native Runtime Libraries

PackageDescriptionLinkOpenVINO.runtime.winNative bindings for Windows
OpenVINO.runtime.ubuntu.22-x86_64Native bindings for ubuntu.22-x86_64
OpenVINO.runtime.ubuntu.20-x86_64Native bindings for ubuntu.20-x86_64
OpenVINO.runtime.ubuntu.18-x86_64Native bindings for ubuntu.18-x86_64
OpenVINO.runtime.debian9-arm64Native bindings for debian9-arm64
OpenVINO.runtime.debian9-armhfNative bindings for debian9-armhf
OpenVINO.runtime.centos7-x86_64Native bindings for centos7-x86_64
OpenVINO.runtime.rhel8-x86_64Native bindings for rhel8-x86_64
OpenVINO.runtime.macos-x86_64Native bindings for macos-x86_64
OpenVINO.runtime.macos-arm64Native bindings for macos-arm64
1.3 YOLOv11与YOLOv12

   YOLO系列目的检测模型自2016年提出以来,始终以"及时检测"为核心优势,通过端到端架构和网格化猜测头脑,在目的检测范畴持续引领技能革新。从YOLOv1的7x7网格基础框架,到YOLOv8的骨干网络优化,再到YOLOv10的C3K2模块创新,该系列通过特征提取增强、后处理优化和盘算效率提升,不停突破速度与精度的平衡极限      。
YOLOv11特色由Ultralytics公司开发,通过改进CSPNet主干网络和颈部架构,实现参数精简与精度提升的双重突破。其核心创新在于:
YOLOv12的开发职员通过其最新模型在开创性版本中树立了盘算机视觉范畴的新标准。YOLOv12 以其无与伦比的速度、准确性和多功能性而闻名,是 YOLO 系列的一次进化,突破了人工视觉的极限。YOLOv12 对 YOLO 框架举行了全面增强,特别注意集成注意力机制,同时又不牺牲 YOLO 模型所期望的及时处理能力。
两代模型分别代表了YOLO系列在传统架构优化与新型注意力机制融合两个方向的最新突破,其中YOLOv12更开创性地将Transformer优势融入及时检测框架,标志着该系列进入"注意力增强"新阶段。
2. 模型获取

2.1 设置环境

     安装模型下载以及转换环境,此处使用Anaconda举行程序集管理,输入以下指令创建一个yolo环境:
  1. conda create -n yolo python=3.10
  2. conda activate yolo
  3. pip install ultralytics
复制代码

2.2 下载并转换ONNX模型

     首先导出目的辨认模型,此处以官方预训练模型为例,目前ultralytics已经集成了,依次输入以下指令即可:
  1. yolo export model=yolo11s.pt format=onnx
复制代码

目前OpenVINO™支持直接调用ONNX模型,因此此处只导出ONNX模型即可,如需要导出OpenVINO™格式的模型,可以参考OpenVINO™官方文档。
3. Yolo 项目设置

3.1 项目创建与环境设置

     在Windows平台开发者可以使用Visual Studio平台开发程序,但无法跨平台实现,为了实现跨平台,此处采用dotnet指令举行项目的创建和设置。
     首先使用dotnet创建一个测试项目,在终端中输入一下指令:
  1. dotnet new console --framework net8.0 --use-program-main -o yolo_sample
复制代码
     此处以Windows平台为例安装项目依赖,首先是安装OpenVINO™ C# API项目依赖,在命令行中输入以下指令即可:
  1. dotnet add package OpenVINO.CSharp.API
  2. dotnet add package OpenVINO.runtime.win
  3. dotnet add package OpenVINO.CSharp.API.Extensions
  4. dotnet add package OpenVINO.CSharp.API.Extensions.OpenCvSharp
复制代码
     关于在不同平台上搭建 OpenVINO™ C# API 开发环境请参考以下文章: 《在Windows上搭建OpenVINO™C#开发环境》《在Linux上搭建OpenVINO™C#开发环境》《在MacOS上搭建OpenVINO™C#开发环境》
接下来安装使用到的图像处理库 OpenCvSharp,在命令行中输入以下指令即可:
  1. dotnet add package OpenCvSharp4
  2. dotnet add package OpenCvSharp4.Extensions
  3. dotnet add package OpenCvSharp4.runtime.win
复制代码
     关于在其他平台上搭建 OpenCvSharp 开发环境请参考以下文章:《【OpenCV】在Linux上使用OpenCvSharp》《【OpenCV】在MacOS上使用OpenCvSharp》
添加完成项目依赖后,项目的设置文件如下所示:
  1. <Project Sdk="Microsoft.NET.Sdk">
  2.   <PropertyGroup>
  3.     <OutputType>Exe</OutputType>
  4.     <TargetFramework>net8.0</TargetFramework>
  5.     <ImplicitUsings>enable</ImplicitUsings>
  6.     <Nullable>enable</Nullable>
  7.   </PropertyGroup>
  8.   <ItemGroup>
  9.     <PackageReference Include="OpenCvSharp4" Version="4.10.0.20241108" />
  10.     <PackageReference Include="OpenCvSharp4.Extensions" Version="4.10.0.20241108" />
  11.     <PackageReference Include="OpenCvSharp4.runtime.win" Version="4.10.0.20241108" />
  12.     <PackageReference Include="OpenVINO.CSharp.API" Version="2025.0.0.1" />
  13.     <PackageReference Include="OpenVINO.runtime.win" Version="2025.0.0.1" />
  14.   </ItemGroup>
  15. </Project>
复制代码
3.2 界说模型猜测方法

     使用 OpenVINO™ C# API 部署模型主要包括以下几个步调:
     按照 OpenVINO™ C# API 部署深度学习模型的步调,编写YOLOv10模型部署流程,在之前的项目里,我们已经部署了YOLOv5~9等一系列模型,其部署流程是基本一致的,YOLOv10模型部署代码如下所示:
  1. internal class YoloDet
  2. {
  3.     public static void predict(string model_path, string image_path, string device)
  4.     {
  5.         DateTime start = DateTime.Now;
  6.         // -------- Step 1. Initialize OpenVINO Runtime Core --------
  7.         Core core = new Core();
  8.         DateTime end = DateTime.Now;
  9.         Console.WriteLine("1. Initialize OpenVINO Runtime Core success, time spend: " + (end - start).TotalMilliseconds + "ms.");
  10.         // -------- Step 2. Read inference model --------
  11.         start = DateTime.Now;
  12.         Model model = core.read_model(model_path);
  13.         end = DateTime.Now;
  14.         Console.WriteLine("2. Read inference model success, time spend: " + (end - start).TotalMilliseconds + "ms.");
  15.         // -------- Step 3. Loading a model to the device --------
  16.         start = DateTime.Now;
  17.         CompiledModel compiled_model = core.compile_model(model, device);
  18.         end = DateTime.Now;
  19.         Console.WriteLine("3. Loading a model to the device success, time spend:" + (end - start).TotalMilliseconds + "ms.");
  20.         // -------- Step 4. Create an infer request --------
  21.         start = DateTime.Now;
  22.         InferRequest infer_request = compiled_model.create_infer_request();
  23.         end = DateTime.Now;
  24.         Console.WriteLine("4. Create an infer request success, time spend:" + (end - start).TotalMilliseconds + "ms.");
  25.         // -------- Step 5. Process input images --------
  26.         start = DateTime.Now;
  27.         Mat image = new Mat(image_path); // Read image by opencvsharp
  28.         int max_image_length = image.Cols > image.Rows ? image.Cols : image.Rows;
  29.         Mat max_image = Mat.Zeros(new OpenCvSharp.Size(max_image_length, max_image_length), MatType.CV_8UC3);
  30.         Rect roi = new Rect(0, 0, image.Cols, image.Rows);
  31.         image.CopyTo(new Mat(max_image, roi));
  32.         float factor = (float)(max_image_length / 640.0);
  33.         end = DateTime.Now;
  34.         Console.WriteLine("5. Process input images success, time spend:" + (end - start).TotalMilliseconds + "ms.");
  35.         // -------- Step 6. Set up input data --------
  36.         start = DateTime.Now;
  37.         Tensor input_tensor = infer_request.get_input_tensor();
  38.         Shape input_shape = input_tensor.get_shape();
  39.         Mat input_mat = CvDnn.BlobFromImage(max_image, 1.0 / 255.0, new OpenCvSharp.Size(input_shape[2], input_shape[3]), new Scalar(), true, false);
  40.         float[] input_data = new float[input_shape[1] * input_shape[2] * input_shape[3]];
  41.         Marshal.Copy(input_mat.Ptr(0), input_data, 0, input_data.Length);
  42.         input_tensor.set_data<float>(input_data);
  43.         end = DateTime.Now;
  44.         Console.WriteLine("6. Set up input data success, time spend:" + (end - start).TotalMilliseconds + "ms.");
  45.         // -------- Step 7. Do inference synchronously --------
  46.         infer_request.infer();
  47.         start = DateTime.Now;
  48.         infer_request.infer();
  49.         end = DateTime.Now;
  50.         Console.WriteLine("7. Do inference synchronously success, time spend:" + (end - start).TotalMilliseconds + "ms.");
  51.         // -------- Step 8. Get infer result data --------
  52.         start = DateTime.Now;
  53.         Tensor output_tensor = infer_request.get_output_tensor();
  54.         int output_length = (int)output_tensor.get_size();
  55.         float[] output_data = output_tensor.get_data<float>(output_length);
  56.         end = DateTime.Now;
  57.         Console.WriteLine("8. Get infer result data success, time spend:" + (end - start).TotalMilliseconds + "ms.");
  58.         // -------- Step 9. Process reault  --------
  59.         start = DateTime.Now;
  60.         // Storage results list
  61.         List<Rect> position_boxes = new List<Rect>();
  62.         List<int> class_ids = new List<int>();
  63.         List<float> confidences = new List<float>();
  64.         // Preprocessing output results
  65.         for (int i = 0; i < 8400; i++)
  66.         {
  67.             for (int j = 4; j < 84; j++)
  68.             {
  69.                 float conf = output_data[8400 * j + i];
  70.                 int label = j - 4;
  71.                 if (conf > 0.2)
  72.                 {
  73.                     float cx = output_data[8400 * 0 + i];
  74.                     float cy = output_data[8400 * 1 + i];
  75.                     float ow = output_data[8400 * 2 + i];
  76.                     float oh = output_data[8400 * 3 + i];
  77.                     int x = (int)((cx - 0.5 * ow) * factor);
  78.                     int y = (int)((cy - 0.5 * oh) * factor);
  79.                     int width = (int)(ow * factor);
  80.                     int height = (int)(oh * factor);
  81.                     Rect box = new Rect(x, y, width, height);
  82.                     position_boxes.Add(box);
  83.                     class_ids.Add(label);
  84.                     confidences.Add(conf);
  85.                 }
  86.             }
  87.         }
  88.         // NMS non maximum suppression
  89.         int[] indexes = new int[position_boxes.Count];
  90.         CvDnn.NMSBoxes(position_boxes, confidences, 0.5f, 0.5f, out indexes);
  91.         end = DateTime.Now;
  92.         Console.WriteLine("9. Process reault  success, time spend:" + (end - start).TotalMilliseconds + "ms.");
  93.         for (int i = 0; i < indexes.Length; i++)
  94.         {
  95.             int index = indexes[i];
  96.             Cv2.Rectangle(image, position_boxes[index], new Scalar(0, 0, 255), 2, LineTypes.Link8);
  97.             Cv2.Rectangle(image, new OpenCvSharp.Point(position_boxes[index].TopLeft.X, position_boxes[index].TopLeft.Y + 30),
  98.                 new OpenCvSharp.Point(position_boxes[index].BottomRight.X, position_boxes[index].TopLeft.Y), new Scalar(0, 255, 255), -1);
  99.             Cv2.PutText(image, class_ids[index] + "-" + confidences[index].ToString("0.00"),
  100.                 new OpenCvSharp.Point(position_boxes[index].X, position_boxes[index].Y + 25),
  101.                 HersheyFonts.HersheySimplex, 0.8, new Scalar(0, 0, 0), 2);
  102.         }
  103.         string output_path = Path.Combine(Path.GetDirectoryName(Path.GetFullPath(image_path)),
  104.             Path.GetFileNameWithoutExtension(image_path) + "_result.jpg");
  105.         Cv2.ImWrite(output_path, image);
  106.         Console.WriteLine("The result save to " + output_path);
  107.         Cv2.ImShow("Result", image);
  108.         Cv2.WaitKey(0);
  109.     }
  110. }
复制代码
接下来就是在C#static void Main(string[] args)方法里调用该方法,调用代码如下所示:
  1. YoloDet.predict("E:/Model/Yolo/yolo11x.onnx", "./demo_2.jpg", "NPU");
  2. YoloDet.predict("E:/Model/Yolo/yolo12x.onnx", "./demo_2.jpg", "CPU");
复制代码
4. 项目运行与演示

4.1 项目编译和运行

     接下来输入项目编译指令举行项目编译,输入以下指令即可:
  1. dotnet build
复制代码
     接下来运行编译后的程序文件,在CMD中输入以下指令,运行编译后的项目文件:
  1. dotnet run --no-build
复制代码
4.2 模型推理效果

下面分别使用x格式的模型演示YOLOv11和YOLOv12模型运行结果:
首先是YOLOv11x模型推理效果,如下图所示

下面是YOLOv12x模型推理效果,如下图所示:

5. YOLO系列模型推理性能体现

下面四个表格通过对YOLOv8、YOLOv11和YOLOv12系列模型在Intel® Core™ Ultra 9 288V处理器上推理速度的对比分析,我们可以看到它们在CPU、NPU和GPU平台上的体现差异。下面将详细描述每个系列在不同硬件平台上的推理速度,并对比其性能。
表 1 YOLOv8全系模型在 Intel® Core™ Ultra 9 288V 处理器上推理速度
模型类型CPUNPUGPUYOLOv8n24.78 ms3.60 ms2.64 msYOLOv8s72.04 ms6.37 ms4.62 msYOLOv8m200.34 ms12.23 ms9.13 msYOLOv8l410.67 ms22.89 ms16.72 msYOLOv8x629.35 ms33.72 ms23.86 ms表1列出了YOLOv8全系模型的推理时间,在YOLOv8系列中,随着模型复杂度的增长,推理时间也随之增长。在CPU上,YOLOv8n(最小模型)需要24.78ms,YOLOv8x(最大模型)则达到629.35ms,推理时间大幅增长。在NPU上,YOLOv8n的推理时间为3.60ms,YOLOv8x则为33.72ms。GPU上,YOLOv8n的推理时间最短,仅为2.64ms,而YOLOv8x则为23.86ms。可以看出,YOLOv8系列在NPU和GPU加速下的体现非常精良,特别是YOLOv8n和YOLOv8s,它们在GPU上的推理时间仅为2.64ms和4.62ms,显示了YOLOv8系列在加速硬件上的高效性。
表 2  YOLOv11全系模型在 Intel® Core™ Ultra 9 288V 处理器上推理速度
模型类型CPUNPUGPUYOLOv11n19.90 ms3.97 ms2.55 msYOLOv11s56.56 ms6.15 ms4.53 msYOLOv11m184.46 ms15.20 ms8.87 msYOLOv11l228.37 ms18.20 ms11.62 msYOLOv11x499.18 ms38.50 ms20.40 ms表2先容了YOLOv11系列,YOLOv11系列的推理时间相较于YOLOv8系列较长,尤其是在CPU上。YOLOv11n在CPU上的推理时间为19.90ms,相比YOLOv8n的24.78ms稍快;但随着模型复杂度增长,YOLOv11x的CPU推理时间为499.18ms,依然长于YOLOv8x的629.35ms。NPU加速方面,YOLOv11n的推理时间为3.97ms,YOLOv11x为38.50ms,固然NPU加速显著提升了推理速度,但团体体现逊色于YOLOv8系列。GPU方面,YOLOv11n在GPU上为2.55ms,YOLOv11x为20.40ms,也体现得相对较慢。
表 3  YOLOv12全系模型在 Intel® Core™ Ultra 9 288V 处理器上推理速度
模型类型CPUNPUGPUYOLOv12n23.31 ms6.55 ms-YOLOv12s64.50 ms13.39 ms-YOLOv12m185.73 ms29.39 ms-YOLOv12l253.26 ms49.43 ms-YOLOv12x559.51 ms82.29 ms-YOLOv12系列的推理时间在所有系列中体现较慢,尤其是在CPU上。YOLOv12n的推理时间为23.31ms,相比YOLOv8n和YOLOv11n都略长,而YOLOv12x的推理时间为559.51ms,显着比其他系列的最大模型更慢。在NPU上,YOLOv12n的推理时间为6.55ms,YOLOv12x为82.29ms,固然在NPU加速下,推理速度有所提升,但相对其他系列仍然较慢。YOLOv12系列在推理速度方面的体现团体较为逊色,特别是在没有GPU加速的情况下。
从推理速度的团体体现来看,YOLOv8系列无疑是体现最好的。YOLOv8在NPU和GPU加速下的推理速度非常高效,尤其是在YOLOv8n和YOLOv8s这两个小型模型上,其推理时间显着优于YOLOv11和YOLOv12系列,且在GPU和NPU加速下依然保持较短的推理时间。相比之下,YOLOv11系列的体现略逊,固然NPU加速有助于提升推理速度,但团体推理时间仍然较长。YOLOv12系列则在推理时间上体现最差,尤其是在没有GPU加速的情况下,其推理时间远高于YOLOv8和YOLOv11系列。
6. 总结

    英特尔® 酷睿™ Ultra 处理器凭借其精彩的性能和高效的能耗管理,成为深度学习和盘算机视觉应用的理想选择。通过结合OpenVINO™工具套件和YOLOv11、YOLOv12等先辈模型,我们可以显著提升推理性能,并确保在不同平台上高效运行。本文先容了如何设置开发环境、使用C# API举行模型部署,以及如何利用处理器的优势优化应用程序性能。随着AI技能的不停发展,英特尔的硬件和软件工具将继续为开发者提供更强大的支持,推动人工智能在各个范畴的应用与创新。盼望通过本文的学习,读者能够在实际项目中灵活运用这些技能,实现更高效、更智能的解决方案。
   最后如果各位开发者在使用中有任何标题,欢迎各人与我联系。


免责声明:如果侵犯了您的权益,请联系站长,我们会及时删除侵权内容,谢谢合作!更多信息从访问主页:qidao123.com:ToB企服之家,中国第一个企服评测及商务社交产业平台。




欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/) Powered by Discuz! X3.4