Attention Is All You Need

最新推荐文章于 2022-06-13 09:03:01 发布

原创最新推荐文章于 2022-06-13 09:03:01 发布 · 204 阅读

0 ·

CC 4.0 BY-SA版权

自然语言处理专栏收录该内容

15 篇文章

订阅专栏

本文深入解析Transformer模型，探讨其核心机制——自注意力（Self-Attention），如何通过并行计算提高效率，解决序列模型的长距离依赖问题。文章详细介绍了Scaled Dot-Product Attention的计算流程，包括Query、Key和Value的生成，以及Mask的应用，确保模型不会看到未来的信息。同时，讲解了Multi-Head Attention和Position-wise Feed-Forward Networks的作用，以及Positional Encoding如何帮助模型理解序列的顺序。

Motivation:

靠attention机制，不使用rnn和cnn，并行度高
通过attention，抓长距离依赖关系比rnn强

Scaled Dot-Product Attention

$d_{k}=d_{model}/h$

其中，

其中因子起到调节作用，使得内积不至于太大（太大的话softmax后就非0即1了，不够“soft”了）。

1.给定输入数据，转换成对应的内容 embedding。

2.得到Q，K，V

3.计算Query和Key的相似度

4.增加mask

query和key有些部分是填充的，这些需要用mask屏蔽，一个简单的方法就是赋予一个很小很小的值或者直接变为0值。
对于decoder的来说，我们是不能看到未来的信息的，所以对于decoder的输入，我们只能计算它和它之前输入的信息的相似度。

对encoder的 Key 进行mask，mask成负无穷（mask成负无穷的位置经过softmax后数值为0）

对decoder的Key进行mask， mask成0，

5.对Query进行mask

6.和Value进行相乘

完整的Scaled Dot-Product Attention的代码如下：

def scaled_dotproduct_attention(queries,keys,num_units=None,
                        num_heads = 0,
                        dropout_rate = 0,
                        is_training = True,
                        causality = False,
                        scope = "mulithead_attention",
                        reuse = None):
    with tf.variable_scope(scope,reuse=reuse):
        if num_units is None:
            num_units = queries.get_shape().as_list[-1]

        # Linear projection
        Q = tf.layers.dense(queries,num_units,activation=tf.nn.relu) #
        K = tf.layers.dense(keys,num_units,activation=tf.nn.relu) #
        V = tf.layers.dense(keys,num_units,activation=tf.nn.relu) #

        outputs = tf.matmul(Q,tf.transpose(K,[0,2,1]))
        outputs = outputs / (K.get_shape().as_list()[-1] ** 0.5)

        # 这里是对填充的部分进行一个mask，这些位置的attention score变为极小，我们的embedding操作中是有一个padding操作的，
        # 填充的部分其embedding都是0，加起来也是0，我们就会填充一个很小的数。
        key_masks = tf.sign(tf.abs(tf.reduce_sum(keys,axis=-1)))
        key_masks = tf.tile(tf.expand_dims(key_masks,1),[1,tf.shape(queries)[1],1])

        paddings = tf.ones_like(outputs) * (-2 ** 32 + 1)
        outputs = tf.where(tf.equal(key_masks,0),paddings,outputs)

        # 这里其实就是进行一个mask操作，不给模型看到未来的信息。
        if causality:
            diag_vals = tf.ones_like(outputs[0,:,:])
            tril = tf.contrib.linalg.LinearOperatorTriL(diag_vals).to_dense()
            masks = tf.tile(tf.expand_dims(tril,0),[tf.shape(outputs)[0],1,1])

            paddings = tf.ones_like(masks) * (-2 ** 32 + 1)
            outputs = tf.where(tf.equal(masks,0),paddings,outputs)

        outputs = tf.nn.softmax(outputs)
        # Query Mask
        query_masks = tf.sign(tf.abs(tf.reduce_sum(queries,axis=-1)))
        query_masks = tf.tile(tf.expand_dims(query_masks,-1),[1,1,tf.shape(keys)[1]])
        outputs *= query_masks
        # Dropout
        outputs = tf.layers.dropout(outputs,rate = dropout_rate,training = tf.convert_to_tensor(is_training))
        # Weighted sum
        outputs = tf.matmul(outputs,V)
        # Residual connection
        outputs += queries
        # Normalize
        outputs = normalize(outputs)

    return outputs