张会挽's Blog

YOLOv8 vs YOLO11：Ultralytics 新旧版本全面对比

Posted on In

YOLO11 是 Ultralytics 发布的最新版本，很多人关心 v8 和 v11 之间的差异以及是否需要升级。本文从架构、性能、训练部署等方面进行全面对比。

架构变化对比

骨干网络变化

YOLOv8 骨干网络

1
2
3
4
5
6
7
8
9
10
11
# YOLOv8 Backbone
# Conv → C2f → Conv → C2f → Conv → C2f → SPPF

class C2f(nn.Module):
    """YOLOv8 核心模块"""
    def __init__(self, c1, c2, n=1):
        super().__init__()
        self.c = int(c2 * 2)
        self.cv1 = Conv(c1, 2 * self.c, 1, 1)
        self.m = nn.ModuleList(Bottleneck(self.c, self.c) for _ in range(n))
        self.cv2 = Conv((2 + n) * self.c, c2, 1)

YOLO11 骨干网络

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# YOLO11 骨干网络
# Conv → C3K2 → Conv → C3K2 → Conv → C3K2 → SPPF

class C3K2(nn.Module):
    """YOLO11 新模块，比 C2f 更高效"""
    def __init__(self, c1, c2, n=1, c3k=False, e=0.5):
        super().__init__()
        # C3K2 根据 c3k 参数决定是否使用深度可分离卷积
        self.c = int(c2 * 2)
        self.cv1 = Conv(c1, 2 * self.c, 1, 1)
        # 深度可分离卷积用于更快的推理
        self.m = nn.ModuleList(
            C3K(self.c, self.c, n=1, shortcut=True) if c3k else
            Bottleneck(self.c, self.c, shortcut=True) for _ in range(n)
        )
        self.cv2 = Conv((2 + n) * self.c, c2, 1)

关键差异

特性 YOLOv8 YOLO11
核心模块 C2f C3K2
深度可分离卷积 无 支持 (c3k=True)
模块数量 统一 灵活配置
计算效率 中 高

C3K2 模块详解

1
2
3
4
5
6
7
8
9
class C3K(nn.Module):
    """C3K 模块：深度可分离卷积变体"""
    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
        super().__init__()
        # 深度可分离卷积：减少参数量
        self.conv1 = Conv(c1, c1, 3, g=c1)  # 深度卷积
        self.conv2 = Conv(c1, c2, 1, 1)     # 逐点卷积
        # 或标准卷积
        self.conv = Conv(c1, c2, 3, g=g) if not c3k else None

SPPF 变化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# YOLOv8 SPPF
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)

# YOLO11 SPPF (略有优化)
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)

Anchor 策略对比

YOLOv8 Anchor

1
2
3
4
5
# YOLOv8 采用 Anchor-free + TAL (Task Alignment Learning)
# 但内部仍有 Anchor 相关的配置

# 检测输出：[batch, nc + reg_max*4, h, w]
# reg_max = 16 (DFL 通道数)

YOLO11 Anchor

1
2
3
4
5
6
7
# YOLO11 继续使用 Anchor-free
# 但做了进一步优化

# 主要变化：
# 1. 进一步简化 Head
# 2. 调整正负样本匹配策略
# 3. 优化损失函数权重

对比

方面 YOLOv8 YOLO11
Anchor 策略 Anchor-free + TAL Anchor-free + 优化 TAL
正负样本匹配 TAL 改进版
DFL reg_max 16 16 (可能调整)

性能对比

参数量对比

模型 YOLOv8 参数量 YOLO11 参数量 减少
nano 3.2M 2.6M -19%
small 11.2M 9.4M -16%
medium 25.9M 20.0M -23%
large 43.7M 25.3M -42%
xlarge 68.2M 56.9M -17%

FLOPs 对比

模型 YOLOv8 FLOPs YOLO11 FLOPs 减少
nano 4.0B 3.2B -20%
small 28.6B 21.5B -25%
medium 78.9B 68.0B -14%
large 165.2B 86.0B -48%
xlarge 257.8B 196.0B -24%

精度对比 (COCO val)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# mAP@0.5:0.95 对比

# nano
YOLOv8n: 37.3 mAP
YOLO11n: 39.5 mAP  (+2.2)

# small
YOLOv8s: 44.9 mAP
YOLO11s: 47.0 mAP  (+2.1)

# medium
YOLOv8m: 50.2 mAP
YOLO11m: 51.5 mAP  (+1.3)

# large
YOLOv8l: 52.9 mAP
YOLO11l: 53.4 mAP  (+0.5)

# xlarge
YOLOv8x: 54.4 mAP
YOLO11x: 54.7 mAP  (+0.3)

速度对比 (T4 GPU)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 推理速度 (ms/image, batch=1)

# nano
YOLOv8n: 1.17 ms
YOLO11n: 0.99 ms  (-15%)

# small
YOLOv8s: 1.77 ms
YOLO11s: 1.47 ms  (-17%)

# medium
YOLOv8m: 2.76 ms
YOLO11m: 2.21 ms  (-20%)

# large
YOLOv8l: 4.52 ms
YOLO11l: 3.10 ms  (-31%)

# large (YOLO11 优势明显)

结论：YOLO11 在 精度提升的同时，速度显著加快，尤其是 Large 版本。

训练对比

训练代码

1
2
3
4
5
6
7
8
9
10
# YOLOv8 训练（与 YOLO11 完全相同）
from ultralytics import YOLO

# YOLOv8
model = YOLO('yolov8s.pt')
results = model.train(data='dataset.yaml', epochs=100)

# YOLO11
model = YOLO('yolo11s.pt')
results = model.train(data='dataset.yaml', epochs=100)

训练时间对比

1
2
3
4
5
6
7
8
9
# 相同硬件 (A100, batch=16, 640x640)

# 100 epochs 训练时间

# YOLOv8s: ~4.5 hours
# YOLO11s: ~4.0 hours  (-11%)

# YOLOv8m: ~8.2 hours
# YOLO11m: ~7.0 hours  (-15%)

默认超参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# YOLOv8 超参数
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

# YOLO11 超参数 (类似)
# 差异不大，主要在架构层面

部署对比

ONNX 导出

1
2
3
4
5
6
# 导出方式完全相同
model = YOLO('yolov8s.pt')
model.export(format='onnx')

model = YOLO('yolo11s.pt')
model.export(format='onnx')

TensorRT 部署

1
2
3
4
5
# 转换命令相同
trtexec --onnx=yolov8s.onnx --saveEngine=yolov8s.engine
trtexec --onnx=yolo11s.onnx --saveEngine=yolo11s.engine

# YOLO11 引擎更小，推理更快

推理代码对比

1
2
3
4
5
6
7
# YOLOv8 推理
model = YOLO('yolov8s.pt')
results = model('test.jpg', verbose=False)

# YOLO11 推理（完全相同）
model = YOLO('yolo11s.pt')
results = model('test.jpg', verbose=False)

使用场景选择

何时选择 YOLOv8

1
2
3
4
5
6
7
8
9
10
11
# 1. 已有 YOLOv8 模型
# - 升级成本高
# - v8 已经满足需求

# 2. 特殊场景
# - YOLOv8 某些特定任务调优良好
# - 不想重新训练

# 3. 团队熟悉度
# - 团队已经熟悉 v8
# - 文档和社区支持更多

何时选择 YOLO11

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 1. 新项目
# - 从头开始，选择最新版本
# - 享受性能提升

# 2. 对速度要求高
# - 实时应用
# - 边缘部署

# 3. 大模型场景
# - YOLO11l vs YOLOv8l 速度优势明显

# 4. 资源受限
# - 显存有限
# - 需要更小的模型

性能 vs 兼容性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 优先级排序

# 速度优先 → YOLO11
# - 实时视频分析
# - 高并发服务
# - 边缘设备

# 精度优先 → 两者均可
# - 差异不大
# - YOLO11 略优

# 稳定性优先 → YOLOv8
# - 更成熟
# - 更多社区验证
# - 更好的文档

升级建议

从 YOLOv8 升级到 YOLO11

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 1. 模型转换
# 直接使用新模型
model = YOLO('yolo11s.pt')

# 或转换旧模型
# YOLO11 暂不支持直接加载 YOLOv8 权重
# 需要重新训练

# 2. 验证精度
# 在验证集上对比
results_v8 = YOLO('yolov8s.pt').val()
results_v11 = YOLO('yolo11s.pt').val()

# 3. 推理服务替换
# 替换模型文件，重新部署

增量更新策略

1
2
3
4
5
6
7
8
9
# 1. A/B 测试
# 新旧模型同时运行，对比结果

# 2. 灰度发布
# 先替换 10% 流量
# 监控指标稳定后全量

# 3. 回滚方案
# 保留旧模型，快速回滚

总结

核心差异

维度 YOLOv8 YOLO11
核心模块 C2f C3K2
参数量 较多 减少 20-40%
FLOPs 较多 减少 20-40%
精度 基准 略高 (+0.5-2 mAP)
速度 中 快 15-30%
兼容性 好 好
社区 成熟 新兴

升级建议

1
2
3
4
5
6
7
8
9
# 建议升级：
# 1. 新项目 → 使用 YOLO11
# 2. 大模型 (l/x) → 升级收益大
# 3. 速度敏感场景 → 必须升级

# 可暂不升级：
# 1. 已有成熟 v8 部署
# 2. 小模型 (n/s)
# 3. 非性能关键场景

总体评价：YOLO11 在保持兼容性的同时，在速度和精度上都有提升，是更好的选择。