论文分享-- >Attention is all you need

本次分享的论文是鼎鼎有名的$attentionisallyouneed$，论文链接attention is all you need，其参考的$tensorflow$ 实现代码tensorflow代码实现。

自己水平有限，在读这篇论文和实现代码时，感觉比较吃力，花了两三天才搞懂了一些，在此总结下。

废话不多说，直接带着代码看论文介绍的网络结构。

下面总结是以论文实验 机器翻译来说的。

我们分部分来看：

建议可以先看看 台大教授李宏毅关于transformer的课程：https://www.bilibili.com/video/av56239558?from=search&seid=17256210640645614178

Stage1 Encode Input

和普遍的做法一样，对文本输入做$wordembedding$ 操作，

embedding_encoder = tf.get_variable("embedding_encoder", [Config.data.source_vocab_size, Config.model.model_dim], self.dtype)(注意这里的model_dim)

embedding_inputs = embedding_encoder

上面其实就是做个输入文本的$embedding$矩阵而已。

模型里已经剔除了$RNN$，$CNN$，如何体现输入文本的先后关系呢？而这种序列的先后关系对模型有着至关重要的作用，于是论文中提出了$PositionEncoding$ 骚操作～，论文是这样做的：

$$PE(pos,2i)=sin(pos/10000^{2i/d_{model}})（偶数位置处）$$
$$PE(pos,2i+1)=cos(pos/10000^{2i/d_{model}})（奇数位置处）$$

这里的$d_{model}$指的是上面$wordembedding$ 的维度，$pos$就是当前的词在整个句子中的位置，例如第一个词还是第二个词等，$i$ 就是遍历$d_{model}$时的值，在代码中是这样做的：

def positional_encoding(dim, sentence_length, dtype=tf.float32):

    encoded_vec = np.array([pos/np.power(10000, 2*i/dim) for pos in range(sentence_length) for i in range(dim)])#对每个位置处都产生一个维度为dim的向量。
    encoded_vec[::2] = np.sin(encoded_vec[::2])#偶数位置处
    encoded_vec[1::2] = np.cos(encoded_vec[1::2])#奇数位置处

    return tf.convert_to_tensor(encoded_vec.reshape([sentence_length, dim]), dtype=dtype)

#Positional Encoding
with tf.variable_scope("positional-encoding"):
                positional_encoded = positional_encoding(Config.model.model_dim, Config.data.max_seq_length,　dtype=self.dtype)

上面生成的$positional\_encoded$其实就是位置信息的$embedding$ 矩阵。论文中提到这样做的原因，就是希望模型能很容易的学到相对先后的位置信息。

# Add
position_inputs = tf.tile(tf.range(0,　Config.data.max_seq_length), [self.batch_size])#将range(0, max_seq_length)列表复制batch_size次，生成shape为[batch_size, max_seq_length]的张量。

position_inputs = tf.reshape(position_inputs，[self.batch_size, Config.data.max_seq_length]) # batch_size x [0, 1, 2, ..., n]#未经过embedding的位置输入信息。

好了$输入文本和位置信息的embedding$矩阵都做好了，该$look\_up$ 了。

encoded_inputs = tf.add(tf.nn.embedding_lookup(embedding_inputs, inputs),  tf.nn.embedding_lookup(positional_encoded, position_inputs))

这与输入文本信息就结合的其位置信息了，作为$encoder$的整体输入，这部分对应的上面那张图的**$stage1$**部分，这部分的操作就是如下：

$$positionalencodingsdded\oplus embeddedinputs$$

$decode\_inputembedding$同理，就不再赘述了。

Stage2 Multi Head Attention

multi head attention 绝对是transform里面的 一个重点和优点，正是有了这个机制，transform才能有这么好的效果。

当时论文读到这里有点懵逼，什么叫$multihead$？再仔细看看论文吧？

由上图我们可以看出$multiheadattention$ 有三个相同的输入，不妨分别记为$Q、K、V$，其实就是上面的$EncodeInput$其$shape$均为$[batch\_size,max\_seq\_length,dim]$。论文中提到对三个输入做$num\_head$次不同的线性映射，即为：

def _linear_projection(self, q, k, v):
    q = tf.layers.dense(q, self.linear_key_dim, use_bias=False)
    k = tf.layers.dense(k, self.linear_key_dim, use_bias=False)
    v = tf.layers.dense(v, self.linear_value_dim, use_bias=False)
	return q, k, v

上述代码就是做线性映射，其中$linear\_key\_dim、linear\_value\_dim$就是映射的$units$个数。这里面相当于把$num\_head$次的线性映射一起做了，后面需要把每一个$head$映射结果分割开，故需要保证$linear\_key\_dim$ 和 $linear\_value\_dim$ 能整除$num\_head$。 经过线性映射后生成的$q、k、v$ 的$shape$分别为$[batch\_size,max\_seq\_length,linear\_key\_dim],[batch\_size,max\_seq\_length,linear\_key\_dim],[batch\_size,max\_seq\_length,linear\_value\_dim]$

然后按$num\_heads$分割开来得：（这里分割开，相当于初始个num_head 不同的权重，下面将会做num_head 次不同的attention操作。理解这非常重要）

def _split_heads(self, q, k, v): 
    def split_last_dimension_then_transpose(tensor, num_heads, dim):
    ┆   t_shape = tensor.get_shape().as_list()
    ┆   tensor = tf.reshape(tensor, [-1] + t_shape[1:-1] + [num_heads, dim // num_heads])
    ┆   return tf.transpose(tensor, [0, 2, 1, 3]) # [batch_size, num_heads, max_seq_len, dim]

    qs = split_last_dimension_then_transpose(q, self.num_heads, self.linear_key_dim)
    ks = split_last_dimension_then_transpose(k, self.num_heads, self.linear_key_dim)
    vs = split_last_dimension_then_transpose(v, self.num_heads, self.linear_value_dim)

    return qs, ks, vs

论文提到，这时生成的$qs、ks、vs$可以并行的放入到$attention\_function$ 中，那么这个$attention\_function$ 是个什么样的结构呢？

上图所示的结构在论文中被称为$ScaledDot\_ProductAttention$，其$attention$值的计算公式如下：
$$Attention(Q,K,V)=softmax\left(\frac{Q{K}^T}{\sqrt{d_k}}\right)V$$

由上面可知，其公式中的$Q、K、Ｖ$ 分别对应的是$qs、ks、vs$，其实都是$EncoderInput$，只是做了不同的线性映射，其中$qs、ks$ 的维度相同。我们可以这样理解$Q{K}^T$操作，假设$Q$为$shape$为$[max\_seq\_length,dim]$的矩阵，$V$为$shape$相同，那么经过$Q{K}^T$操作以后，变成了$shape$为$[max\_seq\_length,max\_seq\_length]$的矩阵，怎样理解这个生成的矩阵呢？其实就是做了个$self\_attention$操作，即是当前句子中每个词和其他词做个乘积形成的矩阵，以得到每个词的权重，以便学习当前应该$foucs$到哪个词。那么为什么要除以$\sqrt{d_k}$呢？论文中说到，当两个矩阵做$dotproduct$时，可能会变得很大（试想一下，两个矩阵相互独立，且均值为０，方差为１，那么经过矩阵相乘以后，均值还为０，方差变成$d_k$），经过$softmax$后，梯度可能会变得很小，为了抵消这种效果，再除以$\sqrt{d_k}$。其代码如下：

def _scaled_dot_product(self, qs, ks, vs):
    key_dim_per_head = self.linear_key_dim // self.num_heads

    o1 = tf.matmul(qs, ks, transpose_b=True)
    o2 = o1 / (key_dim_per_head**0.5)

    if self.masked:
    ┆   diag_vals = tf.ones_like(o2[0, 0, :, :]) # (batch_size, num_heads, query_dim, key_dim)
    ┆   tril = tf.contrib.linalg.LinearOperatorTriL(diag_vals).to_dense() # (q_dim, k_dim)
    ┆   masks = tf.tile(tf.reshape(tril, [1, 1] + tril.get_shape().as_list()),
    ┆   ┆   ┆   ┆   ┆   [tf.shape(o2)[0], tf.shape(o2)[1], 1, 1])
    ┆   paddings = tf.ones_like(masks) * -1e9
    ┆   o2 = tf.where(tf.equal(masks, 0), paddings, o2)

    o3 = tf.nn.softmax(o2)
    return o3

好了，过了$self\_attention$后：

由上图可知，再过$concat$操作：（不同的head关注的点可能不一样，这里concat操作，相当于把num_head次不同的attention结果集成在一起，理解这非常重要）

def _concat_heads(self, outputs):

    def transpose_then_concat_last_two_dimenstion(tensor):
    ┆   tensor = tf.transpose(tensor, [0, 2, 1, 3]) # [batch_size, max_seq_len, num_heads, dim]
    ┆   t_shape = tensor.get_shape().as_list()
    ┆   num_heads, dim = t_shape[-2:]
    ┆   return tf.reshape(tensor, [-1] + t_shape[1:-2] + [num_heads * dim])

    return transpose_then_concat_last_two_dimenstion(outputs)

论文中提到，这样做后，再过一层线性映射。

output = tf.layers.dense(output, self.model_dim)

故整个$MultiHeadAttention$ 操作如下：

def multi_head(self, q, k, v):
    q, k, v = self._linear_projection(q, k, v)
    qs, ks, vs = self._split_heads(q, k, v)
    outputs = self._scaled_dot_product(qs, ks, vs)
    output = self._concat_heads(outputs)
    output = tf.layers.dense(output, self.model_dim)
    return tf.nn.dropout(output, 1.0 - self.dropout)

然后在做个$resNet$和$layerNormalization$：

def _add_and_norm(self, x, sub_layer_x, num=0):
    with tf.variable_scope(f"add-and-norm-{num}"):
    ┆   return tf.contrib.layers.layer_norm(tf.add(x, sub_layer_x)) # with Residual connection

这里面的$sub\_layer\_x$ 就是上面$mutlihead$的输出，$x$就是$encoder\_input$。
矩阵并行化计算过程：

上面就是$Stage2$ 的整个过程。

Stage3 Feed Forward

这一步就比较简单了，就是做两层的$fully\_connection$ 而已，只不过内层的$fully\_connection$ 会过$relu$ 激活。

$$FFN(x)=max(0,x{W}_1+b_1)W_2+b_2$$

别问我为啥$max$

同理再过$reNet、normalization$。

$Decode$部分和上面差不多，只不过在$DecodeInput$ 的$Stage1$部分，做$selfattention$时，我们不能使当前词的后面的词对当前词产生影响，因为在当前我们实际是不知道后面应该有哪些词的，只不过在$train$的时候可以批量的训练，但是在$decode$的时候是不知道的。那么该怎么消除后面词对当前词的影响呢？

在$selfattention$时，会得到$attention$矩阵，我们只需要保留该矩阵的下三角部分即可，然后再做$softmax$，既可消除后面词对当前词的影响。

def _scaled_dot_product(self, qs, ks, vs):
    key_dim_per_head = self.linear_key_dim // self.num_heads

    o1 = tf.matmul(qs, ks, transpose_b=True)
    o2 = o1 / (key_dim_per_head**0.5)

    if self.masked:
    ┆   diag_vals = tf.ones_like(o2[0, 0, :, :]) # (batch_size, num_heads, query_dim, key_dim)
    ┆   tril = tf.contrib.linalg.LinearOperatorTriL(diag_vals).to_dense() # (q_dim, k_dim)
    ┆   masks = tf.tile(tf.reshape(tril, [1, 1] + tril.get_shape().as_list()),
    ┆   ┆   ┆   ┆   ┆   [tf.shape(o2)[0], tf.shape(o2)[1], 1, 1])
    ┆   paddings = tf.ones_like(masks) * -1e9
    ┆   o2 = tf.where(tf.equal(masks, 0), paddings, o2)

    o3 = tf.nn.softmax(o2)
    return o3

剩余部分的$Stage4、Stage5$与上面类似，就不再赘述了。

整个论文的过程可以用如下动画解释：

个人看法

1. 该论文摈弃了$RNN、CNN$ 等作为基本的模型，而是单纯的采用$Attention$结构，使得计算并行性大大提高。
2. 没想到$attention$也可以单独的作为神经网络的一层，甚至可以看作对$input$的$repesentation$。
3. Transformer的多头注意力机制能从不同角度对每个对象的重要性进行评价，从而能更好的学习输入对象中存在的各种关系并对其进行表征。
   
   不同的head, attention的注意力不一样