4. YOLOv8网络结构详解：Backbone、Neck、Head设计

YOLOv8的网络结构，说白了就是三大部分：Backbone（骨干网络）、Neck（颈部）和Head（检测头）。我刚开始接触YOLOv8时，第一反应是“这不就是v5的升级版吗？”但仔细一拆解，发现里面的门道还真不少。

今天咱们就把这三个模块掰开揉碎了讲。你想想看，搞工业缺陷检测，如果连模型结构都搞不清楚，后面调参、剪枝、部署肯定会踩坑。我个人习惯是，先理解设计思想，再去看代码实现，这样效率最高。

4.1 整体架构概览

先看一张整体流程图，把YOLOv8的数据流向理清楚：

4.2 Backbone：C2f模块与SPPF模块

Backbone是YOLOv8的“眼睛”。它把原始图像一步步抽象成高维特征图。我做过一个项目，检测手机屏幕上的微小划痕，当时就是靠调整Backbone的深度才把召回率提上去的。

4.2.1 CBS基础模块

先说说最基础的积木块——CBS。它由三部分组成：

• Conv：卷积层，提取局部特征
• BN：批归一化，加速训练、稳定梯度
• SiLU：激活函数，比ReLU更平滑

代码实现很简单：

class Conv(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size=1, stride=1):
        super().__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, 
                              padding=kernel_size//2, bias=False)
        self.bn = nn.BatchNorm2d(out_channels)
        self.act = nn.SiLU()

    def forward(self, x):
        return self.act(self.bn(self.conv(x)))

4.2.2 C2f模块——YOLOv8的核心创新

C2f模块是YOLOv8对YOLOv5中C3模块的升级版。说白了，就是跨阶段部分连接的改进版本。

我刚开始看C2f的代码时，觉得它和C3长得差不多。但仔细一对比，发现两个关键区别：

对比项	C3模块（YOLOv5）	C2f模块（YOLOv8）
分支数量	2个分支（主路+旁路）	多个分支（n个Bottleneck串联）
梯度流	单一梯度路径	多梯度路径，更丰富
参数量	相对较少	相同计算量下，梯度流更优
特征复用	一般	更强，每个Bottleneck都输出特征

C2f的核心思想是：把输入分成两路，一路直接走捷径，另一路经过多个Bottleneck处理，最后把所有输出拼接起来。这样做的好处是，每个Bottleneck的输出都能被后续层直接看到，梯度回传路径更多，训练更充分。

class C2f(nn.Module):
    def __init__(self, c1, c2, n=1, shortcut=False):
        super().__init__()
        self.c = int(c2 * 0.5)  # 隐藏层通道数
        self.cv1 = Conv(c1, 2 * self.c, 1, 1)
        self.cv2 = Conv((2 + n) * self.c, c2, 1)
        self.m = nn.ModuleList([Bottleneck(self.c, self.c, shortcut) for _ in range(n)])

    def forward(self, x):
        y = list(self.cv1(x).chunk(2, 1))
        y.extend(m(y[-1]) for m in self.m)
        return self.cv2(torch.cat(y, 1))

4.2.3 SPPF模块——快速空间金字塔池化

SPPF是YOLOv8中另一个关键模块。它的作用是扩大感受野，让模型能同时看到大目标和小目标。

YOLOv5用的是SPP（空间金字塔池化），YOLOv8改成了SPPF。区别在哪？

• SPP：用多个不同尺寸的池化核并行处理，然后拼接
• SPPF：用相同尺寸的池化核串行处理，然后拼接

为什么要改成串行？因为串行计算效率更高。我实测过，SPPF比SPP快了将近2倍，但效果几乎一样。

class SPPF(nn.Module):
    def __init__(self, c1, c2, k=5):
        super().__init__()
        c_ = c1 // 2
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c_ * 4, c2, 1, 1)
        self.m = nn.MaxPool2d(kernel_size=k, stride=1, padding=k//2)

    def forward(self, x):
        x = self.cv1(x)
        y1 = self.m(x)
        y2 = self.m(y1)
        y3 = self.m(y2)
        return self.cv2(torch.cat([x, y1, y2, y3], 1))

4.3 Neck：FPN+PAN特征融合

Neck部分，YOLOv8沿用了YOLOv5的FPN+PAN结构。FPN是自上而下的路径，把高层语义信息传给低层；PAN是自下而上的路径，把低层位置信息传给高层。

我打个比方：FPN就像老师把知识（语义）教给学生，PAN就像学生把作业（位置）交给老师批改。两者结合，信息流通更顺畅。

Neck的输入来自Backbone的三个尺度：

• P3：80×80，负责小目标检测
• P4：40×40，负责中目标检测
• P5：20×20，负责大目标检测

经过Neck融合后，输出仍然是这三个尺度，但每个尺度的特征都包含了其他尺度的信息。

4.4 Decoupled Head——解耦检测头

这是YOLOv8和YOLOv5最大的区别之一。YOLOv5用的是耦合检测头，分类和回归共享一个特征图。YOLOv8改成了解耦检测头，分类和回归各走各的路。

为什么要解耦？

你想想看，分类任务关注的是“这是什么”，回归任务关注的是“它在哪里”。这两个任务对特征的需求不一样。分类需要更语义化的特征，回归需要更位置敏感的特征。硬把它们绑在一起，反而互相拖累。

Decoupled Head的结构：

分支	结构	输出
分类分支	Conv → Conv → Conv	类别概率（如：缺陷类别）
回归分支	Conv → Conv → Conv	边界框坐标（x, y, w, h）

每个分支都包含两个卷积层，最后输出各自的结果。注意，回归分支的输出还需要经过Distribution Focal Loss（DFL）处理，把坐标值离散化，提高回归精度。

class Detect(nn.Module):
    def __init__(self, nc=80, ch=()):
        super().__init__()
        self.nc = nc  # 类别数
        self.nl = len(ch)  # 检测层数（3层）
        self.cv2 = nn.ModuleList(
            nn.Sequential(Conv(x, c*4, 3), Conv(c*4, c*4, 3), nn.Conv2d(c*4, 4*16, 1)) 
            for x, c in zip(ch, (max(x, 16) for x in ch)))
        self.cv3 = nn.ModuleList(
            nn.Sequential(Conv(x, c*4, 3), Conv(c*4, c*4, 3), nn.Conv2d(c*4, self.nc, 1)) 
            for x, c in zip(ch, (max(x, 16) for x in ch)))

    def forward(self, x):
        for i in range(self.nl):
            x[i] = torch.cat((self.cv2[i](x[i]), self.cv3[i](x[i])), 1)
        return x

4.5 本章小结

YOLOv8的网络结构，说白了就是三个关键词：C2f（更丰富的梯度流）、SPPF（更高效的感受野扩展）、Decoupled Head（分类回归各司其职）。

我个人觉得，理解这些设计思想比背代码更重要。你想想看，如果哪天你要自己设计一个检测模型，这些模块就是你的“乐高积木”。知道每块积木的用途，才能搭出最适合自己场景的模型。