一个两层的小网络,训练了整整两万步,loss 停在 0.125 再也不动。打印输出发现,四条样本的预测全是 0.5,模型像坏掉了一样。检查代码没有报错,梯度也在更新,问题出在第一行:所有权重都初始化成了零。

另一批常见的问题正好相反。有人为了「更充分」,把权重初始化成很大的随机数,第一轮 loss 直接变成无穷;有人加了 dropout,训练 loss 反而降不下去;有人把 batch 从 32 改到 256,沿用原来的学习率,结果模型几乎不收敛。

这些手段经常被一起塞进训练脚本,却很少有人知道它们各自在管什么。这篇按四个部分讲:初始化如何决定网络能不能学、激活尺度为什么会逐层衰减或爆炸、dropout 训练和推理为什么不一样、学习率和 batch 为什么必须成对调整。每个部分都有一个只用标准库就能跑的小实验。

初始化:全零为什么等于只有一半的网络

先看结论:权重不能全部初始化为零。原因不是「梯度为零所以不更新」这么简单,而是同一层的多个隐藏单元会保持完全对称。它们的输入相同、权重相同,前向算出的激活一样,反向拿到的梯度也一样,更新之后依然一样。两个单元永远做同一件事,等于只有一个单元。

下面这段训练一个两层 sigmoid 网络解 XOR,隐藏层两个单元,分别用全零初始化和随机初始化,各跑两万步。

import math
import random

random.seed(7)

def sigmoid(x):
    return 1.0 / (1.0 + math.exp(-x))

def train_xor(zero_init, steps=20000, lr=2.0):
    if zero_init:
        W1 = [[0.0, 0.0], [0.0, 0.0]]
        b1 = [0.0, 0.0]
    else:
        W1 = [[random.uniform(-1, 1), random.uniform(-1, 1)],
              [random.uniform(-1, 1), random.uniform(-1, 1)]]
        b1 = [random.uniform(-1, 1), random.uniform(-1, 1)]
    W2 = [random.uniform(-1, 1), random.uniform(-1, 1)]
    b2 = random.uniform(-1, 1)

    data = [((0, 0), 0), ((0, 1), 1), ((1, 0), 1), ((1, 1), 0)]
    for _ in range(steps):
        gW1 = [[0.0, 0.0], [0.0, 0.0]]
        gb1 = [0.0, 0.0]
        gW2 = [0.0, 0.0]
        gb2 = 0.0
        loss = 0.0
        for (x1, x2), t in data:
            h = [sigmoid(W1[j][0] * x1 + W1[j][1] * x2 + b1[j]) for j in range(2)]
            y = sigmoid(W2[0] * h[0] + W2[1] * h[1] + b2)
            d = y - t
            loss += 0.5 * d * d
            for j in range(2):
                gW2[j] += d * h[j]
                dh = d * W2[j] * h[j] * (1 - h[j])
                gW1[j][0] += dh * x1
                gW1[j][1] += dh * x2
                gb1[j] += dh
            gb2 += d
        n = len(data)
        for j in range(2):
            W2[j] -= lr * gW2[j] / n
            W1[j][0] -= lr * gW1[j][0] / n
            W1[j][1] -= lr * gW1[j][1] / n
            b1[j] -= lr * gb1[j] / n
        b2 -= lr * gb2 / n

    preds = []
    for (x1, x2), t in data:
        h = [sigmoid(W1[j][0] * x1 + W1[j][1] * x2 + b1[j]) for j in range(2)]
        y = sigmoid(W2[0] * h[0] + W2[1] * h[1] + b2)
        preds.append((x1, x2, round(y, 3), "1" if y >= 0.5 else "0"))
    return loss / 4, preds

lo, pr = train_xor(True)
print("零初始化 final loss", round(lo, 4))
for p in pr:
    print("  输入", p[0], "输出", p[2], "预测", p[3])

lo2, pr2 = train_xor(False)
print("随机初始化 final loss", round(lo2, 4))
for p in pr2:
    print("  输入", p[0], "输出", p[2], "预测", p[3])

本机实际输出:

零初始化 final loss 0.125
  输入 0 输出 0.5 预测 0
  输入 0 输出 0.5 预测 1
  输入 1 输出 0.5 预测 1
  输入 1 输出 0.5 预测 1
随机初始化 final loss 0.0
  输入 0 输出 0.0 预测 0
  输入 0 输出 1.0 预测 1
  输入 1 输出 1.0 预测 1
  输入 1 输出 0.0 预测 0

零初始化那一组,四条样本的输出都卡在 0.5,loss 停在 0.125,正好是「全部猜一半」的误差。随机初始化那一组 loss 降到零,XOR 四个点全部答对。两个隐藏单元在零初始化下从头到尾输出一致,网络实际只有一个隐藏单元,而一个单元连不成 XOR。

输出层的权重可以全零,偏置也可以全零,致命的是隐藏层的权重。判断一个初始化是否合格,有个简单标准:同一层任意两个单元的权重不能完全相同。只要打破对称,梯度就会分化,网络才有机会用上多个单元。

光随机还不够,尺度也要合适。权重太小,信号每传一层就缩小一点,深层几乎收不到输入;权重太大,信号逐层放大,很快就会溢出。这件事在下一篇的实测里会看到具体的数字。

常见做法是按输入连接数缩放随机范围。Xavier 初始化让权重的方差大致等于输入个数的倒数,He 初始化再乘二,配合 ReLU 使用。它们不是精确公式,而是一种经验尺度:让每层输出的方差尽量保持不变,信号才不会逐层衰减或放大。现代框架大多把这些封装成默认值,只有自己手写网络时才需要显式指定。

归一化:让每层的输入尺度稳住

先看尺度失控有多快。下面这段构造一个五层、每层一百个单元的网络,输入是标准正态随机数,权重按三种尺度随机生成,每层过 ReLU 后统计激活值的标准差。

def act_std(scale, layers=5, width=100):
    x = [random.gauss(0, 1) for _ in range(width)]
    out = []
    for _ in range(layers):
        W = [[random.gauss(0, scale) for _ in range(width)] for _ in range(width)]
        x = [max(0.0, sum(W[i][j] * x[j] for j in range(width))) for i in range(width)]
        m = sum(x) / width
        s = math.sqrt(sum((v - m) ** 2 for v in x) / width)
        out.append(round(s, 4))
    return out

for scale in (0.01, 0.1, 1.0):
    print("权重尺度", scale, "各层激活标准差", act_std(scale))

本机实际输出:

权重尺度 0.01 各层激活标准差 [0.0501, 0.0035, 0.0002, 0.0, 0.0]
权重尺度 0.1 各层激活标准差 [0.5923, 0.4187, 0.2627, 0.1857, 0.1326]
权重尺度 1.0 各层激活标准差 [6.9281, 45.2766, 352.189, 2654.296, 16738.0905]

尺度 0.01 时,第五层的激活标准差已经变成零,信号在传递中彻底消失;尺度 0.1 时每层稳定衰减,五层之后只剩原来的五分之一;尺度 1.0 时第五层标准差到了 16738,再深几层就会溢出成无穷。三种尺度都不是随便编的,它们代表「太小、接近、太大」三种典型状态。

归一化(normalization)就是针对这件事的手段。它的做法是:把一层输出的均值拉到零附近、方差拉到一附近,再乘一个可学习的缩放、加一个可学习的偏移,让网络自己决定要不要恢复原来的尺度。按什么范围统计,决定了它的两种主要形态。

BatchNorm:按一批样本统计

对每个特征,在当前 batch 内算均值和方差。训练时用这一批的统计量,同时维护一份滑动平均;推理时用滑动平均。优点是稳定、收敛快;缺点是依赖 batch,batch 太小时统计不准,分布式训练还要跨卡同步。

LayerNorm:按单条样本统计

对一条样本的所有特征算均值和方差,和 batch 大小无关。训练和推理行为一致,适合序列模型和变长输入。缺点是它不区分特征之间的重要性,表达能力上比 BatchNorm 弱一点。

位置也很关键。常见做法是把归一化放在线性层之后、激活函数之前,这样进入激活的值尺度稳定,不会大批落进饱和区。也有放在残差分支末尾的「前置归一化」,深层网络更常用,训练更稳。

归一化不是万能补丁。它稳定了前向的尺度,也就改变了反向的梯度分布,学习率的最优区间会跟着变。加了一层归一化之后,原来的学习率往往要重新调。更不要在同一次实验里既改初始化又加归一化,否则出了问题分不清是谁的功劳或责任。

还有一个容易忽略的细节:BatchNorm 在训练时更新滑动平均,推理时用的是这份历史统计。如果训练轮数很少,滑动平均还没稳定就上线,推理结果会明显偏移。判断办法是比较同一批数据在训练模式和评估模式下的输出,差距大说明统计量还没收敛。

dropout:训练时随机关,推理时怎么补

dropout 是在训练时按概率把一部分神经元的输出置零,让网络不能依赖某几个固定单元,相当于每次训练一个不同的子网络。它在防止过拟合上有效,但训练和推理的行为必须对齐,否则尺度会差一截。

问题出在期望上。假设某一层输出是 20,保留概率 p 是 0.5,那么训练时每个单元有一半机会被关掉,平均输出只有 10;推理时所有单元都开着,输出又是 20。训练和推理看到的数值范围差了一倍,后面层的权重就是按 10 的量级学出来的,推理时会整体偏大。

解决办法叫倒置 dropout:训练时对保留下来的值乘以 1/p,让期望回到 20;推理时什么都不做。下面这段用五千次模拟验证这个放大是否把期望补回来了。

def dropout_stats(p, trials=5000):
    x = 20.0
    train_sum = 0.0
    no_scale_sum = 0.0
    for _ in range(trials):
        keep = random.random() < p
        if keep:
            train_sum += x / p        # 训练时放大
            no_scale_sum += x
    return round(train_sum / trials, 2), round(no_scale_sum / trials, 2)

a, b = dropout_stats(0.5)
print("dropout p=0.5 训练期放大后的均值", a, "不放大时的均值", b, "推理期固定输出 20.0")

本机实际输出:

dropout p=0.5 训练期放大后的均值 19.62 不放大时的均值 9.81 推理期固定输出 20.0

放大后训练期的均值是 19.62,已经贴近推理期的 20;不放大只有 9.81,正好差一半。19.62 而不是精确的 20,是五千次随机模拟的采样误差,次数越多越接近。这个小实验说明的不是 dropout 多神奇,而是「训练和推理必须同一尺度」这条原则。

保留概率 p 的选择也有讲究。p 太小几乎不起作用,p 太大又会让网络欠拟合、训练变慢。常见范围是 0.1 到 0.5,输入层和输出层通常不用。更重要的前提是:只有当模型确实过拟合时才值得加 dropout。一个本身容量不足的模型加 dropout,只会让它更难学。

还有一个工程上的坑:推理时忘了切换到评估模式。框架里训练和推理是两个状态,dropout 和 BatchNorm 的行为都依赖这个开关。忘了切,推理结果每次都不一样,指标自然对不上。这类问题在本地小脚本里不常见,一上服务就容易出现。

dropout 和 BatchNorm 一起用还有个老问题:训练时随机关掉单元会让批内方差变大,归一化的统计量跟着偏,评估时又恢复正常,两者行为对不齐。后来的模型多改用其他正则方式,或者把 dropout 只放在特定位置。如果非要一起用,至少确认顺序和框架的默认行为。

学习率与 batch:一对必须一起改的参数

batch 大小决定梯度有多准。每次只取一条样本,梯度噪声很大;取全量,梯度就是精确值。噪声小意味着方向更可靠,但不意味着每一步都更划算,因为同样一轮数据,大 batch 的更新次数更少。

下面这段在四百个带噪声的样本上,用不同 batch 大小重复估计两百次梯度,统计均值和标准差。真实斜率是 3.0,理想梯度应该接近零附近的小值。

true_w = 3.0
pts = []
for _ in range(400):
    x = random.uniform(-2, 2)
    pts.append((x, true_w * x + random.gauss(0, 1.0)))

def grad_batch(bs, seed):
    rnd = random.Random(seed)
    s = rnd.sample(pts, bs)
    g = sum(2 * (true_w * x - y) * x for x, y in s) / bs
    return g

for bs in (1, 8, 64, 400):
    vals = [grad_batch(bs, s) for s in range(200) if bs <= len(pts)]
    m = sum(vals) / len(vals)
    v = sum((z - m) ** 2 for z in vals) / len(vals)
    print("batch", bs, "梯度均值", round(m, 3), "标准差", round(math.sqrt(v), 3))

本机实际输出:

batch 1 梯度均值 -0.073 标准差 1.976
batch 8 梯度均值 -0.015 标准差 0.682
batch 64 梯度均值 0.001 标准差 0.239
batch 400 梯度均值 0.006 标准差 0.0

batch 从 1 加到 8,梯度标准差从 1.976 降到 0.682;加到 64 降到 0.239;全量时是零,因为每次都是同一批数据,没有随机性。标准差大致按 batch 的平方根下降,这是随机抽样的基本性质,不是这套代码的特殊现象。

噪声小了,单步方向更准,于是可以用更大的步长。这就是「batch 乘 k、学习率乘 k」这条经验规则的来源。但它有前提:模型、优化器、数据分布都不能变,而且 k 不能太大。超过某个规模后,再线性放大学习率反而会不稳定,需要配合 warmup,也就是前期用很小的学习率慢慢升上去。

反过来,batch 变小就要把学习率调小。同样一个学习率,在小 batch 上会被噪声放大成来回乱跳。很多人换 batch 之后发现 loss 曲线变糙,第一反应是模型坏了,其实只是步长和噪声不匹配。

学习率调度也是同一件事的延伸。固定学习率很难兼顾前期和后期:前期需要大步快走,后期需要小步微调。常见做法有按步数衰减、余弦衰减、以及根据验证指标不再下降时减半。它们的共同点是让步长随训练推进变小,而不是一直用同一个值。

显存不够时,还有一个常用手段叫梯度累积:把几个小 batch 的梯度先加起来,再一次性更新,效果接近大 batch,但显存占用还是小 batch 的水平。它改变的是更新频率,不改变单条样本的噪声,所以学习率要按累积后的有效 batch 来定。

不要一次性改多个变量。同时换初始化、加归一化、调 batch 和学习率,如果结果变好,你说不清是哪一项起的作用;如果变差,也找不到原因。训练技巧的调试原则和普通代码一样:一次只动一个,记录每次的结果。

训练不听话时,按现象倒查

下面这张表把常见现象、背后的真实原因和第一步该查的东西对上。顺序按「先查便宜的、再查贵的」排列。

现象真实原因第一步查什么
第一步 loss 就是 NaN 或无穷初始化尺度过大,或学习率过大导致溢出打印初始激活的最大值和首个梯度范数
loss 完全不降,所有输出相同隐藏层权重全零,或多个单元保持对称检查初始化代码,打印同一层两个单元的权重
训练 loss 降、验证差很多过拟合,或推理时没切到评估模式先确认评估模式,再对比训练和验证曲线
加深后前面几层几乎不更新激活逐层衰减到零,梯度传不回去逐层打印激活标准差,对照初始化尺度
换大 batch 后同样的学习率不收敛有效步长与 batch 不匹配按比例放大学习率,或加 warmup 再观察
loss 抖动明显、降不下去batch 太小带来梯度噪声,或学习率偏大把 batch 加倍,或学习率减半,对比曲线
加 BatchNorm 后小 batch 效果很差batch 内统计量不稳,均值和方差本身在抖换 LayerNorm,或把 batch 提到至少几十条
加了 dropout 反而更差模型本身不过拟合,或 p 设得过大先看训练和验证的差距,再决定要不要正则

表里前两行几乎都和初始化有关,这也是最容易被忽略的部分。很多人调了半天学习率,实际上模型从第一步就已经坏了。先确认初始状态正常,再谈后面的技巧。

边界与代价

这些技巧都不能替代数据和梯度。初始化再讲究,标签错了照样学不会;归一化再稳,特征本身没有信息也提不高指标。它们解决的是「优化过程能不能顺利进行」,不是「问题本身有没有解」。

归一化有实际开销。BatchNorm 在训练时要算批内统计量,分布式训练还要跨卡同步,通信成本随规模上升;LayerNorm 计算量小,但在长序列上会带来额外的时间开销。具体数值和硬件、实现有关,这里没有在本机实测,需要在自己的环境里测。

dropout 会让训练变慢。每个 step 都要随机生成掩码,被关掉的单元不参与计算本来算省,但整体收敛需要的步数通常更多,净效果往往是训练时间变长。也正因为如此,现代大模型更常用其他正则手段,dropout 更多出现在全连接层和较小的模型上。

大 batch 用显存换吞吐。它能让 GPU 更满,但显存占用随 batch 线性增长,而且泛化不一定更好。有研究认为过大的 batch 会让模型落在较尖锐的解上,验证指标反而下降。这个结论在不同任务上并不一致,实际要以自己的验证集为准。

还有一个现实约束:这些技巧的效果依赖模型规模。在小模型上验证有效的配置,搬到几十亿参数的模型上未必成立,尤其是学习率和 batch 的缩放关系。本机没有条件跑这种规模,相关结论只能标注为经验规则,不能当定律。

最后,这些手段之间会互相影响。归一化改变梯度的尺度,dropout 改变每步的有效网络,batch 改变噪声,学习率改变步长。单独调每一个都可能有效,组合起来却可能互相抵消。这也是为什么下一篇要讲注意力机制:结构一变,前面这些经验的最优值也会跟着变。

当天能自验的五个练习

  1. 把零初始化的实验改成三个隐藏单元,确认 loss 仍然停在 0.125,并解释为什么多加一个单元没有用。
  2. 把初始化改成只让第二个单元随机、第一个保持零,观察网络能否学会 XOR,说明打破对称的最小条件。
  3. 把激活尺度实验的层数从五层加到十层,记录三种权重尺度下最后一层的标准差,确认衰减和爆炸都在加速。
  4. 把 dropout 的保留概率从 0.5 改成 0.2 和 0.8,各跑五千次模拟,验证放大系数是否始终把期望补回 20。
  5. 把 batch 实验的样本噪声标准差从 1.0 改成 0.1,重跑四个 batch,观察梯度标准差的变化,说明噪声来源。

小结

初始化要打破对称、控制尺度;归一化把每层输入的分布稳住,BatchNorm 看批内统计、LayerNorm 看单条样本;dropout 训练时随机置零并按 1/p 放大,推理时保持原尺度;batch 越大梯度噪声越小,学习率要跟着调整,必要时加 warmup 和衰减。

这四件事都在处理同一个问题:让信号和梯度在多层之间稳定地传下去。而下一层的结构变化会重新定义这个「稳定」的含义。下一篇讲注意力机制,从最简单的加权平均开始,说明 Q、K、V 三个向量各自在做什么。