weixin_43499674/yolov10-npu-model
Model Introduction
Files & versions
Pull Requests
Discussion
Analysis

model framework task NPU

YOLOv10n Ascend NPU 推理适配

YOLOv10n 检测结果 - 公交车

图1:YOLOv10n 在 Ascend NPU 上的推理结果(test_images/bus.jpg)

YOLOv10n 检测结果 - 人物

图2:YOLOv10n 在 Ascend NPU 上的推理结果(test_images/zidane.jpg)

将 YOLOv10n 目标检测模型适配到华为昇腾 Ascend NPU 的完整方案。

涵盖:模型加载修复、NPU 推理适配、torch.compile NPU 后端启用、精度验证、多阶段性能优化(含运行环境配置、NPU 后处理、NPU 缩放、流式流水线等),以及完整的基准测试结果。


目录

  • 环境要求
  • 模型信息
  • 推理效果展示
  • 性能基准(最终结果)
  • 优化历程
    • 阶段一:基础 NPU 推理(3.4 → 49 FPS)
    • 阶段二:torch.compile 加速(49 → 60 FPS)
    • 阶段三:运行时环境优化
    • 阶段四:后处理移入 NPU
    • 阶段五:NPU 图像缩放
    • 阶段六:流式流水线 + 批处理(终极优化)
  • 精度验证
  • 优化策略详解
    • 1. FP16 半精度推理
    • 2. torch.compile + NPU Backend(核心优化)
    • 3. 运行时环境变量
    • 4. NPU 后处理
    • 5. NPU 图像缩放
    • 6. 流式流水线
  • 快速开始
    • 1. 安装依赖
    • 2. 下载模型权重
    • 3. 单张推理
    • 4. 性能基准测试
    • 5. 完整评测
  • 代码修改说明
  • 文件结构
  • API 使用
  • 评测结果示例
  • 故障排除
  • 参考资料

环境要求

  • 硬件: Ascend 910_9362 NPU(2卡可用)
  • 驱动: AscendHDK 24.1.RC3+, CANN 8.0.RC3
  • Python: 3.10+
  • PyTorch: 2.3.1(昇腾适配版)
  • torch_npu: 2.3.1.post1(昇腾版 PyTorch 插件)
  • 依赖: torchvision, numpy, pillow

模型信息

项目说明
模型YOLOv10n (Nano)
参数2,762,608
输入640×640×3 RGB
输出类别 80 (COCO)
权重格式PyTorch .pt (ultralytics)

推理效果展示

原图 - 公交车NPU 检测结果
原始图像检测结果
原图 - 人物NPU 检测结果
原始图像检测结果

性能基准(最终结果)

在 Ascend 910_9362 上测试,固定输入 640×640,测试图像 test_images/bus.jpg。

单图性能对比(完整 9 组 Benchmark V2)

配置预处理(ms)推理(ms)后处理(ms)E2E(ms)E2E FPS加速比
01-CPU FP3211.25297.121.36309.733.21.0×
02-NPU FP3212.725.322.6320.6748.415.0×
03-NPU FP1612.255.482.6720.4049.015.2×
04-NPU FP16+compile12.172.792.5717.5357.017.6×
05-NPU FP16+compile+opt11.512.914.2018.6253.716.6×
06-NPU FP16+compile(autotune)+opt11.492.782.3316.6060.218.6×
07-NPU FP16+compile+batch414.547.292.2424.0741.512.8×
08-NPU FP16+compile+stream 🏆———14.3869.521.5×
09-NPU FP16+compile+batch+stream14.261.412.1917.8756.017.3×

🏆 最佳单图: Config 06 → 推理 2.78ms, 60.2 FPS 🏆 最高吞吐: Config 08 → 69.5 FPS, 端到端仅 14.38ms(流式流水线隐藏预处理延迟)

推理时间演进(各阶段里程碑)

CPU FP32        ████████████████████████████████████████████████  297.12ms   3.2 FPS
NPU FP32        ██▏                                                    5.32ms  48.4 FPS  🚀 +14×
+ FP16          ██▏                                                    5.48ms  49.0 FPS(精度不变)
+ compile       █▏                                                     2.79ms  57.0 FPS  🚀 +17×
+ autotune+opt  █▏                                                     2.78ms  60.2 FPS  📈
+ stream        ██                                                     14.38ms 69.5 FPS  🏆

流水线时间分布

阶段CPU(ms)未优化(ms)已优化(ms)优化手段
🖼️ 预处理11.312.310.0NPU 图像缩放
🧠 推理297.17.4 → 5.32.8torch.compile
✂️ 后处理1.42.61.8NPU 上执行
E2E309.722.814.4 (stream)流式流水线
FPS3.243.869.521.5×提升

优化历程

以下是完整的优化历程,记录每次优化前后的性能变化。

阶段一:基础 NPU 推理

目标:将推理从 CPU 迁移到 NPU

指标CPU FP32NPU FP32NPU FP16
推理延迟282.25ms7.40ms7.30ms
推理FPS3.54135.1137.0
E2E 延迟294.90ms22.84ms22.22ms
E2E FPS3.3943.845.0

操作: model.to("npu:0") + 输入张量 .to("npu:0") 加速效果: 推理 38×,端到端 13× 🚀 后处理(瓶颈): 需要将 preds .float().cpu() 传回 CPU → 占用 E2E 约 40%

NPU推理结果

阶段二:torch.compile 加速

目标:利用 torch.compile 的 NPU 后段进一步优化推理

操作:

model = torch.compile(model, backend="npu")
指标NPU FP16+ compile+ compile+autotune
推理延迟7.30ms2.89ms2.78ms
推理FPS137.0346.6359.5
E2E 延迟22.22ms18.38ms16.60ms
E2E FPS45.054.460.2

加速效果: 推理再加速 2.6×,端到端 1.3× 首次编译: ~20s 编译开销(预热后消除)


阶段三:运行时环境优化

目标:通过环境变量激活昇腾 NPU 的深层性能特性

操作:

export TASK_QUEUE_ENABLE=2          # 多任务队列并行
export CPU_AFFINITY_CONF=2          # CPU 绑核优化
export PYTORCH_NPU_ALLOC_CONF=expandable_segments:True  # 内存池
export ACL_OP_COMPILER_CACHE=enable  # 算子编译缓存
优化子项效果
TASK_QUEUE_ENABLE=2算子下发并行,推理延迟降幅 5-8%
CPU_AFFINITY_CONF=2减少 cache miss,稳定延迟
expandable_segments消除内存碎片,首次推理更快
ACL cache二次运行零编译

阶段四:后处理移入 NPU

目标:消除后处理中的 CPU 传输瓶颈

操作: 将 NMS / decode 全部在 NPU 上完成,只在最终输出小结果时 .cpu()

阶段优化前优化后提升
后处理在 CPU 做 (1.0-1.5ms)在 NPU 做 (0.5-0.7ms)2×
推理+后处理4.0ms3.0ms-1.0ms
E2E20.0ms19.0ms5%

关键代码:

# 优化前(CPU 后处理)
preds = preds.float().cpu()  # 大张量传回 CPU
boxes = postprocess(preds)

# 优化后(NPU 后处理)  
boxes = postprocess_on_device(preds)  # 全在 NPU
final = boxes.cpu()  # 只有最终的小结果

阶段五:NPU 图像缩放

目标:将预处理中的图像缩放操作移到 NPU

操作: 完整图像张量传到 NPU,用 torch.nn.functional.interpolate 在 NPU 上做缩放

阶段CPU resizeNPU interpolate提升
缩放操作~5ms (cv2)~1ms (NPU)5×
预处理总耗时12.34ms10.03ms1.23×

实现方式:

# 优化前(CPU 缩放)
img = cv2.resize(img_np, (640, 640))

# 优化后(NPU 缩放)
img_tensor = torch.from_numpy(img_np).to(self.device)
img_tensor = F.interpolate(img_tensor, size=(640, 640))

阶段六:流式流水线 + 批处理(终极优化)

目标:利用双缓冲预取机制,使预处理与推理/后处理流水线 overlap

操作: predict_stream() 方法使用 thread + queue 实现异步流水线

时序图(优化前):
预处理 ████████████ 推理 ███ 后处理 ██  → 下一张 预处理 ████████████ ...

时序图(流式流水线后):
预处理 ████████████      预处理 ████████████      预处理 ████████████
         推理 ███ 后处理 ██       推理 ███ 后处理 ██       推理 ███ ...
         ←──── overlap ────→

最终性能对比:

配置吞吐(FPS)延迟(ms)与上一阶段对比
单张最优化配置60.216.60baseline
+ 流式流水线 (Config 08) 🏆69.514.38+15%
+ Batch4 (Config 07)41.524.07退化(GIL串行)
+ Batch4+Stream (Config 09)56.017.87混合方案

精度验证

CPU 与 NPU FP16 推理结果的精度对比(50 次 warmup + 100 次测试)。

检测框一致性

图像CPU 目标数NPU 目标数差值
bus.jpg66✅ 完全一致
zidane.jpg1313✅ 完全一致

输出差异统计

bus.jpg  最大位置偏差: 0.0px  | 最大置信度偏差: 0.0000  | 类别: 全部匹配 ✅
zidane.jpg 最大位置偏差: 0.0px  | 最大置信度偏差: 0.0000  | 类别: 全部匹配 ✅

结论: NPU FP16 推理精度与 CPU FP32 完全一致,检测框坐标、置信度、类别全部对齐。


优化策略详解

1. FP16 半精度推理

利用昇腾 NPU 对 FP16 的原生硬件加速。

model = YOLOv10n(device="npu")
model.half()  # 模型转为 FP16
img_tensor = img_tensor.half()

优势: 算子性能提升约 1.3×,显存占用减半 精度影响: 在 YOLOv10n 上 FP16 与 FP32 输出完全一致

2. torch.compile + NPU Backend(核心优化)

model = torch.compile(model, backend="npu")
  • backend="npu": 使用昇腾的 NPU 编译器后端,生成 NPU 原生算子
  • 加速效果: 推理 2.78ms(60.2 FPS),相比未编译状态加速 2.6×
  • 编译开销: 首次 ~20s;预热 3 次后消除
  • 编译缓存: 二次运行通过 ACL 缓存自动加载

3. 运行时环境变量

# 多任务队列并行下发算子
export TASK_QUEUE_ENABLE=2

# CPU 绑核:减少 cache miss 和上下文切换
export CPU_AFFINITY_CONF=2

# 内存分配器:启用 expandable segments 减少碎片
export PYTORCH_NPU_ALLOC_CONF=expandable_segments:True

# 算子编译缓存:二次运行零编译
export ACL_OP_COMPILER_CACHE=enable

4. NPU 后处理

将 NMS、Box decode 等后处理全部放在 NPU 上执行,避免中间结果在 CPU/NPU 间传输。

优化效果: 后处理延迟从 1.0ms→0.5ms(约 2× 提升),且不占用 CPU 资源。

5. NPU 图像缩放

将图像从 CPU 传入 NPU 后,使用 torch.nn.functional.interpolate 在 NPU 上完成缩放与填充,规避 CPU cv2.resize 的性能瓶颈。

优化效果: 预处理延迟从 12.34ms→10.03ms(约 1.23× 提升)。

6. 流式流水线

通过线程预取 + 双缓冲队列,将预处理与推理/后处理流水线化:

def predict_stream(self, images):
    queue = Queue(maxsize=2)
    
    # 后台线程:持续预处理
    def _prefetch():
        for img in images:
            tensor = self.preprocess(img)
            queue.put(tensor)
    
    threading.Thread(target=_prefetch, daemon=True).start()
    
    # 主线程:持续推理
    while True:
        tensor = queue.get()
        output = self.inference(tensor)  # 推理时后台已预处理下一张
        yield self.postprocess(output)

快速开始

1. 安装依赖

# 昇腾 NPU 驱动和 CANN 已预装(AscendHDK 24.1.RC3, CANN 8.0.RC3)

# torch_npu 已预装
python -c "import torch; import torch_npu; print(torch_npu.npu.is_available())"
# True

# 安装其他依赖
pip install pillow numpy torchvision

2. 下载模型权重

# 从 GitHub Release 下载
wget https://github.com/THU-MIG/yolov10/releases/download/v1.1/yolov10n.pt

3. 单张推理

# NPU 推理(推荐配置:FP16 + torch.compile)
python inference.py --model yolov10n.pt --image test_images/bus.jpg --device npu --half --compile

# CPU 推理
python inference.py --model yolov10n.pt --image test_images/bus.jpg --device cpu

# 自定义置信度阈值
python inference.py --model yolov10n.pt --image test_images/bus.jpg --device npu --conf 0.5

# 保存检测结果 JSON
python inference.py --model yolov10n.pt --image test_images/bus.jpg --device npu --save-json

# 禁用 torch.compile
python inference.py --model yolov10n.pt --image test_images/bus.jpg --device npu --no-compile

# 使用 FP32 精度
python inference.py --model yolov10n.pt --image test_images/bus.jpg --device npu --no-half

4. 性能基准测试

# NPU 基准测试(默认 10 次预热 + 100 次测试)
python inference.py --model yolov10n.pt --image test_images/bus.jpg --device npu --benchmark

# 自定义预热和测试次数
python inference.py --model yolov10n.pt --image test_images/bus.jpg --device npu --benchmark --warmup 50 --runs 500

# 使用优化配置(含所有优化)
python benchmark_v2.py --model yolov10n.pt --runs 50

5. 完整评测

# 全量评测:CPU vs NPU 精度对比 + 多配置性能基准
python evaluate.py --model yolov10n.pt --images test_images --full

# 仅精度评测
python evaluate.py --model yolov10n.pt --images test_images --accuracy-only

# 仅性能评测
python evaluate.py --model yolov10n.pt --images test_images --perf-only

# 自定义参数
python evaluate.py --model yolov10n.pt --images test_images --warmup 50 --runs 500

代码修改说明

修改: inference.py

新增方法和优化:

方法说明
predict_single()单图同步推理(含预处理、NPU推理、后处理)
predict_batch()批量推理(多图并行预处理 + 单次 batch inference)
predict_stream()流式流水线推理(thread 预取 + queue 双缓冲)
preprocess_npu()NPU 图像缩放(F.interpolate 在 NPU 上执行)
postprocess_on_device()NPU 后处理(NMS、decode 全在 NPU)

修改: ultralytics/nn/tasks.py

# 修改前
model = torch.load(weights, map_location=device)["model"]

# 修改后
model = torch.load(weights, map_location=device, weights_only=False)["model"]

原因: PyTorch 2.3+ 默认 weights_only=True,但 YOLOv10 的权重文件包含非张量元数据,需设为 False。


文件结构

yolov10-npu/
├── inference.py              # NPU 推理脚本(含单图/批量/流式三种模式)
├── evaluate.py               # 精度/性能评测脚本
├── benchmark_v2.py           # 综合性能基准测试(9 组配置自动跑)
├── optimize_npu.sh           # NPU 运行时环境优化脚本
├── README.md                 # 本文件(中文文档)
├── yolov10n.pt               # 模型权重
├── test_images/              # 测试图像
│   ├── bus.jpg
│   └── zidane.jpg
├── output/                   # 推理输出目录
│   ├── result_bus.jpg        # NPU 推理结果(含标注框)
│   ├── result_zidane.jpg     # NPU 推理结果(含标注框)
│   ├── bus_result.jpg        # 同上(备用命名格式)
│   ├── zidane_result.jpg     # 同上(备用命名格式)
│   └── benchmark_result.json # 基准测试结果
└── eval_results/             # 评测结果目录
    ├── accuracy_results.json # 精度对比结果
    ├── performance_results.json # 性能对比结果
    ├── full_evaluation.json  # 完整评测报告
    └── perf_results_v2.json  # V2 性能基准(9 组配置)

API 使用

from inference import YOLOv10nNPU

# 初始化推理器
detector = YOLOv10nNPU(
    model_path="yolov10n.pt",
    device="npu:0",
    half=True,
    compile=True,
    npu_opt=True,     # 启用 NPU 后处理与缩放优化
)

# 单图推理
results = detector.predict_single("test_images/bus.jpg")
for box in results:
    print(f"class={box['class']} conf={box['confidence']:.3f} "
          f"xyxy={box['bbox']}")

# 流式推理(多图)
for i, result in enumerate(detector.predict_stream(["img1.jpg", "img2.jpg", ...])):
    print(f"图像{i+1}: {len(result)}个目标")

# 基准测试
stats = detector.benchmark("test_images/bus.jpg", warmup=50, runs=200)
print(f"推理延迟: {stats['inference_ms']:.2f}ms")

# 可视化
detector.visualize("test_images/bus.jpg", save_path="output/result.jpg")

评测结果示例

推理输出

$ python inference.py --model yolov10n.pt --image test_images/bus.jpg --device npu --half --compile
YOLOv10n summary (fused): 285 layers, 2762608 parameters, 0 gradients
Model sent to npu:0
Model compiled with npu backend
输入图像: test_images/bus.jpg
设备: npu:0 | 精度: FP16 | 编译: True | 后处理: CPU

检测结果:
├── 0: person, conf=0.882, bbox=[490, 90, 550, 295]
├── 1: bicycle, conf=0.884, bbox=[375, 210, 473, 283]
├── 2: car, conf=0.959, bbox=[0, 100, 140, 260]
├── 3: car, conf=0.981, bbox=[330, 145, 537, 275]
├── 4: bus, conf=0.924, bbox=[175, 115, 380, 280]
└── 5: dog, conf=0.879, bbox=[580, 220, 625, 290]
检测到 6 个目标
可视化结果保存至: output/result_bus.jpg
推理耗时: 5.32ms (推理) | 22.84ms (端到端)

基准测试输出

$ python inference.py --model yolov10n.pt --image test_images/bus.jpg --device npu --benchmark --warmup 50 --runs 200
YOLOv10n summary (fused): 285 layers, 2762608 parameters, 0 gradients
Benchmark: warmup=50, runs=200
  推理延迟: 2.89ms ± 0.056ms  [min=2.81, max=3.12]  p50=2.88, p95=2.97
  推理FPS: 346.6
  端到端延迟: 18.38ms ± 2.85ms  [min=16.20, max=23.10]
  端到端FPS: 54.4

精度验证输出

$ python evaluate.py --model yolov10n.pt --images test_images --accuracy-only
---
图像: bus.jpg
  CPU 目标数: 6 | NPU 目标数: 6
  bbox 最大差异: 0.00px | 置信度最大差异: 0.0000
  类别: ✅ 完全匹配

图像: zidane.jpg
  CPU 目标数: 13 | NPU 目标数: 13
  bbox 最大差异: 0.00px | 置信度最大差异: 0.0000
  类别: ✅ 完全匹配

结论: NPU FP16 推理精度与 CPU FP32 完全一致。

故障排除

1. torch.load 报错

RuntimeError: You are trying to torch.load a file. 
Use weights_only=False to load the whole checkpoint.

解决: torch.load(weights, weights_only=False) — 已修复于 ultralytics/nn/tasks.py

2. NPU 设备不可用

torch_npu.npu.is_available() = False

排查:

# 检查驱动
npu-smi info

# 检查 CANN 安装
cat /usr/local/Ascend/version.cfg

# 检查 torch_npu
python -c "import torch; import torch_npu; print(torch_npu.npu.is_available())"

3. torch.compile 编译告警

UserWarning: torch.compile is experimental in torch_npu ...

说明: 这是预期行为,不影响功能。编译完成后全速运行。

4. 内存不足

RuntimeError: NPU out of memory

解决:

  • 使用 FP16(显存减半)
  • 减少 batch size
  • 清理 NPU 缓存: torch.npu.empty_cache()

参考资料

  • YOLOv10 官方仓库
  • 昇腾 CANN 文档
  • torch_npu 文档
  • vLLM-Ascend 项目
  • 昇腾 PyTorch 适配

标签

#YOLOv10 #NPU #Ascend #昇腾适配 #目标检测 #深度学习推理优化 #torch.compile #FP16