注意力的 PyTorch 实现
这一课在哪
前三课讲清了结构、公式、手算。这一课写成能训练、能推理的完整模块。
三个类:编码器、注意力、解码器, 然后用一个 Seq2Seq 串起来。
改动 ①:编码器必须把全部输出交出来
第 35 章那个编码器是这样的:
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 # ← 只返回这个现在要两个都返回:
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(embed_dim, 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) # 把 packed 还原成填充后的张量,注意力要用 outputs, _ = pad_packed_sequence( outputs, batch_first=True, total_length=src.size(1), ) return outputs, hidden # (B,T,H), (1,B,H)pad_packed_sequence 这一步不能省
pack_padded_sequence 把数据压成一条变长的紧凑序列, 没法直接做 bmm。
要用 pad_packed_sequence 还原成 (B, T, H) ——补回 padding 的位置,才能和后续张量对齐。
total_length=src.size(1) 保证还原后的长度和输入一致。
返回 | 形状 | 角色 |
|---|---|---|
|
| K 和 V |
|
| 解码器初始状态 |
改动 ②:注意力模块
class Attention(nn.Module): """加性注意力:e = w_v^T tanh(W_q q + W_k k)""" def __init__(self, hidden_size): super().__init__() self.w_q = nn.Linear(hidden_size, hidden_size, bias=False) self.w_k = nn.Linear(hidden_size, hidden_size, bias=False) self.w_v = nn.Linear(hidden_size, 1, bias=False) def forward(self, query, keys, mask): """ query: (B, H) —— Q keys: (B, T, H) —— K mask: (B, T) 1 = 真词,0 = padding """ # ① q 和 k 各投一次,加起来,过 tanh,压成 1 个数 projected = torch.tanh( self.w_q(query).unsqueeze(1) + self.w_k(keys) ) # (B, T, H) scores = self.w_v(projected).squeeze(-1) # (B, T) # ② padding 位置不许被注意 scores = scores.masked_fill(mask == 0, -1e9) # ③ softmax return torch.softmax(scores, dim=-1) # (B, T)行 | 干什么 |
|---|---|
|
|
| 公式里的 tanh,按元素 |
|
|
| padding 的分数设成 -1e9,softmax 之后约等于 0 |
mask 这一步是最容易漏的
一个 batch 里短句会被补齐。如果不 mask, softmax 会把注意力分给那些补出来的 0。
后果:模型在「什么都不算」的位置上花了一部分权重, 真正有用的源词拿到的权重被稀释。
不报错,只是效果差——和 35 章那个 ignore_index 是同一类坑。
为什么用 -1e9 而不是 -inf
import torch scores = torch.tensor([[1.0, 2.0, 3.0]]) # 用 -1e9 print(torch.softmax(scores.masked_fill( torch.tensor([[False, False, True]]), -1e9), -1)) # tensor([[0.2689, 0.7311, 0.0000]]) # 用 -inf print(torch.softmax(scores.masked_fill( torch.tensor([[False, False, True]]), float("-inf")), -1)) # tensor([[0.2689, 0.7311, 0.0000]])结果一样。但 -1e9 更安全:
值 | 风险 |
|---|---|
| 整行都被 mask 时(一句全是 padding),softmax 出现 |
| 整行被 mask 时得到一个均匀分布,不会 NaN |
改动 ③:解码器吃 context
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) # 输入是 [词向量; context],所以是 embed_dim + hidden_size self.cell = nn.GRUCell(embed_dim + hidden_size, hidden_size) self.fc = nn.Linear(hidden_size, vocab_size) def step(self, word, context, state): embedded = self.embedding(word) # (B, E) combined = torch.cat([embedded, context], dim=1) # (B, E+H) state = self.cell(combined, state) # (B, H) logits = self.fc(state) # (B, V) return logits, state唯一的改动就是 nn.GRUCell(E, H) → nn.GRUCell(E + H, H), 以及 step 多收一个 context。
放在一起
class Seq2SeqWithAttention(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.attention = Attention(hidden_size) self.decoder = Decoder(tgt_vocab, embed_dim, hidden_size) def forward(self, src, src_len, tgt): # ① 编码器:拿到 K 和 V,以及解码器的起点 encoder_out, hidden = self.encoder(src, src_len) # (B,T,H), (1,B,H) mask = (src != 0).float() # 1=真词 state = hidden.squeeze(0) # (B,H) outputs = [] alphas = [] # 顺手存权重 word = tgt[:, 0] # <bos> for t in range(1, tgt.size(1)): # ② 打分 + softmax:Q=state, K=encoder_out alpha = self.attention(state, encoder_out, mask) # (B,T) # ③ 加权求和:V=encoder_out context = torch.bmm(alpha.unsqueeze(1), encoder_out).squeeze(1) # ④ 走一步解码 logits, state = self.decoder.step(word, context, state) outputs.append(logits) alphas.append(alpha.detach()) word = tgt[:, t] return torch.stack(outputs, dim=1), torch.stack(alphas, dim=1)注意 return 有两个值
第二个 alphas 不是给损失用的,是给画图用的。 形状 (B, 输出长度, 源句长度)。
训练时可以不管它;想画对齐图时取出来就行。
跑一遍,看形状
torch.manual_seed(0) model = Seq2SeqWithAttention(6083, 2343) print(f"{sum(p.numel() for p in model.parameters()):,}") # 3,876,647 src = torch.randint(4, 6083, (4, 12)) src_len = torch.tensor([12, 9, 7, 5]) tgt = torch.randint(4, 2343, (4, 10)) tgt[:, 0] = 2 # <bos> logits, alphas = model(src, src_len, tgt) print(logits.shape) # torch.Size([4, 9, 2343]) print(alphas.shape) # torch.Size([4, 9, 12])张量 | 形状 | 含义 |
|---|---|---|
|
| 4 句,补齐到 12 |
|
| K 和 V |
|
| 12 个源位置的权重 |
|
| 9 步 × 12 个源位置 |
|
| 9 步,每步 2343 个词 |
参数量对比
部分 | 无注意力 | 有注意力 |
|---|---|---|
编码器 | 2,633,728 | 2,633,728 |
解码器 GRUCell | 393,984 | 590,976 |
输出层 | 602,071 | 602,071 |
注意力 | — | 131,328 |
合计 | 3,629,783 | 3,958,103 |
注意力模块三个矩阵: W_q 和 W_k 各 256×256, w_v 是 256×1, 共 65,536 × 2 + 256 = 131,328。
只占总参数的 3.3%。
三种实现风格
同一个加性注意力,可以有三种写法:
写法 | 代码 | 特点 |
|---|---|---|
分开式(本课) |
| 两个矩阵,q 和 k 可以不同维 |
拼接式 |
| 一个矩阵,代码短,但要求一次性拼好 |
点积 |
| 零参数,要求同维 |
数学上分开式和拼接式等价:
第 34.2 课讲 LSTM 时提过同一件事——拼接后乘大矩阵,等于拆开各乘小矩阵再相加。
把权重画出来
alphas 拿到手之后,画一张热力图:
import matplotlib.pyplot as plt alpha = alphas[0].cpu().numpy() # (输出长度, 源长度),取第 0 句 fig, ax = plt.subplots(figsize=(6, 4)) ax.imshow(alpha, cmap="Blues", aspect="auto") ax.set_xlabel("源句位置") ax.set_ylabel("输出位置") ax.set_title("注意力权重")这张图能直接看出模型学没学会
清晰的对齐:一条从左上到右下的斜线,每行只有一个亮点。
没学会:一片均匀,或者亮点全挤在某一列。
不需要 BLEU 就能判断——这是注意力比 RNN 好调试的地方。 有些实现专门留了开关: alignment_history=True # for attention visualization。
这一课留下的三个数
数 | 值 | 含义 |
|---|---|---|
注意力参数 | 131,328 | 只占 3.3% |
|
| 输出长度 × 源长度 |
mask 用的值 |
| 不用 -inf,防 NaN |
下一课
模型写完了。下一课真训一遍,然后和 35 章那个无注意力版逐项对比: 训练曲线、BLEU、按句长分桶。
还要看注意力权重图——那是最直观的证据。