Day 29：YOLO系列详解 — 从v1到v10

今日目标 ：深入理解YOLO从v1到v10的进化逻辑，掌握每个版本的创新点，知道端侧AI该选哪个版本

预计阅读 ：10分钟 | 动手操作：40分钟

---

一、YOLO进化史：从"能跑"到"端侧王者"

2016 YOLOv1  → 首个实时检测器，粗但快
2017 YOLOv2  → 引入Anchor，精度大幅提升
2018 YOLOv3  → 多尺度预测，Darknet-53
2020 YOLOv4  → 各种trick大杂烩，精度速度双优
2020 YOLOv5  → PyTorch版本，社区最活跃
2022 YOLOv6  → 美团出品，工业级优化
2022 YOLOv7  → 官方正统续作，可重参数化
2023 YOLOv8  → Ultralytics出品，Anchor-Free
2024 YOLOv9  → PGI+GELAN，可编程梯度信息
2024 YOLOv10 → NMS-Free，端到端检测

每个版本都在解决前一代的痛点！

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np

torch.manual_seed(42)

---

二、逐代解析

2.1 YOLOv1 (2016) --- 开天辟地

"""
YOLOv1：把检测问题变成回归问题

核心思想：
  1. 将图像分成 S×S 的网格（7×7）
  2. 每个网格预测 B 个框（B=2）+ C 个类别概率
  3. 输出: 7×7×(B*5 + C) = 7×7×30

输出向量的含义：
  每个网格: [x, y, w, h, conf] × 2 + [class_probs] × 20

损失函数（YOLOv1的核心）：
  loss = λ_coord × Σ(坐标损失)     # 坐标最重要，权重5
       + Σ(置信度损失_有物体)       # 有物体时
       + λ_noobj × Σ(置信度损失_无物体) # 无物体时，权重0.5
       + Σ(分类损失)                # 只在有物体时计算

创新点：
  ✅ 端到端训练，一次推理完成检测
  ✅ 实时速度（45 FPS）
  
问题：
  ❌ 每个网格只能预测2个框 → 密集场景漏检
  ❌ 小目标检测差
  ❌ 定位不准
"""

class YOLOv1Loss:
    """YOLOv1损失函数核心实现"""
    def __init__(self, S=7, B=2, C=20, lambda_coord=5, lambda_noobj=0.5):
        self.S = S
        self.B = B
        self.C = C
        self.lambda_coord = lambda_coord
        self.lambda_noobj = lambda_noobj
    
    def compute_loss(self, pred, target):
        """简化版YOLOv1损失"""
        # pred: (batch, S, S, B*5 + C)
        # target: 包含框坐标、置信度、类别
        
        # 1. 坐标损失（只计算有物体的网格）
        coord_loss = ...  # MSE on (x, y, w, h)
        coord_loss *= self.lambda_coord
        
        # 2. 置信度损失
        obj_loss = ...    # 有物体: (pred_conf - 1)²
        noobj_loss = ...  # 无物体: (pred_conf - 0)²
        noobj_loss *= self.lambda_noobj
        
        # 3. 分类损失
        class_loss = ...  # MSE on class probs
        
        return coord_loss + obj_loss + noobj_loss + class_loss

2.2 YOLOv2 (2017) --- 精度飞跃

"""
YOLOv2 (YOLO9000)：引入Anchor，精度大幅提升

核心改进：
  1. BatchNorm → 每层加BN，mAP提升2%
  2. 高分辨率分类器 → 448×448预训练，mAP提升4%
  3. Anchor Box → 用K-Means聚类得到5个先验框
  4. 直接位置预测 → 预测相对于网格的偏移，而非绝对坐标
  5. 多尺度训练 → 每10个batch换一个输入尺寸
  6. Passthrough层 → 融合浅层特征（类似ResNet的skip）

Anchor预测公式（YOLOv2的核心创新）：
  b_x = σ(t_x) + c_x     # 框中心x = sigmoid(偏移) + 网格左上角x
  b_y = σ(t_y) + c_y     # 框中心y
  b_w = p_w × e^(t_w)    # 框宽 = anchor宽 × exp(偏移)
  b_h = p_h × e^(t_h)    # 框高
  
  其中 t_x, t_y, t_w, t_h 是网络预测值
  c_x, c_y 是当前网格的左上角坐标
  p_w, p_h 是Anchor的宽高
  σ 是sigmoid函数，将预测值限制在[0,1]

为什么用sigmoid？
  → 限制预测范围，确保框中心在当前网格内
  → 相比YOLOv1直接预测坐标，更稳定，更容易训练
"""

def yolov2_box_decode(tx, ty, tw, th, anchor_w, anchor_h, cx, cy):
    """
    YOLOv2/v3/v4/v5的框解码公式
    这个公式用了很多年，直到YOLOv8才改成Anchor-Free
    """
    bx = torch.sigmoid(tx) + cx
    by = torch.sigmoid(ty) + cy
    bw = anchor_w * torch.exp(tw)
    bh = anchor_h * torch.exp(th)
    return bx, by, bw, bh


print("YOLOv2框解码公式:")
print("  b_x = σ(t_x) + c_x")
print("  b_y = σ(t_y) + c_y")
print("  b_w = p_w · e^(t_w)")
print("  b_h = p_h · e^(t_h)")
print("  这个公式统治了YOLO世界5年！")

2.3 YOLOv3 (2018) --- 多尺度预测

"""
YOLOv3：多尺度预测 + Darknet-53

核心改进：
  1. Darknet-53 → 更深的backbone，精度媲美ResNet-101但更快
  2. FPN多尺度预测 → 3个尺度（小/中/大物体分别检测）
  3. 多标签分类 → 用sigmoid代替softmax，支持多标签
  4. 9个Anchor → 3个尺度 × 3个Anchor

多尺度预测的意义：
  尺度1 (13×13): 检测大物体（感受野大）
  尺度2 (26×26): 检测中等物体
  尺度3 (52×52): 检测小物体（感受野小，分辨率高）

  这就是为什么YOLOv3的小目标检测比v1/v2好很多！
"""

class YOLOv3Architecture:
    """YOLOv3架构解析"""
    def __init__(self):
        self.backbone = "Darknet-53 (53层卷积)"
        self.neck = "FPN (特征金字塔网络)"
        self.head = "3个检测头 (13×13, 26×26, 52×52)"
        
        # 每个尺度预测: 3 × (4 + 1 + 80) = 255
        # 3个Anchor × (x,y,w,h + confidence + 80个COCO类别)
        self.output = "255 channels per scale"
    
    def describe(self):
        print("YOLOv3架构:")
        print(f"  Backbone: {self.backbone}")
        print(f"  Neck: {self.neck}")
        print(f"  Head: {self.head}")
        print(f"  每个尺度输出: {self.output}")
        print(f"\n  创新: 多尺度预测 → 大幅提升小目标检测能力")

YOLOv3Architecture().describe()

2.4 YOLOv4 (2020) --- Tricks大集合

"""
YOLOv4：Bag of Freebies + Bag of Specials

Bag of Freebies（不增加推理成本的tricks）：
  ✅ Mosaic数据增强（4张图拼1张）
  ✅ 自对抗训练（SAT）
  ✅ CIoU Loss（更好的框回归损失）
  ✅ DropBlock正则化
  ✅ Label Smoothing
  ✅ 余弦退火学习率

Bag of Specials（小幅增加推理成本但大幅提精度的tricks）：
  ✅ Mish激活函数
  ✅ SPP（空间金字塔池化）
  ✅ PANet（路径聚合网络）
  ✅ SAM（空间注意力模块）
  ✅ DIoU-NMS

CSPDarknet53：
  - CSPNet + Darknet53
  - 减少计算量，增强梯度传播
  - 是Darknet-53的改进版

YOLOv4 = YOLOv3 + 各种trick + 更好的训练策略
虽然创新不多，但工程化做到了极致！
"""

# CIoU Loss（YOLOv4的核心改进之一）
def ciou_loss(pred_box, target_box):
    """
    CIoU (Complete IoU) Loss
    
    比普通IoU多了三个惩罚项：
    1. 中心点距离惩罚
    2. 长宽比惩罚
    3. 面积惩罚
    
    CIoU = IoU - (ρ²(b,b_gt)/c²) - (α × v)
    其中：
    - ρ²: 中心点欧氏距离
    - c²: 最小包围框对角线长度
    - α: 权衡参数
    - v: 长宽比一致性
    
    效果：框回归更准确，收敛更快
    """
    pass  # 简化演示

print("YOLOv4核心创新:")
print("  Mosaic增强: 4图拼1图 → 丰富小目标")
print("  CSPDarknet53: 更高效的backbone")
print("  PANet: 更好的特征融合")
print("  CIoU Loss: 更精确的框回归")
print("  Mish激活: 更平滑的梯度流")

2.5 YOLOv5 (2020) --- 社区之王

"""
YOLOv5：Ultralytics出品，PyTorch原生

虽然YOLOv5不是官方正统（YOLOv4作者是AlexeyAB），
但它是最流行、最好用的YOLO版本！

核心特点：
  1. PyTorch原生实现 → 易读、易改、易部署
  2. 自动Anchor计算 → 训练前自动用K-Means聚类
  3. 多种模型规格 → n/s/m/l/x（从超轻到超大）
  4. 完善的训练工具 → 自动混合精度、EMA、超参数进化
  5. 一键导出 → ONNX/TensorRT/CoreML/TFLite

YOLOv5各规格对比：
  模型    | 参数量  | mAP@0.5 | 推理速度(CPU)
  n(nano)| 1.9M   | 45.7%   | 极快
  s(small)| 7.2M  | 56.8%   | 快
  m(medium)| 21.2M | 64.1%   | 中等
  l(large) | 46.5M | 67.3%   | 较慢
  x(xlarge)| 86.7M | 68.9%   | 慢
"""

# YOLOv5的自动Anchor计算
def kmeans_anchors(boxes_wh, k=9):
    """
    K-Means聚类计算最优Anchor尺寸
    
    用IoU作为距离度量（而非欧氏距离）
    因为大框和小框的欧氏距离差异大，用IoU更公平
    """
    def iou_distance(box, clusters):
        """IoU距离 = 1 - IoU（越小越相似）"""
        # box: (w, h), clusters: (k, 2)
        inter_w = np.minimum(box[0], clusters[:, 0])
        inter_h = np.minimum(box[1], clusters[:, 1])
        inter = inter_w * inter_h
        
        area_box = box[0] * box[1]
        area_clusters = clusters[:, 0] * clusters[:, 1]
        union = area_box + area_clusters - inter
        
        return 1 - inter / (union + 1e-8)
    
    # 简化演示
    print("K-Means Anchor聚类:")
    print("  距离度量: 1 - IoU（而非欧氏距离）")
    print("  原因: 大框和小框的IoU距离更公平")
    print("  输出: k个最优的(w, h) Anchor尺寸")

kmeans_anchors(None)

2.6 YOLOv8 (2023) --- Anchor-Free革命

"""
YOLOv8：Ultralytics新一代旗舰

核心变革（最大的！）：
  1. Anchor-Free → 不再需要预设Anchor！
  2. Decoupled Head → 分类和回归分成两个分支
  3. C2f模块 → CSP的改进版，更多梯度流
  4. Task-Aligned Assigner → 更智能的正负样本匹配

Anchor-Free怎么预测框？
  不是预测 (tx, ty, tw, th) 相对于Anchor的偏移
  而是直接预测框的 (left, top, right, bottom) 到中心点的距离！
  
  简化了太多！不需要聚类Anchor，不需要计算Anchor和GT的IoU匹配

Decoupled Head：
  旧版: 一个卷积同时输出 (x,y,w,h) + confidence + class
  YOLOv8: 分成两个分支
    - 分类分支: 输出类别概率
    - 回归分支: 输出框坐标 (left, top, right, bottom)
  
  为什么分开？分类和回归需要不同的特征！
  分类关注"是什么"，回归关注"在哪"
"""

class YOLOv8Head(nn.Module):
    """YOLOv8的Decoupled Head（简化版）"""
    def __init__(self, in_channels, num_classes):
        super().__init__()
        mid_channels = max(in_channels, 64)
        
        # 分类分支
        self.cls_convs = nn.Sequential(
            nn.Conv2d(in_channels, mid_channels, 3, padding=1),
            nn.SiLU(),
            nn.Conv2d(mid_channels, mid_channels, 3, padding=1),
            nn.SiLU(),
        )
        self.cls_pred = nn.Conv2d(mid_channels, num_classes, 1)
        
        # 回归分支（预测left, top, right, bottom）
        self.reg_convs = nn.Sequential(
            nn.Conv2d(in_channels, mid_channels, 3, padding=1),
            nn.SiLU(),
            nn.Conv2d(mid_channels, mid_channels, 3, padding=1),
            nn.SiLU(),
        )
        self.reg_pred = nn.Conv2d(mid_channels, 4, 1)  # 4 = l,t,r,b
    
    def forward(self, x):
        cls_feat = self.cls_convs(x)
        cls_out = self.cls_pred(cls_feat)
        
        reg_feat = self.reg_convs(x)
        reg_out = self.reg_pred(reg_feat)
        
        return cls_out, reg_out


print("YOLOv8核心变革:")
print("  1. Anchor-Free: 不再需要Anchor，直接预测框")
print("  2. Decoupled Head: 分类和回归分开")
print("  3. C2f模块: CSP改进版")
print("  4. 更简洁、更高效、更易部署")

print("\nAnchor-Based vs Anchor-Free:")
print("  Anchor-Based: bbox = decode(预测偏移, Anchor)")
print("  Anchor-Free:  bbox = 直接预测(l,t,r,b)")
print("  少了一个中间步骤，推理更快，部署更简单！")

2.7 YOLOv10 (2024) --- NMS-Free

"""
YOLOv10：端到端，不需要NMS！

核心创新：
  1. NMS-Free训练 → 推理时不需要NMS后处理
  2. Consistent Dual Assignments → 训练和推理一致
  3. 效率驱动的模型设计 → 轻量级卷积、秩引导的block设计

去掉NMS的意义：
  传统YOLO: 推理 → NMS后处理 → 需要额外时间
  YOLOv10: 推理 → 直接出结果！端到端！
  
  对于端侧部署，NMS是瓶颈之一（特别是密集检测场景）
  去掉NMS = 推理更快 + 部署更简单！
"""

# YOLOv10的One-to-One匹配
def yolov10_label_assignment():
    """
    YOLOv10的一对一标签分配
    
    传统YOLO: 一个GT框匹配多个Anchor（一对多）
    → 推理时多个Anchor可能预测同一个物体 → 需要NMS去掉重复
    
    YOLOv10: 一个GT框只匹配一个预测（一对一）
    → 推理时每个物体只有一个预测框 → 不需要NMS！
    
    但一对一匹配的问题：正样本太少，训练困难
    YOLOv10解决方案：双分支训练
    - 一对多分支：提供丰富的梯度信号
    - 一对一分支：输出最终结果
    """
    print("YOLOv10 NMS-Free原理:")
    print("  传统: 一对多匹配 → 重复框 → NMS去重")
    print("  YOLOv10: 一对一匹配 → 无重复框 → 不需要NMS")
    print("  训练时双分支: 一对多(提供梯度) + 一对一(最终输出)")

yolov10_label_assignment()

---

三、YOLO全景对比

def yolo_full_comparison():
    """YOLO各版本完整对比"""
    versions = {
        'YOLOv1': {
            'year': 2016, 'backbone': '自定义', 'input': 448,
            'anchor': '✗', 'multi_scale': '✗', 'nms_free': '✗',
            'mAP@0.5': '63.4%', 'FPS': 45,
            '核心创新': '端到端回归检测',
        },
        'YOLOv2': {
            'year': 2017, 'backbone': 'Darknet-19', 'input': '多尺度',
            'anchor': '✓', 'multi_scale': '✗', 'nms_free': '✗',
            'mAP@0.5': '78.6%', 'FPS': 40,
            '核心创新': 'Anchor + BN + Passthrough',
        },
        'YOLOv3': {
            'year': 2018, 'backbone': 'Darknet-53', 'input': '多尺度',
            'anchor': '✓', 'multi_scale': '✓ (3层)', 'nms_free': '✗',
            'mAP@0.5': '80.7%', 'FPS': 35,
            '核心创新': 'FPN多尺度 + 多标签分类',
        },
        'YOLOv4': {
            'year': 2020, 'backbone': 'CSPDarknet53', 'input': '多尺度',
            'anchor': '✓', 'multi_scale': '✓ (3层)', 'nms_free': '✗',
            'mAP@0.5': '82.3%', 'FPS': 40,
            '核心创新': 'Mosaic + CIoU + PANet',
        },
        'YOLOv5': {
            'year': 2020, 'backbone': 'CSPDarknet53', 'input': 640,
            'anchor': '✓', 'multi_scale': '✓ (3层)', 'nms_free': '✗',
            'mAP@0.5': '68.9% (x)', 'FPS': '30-150',
            '核心创新': 'PyTorch + 易用性 + 多规格',
        },
        'YOLOv8': {
            'year': 2023, 'backbone': 'CSPDarknet', 'input': 640,
            'anchor': '✗ (Anchor-Free)', 'multi_scale': '✓ (3层)', 'nms_free': '✗',
            'mAP@0.5': '69.5% (x)', 'FPS': '30-160',
            '核心创新': 'Anchor-Free + Decoupled Head',
        },
        'YOLOv10': {
            'year': 2024, 'backbone': '改进CSPDarknet', 'input': 640,
            'anchor': '✗', 'multi_scale': '✓ (3层)', 'nms_free': '✓',
            'mAP@0.5': '~70%', 'FPS': '更快',
            '核心创新': 'NMS-Free + 端到端',
        },
    }
    
    print("YOLO全景对比:")
    print(f"{'版本':<10s} {'年份':<6s} {'Anchor':<10s} {'多尺度':<10s} {'NMS-Free':<10s} {'mAP@0.5':<10s}")
    print('-' * 60)
    for name, info in versions.items():
        print(f"{name:<10s} {info['year']:<6d} {info['anchor']:<10s} {info['multi_scale']:<10s} {info['nms_free']:<10s} {info['mAP@0.5']:<10s}")

yolo_full_comparison()

---

四、动手实践

4.1 实战：YOLO损失函数进化

def loss_evolution():
    """
    YOLO损失函数的进化
    
    定位损失：
    v1-v3: MSE Loss (x, y, w, h)
    v4:    CIoU Loss (加入中心点距离+长宽比)
    v5-v7: CIoU Loss
    v8+:   CIoU + Distribution Focal Loss (DFL)
    
    分类损失：
    v1-v2: MSE Loss
    v3-v7: Binary Cross Entropy (多标签)
    v8+:   Binary Cross Entropy
    
    置信度损失：
    v1-v7: Binary Cross Entropy
    v8+:   去除（Decoupled Head不需要）
    """
    print("YOLO损失函数进化:")
    print("  v1-v2: MSE + MSE + MSE (简单粗暴)")
    print("  v3:    BCE + MSE + BCE (改进分类)")
    print("  v4:    BCE + CIoU + BCE (改进定位)")
    print("  v8:    BCE + CIoU+DFL (去掉置信度)")

loss_evolution()

4.2 实战：YOLOv8 Box解码 vs Anchor-Based

def compare_box_decoding():
    """
    对比Anchor-Based和Anchor-Free的框解码
    """
    # Anchor-Based (YOLOv3-v5-v7)
    def decode_anchor_based(predictions, anchors, stride):
        """
        predictions: (batch, 3, grid_h, grid_w, 85)
        85 = 4(坐标) + 1(置信度) + 80(类别)
        """
        tx, ty, tw, th = predictions[..., 0:4].chunk(4, dim=-1)
        
        # 生成网格坐标
        grid_y, grid_x = torch.meshgrid(
            torch.arange(grid_h), torch.arange(grid_w), indexing='ij'
        )
        
        # 解码
        bx = (torch.sigmoid(tx) * 2 - 0.5 + grid_x) * stride
        by = (torch.sigmoid(ty) * 2 - 0.5 + grid_y) * stride
        bw = (torch.sigmoid(tw) * 2) ** 2 * anchors[..., 0] * stride
        bh = (torch.sigmoid(th) * 2) ** 2 * anchors[..., 1] * stride
        
        return torch.cat([bx, by, bw, bh], dim=-1)
    
    # Anchor-Free (YOLOv8+)
    def decode_anchor_free(predictions, stride):
        """
        predictions: (batch, 4, grid_h, grid_w)
        4 = left, top, right, bottom
        """
        lt, tp, rt, bm = predictions[..., 0:4].chunk(4, dim=-1)
        
        grid_y, grid_x = torch.meshgrid(
            torch.arange(grid_h), torch.arange(grid_w), indexing='ij'
        )
        
        # 直接解码为框坐标
        x1 = (grid_x - lt) * stride  # left
        y1 = (grid_y - tp) * stride  # top
        x2 = (grid_x + rt) * stride  # right
        y2 = (grid_y + bm) * stride  # bottom
        
        return torch.stack([x1, y1, x2, y2], dim=-1)
    
    print("框解码对比:")
    print("  Anchor-Based: 需要sigmoid/sqrt/exp + Anchor")
    print("  Anchor-Free:  直接预测(l,t,r,b) → 简单很多！")
    print("  端侧部署: Anchor-Free更容易优化和量化")

compare_box_decoding()

---

五、端侧AI选型指南

def edge_yolo_selection():
    """
    端侧AI YOLO版本选型
    """
    guide = {
        '追求精度 + 有GPU': {
            '推荐': 'YOLOv8m/l + TensorRT FP16',
            'FPS': '60-150',
            '场景': 'Jetson Orin、边缘服务器',
        },
        '速度优先 + 算力有限': {
            '推荐': 'YOLOv8n/s + TensorRT INT8',
            'FPS': '100-300',
            '场景': 'Jetson Nano、树莓派+TPU',
        },
        '极致轻量 + 移动端': {
            '推荐': 'YOLOv8n + NCNN/MNN',
            'FPS': '20-50',
            '场景': 'Android/iOS APP',
        },
        '最新技术 + 追求极致': {
            '推荐': 'YOLOv10n/s',
            'FPS': '更快（NMS-Free）',
            '场景': '需要NMS-Free的场景',
        },
        '稳定 + 社区支持好': {
            '推荐': 'YOLOv5s/m',
            'FPS': '50-100',
            '场景': '大多数端侧项目',
        },
    }
    
    print("端侧AI YOLO选型:")
    for scenario, config in guide.items():
        print(f"\n  [{scenario}]")
        for k, v in config.items():
            print(f"    {k}: {v}")

edge_yolo_selection()

---

六、常见坑点

坑1：YOLO版本号混乱

# YOLOv4作者是AlexeyAB（不是Joseph Redmon！）
# YOLOv5是Ultralytics出品（不是官方正统）
# YOLOv8也是Ultralytics（和v5同一个团队）
# Joseph Redmon在v3之后退出了CV领域

# 面试常问：YOLOv4是谁提出的？→ Alexey Bochkovskiy

坑2：不同YOLO版本的输入尺寸要求

# YOLOv1: 448×448
# YOLOv2-v3: 416×416（常用）或608×608
# YOLOv5-v8: 640×640（默认）
# 输入尺寸必须是32的倍数（因为有5次下采样）

坑3：Anchor尺寸和数据集不匹配

# COCO的Anchor不适合你的数据集 → 用K-Means重新聚类
# YOLOv5中自动聚类：--noautoanchor 关闭自动聚类
# YOLOv8+: Anchor-Free，不需要关心这个问题！

坑4：训练时混淆不同YOLO的标签格式

# YOLOv1-v3: [class, x_center, y_center, w, h] (归一化)
# YOLOv5-v7: [class, x_center, y_center, w, h] (归一化)
# YOLOv8+: 同上，但txt格式不同
# 不同版本之间标签格式不完全兼容！

---

七、今日作业

1. YOLO进化：画出YOLO v1→v10的进化时间线，标注每个版本的核心创新
2. 框解码：实现Anchor-Based和Anchor-Free两种框解码函数，对比差异
3. 端侧选型：根据你的项目需求，选择最合适的YOLO版本，给出理由
4. 打卡 ：评论区发你的选型分析，格式："Day 29/100 打卡：YOLO进化史已掌握！"

---

今日小结

今天你学会了：
✅ YOLO v1→v10完整进化史
✅ YOLOv1: 网格回归，端到端检测
✅ YOLOv2: Anchor + BN + Passthrough
✅ YOLOv3: 多尺度预测 + Darknet-53
✅ YOLOv4: Mosaic + CIoU + PANet
✅ YOLOv5: PyTorch + 多规格 + 易用性
✅ YOLOv8: Anchor-Free + Decoupled Head
✅ YOLOv10: NMS-Free + 端到端
✅ Anchor-Based vs Anchor-Free 框解码
✅ 端侧AI YOLO选型指南
✅ 4个经典坑点

---

明日预告

Day 30：第二阶段总结与自测

15天深度学习知识回顾 + 30道选择题 + 综合实战项目

---

🔥 关注我，每天解锁一个端侧AI技能！

微信公众号：xxx | 小红书：xxx | CSDN：xxx

评论区打卡，一起坚持100天！

---

附：小红书图文版

封面标题建议：YOLO全系列解析 | v1到v10，一篇看懂进化史 🚀

P1 --- 封面

标题：YOLO系列详解

副标题：v1→v10进化史 / Anchor-Free / NMS-Free

关键词：YOLO / 目标检测 / 端侧AI

P2 --- YOLO进化时间线

2016 v1: 端到端回归

2017 v2: Anchor + BN

2018 v3: 多尺度 + Darknet-53

2020 v4: Tricks大集合

2020 v5: PyTorch + 最流行

2023 v8: Anchor-Free革命

2024 v10: NMS-Free

P3 --- 核心变革：Anchor-Free

旧版: 预测偏移 → 解码 → 需要Anchor

新版: 直接预测(l,t,r,b) → 不需要Anchor

更简单、更快、更易部署

YOLOv8的最大变革！

P4 --- 核心变革：NMS-Free

传统: 推理 → NMS → 输出

YOLOv10: 推理 → 直接输出

一对一匹配 → 无重复框

端侧部署的终极简化！

P5 --- 端侧选型指南

追求精度: YOLOv8m + TensorRT

速度优先: YOLOv8n + INT8量化

移动端: YOLOv8n + NCNN/MNN

稳定可靠: YOLOv5s

P6 --- 今日作业

YOLO进化时间线 + 框解码对比

评论区打卡 Day 29/100

标签：#YOLO #目标检测 #AnchorFree #NMSFree #端侧AI

---

CSDN发布提示：CSDN版本建议在YOLO进化部分放一张大时间线图，在Anchor-Based vs Anchor-Free部分放两张对比图，在框解码公式部分放公式推导图。