从 GPT 到 Claude：硬核拆解主流大语言模型架构的演进史

Posted on Edited on In

引言：告别“暴力美学”，走向“精雕细琢”

如果说 Transformer 架构的提出（《Attention is All You Need》, 2017）是给自然语言处理（NLP）领域递上了一把火，那么近年来大语言模型（LLM）的爆发，则是这把火点燃的燎原之势。

从 OpenAI 的 GPT 系列独步武林，到 Meta 的 LLaMA 系列开启开源狂欢，再到 Anthropic 的 Claude 系列在长上下文与对齐领域异军突起，大模型的底层架构并非一成不变。很多人误以为现在的模型还是 2017 年那个原汁原味的 Transformer，但实际上，为了应对计算瓶颈、提升推理效率、突破上下文长度限制，主流大模型的架构早已在暗中经历了多次“基因突变”。

本文将带你深入大模型的底层工程，硬核拆解从 GPT 到 Claude 的架构演进史。我们将探讨那些教科书上很少提及的工程细节，包括但不限于位置编码的进化、注意力机制的变体、MoE（混合专家模型）的复兴，以及大模型对齐训练的范式转移。

第一阶段：GPT 系列的基石 —— 标准 Decoder-Only 与预训练范式

1.1 从 Decoder 说起：单向注意力的优势

最初的 Transformer 是为机器翻译设计的 Encoder-Decoder 架构。而 OpenAI 在 GPT-1 和 GPT-2 中，极其坚定地砍掉了 Encoder，采用了 Decoder-Only 架构。

为什么选择 Decoder？因为在自回归生成任务中，模型只能看到当前词之前的词。Decoder 的因果掩码完美契合了这一特性。更重要的是，研究表明，对于无条件生成和少样本学习，单向注意力足够捕捉语言的规律。

早期的 GPT 架构非常“干净”：

  1. Token Embedding：将文本转化为向量。
  2. 绝对位置编码：注入位置信息。
  3. 多层 Transformer Block：包含多头注意力（MHA）和前馈神经网络（FFN）。
  4. Layer Normalization：采用后归一化结构。

1.2 GPT-3：力大砖飞与工程挑战

到了 GPT-3（1750 亿参数），模型参数量呈指数级上升。这里面临的最大工程挑战是显存墙。模型的参数量（175B）光是加载到 FP16 格式的显存中，就需要约 350GB。这迫使工程师们开始采用 3D 并行策略（数据并行、张量并行、流水线并行），并引入模型量化技术。

此时的 GPT-3，在架构上依然是传统的 Transformer，但它证明了“Scaling Law”：只要模型够大、数据够多、算力够强，智能就会自然涌现。

第二阶段：架构优化的分水岭 —— LLaMA 带来的开源启示

如果说 GPT 是闭源的暴力美学，那么 Meta 的 LLaMA 系列则是开源界的教科书。LLaMA 的问世，向业界证明了通过更优秀的架构设计和更高质量的数据，可以用更小的参数量击败庞然大物。LLaMA 对标准 Transformer 做了三大关键手术。

2.1 术式一：从 Pre-Norm 到 RMSNorm 的降本增效

早期的 Transformer 采用的是 Post-LayerNorm（在残差连接后做归一化），这容易导致训练初期梯度不稳定。后来业界普遍转向了 Pre-LayerNorm（在进入 Attention 和 FFN 前做归一化）。

但 LLaMA 更进一步，放弃了标准的 LayerNorm，转而使用了 RMSNorm（均方根归一化）。

技术细节： LayerNorm 计算均值和方差，而 RMSNorm 认为移除均值计算不仅不影响性能，还能节省约 7% 到 10% 的计算开销。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import torch
import torch.nn as nn

class RMSNorm(nn.Module):
    def __init__(self, dim, eps=1e-6):
        super().__init__()
        self.eps = eps
        self.weight = nn.Parameter(torch.ones(dim))

    def forward(self, x):
        # 计算均方根
        norm = torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)
        # 乘以可学习的权重
        return x * norm * self.weight

2.2 术式二：革命性的 RoPE（旋转位置编码）

位置编码是 Transformer 的灵魂。绝对位置编码（如 GPT 中的正弦编码）无法很好地泛化到未见过长度的序列。后来出现了 T5 风格的相对位置编码，但计算复杂且不够优雅。

LLaMA 引入了苏剑林提出的 RoPE（Rotary Position Embedding，旋转位置编码），这可以说是近年来 LLM 架构中最优美的数学创新之一。

核心思想： RoPE 通过在复数域的旋转，将绝对位置信息以乘法的方式融入到注意力计算中，从而巧妙地实现了相对位置编码的效果。它不仅计算高效，而且支持通过数学插值（如 NTK-Aware Interpolation）来扩展上下文长度。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import torch

def precompute_freqs_cis(dim: int, end: int, theta: float = 10000.0):
    # 计算频率
    freqs = 1.0 / (theta ** (torch.arange(0, dim, 2).float() / dim))
    t = torch.arange(end, device=freqs.device)
    freqs = torch.outer(t, freqs).float()
    # 转换为极坐标
    freqs_cis = torch.polar(torch.ones_ones_like(freqs), freqs)
    return freqs_cis

def apply_rotary_emb(xq, xk, freqs_cis):
    # 将特征维度视为复数
    xq_ = torch.view_as_complex(xq.float().reshape(*xq.shape[:-1], -1, 2))
    xk_ = torch.view_as_complex(xk.float().reshape(*xk.shape[:-1], -1, 2))
    # 乘以旋转矩阵（复数乘法实现旋转）
    xq_out = torch.view_as_real(xq_ * freqs_cis).flatten(3)
    xk_out = torch.view_as_real(xk_ * freqs_cis).flatten(3)
    return xq_out.type_as(xq), xk_out.type_as(xk)

RoPE 的引入，使得后续模型（包括 Claude）在处理超长文本（100K+ tokens）时成为了可能。

2.3 术式三：SwiGLU 激活函数

在 FFN 层，标准的 ReLU 被抛弃，LLaMA 使用了 SwiGLU（Swish-Gated Linear Unit）。虽然 SwiGLU 会增加一点参数量（需要三个权重矩阵而不是两个），但大量实验证明，它在同等参数规模下能提供更好的梯度和更低的困惑度。

第三阶段：打破显存瓶颈 —— 混合专家模型（MoE）与注意力变体

随着模型规模继续扩大，稠密模型每一次前向传播的成本变得不可接受。于是，架构演进走向了两个极端：一个是“稀疏激活”，另一个是“改造注意力机制”。

3.1 GPT-4 的幕后功臣：MoE 架构

尽管 OpenAI 没有公布 GPT-4 的详细架构，但泄露的信息和业界共识表明，GPT-4 是一个基于 MoE（Mixture of Experts） 的模型。拥有 8 个专家，每次生成 token 时只有 2 个专家被激活（总共约 1.8T 参数，每次激活约 280B）。

MoE 的核心逻辑：
MoE 层取代了传统的 FFN 层。它包含一个路由网络和多个并行的 FFN（专家）。对于输入的每个 token，路由网络会计算出它应该交给哪几个专家处理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class TopkRouter(nn.Module):
    def __init__(self, n_experts, top_k=2):
        super().__init__()
        self.w_gate = nn.Linear(dim, n_experts, bias=False)
        self.top_k = top_k

    def forward(self, x):
        # 计算每个 token 分配给每个专家的 logits
        logits = self.w_gate(x)
        # 选取概率最大的 top_k 个专家
        top_k_logits, indices = torch.topk(logits, self.top_k, dim=-1)
        # Softmax 归一化
        scores = F.softmax(top_k_logits, dim=-1)
        return scores, indices

工程挑战（负载均衡）： MoE 最大的问题是“路由崩塌”，即所有 token 都倾向于被发送给少数几个“受欢迎”的专家，导致 GPU 显存溢出。解决这一问题的核心是引入 Auxiliary Loss（辅助损失函数），在训练时惩罚专家间负载的不均衡。

3.2 GQA 与 MQA：为 KV Cache 瘦身

当模型上下文越来越长，KV Cache（键值缓存）占用的显存会急剧膨胀，成为推理延迟的罪魁祸首。

  • MHA（多头注意力）：传统的做法，每个头都有独立的 Q, K, V。
  • MQA（多查询注意力）：所有的查询头共享同一组 K 和 V。这极大降低了显存占用，但可能导致模型质量下降。
  • GQA（分组查询注意力）：LLaMA-2 和许多现代模型采用的折中方案。将 Q 分为几组，每组共享一套 K 和 V。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
MHA: Q(head 1) -> K(head 1), V(head 1)
     Q(head 2) -> K(head 2), V(head 2)

GQA: Q(head 1) ─┐
                 ├─> K(group 1), V(group 1)
     Q(head 2) ─┘
     
     Q(head 3) ─┐
                 ├─> K(group 2), V(group 2)
     Q(head 4) ─┘

MQA: Q(head 1) ─┐
     Q(head 2) ─┤
     Q(head 3) ├─> K(shared), V(shared)
     Q(head 4) ─┘

GQA 在保持接近 MHA 模型性能的同时，拥有了堪比 MQA 的推理速度。这是目前主流大模型（包括 Claude）应对超长上下文推理的标准配置。

第四阶段：Claude 的崛起 —— 超长上下文与“无害化”架构

Anthropic 的 Claude 系列在架构上的演进，代表了当前 LLM 的最高水平之一，尤其是在上下文窗口和对齐两个维度上。

4.1 攻克 200K 上下文：Ring Attention 与 Prompt 混淆

Claude 3 旗舰版支持高达 200K tokens 的上下文。要在 LLaMA 这样基于 RoPE 的架构上实现这一点，单纯依赖插值会导致模型“忘记”短文本的细节。

Ring Attention 架构细节：
在跨节点分布式训练时，传统的将序列切分的方法会导致显存溢出。Ring Attention 通过让计算设备和 Block 数据形成一个环形拓扑。设备在计算自己负责的 Block 注意力时，同时异步向前一个设备发送下一段 KV Block，向下一个设备接收新的 KV Block。这实现了近乎无限上下文的分布式训练。

Prompt 混淆：
为了防止模型在 200K 的长文本中出现“Lost in the Middle”（中间信息丢失）的问题，Claude 在预训练阶段就引入了特殊的文档边界标记和持续预训练策略，增强了模型在浩如烟海的文本中提取细粒度信息的能力。

4.2 从 RLHF 到 Constitutional AI (CAI)

架构的演进不仅在预训练，微调阶段同样重要。GPT 系列广泛采用 RLHF（基于人类反馈的强化学习），但人类反馈存在偏见且成本高昂。

Anthropic 提出了 Constitutional AI（宪法 AI），这也是 Claude 区别于其他模型的核心架构之一。

工作原理：

  1. 监督学习阶段（SL）：模型被要求在有害的 Prompt 下给出回复。然后，模型根据预设的“宪法原则”（如“不要生成分辨率低的刻板印象”）对自己的有害回复进行批评，并修正为无害回复。
  2. RL 阶段（RLAI）：用修正后的数据训练一个偏好模型，再用这个偏好模型代替人类进行 PPO 强化学习。

这种架构设计让 Claude 在不牺牲“有帮助性”的前提下，极大地提升了“无害性”，从根本上改变了模型的安全边界。

第五阶段：底层优化之王 —— FlashAttention 的颠覆

不论架构如何演变，只要还是基于 Transformer，注意力机制的计算复杂度 O(N2)O(N^2) 就是绕不过去的心魔。2023 年，斯坦福大学提出的 FlashAttention 及其后续版本，成为了拯救大模型训练的神器。

目前所有的主流模型（GPT-4, LLaMA-3, Claude）均默认集成 FlashAttention。

为什么 FlashAttention 这么快？
很多人误以为 FlashAttention 是一种近似算法，实际上它是精确注意力。它的加速原理完全建立在对现代 GPU 硬件架构的深刻理解上。

  1. HBM 与 SRAM 的博弈：GPU 的高带宽显存（HBM）容量大但读写慢；SRAM（静态随机存取存储器，即 L2 Cache）容量极小但读写极快。
  2. 减少 HBM 读写次数：传统的注意力计算，需要把 N×NN \times N 的巨大注意力矩阵写入 HBM 再读出来进行 Softmax。FlashAttention 通过分块技术，将 Q, K, V 切成小块在 SRAM 中计算 Softmax（使用 Online Softmax 技术），并累积输出。这避免了对中间巨大矩阵的 HBM 读写。
1
2
3
4
5
6
7
8
9
10
# 使用 FlashAttention 的伪代码示例 (PyTorch 2.0+)
import torch.nn.functional as F

# 传统方式 (OOM Risk)
# q, k, v 在 HBM 中，计算 S = Q @ K^T，分配 N*N 的显存
# A = softmax(S) @ V

# FlashAttention 方式 (SDPA 后端)
# PyTorch 2.0 的 F.scaled_dot_product_attention 会自动调用 FlashAttention
output = F.scaled_dot_product_attention(q, k, v, attn_mask=None, is_causal=True)

FlashAttention-2 和 3 的进一步优化，使得长序列注意力的计算速度成倍提升，直接催生了当前大模型卷“100K+ 上下文”的军备竞赛。

总结：架构的尽头是工程与数据的极致

从 GPT 的开疆拓土，到 LLaMA 的精雕细琢，再到 Claude 的安全与长文本突破，主流大模型的架构演进史，本质上是一部工程优化的血泪史。

我们可以总结出几个清晰的演进规律：

  1. 从“稠密”走向“稀疏”：MoE 架构使得模型可以在不增加推理计算量的前提下，疯狂扩充知识容量。
  2. 从“绝对”走向“相对”：RoPE 的应用使得位置编码具备了泛化性，Ring Attention 等技术使得无限上下文成为可能。
  3. 硬件感知的算法设计：无论是 GQA 还是 FlashAttention，现代模型架构的设计已经不再是纯粹的数学推导，而是深度绑定 GPU 底层计算单元的硬件协同设计。
  4. 对齐成为核心架构：大模型不再仅仅是预训练模型，从 RLHF 到 Constitutional AI，对齐机制已经成为现代 LLM 闭环架构中不可或缺的一环。

面向未来，尽管有像 Mamba（状态空间模型 SSM）这样的新架构试图颠覆 Transformer，但在强大的工程生态和算力惯性下，Decoder-Only Transformer 仍将统治相当长一段时间。

大模型的竞争，正在从单纯的架构创新，转移到系统级的高效推理（如 KV Cache 量化、Continuous Batching）、高质量数据清洗以及基于 Agent 的工作流编排。理解了这些底层架构的演进，我们才能在这场 AI 革命中，不仅知其然，更知其所以然。