YOLOv5-理论部分

YOLOv5

作者: Ultralytics

论文源码: https://github.com/ultralytics/yolov5

Ultralytics：“超视觉技术” / “超视觉系统”

0. 引言

“YOLOv5 🚀 是世界上备受喜爱的视觉人工智能，代表了 Ultralytics 对未来视觉人工智能方法的开源研究，融合了数千小时的研究和开发经验中所学到的教训和最佳实践。”

---

YOLOv5 仓库是在 2020-05-18 创建的，到今天已经迭代了很多个大版本了，现在已经迭代到 v7.0 了。下表是当前 (v7.0 / v6.1) 官网贴出的关于不同大小模型以及输入尺度对应的 mAP、推理速度(Speed)、参数数量(params)以及理论计算量(FLOPs)。

1. 网络结构

YOLOv5 的网络结构主要由以下几部分组成：

1. Backbone: New CSP-Darknet53
   这是网络的主体部分。对于 YOLOv5，主干网络采用了 New CSP-Darknet53 结构，这是对先前版本中使用的 Darknet 架构的修改。
2. Neck: SPPF, New CSP-PAN
   这部分连接了主干网络和头部。在 YOLOv5 中，使用了 SPPF 和 New CSP-PAN 结构。
3. Head: YOLOv3 Head
   这部分负责生成最终的输出。YOLOv5 使用 YOLOv3 头部来实现这一目标。

关模型结构的详细信息可以在 yolov5l.yaml 中找到

下面是官方根据 yolov5l.yaml 绘制的网络整体结构，YOLOv5 不同大小(n, s, m, l, x)的网络整体架构都是一样的，只不过会在每个子模块中采用不同的深度和宽度，分别应对 .yaml 文件中的 depth_multiple 和 width_multiple 参数。还需要注意一点，官方除了 n, s, m, l, x 版本外还有 n6, s6, m6, l6, x6，区别在于后者是针对更大分辨率的图片比如 $1280\times 1280$，当然结构上也有些差异，后者会 64 倍下采样，4 个预测特征层，而前者只会下采样到 32 倍且采用 3 个预测特征层。本文只讨论前者。

高清大图：yolov5-arch.png

注意：YOLOv5 相对于其前身引入了一些小的改变：

• 早期版本中的 Focus 结构被替换为 6x6 Conv2d 结构。这个变化提高了效率 #4825。
• SPP 结构被替换为 SPPF。这个改变使处理速度增加了一倍多。
• 要测试 SPP 和 SPPF 的速度，可以使用以下代码：

展开/折叠

import time
import torch
import torch.nn as nn


class SPP(nn.Module):
    def __init__(self):
        super().__init__()
        self.maxpool1 = nn.MaxPool2d(5, 1, padding=2)
        self.maxpool2 = nn.MaxPool2d(9, 1, padding=4)
        self.maxpool3 = nn.MaxPool2d(13, 1, padding=6)

    def forward(self, x):
        o1 = self.maxpool1(x)
        o2 = self.maxpool2(x)
        o3 = self.maxpool3(x)
        return torch.cat([x, o1, o2, o3], dim=1)


class SPPF(nn.Module):
    def __init__(self):
        super().__init__()
        self.maxpool = nn.MaxPool2d(5, 1, padding=2)

    def forward(self, x):
        o1 = self.maxpool(x)
        o2 = self.maxpool(o1)
        o3 = self.maxpool(o2)
        return torch.cat([x, o1, o2, o3], dim=1)


def main():
    input_tensor = torch.rand(8, 32, 16, 16)
    spp = SPP()
    sppf = SPPF()
    output1 = spp(input_tensor)
    output2 = sppf(input_tensor)

    print(torch.equal(output1, output2))

    t_start = time.time()
    for _ in range(100):
        spp(input_tensor)
    print(f"SPP time: {time.time() - t_start}")

    t_start = time.time()
    for _ in range(100):
        sppf(input_tensor)
    print(f"SPPF time: {time.time() - t_start}")


if __name__ == '__main__':
    main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

True
SPP time: 0.5373051166534424
SPPF time: 0.20780706405639648
1
2
3

通过对比可以发现，两者的计算结果是一模一样的，但 SPPF 比 SPP 计算速度快了不止两倍，快乐翻倍 😂。

1.1 Backbone

通过与上篇博文讲的 YOLOv4 对比，其实YOLOv5 在 Backbone 部分没太大变化。但是 YOLOv5 在 v6.0 版本后相比之前版本有一个很小的改动，把网络的第一层（原来是 Focus 模块）换成了一个 $6\times 6$ 大小的卷积层(nn.Conv2d)。两者在理论上其实等价的，但是对于现有的一些 GPU 设备（以及相应的优化算法）使用 $6\times 6$ 大小的卷积层比使用 Focus 模块更加高效。详情可以参考这个issue #4825 -> Is the Focus layer equivalent to a simple Conv layer?。

下图是原来的 Focus 模块(和之前 Swin Transformer 中的 Patch Merging 类似)，将每个 $2\times 2$ 的相邻像素划分为一个 patch，然后将每个 patch 中相同位置（同一颜色）像素给拼在一起就得到了 4 个 feature map，然后在接上一个 $3\times 3$ 大小的卷积层。这和直接使用一个 $6\times 6$ 大小的卷积层等效。

1.2 Neck

YOLOv5 在 Neck 部分的变化还是相对较大的，首先是将 SPP 换成成了 SPPF（Spatial Pyramid Pooling - Fast, 是 Glenn Jocher 自己设计的），两者的作用是一样的，但后者效率更高。

1.2.1 SPP (Spatial Pyramid Pooling，空间金字塔池化)

SPP 结构如下图所示，是将输入并行通过多个不同大小的 MaxPool，然后做进一步融合，能在一定程度上解决目标多尺度问题。

每一个分支得到 feature map 的 shape 都一样 , 最后会实现通道数 $\times 4$。

关于 SPP 的介绍可以看文章：[语义分割] ASPP不同版本对比（DeepLab、DeepLab v1、DeepLab v2、DeepLab v3、DeepLab v3+、LR-ASPP）

1.2.2 SPPF (Spatial Pyramid Pooling Fast，快速空间金字塔池化)

而 SPPF 结构是将输入串行通过多个 $5\times 5$ 大小的 MaxPool 层，这里需要注意的是串行两个 $5\times 5$ 大小的 MaxPool 层是和一个 $9\times 9$ 大小的 MaxPool 层计算结果是一样的，串行三个 $5\times 5$ 大小的 MaxPool 层是和一个 $13\times 13$ 大小的 MaxPool 层计算结果是一样的。

SPPF 最后同样会实现通道数 $\times 4$

SPPF的代码如下:

class SPPF(nn.Module):
    # Spatial Pyramid Pooling - Fast (SPPF) layer for YOLOv5 by Glenn Jocher
    def __init__(self, c1, c2, k=5):  # equivalent to SPP(k=(5, 9, 13))
        super().__init__()
        c_ = c1 // 2  # hidden channels
        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)  # 先通过CBL进行通道数的减半
        with warnings.catch_warnings():
            warnings.simplefilter('ignore')  # suppress torch 1.9.0 max_pool2d() warning
            y1 = self.m(x)
            y2 = self.m(y1)
            # 上述两次最大池化
            # 将原来的x,一次池化后的y1,两次池化后的y2,3次池化的self.m(y2)先进行拼接，然后再CBL
            return self.cv2(torch.cat([x, y1, y2, self.m(y2)], 1))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1.2.4 CSP-PAN（跨阶段部分网络-路径聚合网络）

前置小知识

• CSP: Cross-Stage Partial Network，跨阶段部分网络
• PAN: Path Aggregation Network，路径聚合网络

   Input                      Input
     |                          |
  Backbone                   Backbone
     |                          |
    Neck                      Neck
   /    \                  /     \
Part A   Part B         Part A   Part B
   \     /                  \     /
 Concatenation              Concatenation
     |                          |
    Head                       Head
     |                          |
   Output                     Output

  Fig.1 CSP                 Fig.2 PAN
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在这个示意图中：

• CSP 结构将输入通过主干网络（Backbone）分成两部分，分别经过两个部分（Part A 和 Part B）的处理，然后再将它们连接在一起（Concatenation）。接下来，特征图进入颈部（Neck），最后到达头部（Head），产生最终的输出。这种结构有助于提高模型的性能和准确性。
• PAN 结构将输入通过主干网络（Backbone），然后进入颈部（Neck），颈部后分成两部分，分别通过两个部分（Part A 和 Part B）的处理，最后再次合并（Concatenation）后经过头部（Head）生成输出。

---

在 Neck 部分另外一个不同点就是 New CSP-PAN 了，在 YOLOv4 中，Neck 的 PAN 结构是没有引入 CSP 结构的，但在 YOLOv5 中作者在 PAN 结构中加入了 CSP。详情见上面的网络结构图，每个 C3 模块里都含有 CSP 结构。

CSP 结构是在 CSPNet（Cross Stage Partial Network）论文中提出的，CSPNet 作者说在目标检测任务中使用 CSP 结构有如下好处：

• Strengthening learning ability of a CNN：增强 CNN 的学习能力
• Removing computational bottlenecks：移除计算瓶颈
• Reducing memory costs：减少 MACs

CSP 的加入可以: 减少网络的计算量以及对显存的占用，同时保证网络的能力不变或者略微提升。CSP 结构的思想参考原论文中绘制的 CSPDenseNet，进入每个 stage（一般在下采样后）先将数据划分成俩部分，如下图左图所示的 Part1 和 Part2。

左边的图是 CSPDenseNet（来源于 CSPNet 论文）。CSP 结构会将网络分为两个部分。Part2 分支首先会经过一系列的 Block（这里是 DenseBlock），最后经过 Transition，得到输出后再与 Part1 上的输出进行 Transition 融合。

1.3 Head

在 Head 部分，YOLOv3, v4, v5 都是一样的。

2. 数据增强策略

在 YOLOv5 代码里，关于数据增强策略还是挺多的，这里简单罗列部分方法：

2.1 Mosaic，马赛克增强

核心思想：将 4 张图片拼成一张图片。

2.2 Copy Paste，复制粘贴增强

将部分目标随机的粘贴到图片中，前提是数据要有分割数据才行，即每个目标的实例分割信息。下面是 Copy paste 原论文中的示意图。

可以理解为是升级版的 Mosaic

2.3 Random affine，随机放射变换 (Rotation, Scale, Translation and Shear)

随机进行仿射变换，但根据配置文件里的超参数发现只使用了 Scale (缩放)和 Translation (平移)。

参考资料：数据增强中的仿射变换：旋转，缩放，平移以及错切(shear)

2.4 MixUp，混合数据增强

Mixup 就是将两张图片按照一定的透明度融合在一起，具体有没有用不太清楚，毕竟没有论文，也没有消融实验。代码中只有较大的模型才使用到了 MixUp，而且每次只有 $10\%$ 的概率会使用到。

2.5 Albumentations

主要是做些滤波、直方图均衡化以及改变图片质量等等，代码里写的只有安装了 albumentations 包才会启用，但在项目的 requirements.txt 文件中 albumentations 包被注释掉了的，所以 默认不启用。

# Extras ----------------------------------------------------------------------
# ipython  # interactive notebook
# mss  # screenshots
# albumentations>=1.0.3
# pycocotools>=2.0.6  # COCO mAP
1
2
3
4
5

“Albumentations” 这个名称通常不会被翻译，因为它是一个特定的计算机视觉数据增强库的名称。如果需要提到这个库，通常会直接保留原名 “Albumentations”。

Albumentations官方文档: https://albumentations.readthedocs.io/en/latest/

Albumentations 基本介绍

albumentations 是一个给予 OpenCV 的快速训练数据增强库，拥有非常简单且强大的可以用于多种任务（分割、检测）的接口，易于定制且添加其他框架非常方便。

它可以对数据集进行逐像素的转换，如:

1. 模糊
2. 下采样
3. 高斯造点
4. 高斯模糊
5. 动态模糊
6. RGB转换
7. 随机雾化
8. 等

也可以进行空间转换（同时也会对目标进行转换），如:

• 裁剪
• 翻转
• 随机裁剪等。

github 及其示例地址如下：

GitHub： https://github.com/albumentations-team/albumentations
示例：https://github.com/albumentations-team/albumentations_examples

参考: https://zhuanlan.zhihu.com/p/107399127/

2.6 Augment HSV(Hue, Saturation, Value)

随机调整色度，饱和度以及明度。

2.7 Random horizontal flip，随机水平翻转

3. 训练策略

在 YOLOv5 源码中使用到了很多训练的策略，这里简单总结几个：

1. Multi-scale training(0.5~1.5x)（多尺度训练）：假设设置输入图片的大小为 $640\times 640$，训练时采用尺寸是在 $0.5\times 640\sim 1.5\times 640$ 之间随机取值，注意取值时取得都是 32 的整数倍（因为网络会最大下采样 32 倍）。
2. AutoAnchor(For training custom data)（自动聚类生产 Anchor 模板）：训练自己数据集时可以根据自己数据集里的目标进行重新聚类生成 Anchors 模板。
3. Warmup and Cosine LR scheduler（带有 Warmup 的余弦调度器）：训练前先进行 Warmup 热身，然后在采用 Cosine 学习率下降策略。
4. EMA(Exponential Moving Average)（指数移动平均）：可以理解为给训练的参数（模型参数）加了一个动量，让它更新过程更加平滑。
5. Mixed precision（混合精度训练）：能够减少显存的占用并且加快训练速度，前提是GPU硬件支持。
6. Evolve hyper-parameters（超参数优化）：没有炼丹经验的人勿碰，保持默认就好。

Evolve Hyper-parameters 简介

“Evolve hyper-parameters” 指的是在机器学习和深度学习中，通过优化算法或搜索策略来动态地调整模型的超参数（Hyperparameters），以提高模型的性能和泛化能力。超参数是指那些不是由模型自动学习而是需要手动设置的参数，它们通常用于控制模型的结构、学习率、正则化等方面。

“Evolve” 表示超参数可以通过不断地尝试不同的值来进行迭代调整，以找到最优的超参数组合。这种过程通常涉及超参数搜索和优化技术，如网格搜索、随机搜索、贝叶斯优化等。

通过进化超参数，可以实现以下目标：

1. 提高模型性能：通过找到最佳的超参数组合，模型的性能通常会得到显著的提升。这包括准确性、泛化能力和训练效率。

2. 防止过拟合：适当的超参数选择可以帮助防止模型过拟合训练数据，从而提高模型的泛化能力。

3. 节省时间和资源：有效的超参数优化可以节省训练时间和计算资源，因为它可以避免不必要的试验和训练周期。

4. 适应不同任务：通过调整超参数，可以使同一模型适应不同类型的任务，而无需重新设计整个模型。

总之，“evolve hyper-parameters” 意味着通过智能的搜索和优化技术来改进模型的性能和适应性，而不是仅仅手动选择固定的超参数值。这是机器学习和深度学习中重要的实践，以实现更好的结果。

4. 其他

4.1 损失计算

YOLOv5 的损失主要由三个部分组成：

1. Classes loss（分类损失）: 采用的是 BCE loss，注意只计算正样本的分类损失。
2. Objectness loss（obj 损失(置信度损失)）: 采用的依然是 BCE loss，注意这里的 obj 指的是网络预测的目标边界框与 Ground True 的 CIoU。这里计算的是所有样本的 obj 损失。
3. Location loss（定位损失）: 采用的是 CIoU loss，注意只计算正样本的定位损失。

$${\mathcal{L}}_{all}={\lambda }_1{\mathcal{L}}_{\mathrm{cls}}+{\lambda }_2{\mathcal{L}}_{\mathrm{obj}}+{\lambda }_3{\mathcal{L}}_{\mathrm{loc}}$$

其中， ${\lambda }_1,{\lambda }_2,{\lambda }_3$ 为平衡系数。

4.2 平衡不同尺度的损失

这里是指针对三个预测特征层（P3, P4, P5）上的 obj损失 采用不同的权重。在源码中，针对预测小目标的预测特征层（P3）采用的权重是 4.0，针对预测中等目标的预测特征层（P4）采用的权重是 1.0，针对预测大目标的预测特征层（P5）采用的权重是 0.4，作者说这是针对 COCO 数据集设置的超参数。

$${\mathcal{L}}_{\mathrm{obj}}=4.0\times {\mathcal{L}}_{\mathrm{obj}}^{\mathrm{small}}+1.0\times {\mathcal{L}}_{\mathrm{obj}}^{\mathrm{medium}}+0.4\times {\mathcal{L}}_{\mathrm{large}}^{\mathrm{small}}$$

4.3 消除 Grid 敏感度 (Eliminating grid sensitivity)

在 YOLOv4 中有提到过，主要是调整预测目标中心点相对 Grid 网格的左上角偏移量。下图是 YOLOv2 和 YOLOv3 的计算公式。

其中：

• $t_x$ 是网络预测的目标中心 $x$ 坐标偏移量（相对于网格的左上角）
• $t_y$ 是网络预测的目标中心 $y$ 坐标偏移量（相对于网格的左上角）
• $c_x$ 是对应网格左上角的 $x$ 坐标
• $c_y$ 是对应网格左上角的 $y$ 坐标
• $\sigma$ 是 sigmoid 激活函数，将预测的偏移量限制在0到1之间，即预测的中心点不会超出对应的 Grid Cell 区域

关于预测目标中心点相对 Grid 网格左上角 $(c_x,c_y)$ 偏移量为 $\sigma (t_x),\sigma (t_y)$。YOLOv4 的作者认为这样做不太合理，比如当真实目标中心点非常靠近网格的左上角点 $\sigma (t_x)$ 和 $\sigma (t_y)$ 应该趋近与 0 或者右下角点（$\sigma (t_x)$ 和 $\sigma (t_y)$ 应该趋近与 1）时，网络的预测值需要负无穷或者正无穷时才能取到，而这种很极端的值网络一般无法达到。

为了解决这个问题，作者对偏移量进行了缩放从原来的 $(0,1)$ 缩放到 $(-0.5,1.5)$ 这样网络预测的偏移量就能很方便达到 0 或 1，故最终预测的目标中心点 $b_x,b_y$ 的计算公式为：

$$\begin{gathered} b_x=\left(2\cdot \sigma (t_x)-0.5\right)+c_x \\ {b}_y=\left(2\cdot \sigma (t_y)-0.5\right)+c_y \end{gathered}$$

下面是霹雳吧啦Wz绘制的 $y=\sigma (x)$ 对应sigma曲线和 $y=2\cdot \sigma (x)-0.5$ 对应scale曲线。

很明显通过引入缩放系数 scale 以后，$x$ 在同样的区间内，$y$ 的取值范围更大，或者说，$y$ 对 $x$ 更敏感了。并且偏移的范围由原来 $(0,1)$ 调整到了 $(-0.5,1.5)$。

$b_w,b_h$ 保持 YOLOv3 的策略不变。

---

在 YOLOv5 中除了调整预测 Anchor 相对 Grid 网格左上角 $(c_x,c_y)$ 偏移量以外，还调整了预测目标高宽的计算公式，之前是：

$$\begin{gathered} b_w=p_w\cdot e^{t_w} \\ {b}_h=p_h\cdot e^{t_h} \end{gathered}$$

在 YOLOv5 中被作者调整为：

$$\begin{gathered} b_w=p_w\cdot (2\cdot \sigma (t_w){)}^2 \\ {b}_h=p_h\cdot (2\cdot \sigma (t_h){)}^2 \end{gathered}$$

作者 Glenn Jocher 对此修改的原话如下，也可以参考issue #471：

The original yolo/darknet box equations have a serious flaw. Width and Height are completely unbounded as they are simply out=exp(in), which is dangerous, as it can lead to runaway gradients, instabilities, NaN losses and ultimately a complete loss of training.

原始的 YOLO/Darknet box 公式存在严重缺陷。宽度和高度完全无限制，因为它们仅为 out = exp(in)，这是危险的，因为它可能导致梯度失控、不稳定、NaN 损失，最终完全失去训练的能力。

作者的大致意思是，原来的计算公式并没有对预测目标宽高做限制，这样可能出现梯度爆炸，训练不稳定等问题。下图是修改前 $y=e^x$ 和修改后 $y=(2\cdot \sigma (x){)}^2$ （相对Anchor宽高的倍率因子）的变化曲线， 很明显调整后倍率因子被限制在 $(0,4)$ 之间。

4.4 匹配样本 (Build Targets)

之前在 YOLOv4 介绍中有讲过该部分内容，其实 YOLOv5 也差不多。主要的区别在于 GT Box 与 Anchor Templates 模板的匹配方式。在 YOLOv4 中是直接将每个 GT Box 与对应的 Anchor Templates 模板计算 IoU，只要 IoU 大于设定的阈值就算匹配成功。但在 YOLOv5 中，作者先去计算每个 GT Box 与对应的 Anchor Templates 模板的高宽比例，即：

$$\begin{gathered} r_w=\frac{w_{gt}}{w_{at}} \\ {r}_h=\frac{h_{gt}}{h{w}_{at}} \end{gathered}$$

然后统计这些比例和它们倒数之间的最大值，这里可以理解成计算 GT Box 和 Anchor Templates 分别在宽度以及高度方向的最大差异（当相等的时候比例为 1，差异最小）：

$$\begin{gathered} r_w^{\max }=\max (r_w,\frac{1}{r_w}) \\ {r}_h^{\max }=\max (r_h,\frac{1}{r_h}) \end{gathered}$$

接着统计 $r_w^{\max }$ 和 $r_h^{\max }$ 之间的最大值，即宽度和高度方向差异最大的值：

$$r^{\max }=\max (r_w^{\max },r_h^{\max })$$

如果 GT Box 和对应的 Anchor Template 的 $r^{max}$ 小于阈值 anchor_t（在源码中默认设置为 4.0），即 GT Box 和对应的 Anchor Template 的高、宽比例相差不算太大，则将 GT Box 分配给该 Anchor Template 模板。为了方便大家理解，可以看下图。

假设对某个 GT Box 而言，其实只要 GT Box 满足在某个 Anchor Template 宽和高的 $\times 0.25$ 倍和 $\times 4.0$ 倍之间就算匹配成功。

剩下的步骤和 YOLOv4 中一致：

将 GT 投影到对应预测特征层上，根据 GT 的中心点定位到对应 Cell，注意图中有三个对应的 Cell。因为网络预测中心点的偏移范围已经调整到了 $(-0.5,1.5)$，所以按理说只要 Grid Cell 左上角点距离 GT 中心点在 $(-0.5,1.5)$ 范围内它们对应的 Anchor 都能回归到 GT 的位置处。这样会让正样本的数量得到大量的扩充。

则这三个 Cell 对应的 AT2 和 AT3 都为正样本。

还需要注意的是，YOLOv5 源码中扩展 Cell 时只会往上、下、左、右 四个方向 扩展，不会往左上、右上、左下、右下方向扩展。

下面又给出了一些根据 $G{T}_x^{center}$, $G{T}_y^{center}$ 的位置扩展的一些 Cell 案例，其中 %1 表示取余并保留小数部分。

到此，YOLOv5 相关理论的内容基本上都分析完了。

知识来源

1. YOLOv5网络详解
2. YOLOv5网络详解