从 GPT 到 Claude：主流大语言模型架构演进全解析

Posted on 2026-05-19 In AI 技术

引言：当我们谈论 ChatGPT、Claude 3 或是 LLaMA 时，我们究竟在谈论什么？是神奇的魔法，还是精密的工程？自 2017 年 Transformer 诞生以来，大语言模型（LLM）的架构经历了一场波澜壮阔的演进。从最初小心翼翼的堆叠 Transformer 层，到如今 Mojo、FlashAttention 等底层技术的疯狂压榨硬件极限，大模型的架构史，就是一部AI工程师不断突破算力与内存瓶颈的“抗争史”。

今天，我们将拨开庞杂的参数迷雾，深入探讨从 GPT-1 到 Claude 3 这条时间线上，主流大模型底层架构的核心演进。本文不仅包含理论解析，还将辅以硬核的代码细节，带你全景式重温这段改变人类历史的AI技术狂飙。

一、蛮荒时代：GPT-1 与 GPT-2 的纯真岁月

在 BERT 统治 NLP 领域的短暂时期，OpenAI 默默坚持着“生成式预训练”路线。GPT-1 和 GPT-2 的架构在今天看来非常“原生态”：标准的 Transformer Decoder 堆叠。

核心架构特征

掩码自注意力：为了保证自回归生成的特性，注意力矩阵只能看到当前词及之前的词。
绝对位置编码：通过正弦/余弦函数或可学习的参数，将位置信息直接加到词向量上。

在这个阶段，模型架构基本遵循原版 Transformer，唯一的区别是去掉了 Cross-Attention（交叉注意力）层，变成了纯粹的 Decoder-Only 架构。

# 早期 GPT 架构的极简概念代码
class EarlyGPTBlock(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        self.attn = nn.MultiheadAttention(d_model, n_heads)
        self.ln = nn.LayerNorm(d_model)
        
    def forward(self, x, mask):
        # 原始的 Post-LN 结构（先计算Attention，再做LayerNorm）
        attn_output, _ = self.attn(x, x, x, attn_mask=mask)
        x = self.ln(x + attn_output) # 残差连接 + LayerNorm
        return x

此时的瓶颈在于：算力不足限制了参数量，而 Post-LN（后归一化）结构在模型变深时极易导致梯度爆炸或消失。

二、规模涌现：GPT-3 与 InstructGPT 的工程奇迹

GPT-3（1750 亿参数）的横空出世，确立了“大力出奇迹”的信仰。但在工程上，如何把 175B 的参数塞进有限的 GPU 显存里运行？

1. 模型并行与张量并行

单张 V100 显存只有 32GB，GPT-3 需要引入模型并行。Megatron-LM 提出了张量并行（TP），将一个巨大的线性层（如 $Y = XA$ ）切分到多张显卡上并行计算。

2. Pre-LN（预归一化）的全面普及

为了解决上百层网络难以训练的问题，GPT-3 及后续主流模型全面转向了 Pre-LN（Pre-Layer Normalization）。将 LayerNorm 放在自注意力层之前，使得梯度流动更加顺畅。

3. InstructGPT 与 RLHF（人类反馈强化学习）

架构本身没有大变，但在模型的外围套上了一层“紧箍咒”：通过 PPO（近端策略优化）算法，让模型学会符合人类的价值观和指令格式。这是 ChatGPT 诞生前的最后一块拼图。

三、开源反击战：LLaMA 架构的“返璞归真”

2023 年，Meta 推出了 LLaMA 系列模型，并以一己之力定义了目前绝大多数开源模型（如 Qwen, Baichuan, Mistral 等）的标准架构。LLaMA 的核心思想是：用更好的数据和更优的微观架构，来超越粗暴的参数堆叠。

核心架构演进细节

1. RoPE（旋转位置编码）

早期的绝对位置编码无法很好地处理长文本的泛化。LLaMA 引入了苏剑林提出的 RoPE。它不仅在绝对位置上表现良好，还能在注意力计算时自然地体现出相对位置信息。

其核心思想是通过复数运算，将 Query 和 Key 在二维平面上旋转对应的角度：

q_m = q e^{im\theta}

k_n = k e^{in\theta}

点积结果自然包含了相对距离 $m-n$ 。

2. SwiGLU 激活函数

在传统的 FFN（前馈神经网络）中，通常使用 ReLU 或 GELU。LLaMA 采用了带有门控机制的 SwiGLU，虽然增加了一点矩阵乘法的计算量，但极大地提升了模型的表达能力。

import torch
import torch.nn as nn
import torch.nn.functional as F

class LlamaFFN(nn.Module):
    def __init__(self, dim, hidden_dim):
        super().__init__()
        # SwiGLU 需要三个权重矩阵，而不是传统的两个
        self.w1 = nn.Linear(dim, hidden_dim, bias=False)
        self.w2 = nn.Linear(hidden_dim, dim, bias=False)
        self.w3 = nn.Linear(dim, hidden_dim, bias=False) # Gate 门控

    def forward(self, x):
        # x: [batch, seq_len, dim]
        # SwiGLU 公式: w2(SiLU(w1(x)) * w3(x))
        return self.w2(F.silu(self.w1(x)) * self.w3(x))

注意：在 LLaMA 之后，几乎所有的大模型（包括 Claude 系列的底层假设中）都抛弃了传统的 FFN，转向了 SwiGLU。

3. RMSNorm（均方根归一化）

为了进一步加速训练，LLaMA 放弃了 LayerNorm，改用不需要计算均值的 RMSNorm，在保持稳定性的同时节省了约 7%~10% 的计算时间。

四、突破长上下文的利器：GQA 与 Mistral 的崛起

随着对话和长文本处理需求的爆发，标准的 Multi-Head Attention（MHA，多头注意力）成了显存杀手。
假设序列长度为 $L$ ，隐藏层维度为 $d$ ，MHA 的计算复杂度和显存占用为 $O(L^2 \times d)$ 。当 $L$ 达到 100k 甚至 1M 时，推理的 KV Cache 会瞬间撑爆显存。

1. GQA（分组查询注意力）

GPT-4 和 Claude 2/3 都在底层架构中引入了极其关键的 GQA（Grouped-Query Attention）（其前身是只在生成时用的 MQA，Multi-Query Attention）。

在传统的 MHA 中，每个 Head 都有独立的 Key 和 Value。而在 GQA 中，将多个 Head 共享同一组 Key 和 Value。

优势：极大减少了 KV Cache 的显存占用，提升了推理速度，同时精度损失极小。

class GroupedQueryAttention(nn.Module):
    def __init__(self, d_model, n_heads, n_kv_heads):
        super().__init__()
        self.n_heads = n_heads # Query 的头数 (如 32)
        self.n_kv_heads = n_kv_heads # Key/Value 的头数 (如 8)
        self.head_dim = d_model // n_heads
        
        # 注意: Q 的维度是 n_heads，而 K 和 V 的维度是 n_kv_heads
        self.wq = nn.Linear(d_model, n_heads * self.head_dim, bias=False)
        self.wk = nn.Linear(d_model, n_kv_heads * self.head_dim, bias=False)
        self.wv = nn.Linear(d_model, n_kv_heads * self.head_dim, bias=False)
        self.wo = nn.Linear(n_heads * self.head_dim, d_model, bias=False)

    def forward(self, x):
        B, L, _ = x.shape
        q = self.wq(x).view(B, L, self.n_heads, self.head_dim)
        k = self.wk(x).view(B, L, self.n_kv_heads, self.head_dim)
        v = self.wv(x).view(B, L, self.n_kv_heads, self.head_dim)
        
        # 关键操作：将 K 和 V 的头广播/复制，以匹配 Q 的头数
        # k -> (B, L, n_heads, head_dim)  [通过 expand 操作]
        k = k.repeat_interleave(self.n_heads // self.n_kv_heads, dim=2)
        v = v.repeat_interleave(self.n_heads // self.n_kv_heads, dim=2)
        
        # 后续进行标准的 Scaled Dot-Product Attention...
        # attn = (q @ k.transpose(-2, -1)) / math.sqrt(self.head_dim)
        # ...

行业影响：由于 GQA 的高效，Mistral 7B 以区区 70 亿参数在性能上直逼早期的 LLaMA-2 13B，并且推理速度大幅提升。这确立了 GQA 在现代 LLM 中的核心地位。

五、巅峰之战：GPT-4 与 Claude 3 的架构哲学

当模型参数达到万亿级别，纯粹的单体模型已经无法承载。GPT-4 和 Claude 3 代表了目前商业模型的最高水平，虽然它们的底层完全闭源，但通过官方透露的技术细节和顶会论文，我们可以拼凑出它们的核心架构画像。

1. 稀疏混合专家模型

GPT-4 是一个典型的 MoE 架构模型。传闻它包含 8 个专家，总计 1.8 万亿参数，但每次前向传播时，路由器只会激活其中的 2 个专家（约 2800 亿参数）。

MoE 的本质是解耦计算时间与模型容量。它的架构改变了传统的 FFN 层：

class SparseMoE(nn.Module):
    def __init__(self, dim, num_experts, top_k):
        super().__init__()
        self.experts = nn.ModuleList([LlamaFFN(dim, hidden_dim) for _ in range(num_experts)])
        self.router = nn.Linear(dim, num_experts, bias=False)
        self.top_k = top_k

    def forward(self, x):
        # 路由器计算每个 token 应该去哪个专家
        router_logits = self.router(x) # [batch, seq, num_experts]
        weights, selected_experts = torch.topk(router_logits, self.top_k)
        
        # 稀疏计算：只计算选中的 top_k 个专家
        # (此处简化了 load_balancing 等复杂的工程实现)
        output = torch.zeros_like(x)
        for i, expert in enumerate(self.experts):
            # 筛选出需要进入当前专家的 token 并计算
            token_mask = (selected_experts == i)
            if token_mask.any():
                expert_input = x[token_mask]
                expert_output = expert(expert_input)
                output[token_mask] += expert_output
        return output

Claude 3 的不同之处：Anthropic 并没有盲从超大 MoE。据推测，Claude 系列在早期使用了相对更紧密的架构，并极度优化了推理后端。相比于 GPT-4 通过 MoE 降低计算量，Claude 更倾向于通过极致的**数据清洗、RLHF（Constitutional AI / 宪法AI）**以及底层的算子优化来提升模型的有效参数利用率。

2. 极致的内存优化：Ring Attention 与 FlashAttention-2/3

要让模型支持 100K（如 Claude 2）甚至 200K（如 Claude 3、Gemini 1.5）的上下文，显存墙是唯一的拦路虎。仅仅依靠 GQA 已经不够了。

FlashAttention：通过分块重新组织注意力计算，减少对 HBM（高带宽内存）的读写次数，以算换存。
Ring Attention：在多卡推理/训练时，将序列长度切分到不同的 GPU 上，通过环形通信传递 Key 和 Value，实现了“无限上下文”的理论可能。

六、架构演进总结与未来展望

从 GPT-1 到 Claude 3，大模型的底层架构演进轨迹异常清晰：

归一化：Post-LN $\rightarrow$ Pre-LN $\rightarrow$ RMSNorm
注意力机制：MHA $\rightarrow$ MQA $\rightarrow$ GQA (辅以 FlashAttention 算子优化)
位置编码：绝对编码 $\rightarrow$ RoPE (旋转位置编码) $\rightarrow$ ALiBi (部分模型)
激活函数：ReLU $\rightarrow$ GELU $\rightarrow$ SwiGLU
宏观拓扑：Dense Transformer $\rightarrow$ Sparse MoE

现在，如果我们要从头训练一个 SOTA 级别的模型，标准配方已经非常固定：
RoPE + SwiGLU + RMSNorm + GQA + FlashAttention。

未来的方向：超越 Transformer？

尽管 Transformer 架构统治了一切，但其 $O(N^2)$ 的计算复杂度依然是阿喀琉斯之踵。目前，诸如 Mamba (状态空间模型 SSM)、RWKV 等线性循环神经网络架构正在异军突起。它们试图以 $O(N)$ 的复杂度实现无限长上下文的推理。

此外，Claude 和 OpenAI 的竞争也从单纯的“架构之争”转向了**“系统级工程之争”**。例如大模型智能体工作流、多模态融合（视觉-语言模型 VLM 的底层对齐）等。

不管底层是 GPT 还是 Claude，这场架构的军备竞赛远未结束。每一行优化的 CUDA 代码，每一次激活函数的替换，都在推动着通用人工智能（AGI）的边界向前拓展。作为开发者和见证者，理解这些底层原理，将是我们在这个 AI 大航海时代不被淘汰的核心底气。

一、 蛮荒时代：GPT-1 与 GPT-2 的纯真岁月