Attention机制介绍（原理+代码）_rx attention

直接进入正题吧，在介绍Attention机制之前需要知道什么是seq2seq模型，也就是Encoder-Decoder模型，下面对seq2seq进行简单的介绍。

1、seq2seq模型

作为RNN模型的一种变体：N vs M，此结构又称为Encoder-Decoder模型，也就是我们常说的seq2seq模型。seq2seq模型的出现解决了许多应用的问题，比如解决了传统的序列等长的问题，在机器翻译等领域得到了很好的运用。
seq2seq模型先将输入数据编码成一个上下文向量c：

这里的上下文向量c有多种方式，可以将最后一个隐状态赋值给c，也可以将最后一个隐状态做变换赋值给c，也可以将所有的状态做变换赋值给c。
得到c之后，然后用另外一个RNN模型进行解码，也就是Decoder过程。你可以理解为将c作为新的h0作为输入到Decoder结构中，


输入的情况分为上面两种，这种结构不限制输入和输出的序列长度，所以在很多领域得到了应用，但其本身存在着有些问题，在Encoder-Decoder结构中，Encoder把所有的输入序列都编码成一个统一的语义特征c再解码，因此， c中必须包含原始序列中的所有信息，它的长度就成了限制模型性能的瓶颈。如机器翻译问题，当要翻译的句子较长时，一个c可能存不下那么多信息，就会造成翻译精度的下降，为了解决这个问题，采用了attention机制。

2、Attention机制

Attention机制的定义：
1、给定一组向量集合values，以及一个向量query，attention机制是一种根据该query计算values的加权求和的机制。
2、attention的重点就是这个集合values中的每个value的“权值”的计算方法。
3、有时候也把这种attention的机制叫做query的输出关注了（或者说叫考虑到了）原文的不同部分。（Query attends to the values）
举例：刚才seq2seq中，哪个是query，哪个是values？
each decoder hidden state attends to the encoder hidden states （decoder的第t步的hidden state----st是query，encoder的hidden states是values）
从定义来看Attention的感性认识：

The weighted sum is a selective summary of the information contained in the values, where the query determines which values to focus on.
换句话说，attention机制就是一种根据某些规则或者某些额外信息（query）从向量表达集合（values）中抽取特定的向量进行加权组合（attention）的方法。简单来讲，只要我们从部分向量里面搞了加权求和，那就算用了attention。

3. attention的计算变体
   首先从大的概念来讲，针对attention的变体主要有两种方式：
   1.一种是在attention 向量的加权求和计算方式上进行创新
   2.另一种是在attention score（匹配度或者叫权值）的计算方式上进行创新

当然还有一种就是把二者都有改变的结合性创新，或者是迁移性创新，比如借鉴CNN的Inception思想等等，后续会提到一点，详细的应该是在以后可能要讲的Tranformer里面会详细提到。
我们先针对第一种方法讲讲区别，其实虽然名字变来变去，他们的差异没有那么多。

3.1 针对attention向量计算方式变体
大概分成这么几种：

Soft attention、global attention、动态attention

Hard attention

“半软半硬”的attention （local attention）

静态attention

强制前向attention

Soft attention、global attention、动态attention
这三个其实就是Soft attention，也就是我们上面讲过的那种最常见的attention，是在求注意力分配概率分布的时候，对于输入句子X中任意一个单词都给出个概率，是个概率分布，把attention变量（context vecor）用ct c_tc
t
​
表示，attention得分在经过了softmax过后的权值用alpha表示

Hard attention
Soft是给每个单词都赋予一个单词match概率，那么如果不这样做，直接从输入句子里面找到某个特定的单词，然后把目标句子单词和这个单词对齐，而其它输入句子中的单词硬性地认为对齐概率为0，这就是Hard Attention Model的思想。

Hard attention的这个pt，我也没有详细研究，不过我觉得可能跟下面讲的local attention机制的找法差不多。据说Hard attention 一般用在图像里面，当图像区域被选中时，权重为1，剩下时候为0。
https://www.cnblogs.com/Determined22/p/6914926.html

local attention （半软半硬attention）
Soft attention 每次对齐的时候都要考虑前面的encoder的所有hi，所以计算量会很大，因此一种朴素的思想是只考虑部分窗口内的encoder隐藏输出，其余部分为0，在窗口内使用softmax的方式转换为概率。这个local attention相反概念的是global attention，global attention其实就是softmax attention，这里不多赘述global attention了。

论文：Effective Approaches to Attention-based Neural Machine Translation
在这个模型中，对于是时刻t的每一个目标词汇，模型首先产生一个对齐的位置 pt（aligned position），context vector 由编码器中一个集合的隐藏层状态计算得到，编码器中的隐藏层包含在窗口[pt-D,pt+D]中，D的大小通过经验选择。

上式之中，大S指的是源句子的长度，Wp和vp是指的模型的参数，通过训练得到，为了支持pt附近的对齐点，设置一个围绕pt的高斯分布，其中小s是在以pt为中心的窗口中的整数，pt是一个在[0，S]之间的实数。小Sigma σ 一般取窗口大小的一半。

静态attention
静态attention：对输出句子共用一个St的attention就够了，一般用在Bilstm的首位hidden state输出拼接起来作为st（在图所示中为u）

论文：Teaching Machines to Read and Comprehend 以及
Supervised Sequence Labelling with Recurrent Neural Networks

上面这个图是我从论文摘过来的静态attention的示意图，有同学可能会注意到的是：这个前面的每个hidden state 不应该都和这里的 u 算一次attention score吗，怎么这里只有一个r和u进行了交互？
其实他这里的r表示的是加权平均的self attention，这个权就是attention ct向量，这个图里面把attention ct的计算过程省略了。直接跳到了ct和st计算真正的s’t的部分。他这个里面用的实际的attention score的计算并不是用点积，是additive attention，什么是additive attention呢？这个下面就会讲根据按照attention score计算的不同的attention model变体。

3.2 针对Attention score的计算方式变体
讲完了在加权向量${\alpha }_i$（注意，此处这个${\alpha }_i$指的是得分softmax之后的向量的第i个分量）的计算上面的各种attention变体，我们现在再回到原始的soft attention公式上面来。在softmax 的Attention向量的计算总是依赖于权重求和，而权重往往是attention score的softmax。

我们可以看到，式子中的变量e代表的就是attention score，alpha是attention的权重，a就是context vector
根据attention score的计算方式不同，我们可以将attention进一步细分分类。attention score的计算主要有以下几种：

注意点积attention score这里有个假设，就是s和h的维数要一样才能进行点积，很好理解。
第二个W矩阵是训练得到的参数，维度是d2 x d1，d2是s的hidden state输出维数，d1是hi的hidden state维数
最后就是上面提到的additive attention，是对两种hidden state 分别再训练矩阵然后激活过后再乘以一个参数向量变成一个得分。
其中，W1 = d3xd1，W2 = d3*d2，v = d3x1 ，d1，d2，d3分别为h和s还有v的维数，属于超参数。

4.更加特殊的attention
4.1 self attention
思想：Self attention也叫做intra-attention在没有任何额外信息的情况下，我们仍然可以通过允许句子使用–self attention机制来处理自己，从句子中提取关注信息。
它在很多任务上都有十分出色的表现，比如阅读理解 (Cheng et al., 2016) 、文本继承 (textual entailment/Parikh et al., 2016) 、自动文本摘要 (Paulus et al., 2017) 。
其已经被证明是非常有效的，而且所以我们下面重点关注一下。

论文：
Cheng, J., Dong, L., & Lapata, M. (2016). Long Short-Term Memory-Networks for Machine Reading
Parikh, A. P., Täckström, O., Das, D., & Uszkoreit, J. (2016). A Decomposable Attention Model for Natural Language Inference. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing.
Paulus, R., Xiong, C., & Socher, R. (2017). A Deep Reinforced Model for Abstractive Summarization. In arXiv preprint arXiv:1705.04304,.

Self attention计算方式
以当前的隐藏状态去计算和前面的隐藏状态的得分，作为当前隐藏单元的attention score，例如：

2. 以当前状态本身去计算得分作为当前单元attention score，这种方式更常见，也更简单，例如：

其中va和Wa是参数，通过训练得到，Wa维数dxd，hi维数dx1，va维数dx1（第一个公式）
前面的w是dx1的向量，hi是dx1，b是（1，）（第二个公式），注意这里其实是简化过后的表示：原始论文 https://arxiv.org/pdf/1512.08756.pdf

上面的式子中，使用的va向量是一个通用的向量，每个隐藏状态并没有区分，如果我们对不同状态计算的时候学习不同的向量va,，也就是一个Va矩阵，得到的就是一个attention矩阵。
论文：
https://arxiv.org/pdf/1703.03130.pdf
上面的式子中，H是nx2u(双向lstm的结果拼接，每个单向LSTM的hidden units是u），Wa是dx2u，Va是rxd，得到的attention 矩阵 A是rxn。
C = rx2u，按论文意思来看就是把一句话编码成了一个rx2u的矩阵（sentence embedding）
在实际操作的过程中，我们也可能在学习时候给A一个F2范式约束项来避免过拟合。

key-value attention

这种attention就是比较新的了，简单来说Key-value attention 是将hi拆分成了两部分，然后使用的时候只针对key部分计算attention权重，然后加权求和的时候只使用value部分进行加权求和。公式如下，attention权重计算如下：

论文：Daniluk, M., Rockt, T., Welbl, J., & Riedel, S. (2017). Frustratingly Short Attention Spans in Neural Language Modeling. In ICLR 2017.

其中呢，这个L是attention窗口长度
WY=kxk,ki=kx1，Wh = kxk，1^T是一个1xL的向量
w 是一个kx1的向量
Wr = kxk，
Wx = kxk
最后得到kx1的ht*与ht一起参与下一步的运算

multi-head attention

最后简单讲一下google的attention is all you need 里面的attention，这一段基本上是摘抄的苏剑林的科学空间的博文了。
Google 在 attention is all you need 中发明了一种叫transformer的网络结构，其中用到了multi-head attention。Transformer在下一节课里面会讲，所以我们就简单介绍一下他里面用到的attention。


首先，google先定义了一下attention的计算，也是定义出key，value，query三个元素（在seq2seq里面，query是st，key和value都是hi）在self 里面，query 是当前要计算的hi，k和v仍然一样，是其他单元的hidden state。在key value attention里面key和value则是分开了的。
然后除以了一下根号dk，为了让内积不至于太大（太大的话softmax后就非0即1了，不够“soft”了）
这里我们不妨假设，Q是nxdk，K是mxdk，v是mxdv，忽略归一化和softmax的话就是三个矩阵相乘，得到的是n*dv的矩阵。我们可以说，通过这么一个attention层，就将一个nxdk的序列Q，提取信息编码成nxdv的序列了。
Wi用来先在算attention对三个矩阵做不同的矩阵变换映射一下，变成nxdk’，mxdk’，mxdv’维度。
最后做并联，有点类似于inception 里面多个卷积核的feature map并联的感觉。

5. 代码示例

以在网上找到的一段keras实现的self attention的代码，其实现原理应该是这篇论文，结构如上图所示，是利用一个mlp来计算h（t）的attention得分，然后这个代码里面进行了进一步简化，让把mlp简化得只有一个共享的w向量，但是每个ht有一个不同的偏置。

#coding=utf-8
'''
Single model may achieve LB scores at around 0.043
Don't need to be an expert of feature engineering
All you need is a GPU!!!!!!!

The code is tested on Keras 2.0.0 using Theano backend, and Python 3.5

referrence Code:https://www.kaggle.com/lystdo/lstm-with-word2vec-embeddings
'''

########################################
## import packages
########################################
import os
import re
import csv
import codecs
import numpy as np
import pandas as pd

########################################
## set directories and parameters
########################################



from keras import backend as K
from keras.engine.topology import Layer
# from keras import initializations
from keras import initializers, regularizers, constraints

np.random.seed(2018)

class Attention(Layer):
    def __init__(self,
                 W_regularizer=None, b_regularizer=None,
                 W_constraint=None, b_constraint=None,
                 bias=True, **kwargs):
        """
        Keras Layer that implements an Attention mechanism for temporal data.
        Supports Masking.
        Follows the work of Raffel et al. [https://arxiv.org/abs/1512.08756]
        # Input shape
            3D tensor with shape: `(samples, steps, features)`.
        # Output shape
            2D tensor with shape: `(samples, features)`.
        :param kwargs:

        """
        self.supports_masking = True
        # self.init = initializations.get('glorot_uniform')
        self.init = initializers.get('glorot_uniform')

        self.W_regularizer = regularizers.get(W_regularizer)
        self.b_regularizer = regularizers.get(b_regularizer)

        self.W_constraint = constraints.get(W_constraint)
        self.b_constraint = constraints.get(b_constraint)

        self.bias = bias

        self.features_dim = 0
        super(Attention, self).__init__(**kwargs)

    def build(self, input_shape):
        self.step_dim = input_shape[1]
        assert len(input_shape) == 3 # batch ,timestep , num_features
        print(input_shape)
        self.W = self.add_weight((input_shape[-1],), #num_features
                                 initializer=self.init,
                                 name='{}_W'.format(self.name),
                                 regularizer=self.W_regularizer,
                                 constraint=self.W_constraint)
        self.features_dim = input_shape[-1]

        if self.bias:
            self.b = self.add_weight((input_shape[1],),#timesteps
                                     initializer='zero',
                                     name='{}_b'.format(self.name),
                                     regularizer=self.b_regularizer,
                                     constraint=self.b_constraint)
        else:
            self.b = None

        self.built = True

    def compute_mask(self, input, input_mask=None):
        # do not pass the mask to the next layers
        return None

    def call(self, x, mask=None):
        features_dim = self.features_dim
        step_dim = self.step_dim
        print(K.reshape(x, (-1, features_dim)))# n, d
        print(K.reshape(self.W, (features_dim, 1)))# w= dx1
        print(K.dot(K.reshape(x, (-1, features_dim)), K.reshape(self.W, (features_dim, 1))))#nx1

        eij = K.reshape(K.dot(K.reshape(x, (-1, features_dim)), K.reshape(self.W, (features_dim, 1))), (-1, step_dim))#batch,step
        print(eij)
        if self.bias:
            eij += self.b

        eij = K.tanh(eij)

        a = K.exp(eij)

        # apply mask after the exp. will be re-normalized next
        if mask is not None:
            # Cast the mask to floatX to avoid float64 upcasting in theano
            a *= K.cast(mask, K.floatx())

        a /= K.cast(K.sum(a, axis=1, keepdims=True) + K.epsilon(), K.floatx())
        print(a)
        a = K.expand_dims(a)
        print("expand_dims:")
        print(a)
        print("x:")
        print(x)
        weighted_input = x * a
        print(weighted_input.shape)
        return K.sum(weighted_input, axis=1)

    def compute_output_shape(self, input_shape):
        # return input_shape[0], input_shape[-1]
        return input_shape[0], self.features_dim

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

6. 总结

总的来说，attention的机制就是一个加权求和的机制，只要我们使用了加权求和，不管你是怎么花式加权，花式求和，只要你是根据了已有信息计算的隐藏状态的加权和求和，那么就是使用了attention，而所谓的self attention就是仅仅在句子内部做加权求和（区别与seq2seq里面的decoder对encoder的隐藏状态做的加权求和）。
self attention我个人认为作用范围更大一点，而key-value其实是对attention进行了一个更广泛的定义罢了，我们前面的attention都可以套上key-value attention，比如很多时候我们是把k和v都当成一样的算来，做self的时候还可能是quey=key=value。
最后，我把分享的ppt也放到文库了，免积分下载（设置未成功，默认要1积分…），有需要的人自取吧。