seq2seq_with_attention
定义注意力解码器
下面看看如何定义Bahdanau注意力，实现循环神经网络编码器-解码器。
其实，我们只需重新定义解码器即可。
为了更方便地显示学习的注意力权重，
以下AttentionDecoder类定义了[带有注意力机制解码器的基本接口]。
class AttentionDecoder(d2l.Decoder):
"""带有注意力机制解码器的基本接口"""
def __init__(self, **kwargs):
super(AttentionDecoder, self).__init__(**kwargs)
@property
def attention_weights(self):
raise NotImplementedError
接下来，让我们在接下来的Seq2SeqAttentionDecoder类中
[实现带有Bahdanau注意力的循环神经网络解码器]。
首先，初始化解码器的状态，需要下面的输入：
- 编码器在所有时间步的最终层隐状态(即(output, state) = encoder(X) 中的state)，将作为注意力的键和值；
- 上一时间步的编码器全层隐状态(即(output, state) = encoder(X) 中的output)，将作为初始化解码器的隐状态；
- 编码器有效长度（排除在注意力池中填充词元）。
在每个解码时间步骤中，解码器上一个时间步的最终层隐状态将用作查询。
因此，注意力输出和输入嵌入都连结为循环神经网络解码器的输入。
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)
## q是编码器最后一个隐藏层的最后一个隐藏状态
## k是编码器最后一个隐藏层的所有隐藏状态
# q 和 k 的featrue为一致且均为num_hiddens
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_outputs为编码器输出
# outputs的形状为(batch_size，num_steps，num_hiddens).
# hidden_state的形状为(num_layers，batch_size，num_hiddens)
# enc_valid_lens的形状为(batch_size, )
outputs, hidden_state = enc_outputs
return (outputs.permute(1, 0, 2), hidden_state, enc_valid_lens)
def forward(self, X, state):
# enc_outputs的形状为(num_steps，batch_size, num_hiddens).
# hidden_state的形状为(num_layers，batch_size，num_hiddens)
enc_outputs, hidden_state, enc_valid_lens = state
## X刚进入forward中维度是(batch_size, nums_steps)
X = self.embedding(X).permute(1, 0, 2)
## X形状调整为(num_steps, batch_size, embed_size)
outputs, self._attention_weights = [], []
for x in X: ## x是在num_steps维度上遍历X, x形状为(batch_size, embed_size)
query = torch.unsqueeze(hidden_state[-1], dim=1) ## 拿出了最后一层layer的最后一个隐藏状态 ,query的形状为(batch_size,1,num_hiddens)
# context的形状为(batch_size,1,num_hiddens)
context = self.attention(
query, enc_outputs, enc_outputs, enc_valid_lens)
## q是编码器最后一个隐藏层的最后一个隐藏状态
## k = enc_outputs是编码器最后一个隐藏层的所有隐藏状态
## v = enc_outputs是编码器最后一个隐藏层的所有隐藏状态
## enc_vaild_lens 是编码器中对句子的padding或截断的长度
## context 维度是 （batch_size, num_q, v_featrues） = (batch_size, 1, num_hiddens)
# 在特征维度上连结
x = torch.cat((context, torch.unsqueeze(x, dim=1)), dim=-1)
## torch.unsqueeze(x, dim=1) 在第二个维度增加一个， x.shape = (batch_size, 1, embed_size)
## context.shape 为(batce_size ,1, num_hiddens)
## 沿着最后一维cat之后的向量形状变为(batch_size, 1, num_hiddens + embed_size), then you can put them into rnn
out, hidden_state = self.rnn(x.permute(1, 0, 2), hidden_state)
## x在放入rnn前形状调整为了(1, batch_size, num_hiddens + embed_size)， 刚才加的一个维度充当了时间步，（时间步为1）
outputs.append(out)
## out是解码器最后一个隐藏层的所有隐藏状态，他被append到output数组中了
self._attention_weights.append(self.attention.attention_weights)
## 本次的attention权重也被append到权重数组中了
## for 循环第二次， 即 X中的第二个时间步， hidden_state变成了上一次解码器运行后的所有0layer的最后一个隐藏状态了
# 全连接层变换后，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注意力解码器]。
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
浙公网安备 33010602011771号