编码器和解码器都用 GRU

这一课在哪

前三课把概念讲完了。这一课写成完整代码。

一共三个类:编码器、解码器、把它们接起来的 Seq2Seq。

编码器

import torch import torch.nn as nn from torch.nn.utils.rnn import pack_padded_sequence class Encoder(nn.Module): def __init__(self, vocab_size, embed_dim=256, hidden_size=256): super().__init__() self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0) self.rnn = nn.GRU( input_size=embed_dim, hidden_size=hidden_size, batch_first=True, ) def forward(self, src, src_len): embedded = self.embedding(src) packed = pack_padded_sequence( embedded, src_len.cpu(), batch_first=True, enforce_sorted=False, ) outputs, hidden = self.rnn(packed) return hidden # 只返回最后一个 h

注意 return hidden——outputs 直接扔了。

张量

形状

为什么不返回

outputs

(B, L, 256)

解码器不知道跟哪一步对齐(第 36 章会要回来)

hidden

(1, B, 256)

整句话压缩成这一个向量

packing 在这里还是必需的

编码器用 pack_padded_sequence, 保证 hidden 是「读完真实长度」的状态,不是「读完全部 padding」。

这点和第 34.6 课讲的一样。

解码器

class Decoder(nn.Module): def __init__(self, vocab_size, embed_dim=256, hidden_size=256): super().__init__() self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0) self.cell = nn.GRUCell(input_size=embed_dim, hidden_size=hidden_size) self.fc = nn.Linear(hidden_size, vocab_size) def step(self, word, state): """ word: (B,) 这一步的输入词 state: (B, 256) 上一步的状态 """ embedded = self.embedding(word) # (B, 256) state = self.cell(embedded, state) # (B, 256) logits = self.fc(state) # (B, vocab) return logits, state

行

形状变化

word

(B,) 整数

embedding(word)

(B,) → (B, 256)

cell(embedded, state)

(B, 256) → (B, 256)

fc(state)

(B, 256) → (B, vocab)

为什么叫 step 不叫 forward

名字只是个提示,但很有用:它一次只走一步。

写成 step 有两个好处:不会误以为能一次喂整个序列; 在推理代码里一眼就能看出来这是循环里的东西。

接起来

class Seq2Seq(nn.Module): def __init__(self, src_vocab, tgt_vocab, embed_dim=256, hidden_size=256): super().__init__() self.encoder = Encoder(src_vocab, embed_dim, hidden_size) self.decoder = Decoder(tgt_vocab, embed_dim, hidden_size) self.hidden_size = hidden_size def forward(self, src, src_len, tgt): """训练时用:tgt 是标准答案,逐位喂进去(teacher forcing)""" # ① 编码器读完,取最后的 h hidden = self.encoder(src, src_len) # (1, B, 256) state = hidden.squeeze(0) # (B, 256) # ② 解码器逐步生成 outputs = [] word = tgt[:, 0] # 第一个输入是 <bos> for t in range(1, tgt.size(1)): logits, state = self.decoder.step(word, state) outputs.append(logits) word = tgt[:, t] # 喂标准答案 return torch.stack(outputs, dim=1) # (B, L-1, V)

packing 在哪?在编码器里面

看 Seq2Seq.forward 会觉得奇怪:怎么没见 pack_padded_sequence?

它在 Encoder.forward 里——self.encoder(src, src_len) 这一行进去,里面就做了打包。

这是故意的:谁需要长度,就让谁负责打包。 编码器需要(要拿到干净的 h),解码器不需要(它是逐步走的)。

所以 src_len 传给了编码器,没有传给解码器。

class Encoder(nn.Module): def forward(self, src, src_len): embedded = self.embedding(src) # ← 打包就在这,藏在编码器内部 packed = pack_padded_sequence( embedded, src_len.cpu(), batch_first=True, enforce_sorted=False, ) outputs, hidden = self.rnn(packed) return hidden

三处要停一下

行

为什么

hidden.squeeze(0)

(1,B,256) → (B,256),GRUCell 要的是后者

word = tgt[:, 0]

第一列是 <bos>

range(1, tgt.size(1))

从 1 开始,因为第 0 列已经当输入了

跑一遍,看形状

torch.manual_seed(0) SRC_VOCAB, TGT_VOCAB = 6083, 2343 model = Seq2Seq(SRC_VOCAB, TGT_VOCAB) print(f"{sum(p.numel() for p in model.parameters()):,}") # 3,548,711 src = torch.randint(4, SRC_VOCAB, (4, 12)) # 4 句,12 个英文词 src_len = torch.tensor([12, 9, 7, 5]) # 真实长度各不相同 tgt = torch.randint(4, TGT_VOCAB, (4, 10)) # 4 句,10 个中文词 tgt[:, 0] = 2 # 第 0 列必须是 <bos> out = model(src, src_len, tgt) print(out.shape) # torch.Size([4, 9, 2343])

量

形状

说明

src

(4, 12)

4 句,补齐到 12

src_len

(4,)

真实长度

编码器 hidden

(1, 4, 256)

压成 256

state

(4, 256)

tgt

(4, 10)

含 <bos>

out

(4, 9, 2343)

9 步,不是 10

为什么是 9 不是 10

tgt 有 10 列,但第 0 列(<bos>)被当成了输入。

循环从 t=1 开始,走 10 - 1 = 9 步。

这就是「标签错一位」在形状上的体现。

参数量拆开

编码器 embedding 6083 × 256 1,557,248 GRU(256,256) 3 × (256×256 + 256×256 + 2×256) 393,984 解码器 embedding 2343 × 256 599,808 GRUCell(256,256) 3 × (256×256 + 256×256 + 2×256) 393,984 fc 256 × 2343 + 2343 602,071 合计 3,548,711

部分

参数

占比

编码器 embedding

1,557,248

43.9%

编码器 GRU

393,984

11.1%

解码器 embedding

599,808

16.9%

解码器 GRUCell

393,984

11.1%

解码器 fc

602,071

17.0%

两个 RNN 加起来只占 22%,其余都在 embedding 和输出层。

这和前面几章一个规律:词表大小才是参数的第一驱动。

三种改法,改一个参数

想改

改哪

影响

用 LSTM 代替 GRU

nn.GRU → nn.LSTM,GRUCell → LSTMCell

多一个 c 状态要传,参数量 ×1.33

加深

num_layers=2

编码器可以;解码器的 Cell 没有层数参数,要自己堆

加宽

hidden_size=512

RNN 参数 ×4,embedding 不变

LSTM 版要多传一个 c

nn.LSTM 返回 (out, (h_n, c_n)), LSTMCell 也返回 (h, c)。

编码器的 c_n 也要传给解码器当初值, 否则等于每次都从 0 开始记。

这一章的代码用 GRU,省掉了这件事—— GRU 只有一个状态,接起来简单。

这一课留下的三个数

数

值

含义

总参数

3,548,711

hidden=256

两个 RNN

787,968

只占 22%

输出步数

L - 1

<bos> 被当输入了

下一课

模型搭好了。但训练前还有一件麻烦事: 两个词表要分开建,而且解码器的输入和标签要错一位。

下一课专门讲数据怎么准备。