注意力的 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) 保证还原后的长度和输入一致。

返回

形状

角色

outputs

(B, T, 256)

K 和 V

hidden

(1, B, 256)

解码器初始状态

改动 ②:注意力模块

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)

行

干什么

w_q(query).unsqueeze(1)

(B,H) → (B,1,H),为了和 (B,T,H) 广播相加

tanh(...)

公式里的 tanh,按元素

w_v(...).squeeze(-1)

(B,T,H) → (B,T,1) → (B,T)

masked_fill

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 更安全:

值

风险

-inf

整行都被 mask 时(一句全是 padding),softmax 出现 0/0 → NaN, 然后整个训练崩掉

-1e9

整行被 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])

张量

形状

含义

src

(4, 12)

4 句,补齐到 12

encoder_out

(4, 12, 256)

K 和 V

alpha 每步

(4, 12)

12 个源位置的权重

alphas

(4, 9, 12)

9 步 × 12 个源位置

logits

(4, 9, 2343)

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%。

三种实现风格

同一个加性注意力,可以有三种写法:

写法

代码

特点

分开式(本课)

w_q(q) + w_k(k)

两个矩阵,q 和 k 可以不同维

拼接式

attn_fc(cat([q,k]))

一个矩阵,代码短,但要求一次性拼好

点积

q @ k.T / sqrt(d)

零参数,要求同维

数学上分开式和拼接式等价:

Wqq+Wkk=W⋅[q; k],W=[Wq∣Wk]W_q q + W_k k = W \cdot [q;\ k], \quad W = [W_q \mid W_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%

alphas 形状

(B, L, T)

输出长度 × 源长度

mask 用的值

-1e9

不用 -inf,防 NaN

下一课

模型写完了。下一课真训一遍,然后和 35 章那个无注意力版逐项对比: 训练曲线、BLEU、按句长分桶。

还要看注意力权重图——那是最直观的证据。