RNN 的训练细节
这一课在哪
模型搭好了。这一课讲训它的时候和前面几章有什么不一样。
前面的图像任务没有这些麻烦——图片都是 224×224,补齐就完事。 文本不同:长度天差地别,padding 会污染结果,梯度还会爆。
# | 细节 | 不处理会怎样 |
|---|---|---|
1 | 把真实长度传进去 | padding 被当成内容 |
2 |
| 最后一步被 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返回 | 形状 | 用途 |
|---|---|---|
|
| 喂给 embedding |
|
| 算损失 |
|
| 告诉模型每个样本真实多长 |
为什么长度必须自己传
模型看到的是补好 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)参数 | 作用 |
|---|---|
| 每个样本的真实长度 |
| 和输入形状对上 |
| 必须加,否则要先按长度排序 |
打包之后 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)参数 | 作用 |
|---|---|
| 要裁剪的所有参数 |
| 梯度的总范数上限 |
它不改方向,只改长度
所有梯度当成一个长向量,算出它的长度 。
如果 ,就整体乘 缩回去。
方向完全不变,只是不让一步走太远。
为什么不用别的办法
办法 | 问题 |
|---|---|
调小学习率 | 梯度爆是单次的,小学习率治不了突然那一下 |
换更稳的优化器 | Adam 也会爆 |
梯度裁剪 | 直接限制上限,最可靠 |
顺序不能错:backward() → clip → step()。
④ 学习率
RNN 比 CNN 敏感。实测:
学习率 | 结果 |
|---|---|
| loss 震荡,不收敛 |
| 正常,8 轮到 80% |
| 太慢,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。
这一课留下的五个数
细节 | 值 |
|---|---|
梯度裁剪 |
|
学习率 |
|
batch size | 64 |
最大长度 | 128 |
8 轮后 dev | 80.58% |
下一课
训完了。下一课看它错在哪——测试集准确率、混淆矩阵、 以及为什么情感分析到 83% 就上不去了。