Transformer--详解

Transformer旨在解决自然语言处理任务中的长依赖性问题。与传统的递归神经网络（如LSTM、GRU）不同，Transformer完全摒弃了递归结构，依赖自注意力机制（Self-Attention）来建模输入序列中的所有位置之间的关系。因此，Transformer能够并行处理整个序列，这极大地提高了训练速度和效率。

Transformer在许多自然语言处理任务（如机器翻译、文本生成、文本分类等）中表现优异，尤其是大规模语言模型（如BERT、GPT、T5等）的基础架构。

Transformer的基本结构

Transformer模型由编码器（Encoder）和解码器（Decoder）两个部分组成，二者都由堆叠的多层相似结构组成。以下是各部分的基本结构：

编码器（Encoder）：
- 编码器由多个层堆叠组成，每一层包括两个子层：
  1. 多头自注意力机制（Multi-Head Self-Attention）：输入序列的所有位置之间进行相互注意，允许模型关注序列中不同部分的信息。
  2. 前馈神经网络（Feed-Forward Network）：独立应用于每个位置。
- 每个子层后都有一个残差连接和层归一化（Layer Normalization），使得梯度传播更为稳定。
解码器（Decoder）：
- 解码器也由多个层堆叠组成，但每层有三个子层：
  1. Masked 多头自注意力机制：确保模型在生成序列时，每个位置只能关注之前的位置。
  2. 编码器-解码器注意力：解码器关注编码器的输出。
  3. 前馈神经网络。
- 同样每个子层后都有残差连接和层归一化。
注意力机制（Attention Mechanism）：
- Transformer依赖于一种称为Scaled Dot-Product Attention的注意力机制。它通过计算查询（Query）、键（Key）和值（Value）之间的点积来生成注意力分数。
位置编码（Positional Encoding）：
- Transformer没有递归结构，因此模型需要一种方式来捕捉序列中的位置信息。位置编码通过正弦和余弦函数添加到输入嵌入上，帮助模型捕获位置信息。

Transformer的经典代码

以下是使用Keras实现Transformer编码器的简化代码示例：

import numpy as np
import tensorflow as tf
from tensorflow.keras.layers import Dense, LayerNormalization, Dropout, Embedding
from tensorflow.keras.models import Model

# Scaled Dot-Product Attention
def scaled_dot_product_attention(query, key, value, mask=None):matmul_qk = tf.matmul(query, key, transpose_b=True)  # 计算Q和K的点积dk = tf.cast(tf.shape(key)[-1], tf.float32)scaled_attention_logits = matmul_qk / tf.math.sqrt(dk)  # 缩放
if mask is not None:scaled_attention_logits += (mask * -1e9)  # 如果有mask，填充为负无穷
attention_weights = tf.nn.softmax(scaled_attention_logits, axis=-1)  # 归一化output = tf.matmul(attention_weights, value)  # 计算权重与V的乘积return output, attention_weights

# Multi-head Attention Layer
class MultiHeadAttention(tf.keras.layers.Layer):def __init__(self, d_model, num_heads):super(MultiHeadAttention, self).__init__()self.num_heads = num_headsself.d_model = d_model
assert d_model % self.num_heads == 0  # 确保可以均匀分成多个头
self.depth = d_model // self.num_heads
self.wq = Dense(d_model)self.wk = Dense(d_model)self.wv = Dense(d_model)self.dense = Dense(d_model)
def split_heads(self, x, batch_size):# 将最后一个维度分成多个头x = tf.reshape(x, (batch_size, -1, self.num_heads, self.depth))return tf.transpose(x, perm=[0, 2, 1, 3])
def call(self, v, k, q, mask=None):batch_size = tf.shape(q)[0]
# 通过线性层获得Q, K, Vq = self.wq(q)k = self.wk(k)v = self.wv(v)
# 分割为多个头q = self.split_heads(q, batch_size)k = self.split_heads(k, batch_size)v = self.split_heads(v, batch_size)
# 计算注意力scaled_attention, attention_weights = scaled_dot_product_attention(q, k, v, mask)
# 合并所有头scaled_attention = tf.transpose(scaled_attention, perm=[0, 2, 1, 3])concat_attention = tf.reshape(scaled_attention, (batch_size, -1, self.d_model))
output = self.dense(concat_attention)  # 通过最后的线性层return output, attention_weights

# 前馈网络
def point_wise_feed_forward_network(d_model, dff):return tf.keras.Sequential([Dense(dff, activation='relu'),  # 第一层Dense(d_model)  # 第二层])

# Transformer Encoder Layer
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 = LayerNormalization(epsilon=1e-6)self.layernorm2 = LayerNormalization(epsilon=1e-6)
self.dropout1 = Dropout(rate)self.dropout2 = Dropout(rate)
def call(self, x, mask=None):attn_output, _ = self.mha(x, x, x, mask)  # 自注意力attn_output = self.dropout1(attn_output)out1 = self.layernorm1(x + attn_output)  # 残差连接 + LayerNorm
ffn_output = self.ffn(out1)  # 前馈ffn_output = self.dropout2(ffn_output)out2 = self.layernorm2(out1 + ffn_output)  # 残差连接 + LayerNorm
return out2

# Transformer Encoder
class Encoder(tf.keras.layers.Layer):def __init__(self, num_layers, d_model, num_heads, dff, input_vocab_size, maximum_position_encoding, rate=0.1):super(Encoder, self).__init__()
self.d_model = d_modelself.num_layers = num_layers
self.embedding = Embedding(input_vocab_size, d_model)self.pos_encoding = positional_encoding(maximum_position_encoding, self.d_model)
self.enc_layers = [EncoderLayer(d_model, num_heads, dff, rate) for _ in range(num_layers)]
self.dropout = Dropout(rate)
def call(self, x, mask=None):seq_len = tf.shape(x)[1]
# 添加embedding和位置编码x = self.embedding(x)x *= tf.math.sqrt(tf.cast(self.d_model, tf.float32))x += self.pos_encoding[:, :seq_len, :]
x = self.dropout(x)
for i in range(self.num_layers):x = self.enc_layers[i](x, mask)
return x

# 位置编码
def positional_encoding(position, d_model):angle_rads = get_angles(np.arange(position)[:, np.newaxis], np.arange(d_model)[np.newaxis, :], d_model)angle_rads[:, 0::2] = np.sin(angle_rads[:, 0::2])  # apply sin to even indices in the arrayangle_rads[:, 1::2] = np.cos(angle_rads[:, 1::2])  # apply cos to odd indices in the arraypos_encoding = angle_rads[np.newaxis, ...]return tf.cast(pos_encoding, dtype=tf.float32)

def get_angles(pos, i, d_model):angle_rates = 1 / np.power(10000, (2 * (i // 2)) / np.float32(d_model))return pos * angle_rates

文本生成任务的示例代码

接下来是如何使用Transformer架构进行文本生成。这种生成任务可以视为基于语言模型的任务，即给定一部分文本，预测接下来的文本。

使用一个已经训练好的Transformer语言模型来生成文本，以下是简化的文本生成代码：

import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing.sequence import pad_sequences

# 假设已经有了一个训练好的Transformer模型
# 为了生成文本，需要以下步骤：

def generate_text(model, tokenizer, seed_text, max_sequence_len, num_words):for _ in range(num_words):token_list = tokenizer.texts_to_sequences([seed_text])[0]  # 将种子文本转换为token序列token_list = pad_sequences([token_list], maxlen=max_sequence_len-1, padding='pre')  # 填充序列predicted = model.predict(token_list, verbose=0)  # 预测下一个单词predicted_word_index = np.argmax(predicted, axis=-1)  # 获取最大概率的单词索引output_word = ""for word, index in tokenizer.word_index.items():if index == predicted_word_index:output_word = wordbreakseed_text += " " + output_word  # 更新种子文本return seed_text

# 使用示例：
seed_text = "The future of AI"
generated_text = generate_text(model, tokenizer, seed_text, max_sequence_len=10, num_words=50)
print(generated_text)