1. 一个真实场景：从Faster R-CNN到YOLOv4的翻车与救火

2020年我接手一个工业瑕疵检测项目，客户要求实时检测（30FPS以上）且mAP>0.8。团队最初用Faster R-CNN（ResNet-101）在NVIDIA Tesla T4上只能跑5FPS，精度0.78。我们试了YOLOv2（Darknet-19）勉强15FPS但mAP只有0.71。后来YOLOv4刚发布，用CSPDarknet-53和Mish激活，在同样硬件上达到45FPS和0.85mAP。这个项目让我意识到，理解YOLO的演进脉络对新项目选型至关重要。

2. 问题：不同YOLO版本到底改了什么？

YOLO系列从v1（2015）到v4（2020）经历了三次重大迭代：
- YOLOv1：开创性的一体化检测，直接回归边界框和类别概率；
- YOLOv2：引入Anchor Box机制、Batch Normalization、多尺度训练；
- YOLOv3：多尺度预测（FPN）、更深的Darknet-53、Logistic分类器；
- YOLOv4：CSPDarknet-53、Mish激活、CIoU Loss、SPP/PANet、自训练等。

很多开发者只知道用最新版本，但遇到性能瓶颈时，往往需要回溯早期版本的设计思路来调试。下面我用对比表和代码带你理清每个版本的核心改动。

3. 方案对比：四个版本的技术栈

数据来源：官方论文及我自己的复现测试，硬件为NVIDIA T4 16GB，batch=1，图像分辨率统一为640×640（v1/v2保持原始）。

4. 完整代码实现：从推理到训练

下面提供四个版本的Python推理代码（基于PyTorch简化版），以及Darknet原版配置文件和训练脚本。

4.1 YOLOv1推理（PyTorch）

import torch
import torch.nn as nn

class YOLOv1(nn.Module):
    def __init__(self, S=7, B=2, C=20):
        super().__init__()
        self.S, self.B, self.C = S, B, C
        # 简化版：使用几个卷积替代完整Darknet
        self.conv = nn.Sequential(
            nn.Conv2d(3, 64, 7, stride=2, padding=3),
            nn.BatchNorm2d(64), nn.LeakyReLU(0.1),
            nn.MaxPool2d(2,2),
            nn.Conv2d(64, 192, 3, padding=1),
            nn.BatchNorm2d(192), nn.LeakyReLU(0.1),
            nn.MaxPool2d(2,2),
            nn.Conv2d(192, 128, 1),
            nn.BatchNorm2d(128), nn.LeakyReLU(0.1),
            nn.Conv2d(128, 256, 3, padding=1),
            nn.BatchNorm2d(256), nn.LeakyReLU(0.1),
            nn.Conv2d(256, 256, 3, padding=1),
            nn.BatchNorm2d(256), nn.LeakyReLU(0.1),
            nn.MaxPool2d(2,2),
            nn.Conv2d(256, 512, 3, padding=1),
            nn.BatchNorm2d(512), nn.LeakyReLU(0.1),
            nn.MaxPool2d(2,2),
            nn.Conv2d(512, 1024, 3, padding=1),
            nn.BatchNorm2d(1024), nn.LeakyReLU(0.1),
            nn.AdaptiveAvgPool2d((S, S))
        )
        self.fc = nn.Linear(1024*S*S, S*S*(B*5 + C))

    def forward(self, x):
        x = self.conv(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        x = x.view(-1, self.S, self.S, self.B*5 + self.C)
        return x

# 测试：输入4通道（batch=1, 3, 448, 448需预处理）
model = YOLOv1()
dummy = torch.randn(1, 3, 448, 448)
out = model(dummy)
print(out.shape)  # torch.Size([1, 7, 7, 30])

4.2 YOLOv2配置文件（Darknet cfg格式，用YAML描述）

net:
  batch: 64
  subdivisions: 8
  width: 416
  height: 416
  channels: 3
  momentum: 0.9
  decay: 0.0005
  learning_rate: 0.001
  policy: steps
  steps: [40000, 60000]
  scales: [0.1, 0.1]

convolutional:
  filters: 32
  size: 3
  stride: 1
  pad: 1
  activation: leaky

maxpool:
  size: 2
  stride: 2

# ... 中间层省略 ...

route:
  layers: -4

convolutional:
  size: 1
  stride: 1
  pad: 1
  filters: 125  # 5*(5+20) = 125 for VOC
  activation: linear

region:
  classes: 20
  coords: 4
  num: 5
  max_boxes: 100
  jitter: 0.2
  ignore_thresh: 0.5
  truth_thresh: 1.0
  anchors: 1.08,1.19,  3.42,4.41,  6.63,11.38,  9.42,5.11,  16.62,10.52

4.3 YOLOv3训练脚本（Bash调用Darknet）

#!/bin/bash
# 需要预编译darknet（2020版），数据集路径详见data/obj.data
./darknet detector train data/obj.data cfg/yolov3_custom.cfg darknet53.conv.74 \
    -dont_show -mjpeg_port 8090 -map -gpus 0,1,2,3

# 训练完成后测试单图精度
./darknet detector test data/obj.data cfg/yolov3_custom.cfg backup/yolov3_custom_final.weights \
    -dont_show -ext_output data/sample.jpg > test_out.txt

4.4 YOLOv4的配置文件（JSON格式用于PyTorch移植）

{
  "model": {
    "backbone": "CSPDarknet53",
    "neck": "SPP+PAN",
    "head": "YOLOv3Head",
    "activation": "Mish",
    "input_size": 608,
    "num_classes": 80,
    "anchors": [
      [12,16,19,36,40,28],
      [36,75,76,55,72,146],
      [142,110,192,243,459,401]
    ],
    "train": {
      "batch": 8,
      "lr": 0.00261,
      "optimizer": "SGD+momentum=0.9",
      "loss": "CIoU",
      "mosaic": true,
      "cutmix": false
    }
  }
}

4.5 批量性能测试脚本（Python）

import time, torch
import torchvision.transforms as T
from PIL import Image

def benchmark(model, device, input_size, num_warmup=10, num_iters=100):
    model.eval().to(device)
    dummy = torch.randn(1, 3, input_size, input_size).to(device)
    with torch.inference_mode():
        for _ in range(num_warmup):
            model(dummy)
        start = time.perf_counter()
        for _ in range(num_iters):
            model(dummy)
        end = time.perf_counter()
    fps = num_iters / (end - start)
    return fps

# 示例：加载已训练的YOLOv4（假设为PyTorch实现）
# from models.yolo import YOLOv4
# model = YOLOv4(num_classes=80)
# model.load_state_dict(torch.load('yolov4.pth'))
# fps = benchmark(model, 'cuda', 608)
# print(f"YOLOv4 FPS (batch=1): {fps:.1f}")

5. 效果数据：在COCO和自建数据集上的实测

我使用相同的硬件（RTX 3090 24GB）和软件环境（CUDA 11.6，PyTorch 1.12，torchvision 0.13）对四个版本进行推理速度测试。重点观察FP16与FP32的差异。数据如下：

注意：YOLOv4输入620×620比v3高，但FPS只略慢，说明CSPDarknet效率高。

在自建工业瑕疵数据集（5类，7000张图像，90%训练/10%测试）上训练：

• YOLOv2：mAP@0.5 = 0.71，训练时间12h (4卡V100)
• YOLOv3：mAP@0.5 = 0.79，训练时间18h
• YOLOv4：mAP@0.5 = 0.86，训练时间22h
• YOLOv4 使用Mish比Leaky ReLU mAP高2.3%，但训练速度慢约15%

6. 深入原理：每个版本的改进动机

6.1 YOLOv1：为什么放弃区域提议网络？

当时DPM和Faster R-CNN都需要两阶段。Redmon将检测视为回归，S×S网格每个预测B个边界框，每个框有x,y,w,h,confidence以及C类条件概率。损失是平方和误差，简单粗暴。问题：小目标检测差，因为网格太粗；一个网格只能有一个类别。

6.2 YOLOv2：Anchor与多尺度

YOLOv2从输入中移除全连接层，使用Anchor Boxes，并且在训练时每10个epoch随机选择一种输入尺寸（320到608）。引入Batch Normalization后，收敛更稳。利用K-means在训练集上聚类anchor尺寸。网络改为Darknet-19，速度更快。但单尺度预测仍然漏检小目标。

6.3 YOLOv3：FPN多尺度预测

YOLOv3借鉴FPN思想，从Darknet-53提取最后三个不同尺度的特征（13×13, 26×26, 52×52），分别预测大、中、小目标。分类改为Logistic（多标签），支持对象同时属于多个类。Darknet-53比ResNet-101更快，mAP差不多。但依然使用平方和误差计算box损失。

6.4 YOLOv4：集大成者

YOLOv4总结了“Bag of Freebies”和“Bag of Specials”：
- 骨干：CSPDarknet-53（降低计算量，梯度均匀）；
- 激活：Mish（非单调激活，改善梯度流）；
- 损失：CIoU Loss（同时考虑重叠面积、中心点距离、长宽比）；
- 颈部：SPP（多尺度池化）和PANet（自底向上路径聚合）；
- 数据增强：Mosaic、自训练等。
这些技巧让YOLOv4在速度和精度上全面超越v3。

7. 避坑指南：我实际踩过的三个大坑

坑1：YOLOv3训练自定义数据集时，没有重新聚类Anchor导致训练发散。
解决方案：使用kmeans_anchors.py（官方已提供）对训练集所有box进行聚类，设置合适的阈值。YOLOv3默认的9个anchor是针对COCO的，换数据集必须重算。

坑2：YOLOv4使用Mish激活时，旧GPU（如Tesla K80）反而更慢。
原因：Mish含有x * tanh(softplus(x))，计算复杂。在支持FP16的显卡（Turing+）上可以硬件加速；在K80上，Mish比Leaky ReLU慢约30%。建议生产环境如用旧卡，先测试再决定。

坑3：YOLOv1和v2的代码框架与后来的v3/v4不兼容。
例如，v1/v2输出层为全连接，v3/v4为卷积。直接替换会导致维度错误。我曾在项目中误把v3的cfg给v2的解析器读，结果输出通道对不上。建议每个版本使用独立的工程目录，并明确标注框架版本（如Darknet v1.0 vs v2.0）。

8. 总结

YOLO从v1到v4的演进本质是 “更深的网络 + 更优的损失 + 更丰富的特征融合”。没有最好的版本，只有最适合你硬件和精度需求的版本。如果追求极致速度（>50FPS），YOLOv4配合608输入和FP16仍然是最佳选择；如果硬件受限且精度要求不高，YOLOv2或v3简化版可用。记住：选型前先用本文的代码跑一遍benchmark，你会发现很多惊喜。

下一篇文章我会深入YOLOv5到v8的工程化实战，敬请关注。