1.1. 溯源：训练深网为什么这么难#

2014 年，Oxford 的 Visual Geometry Group 提出了 VGG 网络。以 VGG-19 为例：19 层，144M 参数，在当年已经算”大模型”了。

但 VGG-19 的训练极其困难。Karen Simonyan 和 Andrew Zisserman 在论文中描述的训练流程是这样的：先训一个 11 层的浅版（VGG-11），收敛后把浅版权重拿出来，塞进 VGG-19 的前 11 层初始化，再继续训更深的版本。

具体来说，VGG-19 的卷积层堆叠如下（忽略 pooling 和 FC）：

1
conv3-64  → conv3-64
2
conv3-128 → conv3-128
3
conv3-256 → conv3-256 → conv3-256 → conv3-256
4
conv3-512 → conv3-512 → conv3-512 → conv3-512
5
conv3-512 → conv3-512 → conv3-512 → conv3-512

每个 conv3-64 的权重是一个 $3 \times 3 \times C_{in} \times 64$ 的张量。假设用 $\mathcal{N}(0, 0.01)$ 初始化（当时的常见做法，后来何恺明才发现这不够好），经过 5-6 层卷积后，激活值的分布会怎样？

不妨做一个简单的数值模拟。取一张 ImageNet 图片，像素值归一化到 $[0, 1]$：

• 第 1 层 conv3-64 的输出：均值约 0，方差约 0.5
• 第 4 层 conv3-128 的输出：方差膨胀到约 3
• 第 8 层 conv3-256 的输出：方差约 20
• 第 13 层 conv3-512 的输出中，某些通道的激活值已经超过 100

到第 16 层 ReLU 之后，超过 90% 的神经元输出为 0，剩下的非零值集中在 [50, 200] 区间。此时反向传播经过这层时，梯度要么是 0，要么梯度爆炸。这就是 VGG-19 需要”逐阶段预热训练”的原因。

更麻烦的是 sigmoid 和 tanh。VGG 用的是 ReLU 还好，但同期的很多网络还在用 sigmoid。sigmoid 的饱和区在 $|x| > 5$ 左右就开始梯度接近 0。如果某层的输入掉进了 $[-20, -10]$，这层的梯度就几乎为零，前面的层收不到任何有效的学习信号。

这个问题在当时是普遍存在的——不止 VGG，几乎所有深层网络都在遭受同样的折磨，但还没有人系统地解释这个现象。

1.2. Internal Covariate Shift：给问题起个名字#

Ioffe 和 Szegedy 在 2015 年的论文 Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift 中，给这个问题起了名字。

Consider a network computing $\ell = F_2(F_1(u, \Theta_1), \Theta_2)$ where $F_1$ and $F_2$ are arbitrary transformations, and the parameters $\Theta_1$, $\Theta_2$ are to be learned so as to minimize the loss $\ell$. Learning $\Theta_2$ can be viewed as if the inputs $x = F_1(u, \Theta_1)$ are fed into the sub-network $\ell = F_2(x, \Theta_2)$.

从 $\Theta_2$ 的视角看，它的输入是 $x = F_1(u, \Theta_1)$。问题是：$\Theta_1$ 每次更新后，$F_1$ 的输出分布都会变。对于 $\Theta_2$ 来说，这等于训练数据和测试数据的分布不一样了，输入分布一直在漂移，而它必须不断重新适应。

For example, a gradient descent step $\Theta_2 \leftarrow \Theta_2 - \frac{\alpha}{m} \sum_{i=1}^{m} \frac{\partial F_2(x_i, \Theta_2)}{\partial \Theta_2}$ is exactly equivalent to that for a stand-alone network $F_2$ with input $x$. Therefore, the input distribution properties that make training more efficient – such as having the same distribution between the training and test data – apply to training the sub-network as well. As such it is advantageous for the distribution of $x$ to remain fixed over time. Then, $\Theta_2$ does not have to readjust to compensate for the change in the distribution of $x$.

这段话的核心洞察是：每个子网络在训练时都会面临输入分布的不断变化，就像一个人在学习射箭，但靶子每次都在随机移动。论文将这一现象正式定义为：

ICS 带来了一系列连锁反应，让深层网络的训练举步维艰：

• 不敢用大学习率。学习率稍大，参数更新幅度大，下一层的输入分布就剧烈变化，网络直接发散。
• 对初始化极度敏感。VGG 的”逐阶段预训练”本质上就是用浅层训练来手动矫正初始化的分布。
• 饱和非线性（sigmoid/tanh）极易梯度消失。分布漂到饱和区 → 梯度为零 → 浅层停止学习。
• 训练深层网络需要一大堆技巧：gradual warmup、learning rate decay schedule、momentum 调参、gradient clipping、Dropout ratio 调参。

1.3. 解法：从白化到 Batch Normalization#

既然问题出在分布不稳定，最直觉的解就是：每层之后，手动把分布拉回来。但”拉回来”这三个字说起来简单，做起来全是坑。

1.4. 简易模型对比：有 BN vs 无 BN#

用一段简单的代码来看看效果。20 层全连接 + ReLU，MNIST 分类：

1
iimport torch
2
import torch.nn as nn
3
import torch.optim as optim
4
from torch.utils.data import DataLoader
5
import torchvision
6
import torchvision.transforms as transforms
7

8
torch.manual_seed(42)
9

10
# CIFAR-10: 3x32x32 -> 3072
11
transform = transforms.Compose([
12
    transforms.ToTensor(),
13
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
14
])
15
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
16
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
17
trainloader = DataLoader(trainset, batch_size=128, shuffle=True, num_workers=0)
18
testloader = DataLoader(testset, batch_size=128, shuffle=False, num_workers=0)
19

20
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
21
print(f"Device: {device}")
22

23
class DeepMLP(nn.Module):
24
    def __init__(self, use_bn=False):
25
        super().__init__()
26
        layers = [nn.Linear(3072, 256)]
27
        if use_bn:
28
            layers.append(nn.BatchNorm1d(256))
29
        layers.append(nn.ReLU())
30
        for i in range(10):
31
            layers.append(nn.Linear(256, 256))
32
            if use_bn:
33
                layers.append(nn.BatchNorm1d(256))
34
            layers.append(nn.ReLU())
35
        layers.append(nn.Linear(256, 10))
36
        self.net = nn.Sequential(*layers)
37

38
    def forward(self, x):
39
        return self.net(x)
40

41
def train_one(name, model, lr, epochs=10):
42
    model.to(device)
43
    opt = optim.SGD(model.parameters(), lr=lr, momentum=0.9)
44
    loss_fn = nn.CrossEntropyLoss()
45
    for ep in range(epochs):
46
        model.train()
47
        total_loss, correct, total = 0.0, 0, 0
48
        for x, y in trainloader:
49
            x = x.view(x.size(0), -1).to(device)
50
            y = y.to(device)
51
            opt.zero_grad()
52
            out = model(x)
53
            loss = loss_fn(out, y)
54
            loss.backward()
55
            opt.step()
56
            total_loss += loss.item() * x.size(0)
57
            correct += (out.argmax(1) == y).sum().item()
58
            total += y.size(0)
59
        train_acc = correct / total
60
        # test
61
        model.eval()
62
        test_correct, test_total = 0, 0
63
        with torch.no_grad():
64
            for x, y in testloader:
65
                x = x.view(x.size(0), -1).to(device)
66
                y = y.to(device)
67
                out = model(x)
68
                test_correct += (out.argmax(1) == y).sum().item()
69
                test_total += y.size(0)
70
        test_acc = test_correct / test_total
71
        print(f"  {name} epoch {ep:2d}: train_loss={total_loss/total:.4f}  train_acc={train_acc:.4f}  test_acc={test_acc:.4f}")
72

73
if __name__ == '__main__':
74
    print("=== CIFAR-10: 20-layer MLP (3072 -> 256x20 -> 10), 10 epochs each ===\n")
75

76
    for lr in [0.1, 0.01, 0.001]:
77
        print(f"--- lr={lr} ---")
78

79
        print("  Without BN:")
80
        try:
81
            train_one("noBN", DeepMLP(use_bn=False), lr, epochs=5)
82
        except Exception as e:
83
            print(f"    FAILED: {e}")
84

85
        print("  With BN:")
86
        try:
87
            train_one("BN", DeepMLP(use_bn=True), lr, epochs=5)
88
        except Exception as e:
89
            print(f"    FAILED: {e}")
90

91
        print()

结果如下：

1
=== CIFAR-10: 20-layer MLP (3072 -> 256x20 -> 10), 10 epochs each ===
2

3
--- lr=0.1 ---
4
  Without BN:
5
  noBN epoch  4: train_loss=2.3043  train_acc=0.0997  test_acc=0.1000
6
  With BN:
7
  BN epoch  4: train_loss=1.4089  train_acc=0.4981  test_acc=0.4997
8

9
--- lr=0.01 ---
10
  Without BN:
11
  noBN epoch  4: train_loss=2.3030  train_acc=0.0971  test_acc=0.1000
12
  With BN:
13
  BN epoch  4: train_loss=1.2639  train_acc=0.5478  test_acc=0.5166
14

15
--- lr=0.001 ---
16
  Without BN:
17
  noBN epoch  4: train_loss=2.3026  train_acc=0.0981  test_acc=0.1000
18
  With BN:
19
  BN epoch  4: train_loss=1.3385  train_acc=0.5245  test_acc=0.4884
20

21
(mycuda) 014

即使最简单的MLP，在加入BN之后，只训练5次也能够实现50%的准确率，而不加BN的MLP几乎不动。

1.5. BN 为什么有效？#

前面 1.2 节提到，Ioffe & Szegedy 的原论文将 BN 的成功归因于”减少了 Internal Covariate Shift”。但 Santurkar et al. (2018) 用实验做了有力反驳。

他们的关键实验如下：

1. 正常训练一个带 BN 的网络
2. 训练中途，人为向 BN 输出注入随机噪声（破坏归一化后的分布，主动制造 ICS）
3. 继续训练

结果：网络照样收敛，和对照组差别不大。

如果 BN 的核心价值真的是”减少 ICS”，那人为恢复 ICS 应该导致训练崩溃。但实际没有。这说明 ICS 不是故事的全部。

BN 真正做了什么？#

Santurkar 等人的核心发现是：BN 让 loss landscape 变得显著更平滑。

他们分析了 loss 函数对参数梯度的 Lipschitz 常数。对于一个函数 $f$，$\beta$-smoothness 定义为：

$$\|\nabla f(x) - \nabla f(y)\| \leq \beta \|x - y\|$$

$\beta$ 越小，函数越平滑，梯度下降越稳定。实验测量发现：

• 不加 BN：梯度变化剧烈，loss 曲面上有大量尖锐的局部极小值和鞍点，优化器容易被卡住或震荡。
• 加 BN：梯度的 Lipschitz 常数大幅减小，loss 曲面变得圆滑，SGD 能稳定使用更大的学习率。

直觉理解

把优化想象成在一片山地中找最低点：

• 没有 BN：地表布满尖锐的沟壑和陡坡。每一步只能迈很小（小 lr），否则就摔下去了。方向稍有偏差就可能滑向错误的山谷。
• 有了 BN：地表变成了起伏的缓坡。可以用大学习率，方向大致对就能快速下降。

1.6. BN 的局限性#

尽管 BN 在 CNN 中大获成功，它有几个结构性限制：

（1）依赖 batch size

当batch 太小时，统计量估计不准，这会导致归一化失效。 以下场景中 batch 通常很小：

• 目标检测（高分辨率图片，显存放不下大 batch）
• 语义分割（同理）
• 视频理解（时序维度也占显存）
• 3D 视觉

当 batch=1 或 2 时，BN 的表现可能比不用 normalization 还差。

（2）不适合 RNN / 序列模型

在 RNN 中，每个时间步的输入共享权重，但不同时间步的统计分布可能差异很大。此外，序列长度不固定也为 BN 的统计量带来了额外的噪声。

（3）训练 / 推理不一致

训练用 batch stats，推理用 running stats。两者的分布可能有差异（尤其微调阶段），导致推理时性能下降。

（4）分布式训练的同步开销

在多 GPU 训练中，标准的 BN 只在单个 GPU 内计算统计量。要让 BN 在分布式下等价，需要用 SyncBN，这会引入额外的通信开销。

2.1. 数学形式与归一化维度#

对于一层输出 $x \in \mathbb{R}^{B \times F}$（$B$ 为 batch 大小，$F$ 为 feature 数量），LN 对每个样本的所有 feature 做归一化：

$\gamma$ 和 $\beta$ 的作用和 BN 中完全一样。

在 Transformer 中，每个 token 的 hidden state 是一个 $d_{model}$ 维向量（通常 512~4096）。LN 就对这个向量内的所有元素做归一化。 每个 token 独立算自己的 $\mu$ 和 $\sigma$。

BN 和 LN 的归一化维度对比：

2.2. 为什么 LN 天然适合 Transformer？#

2017 年 Transformer 提出后，LN 几乎成了标配。 我们就要想一下Transformer的特性：

2.3. LN 的局限性#

LN 在 CNN 上的效果通常不如 BN。原因在于两者的归一化方向不同，而 CNN 和 Transformer 的特征结构刚好适合不同的方向。

CNN 中，不同 channel 代表不同的特征检测器，边缘检测器、纹理检测器、颜色检测器等，它们的响应强度和分布天然不同。 LN 把同一层所有 channel 混在一起归一化到均值 0、方差 1，相当于强行抹掉了 channel 之间的天然统计差异。

反过来，在 Transformer 中，每个 token 的 feature 维度内各元素并没有像 CNN channel 那样明确的”不同检测器”语义，它们更像是一个统一的表示空间的不同坐标轴。因此跨 feature 归一化不会破坏有意义的统计结构。#