# 迁移学习与微调

> 别人花了一百万 GPU 小时，教会一个网络边缘、纹理和物体部件长什么样。在训练你自己的之前，你应该把那些特征借过来。

**类型：** Build
**语言：** Python
**前置要求：** 阶段 4 第 03 课（CNN）、阶段 4 第 04 课（图像分类）
**预计时间：** ~75 分钟

## 学习目标

- 区分特征提取和微调，并根据数据集规模、领域距离和算力预算挑对那一个
- 加载一个预训练骨干，替换它的分类头，只训练头部，在 20 行以内达到一个能用的基线
- 用差异化学习率渐进解冻各层，让早期的通用特征比后期的任务特定特征更新得更小
- 诊断三种常见故障：解冻块上学习率过高导致的特征漂移、小数据集上 BN 统计量崩溃、灾难性遗忘

## 问题背景

在 ImageNet 上训练一个 ResNet-50 大约要 2,000 GPU 小时。很少有团队能为他们交付的每个任务都掏这个预算。几乎每个团队实际交付的，是一个预训练骨干，配上一个在几百或几千张任务特定图像上训练的新头部。

这不是抄近路。任何 ImageNet 训练的 CNN，它的第一个卷积块学的是边缘和类 Gabor 滤波器。接下来几个块学纹理和简单图案。中间的块学物体部件。最后的块学那些开始像 1,000 个 ImageNet 类别的组合。这个层级前 90% 几乎原封不动地迁移到医学影像、工业检测、卫星数据和其他每个视觉任务——因为大自然的边缘和纹理词汇是有限的。最后 10% 才是你真正要训练的。

把迁移做对，有三个 bug 在等着你：用过高的学习率毁掉预训练特征、冻得太多让模型信息不足、让 BatchNorm 的运行统计量漂向一个网络其余部分从未学过的小数据集。这一课故意把每一个都走一遍。

## 核心概念

### 特征提取 vs 微调

两种模式，看你多信任预训练特征、手头有多少数据来选。

```mermaid
flowchart TB
    subgraph FE["特征提取 —— 骨干冻结"]
        FE1["预训练骨干<br/>（无梯度）"] --> FE2["新头部<br/>（训练）"]
    end
    subgraph FT["微调 —— 端到端"]
        FT1["预训练骨干<br/>（极小 LR）"] --> FT2["新头部<br/>（正常 LR）"]
    end

    style FE1 fill:#e5e7eb,stroke:#6b7280
    style FE2 fill:#dcfce7,stroke:#16a34a
    style FT1 fill:#fef3c7,stroke:#d97706
    style FT2 fill:#dcfce7,stroke:#16a34a
```

经验法则：

| 数据集规模 | 领域距离 | 配方 |
|--------------|-----------------|--------|
| < 1k 张 | 接近 ImageNet | 冻结骨干，只训练头部 |
| 1k-10k | 接近 | 冻结前 2-3 个阶段，微调其余 |
| 10k-100k | 任意 | 用差异化 LR 端到端微调 |
| 100k+ | 远 | 全部微调；如果领域足够远，考虑从零训练 |

"接近 ImageNet"大致意思是带物体内容的自然 RGB 照片。医学 CT 扫描、俯视卫星影像和显微图像是远领域——特征仍然有帮助，但你需要让更多层去适应。

### 冻结为什么能行得通

CNN 学到的 ImageNet 特征不是为那 1,000 个类别特化的。它们是为自然图像的统计量特化的：特定朝向的边缘、纹理、对比模式、形状原语。这些统计量在人类能叫得出名字的几乎每个视觉领域里都稳定。这就是为什么一个在 ImageNet 上训练、仅加一个新线性头（不微调骨干）就在 CIFAR-10 上零样本评估的模型，能达到 80%+ 的准确率。头部是在学：对这个任务，该给已经学到的特征里哪些加权。

### 差异化学习率

当你确实要解冻时，早期层应该比后期层训练得慢。早期层编码你想保留的通用特征；后期层编码你需要大幅移动的任务特定结构。

```
典型配方：

  stage 0（stem + 第一组）：    lr = base_lr / 100    （基本固定）
  stage 1：                     lr = base_lr / 10
  stage 2：                     lr = base_lr / 3
  stage 3（最后一个骨干组）：   lr = base_lr
  head：                        lr = base_lr  （或略高）
```

在 PyTorch 里，这就是传给优化器的一个参数组列表。一个模型，五个学习率，零额外代码。

### BatchNorm 问题

BN 层持有 `running_mean` 和 `running_var` 缓冲区，它们是在 ImageNet 上算的。如果你的任务有不同的像素分布——不同的光照、不同的传感器、不同的色彩空间——那些缓冲区就是错的。按偏好顺序排的三个选项：

1. **让 BN 处于 train 模式微调。** 让 BN 和其他一切一起更新它的运行统计量。任务数据集中等规模（>= 5k 样本）时的默认选择。
2. **让 BN 处于 eval 模式冻结。** 保留 ImageNet 统计量，只训练权重。当你的数据集小到 BN 的移动平均会很嘈杂时，这是对的。
3. **用 GroupNorm 替换 BN。** 彻底去掉移动平均问题。用于每 GPU batch size 极小的检测和分割骨干。

这个搞错了，会悄无声息地把准确率拉低 5-15%。

### 头部设计

分类头是 1-3 个线性层加一个可选的 dropout。每个 torchvision 骨干都自带一个默认头，你来替换它：

```
backbone.fc = nn.Linear(backbone.fc.in_features, num_classes)          # ResNet
backbone.classifier[1] = nn.Linear(..., num_classes)                    # EfficientNet、MobileNet
backbone.heads.head = nn.Linear(..., num_classes)                       # torchvision ViT
```

对小数据集，一个线性层通常就够。当任务分布离骨干的训练分布更远时，加一个隐藏层（Linear -> ReLU -> Dropout -> Linear）有帮助。

### 逐层 LR 衰减

差异化 LR 的一个更平滑版本，用于现代微调（BEiT、DINOv2、ViT-B 微调）。不是把层分组成阶段，而是给每一层一个比它上面那层略小的 LR：

```
lr_layer_k = base_lr * decay^(L - k)
```

decay = 0.75、L = 12 个 transformer 块时，第一块以头部 LR 的 `0.75^11 ≈ 0.04x` 训练。对 transformer 微调比对 CNN 更要紧，CNN 用按阶段分组的 LR 通常就够了。

### 评估什么

迁移学习的运行需要两个你在从零训练时不会去追踪的数：

- **仅预训练准确率** —— 骨干冻结时头部的准确率。这是你的下限。
- **微调后准确率** —— 同一个模型端到端训练后的准确率。这是你的上限。

如果微调后比仅预训练还低，你有一个学习率或 BN 的 bug。永远把两个都打印出来。

## 动手构建

### 第 1 步：加载一个预训练骨干并检查它

```python
import torch
import torch.nn as nn
from torchvision.models import resnet18, ResNet18_Weights

backbone = resnet18(weights=ResNet18_Weights.IMAGENET1K_V1)
print(backbone)
print()
print("classifier head:", backbone.fc)
print("feature dim:", backbone.fc.in_features)
```

`ResNet18` 有四个阶段（`layer1..layer4`），加一个 stem 和一个 `fc` 头。每个 torchvision 分类骨干都有类似的结构。

### 第 2 步：特征提取 —— 冻结一切，替换头部

```python
def make_feature_extractor(num_classes=10):
    model = resnet18(weights=ResNet18_Weights.IMAGENET1K_V1)
    for p in model.parameters():
        p.requires_grad = False
    model.fc = nn.Linear(model.fc.in_features, num_classes)
    return model

model = make_feature_extractor(num_classes=10)
trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
frozen = sum(p.numel() for p in model.parameters() if not p.requires_grad)
print(f"trainable: {trainable:>10,}")
print(f"frozen:    {frozen:>10,}")
```

只有 `model.fc` 可训练。骨干是一个冻结的特征提取器。

### 第 3 步：差异化微调

一个工具函数，构建带阶段特定学习率的参数组。

```python
def discriminative_param_groups(model, base_lr=1e-3, decay=0.3):
    stages = [
        ["conv1", "bn1"],
        ["layer1"],
        ["layer2"],
        ["layer3"],
        ["layer4"],
        ["fc"],
    ]
    groups = []
    for i, names in enumerate(stages):
        lr = base_lr * (decay ** (len(stages) - 1 - i))
        params = [p for n, p in model.named_parameters()
                  if any(n.startswith(k) for k in names)]
        if params:
            groups.append({"params": params, "lr": lr, "name": "_".join(names)})
    return groups

model = resnet18(weights=ResNet18_Weights.IMAGENET1K_V1)
model.fc = nn.Linear(model.fc.in_features, 10)
for p in model.parameters():
    p.requires_grad = True

groups = discriminative_param_groups(model)
for g in groups:
    print(f"{g['name']:>10s}  lr={g['lr']:.2e}  params={sum(p.numel() for p in g['params']):>8,}")
```

`decay=0.3` 意味着每个阶段以下一个阶段 30% 的速率训练。`fc` 拿到 `base_lr`，`layer4` 拿到 `0.3 * base_lr`，`conv1` 拿到 `0.3^5 * base_lr ≈ 0.00243 * base_lr`。听起来很极端；经验上它管用。

### 第 4 步：BatchNorm 处理

一个 helper，冻结 BN 的运行统计量但不冻结它的权重。

```python
def freeze_bn_stats(model):
    for m in model.modules():
        if isinstance(m, (nn.BatchNorm1d, nn.BatchNorm2d, nn.BatchNorm3d)):
            m.eval()
            for p in m.parameters():
                p.requires_grad = False
    return model
```

在每个 epoch 开头设置完 `model.train()` 之后调用它。`model.train()` 把一切翻到训练模式；这个只对 BN 层把它翻回去。

### 第 5 步：一个极简的端到端微调循环

```python
from torch.optim import SGD
from torch.utils.data import DataLoader
from torch.optim.lr_scheduler import CosineAnnealingLR
import torch.nn.functional as F

def fine_tune(model, train_loader, val_loader, device, epochs=5, base_lr=1e-3, freeze_bn=False):
    model = model.to(device)
    groups = discriminative_param_groups(model, base_lr=base_lr)
    optimizer = SGD(groups, momentum=0.9, weight_decay=1e-4, nesterov=True)
    scheduler = CosineAnnealingLR(optimizer, T_max=epochs)

    for epoch in range(epochs):
        model.train()
        if freeze_bn:
            freeze_bn_stats(model)
        tr_loss, tr_correct, tr_total = 0.0, 0, 0
        for x, y in train_loader:
            x, y = x.to(device), y.to(device)
            logits = model(x)
            loss = F.cross_entropy(logits, y, label_smoothing=0.1)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            tr_loss += loss.item() * x.size(0)
            tr_total += x.size(0)
            tr_correct += (logits.argmax(-1) == y).sum().item()
        scheduler.step()

        model.eval()
        va_total, va_correct = 0, 0
        with torch.no_grad():
            for x, y in val_loader:
                x, y = x.to(device), y.to(device)
                pred = model(x).argmax(-1)
                va_total += x.size(0)
                va_correct += (pred == y).sum().item()
        print(f"epoch {epoch}  train {tr_loss/tr_total:.3f}/{tr_correct/tr_total:.3f}  "
              f"val {va_correct/va_total:.3f}")
    return model
```

在 CIFAR-10 上用上面这个配方训五个 epoch，能把 `ResNet18-IMAGENET1K_V1` 从约 70% 的零样本线性探针准确率带到约 93% 的微调后准确率。单靠头部、永不触碰骨干的话，会在 86% 左右停滞。

### 第 6 步：渐进解冻

一个调度，从末端往开头方向每个 epoch 解冻一个阶段。以多花几个 epoch 为代价，缓解特征漂移。

```python
def progressive_unfreeze_schedule(model):
    stages = ["layer4", "layer3", "layer2", "layer1"]
    yielded = set()

    def start():
        for p in model.parameters():
            p.requires_grad = False
        for p in model.fc.parameters():
            p.requires_grad = True

    def unfreeze(epoch):
        if epoch < len(stages):
            name = stages[epoch]
            yielded.add(name)
            for n, p in model.named_parameters():
                if n.startswith(name):
                    p.requires_grad = True
            return name
        return None

    return start, unfreeze
```

第一个 epoch 之前调用一次 `start()`。每个 epoch 开头调用 `unfreeze(epoch)`。每当可训练参数的集合变化时就重建优化器，否则被冻结的参数仍持有缓存的动量，会把它搞糊涂。

## 实际使用

对大多数真实任务，`torchvision.models` + 三行就够了。上面那套更重的机制，是在你撞上库默认值修不了的问题时才要紧。

```python
from torchvision.models import resnet50, ResNet50_Weights

model = resnet50(weights=ResNet50_Weights.IMAGENET1K_V2)
model.fc = nn.Linear(model.fc.in_features, num_classes)
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4, weight_decay=1e-4)
```

另外两个生产级的默认选择：

- `timm` 提供约 800 个预训练视觉骨干，API 一致（`timm.create_model("resnet50", pretrained=True, num_classes=10)`）。任何超出 torchvision 模型库的微调，它都是标准。
- 对 transformer，`transformers.AutoModelForImageClassification.from_pretrained(name, num_labels=N)` 给你 ViT / BEiT / DeiT，加载语义和文本模型一样。

## 拿去用

这一课产出：

- `outputs/prompt-fine-tune-planner.md` —— 一个 prompt，根据数据集规模、领域距离和算力预算，在特征提取、渐进式、端到端微调之间挑选。
- `outputs/skill-freeze-inspector.md` —— 一个 skill，给定一个 PyTorch 模型，报告哪些参数可训练、哪些 BatchNorm 层处于 eval 模式，以及优化器是否真的拿到了那些可训练参数。

## 练习

1. **（简单）** 在同一个合成 CIFAR 数据集上，把一个 `ResNet18` 作为线性探针（骨干冻结）训一遍、再作为完整微调训一遍。把两个准确率并排报出来。解释哪个差距告诉你特征迁移得好，哪个告诉你它们迁移得不好。
2. **（中等）** 故意引入一个 bug：把骨干阶段的 `base_lr` 设成 `1e-1` 而不是头部的。展示训练损失爆炸，然后应用 `discriminative_param_groups` helper 恢复。记录每个阶段开始发散时的 LR。
3. **（困难）** 拿一个医学影像数据集（例如 CheXpert-small、PatchCamelyon 或 HAM10000），对比三种模式：(a) ImageNet 预训练冻结骨干 + 线性头；(b) ImageNet 预训练端到端微调；(c) 从零训练。各报告准确率和算力成本。在多大的数据集规模下，从零训练才变得有竞争力？

## 关键术语

| 术语 | 大家嘴上怎么说 | 它实际是什么 |
|------|----------------|----------------------|
| 特征提取 | "冻结并训练头部" | 骨干参数冻结，只有新分类头接收梯度 |
| 微调 | "端到端重新训练" | 所有参数可训练，通常 LR 比从零训练小得多 |
| 差异化 LR | "早期层用更小的 LR" | 优化器参数组中，早期阶段 LR 是后期阶段 LR 的一个分数 |
| 逐层 LR 衰减 | "平滑的 LR 梯度" | 每层 LR 乘以 decay^(L - k)；在 transformer 微调里常见 |
| 灾难性遗忘 | "模型丢了 ImageNet" | 过高的 LR 在新任务信号学到之前就覆盖了预训练特征 |
| BN 统计量漂移 | "running mean 错了" | BatchNorm 的 running_mean/var 是在与当前任务不同的分布上算的，悄悄拉低准确率 |
| 线性探针 | "冻结骨干 + 线性头" | 对预训练特征的评估——在冻结表示之上最好的线性分类器的准确率 |
| 灾难性崩溃 | "全都预测成一个类" | 用高到足以在头部梯度稳定之前就毁掉特征的 LR 微调时会发生 |

## 延伸阅读

- [How transferable are features in deep neural networks? (Yosinski et al., 2014)](https://arxiv.org/abs/1411.1792) —— 量化了特征跨层可迁移性的那篇论文
- [Universal Language Model Fine-tuning (ULMFiT, Howard & Ruder, 2018)](https://arxiv.org/abs/1801.06146) —— 最初的差异化 LR / 渐进解冻配方；这些点子直接迁移到视觉
- [timm documentation](https://huggingface.co/docs/timm) —— 现代视觉骨干，以及它们训练时所用精确微调默认值的参考
- [A Simple Framework for Linear-Probe Evaluation (Kornblith et al., 2019)](https://arxiv.org/abs/1805.08974) —— 为什么线性探针准确率要紧，以及如何正确地报告它
