Attention 和self-attention
一、Attention
1.基本信息
最先出自于Bengio团队一篇论文：NEURAL MACHINE TRANSLATION BY JOINTLY LEARNING TO ALIGN AND TRANSLATE ，论文在2015年发表在ICLR。
encoder-decoder模型通常的做法是将一个输入的句子编码成一个固定大小的state，然后将这样的一个state输入到decoder中的每一个时刻，这种做法对处理长句子会很不利，尤其是随着句子长度的增加，效果急速下滑。
motivation：是针对encoder-decoder长句子翻译效果较差的问题。
解决原理：仿造人脑结构，对一张图片或是一个句子，有选择性的关注重点部分。
论文解决思路：在生成当前词的时候，只要把上一个state与所有的input word融合，而后做一个权重计算。通过这种方式生成的词就会有针对性，在句子长度较长时效果尤其明显。
2.核心算法
假设当前的输出的词位置为i，j是输入的词位置，$s_{i-1}$输出位置的上一个隐藏状态，$h_{j}$是输入的隐藏状态，$h_{j}$对应的权重，就是将$s_{i-1}$和$h_{j}$融合都一块，计算在所有的输入隐藏状态的比重。具体可参照如下公式。
二、Self-attention
1.基本信息
出自于Google团队的论文：Attention Is All You Need ，2017年发表在NIPS。
1)motivation：RNN本身的结构，阻碍了并行化；同时RNN对长距离依赖问题，效果会很差。
2)解决思路：通过不同词向量之间矩阵相乘，得到一个词与词之间的相似度，进而无距离限制。
3)优势：
- attention的计算可以并行化，tensor之间的矩阵乘法，不存在时序；
- 同一个句子中每个词之间均可以做相似度计算，无视距离；
- 多头机制，关注每一部分维度的表示，比如第一部分是词性，第二部分是语义等等；
- 可以增加到非常深的深度，堆叠很多块，充分发掘DNN模型的特性。
4)整体结构：
2.self-attention
$Attention(Q;K;V) = softmax(\frac{QK^T}{\sqrt{d_k}})V$
对于$ softmax(\frac{QK^T}{\sqrt{d_k}})$，是得到一个相似度，而$ softmax(\frac{QK^T}{\sqrt{d_k}})V$是将相似度溶于embedding中。
每个位置的词都可以无视方向和距离，有机会直接和句子中的每个词encoding。比如下图这个句子，每个单词和同句其他单词之间都有一条边，边的颜色越深表明相关性越强，而一般意义模糊的词语所连的边都比较深。比如：law，application，missing，opinion。
3.multi-head attention
1）multi-head的实现方式
将一个词的词向量切分成h个块，求attention相似度时是一个句子中每个词之间第i个块的相似度。原论文是有h次线性映射，后来的bert是切分为h个部分。
原论文multi-head操作方式：引自原论文
| Instead of performing a single attention function with dmodel-dimensional keys, values and queries,we found it beneficial to linearly project the queries, keys and values h times with different, learned linear projections to dk, dk and dv dimensions, respectively.
|
2）bert实现代码：先线性映射，而后reshape，之后再矩阵乘法
# Scalar dimensions referenced here: # B = batch size (number of sequences) # F = `from_tensor` sequence length # T = `to_tensor` sequence length # N = `num_attention_heads` # H = `size_per_head` from_tensor_2d = reshape_to_matrix(from_tensor) to_tensor_2d = reshape_to_matrix(to_tensor) # `query_layer` = [B*F, N*H] query_layer = tf.layers.dense( from_tensor_2d, num_attention_heads * size_per_head, activation=query_act, name="query", kernel_initializer=create_initializer(initializer_range)) # `key_layer` = [B*T, N*H] key_layer = tf.layers.dense( to_tensor_2d, num_attention_heads * size_per_head, activation=key_act, name="key", kernel_initializer=create_initializer(initializer_range)) # `value_layer` = [B*T, N*H] value_layer = tf.layers.dense( to_tensor_2d, num_attention_heads * size_per_head, activation=value_act, name="value", kernel_initializer=create_initializer(initializer_range)) # `query_layer` = [B, N, F, H] query_layer = transpose_for_scores(query_layer, batch_size, num_attention_heads, from_seq_length, size_per_head) # `key_layer` = [B, N, T, H] key_layer = transpose_for_scores(key_layer, batch_size, num_attention_heads, to_seq_length, size_per_head) # Take the dot product between "query" and "key" to get the raw # attention scores. # `attention_scores` = [B, N, F, T] attention_scores = tf.matmul(query_layer, key_layer, transpose_b=True) attention_scores = tf.multiply(attention_scores, 1.0 / math.sqrt(float(size_per_head)))
3）multi-head的意义
由于单词映射在高维空间作为向量形式，每一维空间都可以学到不同的特征，相邻空间所学结果更相似，相较于全体空间放到一起对应更加合理。比如对于vector-size=512的词向量，取h=8，每64个空间做一个attention，学到结果更细化。
4.分类和生成任务
1）分类任务
分类任务只是用到了encoder，不需要decoder部分。encoder输出的tenser可以直接reshape，加一个全连接即可分类；也可以对每一个词求权重和，而后再分类。
2）生成式任务
生成式任务需要decoder部分，而decoder需要把当前位置i之后的词mask掉，就是设置为负无穷，因为生成当前词的时候，是无法看到之后的词。整个encoder完成之后，才开始decoder部分，其中decoder的K和Q是来源于encoder，V是decoder的上一个状态。
对应的multi_attention的代码如下， causality指示是否mask。
def multihead_attention(queries, keys, num_units=None, num_heads=8, dropout_rate=0, is_training=True, causality=False, scope="multihead_attention", reuse=None): '''Applies multihead attention. Args: queries: A 3d tensor with shape of [N, T_q, C_q]. keys: A 3d tensor with shape of [N, T_k, C_k]. num_units: A scalar. Attention size. dropout_rate: A floating point number. is_training: Boolean. Controller of mechanism for dropout. causality: Boolean. If true, units that reference the future are masked. num_heads: An int. Number of heads. scope: Optional scope for `variable_scope`. reuse: Boolean, whether to reuse the weights of a previous layer by the same name. Returns A 3d tensor with shape of (N, T_q, C) ''' with tf.variable_scope(scope, reuse=reuse): # Set the fall back option for num_units if num_units is None: num_units = queries.get_shape().as_list[-1] # Linear projections Q = tf.layers.dense(queries, num_units, activation=tf.nn.relu) # (N, T_q, C) K = tf.layers.dense(keys, num_units, activation=tf.nn.relu) # (N, T_k, C) V = tf.layers.dense(keys, num_units, activation=tf.nn.relu) # (N, T_k, C) # Split and concat Q_ = tf.concat(tf.split(Q, num_heads, axis=2), axis=0) # (h*N, T_q, C/h) K_ = tf.concat(tf.split(K, num_heads, axis=2), axis=0) # (h*N, T_k, C/h) V_ = tf.concat(tf.split(V, num_heads, axis=2), axis=0) # (h*N, T_k, C/h) # Multiplication outputs = tf.matmul(Q_, tf.transpose(K_, [0, 2, 1])) # (h*N, T_q, T_k) # Scale outputs = outputs / (K_.get_shape().as_list()[-1] ** 0.5) # Key Masking key_masks = tf.sign(tf.abs(tf.reduce_sum(keys, axis=-1))) # (N, T_k) key_masks = tf.tile(key_masks, [num_heads, 1]) # (h*N, T_k) key_masks = tf.tile(tf.expand_dims(key_masks, 1), [1, tf.shape(queries)[1], 1]) # (h*N, T_q, T_k) paddings = tf.ones_like(outputs) * (-2 ** 32 + 1) outputs = tf.where(tf.equal(key_masks, 0), paddings, outputs) # (h*N, T_q, T_k) # Causality = Future blinding if causality: diag_vals = tf.ones_like(outputs[0, :, :]) # (T_q, T_k) #生成一个下三角矩阵，就是对角线全为0 tril = tf.contrib.linalg.LinearOperatorTriL(diag_vals).to_dense() # (T_q, T_k) masks = tf.tile(tf.expand_dims(tril, 0), [tf.shape(outputs)[0], 1, 1]) # (h*N, T_q, T_k) paddings = tf.ones_like(masks) * (-2 ** 32 + 1) #将outputs上三角的值，都改成负无穷， outputs = tf.where(tf.equal(masks, 0), paddings, outputs) # (h*N, T_q, T_k) #outputs的上三角全为0 outputs = tf.nn.softmax(outputs) # (h*N, T_q, T_k) # Dropouts outputs = tf.layers.dropout(outputs, rate=dropout_rate, training=tf.convert_to_tensor(is_training)) # Weighted sum outputs = tf.matmul(outputs, V_) # ( h*N, T_q, C/h) # Restore shape outputs = tf.concat(tf.split(outputs, num_heads, axis=0), axis=2) # (N, T_q, C) # Residual connection outputs += queries # Normalize outputs = normalize(outputs) # (N, T_q, C) return outputs
