seq2seq 的注意力

这一课在哪

上一课量出了缺陷:句子越长 BLEU 越低,1-5 词 25.79,13+ 词只有 9.92。

这一课把注意力插进去。

改动只有一处

和上一课的模型对比

这个新的模型和 seq2seq 完全相同, 只不过上下文变量 cc 在每个解码时间步 t′t' 都会被 ct′c_{t'} 替换。

原来是一个 cc 用到最后; 现在是每一步现算一个 ct′c_{t'}。

十步就有十个不同的 c。

Q、K、V 分别是谁

第 36.1 课就定了三个角色:查询、键、值。放到 seq2seq 里是这样对应的:

角色

在这里是

哪来的

Q 查询

解码器上一步的隐状态 st′−1s_{t'-1}

解码器自己

K 键

编码器每一步的隐状态 hth_t

编码器全部保留

V 值

同一个 hth_t

编码器全部保留

两件事必须记住

① Q 来自解码器,K 和 V 都来自编码器。

② K 和 V 是同一个东西——编码器的输出既当键又当值。

这和 36.5 算过的跨注意力一模一样:那边 Q 一边、K V 另一边。 这里只是把「另一边」具体落成了编码器的全部输出。

架构图

图:seq2seq + 注意力。左边编码器产生 h1…h4(对应 K 和 V),右边解码器自回归产生自己的 h(最后那个对应 Q)。中间的 attention 黑盒吃下 Q 和全部 K、V,输出 c。c 和 h 拼接后经 Linear 得到词分布。图取自尚硅谷《大模型技术之 NLP》第 124 页。

对着 Q/K/V 看这张图,三个地方:

看图上的

就是

左边一排绿色 h1…h4h_1 \dots h_4

K 和 V(编码器每步的输出,全留着)

右边解码器最上面那个橙色 h3h_3

Q(当前要生成词时,解码器的状态)

中间写着 attention 的黑盒

吃 Q 和全部 K、V,吐出 c3c_3

图上一个容易看漏的细节

图上「融合」那个黑块:c3c_3 和 h3h_3 拼起来才进 Linear。

不是只用 cc。解码器自己的状态也要一起进去。

三步计算

① 打分:每个 hth_t 配不配?

用 Q 和每个 K 算一个分数。这里用加性注意力 (第 36.7 课的第一种):

et′,t=wv⊤tanh⁡(Wqst′−1+Wkht)e_{t',t} = w_v^{\top} \tanh\left(W_q s_{t'-1} + W_k h_t\right)

符号

是什么

et′,te_{t',t}

第 t′t' 个输出词,对第 tt 个源词的分数

st′−1s_{t'-1}

Q,解码器上一步的状态

hth_t

K,编码器第 t 步的输出

Wq,Wk,wvW_q, W_k, w_v

三个可学习参数

为什么用加性而不是点积

点积要求 Q 和 K 同维。

这里解码器状态和自己设计的编码器维度可以不一样, 加性更省事——它用两个矩阵把两边投到同一维度。

Transformer 里维度统一,才换成点积。

② softmax:分数变成权重

αt′,t=exp⁡(et′,t)∑k=1Texp⁡(et′,k)\alpha_{t',t} = \frac{\exp(e_{t',t})}{\sum_{k=1}^{T} \exp(e_{t',k})}

对所有源位置做 softmax,和为 1。权重个数等于源句长度 T。

③ 加权求和:得到这一步的 c

ct′=∑t=1Tαt′,thtc_{t'} = \sum_{t=1}^{T} \alpha_{t',t} h_t

注意用的是 hth_t(也就是 V),不是重新算一遍。

④ 拼起来,才是解码器那一步的输入

st′=GRUCell([ yt′−1; ct′ ], st′−1)s_{t'} = \mathrm{GRUCell}\left([\,y_{t'-1};\ c_{t'}\,],\ s_{t'-1}\right)

yt′−1y_{t'-1} 是上一步输出的词的 embedding。

代码:和普通 seq2seq 并排

普通版(第 35.6 课):

_, hidden = self.encoder(src, src_len) # 只拿最后一个 state = hidden.squeeze(0) for t in range(1, tgt.size(1)): word = tgt[:, t] embedded = self.embedding(word) state = self.cell(embedded, state) # 只喂 word logits = self.fc(state)

注意力版:

encoder_out, hidden = self.encoder(src, src_len) # encoder_out: (B, T, H) ← 就是 K 和 V,以前这一行是丢掉的 state = hidden.squeeze(0) for t in range(1, tgt.size(1)): word = tgt[:, t] embedded = self.embedding(word) # ① 打分:Q = state,K = encoder_out scores = torch.bmm(self.Wq(state).unsqueeze(1), encoder_out.transpose(1, 2)) # (B, 1, T) # ② softmax alpha = torch.softmax(scores.squeeze(1), dim=-1) # (B, T) # ③ 加权求和:V = encoder_out context = torch.bmm(alpha.unsqueeze(1), encoder_out).squeeze(1) # ④ 拼接后喂进去 state = self.cell(torch.cat([embedded, context], dim=1), state) logits = self.fc(state)

四行对应三个角色

代码

谁是 Q/K/V

self.Wq(state)

Q

encoder_out.transpose(1,2)

K

torch.bmm(alpha, encoder_out)

V(同一个 encoder_out)

看第三行和第五行:encoder_out 用了两次。 一次当键去打分,一次当值被加权。这就是「K 和 V 是同一个东西」在代码里的样子。

另一种写法:拼接式(来自 bentrevett 的教程)

上面是把 Q、K 各乘一个矩阵再相加。还有另一种更直接的写法: 把 Q 和 K 拼起来,过一层,再压成一个数。

class Attention(nn.Module): def __init__(self, encoder_hidden_dim, decoder_hidden_dim): super().__init__() self.attn_fc = nn.Linear( (encoder_hidden_dim * 2) + decoder_hidden_dim, decoder_hidden_dim ) self.v_fc = nn.Linear(decoder_hidden_dim, 1, bias=False) def forward(self, hidden, encoder_outputs): # hidden: [batch, decoder_hidden] # encoder_outputs:[src_len, batch, encoder_hidden * 2] ... # 把 hidden 复制 src_len 份,和 encoder_outputs 拼在一起 # → attn_fc → tanh → v_fc → 得到每个位置的分数

细节

说明

encoder_hidden_dim * 2

编码器是双向的,输出维度翻倍

先拼接再 attn_fc

等价于加性注意力的 Wqq+WkkW_q q + W_k k

v_fc 没有 bias

压成 1 个数,偏置没意义

两种写法数学上是一回事

Wqq+WkkW_q q + W_k k 和 W⋅[q;k]W \cdot [q; k] 在矩阵乘法里完全等价——拼接后乘一个大矩阵, 等于拆开各乘一个小矩阵再相加。

只是写起来一个更直观、一个更省代码。第 34.2 课讲 LSTM 时提过同一件事。

形状走一遍

设 batch=4, 源句 10 词, embed=256, hidden=256:

量

形状

角色

encoder_out

(4, 10, 256)

K 和 V

state

(4, 256)

Q

Wq(state) → unsqueeze

(4, 1, 256)

Q

encoder_out.transpose(1,2)

(4, 256, 10)

K

scores

(4, 1, 10)

每个源位置一个分数

alpha

(4, 10)

权重,和为 1

context

(4, 256)

c

cat([embedded, context])

(4, 512)

解码器那一步的输入

GRUCell 的输入维度要改

拼接后输入是 E + H = 512, 所以 nn.GRUCell(E, H) 要改成 nn.GRUCell(E + H, H)。

改漏了报 mat1 and mat2 shapes cannot be multiplied。

注意力权重能画出来

这是注意力的一个副产品:权重矩阵可以画成图, 直接看到「第 3 个中文词主要看第 2 个英文词」。

有的实现专门为这件事留了开关:

self.decoder_cell = tfa.seq2seq.AttentionWrapper( ..., attention_mechanism=self.attention, attention_layer_size=attention_layer_size, alignment_history=True, # for attention visualization )

训练完之后把 alignment_history 拿出来, 就是一个 (输出长度, 输入长度) 的矩阵,画成热力图。

为什么这件事值得单独提

RNN 的 h 里到底是什么,看不出来。

注意力权重是模型内部少数几个能直接读、还能画出来的东西。

如果画出来是一条对角线,说明译文的第 i 个词对应原文的第 i 个词; 如果是一条斜线或乱成一团,说明学出了问题——不需要看 BLEU 就能判断。

多出来的代价

代价

具体

不能并行

解码器每步依赖上一步的 ss,只能顺序跑

每步多两次矩阵乘

两次 bmm,T 大时不小

显存

encoder_out 要一直留着,原来是丢掉的

参数

Wq,Wk,wvW_q, W_k, w_v 三组,再加宽了的 GRUCell

这一课留下的三个数

数

值

含义

保留的张量

(B, T, H)

原来是 (1, B, H)

每步权重个数

TT

源句长度

解码器输入维度

E + H

embedding 和 c 拼接

下一课

结构清楚了。下一课手算一次—— 源句 3 个词、解码第 1 步,把 3 个分数、3 个权重、和 c 全算出来。

算完你会看到:权重把大部分给了某一个词,这就是「对齐」出现了。