文本摘要項目(五)——Transformer:Attention Is All You Need

我們前面幾節的模型都是基於seq2seq模型的，seq2seq模型固然很好，它有很多優點，比如可以學習到序列的順序特徵、通過LSTM或GRU單元，可以學習到長期依賴的特徵等。但是在實際應用中發現，seq2seq中的RNN機制，存在以下兩個問題：因此，Transformer應運而生，它拋棄了傳統的CNN和RNN結構，整個網絡結構完全是由self-attention和Feed Forward Neural Network組成。由於不再使用RNN，所以Transformer具備了並行計算的能力，符合現有的GPU框架；其次，它使用了self-attention機制，可以計算當前詞與其他詞的attention權重，因此可以學習到具有長期依賴的文本間信息。下面，我們就具體來看看Transformer的模型結構：我們以機器翻譯為例，剖析Transformer結構，在機器翻譯中，Transformer就是一個黑盒機制：

圖1: Transformer總體結構圖

而在Transformer內部，其整體結構還是一個Encoder-Decoder，我們可以將圖1中的Transformer部分放大如下圖2：

圖2: Transformer內部結構圖

我們繼續將Encoders部分和Decoders部分進行放大，如圖3所示，編碼器與解碼器都是由6個block組成。而且與seq2seq模型類似，編碼器的輸出會作為解碼器的輸入。

圖3: Encoder及Decoder部分拆分

我們繼續放大Encoder的block部分，如圖4，包含一個「self-attention」模塊和一個「Feed Forward Neural Network」模塊。

圖4: Encoder Block內部結構

在Encoder中，輸入的語料會先被表徵成詞嵌入，然後經過一個「self-attention」模塊，得到向量Z，經過Add&Normalize後，向量Z輸入到「Feed Forward Neural Network」模塊，輸出向量R，再經過一個Add&Normalize操作，最後將向量R傳遞到下一個block。

圖5: block2block

Self-Attention接下來，我們繼續解析Encoder的block部分，其中最核心的，就是Self-Attention。在前面的RNN模型中，我們已經介紹了一個Attention機制，RNN中的Attention機制是通過t-1時刻的hidden state與Encoder的output加權求和後，對結果進行一個正切加softmax運算，得到的權重，其主要計算的是Encoder的各個時刻對Decoder的當前時刻的注意力權重。而Self-Attention則與之不同，它計算的是Encoder中，不同詞之間的權重關係。

圖6: Self-Attention的可視化表示

那Self-Attention具體是怎麼實現的呢？首先，對於輸入語料中的一個單詞而言，它通過一個embedding層，得到一個512維的向量X，然後，用X乘以形狀為(512,64)的三個權重矩陣、、，得到三個64維的向量Q(Query向量)、K(Key向量)、V(Value向量)。

然後，每個單詞的q向量，依次乘以每個單詞的k向量，得到score，為了將數據的方差拉回到原來的水平，需要對score值除以，這裡是Q、K、V的維度，即為64。接下來再對score施以softmax激活函數，得到的值乘以對應的向量V，最後將每個向量v相加得到最終的輸出結果z。

這裡的向量Q，其實就是查詢向量的意思，它詢問每個單詞對當前單詞的影響權重，得到最終的輸出向量。當然在實際計算過程中，是以矩陣的方式進行計算：

圖9: Self-Attention矩陣計算

此外，自注意力還有一個多頭的概念，多頭就意味著多組Q、K、V矩陣，在原論文中，作者定義了8個頭，即8組Q、K、V矩陣，這樣就會得到8組Z向量。最後將8組Z向量進行一個拼接後再進行一個矩陣變換，重新將向量維度變為512維。這樣做的好處是可以從多個角度學習語料的特徵，這樣可以學習到語料的更多特徵。

圖10: Multi-Self-Attention
Input Embedding由於Transformer拋棄了RNN結構，為了使它能夠學習到每個詞的位置信息，所以Transformer的Input Embedding是由Token Embedding和Positional Embedding相加得到，其中，Token Embedding就是一個512維的詞嵌入，而Positional Embedding則是由正餘弦函數得到。

圖11: Transformer Embedding
Add&Normalize下面我們進入Encoder Block的另一部分，Add&Normalize部分，我們先說一下Normalize，Transformer中的Normalize就是一個歸一化處理，不過這裡的歸一化是在層上的歸一化（Layer Normalization），而CV中的歸一化一般是Batch Normalization。為什麼要在層上做歸一化處理呢，這是因為不同的輸入長度是不一樣的，長度較短的輸入會用Padding填充，為了不把Padding計入分布，所以使用Layer Normalization。而Add屬於殘差結構，為了防止梯度消失。Feed ForwordFeed Forward層比較簡單，假設傳入的數據是y，那麼Feed Forward的操作公式如下：

由於Self Attention部分使用的基本上都是相乘和相加運算，所以為了增加整個模型的非線性能力，就加入了Feed Forward層。
介紹完Encoder部分，我們再來看看Decoder部分，其結構與Encoder部分大體相似，使用正確的生成語料作為輸入，有Self Attention和Feed Forward。不過Decoder部分多出了一塊——Encoder-Decoder Attention，與Self Attention不同的是，Encoder-Decoder Attention中的Q向量來自於Decoder部分的輸入，但是K向量和V向量則是來自於Encoder的output部分，也就是說，Encoder-Decoder Attention加入了Encoder部分的注意力權重。此外，在Decoder部分的最後，加入了一個全連接層和Softmax層，為的是將向量映射到Vocabulary中，輸出正確的詞。在摘要生成中，可以將最後的輸出和真實的標籤做一個交叉熵，然後進行訓練就可以了。

Transformer & PGN接下來，我們把Transformer與我們之前講到的PGN模型進行融合(出自論文 "Transformers and Pointer-Generator Networks for Abstractive Summarization")。我們先回顧一下之前p_gen係數的計算公式：

在Transformer中，dec_input就是Decoder的輸入經過Embedding層之後的值，hidden_state就是Decoder的hidden state，這兩個值都是已知的，而剩下的context vector，則是需要計算的，同樣和之前一樣，context vector等於attention weight與encoder output乘積，在Transformer中，encoder output用到的就是Encoder層最後的輸出，而attention weight用的則是Encoder-Decoder Attention，這樣就可以得到context vector，計算p_gen。

代碼部分說了這麼多，還是迷迷糊糊，不如直接看代碼來得清楚，ok，我們進入代碼部分。我們先來看一下Self-Attention部分，如下：

def scaled_dot_product_attention(q, k, v, mask):    matmul_qk = tf.matmul(q, k, transpose_b=True)         dk = tf.cast(tf.shape(k)[-1], tf.float32)    scaled_attention_logits = matmul_qk/tf.math.sqrt(dk)        if mask is not None:        scaled_attention_logits += (mask*-1e9)    attention_weights = tf.nn.softmax(scaled_attention_logits, axis=-1)    output = tf.matmul(attention_weights, v)    return output, attention_weights
這其中用到了一個mask，這是因為由於輸入的語料長度不一致，對於較長的語料，會進行截斷，而對於較短的語料，則會用"Padding"字符進行填充，但是在計算Self-Attention的時候，這些填充字符沒有實際意義，所以需要掩蓋掉。這裡用到的方法，是構造一個mask矩陣，對於填充部分，用-1e9表示（代表無窮小），這樣再計算Softmax的時候，這些無窮小的地方就會變為0，所以成功掩蓋掉填充欄位。再來看一下Embedding部分，這裡用Token Embedding和Position Embedding組合成Embedding部分，
class Embedding(tf.keras.layers.Layer):    def __init__(self, vocab_size, d_model):        super(Embedding, self).__init__()        self.vocab_size = vocab_size        self.d_model = d_model        # token embedding        self.embedding = tf.keras.layers.Embedding(vocab_size, d_model)        self.pos_encoding = positional_encoding(vocab_size, d_model)
    def call(self, x):        embed_x = self.embedding(x)        embed_x *= tf.math.sqrt(tf.cast(self.d_model, tf.float32))        # 根據語料長度截取        embed_x += self.pos_encoding[:, :tf.shape(x)[1], :]        return embed_x
def point_wise_feed_forward_network(d_model, dff):    return tf.keras.Sequential([        tf.keras.layers.Dense(dff, activation='relu'),        tf.keras.layers.Dense(d_model)    ])
接下來看一下Encoder Block部分，基本是按照上面的結構進行組裝，不過這裡多了一點就是在Self-Attention層和Feed Forward層後面用到了dropout層去提高模型的泛化能力。
class EncoderLayer(tf.keras.layers.Layer):    def __init__(self, d_model, num_heads, dff, rate=0.1):        super(EncoderLayer, self).__init__()        self.mha = MultiHeadAttention(d_model, num_heads)        self.ffn = point_wise_feed_forward_network(d_model, dff)        self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)        self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)        self.dropout1 = tf.keras.layers.Dropout(rate)        self.dropout2 = tf.keras.layers.Dropout(rate)    def call(self, x, training, mask):        attn_output, _ = self.mha(x, x, x, mask)        attn_output = self.dropout1(attn_output, training=training)        out1 = self.layernorm1(x+attn_output)        ffn_output = self.ffn(out1)        ffn_output = self.dropout2(ffn_output, training=training)        out2 = self.layernorm2(out1+ffn_output)        return out2
Decoder Block部分與Encoder Block部分相似，也是按照上面講的結構，對各個模塊進行組裝。可以看到這個地方用到兩個Attention，第一個是Self-Attention，第二個是EncoderDecoder-Attention。此外，還有一點，就是在Decoder Block部分中的Self-Attention中用到的mask不是Encoder Block部分中的Padding Mask，而是Look Ahead Mask，它對應的是一個下三角矩陣，依次將Decoder部分語料中的每個詞逐個顯示。這樣做的目的是為了讓每個詞生成的時候，只會注意到前面的詞，而不會注意到後面的詞。
class DecoderLayer(tf.keras.layers.Layer):    def __init__(self, d_model, num_heads, dff, rate=0.1):        super().__init__()        self.mha1 = MultiHeadAttention(d_model, num_heads)        self.mha2 = MultiHeadAttention(d_model, num_heads)        self.ffn = point_wise_feed_forward_network(d_model, dff)        self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)        self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)        self.layernorm3 = tf.keras.layers.LayerNormalization(epsilon=1e-6)        self.dropout1 = tf.keras.layers.Dropout(rate)        self.dropout2 = tf.keras.layers.Dropout(rate)        self.dropout3 = tf.keras.layers.Dropout(rate)    def call(self, x, enc_output, training, look_ahead_mask, padding_mask):        attn1, attn_weights_block1 = self.mha1(x, x, x, look_ahead_mask)        attn1 = self.dropout1(attn1, training=training)        out1 = self.layernorm1(attn1 + x)        attn2, attn_weights_block2 = self.mha2(enc_output, enc_output, out1, padding_mask)        attn2 = self.dropout2(attn2, training=training)        out2 = self.layernorm2(out1 + attn2)        ffn_output = self.ffn(out2)        ffn_output = self.dropout3(ffn_output, training=training)        out3 = self.layernorm3(ffn_output+out2)
最後看一下整個模型部分，首先是組織num_layers個Encoder Block，同樣加入Dropout層提高泛化能力。
class Encoder(tf.keras.layers.Layer):    def __init__(self, num_layers, d_model, num_heads, dff, rate=0.1):        super().__init__()        self.d_model = d_model        self.num_layers = num_layers        self.enc_layers = [EncoderLayer(d_model, num_heads, dff, rate) for _ in range(num_layers)]        self.dropout = tf.keras.layers.Dropout(rate)    def call(self, x, training, mask):        x = self.dropout(x, training=training)        for i in range(self.num_layers):            x = self.enc_layers[i](x, training, mask)        return x
其次是相對比較複雜的Decoder部分，這裡使用Encoder-Decoder-Attention與Encoder部分的output相乘得到context vector，然後再和decoder input和decoder state一起計算出p_gen係數。
    def call(self, x, enc_output, training, look_ahead_mask, padding_mask):        attention_weights = {}        out = self.dropout(x, training=training)        for i in range(self.num_layers):            out, block1, block2 = self.dec_layers[i](out, enc_output, training, look_ahead_mask, padding_mask)            attention_weights['decoder_layer{}_block1'.format(i+1)] = block1            attention_weights['decoder_layer{}_block2'.format(i+1)] = block2        enc_out_shape = tf.shape(enc_output)        context = tf.reshape(enc_output, (enc_out_shape[0], enc_out_shape[1], self.num_heads, self.depth))        context = tf.transpose(context, [0, 2, 1, 3])        context = tf.expand_dims(context, axis=2)         attn = tf.expand_dims(block2, axis=-1)         context=context*attn         context = tf.reduce_sum(context, axis=3)         context = tf.transpose(context, [0, 2, 1, 3])         context = tf.reshape(context, (tf.shape(context)[0], tf.shape(context)[1], self.d_model))                 a = self.Wx(x)        b = self.Ws(out)        c = self.Wh(context)        p_gens = tf.sigmoid(self.V(a + b + c))        return out, attention_weights, p_gens
最後是PGN_TRANSFORMER模型部分，這裡最終生成的distribution的計算方法calc_final_dist與之前PGN模型的計算方法沒有區別。
    def call(self, inp, extended_inp, max_oov_len, tar, training, enc_padding_mask, look_ahead_mask, dec_padding_mask):        embed_x = self.embedding(inp)        embed_dec = self.embedding(tar)        enc_output = self.encoder(embed_x, training, enc_padding_mask)        dec_output, attention_weights, p_gens = self.decoder(embed_dec,                                                             enc_output,                                                             training,                                                             look_ahead_mask,                                                             dec_padding_mask)        final_output = self.final_layer(dec_output)        final_output = tf.nn.softmax(final_output)        attn_dists = attention_weights['decoder_layer{}_block2'.format(self.params["num_blocks"])]        attn_dists = tf.reduce_sum(attn_dists, axis=1)/self.params["num_heads"]        final_dists = calc_final_dist(extended_inp,                                      tf.unstack(final_output, axis = 1),                                      tf.unstack(attn_dists, axis=1),                                      tf.unstack(p_gens, axis=1),                                      max_oov_len,                                      self.params["vocab_size"],                                      self.params["batch_size"])        outputs = dict(logits=tf.stack(final_dists, 1), attentions=attn_dists)        return outputs