从 GPT 到 Claude：主流大模型架构演进史与核心技术解码

Posted on In

引言：大航海时代的引擎进化

如果说大语言模型（LLM）是当前人工智能时代的“大航海探险”，那么底层模型架构无疑就是驱动这艘巨轮的“蒸汽机”。

自 2017 年 Google 提出 Transformer 架构以来，自然语言处理（NLP）领域发生了翻天覆地的变化。从最初被誉为“暴力美学”的 GPT-3，到开启平民化浪潮的 LLaMA，再到如今在逻辑推理和长文本处理上大放异彩的 Claude 3，大模型的底层架构并非一成不变，而是经历了一场精密而深刻的“外科手术式”进化。

许多开发者在使用各类大模型 API 时，可能会觉得它们只是参数量大小不同的“黑盒”。然而，从 GPT 到 Claude，模型架构在注意力机制、位置编码、上下文扩展以及对齐技术上都产生了数次质的飞跃。

本文将带你深入时间轴，剥开大模型黑盒的神秘外衣，详细解码从 GPT 到 Claude 的主流大模型架构演进史。我们将不仅停留在理论层面，还会结合核心代码片段，让你直观感受底层技术的变革。

第一阶段：奠基与暴力美学 —— GPT 系列的纯粹 Decoder

要理解大模型的演进，我们必须回到一切的开端：Transformer 的 Decoder-Only 架构。

1. Transformer 与自回归的胜利

尽管最初的 Transformer 是为机器翻译设计的 Encoder-Decoder 架构，但 OpenAI 在 GPT 系列中坚定地选择了 Decoder-Only（仅解码器） 路线。其核心直觉是：既然语言的本质是“预测下一个词”，那么单纯的因果语言模型（Causal Language Model）就足以吸收世界上所有的知识。

GPT 架构的核心是因果自注意力，即当前词只能关注它前面的词。

基础 Causal Self-Attention 代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import torch
import torch.nn as nn
import math

class CausalSelfAttention(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        assert d_model % n_heads == 0
        self.n_heads = n_heads
        self.d_head = d_model // n_heads
        
        # Q, K, V 线性投影层
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        
        # 输出投影层
        self.W_o = nn.Linear(d_model, d_model)

    def forward(self, x):
        B, T, C = x.size() # Batch, Sequence Length, Embedding Dimension
        
        # 计算 Query, Key, Value
        q = self.W_q(x).view(B, T, self.n_heads, self.d_head).transpose(1, 2)
        k = self.W_k(x).view(B, T, self.n_heads, self.d_head).transpose(1, 2)
        v = self.W_v(x).view(B, T, self.n_heads, self.d_head).transpose(1, 2)

        # Scaled Dot-Product Attention
        attn_scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(self.d_head)
        
        # 核心：引入因果掩码，防止看到未来的词
        mask = torch.tril(torch.ones(T, T, device=x.device)).view(1, 1, T, T)
        attn_scores = attn_scores.masked_fill(mask == 0, float('-inf'))
        
        attn_weights = torch.softmax(attn_scores, dim=-1)
        
        # 输出结果
        out = torch.matmul(attn_weights, v)
        out = out.transpose(1, 2).contiguous().view(B, T, C)
        return self.W_o(out)

2. GPT-3 的暴力美学与局限性

GPT-1 和 GPT-2 证明了“无监督预训练+有监督微调”的有效性。而 GPT-3（1750 亿参数）则向世界展示了一条新的Scaling Law（尺度定律）：只要模型足够大，数据足够多，它就能产生“涌现能力”，甚至不需要微调。

但 GPT-3 的架构相对原始，存在两个致命瓶颈：

  1. 上下文窗口固定（通常为 2K~4K）：无法处理长文档。
  2. 注意力机制的 O(N2)O(N^2) 复杂度：序列长度翻倍，计算量呈指数级增长。

第二阶段：对齐与工程优化 —— ChatGPT 的诞生

如果说 GPT-3 是一个拥有海量知识但性格古怪的“野蛮人”，那么 ChatGPT（基于 GPT-3.5）就是经过了现代文明洗礼的“学者”。这背后的核心架构演进不仅仅是神经网络结构的变化，更是训练范式的重构。

1. 从预训练到 RLHF

OpenAI 引入了人类反馈强化学习，这是大模型架构演进史上的一座里程碑。它将大模型分为了三个训练阶段：

  • SFT（监督微调）：教会模型模仿人类的问答格式。
  • RM（奖励模型）：训练一个打分器，评判模型回答的质量。
  • PPO（强化学习优化）：利用打分器作为奖励函数，优化大模型的行为。

RLHF 的核心 PPO 损失函数可以简化为：

LPPO=Ex∼D,y∼πθ[min⁡(rt(x,y)A^t,clip(rt(x,y),1−ϵ,1+ϵ)A^t)]L_{PPO} = \mathbb{E}_{x \sim D, y \sim \pi_\theta} \left[ \min \left( r_t(x,y) \hat{A}_t, \text{clip}(r_t(x,y), 1-\epsilon, 1+\epsilon) \hat{A}_t \right) \right]

(其中 rtr_t 是当前策略与旧策略的概率比，A^t\hat{A}_t 是优势函数，由奖励模型给出)

2. 底层工程优化

在实际的工程架构中，为了让庞大的 GPT-3.5 能够快速推理，OpenAI 在底层广泛采用了 FlashAttention（减少 HBM 访问次数，加速注意力计算）和 Continuous Batching（连续批处理），这些系统级的架构优化使得实时对话成为可能。

第三阶段：开源反击战 —— LLaMA 架构的教科书级重构

就在闭源模型打得不可开交时，Meta 横空出世的 LLaMA 系列给开源社区注入了强心剂。LLaMA 的架构演进意义在于：它证明了通过更优的架构设计和更高质量的数据，小参数量模型也能匹敌庞大的 GPT-3。

LLaMA 对传统的 Transformer Decoder 进行了多项关键手术：

1. Pre-normalization 与 RMSNorm

为了缓解深层网络中的梯度消失问题，LLaMA 放弃了传统的 Post-LayerNorm，采用了 Pre-normalization，并使用计算开销更小的 RMSNorm（Root Mean Square Normalization）替代标准的 LayerNorm。

1
2
3
4
5
6
7
8
9
10
11
class RMSNorm(nn.Module):
    def __init__(self, d_model, eps=1e-6):
        super().__init__()
        self.eps = eps
        self.weight = nn.Parameter(torch.ones(d_model))

    def forward(self, x):
        # 计算均方根
        norm = torch.rsqrt(torch.mean(x ** 2, -1, keepdim=True) + self.eps)
        # 仅使用缩放因子，省略了 LayerNorm 中的偏置
        return x * norm * self.weight

2. 激活函数的进化：SwiGLU

在 FFN（前馈神经网络）层，LLaMA 放弃了传统的 ReLU，采用了性能更优的 SwiGLU 激活函数。SwiGLU 引入了门控机制，虽然增加了一点参数量，但极大地提升了模型的表达能力。

1
2
3
4
5
6
7
8
9
10
class SwiGLU(nn.Module):
    def __init__(self, d_model, d_ff, bias=False):
        super().__init__()
        self.w1 = nn.Linear(d_model, d_ff, bias=bias)
        self.w2 = nn.Linear(d_ff, d_model, bias=bias)
        self.w3 = nn.Linear(d_model, d_ff, bias=bias) # SwiGLU 额外增加的权重矩阵

    def forward(self, x):
        # w1 计算 SILU 激活，w3 作为门控
        return self.w2(nn.functional.silu(self.w1(x)) * self.w3(x))

3. 位置编码的突破：RoPE (旋转位置编码)

这是 LLaMA 架构中最具革命性的一环。早期的 GPT 模型使用绝对位置编码，这种方法难以很好地泛化到训练时未见过的长序列。LLaMA 引入了苏剑林提出的 RoPE（Rotary Position Embedding）。

RoPE 的核心思想是通过在复数域的旋转，将绝对位置信息融入到 Query 和 Key 中，从而在计算点积时自然体现出相对位置信息。

RoPE 的极简代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def precompute_freqs_cis(dim: int, end: int, theta: float = 10000.0):
    # 计算频率
    freqs = 1.0 / (theta ** (torch.arange(0, dim, 2)[: (dim // 2)].float() / dim))
    t = torch.arange(end, device=freqs.device)
    freqs = torch.outer(t, freqs).float()
    # 将频率转换为复数域的旋转角度 (欧拉公式)
    freqs_cis = torch.polar(torch.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+）奠定了坚实的数学基础。

第四阶段：突破长文本与对齐极限 —— Claude 系列的崛起

如果说 LLaMA 奠定了现代开源模型的基础，那么 Anthropic 的 Claude 系列则在**“长上下文处理”和“安全对齐架构”**上走出了截然不同的道路。Claude 3 的横空出世，让人们看到了超越 GPT-4 的可能性。

1. 从 GQA 到更大上下文的跨越

在处理 100K~200K token 的超长上下文时，标准的 MHA（多头注意力）会面临严重的 KV Cache 内存墙。Claude 在底层架构上采用了 GQA (Grouped-Query Attention) 甚至进化版的 MLA (Multi-Head Latent Attention，多头潜在注意力，在 DeepSeek 等模型中也被验证)。

GQA 的核心思想：
传统的 MHA 中，每个 Query 头都有自己独立的 Key 和 Value 头。而在 GQA 中，将多个 Query 头划分为一组，共享同一个 Key 和 Value 头。这极大地压缩了推理时的 KV Cache 显存占用，使得在相同算力下，模型可以“看到”更长的文本。

1
2
3
4
5
6
7
8
9
10
11
# 伪代码演示 GQA 的逻辑
# 假设 n_heads = 32, n_kv_heads = 8 (每4个Q头共享一组KV)
q = proj_q(x) # shape: [B, T, 32, d_head]
k = proj_k(x) # shape: [B, T, 8, d_head]
v = proj_v(x) # shape: [B, T, 8, d_head]

# 扩展 KV 头以匹配 Q 头进行矩阵乘法
k = k.repeat_interleave(4, dim=2) # shape: [B, T, 32, d_head]
v = v.repeat_interleave(4, dim=2) # shape: [B, T, 32, d_head]

attn_weights = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_head)

通过结合 RoPE、GQA 以及更先进的系统级优化（如 Prompt Caching 机制），Claude 架构成功支撑起了 200K token 的上下文窗口，并且能在“大海捞针”测试中保持极高的召回率。

2. 架构层面的安全对齐：Constitutional AI (CAI)

如果说 OpenAI 的 RLHF 是依靠庞大的人类标注团队进行“填鸭式”教育，那么 Claude 的核心架构演进在于其独创的 宪法 AI（Constitutional AI，简称 CAI）。

传统的 RLHF 完全依赖人类的偏好数据，这存在两个问题：

  1. 人类偏好本身存在偏见或可能是有害的。
  2. 高质量的标注数据成本极高且面临瓶颈。

Claude 的 CAI 架构分为两个阶段，巧妙地利用了模型自身的反馈：

  • 监督学习阶段（SLF）：

    • 首先让一个经过初步预训练的模型生成可能有害的回答。
    • 然后，提供一个包含几项核心原则的“宪法”（例如：请选择最无害且最有助于用户的回答）。
    • 让模型根据宪法对自己的回答进行批评，并修改生成一个安全的回答。
    • 使用这些由模型自己根据宪法修订的优质数据对模型进行微调。

  • 强化学习阶段（RLAIF，AI 反馈强化学习）：

    • 放弃人类标注的 Reward Model。取而代之的是，让两个模型生成回答，然后让另一个 AI 根据“宪法”原则对这两个回答进行打分。
    • 利用这些 AI 生成的偏好对来训练 Reward Model，最后用 PPO 算法优化主模型。

CAI 的直觉公式：

Claude=Base LLM+SLF(Critique→Revision)+RLAIF(Constitution)\text{Claude} = \text{Base LLM} + \text{SLF} (\text{Critique} \rightarrow \text{Revision}) + \text{RLAIF} (\text{Constitution})

这种架构设计的精妙之处在于，它将对齐过程变成了一个可扩展、规则驱动的自动化系统。Claude 之所以在安全性、逻辑推理上表现卓越，并且不容易被“越狱”，正是因为它的底层训练融入了这套基于逻辑法则的反馈闭环。

第五阶段：走向未来 —— MoE 与 多模态的融合

从 GPT 到 Claude 的发展脉络中，我们还可以观察到架构演进的最新趋势，这些趋势正在定义 2024 年以后的模型标准：

1. 稀疏专家模型

无论是 GPT-4 还是 Claude 3 的某些版本，业界普遍推测它们采用了 MoE 架构。MoE 打破了传统的 Dense 模型（每次生成一个词都要激活所有参数）的限制。
在 MoE 架构中，FFN 层被替换为了多个并行的“专家网络”。一个路由机制会根据当前的输入 Token，决定只激活其中 1~2 个专家。

  • 优势：以远低于实际参数量的计算代价，获得了庞大的模型容量。

2. 原生多模态架构

早期架构是针对文本 token 设计的。如今的演进方向是统一的多模态架构。例如 Claude 3 和 GPT-4o 能够极快地响应视觉和听觉，其底层在于视觉编码器不再与 LLM 是外挂拼接的，而是将图像、音频转化为 Token，直接在 LLM 的核心 Transformer 层中与文本 Token 一起进行自注意力和 RoPE 位置编码。

总结：大模型架构演进的底层逻辑

回顾从 GPT 到 Claude 的演进史，我们可以清晰地看到几个核心的底层逻辑：

  1. 从暴力扩展到精细手术：早期人们迷信堆算力，但后来（如 LLaMA）证明，在归一化、激活函数和位置编码上进行精细修改，能极大提升参数利用率。
  2. 打破上下文瓶颈：位置编码从绝对走向相对（RoPE），注意力机制从多头走向分组共享（GQA），这些架构上的创新使得 200K 甚至更长的上下文窗口成为现实。
  3. 从人类对齐到宪法对齐：RLHF 到 RLAIF 的演进，意味着大模型正在从被动接受人类指导，转向基于规则进行自我反思和进化，这是迈向高阶智能的必经之路。

无论是 GPT 的开创性，LLaMA 的工程美学，还是 Claude 在长文本和 Constitutional AI 上的突破，大模型的架构演进史就是一部人类不断逼近通用人工智能（AGI）的折叠史。

作为开发者和技术人员，理解这些黑盒内部的架构变革，不仅能让我们在模型选型和 Prompt 工程中知其然更知其所以然，更能让我们在这个 AI 日新月异的时代，把握住技术发展的脉搏。未来的大模型架构会更加高效、智能、安全，而这出波澜壮阔的大戏，才刚刚进入高潮。