注意力机制（三）：Bahdanau注意力

专栏：神经网络复现目录

注意力机制

注意力机制（Attention Mechanism）是一种人工智能技术，它可以让神经网络在处理序列数据时，专注于关键信息的部分，同时忽略不重要的部分。在自然语言处理、计算机视觉、语音识别等领域，注意力机制已经得到了广泛的应用。

注意力机制的主要思想是，在对序列数据进行处理时，通过给不同位置的输入信号分配不同的权重，使得模型更加关注重要的输入。例如，在处理一句话时，注意力机制可以根据每个单词的重要性来调整模型对每个单词的注意力。这种技术可以提高模型的性能，尤其是在处理长序列数据时。

在深度学习模型中，注意力机制通常是通过添加额外的网络层实现的，这些层可以学习到如何计算权重，并将这些权重应用于输入信号。常见的注意力机制包括自注意力机制（self-attention）、多头注意力机制（multi-head attention）等。

总之，注意力机制是一种非常有用的技术，它可以帮助神经网络更好地处理序列数据，提高模型的性能。

---

---

回顾seq2seq

假设输入序列是$x_1,...,x_T$ 其中$x_t$是输入文本序列中的第$t$个词元。 在时间步$t$，循环神经网络将词元$x_t$的输入特征向量$x_t$ 和$h_{t-1}$（即上一时间步的隐状态） 转换为$h_t$（即当前步的隐状态）。

编码器

使用一个函数$f$来描述循环神经网络的循环层所做的变换：
$$h_t=f(x_t,h_{t-1})$$
总之，编码器通过选定的函数$q$， 将所有时间步的隐状态转换为上下文变量：
$$c=q(h_1,...,h_T)$$

解码器

编码器输出的上下文变量$c$对整个输入序列$x_1,...,x_T$进行编码。 来自训练数据集的输出序列$y_1,...,y_T$， 对于每个时间步$t^{\prime }$（与输入序列或编码器的时间步$t$不同）， 解码器输出$y^{\prime }$的概率取决于先前的输出子序列$y_1,...,y_{t-1}$和上下文变量$c$， 即$P(y_t^{\prime }|y_1,..,y_{t^{\prime }-1},c)$。

为了在序列上模型化这种条件概率， 我们可以使用另一个循环神经网络作为解码器。 在输出序列上的任意时间步$t^{\prime }$， 循环神经网络将来自上一时间步的输出$y_{t^{\prime }-1}$和上下文变量$c$作为其输入， 然后在当前时间步将它们和上一隐状态$s_{t^{\prime }-1}$ 转换为隐状态$s_{t^{\prime }}$。 因此，可以使用函数$g$来表示解码器的隐藏层的变换：
$$s_{t^{\prime }}=g(y_{t^{\prime }-1},c,s_{t^{\prime }-1})$$

Bahdanau 注意力

Bahdanau 注意力是一种在神经机器翻译中使用的注意力机制，由Dzmitry Bahdanau等人于2015年首次提出。

在传统的神经机器翻译模型中，编码器将源语言句子编码为一个固定长度的向量，然后解码器使用这个向量生成目标语言句子。然而，这种固定长度向量的方法存在一些缺点，例如无法处理较长的句子，以及无法捕捉句子中不同单词之间的复杂依赖关系。

Bahdanau 注意力通过引入一种动态的对齐机制来解决这些问题。在每个时间步，解码器都会根据先前的输出和编码器的所有隐藏状态计算一个对齐分布，该分布指示编码器中哪些位置对当前时间步的输出最有用。然后，解码器使用加权的编码器隐藏状态来生成当前时间步的输出。

这种动态对齐机制可以使模型更好地捕捉源语言和目标语言之间的复杂依赖关系，从而提高翻译的准确性和流畅度。Bahdanau 注意力已经被广泛应用于机器翻译、语音识别、图像标注等领域，并成为了当前神经机器翻译领域的主流方法之一。

Bahdanau模型

这个新的基于注意力的模型与上述模型相同， 只不过上下文变量$c$在任何解码时间步$t^{\prime }$都会被$c_{t^{\prime }}$替换。 假设输入序列中有$T$个词元， 解码时间步$t^{\prime }$的上下文变量是注意力集中的输出：
$$c_{t^{\prime }}=\sum _{t=1}^T\alpha (s_{t^{\prime }-1},h_t)h_t$$
其中，时间步$t^{\prime }-1$时的解码器隐状态$s_{t^{\prime }-1}$是查询， 编码器隐状态$h_t$既是键，也是值， 注意力权重$\alpha$是使用加性注意力打分函数计算的。

实现

模型定义

#@save
class AttentionDecoder(d2l.Decoder):
    """带有注意力机制解码器的基本接口"""
    def __init__(self, **kwargs):
        super(AttentionDecoder, self).__init__(**kwargs)

    @property
    def attention_weights(self):
        raise NotImplementedError

接下来，让我们在接下来的Seq2SeqAttentionDecoder类中 实现带有Bahdanau注意力的循环神经网络解码器。 首先，初始化解码器的状态，需要下面的输入：

1. 编码器在所有时间步的最终层隐状态，将作为注意力的键和值；

2. 上一时间步的编码器全层隐状态，将作为初始化解码器的隐状态；

3. 编码器有效长度（排除在注意力池中填充词元）。

在每个解码时间步骤中，解码器上一个时间步的最终层隐状态将用作查询。 因此，注意力输出和输入嵌入都连结为循环神经网络解码器的输入。

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):
        # 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的形状为(num_steps,batch_size,embed_size)
        X = self.embedding(X).permute(1, 0, 2)
        outputs, self._attention_weights = [], []
        for x in X:
            # query的形状为(batch_size,1,num_hiddens)
            query = torch.unsqueeze(hidden_state[-1], dim=1)
            # context的形状为(batch_size,1,num_hiddens)
            context = self.attention(
                query, enc_outputs, enc_outputs, enc_valid_lens)
            # 在特征维度上连结
            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

这段代码实现了Bahdanau注意力模型的核心原理。Bahdanau注意力模型是一种用于序列到序列（seq2seq）学习的模型，其核心思想是在解码器的每一步中，根据当前的解码器状态和编码器的输出，动态地选择编码器输出的不同部分来计算当前时刻的输出。

具体来说，该代码段的实现流程如下：

1. 在解码器的每一步中，先将当前的解码器输入 $x$ 和编码器输出 $enc\_outputs$ 进行注意力计算，得到当前时刻的上下文向量 $context$。注意力计算使用的是加性注意力（Additive Attention）机制，其中 $query$ 表示当前时刻的解码器状态，$keys$ 和 $values$ 均为编码器的输出 $enc\_outputs$，$enc\_valid\_lens$ 为编码器的有效长度。

2. 将当前时刻的输入 $x$ 和上下文向量 $context$ 在特征维度上进行拼接，得到新的输入 $x$。

3. 将新的输入 $x$ 和上一时刻的解码器状态 $hidden\_state$ 输入到 GRU 中，得到当前时刻的输出 $out$ 和新的解码器状态 $hidden\_state$。

4. 将当前时刻的输出 $out$ 加入到输出列表 $outputs$ 中。

5. 将当前时刻的注意力权重加入到注意力权重列表 $\_attention\_weights$ 中。

重复以上步骤，直到解码器输出序列的所有时刻均被计算完毕。

在实现过程中，需要注意的是，输入数据的维度需要与模型的设计保持一致。具体来说，输入数据 $X$ 的维度应为 $(batch\_size,seq\_length)$，其中 $batc{h}_{s}ize$ 表示批量大小，$se{q}_{l}ength$ 表示序列长度。而模型中的循环神经网络 (RNN) 层需要的输入是 $(seq\_length,batch\_size,input\_size)$，因此需要对输入数据进行维度变换。在这段代码中，使用了 PyTorch 中的 permute() 函数对输入数据的维度进行变换。

同时，在每一步注意力计算时，还需要根据编码器的有效长度 $en{c}_{v}ali{d}_{l}ens$ 进行 Mask 处理，以避免无效位置对注意力计算造成影响。这里采用了 Additive Attention 类中的 call() 函数，自动对无效位置进行了 Mask 处理。

具体地说，解码器的构造函数接受以下参数：

vocab_size：词汇表的大小
embed_size：嵌入向量的大小
num_hiddens：RNN层中的隐藏单元数
num_layers：RNN层中的层数
dropout：Dropout的概率

在构造函数中，解码器首先调用其父类 AttentionDecoder 的构造函数进行初始化。然后，它定义了三个模块：

self.attention：一个加性注意力模型，它将编码器的输出与解码器的隐藏状态作为输入，并返回一个上下文向量，以指导解码器在当前时间步生成目标序列。

self.embedding：一个嵌入层，它将目标序列转换为嵌入向量。

self.rnn：一个带有 GRU 单元的 RNN 层，它将上下文向量和嵌入向量连接起来，并返回当前时间步的输出和隐藏状态。

接下来，解码器定义了一个 init_state 方法，它接受编码器的输出，编码器的有效长度和任意其他参数，并将它们转换为解码器的初始状态。这个方法将编码器的输出的第一维和第二维交换，并且将有效长度作为第三个元素添加到状态中。

最后，解码器定义了一个 forward 方法，它接受目标序列和解码器的状态作为输入，并返回生成的序列及其最终状态。在这个方法中，首先将目标序列转换为嵌入向量，然后迭代序列中的每个时间步。在每个时间步，解码器使用注意力机制来计算上下文向量，并将其与嵌入向量连接起来，以便输入到RNN中。然后，解码器将RNN输出添加到一个列表中，并将注意力权重添加到另一个列表中。最后，解码器使用全连接层将所有输出转换为一个概率分布，然后返回生成的序列及其状态。注意力权重可以通过属性 self.attention_weights 访问。

在自然语言处理中，词向量嵌入（Word embedding）是指将词语映射到低维的实数向量空间中。通过将每个单词表示为一个向量，可以在神经网络中更方便地进行处理。
在这个代码中，nn.Embedding 是一个用于定义一个词向量嵌入层的 PyTorch 模块。在 Seq2SeqAttentionDecoder 的初始化函数中，self.embedding 是一个 nn.Embedding 实例，用于将单词编码为对应的词向量。具体来说，给定一个整数，这个整数对应于一个单词的编号，这个嵌入层会将这个整数转换为一个固定大小的向量，这个向量会作为神经网络中的输入。
在这个代码中，self.embedding 接收 X 作为输入，其中 X 是一个整数张量，其形状为 (batch_size, num_steps)。这个嵌入层会将每个整数转换为一个词向量，这些词向量组成的张量的形状为 (batch_size, num_steps, embed_size)。这样，我们就可以将文本序列编码为对应的词向量序列，并在神经网络中使用这些向量进行处理。

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

训练

embed_size, num_hiddens, num_layers, dropout = 32, 32, 2, 0.1
batch_size, num_steps = 64, 10
lr, num_epochs, device = 0.005, 250, 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)

测试

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}')

注意力可视化

# 加上一个包含序列结束词元
d2l.show_heatmaps(
    attention_weights[:, :, :, :len(engs[-1].split()) + 1].cpu(),
    xlabel='Key positions', ylabel='Query positions')