AI LLM 模型之 Transformer 架构解析

最新推荐文章于 2025-07-03 19:05:15 发布

原创最新推荐文章于 2025-07-03 19:05:15 发布 · 516 阅读

11 ·

CC 4.0 BY-SA版权

文章标签：

#人工智能 #transformer #深度学习 #机器学习 #AI #大模型

大模型同时被 3 个专栏收录

33 篇文章

订阅专栏

33 篇文章

订阅专栏

人工智能

33 篇文章

订阅专栏

一、引言

在人工智能（AI）领域，大型语言模型（LLM）的发展取得了显著的成果。Transformer 架构作为现代 LLM 的核心，自 2017 年被提出以来，彻底改变了自然语言处理（NLP）的格局。它摒弃了传统的循环神经网络（RNN）及其变体（如 LSTM 和 GRU），引入了自注意力机制，使得模型能够并行处理序列数据，大大提高了训练效率和性能。本文将深入解析 Transformer 架构的原理、方法论、代码实现，并通过具体案例说明其在实际应用中的强大能力。

二、Transformer 架构的背景与动机

2.1 传统模型的局限性

在 Transformer 出现之前，RNN 及其变体在处理序列数据时表现出色，但随着研究的深入，这些模型的局限性逐渐显现：

难以并行化计算：RNN 及其变体需要按顺序处理序列中的每个元素，这使得模型无法充分利用现代硬件（如 GPU 和 TPU）的并行计算能力。例如，在处理长文本时，RNN 需要逐词计算，导致训练速度缓慢。
长距离依赖问题：RNN 在处理长序列时，容易出现梯度消失或梯度爆炸的问题。这种现象使得模型难以捕捉序列中的长距离依赖关系。例如，在处理长文本时，模型可能无法有效地关联句子开头和结尾的信息。
固定长度的上下文窗口：RNN 的上下文信息传递依赖于隐藏状态，其大小是固定的。这限制了模型对全局信息的感知能力，导致其在处理复杂语义任务时表现不佳。
训练效率低：RNN 的逐词处理方式使得模型在训练时难以利用并行化技术，导致训练时间长，难以扩展到大规模数据集。

2.2 Transformer 的诞生

为了解决这些问题，2017 年，Vaswani 等人在论文《Attention is All You Need》中提出了一种全新的架构——Transformer。该架构完全摒弃了 RNN，转而使用基于注意力机制（Attention Mechanism）的结构，显著提升了模型的性能和效率。Transformer 架构的核心在于其独特的自注意力机制（Self - Attention）和多头注意力机制（Multi - Head Attention），这些机制使得模型能够并行处理序列，并且能够捕捉长距离依赖关系。

三、Transformer 架构详解

3.1 总体架构

Transformer 采用了编码器 - 解码器（Encoder - Decoder）架构，这一架构在机器翻译等序列到序列的任务中表现卓越。编码器负责将输入序列（如源语言句子）转换为一系列连续的向量表示，这些向量蕴含了输入序列的丰富语义信息；解码器则基于编码器的输出，结合已生成的部分目标序列（如目标语言句子的已生成部分），逐步生成完整的目标序列。

3.2 编码器结构

编码器由多个相同的层堆叠而成，每一层又包含两个子层：多头自注意力机制（Multi - Head Self - Attention）和位置全连接前馈网络（Position - wise Feed - Forward Network）。

多头自注意力机制：自注意力机制是 Transformer 的核心创新点。传统的注意力机制计算 Query（查询）、Key（键）和 Value（值）三个向量之间的关联程度，以确定输入序列中各个位置对于当前位置的重要性权重。在 Transformer 中，多头自注意力机制将输入向量通过多个不同的线性变换，得到多组 Query、Key 和 Value 矩阵，并行计算多个注意力子空间的结果，然后将这些结果拼接并通过线性变换输出。这种方式能够让模型从不同角度捕捉输入序列中的依赖关系，增强对复杂语义的理解能力。
位置全连接前馈网络：在多头自注意力机制之后，每个位置的向量表示会输入到位置全连接前馈网络中。这个网络由两个线性层和一个 ReLU 激活函数组成，对每个位置的向量进行独立处理，进一步提取特征。

3.3 解码器结构

解码器同样由多个相同的层堆叠组成，每一层包含三个子层：多头自注意力机制、编码器 - 解码器注意力机制（Encoder - Decoder Attention）和位置全连接前馈网络。

多头自注意力机制：解码器中的多头自注意力机制与编码器中的类似，但有一个重要区别，它在计算注意力时会屏蔽未来位置的信息，确保在生成目标序列时，模型只能依赖已经生成的部分，而不会提前看到未来的信息，符合序列生成的逻辑。
编码器 - 解码器注意力机制：这一子层用于将编码器的输出与解码器当前的输入相结合，使得解码器能够利用编码器提取的源序列信息来生成目标序列。它的计算方式与多头自注意力机制类似，只是 Query 来自解码器的前一层输出，而 Key 和 Value 来自编码器的输出。
位置全连接前馈网络：与编码器中的位置全连接前馈网络结构相同，对经过前两个子层处理后的向量进行进一步的特征变换和信息整合。

3.4 位置编码

Transformer 模型本身不具备对序列中元素位置信息的感知能力，因此引入了位置编码（Position Encoding）。位置编码通过为每个位置生成一个唯一的向量表示，将位置信息融入到输入序列中。常见的位置编码方式是正弦位置编码，其公式为： [PE_{(pos, 2i)} = \sin(\frac{pos}{10000^{\frac{2i}{d_{model}}}})] [PE_{(pos, 2i + 1)} = \cos(\frac{pos}{10000^{\frac{2i}{d_{model}}}})] 其中，(pos) 表示单词在句子中的位置，(i) 表示维度，(d_{model}) 是模型的维度。

四、Transformer 的核心机制

4.1 自注意力机制

自注意力机制的作用是让模型在处理一个词时，动态关注输入序列中其他词的重要性，捕捉长距离依赖关系。具体步骤如下：

输入表示：每个单词的嵌入表示（Embedding）作为输入。
生成 Query、Key 和 Value 向量：每个输入通过学习得到的权重矩阵映射为查询、键和值向量。
计算注意力分数：计算查询向量与所有键向量的点积，然后除以键向量维度的平方根（通常是 8）以获得更稳定的梯度。
归一化：使用 softmax 函数将注意力分数归一化为概率分布。
加权求和：根据这些概率分布，对值向量进行加权求和，得到每个元素的输出表示。

自注意力的计算公式为： [Attention(Q, K, V) = \text{softmax}(\frac{QK^T}{\sqrt{d_k}})V] 其中，(Q)、(K) 和 (V) 分别是查询、键和值矩阵，(d_k) 是键向量的维度。

[图片上传失败…(image-b873da-1751375977540)]

4.2 多头注意力机制

多头注意力机制是在自注意力机制的基础上引入的，通过将输入序列分成多个头（Head），每个头独立计算注意力，最后将结果拼接并线性变换。这样可以让模型从不同的表示子空间获取信息，提高模型的表达能力。

多头注意力的计算公式为： [MultiHead(Q, K, V) = \text{Concat}(head_1, \cdots, head_h)W^O] 其中，(h) 是头的数量，(W^O) 是输出的线性变换矩阵。

五、代码解析

以下是一个使用 PyTorch 实现的简单 Transformer 模型示例：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, Dataset
from transformers import TransformerEncoder, TransformerEncoderLayer, TransformerDecoder, TransformerDecoderLayer

# 示例数据集
class TranslationDataset(Dataset):
    def __init__(self, src_sentences, tgt_sentences, src_vocab, tgt_vocab, max_len=50):
        self.src_sentences = src_sentences
        self.tgt_sentences = tgt_sentences
        self.src_vocab = src_vocab
        self.tgt_vocab = tgt_vocab
        self.max_len = max_len

    def __len__(self):
        return len(self.src_sentences)

    def __getitem__(self, idx):
        src_sentence = self.src_sentences[idx]
        tgt_sentence = self.tgt_sentences[idx]

        # 将句子转换为索引
        src_indices = [self.src_vocab.get(word, self.src_vocab["<unk>"]) for word in src_sentence.split()]
        tgt_indices = [self.tgt_vocab.get(word, self.tgt_vocab["<unk>"]) for word in tgt_sentence.split()]

        # 填充到最大长度
        src_indices = src_indices[:self.max_len] + [self.src_vocab["<pad>"]] * (self.max_len - len(src_indices))
        tgt_indices = tgt_indices[:self.max_len] + [self.tgt_vocab["<pad>"]] * (self.max_len - len(tgt_indices))

        return {
            "src": torch.tensor(src_indices, dtype=torch.long),
            "tgt": torch.tensor(tgt_indices, dtype=torch.long)
        }

# Transformer 模型
class TransformerModel(nn.Module):
    def __init__(self, src_vocab_size, tgt_vocab_size, d_model=512, nhead=8, num_encoder_layers=6, num_decoder_layers=6, dim_feedforward=2048, dropout=0.1):
        super().__init__()
        self.encoder_layer = TransformerEncoderLayer(d_model=d_model, nhead=nhead, dim_feedforward=dim_feedforward, dropout=dropout)
        self.decoder_layer = TransformerDecoderLayer(d_model=d_model, nhead=nhead, dim_feedforward=dim_feedforward, dropout=dropout)
        self.encoder = TransformerEncoder(self.encoder_layer, num_layers=num_encoder_layers)
        self.decoder = TransformerDecoder(self.decoder_layer, num_layers=num_decoder_layers)
        self.src_embedding = nn.Embedding(src_vocab_size, d_model)
        self.tgt_embedding = nn.Embedding(tgt_vocab_size, d_model)
        self.fc_out = nn.Linear(d_model, tgt_vocab_size)

    def forward(self, src, tgt, src_mask=None, tgt_mask=None, src_key_padding_mask=None, tgt_key_padding_mask=None):
        src_emb = self.src_embedding(src)
        tgt_emb = self.tgt_embedding(tgt)

        encoder_output = self.encoder(src_emb, mask=src_mask, src_key_padding_mask=src_key_padding_mask)
        decoder_output = self.decoder(tgt_emb, encoder_output, tgt_mask=tgt_mask, memory_key_padding_mask=src_key_padding_mask)
        output = self.fc_out(decoder_output)
        return output

代码解释：

数据集类 TranslationDataset：用于处理翻译任务的数据集，将句子转换为索引并进行填充。
Transformer 模型类 TransformerModel：
- src_embedding 和 tgt_embedding：分别用于将源语言和目标语言的单词转换为向量表示。
- encoder 和 decoder：分别是 Transformer 的编码器和解码器。
- fc_out：全连接层，用于将解码器的输出转换为目标词汇表的概率分布。
前向传播方法 forward：将输入的源语言和目标语言序列转换为向量表示，然后通过编码器和解码器进行处理，最后通过全连接层输出结果。

六、案例说明

6.1 机器翻译

Google 翻译使用 Transformer 模型进行神经机器翻译（NMT），提高了多语言翻译的质量和速度。其工作流程如下：

分词处理：将源语言句子进行分词。
编码器处理：将源语言序列输入到编码器，获取每个词的上下文表示。
解码器处理：解码器根据编码器的输出生成目标语言的翻译结果。

# 伪代码示例
import tensorflow as tf
from tensorflow.keras import layers

# 定义 Transformer 模型
def transformer_encoder(inputs, num_heads, ff_dim, num_layers):
    x = inputs
    for _ in range(num_layers):
        attention_output = layers.MultiHeadAttention(num_heads=num_heads, key_dim=ff_dim)(x, x)
        x = layers.Add()([x, attention_output])  # 残差连接
        x = layers.LayerNormalization()(x)

        ff_output = layers.Dense(ff_dim, activation='relu')(x)
        x = layers.Add()([x, ff_output])  # 残差连接
        x = layers.LayerNormalization()(x)
    return x

# 输入源语言的句子
input_sequence = tf.random.uniform((32, 100))  # 假设输入一个 32 个句子的批次，每个句子 100 个词
output = transformer_encoder(input_sequence, num_heads=8, ff_dim=256, num_layers=6)

6.2 文本生成

OpenAI 的 GPT 系列（例如 GPT - 3）基于 Transformer 架构进行文本生成。它通过预训练大规模语料库，能够生成高质量的自然语言文本。其工作流程如下：

输入起始文本：输入一些起始文本作为上下文。
解码器生成文本：使用解码器逐步生成下一个词，并将其作为新的上下文继续生成下一个词，直到生成完整的文本。

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer

# 加载 GPT2 模型
model = GPT2LMHeadModel.from_pretrained("gpt2")
tokenizer = GPT2Tokenizer.from_pretrained("gpt2")

# 输入提示文本
prompt = "Once upon a time"

# 编码输入文本
inputs = tokenizer(prompt, return_tensors="pt")

# 生成文本
generated_ids = model.generate(inputs['input_ids'], max_length=100, num_return_sequences=1)

# 解码生成的文本
generated_text = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
print(generated_text)