别再死记硬背YAML了！手把手带你拆解YOLOv5s的Backbone网络结构（附代码逐行解析）

别再死记硬背YAML了！手把手带你拆解YOLOv5s的Backbone网络结构（附代码逐行解析）

第一次打开YOLOv5的配置文件时，相信很多人都会被那一行行神秘的YAML代码弄得一头雾水。depth_multiple和width_multiple到底如何影响网络结构？[-1, 3, C3, [128]]这样的配置行又该如何解读？本文将带你像调试代码一样，逐行拆解YOLOv5s的Backbone配置，让你真正理解每一行YAML背后的网络构建逻辑。

1. 从配置文件到网络结构：核心参数解析

在YOLOv5的模型配置中，有三个关键参数控制着整个网络的结构：

# Parameters nc: 80 # 类别数 depth_multiple: 0.33 # 深度系数 width_multiple: 0.50 # 宽度系数

• nc（number of classes）相对容易理解，它表示模型需要检测的类别数量。但真正影响网络架构的是后面两个参数：

• depth_multiple：控制模块重复次数的缩放因子。当配置中的number值大于1时，实际模块数量 = number × depth_multiple（向下取整）

• width_multiple：控制通道数的缩放因子。所有卷积层的输出通道数 = 配置通道数 × width_multiple（向下取整）

以YOLOv5s为例，它的depth_multiple为0.33，width_multiple为0.5。这意味着相比基准模型，YOLOv5s的深度和宽度都大幅缩减，从而实现了轻量化。

2. Backbone配置行逐行解读

让我们来看YOLOv5s Backbone的完整配置：

backbone: # [from, number, module, args] [[-1, 1, Conv, [64, 6, 2, 2]], # 0-P1/2 [-1, 1, Conv, [128, 3, 2]], # 1-P2/4 [-1, 3, C3, [128]], # 2 [-1, 1, Conv, [256, 3, 2]], # 3-P3/8 [-1, 6, C3, [256]], # 4 [-1, 1, Conv, [512, 3, 2]], # 5-P4/16 [-1, 9, C3, [512]], # 6 [-1, 1, Conv, [1024, 3, 2]], # 7-P5/32 [-1, 3, C3, [1024]], # 8 [-1, 1, SPPF, [1024, 5]], # 9 ]

每一行配置都由四个部分组成：

1. from：输入来源层索引，-1表示前一层的输出
2. number：模块重复次数（受depth_multiple影响）
3. module：模块类型（Conv、C3、SPPF等）
4. args：模块参数列表

2.1 第一层卷积解析

让我们以第一行为例进行详细拆解：

[-1, 1, Conv, [64, 6, 2, 2]], # 0-P1/2

这表示：

• 输入来自前一层（-1）
• 该模块重复1次（不受depth_multiple影响）
• 模块类型是Conv（标准卷积）
• 参数列表[64, 6, 2, 2]对应：
  • 基准输出通道数：64
  • 卷积核大小：6x6
  • 步长stride：2
  • 填充padding：2

考虑width_multiple=0.5，实际输出通道数 = 64 × 0.5 = 32

我们可以用以下代码验证这一层的输出尺寸：

import torch from models.common import Conv # 模拟输入 (batch=1, channels=3, height=640, width=640) x = torch.randn(1, 3, 640, 640) # 创建卷积层 (实际输出通道=64*0.5=32) conv = Conv(3, 64, k=6, s=2, p=2) # 前向传播 out = conv(x) print(out.shape) # torch.Size([1, 32, 320, 320])

特征图尺寸计算：

output_size = (input_size - kernel_size + 2*padding) / stride + 1 = (640 - 6 + 4)/2 + 1 = 320

2.2 C3模块的配置解析

再看一个典型的C3模块配置：

[-1, 3, C3, [128]], # 2

这表示：

• 输入来自前一层（-1）
• 基准重复次数为3，实际重复次数 = 3 × 0.33 ≈ 1
• 模块类型是C3
• 参数[128]表示基准输出通道数为128，实际 = 128 × 0.5 = 64

C3模块是YOLOv5中的核心组件，它由多个Bottleneck单元组成。我们将在第3章详细解析其内部结构。

3. 关键模块的内部实现

3.1 Conv模块：不只是简单的卷积

YOLOv5中的Conv模块实际上是Conv-BN-SiLU的组合：

class Conv(nn.Module): # Standard convolution def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True): super().__init__() self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False) self.bn = nn.BatchNorm2d(c2) self.act = nn.SiLU() if act else nn.Identity() def forward(self, x): return self.act(self.bn(self.conv(x)))

几个关键点：

1. 默认使用SiLU激活函数（Swish）
2. 自动计算padding（autopad函数）
3. 支持分组卷积（groups参数）

3.2 C3模块：跨阶段部分连接

C3模块是YOLOv5对CSPNet的改进实现，其结构如下：

class C3(nn.Module): # CSP Bottleneck with 3 convolutions def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5): super().__init__() c_ = int(c2 * e) # hidden channels self.cv1 = Conv(c1, c_, 1, 1) self.cv2 = Conv(c1, c_, 1, 1) self.cv3 = Conv(2 * c_, c2, 1) self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n))) def forward(self, x): return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), 1))

C3模块的工作流程：

1. 输入分为两个分支：
   • 分支1：cv1 → n个Bottleneck → 输出1
   • 分支2：cv2 → 输出2
2. 两个分支的输出在通道维度拼接（concat）
3. 通过cv3进行特征融合

3.3 Bottleneck：残差连接的核心

Bottleneck是C3模块中的基本单元：

class Bottleneck(nn.Module): def __init__(self, c1, c2, shortcut=True, g=1, e=0.5): super().__init__() c_ = int(c2 * e) self.cv1 = Conv(c1, c_, 1, 1) self.cv2 = Conv(c_, c2, 3, 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))

当shortcut=True且输入输出通道相同时，Bottleneck会添加残差连接。这种设计：

1. 缓解了梯度消失问题
2. 保留了更多原始信息
3. 提高了特征复用率

3.4 SPPF：空间金字塔池化快速版

SPPF模块是对SPP的改进，速度更快但效果相当：

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))

SPPF通过串联不同尺度的最大池化结果，实现了多尺度特征融合，这对检测不同大小的物体特别有效。

4. 完整Backbone的数据流可视化

让我们将整个Backbone的数据流绘制出来（考虑YOLOv5s的缩放系数）：

注意：表中的"实际参数"已经考虑了width_multiple=0.5的影响，C3模块的重复次数考虑了depth_multiple=0.33的影响。

5. 实践：从配置文件生成网络结构

理解了配置规则后，我们可以编写代码将YAML配置转换为实际的PyTorch模型：

def parse_model(d, ch): layers = [] for i, (f, n, m, args) in enumerate(d['backbone']): m = eval(m) if isinstance(m, str) else m for j, a in enumerate(args): try: args[j] = eval(a) if isinstance(a, str) else a except: pass n = max(round(n * d['depth_multiple']), 1) if n > 1 else n if m in [Conv, C3, SPPF]: c1, c2 = ch[f], args[0] c2 = make_divisible(c2 * d['width_multiple'], 8) args = [c1, c2, *args[1:]] if m is C3: args.insert(2, n) n = 1 elif m is nn.BatchNorm2d: args = [ch[f]] module = m(*args) layers.append(module) ch.append(c2) return nn.Sequential(*layers), ch

关键处理步骤：

1. 解析depth_multiple和width_multiple
2. 计算实际的模块重复次数和通道数
3. 动态创建对应的PyTorch模块

在实际项目中调试YOLOv5模型时，建议在models/yolo.py的Model类构造函数中打印各层的输入输出形状，这将帮助你更直观地理解网络结构。