YOLO: 只若初见

2024-09-23

YOLO(You only Live Once) 你只活一次

You Only Look Once

YOLO 模型首次由 Joseph Redmon 等人于 2015 年提出，其全称是 You Only Look Once, 指只需要浏览一次就可以识别出图中的物体的类别和位置。这种只需要看一次的方式被称为 Region-free 方法，以往的 Region-based 方法需要将边框回归和 softmax 分类分开进行，而 YOLO 不需要提前找到可能存在目标的 Region, 这种通过直接回归的方式可以同时获取到物体的位置信息和类别信息，显著提高了推理检测的速度。

一个典型的 Region-base 方法的流程是这样的：先通过计算机图形学或深度学习的方法，找出图片中若干个可能存在物体的区域，将这些区域裁剪下来，放入一个图片分类器中，再由分类器分类。我们将这种 Region-based 方法方法称为两阶段 (2-stage) 方法，而像 YOLO 这样的 Region-free 方法只需要一次扫描，所以也被称为单阶段 (1-stage) 模型。

YOLOv1 通过同时检测所有的边界框，统一了物体检测步骤。为了实现这一目标，YOLO 将输入图像划每个边界框的预测由五个值组成：Pc、bx、by、bh、bw ，其中 Pc 是 bbox (bounding box) 的置信度分数，反映了模型对 bbox 包含物体的置信度以及 bbox 的精确程度。bx 和 by 坐标是方框相对于网格单元中心的偏移量，bh 和 bw 是方框相对于整个图像的高度和宽度。YOLO 的输出是一个 S×S×(B×5+C) 的张量，其中 SxS 是网格单元的个数，B 是每个网格单元中初始框的个数，而 C 则是最终分类的类别数量。

YOLO 系模型结构由骨干，颈部和头部三部分组成，其中骨干 Backbone 用于提取特征，颈部 Neck 用于特征增强，头部 Head 用于 bbox 预测。YOLOv1 的推理过程可分为三步：

将输入图片缩放至 448x448x3 大小；
经过 24 个卷积层 + 2 个全连接层组成的 backbone 网络提取特征图，把提取到的特征图送入两层全连接层，最终输出 7x7x30 大小的特征图；
用非最大抑制（NMS）去除重复的检测结果。

骨干网络输出的张量大小 7x7x30 是因为 YOLOv1 使用了 7x7 的网格划分，其中每个网格预测 2 个边框。30 个通道维度包含了每个类别的概率 (20) + 两个边界框 (2) x 置信度和位置信息 (1+4).

这里输出的的置信度为 confience = Pr * IOU, 其中 Pr 表示目标是否在框内，当目标在框内时，Pr 取 1, 此时 confidence 就是 IOU 的值，如果目标不在框内，Pr 值取 0, confidence 值也就是 0. 最终每个预测框的分数为 Score = confidence * C, 使用这个得分进行后续的非极大值抑制去除多余的检测框。

YOLOv1 的不足之处在于每一个网格仅 2 个预测框且只有一类，所以当存在多物体密集挨着的时候或者目标较小的时候，检测效果不好。

YOLO 系列

YOLO 模型发布后吸引了大批研究人员参与后续的改良优化，各种 YOLO 系模型百花齐放。

YOLO Time

YOLOv2 与 YOLOv3

YOLOv1 发布一年之后 Joseph Redmon 等人提出改进后的 YOLOv2 版本，这个模型的主要改进如下：

使用 Darknet-19 作为骨干网络，采用全卷积架构，去掉了原模型最后的全连接层；
借鉴 Faster-RCNN 的思想，引入了锚框 (Anchor boxes) 的概念，将目标框的位置预测由直接预测坐标调整为预测偏移量，大大降低了预测难度，提升了预测准确性。
引入 PassThrough 的概念，连接了不同层级的特征，进一步加强特征表达；
损失函数优化调整，加入了适应权重的损失函数，使得模型更加关注难以训练的样本，提高了检测准确性；

2018 年 Joseph Redmon 等人再次提出进一步改进的 YOLOv3 模型，这个模型主要改动如下：

使用 Darknet-53 作为骨干网络，引入了残差连接（Residual connections）和批归一化（Batch Normalization）等技术，使得网络结构能进一步加深；
借鉴了特征金字塔的思想，在三个不同的尺寸上分别进行预测。

出于对模型被负面使用的担忧，Joseph Redmon 这位 YOLO 之父在 YOLOv3 发布后不久宣布离开 CV 学术界，深藏身与名。

其他 YOLO 系模型

自 2020 年起，针对 YOLO 改进的模型如雨后春笋般出现，其中一些重要的改进有：

YOLOv4 由 YOLO 社区元老 Alexey Bochkovskiy 于 2020 年发布，这个版本将 CSP 引入骨干网络，采用了 SPP 空间金字塔来扩大感受野，并引入了 Mish 激活函数和 Mosaic 数据增强等一系列 trick 方法。
YOLOv5 和 YOLOv8 由 Ultralytics 发布，其中 YOLOv5 是首个基于 PyTorch 而非 Darknet 的 YOLO 实现。Ultralytics 提供了不同尺度的预训练模型，旨在提供一个开箱即用的 YOLO 框架，不过 Ultralytics 并未发表对应的论文。
YOLOX 从 Anchor-based 回到 Anchor-free, 去除了 YOLOv2 时加入的锚框，精简了计算量并增强了模型泛化能力，之后的 YOLO 系模型基本上都采用了 Anchor-free 的结构。
YOLO-World LLM 的爆发推动了像 Grounding DINO 这样的开集检测模型的出现，相比基于 Transformer 的 Grounding DINO, 2024 年的 YOLO-World 更为轻量，更能满足推理的实时性要求。

Ultralytics

得益于其模块化的设计和便捷的封装，Ultralytics 在 2020 年发布的 YOLOv5 和 2023 年的 YOLOv8 在社区中的反响很高，尽管这两个版本的 YOLO 并没有对架构做出太多调整，但都结合了一些最新的 trick, 能以很小的计算代价获得相当可观的精度，尤其在一些边缘计算的场景下表现优良。Ultralytics 还积极跟进 YOLO 的各种发展，完成了 YOLOv10, YOLO-World 等模型的实现，大有一统 YOLO 系列的趋势。

YOLOv8

Ultralytics 的 YOLOv8 提供了 5 个尺度的预训练模型，分别是微小 (nano), 小 (small), 中等 (middle), 大 (large) 和超大 (xlarge), 具体参数参考如下：

模型	层数	参数	梯度	GFLOPs
n	225	3157200	3157184l	8.9
s	225	11166560	11166544	28.8
m	295	25902640	25902624	79.3
l	365	43691520	43691504	165.7
x	365	68229648	68229632	258.5

下为 Ultralytics YOLOv8 的结构图。图源 RangeKing

YOLOv8 Arch

YOLOv8n 在 Ultralytics 中的具体结构如下：

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

# YOLOv8.0n head
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]]   # cat backbone P4
  - [-1, 3, C2f, [512]]         # 12

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 4], 1, Concat, [1]]   # cat backbone P3
  - [-1, 3, C2f, [256]]         # 15 (P3/8-small)

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 12], 1, Concat, [1]]  # cat head P4
  - [-1, 3, C2f, [512]]         # 18 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 9], 1, Concat, [1]]   # cat head P5
  - [-1, 3, C2f, [1024]]        # 21 (P5/32-large)

  - [[15, 18, 21], 1, Detect, [nc]] # Detect(P3, P4, P5)

Ultralytics 模型的每层网络由 4 个参数定义，也就是第一行注释中的 from, repeats, module 和 args.

第一个参数 from 是输入的张量维度，值 -1 表示使用上一层的输出大小作为本层的输入大小；第二个 repeats 参数表示该层需要重复进行的次数；第三个参数指明本层使用的卷积块类型，最后一个参数是卷积块的初始化值，分别是 [out_chanel, kernel_size, stride].

在主干网络中，最后生成的特征图切片大小为输入大小的 1/32, 所以输入图像必须被初始化为 32 的整数倍大小。

第 2, 4, 6 层中出现的 C2f 卷积块由一个CSP层和两个卷积层组成，f表示快速实现，其主要作用是转换输入张量的通道数并输出到不同的分支上，再通过融合这些通道的特征来增强模型的非线性建模能力。

class C2f(nn.Module):
    """Faster Implementation of CSP Bottleneck with 2 convolutions."""

    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
        """Initializes a CSP bottleneck with 2 convolutions and n Bottleneck blocks for faster processing."""
        super().__init__()
        self.c = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, 2 * self.c, 1, 1)
        self.cv2 = Conv((2 + n) * self.c, c2, 1)  # optional act=FReLU(c2)
        self.m = nn.ModuleList(Bottleneck(self.c, self.c, shortcut, g, k=((3, 3), (3, 3)), e=1.0) for _ in range(n))

    def forward(self, x):
        """Forward pass through C2f layer."""
        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))

    def forward_split(self, x):
        """Forward pass using split() instead of chunk()."""
        y = list(self.cv1(x).split((self.c, self.c), 1))
        y.extend(m(y[-1]) for m in self.m)
        return self.cv2(torch.cat(y, 1))

class Bottleneck(nn.Module):
    """Standard bottleneck."""

    def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5):
        """Initializes a standard bottleneck module with optional shortcut connection and configurable parameters."""
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, k[0], 1)
        self.cv2 = Conv(c_, c2, k[1], 1, g=g)
        self.add = shortcut and c1 == c2

    def forward(self, x):
        """Applies the YOLO FPN to input data."""
        return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))

骨干网络中最后一层是快速空间金字塔池化层 (SPPF), 该层是空间金字塔池化层 (SPP) 的一个改进实现，该层的主要作用是提取并融合不同尺度下的特征，增强模型对不同尺度目标的识别能力。

class SPPF(nn.Module):
    """Spatial Pyramid Pooling - Fast (SPPF) layer for YOLOv5 by Glenn Jocher."""

    def __init__(self, c1, c2, k=5):
        """
        Initializes the SPPF layer with given input/output channels and kernel size.

        This module is 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):
        """Forward pass through Ghost Convolution block."""
        y = [self.cv1(x)]
        y.extend(self.m(y[-1]) for _ in range(3))
        return self.cv2(torch.cat(y, 1))

YOLO11

2024 年 10 月 ultralytics 发布了最新的 YOLO 11, 这个版本相较于 v8 有更深的网络层，但在参数量上有所减少。

模型	层数	参数	梯度	GFLOPs
n	319	2624080	2624064	6.6
s	319	9458752	9458736	21.7
m	409	20114688	20114672	68.5
l	631	25372160	25372144	87.6
x	631	56966176	56966160	196.0

YOLO 11 的模型结构如下：

# YOLO11n backbone
backbone:
  # [from, repeats, module, args]
  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
  - [-1, 2, C3k2, [256, False, 0.25]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 2, C3k2, [512, False, 0.25]]
  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  - [-1, 2, C3k2, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  - [-1, 2, C3k2, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]] # 9
  - [-1, 2, C2PSA, [1024]] # 10

# YOLO11n head
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  - [-1, 2, C3k2, [512, False]] # 13

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 13], 1, Concat, [1]] # cat head P4
  - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 10], 1, Concat, [1]] # cat head P5
  - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)

  - [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)

可以看到这个结构和 v8 相比并没有多大改动，主要是将 v8 的C2f块全部替换为了C3k2块，并在原骨干层最后的金字塔池化层后添加了一个C2PSA层。

C3k2块继承自C2f块，这里的C3k块由一个CSP层和三个卷积层组成，k表示其卷积核使用自定义 size.

class C3k2(C2f):
    """Faster Implementation of CSP Bottleneck with 2 convolutions."""

    def __init__(self, c1, c2, n=1, c3k=False, e=0.5, g=1, shortcut=True):
        """Initializes the C3k2 module, a faster CSP Bottleneck with 2 convolutions and optional C3k blocks."""
        super().__init__(c1, c2, n, shortcut, g, e)
        self.m = nn.ModuleList(
            C3k(self.c, self.c, 2, shortcut, g) if c3k else Bottleneck(self.c, self.c, shortcut, g) for _ in range(n)
        )

C2PSA块由一系列PSA块组成，旨在加强模型对于位置信息的自注意力。

class C2PSA(nn.Module):

    def __init__(self, c1, c2, n=1, e=0.5):
        """Initializes the C2PSA module with specified input/output channels, number of layers, and expansion ratio."""
        super().__init__()
        assert c1 == c2
        self.c = int(c1 * e)
        self.cv1 = Conv(c1, 2 * self.c, 1, 1)
        self.cv2 = Conv(2 * self.c, c1, 1)

        self.m = nn.Sequential(*(PSABlock(self.c, attn_ratio=0.5, num_heads=self.c // 64) for _ in range(n)))

    def forward(self, x):
        """Processes the input tensor 'x' through a series of PSA blocks and returns the transformed tensor."""
        a, b = self.cv1(x).split((self.c, self.c), dim=1)
        b = self.m(b)
        return self.cv2(torch.cat((a, b), 1))

其中PSA(Position-Sensitive Attention)块的实现如下：

class PSA(nn.Module):

    def __init__(self, c1, c2, e=0.5):
        """Initializes the PSA module with input/output channels and attention mechanism for feature extraction."""
        super().__init__()
        assert c1 == c2
        self.c = int(c1 * e)
        self.cv1 = Conv(c1, 2 * self.c, 1, 1)
        self.cv2 = Conv(2 * self.c, c1, 1)

        self.attn = Attention(self.c, attn_ratio=0.5, num_heads=self.c // 64)
        self.ffn = nn.Sequential(Conv(self.c, self.c * 2, 1), Conv(self.c * 2, self.c, 1, act=False))

    def forward(self, x):
        """Executes forward pass in PSA module, applying attention and feed-forward layers to the input tensor."""
        a, b = self.cv1(x).split((self.c, self.c), dim=1)
        b = b + self.attn(b)
        b = b + self.ffn(b)
        return self.cv2(torch.cat((a, b), 1))

[ ML ]

#DL #YOLO