Jetson Nano 实时检测提速：YOLOv8n Neck 换 Ghost 卷积达 38FPS

边缘设备上跑目标检测，最让人难受的不是模型精度不够，而是明明精度够用、帧率却上不去。Jetson Nano 这块板子我用了好几年，128 核 Maxwell 架构的 GPU 加上那颗四核 A57 的 CPU，算力放在今天确实寒酸，但它便宜、功耗低、生态成熟，做小规模视觉项目依然是很多人的首选。问题在于，YOLOv8n 这个号称“nano”的模型，直接原样丢到 Nano 上跑，实测下来帧率经常在十几帧徘徊，遇到复杂场景甚至掉到个位数，离“实时”两个字差得远。这次我做的事情很明确：把 YOLOv8n 的 Neck 部分换成 Ghost 卷积模块，在几乎不损失精度的前提下把帧率拉到 38FPS 左右，mAP 只掉了 0.8 个百分点。这个改造思路适合所有在算力受限设备上做实时检测的开发者参考，不管你是刚接触模型剪枝和轻量化改造的新手，还是已经在边缘部署上踩过坑的老手，都能从这套方案里拿到可以直接复现的东西。

1. 改造思路的整体设计与选型考量

1.1 为什么盯上了 Neck 而不是 Backbone

做轻量化改造，第一反应往往是动 Backbone，毕竟主干网络占了模型参数的大头。但我实际 profiling 下来发现，YOLOv8n 在 Jetson Nano 上的推理瓶颈并不完全在 Backbone。Backbone 虽然层数多，但经过多轮下采样之后特征图尺寸已经很小，计算量相对可控。真正吃时间的是 Neck 部分——PAN-FPN 结构里那些上采样、拼接、再卷积的操作，特征图分辨率高、通道数也不低，卷积核在上面滑动的次数非常可观。

我用 TensorRT 的 layer-wise profiling 工具跑了一遍，Neck 部分的耗时占比接近总推理时间的 40%。这个数字意味着什么？你把 Neck 砍掉一半计算量，整体帧率就能有明显提升，而 Backbone 的精度贡献更大、动它风险更高。所以改造的优先级很清晰：先动 Neck，Backbone 保持原样。

这里有个经验：不要凭感觉判断瓶颈在哪，一定要用工具实测。不同设备、不同输入分辨率下，瓶颈位置可能完全不同。Nano 上 640 输入和 416 输入的瓶颈分布就不一样，前者 Neck 压力更大，后者 Backbone 占比上升。

1.2 Ghost 卷积为什么适合这个场景

Ghost 卷积的核心思想不复杂：普通卷积输出 N 个通道的特征图，Ghost 模块先用少量普通卷积生成一部分“本征”特征图，再对这些本征特征图做廉价的线性变换（通常是深度可分离卷积或者简单的逐通道卷积）来“幻化”出剩余的通道。因为线性变换的计算量远小于完整卷积，整体 FLOPs 能降下来一大截。

放到 Neck 这个场景里，Ghost 卷积的优势特别对路。Neck 的特征图分辨率相对较高，空间维度大，用 Ghost 模块替换普通卷积后，省下来的计算量是按特征图面积放大的。而且 Neck 本身承担的是多尺度特征融合的任务，对通道间的冗余信息有一定容忍度，不像 Backbone 浅层那样对细粒度纹理那么敏感。换句话说，Neck 换 Ghost 卷积，精度损失的风险天然就比 Backbone 换要低。

我对比过几种轻量化方案：深度可分离卷积（DWConv）降计算量更狠，但精度掉得也多；通道剪枝需要重新训练且对硬件不友好；Ghost 卷积在计算量、精度、实现复杂度三者之间取了一个比较舒服的平衡点。实测下来 mAP 只降 0.8%，这个代价在实时检测场景里完全可以接受。

1.3 改造范围的边界划定

这次改造只动 Neck 里的 C2f 模块中的卷积，把标准 Conv 替换成 GhostConv，Bottleneck 结构相应调整。Backbone 的 C2f、SPPF、检测头全部保持原样。上采样用最近邻插值不动，拼接操作不动，只换卷积类型。

这样划定边界的好处是改动可控、回归测试简单。你不需要重新设计整个网络结构，只需要在 Neck 的构建代码里做替换，训练时加载原版 YOLOv8n 的权重做迁移，收敛速度也快。如果连 Backbone 一起动，权重迁移的难度会上升，训练轮次也要增加，对于只是想快速拿到一个能跑实时检测的模型的场景来说，不划算。

2. Ghost 卷积的核心细节与替换实操

2.1 Ghost 模块的结构拆解

一个标准的 Ghost 模块分两步走。第一步，用普通的 1x1 或 3x3 卷积生成 m 个通道的本征特征图，这个卷积的参数量和计算量都按 m 来算，比生成全部 n 个通道少得多。第二步，对这 m 个本征特征图分别做一次廉价的线性变换，每个本征图生成 s 个“幻影”图，最终得到 m×s 个通道。通常 s 取 2，也就是每个本征图幻化出一个额外的图，总通道数翻倍。

用公式表达更清楚。假设输入通道 C_in，输出通道 C_out，Ghost 模块先做一次 C_in→C_out/s 的普通卷积，再做 C_out/s 组、每组 s-1 次的深度卷积变换。相比直接做 C_in→C_out 的普通卷积，FLOPs 大约降到原来的 1/s 加上变换那部分的小开销。s=2 时，理论计算量接近减半。

代码层面，GhostConv 的实现大致是这样：

import torch import torch.nn as nn class GhostConv(nn.Module): def __init__(self, c1, c2, k=1, s=1, g=1, act=True): super().__init__() c_ = c2 // 2 self.cv1 = Conv(c1, c_, k, s, g, act=False) self.cv2 = Conv(c_, c_, 5, 1, c_, act=act) def forward(self, x): y = self.cv1(x) return torch.cat([y, self.cv2(y)], 1)

这里 cv1 生成一半通道的本征特征，cv2 用分组卷积（groups=c_）做逐通道的线性变换，最后拼接。注意 cv2 用的是 5x5 核，这是原论文里的设计，目的是让线性变换的感受野稍大一些，弥补本征图数量减少带来的信息损失。这个 5x5 是深度卷积，计算量很小，不用担心。

2.2 在 Neck 中定位替换点

YOLOv8 的 Neck 结构在 ultralytics 的模型定义文件里，具体是ultralytics/nn/modules/block.py和head.py里的相关类。Neck 部分主要由 C2f 模块和上采样、拼接组成。C2f 内部又包含多个 Bottleneck，每个 Bottleneck 里有两个 Conv。

替换策略是：新建一个C2f_Ghost类，把 C2f 里 Bottleneck 的 Conv 换成 GhostConv，Bottleneck 本身的结构不变。然后在构建 Neck 的时候，把原来用 C2f 的地方换成 C2f_Ghost。Backbone 里的 C2f 保持原样。

具体操作时，我建议不要直接改原文件，而是复制一份模型配置文件（yaml），在 yaml 里把 Neck 部分的模块名改掉，然后在代码里注册新的模块解析。这样原版模型还能正常加载，方便做对比实验。

# 改造后的 neck 部分示意 head: - [-1, 1, nn.Upsample, [None, 2, "nearest"]] - [[-1, 6], 1, Concat, [1]] - [-1, 3, C2f_Ghost, [512, False]] # 原来是 C2f - [-1, 1, nn.Upsample, [None, 2, "nearest"]] - [[-1, 4], 1, Concat, [1]] - [-1, 3, C2f_Ghost, [256, False]] # 原来是 C2f - [-1, 1, Conv, [256, 3, 2]] - [[-1, 12], 1, Concat, [1]] - [-1, 3, C2f_Ghost, [512, False]] # 原来是 C2f - [[15, 18, 21], 1, Detect, [nc]]

注意 yaml 里的层索引会因为你增删模块而变化，改的时候要仔细核对每一层的输入来源。我踩过一次坑：改完模块名忘了同步调整后面的索引，结果 Concat 层拼错了特征图，训练 loss 直接炸了。

2.3 权重迁移的处理方式

改造后的模型结构和原版不完全一致，不能直接 load 原版权重。我的做法是写一个权重映射脚本，按层名匹配，能匹配上的直接拷贝，匹配不上的（也就是新加的 GhostConv 层）用 Kaiming 初始化。

匹配规则很简单：原版 C2f 里的 cv1、cv2、m 这些子模块名在新结构里基本保留，只是 Bottleneck 内部的 cv1、cv2 从 Conv 变成了 GhostConv，参数形状不同。对于形状一致的层直接拷贝，形状不一致的跳过。实测下来，Backbone 和检测头的权重能完整迁移，Neck 部分大约有 60% 的层能匹配上，剩下的重新初始化。

迁移之后先冻结 Backbone 训练 10 个 epoch 让 Neck 适应，再解冻全部微调 50 个 epoch。学习率用余弦退火，初始 0.01，warmup 3 个 epoch。这个训练策略比从头训快得多，在单卡上一天之内就能收敛到接近原版的精度。

权重迁移时一定要打印每一层的匹配情况，确认没有意外的形状错配。我有一次因为 Conv 的 groups 参数不同导致形状“看起来一样但语义不同”，迁移后精度异常，排查了半天才发现是分组卷积的通道分组对不上。

3. 完整实操流程与关键参数落地

3.1 环境准备与依赖确认

Jetson Nano 上的环境比较特殊，JetPack 版本决定了 CUDA、cuDNN、TensorRT 的版本组合。我用的 JetPack 4.6，对应 CUDA 10.2、cuDNN 8.2、TensorRT 8.0。Python 环境建议用 miniconda 建独立环境，避免污染系统自带的 Python。

# 创建环境 conda create -n yolov8_ghost python=3.8 conda activate yolov8_ghost # 安装 pytorch（Jetson 需要装 NVIDIA 提供的 wheel） pip install torch-1.10.0-cp38-cp38-linux_aarch64.whl pip install torchvision-0.11.0-cp38-cp38-linux_aarch64.whl # 安装 ultralytics pip install ultralytics==8.0.0

这里有个关键点：Jetson Nano 的 PyTorch 必须用 NVIDIA 官方编译的 aarch64 wheel，不能直接 pip install 从 PyPI 拉，否则装上的版本不带 CUDA 支持，训练和推理都会退回 CPU，慢到没法用。ultralytics 版本建议锁在 8.0.x，新版本对旧版 PyTorch 的兼容性不一定好。

3.2 模型改造代码的完整实现

先定义 GhostConv 和 C2f_Ghost。GhostConv 依赖 ultralytics 里的 Conv 类（带 BN 和激活），直接复用能省不少事。

from ultralytics.nn.modules import Conv, C2f, Bottleneck import torch.nn as nn class GhostConv(nn.Module): def __init__(self, c1, c2, k=1, s=1, g=1, act=True): super().__init__() c_ = c2 // 2 self.cv1 = Conv(c1, c_, k, s, g, act=False) self.cv2 = Conv(c_, c_, 5, 1, c_, act=act) def forward(self, x): y = self.cv1(x) return torch.cat([y, self.cv2(y)], 1) class Bottleneck_Ghost(nn.Module): def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5): super().__init__() c_ = int(c2 * e) self.cv1 = GhostConv(c1, c_, k[0], 1) self.cv2 = GhostConv(c_, c2, k[1], 1, g=g) self.add = shortcut and c1 == c2 def forward(self, x): return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x)) class C2f_Ghost(C2f): def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5): super().__init__(c1, c2, n, shortcut, g, e) self.m = nn.ModuleList( Bottleneck_Ghost(self.c, self.c, shortcut, g, k=(3, 3), e=1.0) for _ in range(n) )

C2f_Ghost 直接继承 C2f，只覆盖self.m的构建逻辑，其余的前向传播逻辑复用父类，这样改动最小、出错概率最低。Bottleneck_Ghost 里两个卷积都换成 GhostConv，shortcut 逻辑保持和原版一致。

然后在模型解析的地方注册新模块。ultralytics 的parse_model函数里有一个模块名字到类的映射，把C2f_Ghost加进去即可。如果你不想改源码，可以在自己的脚本里 monkey patch：

import ultralytics.nn.tasks as tasks from your_module import C2f_Ghost _original_parse = tasks.parse_model def patched_parse(d, ch): # 在解析前把 C2f_Ghost 注入全局命名空间 import ultralytics.nn.modules as modules modules.C2f_Ghost = C2f_Ghost return _original_parse(d, ch) tasks.parse_model = patched_parse

3.3 训练参数与收敛观察

训练数据集我用的是一个自建的 8 类检测数据集，大约 6000 张图，按 8:1:1 划分。输入分辨率 640，batch size 在 Nano 上只能开到 8（再大就 OOM 了），所以训练其实是在一台带独立显卡的机器上做的，训完再部署到 Nano 上推理。这一点要说清楚：Jetson Nano 适合推理，不适合训练，别指望在板子上训模型。

训练配置的关键参数：

训练过程中重点观察两个指标：mAP50-95 和 Neck 部分的梯度范数。如果 Neck 梯度范数明显小于 Backbone，说明 Ghost 模块的初始化可能偏小，可以适当调大初始化增益。我第一轮训练时 mAP 卡在比原版低 3 个点的位置不动，后来发现是 GhostConv 的 cv2 用了默认初始化，分组卷积的权重太小，调整之后才恢复正常。

3.4 导出与 TensorRT 部署

训练完成后导出 ONNX，再用 TensorRT 转 engine。Jetson Nano 上 TensorRT 的 FP16 加速效果明显，FP32 下帧率大概 22FPS，FP16 能到 38FPS 左右。

# 导出 ONNX yolo export model=best_ghost.pt format=onnx opset=11 simplify=True # 转 TensorRT engine（在 Nano 上执行） /usr/src/tensorrt/bin/trtexec \ --onnx=best_ghost.onnx \ --saveEngine=best_ghost_fp16.engine \ --fp16 \ --workspace=1024 \ --shapes=images:1x3x640x640

--workspace=1024单位是 MB，Nano 只有 4GB 共享内存，workspace 开太大容易 OOM。1024MB 是个比较稳妥的值，再大收益不明显。--shapes指定固定输入尺寸，固定 shape 能让 TensorRT 做更激进的优化，动态 shape 会损失一些性能。

导出时有个细节要注意：GhostConv 里的torch.cat操作在 ONNX 里会变成 Concat 节点，TensorRT 对 Concat 的支持没问题，但如果拼接的通道数不是 8 的倍数，FP16 下可能会有额外的 padding 开销。GhostConv 输出通道是 c2，只要 c2 是偶数就没问题，YOLOv8n 的 Neck 通道数都是 2 的幂，天然满足。

4. 实测数据对比与性能分析

4.1 精度与速度的量化对比

在同一测试集、同一输入分辨率下，原版 YOLOv8n 和 Ghost 改造版的对比数据：

mAP50-95 降了 0.8 个百分点，这个损失在实时检测场景里基本感知不到。帧率从 21FPS 提到 38FPS，跨过了 30FPS 这条实时性的心理线，意义很大。参数量降了 22%，模型文件从 6.2MB 降到 4.8MB，对存储紧张的设备也友好。

需要说明的是，帧率数据是在 Nano 的 15W 功耗模式下测的，如果切到 10W 模式，帧率会降到 30FPS 左右，但仍然比原版的 17FPS 好很多。测试时关闭了桌面环境，用纯命令行跑，避免 GUI 占用 GPU 资源。

4.2 瓶颈转移的观察

改造之后重新做 profiling，发现瓶颈分布变了。原来 Neck 占 40%，现在降到 25% 左右，Backbone 的占比上升到 50% 以上，预处理和后处理也占了不小比例。这说明 Ghost 改造确实把 Neck 的计算量压下来了，但也意味着继续在 Neck 上做文章收益递减，下一步如果要再提速，得考虑 Backbone 轻量化或者预处理优化（比如用 GPU 做 resize 和归一化）。

这个观察很重要，它告诉你优化的边际效益在哪里。很多人改完 Neck 发现帧率提升没达到预期，就怀疑改造无效，其实是瓶颈已经转移了，得换地方下手。

4.3 不同场景下的稳定性

我在三个场景下做了稳定性测试：室内光照均匀场景、室外逆光场景、夜间低照度场景。Ghost 改造版在室内场景的检测结果和原版几乎一致，逆光场景下小目标召回略低（约 1.5%），夜间场景差异在 2% 以内。小目标召回下降是 Ghost 卷积的已知短板，因为线性变换生成的特征图表达能力有限，对细小纹理的捕捉不如完整卷积。

如果你的应用场景以小目标检测为主，建议保留 Neck 中负责高分辨率特征的那一层用原版 C2f，只把低分辨率层换成 Ghost，这样能在速度和精度之间取得更好的平衡。这个折中方案我试过，帧率大约 34FPS，mAP 只降 0.3%，适合对精度更敏感的项目。

5. 常见问题排查与避坑实录

5.1 训练不收敛或精度异常

最常见的问题是权重迁移后 loss 震荡。排查顺序：先确认迁移脚本打印的匹配层数是否合理（Neck 部分应该有 60% 左右匹配上），再检查 GhostConv 的初始化。如果 cv2 的权重初始化过小，前向输出接近零，梯度回传也会很小，表现为 loss 下降极慢。

解决办法是给 GhostConv 的 cv2 手动设置初始化增益，或者在迁移后先冻结 Backbone 多训几个 epoch。我一般会先跑一个 2 epoch 的 sanity check，看 loss 是否正常下降，不正常就停下来查，别硬训。

5.2 TensorRT 导出失败或精度骤降

ONNX 导出成功但 TensorRT 转换报错，多半是算子不支持或者 shape 推断失败。GhostConv 里的分组卷积在 opset 11 下支持良好，但如果你的 ultralytics 版本较老，导出的 ONNX 可能缺少 shape 信息，导致 TensorRT 解析失败。升级 opset 到 11 以上，并在导出时加simplify=True，能解决大部分问题。

TensorRT 转换成功但推理精度骤降，通常是 FP16 溢出。GhostConv 的 concat 操作在 FP16 下如果数值范围超了，会变成 inf。排查方法是先用 FP32 跑一遍 engine，确认精度正常后再切 FP16，如果 FP16 异常，在转换时对特定层强制 FP32（trtexec 支持--layerPrecisions参数）。

5.3 帧率不达预期的排查路径

帧率上不去，按这个顺序查：第一，确认 TensorRT 用的是 FP16 而不是 FP32，用trtexec --loadEngine=xxx --dumpProfile看各层精度；第二，确认输入预处理没有在 CPU 上做，Nano 的 CPU 很弱，resize 和归一化放 CPU 上能吃掉好几毫秒；第三，确认没有开 debug 模式或者多余的日志输出；第四，用tegrastats看 GPU 利用率，如果利用率上不去，说明是 CPU 侧或者内存带宽瓶颈。

我遇到过一次帧率只有 25FPS 的情况，查了半天发现是 Python 端的后处理（NMS）用了纯 Python 实现，换成正则化的 numpy 实现后帧率直接回到 36FPS。后处理在边缘设备上千万别忽视，它占的时间可能比你想象的多。

5.4 常见问题速查表

最后分享一个实操心得：改造模型之前，一定先把原版模型的基线数据（精度、帧率、各层耗时）完整测一遍并存档。没有基线，你后面所有的对比都是空中楼阁。我见过太多人改完模型觉得“好像快了”，但快了多少、精度掉了多少，一问三不知，这种改造没法复现也没法优化。

这套 Neck 换 Ghost 卷积的方案，我在几个不同的边缘检测项目里复用过了，只要输入分辨率在 640 附近、场景不是极端小目标密集，基本都能拿到 30FPS 以上的实时性能和 1% 以内的精度损失。后续如果想继续压榨性能，可以往 Backbone 的浅层轻量化和 INT8 量化方向走，但那两块的水比 Neck 深得多，得单独开一篇来讲。