Transformer 模型架构详解与核心组件解析

4. 前馈神经网络（FFN）

每个编码器和解码器层中，除了自注意力机制，还有一个独立的前馈神经网络（FFN），它用于对自注意力输出的结果进行进一步的非线性变换。FFN 由两层线性变换和一个激活函数（通常是 ReLU）组成。

FFN 的作用是通过非线性映射提升模型的表达能力，使模型能够拟合更复杂的函数关系。

5. 层归一化和残差连接

为了加速训练并解决梯度消失或爆炸的问题，Transformer 在每个子层（包括自注意力机制和前馈神经网络）后面引入了残差连接和层归一化。

• 残差连接：将输入直接加到子层的输出上，保持信息传递流畅。
• 层归一化：对每个子层的输出进行归一化处理，提升模型的稳定性。

6. Masked 多头自注意力子层

Masked 多头自注意力子层用于解码器的生成任务。在生成过程中，模型生成当前时间步的单词时，只能依赖之前生成的单词，而不能看到未来未生成的单词。为了确保这一点，Masked 多头自注意力机制通过在注意力矩阵中对未来位置进行掩码，使其权重为负无穷，从而保证模型只能'关注'到之前的位置。

7. 编码器 - 解码器多头注意力子层

编码器 - 解码器多头注意力子层在 Transformer 解码器中起到了关键作用，它使解码器能够有效地关注输入序列（编码器的输出），从而在生成序列时参考原始输入信息。具体来说，编码器 - 解码器多头注意力的基本思想是通过对编码器输出（Key 和 Value）和解码器当前输入（Query）来生成新的表示。

示例代码实现

下面，我们从头开始构建一个 Transformer 模型。首先，我们来创建一个 MultiHeadAttention 类，它实现了 Transformer 中的多头自注意力机制。

import numpy as np

class MultiHeadAttention:
    def __init__(self, num_hiddens: int, num_heads: int, dropout: float = 0.0, bias: bool = False):
        self.num_heads = num_heads
        self.num_hiddens = num_hiddens
        self.d_k = self.d_v = num_hiddens // num_heads
        
        # 初始化权重矩阵
        self.W_q = np.random.rand(num_hiddens, num_hiddens)
        self.W_k = np.random.rand(num_hiddens, num_hiddens)
        self.W_v = np.random.rand(num_hiddens, num_hiddens)
        self.W_o = np.random.rand(num_hiddens, num_hiddens)
        
        if bias:
            self.b_q = np.random.rand(num_hiddens)
            self.b_k = np.random.rand(num_hiddens)
            self.b_v = np.random.rand(num_hiddens)
            self.b_o = np.random.rand(num_hiddens)
        else:
            self.b_q = self.b_k = self.b_v = self.b_o = np.zeros(num_hiddens)

    def transpose_qkv(self, X: np.ndarray) -> np.ndarray:
        # 调整形状以便并行计算多个 head
        X = X.reshape(X.shape[0], X.shape[1], self.num_heads, -1)
        X = X.transpose(0, 2, 1, 3)
        return X.reshape(-1, X.shape[2], X.shape[3])
    
    def transpose_output(self, X: np.ndarray) -> np.ndarray:
        # 恢复形状
        X = X.reshape(-1, self.num_heads, X.shape[1], X.shape[2])
        X = X.transpose(0, 2, 1, 3)
        return X.reshape(X.shape[0], X.shape[1], -1)
    
    def scaled_dot_product_attention(self, Q: np.ndarray, K: np.ndarray, V: np.ndarray, valid_lens: np.ndarray = None) -> np.ndarray:
        d_k = Q.shape[-1]
        scores = np.matmul(Q, K.transpose(0, 2, 1)) / np.sqrt(d_k)
        if valid_lens is not None:
            mask = np.arange(scores.shape[-1]) < valid_lens[:, None]
            scores = np.where(mask[:, None, :], scores, -np.inf)
        attention_weights = np.exp(scores - np.max(scores, axis=-1, keepdims=True))
        attention_weights /= attention_weights.sum(axis=-1, keepdims=True)
        return np.matmul(attention_weights, V)
    
    def forward(self, queries: np.ndarray, keys: np.ndarray, values: np.ndarray, valid_lens: np.ndarray = None) -> np.ndarray:
        queries = self.transpose_qkv(np.dot(queries, self.W_q) + self.b_q)
        keys = self.transpose_qkv(np.dot(keys, self.W_k) + self.b_k)
        values = self.transpose_qkv(np.dot(values, self.W_v) + self.b_v)
        
        if valid_lens is not None:
            valid_lens = np.repeat(valid_lens, self.num_heads, axis=0)
        
        output = self.scaled_dot_product_attention(queries, keys, values, valid_lens)
        output_concat = self.transpose_output(output)
        return np.dot(output_concat, self.W_o) + self.b_o

在 forward 方法中，首先对 queries、keys 和 values 进行线性变换，分别生成查询、键和值向量。然后通过 scaled_dot_product_attention 方法计算每个注意力头的输出。接下来，调用 transpose_output 方法将多个注意力头的输出拼接起来。最后，拼接后的输出通过 W_o 矩阵进行线性变换，并加上偏置 b_o，得到最终的输出。

下面，我们来看一下位置编码的实现。

def positional_encoding(seq_len: int, d_model: int) -> np.ndarray:
    pos = np.arange(seq_len)[:, np.newaxis]
    i = np.arange(d_model)[np.newaxis, :]
    angle_rates = 1 / np.power(10000, (2 * (i // 2)) / np.float32(d_model))
    pos_encoding = pos * angle_rates
    
    pos_encoding[:, 0::2] = np.sin(pos_encoding[:, 0::2])
    pos_encoding[:, 1::2] = np.cos(pos_encoding[:, 1::2])
    
    return pos_encoding

然后，我们创建一个前馈网络。

class FeedForward:
    def __init__(self, d_model: int, d_ff: int):
        self.W1 = np.random.randn(d_model, d_ff) * np.sqrt(2.0 / (d_model + d_ff))
        self.b1 = np.zeros(d_ff)
        self.W2 = np.random.randn(d_ff, d_model) * np.sqrt(2.0 / (d_ff + d_model))
        self.b2 = np.zeros(d_model)

    def __call__(self, x: np.ndarray) -> np.ndarray:
        return self.forward(x)

    def forward(self, x: np.ndarray) -> np.ndarray:
        return np.dot(np.maximum(0, np.dot(x, self.W1) + self.b1), self.W2) + self.b2

接下来，我们构建一个编码器层，将多头注意力机制与前馈神经网络相结合，构成了 Transformer 模型的核心构建块之一。

class EncoderLayer:
    def __init__(self, d_model: int, num_heads: int, d_ff: int, dropout: float = 0.0, bias: bool = False):
        self.d_model = d_model
        self.num_heads = num_heads
        self.d_ff = d_ff
        
        self.multi_head_attention = MultiHeadAttention(d_model, num_heads, dropout, bias)
        self.feed_forward = FeedForward(d_model, d_ff)

    def __call__(self, x: np.ndarray, mask: np.ndarray = None) -> np.ndarray:
        return self.forward(x, mask)

    def forward(self, x: np.ndarray, mask: np.ndarray = None) -> np.ndarray:
        attn_output = self.multi_head_attention.forward(x, x, x, mask)
        output = self.feed_forward(attn_output)
        return output

然后，我们来构建一个解码器层，它包括两个多头注意力机制和一个前馈网络。

class DecoderLayer:
    def __init__(self, d_model: int, num_heads: int, d_ff: int, dropout: float = 0.0, bias: bool = False):
        self.d_model = d_model
        self.num_heads = num_heads
        self.d_ff = d_ff
        
        self.multi_head_attention_1 = MultiHeadAttention(d_model, num_heads, dropout, bias)
        self.multi_head_attention_2 = MultiHeadAttention(d_model, num_heads, dropout, bias)
        self.feed_forward = FeedForward(d_model, d_ff)
    
    def __call__(self, x: np.ndarray, enc_output: np.ndarray, mask: np.ndarray = None) -> np.ndarray:
        return self.forward(x, enc_output, mask)
    
    def forward(self, x: np.ndarray, enc_output: np.ndarray, mask: np.ndarray = None) -> np.ndarray:
        attn_output1 = self.multi_head_attention_1.forward(x, x, x, mask)
        attn_output2 = self.multi_head_attention_2.forward(attn_output1, enc_output, enc_output, mask)
        output = self.feed_forward(attn_output2)
        return output

最后，我们创建一个 Transformer 类，它集成了编码器和解码器层。

class Transformer:
    def __init__(self, d_model: int, num_heads: int, d_ff: int, num_layers: int, input_vocab_size: int, target_vocab_size: int, max_seq_len: int):
        self.d_model = d_model
        self.num_heads = num_heads
        self.d_ff = d_ff
        self.num_layers = num_layers
        self.input_vocab_size = input_vocab_size
        self.target_vocab_size = target_vocab_size
        self.max_seq_len = max_seq_len
        
        self.encoder_layers = [EncoderLayer(d_model, num_heads, d_ff) for _ in range(num_layers)]
        self.decoder_layers = [DecoderLayer(d_model, num_heads, d_ff) for _ in range(num_layers)]
        
        self.embedding = np.random.randn(input_vocab_size, d_model) * np.sqrt(2.0 / (input_vocab_size + d_model))
        self.pos_encoding = positional_encoding(max_seq_len, d_model)
        self.output_layer = np.random.randn(d_model, target_vocab_size) * np.sqrt(2.0 / (d_model + target_vocab_size))

    def __call__(self, input_seq: np.ndarray, target_seq: np.ndarray, mask: np.ndarray = None) -> np.ndarray:
        return self.forward(input_seq, target_seq, mask)

    def forward(self, input_seq: np.ndarray, target_seq: np.ndarray, mask: np.ndarray = None) -> np.ndarray:
        enc_output = self.encode(input_seq, mask)
        dec_output = self.decode(target_seq, enc_output, mask)
        output = np.dot(dec_output, self.output_layer)
        return output

    def encode(self, input_seq: np.ndarray, mask: np.ndarray = None) -> np.ndarray:
        seq_len = input_seq.shape[1]
        x = self.embedding[input_seq] + self.pos_encoding[:seq_len, :]
        
        for layer in self.encoder_layers:
            x = layer(x, mask)
        
        return x

    def decode(self, target_seq: np.ndarray, enc_output: np.ndarray, mask: np.ndarray = None) -> np.ndarray:
        seq_len = target_seq.shape[1]
        x = self.embedding[target_seq] + self.pos_encoding[:seq_len, :]
        
        for layer in self.decoder_layers:
            x = layer(x, enc_output, mask)
        
        return x

# 示例运行
d_model = 512
num_heads = 8
d_ff = 2048
num_layers = 6
input_vocab_size = 10000
target_vocab_size = 10000
max_seq_len = 100

# 创建 transformer 模型
transformer = Transformer(d_model, num_heads, d_ff, num_layers, input_vocab_size, target_vocab_size, max_seq_len)

# 虚拟输入和目标序列
input_seq = np.random.randint(0, input_vocab_size, (32, 50))
target_seq = np.random.randint(0, target_vocab_size, (32, 50))

# 前向传播
output = transformer(input_seq, target_seq)
print(output.shape)  # Should be (batch_size, target_seq_len, target_vocab_size)
# (32, 50, 10000)

训练与优化策略

在实际应用中，训练 Transformer 模型需要注意以下几点：

1. 损失函数：通常使用交叉熵损失函数（Cross Entropy Loss），特别是在分类和序列生成任务中。
2. 优化器：Adam 优化器是首选，因为它能自适应地调整学习率，适合处理稀疏梯度和噪声数据。
3. 学习率调度：采用 Warmup 策略，即在训练初期缓慢增加学习率，随后逐渐衰减，有助于模型收敛。
4. 正则化：Dropout 和 Label Smoothing 是常用的正则化手段，能有效防止过拟合。

应用场景

Transformer 模型已广泛应用于多个领域：

• 机器翻译：如 Google Translate 后端技术。
• 文本生成：如 GPT 系列大模型的基础架构。
• 图像识别：Vision Transformer (ViT) 将 Transformer 应用于图像分类。
• 语音识别：结合声学模型进行端到端语音转文字。

总结

Transformer 模型凭借其强大的并行计算能力和对长距离依赖的处理能力，已成为现代深度学习的主流架构。通过深入理解其核心组件如自注意力机制、位置编码及编码器 - 解码器结构，开发者可以更有效地设计和优化自己的 AI 系统。本文提供的代码示例展示了从零构建基础 Transformer 的过程，为进一步研究复杂变体奠定了坚实基础。