【深度学习】YOLO 模型部署全攻略（本地 / 嵌入式 / 移动端）

本文主要内容为YOLO 模型在本地、嵌入式、移动端三大主流平台的部署方案，核心是根据不同平台的硬件特性、性能需求，选择适配的模型格式、推理框架和优化策略（以 YOLOv8 为例，v5 通用，兼顾部署效率与精度平衡）。

核心部署逻辑

不同平台的硬件算力、存储资源、实时性要求差异显著，部署需遵循 "平台适配优先、轻量化先行、精度损失可控（≤3%）" 的原则，核心流程如下：

一、本地部署（桌面 / 服务器，最高优先级，最易落地）

本地部署主要针对Windows/Linux 桌面端、云服务器 / 本地服务器 ，硬件通常具备较强算力（Intel/AMD 多核 CPU、NVIDIA 中高端 GPU），核心需求是平衡速度与精度、部署流程简单、易于调试。

1. 核心部署方案（按优先级排序）

方案 1：Ultralytics 原生部署（最简单，快速验证，推荐入门）

YOLOv8 官方提供的ultralytics库支持一键推理，无需额外转换模型格式，适合快速验证模型效果、非生产环境部署。

适用场景：快速测试、桌面端演示、非实时性批量推理
硬件要求：CPU（≥4 核）、GPU（NVIDIA ≥6G 显存，可选）

实操步骤 ：

安装依赖（已安装可跳过）：
python 复制代码
```
pip install ultralytics opencv-python
```

一键推理（命令行 / Python 代码）：

命令行（快速便捷）：

python 复制代码

# CPU推理
yolo detect predict model=runs/detect/train/weights/best.pt source=test.jpg save=True
# GPU推理（指定device=0，需安装CUDA/cuDNN）
yolo detect predict model=runs/detect/train/weights/best.pt source=test.jpg device=0 save=True

Python 代码（便于二次开发）：

python 复制代码

from ultralytics import YOLO

# 加载模型
model = YOLO("runs/detect/train/weights/best.pt")
# 推理（CPU/GPU自动适配，有GPU优先使用GPU）
results = model.predict(
    source="test.jpg",  # 输入源（图片/视频/文件夹）
    imgsz=640,          # 输入尺寸
    conf=0.3,           # 置信度阈值
    iou=0.45,           # NMS IoU阈值
    save=True           # 保存预测结果
)

部署效果：GPU（RTX 3060）FPS≈60-100，CPU（i7-12700H）FPS≈10-20，精度无损失，部署成本为 0。

方案 2：ONNX + ONNX Runtime 部署（平衡速度 / 易用性，推荐生产环境）

将.pt模型转换为 ONNX 格式，使用 ONNX Runtime 推理，速度较原生部署提升 20%-30%，支持跨平台（Windows/Linux/macOS），适合生产环境桌面端 / 服务器部署。

适用场景：生产环境桌面端、通用服务器、批量推理
硬件要求：CPU（≥4 核）、GPU（NVIDIA ≥6G 显存，可选）

实操步骤 ：

导出 ONNX 模型：

python 复制代码

# 导出FP32格式（精度无损失），支持GPU/CPU
yolo export model=best.pt format=onnx imgsz=640
# 导出FP16格式（速度更快，精度损失≤1%），仅支持GPU
yolo export model=best.pt format=onnx imgsz=640 half=True device=0

安装 ONNX Runtime 依赖：

python 复制代码

# CPU版本
pip install onnxruntime opencv-python
# GPU版本（需安装CUDA 11.6+）
pip install onnxruntime-gpu opencv-python

ONNX Runtime 推理代码：

python 复制代码

import cv2
import onnxruntime as ort
import numpy as np

# 1. 预处理（YOLOv8要求）
def preprocess(img_path, imgsz=640):
    img = cv2.imread(img_path)
    h, w, c = img.shape
    # 缩放至输入尺寸，保持长宽比，填充黑边
    scale = min(imgsz/w, imgsz/h)
    new_w, new_h = int(w*scale), int(h*scale)
    resized_img = cv2.resize(img, (new_w, new_h), interpolation=cv2.INTER_LINEAR)
    # 构建输入图片（黑边填充）
    input_img = np.zeros((imgsz, imgsz, 3), dtype=np.uint8)
    input_img[:new_h, :new_w, :] = resized_img
    # 转换格式：BGR→RGB，HWC→CHW，归一化到[0,1]，添加批次维度
    input_img = cv2.cvtColor(input_img, cv2.COLOR_BGR2RGB)
    input_img = input_img.transpose(2, 0, 1).astype(np.float32) / 255.0
    input_img = np.expand_dims(input_img, axis=0)
    return input_img, img, scale, (new_w, new_h)

# 2. 加载ONNX模型并推理
onnx_path = "best.onnx"
sess = ort.InferenceSession(onnx_path, providers=["CUDAExecutionProvider", "CPUExecutionProvider"])
input_name = sess.get_inputs()[0].name

# 3. 推理与后处理
input_img, raw_img, scale, (new_w, new_h) = preprocess("test.jpg")
outputs = sess.run(None, {input_name: input_img})

# 4. 解析结果（简化版，完整解析可参考ultralytics官方代码）
print("推理完成，输出结果形状：", outputs[0].shape)

部署效果：GPU（RTX 3060）FPS≈80-130，CPU（i7-12700H）FPS≈15-30，精度损失≤1%（FP16）。

方案 3：TensorRT 部署（NVIDIA GPU 极致提速，推荐高性能服务器）

将模型转换为 TensorRT 引擎（.engine格式），最大化 NVIDIA GPU 算力，速度较 ONNX 提升 50%-100%，适合对实时性要求高的服务器部署（如实时监控、视频分析）。

适用场景：高性能 NVIDIA GPU 服务器、实时视频分析、低延迟推理
硬件要求：NVIDIA GPU（≥6G 显存，支持 TensorRT，如 RTX 30 系列 / 40 系列、Tesla T4/V100）

实操步骤 ：

安装 TensorRT（需对应 CUDA 版本，参考 NVIDIA 官方文档）

导出 TensorRT 引擎：

python 复制代码

# 直接导出.engine格式（YOLOv8一键支持）
yolo export model=best.pt format=engine imgsz=640 device=0 half=True

TensorRT 推理（基于ultralytics封装，简化开发）：

python 复制代码

from ultralytics import YOLO

# 加载TensorRT引擎模型
model = YOLO("best.engine")
# GPU推理（极致速度）
results = model.predict(
    source="test.mp4",  # 视频输入，支持实时流
    imgsz=640,
    conf=0.3,
    device=0,
    stream=True  # 开启流式推理，降低延迟
)

# 遍历流式结果
for result in results:
    boxes = result.boxes
    print("检测框：", boxes.xyxy)

部署效果：GPU（RTX 3060）FPS≈150-200，GPU（Tesla T4）FPS≈200-300，精度损失≤2%（FP16/INT8）。

2. 本地部署核心优化与避坑

GPU 优先：有 NVIDIA GPU 时，优先选择 ONNX Runtime GPU/ TensorRT，速度提升显著；
格式选择 ：快速测试用.pt，生产环境 CPU 用 ONNX，GPU 用 TensorRT；
批量推理 ：批量处理图片 / 视频帧时，设置batch=16/32，提升推理效率；
避坑：导出 ONNX/TensorRT 时，确保imgsz为 32 的倍数，否则会导致推理错误。

二、嵌入式部署（Jetson / 树莓派，边缘计算核心）

嵌入式部署主要针对NVIDIA Jetson 系列（Nano/Xavier/Orin）、树莓派、嵌入式 Linux 开发板 ，硬件算力有限、存储资源紧张，核心需求是轻量化模型、低功耗、满足边缘实时性（≥15FPS）。

1. 主流嵌入式平台部署方案

平台 1：NVIDIA Jetson 系列（推荐，算力较强，易部署）

Jetson 系列（Nano/Xavier NX/Orin NX）内置 CUDA/TensorRT 支持，适配 YOLO 模型，是边缘计算的首选，核心采用 "YOLOv8n + TensorRT INT8" 部署方案。

适用场景：边缘实时监控、机器人视觉、智能安防
硬件要求：Jetson Nano（4G 显存）、Jetson Xavier NX（8G 显存）、Jetson Orin NX（16G 显存）

实操步骤 ：

准备环境：刷入 JetPack 系统（自带 CUDA/TensorRT/OpenCV）

模型轻量化：选择 YOLOv8n，导出 TensorRT INT8 引擎（节省显存，提升速度）：

python 复制代码

# Jetson Nano/Xavier 一键导出INT8 TensorRT引擎
yolo export model=yolov8n.pt format=engine imgsz=480 device=0 int8=True data=data.yaml

推理部署（与服务器 TensorRT 部署一致，简化代码）：

python 复制代码

from ultralytics import YOLO

# 加载轻量化TensorRT引擎
model = YOLO("yolov8n.engine")
# 边缘实时推理（低功耗模式）
results = model.predict(
    source=0,  # 外接摄像头
    imgsz=480,
    conf=0.3,
    device=0,
    save=False  # 关闭保存，降低存储占用
)

部署效果 ：
- Jetson Nano：FPS≈15-20（YOLOv8n + INT8），精度损失≤3%，功耗≤5W；
- Jetson Xavier NX：FPS≈50-80（YOLOv8n + INT8），精度损失≤3%，功耗≤10W。

平台 2：树莓派（低成本，算力有限，入门级）

树莓派（4B/5B）算力较弱（ARM CPU / 集成显卡），无 CUDA 支持，核心采用 "YOLOv8n + OpenVINO + INT8" 部署方案。

适用场景：低成本边缘演示、简单视觉检测、非实时性场景
硬件要求：树莓派 4B（8G 内存）、树莓派 5B（8G 内存）、外接摄像头 / USB 摄像头

实操步骤 ：

准备环境：安装 Raspberry Pi OS，安装 OpenVINO：
python 复制代码
```
pip install openvino-dev ultralytics opencv-python
```
模型转换：导出 OpenVINO 格式（INT8 量化，降低计算量）：
python 复制代码
```
yolo export model=yolov8n.pt format=openvino imgsz=480 int8=True data=data.yaml
```

OpenVINO 推理（适配 ARM CPU，开启多线程）：

python 复制代码

from openvino.runtime import Core
import cv2
import numpy as np

# 加载OpenVINO模型
core = Core()
model = core.read_model("yolov8n_openvino_model.xml")
compiled_model = core.compile_model(model, "CPU")  # 适配树莓派ARM CPU
input_layer = compiled_model.input(0)

# 摄像头实时推理（开启多线程，提升速度）
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    # 预处理（与ONNX一致，简化版）
    input_img = cv2.resize(frame, (480, 480))
    input_img = cv2.cvtColor(input_img, cv2.COLOR_BGR2RGB)
    input_img = input_img.transpose(2, 0, 1).astype(np.float32) / 255.0
    input_img = np.expand_dims(input_img, axis=0)

    # 推理（多线程加速）
    results = compiled_model([input_img])

    # 显示帧（简化版）
    cv2.imshow("Raspberry Pi YOLO Detection", frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

部署效果：树莓派 5B（8G）：FPS≈10-15（YOLOv8n + INT8），精度损失≤3%，功耗≤3W。

2. 嵌入式部署核心优化与避坑

模型极致轻量化：优先选择 YOLOv8n，输入尺寸调整为 480/320（32 的倍数），降低计算量；
INT8 量化必开：嵌入式平台存储 / 算力有限，INT8 量化可减少 75% 模型体积，提升 50% 以上速度；
低功耗优化 ：Jetson 系列开启jetson_clocks（性能模式）或nvpmodel（低功耗模式），平衡速度与功耗；
避坑：树莓派无 CUDA 支持，避免使用 TensorRT 格式，优先选择 OpenVINO/TFLite。

三、移动端部署（Android/iOS，端侧智能核心）

移动端部署主要针对Android（手机 / 平板）、iOS（iPhone/iPad） ，硬件为 ARM 架构 CPU/GPU、神经网络处理器（NPU），核心需求是超轻量化模型、低延迟、低功耗、适配移动端生态。

1. Android 部署（主流，开源生态完善，推荐）

Android 部署核心采用 "YOLOv8n + TFLite INT8 + NNAPI" 方案，利用 TFLite 适配移动端，NNAPI 调用设备 NPU/GPU 加速，支持离线推理。

适用场景：手机 APP 视觉检测、移动端智能扫码、端侧隐私保护（数据不上云）
硬件要求：Android 8.0+，支持 NNAPI，配备 NPU/GPU（如骁龙 8 系、天玑 9 系）

实操步骤 ：

模型转换：导出 TFLite INT8 格式（YOLOv8 一键支持）：
python 复制代码
```
yolo export model=yolov8n.pt format=tflite imgsz=320 int8=True data=data.yaml
```

移动端集成（基于 Android Studio，Java/Kotlin）：

步骤 1：将yolov8n.tflite放入app/src/main/assets目录；

步骤 2：添加 TFLite 依赖（build.gradle）：

java 复制代码

dependencies {
    // TFLite核心依赖
    implementation 'org.tensorflow:tensorflow-lite:2.15.0'
    // TFLite NNAPI加速依赖
    implementation 'org.tensorflow:tensorflow-lite-support:0.4.4'
    implementation 'org.tensorflow:tensorflow-lite-gpu:2.15.0'
}

步骤 3：编写 TFLite 推理代码（简化版，Java）：

java 复制代码

import org.tensorflow.lite.Interpreter;
import java.io.FileInputStream;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

// 加载TFLite模型
private MappedByteBuffer loadModelFile(AssetManager assetManager, String modelPath) throws IOException {
    AssetFileDescriptor fileDescriptor = assetManager.openFd(modelPath);
    FileInputStream inputStream = new FileInputStream(fileDescriptor.getFileDescriptor());
    FileChannel fileChannel = inputStream.getChannel();
    long startOffset = fileDescriptor.getStartOffset();
    long declaredLength = fileDescriptor.getDeclaredLength();
    return fileChannel.map(FileChannel.MapMode.READ_ONLY, startOffset, declaredLength);
}

// 初始化推理器（开启NNAPI加速）
Interpreter.Options options = new Interpreter.Options();
options.setUseNNAPI(true); // 调用设备NPU/GPU加速
Interpreter tflite = new Interpreter(loadModelFile(getAssets(), "yolov8n.tflite"), options);

// 后续：图像预处理、推理、后处理（参考YOLOv8 TFLite官方文档）

部署效果：骁龙 8 Gen 2：FPS≈25-35（YOLOv8n + INT8），精度损失≤3%，功耗低，支持离线运行。

2. iOS 部署（闭源生态，适配苹果设备）

iOS 部署核心采用 "YOLOv8n + Core ML + INT8" 方案，利用 Core ML 适配苹果生态，调用 Apple Neural Engine（ANE）加速，支持离线推理、隐私保护。

适用场景：iOS APP 视觉检测、iPhone/iPad 端智能分析、苹果生态闭环应用
硬件要求：iOS 13.0+，配备 ANE（iPhone 8+/iPad Pro 2018+）

实操步骤 ：

模型转换：导出 Core ML 格式（YOLOv8 一键支持）：
python 复制代码
```
yolo export model=yolov8n.pt format=coreml imgsz=320 int8=True data=data.yaml
```

移动端集成（基于 Xcode，Swift/Objective-C）：

步骤 1：将yolov8n.mlmodel拖入 Xcode 项目，勾选 "Add to targets"；

步骤 2：编写 Core ML 推理代码（简化版，Swift）：

Swift 复制代码

import CoreML
import Vision

// 加载Core ML模型
guard let model = try? VNCoreMLModel(for: yolov8n().model) else {
    fatalError("加载模型失败")
}

// 配置视觉请求
let request = VNCoreMLRequest(model: model) { request, error in
    guard let results = request.results as? [VNRecognizedObjectObservation] else {
        return
    }
    // 解析检测结果
    for result in results {
        print("检测框：\(result.boundingBox)，置信度：\(result.confidence)")
    }
}

// 处理摄像头帧（简化版）
let handler = VNImageRequestHandler(ciImage: CIImage(image: UIImage(named: "test.jpg")!), options: [:])
try? handler.perform([request])

部署效果：iPhone 15 Pro：FPS≈30-40（YOLOv8n + INT8），精度损失≤3%，功耗低，支持离线运行。

3. 移动端部署核心优化与避坑

超轻量化模型：仅选择 YOLOv8n，输入尺寸调整为 320/256（32 的倍数），最小化计算量；
INT8 量化必开：移动端存储 / 算力有限，INT8 量化是实现流畅运行的关键；
离线推理优先：移动端优先选择 TFLite/Core ML 离线模型，避免网络依赖，保护用户隐私；
避坑：
- Android：不同厂商 NPU 适配差异大，需多设备测试，优先使用 NNAPI 自动适配；
- iOS：Core ML 模型需在 Xcode 中进行 "模型编译"，支持 ANE 加速，避免直接运行未编译模型。

四、三大平台部署对比与选型指南

部署平台	核心方案	优势	劣势	适用场景	精度损失	推荐模型
本地（桌面 / 服务器）	YOLOv8s/m + ONNX/TensorRT	速度快、精度高、易调试、可二次开发	功耗高、依赖高性能硬件	实时监控、批量推理、视频分析	≤2%（TensorRT INT8）	YOLOv8s/m/l
嵌入式（Jetson / 树莓派）	YOLOv8n + TensorRT/OpenVINO	边缘部署、低延迟、数据不上云、功耗适中	算力有限、精度略有损失	机器人视觉、智能安防、边缘监控	≤3%（INT8）	YOLOv8n
移动端（Android/iOS）	YOLOv8n + TFLite/Core ML	便携、低功耗、离线运行、隐私保护	算力弱、模型限制大、开发复杂度高	手机 APP、端侧智能、移动检测	≤3%（INT8）	YOLOv8n

核心选型原则

优先看硬件：有 NVIDIA GPU 选 TensorRT，Intel CPU 选 OpenVINO，移动端选 TFLite/Core ML；
次优先看需求：实时性要求高选 TensorRT/NNAPI，低成本选树莓派 / YOLOv8n，隐私保护选移动端离线部署；
最后看精度：精度要求高选 YOLOv8m/l（本地 / 服务器），精度要求适中选 YOLOv8n（嵌入式 / 移动端）。

总结

核心部署要点

平台适配：不同平台选择专属模型格式与推理框架，是部署成功的关键；
轻量化先行：嵌入式 / 移动端必须使用 YOLOv8n + INT8 量化，平衡速度与精度；
离线优先：生产环境优先选择离线模型（ONNX/TFLite/Core ML），避免依赖第三方库 / 网络；
验证落地：每一步部署后，验证速度（FPS）、精度（mAP@0.5）、稳定性，确保满足业务需求。

部署后续工作

后处理优化：完善检测结果解析、NMS 优化，提升最终用户体验；
性能调优：针对目标设备，微调输入尺寸、置信度阈值，最大化速度 / 精度平衡；
批量部署：嵌入式 / 移动端批量部署时，做好模型版本管理、设备适配测试。

【深度学习】YOLO 模型部署全攻略（本地 / 嵌入式 / 移动端）

核心部署逻辑

一、 本地部署（桌面 / 服务器，最高优先级，最易落地）

1. 核心部署方案（按优先级排序）

方案 1：Ultralytics 原生部署（最简单，快速验证，推荐入门）

方案 2：ONNX + ONNX Runtime 部署（平衡速度 / 易用性，推荐生产环境）

方案 3：TensorRT 部署（NVIDIA GPU 极致提速，推荐高性能服务器）

2. 本地部署核心优化与避坑

二、 嵌入式部署（Jetson / 树莓派，边缘计算核心）

1. 主流嵌入式平台部署方案

平台 1：NVIDIA Jetson 系列（推荐，算力较强，易部署）

平台 2：树莓派（低成本，算力有限，入门级）

2. 嵌入式部署核心优化与避坑

三、 移动端部署（Android/iOS，端侧智能核心）

1. Android 部署（主流，开源生态完善，推荐）

2. iOS 部署（闭源生态，适配苹果设备）

3. 移动端部署核心优化与避坑

四、 三大平台部署对比与选型指南

核心选型原则

总结

核心部署要点

部署后续工作

一、本地部署（桌面 / 服务器，最高优先级，最易落地）

二、嵌入式部署（Jetson / 树莓派，边缘计算核心）

三、移动端部署（Android/iOS，端侧智能核心）

四、三大平台部署对比与选型指南