RNN 的训练细节

这一课在哪

模型搭好了。这一课讲训它的时候和前面几章有什么不一样。

前面的图像任务没有这些麻烦——图片都是 224×224,补齐就完事。 文本不同:长度天差地别,padding 会污染结果,梯度还会爆。

#

细节

不处理会怎样

1

把真实长度传进去

padding 被当成内容

2

pack_padded_sequence

最后一步被 padding 污染

3

梯度裁剪

loss 突然变成 NaN

4

学习率要小

前几轮完全不学

5

按长度分桶

一半算力浪费在 padding 上

① collate_fn 要多返回一个东西

上一课的 collate_fn 返回两样:补齐的 ids 和标签。 现在要多加一个真实长度:

from torch.nn.utils.rnn import pad_sequence def collate_fn(batch): sequences, labels = zip(*batch) lengths = torch.tensor([len(s) for s in sequences]) padded = pad_sequence(sequences, batch_first=True, padding_value=0) return padded, torch.stack(labels), lengths

返回

形状

用途

padded

(B, L)

喂给 embedding

labels

(B,)

算损失

lengths

(B,)

告诉模型每个样本真实多长

为什么长度必须自己传

模型看到的是补好 0 的矩阵,它不知道哪些 0 是真的、哪些是补的。

而且如果一句话本身就是「0 0 0」,那就真的分不清了。

所以长度必须显式传进去,不能靠模型猜。

② pack_padded_sequence

这是 RNN 训练里最重要也最容易被跳过的一步。

不打包会怎样

假设一个 batch 里有一句 3 个字、一句 20 个字。补齐后全是 20 长。

句子 A(真长 3): [2, 5, 12, 3, 0, 0, 0, ..., 0] └── 这 17 个 0 会继续喂进 RNN ──┘

RNN 会老老实实把这 17 个 0 也跑一遍。h 虽然变化不大, 但确实在变——tanh(W_hh @ h + b) 每次都会推一点。

更糟的是:最后一步的 h 是读完 17 个 padding 之后的状态。

取 h_n 的坑在这

h_n 永远返回读完整批最长序列之后的那个 h。

句子 A 的 h_n 其实是「读了 3 个真字 + 17 个 0」的结果, 不是「读完了这句话」的结果。

打包怎么做

from torch.nn.utils.rnn import pack_padded_sequence packed = pack_padded_sequence( embedded, lengths.cpu(), batch_first=True, enforce_sorted=False, # 允许不按长度降序排列 ) out, h_n = self.rnn(packed)

参数

作用

lengths

每个样本的真实长度

batch_first=True

和输入形状对上

enforce_sorted=False

必须加,否则要先按长度排序

打包之后 RNN 内部是这样算的:

第 1 步:只算 2 个样本(长度 >= 1 的) 第 2 步:只算 2 个样本 第 3 步:只算 1 个样本(另一句已经结束) 第 4 步起:全结束了,不算 ...

padding 完全没参与计算,h_n 也是干净的。

print(out) # PackedSequence(data=..., batch_sizes=tensor([2, 2, 1]), ...)

batch_sizes 就是「每一步还有几个样本在跑」。

③ 梯度裁剪

RNN 特有的问题:梯度会爆。

因为反向传播要穿过几十个时间步,每一步都乘一个权重矩阵。 乘 20 次之后,稍微大于 1 的就会指数爆炸。

loss.backward() # 看梯度有多大 total_norm = 0.0 for p in model.parameters(): if p.grad is not None: total_norm += p.grad.data.norm(2).item() ** 2 total_norm = total_norm ** 0.5 print(total_norm) # 不裁剪时可能是几十甚至几百

解法一行:

torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

参数

作用

model.parameters()

要裁剪的所有参数

max_norm=1.0

梯度的总范数上限

它不改方向,只改长度

所有梯度当成一个长向量,算出它的长度 ∥g∥\|g\|。

如果 ∥g∥>1\|g\| > 1,就整体乘 1/∥g∥1 / \|g\| 缩回去。

方向完全不变,只是不让一步走太远。

为什么不用别的办法

办法

问题

调小学习率

梯度爆是单次的,小学习率治不了突然那一下

换更稳的优化器

Adam 也会爆

梯度裁剪

直接限制上限,最可靠

顺序不能错:backward() → clip → step()。

④ 学习率

RNN 比 CNN 敏感。实测:

学习率

结果

1e-2

loss 震荡,不收敛

1e-3

正常,8 轮到 80%

1e-4

太慢,8 轮才 70%

⑤ 按长度分桶

如果一批里最长的 200、其他都是 20,那90% 算力在算 padding。

做法:把长度相近的放在一批。

class BucketSampler(torch.utils.data.Sampler): def __init__(self, lengths, batch_size, shuffle=True): self.lengths = lengths self.batch_size = batch_size self.shuffle = shuffle def __iter__(self): order = torch.argsort(torch.tensor(self.lengths)) batches = [order[i:i + self.batch_size] for i in range(0, len(order), self.batch_size)] if self.shuffle: random.shuffle(batches) for b in batches: b = b[torch.randperm(len(b))] yield from batches def __len__(self): return (len(self.lengths) + self.batch_size - 1) // self.batch_size

分桶的代价

同一批里的样本长度相近,但每批的组成变得固定—— 梯度噪声变大,有时会略微掉点。

所以分桶内部还要再打乱一次(上面那个 randperm)。

完整的训练循环

import time import torch import torch.nn as nn from torch.nn.utils.rnn import pack_padded_sequence device = "cuda" if torch.cuda.is_available() else "cpu" model = SentimentRNN(vocab_size=len(itos)).to(device) loss_fn = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) MAX_NORM = 1.0 for epoch in range(1, 9): model.train() running_loss, seen, correct = 0.0, 0, 0 for ids, labels, lengths in train_loader: ids = ids.to(device) labels = labels.to(device) logits = model(ids, lengths) loss = loss_fn(logits, labels) optimizer.zero_grad() loss.backward() # 裁剪必须在 step 之前 torch.nn.utils.clip_grad_norm_(model.parameters(), MAX_NORM) optimizer.step() running_loss += loss.item() * labels.size(0) seen += labels.size(0) correct += (logits.argmax(dim=1) == labels).sum().item() model.eval() dev_correct, dev_seen = 0, 0 with torch.no_grad(): for ids, labels, lengths in dev_loader: ids = ids.to(device) labels = labels.to(device) dev_correct += (model(ids, lengths).argmax(dim=1) == labels).sum().item() dev_seen += labels.size(0) print( f"{epoch} loss {running_loss/seen:.4f} " f"train {100*correct/seen:.2f}% dev {100*dev_correct/dev_seen:.2f}%" )

模型的 forward 也配合改成收 lengths:

class SentimentRNN(nn.Module): def forward(self, x, lengths): embedded = self.embedding(x) packed = pack_padded_sequence( embedded, lengths.cpu(), batch_first=True, enforce_sorted=False, ) _, h_n = self.rnn(packed) return self.fc(self.dropout(h_n[0]))

真实训练结果

词表 3,660,参数 481,026,RTX 5060 每轮 8 秒:

1 loss 0.6846 train 57.08% dev 64.50% 2 loss 0.6181 train 66.28% dev 73.25% 3 loss 0.5246 train 75.34% dev 73.00% 4 loss 0.4808 train 78.30% dev 78.50% 5 loss 0.4319 train 82.00% dev 76.00% 6 loss 0.3993 train 83.49% dev 79.17% 7 loss 0.3703 train 85.49% dev 80.42% 8 loss 0.3522 train 86.33% dev 80.58%

现象

说明

第 1 轮 train 只有 57%

比 dev(64.5%)还低——训练时 dropout 开着

train 一直涨到 86%

模型还有余力

dev 在 80% 附近平了

过拟合开始。单层 RNN 就这个上限

第 1 轮 train < dev 是正常的

model.train() 时 dropout 在随机丢神经元,等于在做难题。

model.eval() 时 dropout 关掉,全功率运行。

所以第一轮 dev 比 train 高,不是 bug。

这一课留下的五个数

细节

值

梯度裁剪

max_norm=1.0

学习率

1e-3

batch size

64

最大长度

128

8 轮后 dev

80.58%

下一课

训完了。下一课看它错在哪——测试集准确率、混淆矩阵、 以及为什么情感分析到 83% 就上不去了。