注意力机制-FlyAI

注意力机制

自然语言处理

最后更新 2021-03-24 11:46 阅读 9538

最后更新 2021-03-24 11:46

阅读 9538

自然语言处理

![](https://markdown-images-1257755739.cos.ap-guangzhou.myqcloud.com/hexo/images/v2-24927f5c33083c1322bc16fa9feb38fd_r.jpg)

# RNN结构的局限

机器翻译解决的是输入是一串在某种语言中的一句话，输出是目标语言相对应的话的问题，如将英语中的一段话翻译成合适的法语。以前的Neural Machine Translation模型，通常的配置是encoder-decoder结构，即encoder读取输入的句子将其转换为定长的一个向量，然后decoder再将这个向量翻译成对应的目标语言的文字。通常encoder及decoder均采用RNN结构如LSTM或GRU等（encoder在各个时间步依赖相同的背景变量来获取输入序列信息，decoder在各个时间步依赖相同的背景变量来获取输入序列信息）。但是这个结构有些问题，尤其是RNN机制实际中存在长程梯度消失的问题，对于较长的句子，我们很难寄希望于将输入的序列转化为定长的向量而保存所有的有效信息，所以随着所需翻译句子的长度的增加，这种结构的效果会显著下降。

# Attention机制的引入

为了解决这一由长序列到定长向量转化而造成的信息损失的瓶颈，Attention注意力机制被引入了。Attention机制跟人类翻译文章时候的思路有些类似，即将注意力关注于我们翻译部分对应的上下文。在Attention模型中，当我们翻译当前词语时，我们会寻找源语句中相对应的几个词语，并结合之前的已经翻译的部分作出相应的翻译。

一个翻译例子：输入为英语序列“They”“are”“watching”“.”，输出为法语列“Ils”“regardent”“.”。不难想到，解码器在生成输出序列中的每一个词时可能只需利用输入序列某一部分的信息。例如，在输出序列的时间步1，解码器可以主要依赖“They”“are”的信息来生成“Ils”，在时间步2则主要使用来自“watching”的编码信息生成“regardent”，最后在时间步3则直接映射句号“.”。这看上去就像是在解码器的每一时间步对输入序列中不同时间步的表征或编码信息分配不同的注意力一样。

仍然以循环神经网络为例，注意力机制通过对编码器所有时间步的隐藏状态做加权平均来得到背景变量。解码器在每一时间步调整这些权重，即注意力权重，从而能够在不同时间步分别关注输入序列中的不同部分并编码进相应时间步的背景变量。在seq2seq里区分了输入序列（编码器）的索引$t$与输出序列（解码器）的索引$t'$。解码器在时间步$t'$的隐藏状态

$$
\boldsymbol{s}_{t'} = g(\boldsymbol{y}_{t'-1}, \boldsymbol{c},\boldsymbol{s}_{t'-1})
$$
其中，$\boldsymbol{y}_{t'-1}$是上一时间步$(t'-1)$的输出$y_{t'-1}$的表征，$s_{t^\prime-1}$是上一时间步$(t^\prime-1)$的隐藏状态，且任一时间步$t'$使用相同的背景变量$\boldsymbol{c}$。

但在注意力机制中，解码器的每一时间步将使用可变的背景变量。记$\boldsymbol{c}_{t'}$是解码器在时间步$t'$的背景变量，那么解码器在该时间步的隐藏状态可以改写为：
$$
\boldsymbol{s}_{t'} = g(\boldsymbol{y}_{t'-1}, \boldsymbol{c}_{t'}, \boldsymbol{s}_{t'-1})
$$

这里的关键是如何计算背景变量$\boldsymbol{c}_{t'}$和如何利用它来更新隐藏状态$\boldsymbol{s}_{t'}$。下面将分别描述这两个关键点。

## 编码器中的attention

下图描绘了注意力机制如何为解码器在时间步2计算背景变量。首先，函数$a$根据解码器在时间步1的隐藏状态和编码器在各个时间步的隐藏状态计算softmax运算的输入。softmax运算输出概率分布并对编码器各个时间步的隐藏状态做加权平均，从而得到背景变量。

![编码器—解码器上的注意力机制](https://markdown-images-1257755739.cos.ap-guangzhou.myqcloud.com/hexo/images/10.11_attention.svg)

具体来说，令编码器在时间步$t$的隐藏状态为$\boldsymbol{h}_t$，且总时间步数为$T$。那么解码器在时间步$t'$的背景变量为所有编码器隐藏状态的加权平均：

$$
\boldsymbol{c}_{t'} = \sum_{t=1}^T \alpha_{t' t} \boldsymbol{h}_t,
$$

其中给定$t'$时，权重$\alpha_{t' t}$在$t=1,\ldots,T$的值是一个概率分布。为了得到概率分布，可以使用softmax运算:

$$
\alpha_{t' t} = \frac{\exp(e_{t' t})}{ \sum_{k=1}^T \exp(e_{t' k}) },\quad t=1,\ldots,T.
$$

现在，需要定义如何计算上式中softmax运算的输入$e_{t' t}$。由于$e_{t' t}$同时取决于解码器的时间步$t'$和编码器的时间步$t$，不妨以解码器在时间步$t'-1$的隐藏状态$\boldsymbol{s}_{t' - 1}$与编码器在时间步$t$的隐藏状态$\boldsymbol{h}_t$为输入，并通过函数$a$计算$e_{t' t}$：

$$
e_{t' t} = a(\boldsymbol{s}_{t' - 1}, \boldsymbol{h}_t).
$$

这里函数$a$有多种选择，如果两个输入向量长度相同，一个简单的选择是计算它们的内积$a(\boldsymbol{s}, \boldsymbol{h})=\boldsymbol{s}^\top \boldsymbol{h}$。而最早提出注意力机制的论文则将输入连结后通过含单隐藏层的多层感知机变换：

$$
a(\boldsymbol{s}, \boldsymbol{h}) = \boldsymbol{v}^\top \tanh(\boldsymbol{W}_s \boldsymbol{s} + \boldsymbol{W}_h \boldsymbol{h}),
$$

其中$\boldsymbol{v}$、$\boldsymbol{W}_s$、$\boldsymbol{W}_h$都是可以学习的模型参数。

## 计算背景向量

还可以对注意力机制采用更高效的矢量化计算。广义上，注意力机制的输入包括查询项以及一一对应的键项和值项，其中值项是需要加权平均的一组项。在加权平均中，值项的权重来自查询项以及与该值项对应的键项的计算。

在上面的例子中，查询项为解码器的隐藏状态，键项和值项均为编码器的隐藏状态。
考虑一个常见的简单情形，即编码器和解码器的隐藏单元个数均为$h$，且函数$a(\boldsymbol{s}, \boldsymbol{h})=\boldsymbol{s}^\top \boldsymbol{h}$。假设我们希望根据解码器单个隐藏状态$\boldsymbol{s}_{t' - 1} \in \mathbb{R}^{h}$和编码器所有隐藏状态$\boldsymbol{h}_t \in \mathbb{R}^{h}, t = 1,\ldots,T$来计算背景向量$\boldsymbol{c}_{t'}\in \mathbb{R}^{h}$。
我们可以将查询项矩阵$\boldsymbol{Q} \in \mathbb{R}^{1 \times h}$设为$\boldsymbol{s}_{t' - 1}^\top$，并令键项矩阵$\boldsymbol{K} \in \mathbb{R}^{T \times h}$和值项矩阵$\boldsymbol{V} \in \mathbb{R}^{T \times h}$相同且第$t$行均为$\boldsymbol{h}_t^\top$。此时，我们只需要通过矢量化计算
$$
\boldsymbol{c}_{t'}^\top =\text{softmax}(\boldsymbol{Q}\boldsymbol{K}^\top)\boldsymbol{V}
$$

即可算出转置后的背景向量$\boldsymbol{c}_{t'}^\top$。当查询项矩阵$\boldsymbol{Q}$的行数为$n$时，上式将得到$n$行的输出矩阵。输出矩阵与查询项矩阵在相同行上一一对应。

# Attention机制的本质思想

如果把Attention机制从上文讲述例子中的Encoder-Decoder框架中剥离，并进一步做抽象，可以更容易看懂Attention机制的本质思想。

![](https://markdown-images-1257755739.cos.ap-guangzhou.myqcloud.com/hexo/images/v2-24927f5c33083c1322bc16fa9feb38fd_r.jpg)

可以这样来看待Attention机制：将Source中的构成元素想象成是由一系列的<Key,Value>数据对构成，此时给定Target中的某个元素Query，通过计算Query和各个Key的相似性或者相关性，得到每个Key对应Value的权重系数，然后对Value进行加权求和，即得到了最终的Attention数值。所以本质上Attention机制是对Source中元素的Value值进行加权求和，而Query和Key用来计算对应Value的权重系数。即可以将其本质思想改写为如下公式：
$$
Attention(Query,source) = \sum_{i=1}^{L_x} similarity(query,key)*value_i
$$
其中，$L_x=\|Source\|$代表Source的长度。上文所举的机器翻译的例子里，因为在计算Attention的过程中，Source中的Key和Value合二为一，指向的是同一个东西，也即输入句子中每个单词对应的隐藏状态，所以可能不容易看出这种能够体现本质思想的结构。

从概念上理解，把Attention仍然理解为从大量信息中有选择地筛选出少量重要信息并聚焦到这些重要信息上，忽略大多不重要的信息，这种思路仍然成立。聚焦的过程体现在权重系数的计算上，权重越大越聚焦于其对应的Value值上，即权重代表了信息的重要性，而Value是其对应的信息。

从上图还可以引出另外一种理解，也可以将Attention机制看作一种**软寻址**:Source可以看作存储器内存储的内容，元素由地址Key和值Value组成，当前有个Key=Query的查询，目的是取出存储器中对应的Value值，即Attention数值。通过Query和存储器内元素Key的地址进行相似性比较来寻址，之所以说是软寻址，指的不像一般寻址只从存储内容里面找出一条内容，而是可能从每个Key地址都会取出内容，取出内容的重要性根据Query和Key的相似性来决定，之后对Value进行加权求和，这样就可以取出最终的Value值，也即Attention值。所以不少研究人员将Attention机制看作软寻址的一种特例，这也是非常有道理的。

# Attention机制的计算过程

Attention机制的具体计算过程，如果对目前大多数方法进行抽象的话，可以将其归纳为**两个过程**：

1. 第一个过程是根据Query和Key计算权重系数

1. 第一个阶段：根据Query和Key计算两者的相似性或者相关性

- 点积：$score(h_t,h_s) = h_t^T \cdot h_s$
		- Cosine相似度：$score(h_t,h_s) = \frac{h_t^T \cdot h_s}{\|h_t\|\cdot\|h_s\|}$
		- MLP:$score(h_t,h_s) = MLP(h_t , h_s)$
		- Scaled Dot Product : $score(h_t,h_s) = \frac{h_t^T \cdot h_s}{\sqrt{H}}$ ,其中`H`是RNN encoder隐藏状态的数量
		- Concat：$v_{a}^{\top} \cdot \tanh \left(W_{a}\left[h_{t}: h_{s}\right]\right)$
		- Location: $W_a \cdot h_t$
		- General: $h_t^T\cdot W_a\cdot h_s$

2. 第二个阶段：对第一阶段的原始分值进行归一化处理
		$$
		\alpha_i = softmax(sim_i) = \frac{e^{sim_i}}{\sum_{j=1}^{L_x}{e^{sim_j}}}
		$$

2. 第二个过程根据权重系数对Value进行加权求和
	$$
	attention(Query,Source) = \sum_{i=1}^{L_x} \alpha_i \cdot Value_i
	$$

![](https://markdown-images-1257755739.cos.ap-guangzhou.myqcloud.com/hexo/images/v2-07c4c02a9bdecb23d9664992f142eaa5_1440w.jpg)

# Self Attention

Self Attention也经常被称为intra Attention（内部Attention）。在一般任务的Encoder-Decoder框架中，输入Source和输出Target内容是不一样的，比如对于英-中机器翻译来说，Source是英文句子，Target是对应的翻译出的中文句子，Attention机制发生在Target的元素Query和Source中的所有元素之间。而Self Attention是Source内部元素之间或者Target内部元素之间发生的Attention机制，也可以理解为Target=Source这种特殊情况下的注意力计算机制。其具体计算过程是一样的，只是计算对象发生了变化而已。

##Self Attention学到了哪些规律或者抽取出了哪些特征？

以机器翻译中的Self Attention来说明，图11和图12是可视化地表示Self Attention在同一个英语句子内单词间产生的联系。以机器翻译中的Self Attention来说明，下面两张图是可视化地表示Self Attention在同一个英语句子内单词间产生的联系。

![](https://markdown-images-1257755739.cos.ap-guangzhou.myqcloud.com/hexo/images/v2-1b7a38bc0bd8a46b52753ece64f665ad_r.jpg)

![](https://markdown-images-1257755739.cos.ap-guangzhou.myqcloud.com/hexo/images/v2-c19809fef8cd32115ad69d6946ec6564_r.jpg)

从两张图可以看出，Self Attention可以捕获同一个句子中单词之间的一些句法特征（有一定距离的短语结构）或者语义特征（its的指代对象Law）。

很明显，引入Self Attention后会**更容易捕获句子中长距离的相互依赖的特征**，因为如果是RNN或者LSTM，需要依次序序列计算，对于远距离的相互依赖的特征，要经过若干时间步步骤的信息累积才能将两者联系起来，而距离越远，有效捕获的可能性越小。

但是Self Attention在计算过程中会直接将句子中任意两个单词的联系通过一个计算步骤直接联系起来，所以远距离依赖特征之间的距离被极大缩短，有利于有效地利用这些特征。除此外，Self Attention对于增加计算的并行性也有直接帮助作用。这是为何Self Attention逐渐被广泛使用的主要原因。

## 代码

```python
class SelfAttention(Layer):
    """
    Layer for implementing self-attention mechanism. Weight variables were preferred over Dense()
    layers in implementation because they allow easier identification of shapes. Softmax activation
    ensures that all weights sum up to 1.
    @param (int) size: a.k.a attention length, number of hidden units to decode the attention before
           the softmax activation and becoming annotation weights
    @param (int) num_hops: number of hops of attention, or number of distinct components to be
           extracted from each sentence.
    @param (bool) use_penalization: set True to use penalization, otherwise set False
    @param (int) penalty_coefficient: the weight of the extra loss
    @param (str) model_api: specify to use TF's Sequential OR Functional API, note that attention
           weights are not outputted with the former as it only accepts single-output layers
    """
    def __init__(self, size, num_hops=8, use_penalization=True,
                 penalty_coefficient=0.1, model_api='functional', **kwargs):
        if model_api not in ['sequential', 'functional']:
            raise ValueError("Argument for param @model_api is not recognized")
        self.size = size
        self.num_hops = num_hops
        self.use_penalization = use_penalization
        self.penalty_coefficient = penalty_coefficient
        self.model_api = model_api
        super(SelfAttention, self).__init__(**kwargs)

def get_config(self):
        base_config = super(SelfAttention, self).get_config()
        base_config['size'] = self.size
        base_config['num_hops'] = self.num_hops
        base_config['use_penalization'] = self.use_penalization
        base_config['penalty_coefficient'] = self.penalty_coefficient
        base_config['model_api'] = self.model_api
        return base_config

def build(self, input_shape):
        self.W1 = self.add_weight(name='W1',
                                  shape=(self.size, input_shape[2]),  # (size, H)
                                  initializer='glorot_uniform',
                                  trainable=True)
        self.W2 = self.add_weight(name='W2',
                                  shape=(self.num_hops, self.size),  # (num_hops, size)
                                  initializer='glorot_uniform',
                                  trainable=True)
        super(SelfAttention, self).build(input_shape)

def call(self, inputs):  # (B, S, H)
        # Expand weights to include batch size through implicit broadcasting
        W1, W2 = self.W1[None, :, :], self.W2[None, :, :]
        hidden_states_transposed = Permute(dims=(2, 1))(inputs) # (B, H, S)
        attention_score = tf.matmul(W1, hidden_states_transposed) # (B, size, S)
        attention_score = Activation('tanh')(attention_score) # (B, size, S)
        attention_weights = tf.matmul(W2, attention_score)# (B, num_hops, S)
        attention_weights = Activation('softmax')(attention_weights)  # (B, num_hops, S)
        embedding_matrix = tf.matmul(attention_weights, inputs)  # (B, num_hops, H)
        embedding_matrix_flattened = Flatten()(embedding_matrix)  # (B, num_hops*H)

if self.use_penalization:
            attention_weights_transposed = Permute(dims=(2, 1))(attention_weights)  # (B, S, num_hops)
            product = tf.matmul(attention_weights, attention_weights_transposed)  # (B, num_hops, num_hops)
            identity = tf.eye(self.num_hops, batch_shape=(inputs.shape[0],)) # (B, num_hops, num_hops)
            frobenius_norm = tf.sqrt(tf.reduce_sum(tf.square(product - identity)))  # distance
            self.add_loss(self.penalty_coefficient * frobenius_norm)  # loss

if self.model_api == 'functional':
            return embedding_matrix_flattened, attention_weights
        elif self.model_api == 'sequential':
            return embedding_matrix_flattened
```

# Attention变种

## 硬性注意力

之前提到的注意力是软性注意力，其选择的信息是所有输入信息**在注意力分布下的期望**。还有一种注意力是只关注到**某一个位置上的信息**，叫做**hard attention**。硬性注意力有两种实现方式：

1. 一种是选取**最高概率**的输入信息；
2. 另一种硬性注意力可以通过在注意力分布式上**随机采样**的方式实现。

硬性注意力模型的**缺点**：

硬性注意力的一个缺点是基于最大采样或随机采样的方式来选择信息。**因此最终的损失函数与注意力分布之间的函数关系不可导**，因此**无法使用在反向传播算法进行训练**。为了使用反向传播算法，一般使用软性注意力来代替硬性注意力。硬性注意力需要通过强化学习来进行训练。

## 键值对注意力

Key！=Value，注意力函数变成：
$$
attention((K,V),Q) = \sum_{i=1}^{N}{\alpha_i v_i} = \sum_{i=1}^{N}{\frac{e^{sim_i}}{\sum_{j=1}^{L_x}{e^{sim_j}}} v_i}
$$

## 多头注意力

多头注意力是利用多个查询$Q = [q_1, \ldots, q_M]$，来平行地计算从输入信息中选取多个信息。**每个注意力关注输入信息的不同部分**，然后再进行拼接：
$$
\operatorname{att}((K, V), Q)=\operatorname{att}\left((K, V), \mathbf{q}_{1}\right) \oplus \cdots \oplus \mathbf{a t t}\left((K, V), \mathbf{q}_{M}\right)
$$

# 总结

* 可以在解码器的每个时间步使用不同的背景变量，并对输入序列中不同时间步编码的信息分配不同的注意力。
* 广义上，注意力机制的输入包括查询项以及一一对应的键项和值项。
* 注意力机制可以采用更为高效的矢量化计算。

# 参考文献

[1] Bahdanau, D., Cho, K., & Bengio, Y. (2014). Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473.

[2] Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., ... & Polosukhin, I. (2017). Attention is all you need. In Advances in Neural Information Processing Systems (pp. 5998-6008).

[3] Devlin, J., Chang, M. W., Lee, K., & Toutanova, K. (2018). Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805.

[4] Radford, A., Wu, J., Child, R., Luan, D., Amodei, D., Sutskever I. (2019). Language Models are Unsupervised Multitask Learners. OpenAI.

本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可，转载请附上原文出处链接和本声明。
本文链接地址：https://flyai.com/article/849

讨论

500字

表情

发送

删除确认

是否删除该条评论？

取消删除