系列文章目录
文章目录
我们来真的看一下实际应用中，key，value，query是什么东西，但是取决于应用场景不同，这三个东西会产生变化。先将放在seq2seq这个例子。
动机
机器翻译中，每个生成的词可能相关于源句子中不同的词。
比如RNN的最后一个时刻的最后一个输出，把所有东西压到一起，你看到的东西可能看不清楚。我想要翻译对应的词的时候，关注原句子中对应的部分，这就是将注意力机制放在seq2seq的动机，而之前的seq2seq模型中不能对此直接建模。
加入注意力
大体上就是，我在解码器RNN的输入一部分来自embedding，之前还有一部分是来自RNN最后一个时刻的最后一层作为上下文和embedding一起传进去。现在说最后一个时刻作为Context传进去不好，我应该根据我的现在预测值的不一样去选择不是最后一个时刻，可能是前面某个时刻对应的那些隐藏状态（经过注意力机制）作为输入。
编码器对每次词的输出作为key和value(它们成对的）。
解码器RNN对上一个词的输出是query。
注意力的输出和下一个词的词嵌入合并进入解码器。
总结
- Seq2seq中通过隐状态在编码器和解码器中传递信息
- 注意力机制可以根据解码器RNN的输出来匹配到合适的编码器RNN的输出来更有效的传递信息
代码
python
import torch
from torch import nn
from d2l import torch as d2l定义注意力解码器
下面看看如何定义Bahdanau注意力，实现循环神经网络编码器-解码器。
其实，我们只需重新定义解码器即可。
为了更方便地显示学习的注意力权重，
以下AttentionDecoder类定义了[带有注意力机制解码器的基本接口]。
python
#@save
class AttentionDecoder(d2l.Decoder):
"""带有注意力机制解码器的基本接口"""
def __init__(self, **kwargs):
super(AttentionDecoder, self).__init__(**kwargs)
@property
def attention_weights(self): #画图所需代码
raise NotImplementedError接下来，让我们在接下来的Seq2SeqAttentionDecoder类中[实现带有Bahdanau注意力的循环神经网络解码器 ]。
首先，初始化解码器的状态，需要下面的输入：
- 编码器在所有时间步的最终层隐状态，将作为注意力的键和值；
- 上一时间步的编码器全层隐状态，将作为初始化解码器的隐状态；
- 编码器有效长度（排除在注意力池中填充词元）。
在每个解码时间步骤中，解码器上一个时间步的最终层隐状态将用作查询。
因此，注意力输出和输入嵌入都连结为循环神经网络解码器的输入。
python
class Seq2SeqAttentionDecoder(AttentionDecoder):
def __init__(self, vocab_size, embed_size, num_hiddens, num_layers,
dropout=0, **kwargs):
super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)
self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout) #相比之前只是新增了这行代码
self.embedding = nn.Embedding(vocab_size, embed_size)
self.rnn = nn.GRU( embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout)
self.dense = nn.Linear(num_hiddens, vocab_size)
def init_state(self, enc_outputs, enc_valid_lens, *args): #多了一个enc_valid_lens，之前不需要，现在需要知道英语的句子哪些是pad的。
# outputs的形状为(batch_size，num_steps，num_hiddens).
# hidden_state的形状为(num_layers，batch_size，num_hiddens)
outputs, hidden_state = enc_outputs
return (outputs.permute(1, 0, 2), hidden_state, enc_valid_lens)
def forward(self, X, state):
# enc_outputs的形状为(batch_size,num_steps,num_hiddens).
# hidden_state的形状为(num_layers,batch_size, num_hiddens)
enc_outputs, hidden_state, enc_valid_lens = state
X = self.embedding(X).permute(1, 0, 2) # 输出X的形状为(num_steps,batch_size,embed_size)
outputs, self._attention_weights = [], []
for x in X:
# print("x.shape = "+str(x.shape)) #x.shape = torch.Size([4, 8])
query = torch.unsqueeze(hidden_state[-1], dim=1) # query的形状改为(batch_size,1,num_hiddens) 虽然query只有一个，但是要把query数量这个维度加进去，才能应用上一博客的函数
# context的形状为(batch_size,1,num_hiddens)
context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens) # key和value是成对的，且都是encoder的output，enc_valid_lens是为了防止encoder中那些无效的pad的部分也被当作正常部分进行运算，encoder的长度是由num_steps确定好的定长的。query每次都会变。
# print("context.shape = "+ str(context.shape)) #context.shape = torch.Size([4, 1, 16])
# 在特征维度上连结
x = torch.cat((context, torch.unsqueeze(x, dim=1)), dim=-1)
# 将x变形为(1,batch_size,embed_size+num_hiddens)
out, hidden_state = self.rnn(x.permute(1, 0, 2), hidden_state)
outputs.append(out)
self._attention_weights.append(self.attention.attention_weights) # 将输出和注意力权重保存到列表中。
# 全连接层变换后，outputs的形状为
# (num_steps,batch_size,vocab_size)
outputs = self.dense(torch.cat(outputs, dim=0))
return outputs.permute(1, 0, 2), [enc_outputs, hidden_state, enc_valid_lens]
@property
def attention_weights(self):
return self._attention_weights接下来，使用包含7个时间步的4个序列输入的小批量[测试Bahdanau注意力解码器]。
python
encoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16,
num_layers=2)
encoder.eval()
decoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16,
num_layers=2)
decoder.eval()
X = torch.zeros((4, 7), dtype=torch.long) # (batch_size,num_steps)
state = decoder.init_state(encoder(X), None)
output, state = decoder(X, state)
output.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape(torch.Size([4, 7, 10]), 3, torch.Size([4, 7, 16]), 2, torch.Size([4, 16]))
训练
与 :numref:sec_seq2seq_training类似，
我们在这里指定超参数，实例化一个带有Bahdanau注意力的编码器和解码器，
并对这个模型进行机器翻译训练。
由于新增的注意力机制，训练要比没有注意力机制的
:numref:sec_seq2seq_training慢得多。
python
embed_size, num_hiddens, num_layers, dropout = 32, 32, 2, 0.1
batch_size, num_steps = 64, 10
lr, num_epochs, device = 0.005, 30, d2l.try_gpu()
train_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)
encoder = d2l.Seq2SeqEncoder(
len(src_vocab), embed_size, num_hiddens, num_layers, dropout)
decoder = Seq2SeqAttentionDecoder(
len(tgt_vocab), embed_size, num_hiddens, num_layers, dropout)
net = d2l.EncoderDecoder(encoder, decoder)
d2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)loss 0.099, 10527.1 tokens/sec on cuda:0
<Figure size 350x250 with 1 Axes>
模型训练后，我们用它[将几个英语句子翻译成法语]并计算它们的BLEU分数。
python
engs = ['go .', "i lost .", 'he\'s calm .', 'i\'m home .']
fras = ['va !', 'j\'ai perdu .', 'il est calme .', 'je suis chez moi .']
for eng, fra in zip(engs, fras):
translation, dec_attention_weight_seq = d2l.predict_seq2seq( net, eng, src_vocab, tgt_vocab, num_steps, device, True)
print(f'{eng} => {translation}, ', f'bleu {d2l.bleu(translation, fra, k=2):.3f}')go . => <unk> ., bleu 0.000
i lost . => je suis parti ., bleu 0.000
he's calm . => il est <unk> ., bleu 0.658
i'm home . => je suis <unk> ., bleu 0.512
python
attention_weights = torch.cat([step[0][0][0] for step in dec_attention_weight_seq], 0).reshape((
1, 1, -1, num_steps))训练结束后，下面通过[可视化注意力权重 ]
会发现，每个查询都会在键值对上分配不同的权重，这说明
在每个解码步中，输入序列的不同部分被选择性地聚集在注意力池中。
python
# 加上一个包含序列结束词元
d2l.show_heatmaps(
attention_weights[:, :, :, :len(engs[-1].split()) + 1].cpu(),
xlabel='Key positions', ylabel='Query positions')
小结
- 在预测词元时，如果不是所有输入词元都是相关的，那么具有Bahdanau注意力的循环神经网络编码器-解码器会有选择地统计输入序列的不同部分。这是通过将上下文变量视为加性注意力池化的输出来实现的。
- 在循环神经网络编码器-解码器中，Bahdanau注意力将上一时间步的解码器隐状态视为查询，在所有时间步的编码器隐状态同时视为键和值。
练习
- 在实验中用LSTM替换GRU。
- 修改实验以将加性注意力打分函数替换为缩放点积注意力，它如何影响训练效率？