YOLOv5s部署实战：PyTorch转ONNX再到OpenVINO的CPU推理全流程

最近刚把一个 YOLOv5s 目标检测模型完整走了一遍部署链路：从 PyTorch 预训练权重转成 ONNX，再用 OpenVINO 变成推理加速模型，最后在 Windows 10 上用 Python 做实际推理测试。整个过程在 CPU 上完成，没有碰 GPU，效果却比直接跑 PyTorch 明显快，而且完全绕开了 PyTorch 在部署时那堆烦人的版本问题。

这篇就是把这次实操完整记录一下，包括每一步为什么要这么走、命令怎么写、模型导出的参数怎么选、ONNX 转 OpenVINO 时注意什么，以及我在 Win10 下的真实测试数据。如果你手头有一个训练好的 YOLOv5s 权重，想部署到只装了 CPU 的机器上，或者单纯想把 PyTorch 模型导出成更轻量的部署格式，这篇可以直接照抄。

1. 先看整条链路的思路：为什么是 PyTorch → ONNX → OpenVINO

1.1 为什么选 YOLOv5s 而不是更大的模型

YOLOv5 按深度和宽度分了 n / s / m / l / x 几个档位，s 属于“小模型”档，参数量大约只有 7.2M，模型体积在 FP32 下约 14MB。选它做 CPU 推理有两个直接原因：一是参数量小，CPU 推理时的计算压力可控；二是 YOLOv5s 在 COCO 上已经有成熟的预训练权重，开箱即有接近 mAP 37.2 的检测能力，很多工业场景（包装盒计数、人员闯禁区、区域入侵等）用 s 档已经完全够用。

如果你选 l 或 x 档位，模型的 mAP 确实更高，但 CPU 上的推理延迟会成倍上升，很多时候反而部署不下去。我的经验是：先用 s 档把整条链路跑通，确认精度满足需求再考虑是否换更大的模型，这个顺序最省时间。

1.2 为什么必须经过 ONNX 这道中间层

直接拿 PyTorch 的 .pt 文件喂给 OpenVINO 其实是走不通的，因为 OpenVINO 的模型解析器原生不认 PyTorch 的 torchscript。做模型转换时，业界最通用也最稳妥的中间格式就是 ONNX。

ONNX（Open Neural Network Exchange）本质是一个“模型交换协议”，它定义了一套统一的算子集合和计算图描述格式。把 PyTorch 模型导出成 ONNX 之后，模型的计算图结构、权重、算子类型都被封装成一个标准文件，接下来无论是转 OpenVINO、TensorRT、ONNX Runtime，还是别的推理框架，都是从这个标准文件出发。你可以把 ONNX 理解为“普通话”，PyTorch 是“方言”，OpenVINO 是另一种“方言”，先把方言翻译成普通话，再翻译成目标方言，远比两种方言直接互译可靠。

实际操作中我也验证过：从 .pt 直接想跳到 OpenVINO 常常因为某个算子的兼容性报错，而先转 ONNX 再转 IR 基本一次通过。因为 ONNX 已经帮忙做了一层算子的标准化处理。

1.3 OpenVINO 到底“加速”了什么

很多人以为 OpenVINO 是一个“魔法优化器”，放进去就变快。它真正的加速来自三个层面：

第一是算子融合。OpenVINO 在把 ONNX 转换成 IR（Intermediate Representation，中间表示）时，会做图优化，把可以合并的算子融合成一个高效的算子，常见的有各种 BatchNormalization 与卷积的融合、相邻 Reshape 合并、激活函数与卷积合并等。这减少了推理时的算子调度开销和内存读写次数。

第二是适配底层 CPU 指令集。OpenVINO 的 CPU 插件会尽量利用 CPU 支持的 SIMD 指令集，比如 AVX2、AVX-512，如果 CPU 支持 VNNI 指令，INT8 量化推理还能进一步加速。它还会根据不同的 CPU 微架构挑选最优的内核实现，这一点是手写优化的 C++ 模型代码都不一定做到的。

第三是内存管理优化。IR 模型中的内存规划、张量布局都是经过预调配的，运行时不走 Python 侧的张量创建销毁循环，减少了内存碎片和分配开销。

实测我后面的数据显示：同样一台 Win10 机器，OpenVINO 的 IR 模型比原始 PyTorch 在 CPU 上快了不少，而且部署后不再依赖 PyTorch 运行时，整个程序体积和依赖都干净很多。

2. 环境准备：Win10 + Python 的具体搭配

2.1 Python 版本与虚拟环境选择

这次我用的 Python 版本是 3.10，装在 Win10 64 位系统上。选 3.10 而不是最新版本的 Python 是因为：YOLOv5 官方仓库长期测试的 Python 范围是 3.8 至 3.11，OpenVINO 对 Python 3.10 的 wheel 包支持也非常成熟，两边交集最大。如果你用 3.12 或者 3.13，不是一定不行，但大概率会在某个依赖包编译环节多出一堆麻烦。

强烈建议新建一个虚拟环境，别直接装在系统 Python 里，不然各个项目的依赖互相打架非常痛苦。我用的命令很简单：

python -m venv yolo_ov yolo_ov\Scripts\activate

注意 Win10 下虚拟环境里 Python 的路径是yolo_ov\Scripts\python.exe，而不是 Linux 下的bin/python。装好环境后先升级一下 pip，避免后面装包时出现依赖解析问题。

2.2 安装 PyTorch：CPU 版就足够了

接下来装 PyTorch。因为这次任务是模型转换和推理，不涉及训练，所以不需要 GPU 版。CPU 版的 PyTorch 包体积小、安装快，也避免了解 CUDA 版本和 cuDNN 匹配的麻烦。YOLOv5 官方仓库的 requirements.txt 会给你装一个默认版本的 torch，但那个版本往往偏新，直接装官方最新也可以。我是这样装的：

pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu

用 CPU 版 torch 在后续运行export.py导出 ONNX 时完全没问题，因为导出走的是算子跟踪，不依赖 CUDA。如果你平时机器上有 N 卡而且已经装了 CUDA 版 PyTorch，也可以保留，不影响后续步骤，只是模型转换时设置device=cpu会更稳。

2.3 获取 YOLOv5 源码并安装依赖

YOLOv5 的官方仓库以源码方式使用最方便。直接在某个工作目录下克隆仓库，然后安装它的依赖：

git clone https://github.com/ultralytics/yolov5 cd yolov5 pip install -r requirements.txt

这里注意：requirements.txt里包含 opencv-python、pandas、matplotlib、numpy 等一堆包，会占用一些时间。如果网络条件不好，多等一会，别中途掐断，否则依赖不全后面导出模型时会冒出一堆找不到模块的报错。

依赖装完之后，顺手再确认我们要用的关键包是否齐全：

python -c "import torch, cv2, numpy, onnx; print('deps ok')"

如果这行没有报错，说明前面环境没问题。如果缺 onnx，需要单独补装pip install onnx。

注意：YOLOv5 仓库的版本更新比较快，不同 commit 的 export.py 输出细节略有差异。建议在克隆后固定到你测试过的版本，比如git checkout一个相对新的稳定 tag，避免后续接口变动导致命令行为不一致。

2.4 下载 yolov5s.pt 预训练权重

YOLOv5 官方有直接给好的 COCO 预训练权重，仓库里README提供了下载链接。yolov5s.pt的体积大约 14MB，直接下载到yolov5目录下即可。也可以在命令行里手动拉取：

cd yolov5 # 在 Python 里执行： # import torch # model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True)

但最省事的方法其实是从官方 Release 页面下载 .pt 文件，然后放到weights目录。如果你之后要拿自己的数据集重训，就用python train.py --weights yolov5s.pt的方式把预训练权重作为初始权重，效果会比随机初始化好很多。

2.5 安装 OpenVINO 并验证

OpenVINO 安装很简单，直接 pip 装官方发行版：

pip install openvino

装完后验证版本号：

python -c "from openvino import Core; print(Core().available_devices)"

这一行如果输出类似['CPU']，就代表安装成功且能看到 CPU 设备。这里提一句版本差异：OpenVINO 2023.3 之前的版本里，模型转换工具叫mo（Model Optimizer），2023.3 及之后改成了ovc。如果你的环境装的是老版本，后续转换命令可能有差异，建议先确认pip show openvino里的版本号。

我这次使用的是比较新的版本，所以用的命令是ovc。如果遇到mo命令找不到，说明新版已经废弃了旧入口，升级到新版用ovc正是标准操作。

3. 把 YOLOv5s 从 PyTorch 导出为 ONNX

3.1 使用 export.py 导出 ONNX

YOLOv5 仓库提供了现成的导出脚本export.py，支持导出多种格式：ONNX、TorchScript、TensorRT、OpenVINO 等。我们这次只导出 ONNX，命令如下：

python export.py --weights yolov5s.pt --include onnx --img-size 640 640 --batch-size 1

几个参数说明一下：

• --weights yolov5s.pt：指定输入的权重文件。
• --include onnx：指定导出的目标格式。这里只写 onnx，不写 openvino，因为我想手动用 ovc 转 IR，便于理解中间产物。
• --img-size 640 640：导出模型的输入尺寸。常见的是 640x640，如果想让模型跑得更快也可以改成 320 或 416，但精度会受影响。这个尺寸必须和你之后推理时的预处理尺寸保持一致。
• --batch-size 1：导出 Batch 为 1 的模型。大多数部署场景下都是单张图片推理，所以 Batch 1 最合适。如果你的场景确实需要批量推理，再改成更大的值，但 OpenVINO 推理时动态 Batch 的处理会复杂一些。

导出脚本跑完后，在yolov5目录下会多出一个yolov5s.onnx文件。这个文件就是 PyTorch 模型的 ONNX 表示。脚本可能会输出一些 UserWarning，不要慌，大多是运行时提示，只要最后出现类似Export complete的提示就说明成功了。

3.2 用 ONNX Runtime 先验证导出结果

拿到 ONNX 文件后，我强烈建议先用 ONNX Runtime 跑一次推理验证图结构是否正确。这样能提前把“模型本身的问题”和“OpenVINO 转换的问题”分开排查。

先装 onnxruntime：

pip install onnxruntime

然后用一个几行代码的小脚本做验证：

import onnxruntime as ort import numpy as np session = ort.InferenceSession("yolov5s.onnx", providers=["CPUExecutionProvider"]) input_name = session.get_inputs()[0].name output_name = session.get_outputs()[0].name print("input:", session.get_inputs()[0].name, session.get_inputs()[0].shape) print("output:", session.get_outputs()[0].name, session.get_outputs()[0].shape) # 构造随机输入 x = np.random.randn(1, 3, 640, 640).astype(np.float32) result = session.run([output_name], {input_name: x}) print("result shape:", result[0].shape)

如果输出结果是(1, 25200, 85)，说明 ONNX 图完全正常。对这个形状解释一下：YOLOv5 对 640x640 输入会生成 3 个不同尺度的检测头，分别是 80x80、40x40、20x20 的特征图，每个格子预测 3 个锚框，所以总输出行数为 (6400 + 1600 + 400) * 3 = 25200；每个检测行包含 5 个坐标/置信度字段（中心 x、中心 y、宽、高、目标置信度）和 80 个类别得分（COCO 80 类），共 85 列。

3.3 另一种更简单的导出方式：直接用 torch.hub

除了用export.py，YOLOv5 也支持直接从 hub 加载模型再转 ONNX：

import torch model = torch.hub.load("ultralytics/yolov5", "yolov5s", pretrained=True) model.model.eval() dummy_input = torch.randn(1, 3, 640, 640) torch.onnx.export(model.model, dummy_input, "yolov5s_hub.onnx", opset_version=12, input_names=["images"], output_names=["output"])

这种方式的优点是不需要下载整个仓库，缺点是无法利用export.py里关于锚框和输出格式的专门处理。我建议优先用仓库里的export.py，因为它对你的后续部署更友好。

导出完毕后，还有一个要点：OpenVINO 对 ONNX 的算子兼容性整体很好，但如果你自定义了特殊算子，那部分会报错。YOLOv5 全链路用的都是标准卷积、归一化、SiLU 等算子，所以转换不会有太大障碍。

4. OpenVINO 转换：ONNX 到 IR 模型

4.1 使用 ovc 转换命令

拿到yolov5s.onnx后，下一步就是用 OpenVINO 自带的模型转换工具把它转成 IR 格式。IR 文件是两个文件：一个.xml（模型结构）和一个.bin（模型权重），OpenVINO 推理时用这两个文件就能完全脱离 ONNX 和 PyTorch。

新版 OpenVINO 的转换命令：

ovc yolov5s.onnx --output_dir yolov5s_ir

执行成功后yolov5s_ir目录下出现yolov5s.xml和yolov5s.bin，代表转换完成。这里很多刚接触的人会疑惑：为什么 IR 有两个文件？你可以把.xml类比为电路的原理图，描述每个模块怎么连接；.bin类比为电路板上组件的具体参数值，两者合起来才能工作。

如果你的 OpenVINO 是 2023.3 之前的老版本，命令要改成：

mo --input_model yolov5s.onnx --output_dir yolov5s_ir

新版本里mo命令还保留了一个兼容入口，但会提示你使用ovc。我建议直接用ovc，参数更简洁，输出信息也更清晰。

4.2 转换为 FP16 模型：一个可选的性能优化

OpenVINO 在转换时支持把权重压缩成 FP16，这样可以进一步减少模型大小，也能带来一定的推理加速，尤其是在一些对内存带宽敏感的 CPU 上。转换方式：

ovc yolov5s.onnx --compress_fp16 --output_dir yolov5s_ir_fp16

FP16 模型精度损失很小，目标检测这种任务的输出结果基本看不出差异，但模型体积会直接从约 28MB 降到约 14MB。实测下来，部分 CPU 上 FP16 比 FP32 速度快，部分 CPU 上几乎没差别，建议两个版本都转出来，然后用 benchmark 工具对比一下再选。

提示：FP16 在 CPU 上并不是“一定更快”，它主要靠减少内存读写带宽来省时间，如果你的模型本来就是计算密集而不是访存密集，比值差异不会很大。不过多个选项总比没有强，特别是 INFERENCE 时结合 INT8 量化，收益更明显。

4.3 转换过程中发生了什么：从 ONNX 到 IR 的图优化

ovc并不是简单地把 ONNX 文件格式改个名，它内部做了不少事。首先解析 ONNX 的图结构，然后应用一组预定义的重写规则，比如 Constant Folding（常量子表达式折叠）、BatchNormalization 融合、Convolution 与激活函数的合并等等。这个中间过程中，模型计算图的规模通常会比原始 ONNX 更紧凑。

举个例子：YOLOv5 的模型里有大量 SiLU 激活函数，ONNX 中 SiLU 会被表示成一个 Sigmoid 乘以输入的组合算子，而 OpenVINO 内部有更高效的 SiLU 实现，在 IR 图优化阶段就直接替换成一个算子，推理时省了中间的操作数分配和调度开销。

转换完成后，如果你好奇 IR 内部长什么样，可以打开.xml文件直接看，里面是xml格式的节点描述。虽然很长，但刻意读一下开头部分，会发现模型的输入依然是[1, 3, 640, 640]，输出也保留了[1, 25200, 85]的布局，这意味着我们的后处理逻辑可以完全复用 ONNX 推理时的代码。

4.4 动态输入尺寸问题

建议导出 ONNX 时固定成640x640的静态尺寸，尽量避免动态尺寸。原因有两点：

第一，OpenVINO 在处理静态形状时，可以对内存布局提前做最优化，性能更稳定。第二，动态形状意味着每次推理时 OpenVINO 都要重新做输入 shape 适配，可能带来额外开销。如果你确实需要多尺寸推理，建议在导出 ONNX 时指定几种固定尺寸，而不是用动态维度。

5. 用 OpenVINO Runtime 做一次完整推理

5.1 模型加载与输入输出准备

OpenVINO 推理的核心 API 非常简单，首先加载模型：

import cv2 import numpy as np from openvino import Core core = Core() model = core.read_model("yolov5s_ir/yolov5s.xml") compiled_model = core.compile_model(model, "CPU") input_key = compiled_model.input(0) output_key = compiled_model.output(0)

Core.read_model读取 IR 模型，compile_model把模型编译到 CPU 设备上。这里compiled_model是一个可复用推理对象，真正的推理性能优化在compile_model这一步就完成了。

如果只想知道模型输入输出的形状，可以打印：

print(input_key.shape) # [1,3,640,640] print(output_key.shape) # [1,25200,85]

5.2 图像预处理：letterbox 是关键

YOLOv5 的预处理和很多分类模型不太一样，不是直接 resize 到 640x640，而是要先做 letterbox 操作：把原始图片等比缩放，然后填充灰色边框补成 640x640。这么做是为了避免直接拉伸造成目标形变，影响检测精度。

比如一张 1920x1080 的图片，等比缩放到高度 640，宽会变大到接近 1138，超出 640，所以只能把宽缩小到 640，然后上下填充灰边。

实际的 letterbox 代码：我参考了 YOLOv5 官方 utils 里的实现并做了精简：

def letterbox(img, new_shape=(640, 640), color=(114, 114, 114)): shape = img.shape[:2] # 原始 h, w r = min(new_shape[0] / shape[0], new_shape[1] / shape[1]) new_unpad = (int(round(shape[1] * r)), int(round(shape[0] * r))) dw = (new_shape[1] - new_unpad[0]) / 2 dh = (new_shape[0] - new_unpad[1]) / 2 top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1)) left, right = int(round(dw - 0.1)), int(round(dw + 0.1)) img = cv2.resize(img, new_unpad, interpolation=cv2.INTER_LINEAR) img = cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color) return img, r, left, top

预处理后半部分就是归一化和张量转置，注意 YOLOv5 的输入是 NCHW，需要在 HWC 图像通道转成 CHW，然后除以 255：

img = cv2.cvtColor(cv2.imread("test.jpg"), cv2.COLOR_BGR2RGB) img, ratio, left, top = letterbox(img, (640, 640)) blob = img.astype(np.float32) / 255.0 blob = np.transpose(blob, (2, 0, 1)) # HWC -> CHW blob = np.expand_dims(blob, 0).astype(np.float32)

注意这里用的是 RGB 顺序，YOLOv5 训练时就是用 RGB 数据做归一化的，读图后从 BGR 转到 RGB 是为了保持一致。预处理过程中的r、left、top三个参数必须记住，因为后面把检测框坐标映射回原图时要用到。

5.3 推理与后处理：25200 个预测框的解析

OpenVINO 推理本身只有一行：

result = compiled_model([blob])[output_key]

返回的result形状是(1, 25200, 85)。这个输出和 YOLOv5 官方输出的格式完全一致，所以后处理可以用官方代码里的 NMS 函数，也可以自己解析。基本的解析逻辑如下：

第一，要先从 85 列里分离出坐标信息（前 4 列）、目标置信度（第 5 列）和类别得分（后 80 列）。第二，用“目标置信度 * 类别得分的最大值”作为该检测框的最终得分，若低于阈值（比如 0.25）就过滤掉。第三，对剩下的框做类别置信度筛选，然后在每个类别内部做 NMS，抑制重叠框。

一个最省事的方法是用 OpenCV 内置的 NMS 函数：

boxes, scores, class_ids = [], [], [] for pred in result[0]: obj_conf = pred[4] cls_conf = pred[5:].max() score = obj_conf * cls_conf if score < 0.25: continue # 解码 xywh -> xyxy（注意是 letterbox 后的坐标） x, y, w, h = pred[:4] x1, y1 = x - w / 2, y - h / 2 x2, y2 = x + w / 2, y + h / 2 boxes.append([x1, y1, x2 - x1, y2 - y1]) scores.append(float(score)) class_ids.append(int(pred[5:].argmax())) indices = cv2.dnn.NMSBoxes(boxes, scores, score_threshold=0.25, nms_threshold=0.45)

注意cv2.dnn.NMSBoxes在不同 OpenCV 版本里返回格式略有不同。4.5.x 后返回的是二维数组，需要取indices.flatten()遍历。大家写代码时注意兼容。

NMS 结束后，把框的坐标除以r，再减去left和top，就还原回原图坐标：

x1 = (x1 - left) / r y1 = (y1 - top) / r x2 = (x2 - left) / r y2 = (y2 - top) / r

然后就可以用cv2.rectangle画框了。

5.4 完整推理脚本参考

把上面这些串起来，一个完整的脚本大概是这样的：

import cv2 import numpy as np from openvino import Core def letterbox(img, new_shape=(640, 640), color=(114, 114, 114)): shape = img.shape[:2] r = min(new_shape[0] / shape[0], new_shape[1] / shape[1]) new_unpad = (int(round(shape[1] * r)), int(round(shape[0] * r))) dw = (new_shape[1] - new_unpad[0]) / 2 dh = (new_shape[0] - new_unpad[1]) / 2 top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1)) left, right = int(round(dw - 0.1)), int(round(dw + 0.1)) img = cv2.resize(img, new_unpad, interpolation=cv2.INTER_LINEAR) img = cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color) return img, r, left, top def preprocess(image_path): img = cv2.cvtColor(cv2.imread(image_path), cv2.COLOR_BGR2RGB) img, r, left, top = letterbox(img, (640, 640)) blob = img.astype(np.float32) / 255.0 blob = np.transpose(blob, (2, 0, 1)) blob = np.expand_dims(blob, 0).astype(np.float32) return blob, img, r, left, top def postprocess(result, r, left, top, orig_shape, conf_thres=0.25, iou_thres=0.45): boxes, scores, class_ids = [], [], [] for pred in result[0]: obj_conf = pred[4] cls_conf = pred[5:].max() score = obj_conf * cls_conf if score < conf_thres: continue x, y, w, h = pred[:4] boxes.append([(x - w / 2 - left) / r, (y - h / 2 - top) / r, w / r, h / r]) scores.append(float(score)) class_ids.append(int(pred[5:].argmax())) indices = cv2.dnn.NMSBoxes(boxes, scores, conf_thres, iou_thres) results = [] if indices is not None: for i in indices.flatten(): x, y, w, h = boxes[i] x1, y1, x2, y2 = x, y, x + w, y + h results.append([class_ids[i], scores[i], x1, y1, x2, y2]) return results core = Core() compiled_model = core.compile_model(core.read_model("yolov5s_ir/yolov5s.xml"), "CPU") blob, _, r, left, top = preprocess("test.jpg") result = compiled_model([blob])[compiled_model.output(0)] detections = postprocess(result, r, left, top, cv2.imread("test.jpg").shape[:2]) for det in detections: cls_id, score, x1, y1, x2, y2 = det print(f"class {cls_id}, score {score:.3f}, box ({x1:.1f},{y1:.1f})-({x2:.1f},{y2:.1f})")

这段代码完全可以在你的项目里直接复用，只要把模型路径和图片路径改一下就行。类别名映射可以根据 YOLOv5 官方data/coco.yaml里的 80 个类别名对应上。

5.5 性能实测：PyTorch 与 OpenVINO 的对比

这里放一组我实测的参考数据。测试环境是 Windows 10（某台 i5 型号的 CPU，8 核，16GB 内存），输入尺寸 640x640，测试图是 1080p 的街景图，共跑 100 次取平均值：

这个表格只代表我这台机器的数据，不同 CPU 的表现会有差异，但可以明显看到：ONNX Runtime 本身已经能带来一些加速，OpenVINO 在 CPU 上的加速效果则更大，FP16 又有额外收益。

如果想知道你的 CPU 上 OpenVINO 的极限性能，不用写脚本，直接用它自带的 benchmark_app 工具：

benchmark_app -m yolov5s_ir/yolov5s.xml -d CPU -niter 200

这个工具会输出平均延迟、吞吐量、P95 延迟等数据，比手搓脚本测速更标准，推荐大家转完模型先用它看一轮结果。

6. 常见问题与排查经验

6.1 转换常见报错与解决办法

这一路下来，我积累了几个高频问题，整理成表格方便排查：

6.2 检测不到任何目标的排查顺序

模型能跑起来但什么都检测不到，这个问题最折磨人。我的排查顺序是：

第一，先用 ONNX Runtime 跑一遍原始 ONNX，如果 ONNX Runtime 也检测不出来，说明导出环节或预处理写错了；如果 ONNX Runtime 能检测出来，说明问题出在 OpenVINO 侧的参数或模型加载。第二，检查输入是否归一化到 0~1，很多 OpenVINO 转换后的模型对输入分布敏感，忘记除以 255 会导致置信度全部变得极低。第三，检查后处理里的类别索引是否对应正确，如果类别映射串了，可能看起来是“检测不到”，其实只是画到了错误标签上。

另外，别忘了检查置信度阈值。YOLOv5 预训练模型的默认阈值是 0.25，但如果你输入图片较小或者目标较远，实际分数可能会低于阈值，可以调低到 0.1 试试，确认有检测框后再逐步调高。

6.3 一个避坑经验：确认 CPU 负载策略

OpenVINO 默认推理时会尽量使用所有 CPU 核心，这在了一些共享机器上会造成整体卡顿。实际部署时可以通过参数限制线程数：

config = {"PERFORMANCE_HINT": "THROUGHPUT", "NUM_STREAMS": "2"} compiled_model = core.compile_model(model, "CPU", config)

或者直接用"NUM_STREAMS": "1"来限制单路推理，这会牺牲一点吞吐，但能保证其他进程的响应。我做部署时一般会先测THROUGHPUT、LATENCY、OVERRIDE三种配置，然后挑最符合当前业务场景的。

6.4 关于 OpenVINO INT8 量化的一个提示

如果你的部署环境对性能有更高要求，可以再尝试 INT8 量化。OpenVINO 提供了基于 IR 模型的量化工具，把 FP16/FP32 模型进一步量化为 INT8，通常能再带来 2~3 倍加速。但 INT8 量化需要一小组代表性的校准数据，而且 YOLOv5 的检测头部分对量化比较敏感，可能需要在某些层上跳过量化。

三步安排建议：先用 FP32 把流程跑通，再试 FP16 看无损收益，最后如果延迟还不达标，再上 INT8 量化结合精度验证。不要一开始就用 INT8，排查问题的复杂度会上升不少。

7. 最后再分享一点自己的实操体会

把整个链路完整跑一遍之后，我最大的感受是：模型部署这件事，真正花时间的不是在模型转换指令本身，而是在环境对齐和后续的预处理/后处理细节上。比如 letterbox 的参数、坐标还原、BGR 与 RGB 的顺序，任何一个细节错了，都会让你在一个看起来“已经成功转换”的模型上白白排查很久。

我个人在实际项目里的标准流程已经固化了：先导出 ONNX，再用 ONNX Runtime 验证一遍模型能输出预期 shape，然后转 IR 用 benchmark_app 测速，最后写推理脚本验证真实图片的检测效果。每一层都独立验证，有问题一眼就能定位到是哪一层出的错。

如果你在 Win10 上按这个流程走，大概率能一次成功。这个链路后面还能继续扩展：比如把 OpenVINO 集成到 C++ 服务里拿到更低延迟，或者用 OpenVINO 的 POT 工具做 INT8 量化，再比如对接摄像头做实时视频流检测，这些都是在同一个 IR 模型基础之上展开的。先把基础链路跑通，后面的路会越走越顺。