YOLOv5边缘计算部署：Jetson设备适配实战案例

JetFalcon67

788人浏览 · 2026-03-04 18:44:36

JetFalcon67 · 2026-03-04 18:44:36 发布

YOLOv5边缘计算部署：Jetson设备适配实战案例

YOLO（You Only Look Once）自2015年问世以来，凭借其“只看一次”就能完成目标检测的独特架构，迅速成为计算机视觉领域的明星算法。它把目标检测任务从传统的多阶段流程简化为单次前向传播，在速度和精度之间找到了绝佳平衡点。

如今，YOLOv5作为该系列的最新演进版本，不仅继承了前辈们的优秀基因，更在易用性、灵活性和部署友好性上达到了新高度。但当我们想把YOLOv5从云端服务器搬到边缘设备——比如NVIDIA Jetson系列开发板上时，事情就变得有趣起来了。

边缘设备不像服务器那样有充裕的计算资源和内存空间，它们需要在有限的功耗和算力下完成实时推理任务。今天，我就带你一起探索如何在Jetson设备上部署YOLOv5，分享一些实战中踩过的坑和总结的经验。

1. 为什么选择YOLOv5进行边缘部署？

在开始具体操作之前，我们先聊聊为什么YOLOv5特别适合边缘计算场景。了解这些背景，能帮助你在后续的部署和优化中做出更明智的选择。

1.1 边缘计算的特殊需求

边缘设备——无论是Jetson Nano、Jetson Xavier NX还是Jetson AGX Orin——都有几个共同特点：

算力有限：虽然Jetson系列性能不错，但和服务器级GPU相比仍有差距
内存紧张：通常只有4GB到16GB内存，模型太大就装不下
功耗敏感：很多边缘设备靠电池供电，需要平衡性能和功耗
实时性要求高：工业检测、安防监控等场景需要毫秒级响应

这些限制意味着不是所有模型都适合边缘部署。我们需要一个在精度、速度和模型大小之间取得良好平衡的解决方案。

1.2 YOLOv5的独特优势

YOLOv5在这方面表现出色，主要有以下几个原因：

模型尺寸灵活：YOLOv5提供了从nano到x-large的多个预训练模型

YOLOv5n：仅1.9M参数，适合资源极度受限的场景
YOLOv5s：7.2M参数，精度和速度的平衡点
YOLOv5m：21.2M参数，适合大多数应用
YOLOv5l：46.5M参数，精度更高
YOLOv5x：86.7M参数，追求极致精度

部署友好：YOLOv5原生支持多种部署格式

PyTorch模型（.pt）：用于训练和推理
ONNX格式：跨平台部署标准
TensorRT引擎：针对NVIDIA GPU优化
CoreML格式：苹果设备部署
TFLite格式：移动端和嵌入式设备

社区生态成熟：Ultralytics团队维护活跃，文档齐全，遇到问题容易找到解决方案。

2. Jetson设备环境准备

工欲善其事，必先利其器。在Jetson上部署YOLOv5之前，我们需要先搭建好开发环境。这个过程可能会遇到一些依赖问题，别担心，我会带你一步步解决。

2.1 系统基础配置

首先确保你的Jetson设备已经刷好了最新的JetPack系统。JetPack是NVIDIA为Jetson系列定制的软件开发套件，包含了操作系统、CUDA、cuDNN等必要组件。

检查系统信息：

# 查看JetPack版本
cat /etc/nv_tegra_release

# 查看CUDA版本
nvcc --version

# 查看Python版本
python3 --version

如果你的设备还没安装JetPack，建议先到NVIDIA官网下载最新版本。目前主流的是JetPack 5.x系列，它基于Ubuntu 20.04，支持Python 3.8。

2.2 安装必要的依赖包

Jetson设备使用的是ARM架构，很多Python包需要从源码编译安装。这里有个小技巧：先安装系统级的依赖，再安装Python包。

# 更新系统包
sudo apt update
sudo apt upgrade -y

# 安装编译工具和基础依赖
sudo apt install -y build-essential cmake git libopenblas-dev liblapack-dev
sudo apt install -y libjpeg-dev libpng-dev libtiff-dev
sudo apt install -y python3-pip python3-dev python3-venv

# 安装PyTorch依赖
sudo apt install -y libopenmpi-dev libomp-dev

重要提示：Jetson设备的存储空间有限，建议使用SD卡扩展存储，或者挂载外部硬盘。编译PyTorch这类大型项目需要足够的临时空间。

2.3 创建Python虚拟环境

我强烈建议使用虚拟环境来管理Python包，这样可以避免系统Python环境被污染，也方便不同项目使用不同版本的包。

# 创建虚拟环境
python3 -m venv yolov5_env

# 激活虚拟环境
source yolov5_env/bin/activate

# 升级pip
pip install --upgrade pip

虚拟环境激活后，你的命令行提示符前面会出现(yolov5_env)字样，表示当前在这个环境中工作。

3. 在Jetson上安装PyTorch和YOLOv5

这是最关键的一步。Jetson的ARM架构意味着我们不能直接使用PyTorch官网提供的预编译包，需要从源码编译或者使用NVIDIA提供的版本。

3.1 安装PyTorch for Jetson

NVIDIA为Jetson设备提供了优化版的PyTorch，我们需要根据JetPack版本选择对应的PyTorch版本。

对于JetPack 5.x（Python 3.8）：

# 安装PyTorch
wget https://nvidia.box.com/shared/static/ssf2v7pf5i245fk4i0q926hy4imzs2ph.whl -O torch-1.12.0a0+2c916ef.nv22.3-cp38-cp38-linux_aarch64.whl
pip install torch-1.12.0a0+2c916ef.nv22.3-cp38-cp38-linux_aarch64.whl

# 验证安装
python3 -c "import torch; print(f'PyTorch版本: {torch.__version__}')"
python3 -c "import torch; print(f'CUDA可用: {torch.cuda.is_available()}')"

如果显示CUDA可用为True，说明PyTorch安装成功并且能够调用Jetson的GPU。

3.2 安装YOLOv5

现在可以安装YOLOv5了。Ultralytics团队把YOLOv5做成了一个Python包，安装起来很简单：

# 安装YOLOv5
pip install yolov5

# 或者从源码安装（推荐，方便修改）
git clone https://github.com/ultralytics/yolov5
cd yolov5
pip install -r requirements.txt

requirements.txt里包含了所有依赖包，安装过程可能需要一些时间。如果遇到某个包安装失败，可以尝试单独安装或者寻找替代版本。

3.3 测试基础功能

安装完成后，我们来跑一个简单的测试，确保一切正常：

import torch
import yolov5

# 检查设备
device = 'cuda' if torch.cuda.is_available() else 'cpu'
print(f"使用设备: {device}")

# 加载预训练模型
model = yolov5.load('yolov5s.pt', device=device)

# 设置模型参数
model.conf = 0.25  # 置信度阈值
model.iou = 0.45   # IoU阈值

# 测试图片
img_url = 'https://ultralytics.com/images/zidane.jpg'
results = model(img_url)

# 显示结果
results.show()
results.save()

如果能看到检测结果图片保存到runs/detect/exp目录，说明基础安装成功了。

4. Jetson设备上的性能优化技巧

在Jetson上直接运行YOLOv5可能感觉有点慢，别急，我们有几个优化技巧可以让它飞起来。

4.1 使用TensorRT加速

TensorRT是NVIDIA的深度学习推理优化器，它能把训练好的模型转换成高度优化的推理引擎。对于Jetson设备来说，TensorRT能带来2-5倍的性能提升。

第一步：安装TensorRT

JetPack已经包含了TensorRT，但我们需要安装Python绑定：

# 安装TensorRT Python包
sudo apt install python3-libnvinfer python3-libnvinfer-dev

第二步：导出模型为ONNX格式

TensorRT不支持直接加载PyTorch模型，需要先转换成ONNX：

import torch

# 加载PyTorch模型
model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True)

# 导出为ONNX
dummy_input = torch.randn(1, 3, 640, 640).to('cuda')
torch.onnx.export(
    model,
    dummy_input,
    'yolov5s.onnx',
    opset_version=12,
    input_names=['images'],
    output_names=['output'],
    dynamic_axes={'images': {0: 'batch'}, 'output': {0: 'batch'}}
)

第三步：使用TensorRT推理

这里有个简化版的TensorRT推理代码：

import tensorrt as trt
import pycuda.driver as cuda
import pycuda.autoinit
import numpy as np

class YOLOv5TRT:
    def __init__(self, engine_path):
        # 加载TensorRT引擎
        self.logger = trt.Logger(trt.Logger.WARNING)
        with open(engine_path, 'rb') as f:
            self.engine = trt.Runtime(self.logger).deserialize_cuda_engine(f.read())
        
        self.context = self.engine.create_execution_context()
        
    def inference(self, image):
        # 这里简化了预处理和后处理
        # 实际使用时需要完整的流程
        pass

# 使用示例
trt_model = YOLOv5TRT('yolov5s.trt')

实际项目中，你可能需要使用NVIDIA提供的YOLOv5 TensorRT示例代码，或者使用开源的TensorRT封装库。

4.2 模型量化压缩

模型量化是减少模型大小、提升推理速度的有效方法。YOLOv5支持INT8量化，能在几乎不损失精度的情况下大幅提升速度。

# 简单的量化示例
model = yolov5.load('yolov5s.pt')

# 准备校准数据（用于确定量化参数）
calibration_data = [...]  # 一批代表性图片

# 量化模型（这里需要具体的量化工具）
# 实际使用中，TensorRT的INT8量化效果最好

在Jetson上，结合TensorRT的INT8量化，通常能获得最佳的性能提升。

4.3 输入分辨率优化

YOLOv5默认使用640x640的输入分辨率，但在边缘设备上，我们可以根据实际需求调整：

降低分辨率：如果检测目标比较大，可以降低到416x416甚至320x320
动态分辨率：根据场景需要动态调整输入大小
多尺度训练：训练时使用多尺度，推理时固定到最优尺度

# 调整输入尺寸
model.imgsz = 416  # 改为416x416

# 或者根据设备能力动态调整
def get_optimal_size(device_type):
    if device_type == 'Jetson Nano':
        return 320
    elif device_type == 'Jetson Xavier NX':
        return 416
    else:
        return 640

4.4 批处理优化

虽然边缘设备内存有限，但适当的批处理能提高GPU利用率：

# 单张图片推理
results = model(single_image)

# 批处理推理（2-4张为宜）
batch_images = [img1, img2, img3, img4]
batch_results = model(batch_images)

对于视频流处理，可以积累几帧后批量处理，平衡延迟和吞吐量。

5. 实战案例：智能安防监控系统

理论讲得差不多了，我们来看一个实际的应用案例。假设我们要在Jetson Xavier NX上部署一个智能安防监控系统，需要实时检测人、车等目标。

5.1 系统架构设计

整个系统可以分为几个模块：

摄像头输入 → 视频解码 → 图像预处理 → YOLOv5推理 → 结果后处理 → 报警/存储

每个环节都需要针对Jetson设备进行优化。

5.2 代码实现

下面是核心的推理代码框架：

import cv2
import torch
import time
from yolov5 import YOLOv5

class SecurityMonitor:
    def __init__(self, model_path='yolov5s.pt', conf_thresh=0.5):
        # 初始化模型
        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
        self.model = YOLOv5(model_path, device=self.device)
        self.model.conf = conf_thresh
        
        # 只检测人、车等关键目标
        self.classes_of_interest = [0, 2, 5, 7]  # person, car, bus, truck
        
        # 性能统计
        self.frame_count = 0
        self.total_time = 0
        
    def process_frame(self, frame):
        """处理单帧图像"""
        start_time = time.time()
        
        # 推理
        results = self.model(frame)
        
        # 过滤感兴趣的目标
        detections = []
        for result in results.xyxy[0]:  # 获取检测结果
            if int(result[5]) in self.classes_of_interest:
                detections.append({
                    'class': int(result[5]),
                    'confidence': float(result[4]),
                    'bbox': result[:4].tolist()
                })
        
        # 绘制结果
        annotated_frame = self.draw_detections(frame, detections)
        
        # 性能统计
        inference_time = time.time() - start_time
        self.frame_count += 1
        self.total_time += inference_time
        
        return annotated_frame, detections
    
    def draw_detections(self, frame, detections):
        """在图像上绘制检测框"""
        for det in detections:
            x1, y1, x2, y2 = map(int, det['bbox'])
            label = f"{det['class']}: {det['confidence']:.2f}"
            
            # 绘制矩形框
            cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
            # 绘制标签
            cv2.putText(frame, label, (x1, y1-10), 
                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
        
        # 显示FPS
        if self.frame_count > 0:
            avg_fps = self.frame_count / self.total_time
            cv2.putText(frame, f"FPS: {avg_fps:.1f}", (10, 30),
                       cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
        
        return frame
    
    def run(self, video_source=0):
        """主循环"""
        cap = cv2.VideoCapture(video_source)
        
        while True:
            ret, frame = cap.read()
            if not ret:
                break
            
            # 处理帧
            processed_frame, detections = self.process_frame(frame)
            
            # 显示结果
            cv2.imshow('Security Monitor', processed_frame)
            
            # 检查是否有异常（示例：检测到人）
            if any(det['class'] == 0 for det in detections):
                print("检测到人员！")
                # 这里可以触发报警或记录
            
            # 按q退出
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
        
        cap.release()
        cv2.destroyAllWindows()

# 使用示例
if __name__ == "__main__":
    monitor = SecurityMonitor()
    monitor.run()  # 使用默认摄像头

5.3 性能优化实践

在实际部署中，我们还需要考虑以下优化：

视频解码优化：

# 使用硬件加速解码
cap = cv2.VideoCapture(video_source)
cap.set(cv2.CAP_PROP_HW_ACCELERATION, cv2.VIDEO_ACCELERATION_ANY)

异步处理：

# 使用多线程，一个线程负责读取视频，一个线程负责推理
import threading
from queue import Queue

class AsyncProcessor:
    def __init__(self):
        self.frame_queue = Queue(maxsize=2)
        self.result_queue = Queue(maxsize=2)
        
    def capture_thread(self):
        while True:
            ret, frame = self.cap.read()
            if ret:
                self.frame_queue.put(frame)
    
    def inference_thread(self):
        while True:
            frame = self.frame_queue.get()
            results = self.model(frame)
            self.result_queue.put(results)

内存管理：

# 定期清理缓存
import gc
import torch

def cleanup_memory():
    torch.cuda.empty_cache()
    gc.collect()

# 每处理100帧清理一次
if self.frame_count % 100 == 0:
    cleanup_memory()

6. 常见问题与解决方案

在Jetson上部署YOLOv5时，你可能会遇到一些问题。这里我整理了一些常见问题和解决方法。

6.1 内存不足问题

问题表现：运行时报错CUDA out of memory

解决方案：

使用更小的模型（YOLOv5n或YOLOv5s）
降低输入图像分辨率
减少批处理大小
使用梯度检查点（训练时）
启用swap空间

# 增加swap空间
sudo fallocate -l 4G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

# 永久生效
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

6.2 推理速度慢

问题表现：FPS低于预期

解决方案：

启用TensorRT加速
使用INT8量化
优化预处理和后处理代码
使用半精度（FP16）推理
调整模型置信度阈值

# 使用FP16推理
model = model.half()  # 转换为半精度
input_tensor = input_tensor.half()

# 调整置信度阈值（平衡精度和速度）
model.conf = 0.4  # 默认0.25，提高可减少检测数量

6.3 模型精度下降

问题表现：在Jetson上检测效果比服务器差

解决方案：

检查输入数据预处理是否一致
验证TensorRT转换是否正确
使用校准数据集进行INT8量化
在Jetson上进行微调（迁移学习）

# 在Jetson上进行微调
import torch.optim as optim

# 加载预训练模型
model = yolov5.load('yolov5s.pt')

# 冻结部分层（加速训练，减少过拟合）
for param in model.model[:10].parameters():  # 冻结前10层
    param.requires_grad = False

# 准备优化器
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 使用本地数据训练
# ... 训练代码 ...

6.4 摄像头兼容性问题

问题表现：无法读取摄像头或视频流

解决方案：

检查摄像头驱动
使用GStreamer后端
调整视频采集参数

# 使用GStreamer管道（适用于Jetson）
pipeline = (
    "nvarguscamerasrc ! "
    "video/x-raw(memory:NVMM), width=1280, height=720, format=NV12, framerate=30/1 ! "
    "nvvidconv flip-method=0 ! "
    "video/x-raw, width=640, height=480, format=BGRx ! "
    "videoconvert ! "
    "video/x-raw, format=BGR ! "
    "appsink"
)

cap = cv2.VideoCapture(pipeline, cv2.CAP_GSTREAMER)