张会挽's Blog

YOLOv8 核心原理：架构解析与训练技巧

Posted on In

YOLOv8 是 Ultralytics 发布的 YOLO 系列最新力作，在精度和速度上都有显著提升。本文深入解析其核心架构和关键模块，以及实用的训练技巧。

整体架构

YOLOv8 架构图

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
┌─────────────────────────────────────────────────────────────┐
│                         YOLOv8                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Backbone (C2f + SPPF)                                      │
│  ┌─────┐   ┌──────────┐   ┌──────────┐   ┌──────────┐    │
│  │Conv │──►│   C2f    │──►│   C2f    │──►│   SPPF   │    │
│  │640² │   │  640²    │   │  1280²   │   │  1280²   │    │
│  └─────┘   └──────────┘   └──────────┘   └──────────┘    │
│                                                             │
│  Neck (C2f + SPPF)                                          │
│  ┌──────────┐   ┌──────────┐   ┌──────────┐               │
│  │   C2f    │◄──│  Upsample│◄──│   C2f    │               │
│  │  1280²   │   │          │   │  2560²   │               │
│  └────┬─────┘   └──────────┘   └──────────┘               │
│       │                                                       │
│  ┌────▼─────┐   ┌──────────┐                                │
│  │   C2f    │──►│  Down    │──► ...                        │
│  │  1280²   │   │  Sample  │                                │
│  └──────────┘   └──────────┘                                │
│                                                             │
│  Head (Decoupled + Anchor-free)                              │
│  ┌──────────┐   ┌──────────┐   ┌──────────┐                │
│  │  80×80   │   │  40×40   │   │  20×20   │                │
│  │ 小目标   │   │  中目标   │   │  大目标   │                │
│  └──────────┘   └──────────┘   └──────────┘                │
│                                                             │
└─────────────────────────────────────────────────────────────┘

核心组件一览

1
2
3
4
5
6
7
# YOLOv8 核心组件

1. Backbone:  C2f, SPPF
2. Neck:      C2f, SPPF, Upsample, Downsample
3. Head:      Decoupled Head (分类 + 回归)
4. Loss:      BFLoss (Distribution Focal Loss) + IoU Loss
5. Post-proc: NMS (Non-Maximum Suppression)

Backbone 详解

Conv 模块

1
2
3
4
5
6
7
8
9
10
11
12
# 基础卷积模块
class Conv(nn.Module):
    def __init__(self, in_ch, out_ch, kernel=1, stride=1, padding=None, groups=1):
        super().__init__()
        if padding is None:
            padding = kernel // 2
        self.conv = nn.Conv2d(in_ch, out_ch, kernel, stride, padding, groups=groups, bias=False)
        self.bn = nn.BatchNorm2d(out_ch)
        self.act = nn.SiLU()  # SiLU / Swish 激活

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

C2f 模块（核心创新）

C2f 是 YOLOv8 的核心模块，替代了 YOLOv5 的 C3：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class C2f(nn.Module):
    """YOLOv8 的核心模块"""
    def __init__(self, in_ch, out_ch, n=1, shortcut=False, groups=1):
        super().__init__()
        # 隐藏层通道数
        self.c = int(out_ch * 2)
        # 分割后的通道数
        self.cv1 = Conv(in_ch, 2 * self.c, 1, 1)
        # n 个 Bottleneck
        self.m = nn.ModuleList(
            Bottleneck(self.c, self.c, shortcut, groups) for _ in range(n)
        )
        # 输出通道
        self.cv2 = Conv((2 + n) * self.c, out_ch, 1)

    def forward(self, x):
        # 分割为两份
        y = list(self.cv1(x).chunk(2, 1))
        # 通过 Bottleneck
        y.extend(m(y[-1]) for m in self.m)
        # 拼接并卷积
        return self.cv2(torch.cat(y, 1))

C2f vs C3 对比

1
2
3
4
5
6
7
8
# YOLOv5 C3：
# - 残差分支只有 Bottleneck
# - 输出直接拼接

# YOLOv8 C2f：
# - 残差分支包含完整特征
# - 保留了更完整的梯度流
# - 效果更好但计算量略增

SPPF 模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 空间金字塔池化
class SPPF(nn.Module):
    def __init__(self, in_ch, out_ch, k=5):
        super().__init__()
        hidden_ch = in_ch // 2
        self.cv1 = Conv(in_ch, hidden_ch, 1)
        self.cv2 = Conv(hidden_ch * 4, out_ch, 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))

SPP vs SPPF

1
2
3
4
5
6
7
# SPP：并行多个不同尺寸的 MaxPool
# - 5×5, 9×9, 13×13
# - 计算量大

# SPPF：串行三个 MaxPool
# - 等效于 SPP 但计算量减少约 1/3
# - 效果相同，速度更快

Neck 结构

PANet (Path Aggregation Network)

1
2
3
4
5
6
7
8
9
10
11
12
# YOLOv8 Neck 采用 PANet 结构

# 自底向上路径聚合
# - 将低层特征（细粒度）传递到高层
# - 增强多尺度特征融合

# 结构：
# ┌────────────────────────────────────┐
# │           Bottom-up Path           │
# │   P3 ──► P4 ──► P5                │
# │   (浅层特征向上融合)                │
# └────────────────────────────────────┘

Neck Forward 流程

1
2
3
4
5
6
7
8
9
10
11
12
13
# 简化流程
def forward_neck(self, features):
    P3, P4, P5 = features  # 来自 backbone

    # 自顶向下
    P5_up = F.interpolate(P5, size=P4.shape[2:])
    P4_out = self.cv4(torch.cat([P4, P5_up], 1))

    # 自底向上
    P4_down = F.max_pool2d(P4_out, 2)
    P3_out = self.cv5(torch.cat([P3, P4_down], 1))

    return [P3_out, P4_out, P5]

Head 结构

Decoupled Head

YOLOv8 采用分类和回归分支完全解耦的 Head：

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
class Detect(nn.Module):
    def __init__(self, nc=80, ch=()):
        super().__init__()
        self.nc = nc  # 类别数
        self.nl = len(ch)  # 检测层数 (3)
        self.reg_max = 16  # DFL 通道数
        self.no = nc + self.reg_max * 4  # 输出通道
        self.stride = torch.zeros(self.nl)  # 步长

        # 解耦的分类和回归分支
        self.cv2 = nn.ModuleList(
            nn.Sequential(Conv(x, x, 3), Conv(x, x, 3), nn.Conv2d(x, 4 * self.reg_max, 1))
            for x in ch
        )
        self.cv3 = nn.ModuleList(
            nn.Sequential(Conv(x, x, 3), Conv(x, x, 3), nn.Conv2d(x, self.nc, 1))
            for x in ch
        )

    def forward(self, x):
        # 分类输出
        cls = [cv3(x) for cv3, x in zip(self.cv3, x)]
        # 回归输出
        box = [cv2(x) for cv2, x in zip(self.cv2, x)]
        return cls, box

Decoupled vs Coupled

1
2
3
4
5
6
7
8
# Coupled Head (YOLOv3-v5):
# - 分类和回归共享特征
# - 训练收敛慢

# Decoupled Head (YOLOv8):
# - 分类和回归独立分支
# - 收敛更快，精度更高
# - 参数量略增

输出张量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# YOLOv8 COCO (80 类) 输出

# 三个尺度的输出：

# P3 (80×80): 检测小目标
# - 80×80×80 (分类)
# - 80×80×64 (回归, 4×16)

# P4 (40×40): 检测中目标
# - 40×40×80
# - 40×40×64

# P5 (20×20): 检测大目标
# - 20×20×80
# - 20×20×64

# 每个位置 80 类别 + 4×16 (DFL 回归) = 144 通道

损失函数

BFLoss (Box Loss)

YOLOv8 使用 CIoU + DFL 的组合损失：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class BboxLoss(nn.Module):
    def __init__(self, reg_max):
        super().__init__()
        self.reg_max = reg_max

    def forward(self, pred_dist, pred_bboxes, anchor_points, target_bboxes, target_scores):
        # 1. IoU Loss (CIoU)
        iou = bbox_iou(pred_bboxes, target_bboxes, xywh=True, CIoU=True)
        loss_iou = ((1.0 - iou) * target_scores).sum()

        # 2. DFL Loss (Distribution Focal Loss)
        # DFL 将回归转换为分类问题
        loss_dfl = self._df_loss(pred_dist, target_bboxes)

        return loss_iou, loss_dfl

DFL (Distribution Focal Loss)

1
2
3
4
5
6
7
8
9
10
# DFL 将连续回归转为离散分类

# 原理：
# - 将 [l, r] 区间分成 reg_max 份
# - 预测每个离散点的概率
# - 加权求和得到最终值

# 例如 reg_max=16：
# - 预测 16 个概率值
# - 最终值 = Σ (p_i × position_i)

完整 Loss

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class YOLOv8Loss:
    def __init__(self, model):
        self.bce = nn.BCEWithLogitsLoss(reduction='none')
        self.box_loss = BboxLoss(reg_max=16)
        self.cls_loss = nn.BCEWithLogitsLoss(reduction='none')
        self.stride = model.stride

    def __call__(self, preds, targets):
        # 1. Box Loss: CIoU + DFL
        loss_box, loss_dfl = self.box_loss(...)

        # 2. Classification Loss: BCE
        loss_cls = self.cls_loss(...)

        # 3. 置信度 Loss
        loss_obj = self.bce(...)

        # 4. 加权求和
        return loss_box + 0.5 * loss_dfl + loss_cls + loss_obj

训练技巧

数据增强

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# YOLOv8 主要数据增强：

# 1. Mosaic
# - 4 张图拼成 1 张
# - 提高 batch 内多样性

# 2. MixUp
# - 两张图加权融合
# - λ ~ Beta(α=0.5)

# 3. Copy-Paste
# - 复制目标粘贴到其他位置

# 4. HSV 增强
# - 色调、饱和度、明度

# 5. 几何变换
# - 随机翻转、旋转、缩放

训练配置

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
# YOLOv8 训练超参（yolov8s.yaml）

# 优化器
optimizer: SGD
lr0: 0.01
lrf: 0.01
momentum: 0.937
weight_decay: 0.0005

# 学习率调度
warmup_epochs: 3.0
warmup_momentum: 0.8
warmup_bias_lr: 0.1

# 数据增强
hsv_h: 0.015
hsv_s: 0.7
hsv_v: 0.4
degrees: 0.0
translate: 0.1
scale: 0.5
shear: 0.0
perspective: 0.0
flipud: 0.0
fliplr: 0.5
mosaic: 1.0
mixup: 0.0
copy_paste: 0.0

训练策略

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 1. 预热 (Warmup)
# - 前 3 个 epoch 逐渐增大学习率
# - 避免初期震荡

# 2. 余弦退火
# - lr = lr0 * cos(π * epoch / epochs)

# 3. EMA (Exponential Moving Average)
# - 移动平均模型权重
# - 提高泛化能力

# 4. 梯度裁剪
# - 防止梯度爆炸
# - max_norm=10.0

验证技巧

1
2
3
4
5
6
7
8
9
10
11
# 1. 使用 Val mode
from ultralytics import YOLO
model = YOLO('yolov8s.pt')
metrics = model.val(data='coco.yaml', split='val')

# 2. 查看 mAP
print(f"mAP50: {metrics.box.map50:.3f}")
print(f"mAP50-95: {metrics.box.map:.3f}")

# 3. 查看每类 AP
print(metrics.box.ap50)

常见问题排查

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 问题1：训练 loss 不下降
# 解决：
# - 检查数据标注是否正确
# - 降低学习率 (lr0=0.001)
# - 检查图像是否正常加载

# 问题2：小目标漏检
# 解决：
# - 降低输入分辨率 (640 → 1280)
# - 检查小目标标注是否正确
# - 调整 loss 权重

# 问题3：mAP 低
# 解决：
# - 增加训练 epoch
# - 使用更强的数据增强
# - 检查类别是否平衡

总结

YOLOv8 核心要点：

组件 改进 效果
Backbone C2f 模块 更好的梯度流
Neck C2f + SPPF 高效多尺度融合
Head Decoupled + TAL 分类回归解耦
Loss BFLoss (CIoU + DFL) 更稳定训练
Anchor Anchor-free 简化设计

训练建议：

  1. 数据集：确保标注准确，小目标标注完整
  2. 增强：默认配置足够强，不要过度增强
  3. 学习率：默认 SGD 效果好，可尝试 AdamW
  4. Epoch：300 epoch 通常足够
  5. Batch：根据显存调整，最大化利用