训练细节
这一课在哪
模型拼好了,但还跑不起来。
这一课讲三件事:训练时怎么算、推理时为什么不一样、 以及那个「不一样」带来的一个实际坑。
训练时:编解码都是并行的
这是 Transformer 最爽的地方,也是它比 RNN 快的根本原因。
编码器:整句一起进
源句「我 喜 欢 你」 我 ──┐ 喜 ──┤ 欢 ──┤──► 编码器 ──► h1 h2 h3 h4 你 ──┘ ↑ 四个 token 同时处理没有「先算第 1 个才能算第 2 个」。四个位置一次全部算完。
解码器:也整句一起进,靠掩码挡住未来
<sos> I like you │ │ │ │ └───┴───┴────┴──► 解码器 ──► I like you <eos> ↑ 四个位置同时算,但每个只看前面的训练时正确答案已经在手上了,所以四个位置一次算完, 每个位置只看它前面的——这就是 37.5 课那个因果掩码的作用。
这就是为什么 Transformer 训得快
RNN 解码 4 个词要串行跑 4 次,因为第 2 步要吃第 1 步的输出。
Transformer 一次就够——掩码保证了「看不到未来」, 所以可以并行。
训练时 GPU 能吃满,这是它取代 RNN 的直接原因。
推理时:只能一个一个来
推理时手上没有答案,只能先生成第 1 个词, 把它接到输入后面,再生成第 2 个……
第 1 步 输入 <sos> → 输出 I 第 2 步 输入 <sos> I → 输出 like 第 3 步 输入 <sos> I like → 输出 you 第 4 步 输入 <sos> I like you → 输出 <eos>训练 | 推理 | |
|---|---|---|
解码器输入 | 整句答案 | 已生成的部分 |
跑几次 | 1 次 | n 次(生成几个词就跑几次) |
能不能并行 | 能 | 不能,后一个依赖前一个 |
掩码 | 必须加 | 加不加都行(本来就只有一个位置是新的) |
坑:PyTorch 封好的 Transformer 不能直接推理
nn.Transformer 的 forward 是把编码器和解码器一起跑:
out = model(src, tgt) # 编码器跑一遍,解码器跑一遍看着没问题。但推理循环里你这样写就糟了:
for step in range(20): out = model(src, tgt) # ✗ 编码器又跑了一遍 tgt = torch.cat([tgt, out[:, -1:]], dim=1)编码器在每个循环里被重复执行
src 从头到尾没变过, 但编码器每次都重新算一遍。
生成 20 个词,编码器就跑了 20 遍—— 白算 19 遍。
正确做法:拆开调用
nn.Transformer 内部本来就是两个独立部件, 可以单独调用:
# 编码器只跑一次 memory = model.encoder(src) # (B, T_src, d) tgt = torch.zeros(B, 1, d) # 只有 <sos> for step in range(20): mask = nn.Transformer.generate_square_subsequent_mask(tgt.size(1)) out = model.decoder(tgt, memory, tgt_mask=mask) # 只跑解码器 tgt = torch.cat([tgt, out[:, -1:]], dim=1)先验证这两件事等价:
m.eval() with torch.no_grad(): mem = m.encoder(src) a = m.decoder(tgt, mem) b = m(src, tgt) print(torch.allclose(a, b, atol=1e-6)) # True完全一样。拆开调用不改变结果,只是让编码器不必重复跑。
能省多少
实测生成 20 步(CPU,batch=2,源句 10 个词):
写法 | 耗时 |
|---|---|
每个循环都跑 | 1.164 s |
编码器只跑一次 | 0.775 s |
省下 | 33% |
这只是 CPU 上、小模型、短句
真正的翻译服务里,源句可能几百个词、模型几十层, 重复跑编码器的代价远大于 33%。
所以线上部署一定是拆开调的—— 编码器算一次,缓存起来,解码器反复用。
其他训练细节
① 学习率先升后降
论文用的是这个公式,不是固定学习率:
前半段()学习率线性上升, 后半段按平方根倒数下降。
取 、,实算几个点:
step | 学习率 | |
|---|---|---|
1 | 0.000000 | 几乎从 0 开始 |
400 | 0.000070 | 还在爬 |
4000 | 0.000699 | 峰值 |
40000 | 0.000221 | 慢慢降 |
为什么要 warmup?
Transformer 一开始参数很乱,梯度方向不稳定。 用一个极小的学习率先走几步,让模型「看几眼数据」再放大步子。
这和 37.3 课的 Pre-LN 是一回事的两面
Post-LN 的残差主干被 LayerNorm 打断,深层梯度容易爆, 所以特别依赖 warmup。
换成 Pre-LN 之后,warmup 的必要性就小很多——今天很多大模型直接不要 warmup。
② label smoothing
标签不是「正确答案 1.0,其余 0」,而是 「正确答案 0.9,其余均分 0.1」。
criterion = LabelSmoothing(size=tgt_vocab, padding_idx=0, smoothing=0.1)好处:不让模型对某个答案过度自信,泛化更好。 翻译任务里很常用。
③ 梯度裁剪
Transformer 的梯度有时会突然很大,直接更新会把模型搞乱。
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)把所有梯度按比例缩到范数不超过 1。一行,但几乎是必加的。
④ batch 里的填充别忘了 mask
三种 mask 各管一件事,训练时全都要传对:
mask | 传到哪 | 挡什么 |
|---|---|---|
| 编码器 | 源句补出来的 padding |
| 解码器自注意力 | 未来的词(因果) |
| 解码器跨注意力 | 编码器输出里的 padding |
漏传一个都不报错
mask 传错了形状不对会报错, 但漏传不会——模型照样训,只是效果差。
尤其是 tgt_mask:漏了就等于训练时偷看答案, 训练损失掉得飞快,推理时一塌糊涂。
这个现象是「训练 loss 很低但生成乱码」的头号原因。
完整训练循环
optimizer = torch.optim.Adam(model.parameters(), lr=1.0, betas=(0.9, 0.98), eps=1e-9) for epoch in range(n_epochs): model.train() for src, tgt, src_pad, tgt_pad in loader: tgt_in = tgt[:, :-1] # 输入:去掉最后一个 tgt_out = tgt[:, 1:] # 标签:去掉第一个 tgt_mask = nn.Transformer.generate_square_subsequent_mask( tgt_in.size(1) ).to(device) logits = model( src, tgt_in, tgt_mask=tgt_mask, src_key_padding_mask=src_pad, tgt_key_padding_mask=tgt_pad, memory_key_padding_mask=src_pad, ) loss = criterion( logits.reshape(-1, tgt_vocab), tgt_out.reshape(-1), ) optimizer.zero_grad() loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) optimizer.step() scheduler.step() # 按 step 更新学习率几个要点:
行 | 为什么 |
|---|---|
| 输入去掉最后一个、标签去掉第一个,错开一位 |
| 论文用的,第二个比默认的 0.999 小 |
| 按 step 更新,不是按 epoch |
这一课留下的三个数
数 | 值 | 含义 |
|---|---|---|
warmup 峰值 | step 4000, lr 0.000699 | 之后按平方根倒数降 |
缓存编码器 | 快 33% | 1.164s → 0.775s |
梯度裁剪 | 1.0 | 几乎必加 |
下一课
训练的门道讲完了。下一课真跑一遍—— 同一个中英翻译任务,和第 36 章那个 BLEU 28.63 硬碰硬。
特别要看:长短句的分桶曲线是不是变平了。