从 GPT 到 Claude：万字解码主流大语言模型架构演进史

Posted on In

引言：超越“炼丹”，大模型背后的硬核架构

自 ChatGPT 横空出世以来，大语言模型（LLM）已经从实验室走向了千行百业。我们在惊叹 AI 能够写诗、写代码、做推理的同时，往往容易忽略支撑这些神奇表现的底层基石——模型架构。

在很多人看来，大模型的训练就像是“炼丹”，只要数据够多、算力够大，丢进一个黑盒子里就能跑出奇迹。然而，现实并非如此。从 2017 年 Transformer 的提出，到 GPT 系列的“大力出奇迹”，再到如今以 Claude 3、GLM 为代表的架构创新与工程优化，大模型的底层架构正在经历一场极其精密且快速的演化。

本文将带你拨开迷雾，深入剖析从 GPT 到 Claude 等主流大模型的架构演进史。我们将探讨那些关键的架构创新（如 RoPE、SwiGLU、MoE、GQA），并通过实际的代码片段，让你直观感受这些改变世界的技术细节。

一、一切的起源：Transformer 与它的“偏科”

2017 年，Google 发表了那篇著名的《Attention Is All You Need》，正式提出了 Transformer 架构。这是大模型时代的滥觞。

原始的 Transformer 采用的是 Encoder-Decoder（编码器-解码器） 架构：

  • Encoder（编码器）：负责阅读输入文本，提取特征，生成隐藏状态。它是双向的，能同时看到上下文。
  • Decoder（解码器）：负责根据编码器的输出逐字生成结果。它是**单向（自回归）**的，只能看到当前词和历史词，不能“偷看”未来。

随着研究的深入，大模型的发展出现了三个截然不同的“流派”：

  1. Encoder-only 流派（以 BERT 为代表）：只保留了编码器。极其适合文本分类、信息抽取等“理解型”任务，但在开放式文本生成上表现不佳。
  2. Encoder-Decoder 流派（以 T5、BART 为代表）：保留了原始结构，适合翻译、摘要等 Sequence-to-Sequence 任务。
  3. Decoder-only 流派（以 GPT、Claude、LLaMA 为代表）：大模型时代的绝对王者。研究者们发现，只要参数量足够大、数据足够多，单向的 Decoder 在进行 Next-token Prediction（预测下一个词）时，不仅学会了生成，也涌现出了极强的理解能力。

自此，Decoder-only 成为了主流大模型的标准形态。

二、GPT 王朝：大力出奇迹与标准 Decoder 的确立

OpenAI 的 GPT 系列是 Decoder-only 路线的坚定践行者。从 GPT-1 到 GPT-3，甚至传闻中的 GPT-4（尽管可能引入了 MoE），其核心架构始终围绕着因果解码器。

核心机制：自回归与因果掩码

GPT 的核心思想非常简单：给定前面的词 x1,x2,...,xt−1x_1, x_2, ..., x_{t-1}，预测下一个词 xtx_t 的概率。

为了防止模型在训练时“看到”未来的词，GPT 在自注意力计算时引入了因果掩码。这是一个典型的下三角矩阵。

代码示例：PyTorch 实现 GPT 的因果掩码

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
41
import torch
import torch.nn as nn

class CausalSelfAttention(nn.Module):
    def __init__(self, embed_dim, num_heads, max_seq_len):
        super().__init__()
        self.num_heads = num_heads
        self.head_dim = embed_dim // num_heads
        
        self.qkv_proj = nn.Linear(embed_dim, 3 * embed_dim)
        self.o_proj = nn.Linear(embed_dim, embed_dim)
        
        # 注册因果掩码（下三角矩阵）
        # 1 表示允许关注，0 表示屏蔽
        mask = torch.tril(torch.ones(max_seq_len, max_seq_len)).view(1, 1, max_seq_len, max_seq_len)
        self.register_buffer("mask", mask)

    def forward(self, x):
        B, T, C = x.size() # Batch, Sequence Length, Embedding Dim
        
        # 计算 Q, K, V
        qkv = self.qkv_proj(x)
        q, k, v = qkv.chunk(3, dim=-1)
        
        # 重塑为多头形状
        q = q.view(B, T, self.num_heads, self.head_dim).transpose(1, 2)
        k = k.view(B, T, self.num_heads, self.head_dim).transpose(1, 2)
        v = v.view(B, T, self.num_heads, self.head_dim).transpose(1, 2)

        # 计算注意力分数
        attn_weights = torch.matmul(q, k.transpose(-2, -1)) / (self.head_dim ** 0.5)
        
        # 【关键】应用因果掩码，将未来词的注意力分数设为负无穷，Softmax后变为0
        attn_weights = attn_weights.masked_fill(self.mask[:, :, :T, :T] == 0, float('-inf'))
        
        attn_weights = torch.softmax(attn_weights, dim=-1)
        
        # 输出
        out = torch.matmul(attn_weights, v)
        out = out.transpose(1, 2).contiguous().view(B, T, C)
        return self.o_proj(out)

GPT 系列证明了一个深刻的道理：架构的简洁性加上海量的数据，能产生惊人的智能涌现。 但这并不意味着架构无需演进。随着模型参数突破百亿、千亿，以及上下文窗口的急剧扩大，传统的 Transformer 架构遇到了算力和显存的墙。

三、开源界的曙光：LLaMA 引爆的架构微调革命

如果说 OpenAI 是摸黑前进的探险家，那么 Meta 推出的 LLaMA 系列则是照亮开源大模型夜空的灯塔。LLaMA 并没有发明全新的架构，而是把原有 Transformer 的每一个组件都做到了极致的工程优化。

现代主流大模型（包括后来的 Mistral, Qwen, 以及传闻中 Claude 的底层设计）几乎全部采用了 LLaMA 架构。它的核心改进有三点：RoPE、SwiGLU 和 RMSNorm。

1. 位置编码的进化：从绝对到相对

由于自注意力机制本身是“无视距离”的（词与词之间没有位置概念），必须注入位置信息。早期的 GPT 使用绝对位置编码，但这会导致模型难以外推（训练时长度为 2K，推理时无法直接支持 4K）。

LLaMA 引入了 RoPE（旋转位置编码，Rotary Position Embedding）。其核心思想是通过在复数域的旋转，将词的绝对位置信息融入到 Query 和 Key 中，从而巧妙地利用了向量内积的相对性。

代码示例：RoPE 的简化实现

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
import torch
import torch.nn as nn
import math

class RotaryEmbedding(nn.Module):
    def __init__(self, dim, max_seq_len=2048):
        super().__init__()
        # 计算旋转角度的频率
        inv_freq = 1.0 / (10000 ** (torch.arange(0, dim, 2).float() / dim))
        self.register_buffer("inv_freq", inv_freq)
        
        # 预计算 cos 和 sin 缓存
        t = torch.arange(max_seq_len).type_as(self.inv_freq)
        freqs = torch.outer(t, self.inv_freq)
        emb = torch.cat((freqs, freqs), dim=-1)
        self.register_buffer("cos_cached", emb.cos()[None, None, :, :])
        self.register_buffer("sin_cached", emb.sin()[None, None, :, :])

    def forward(self, x, seq_len):
        return (
            self.cos_cached[:, :, :seq_len, :],
            self.sin_cached[:, :, :seq_len, :]
        )

def apply_rotary_emb(x, cos, sin):
    # x: [Batch, Num_Heads, Seq_Len, Head_Dim]
    d = x.shape[-1] // 2
    x1, x2 = x[..., :d], x[..., d:]
    # 旋转矩阵的等价变换
    return torch.cat((x1 * cos[..., :d] - x2 * sin[..., :d], 
                      x2 * cos[..., :d] + x1 * sin[..., :d]), dim=-1)

RoPE 最大的优势是优秀的长度外推性，这为后来 Claude 和 GPT-4 支持高达 100K~200K 的超长上下文奠定了数学基础。

2. 激活函数的升级：SwiGLU

在传统的 Transformer 中，前馈神经网络（FFN）通常使用 ReLU 激活函数。LLaMA 将其替换为了 SwiGLU。

SwiGLU 引入了门控机制和 Swish 函数，不仅带来了更平滑的梯度传播，还在实验中表现出比 ReLU 更好的模型性能。其计算公式为：

SwiGLU(x,W,V,b)=(Swish(xW+b)⊗(xV+c))\text{SwiGLU}(x, W, V, b) = (\text{Swish}(xW + b) \otimes (xV + c))

3. 归一化的演进：RMSNorm

为了稳定深层网络的训练，GPT 使用了 LayerNorm。但 LayerNorm 需要计算均值和方差，计算开销较大。LLaMA 采用了 RMSNorm（均方根归一化）。它去除了均值计算，只计算均方根，在保持训练稳定性的同时，显著提升了计算效率。

四、Claude 与混合专家模型：突破参数扩展的极限

当我们谈论 Claude 3 或 GPT-4 时，我们面对的是能够处理极其复杂逻辑、参数量可能达到万亿级别的庞然大物。如果继续使用 LLaMA 那种 Dense（稠密）模型，即每一个 Token 的生成都需要激活模型所有的参数，那么推理成本将是天文数字。

为了解决“模型越大越聪明”与“推理太贵跑不动”的矛盾，架构演进走向了 MoE（Mixture of Experts，混合专家模型）。这也是 Claude 等现代顶级大模型在架构上的一次巨大飞跃。

MoE 架构的核心思想

MoE 的灵感来源于人类社会分工。它将原本庞大的 FFN 层拆分成多个独立的“专家网络”，并增加一个“路由机制”。

当输入一个 Token 时，路由网络（通常是一个极小的线性层加上 Softmax）会决定将这个 Token 发送给哪几个（通常是 Top-2）最擅长的专家进行处理。这样，虽然模型的总参数量极大（比如 1.8 万亿），但在实际推理时，每个 Token 只激活其中的一小部分参数（比如几百亿），从而大幅降低延迟和推理成本。

避免“专家坍塌”：负载均衡的挑战

MoE 架构在实际训练中有一个致命问题：Route Collapse（路由坍塌）。由于网络具有正反馈机制，模型很快就会学会把所有的 Token 都路由给同一个或少数几个“ favored experts”（受青睐的专家），导致其他专家得不到训练，最终退化成一个巨大的普通稠密模型。

为了解决这个问题，现代大模型（如 Mistral 8x7B，以及 Claude 背后类似的架构理念）引入了辅助损失函数，用于惩罚专家之间的负载不均衡。

代码示例：MoE 路由与辅助 Loss 计算

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
41
import torch
import torch.nn as nn
import torch.nn.functional as F

class MoERouter(nn.Module):
    def __init__(self, embed_dim, num_experts, top_k=2):
        super().__init__()
        self.num_experts = num_experts
        self.top_k = top_k
        self.gate_proj = nn.Linear(embed_dim, num_experts, bias=False)

    def forward(self, x):
        # x: [Batch * Seq_len, Embed_dim]
        logits = self.gate_proj(x) # [B*T, num_experts]
        
        # 计算每个专家被选中的概率
        probs = F.softmax(logits, dim=-1)
        
        # 选取概率最高的 Top-K 个专家
        top_k_probs, top_k_indices = torch.topk(probs, self.top_k, dim=-1)
        
        # 重新归一化被选中专家的权重
        top_k_probs = top_k_probs / top_k_probs.sum(dim=-1, keepdim=True)
        
        # 【核心工程细节】计算辅助损失以保证负载均衡
        # f_i: 每个专家被选中的频率
        # P_i: 每个专家获得的平均路由概率
        # Auxiliary Loss = alpha * N * sum(f_i * P_i)
        
        # 计算平均概率 P_i
        mean_probs = probs.mean(dim=0) 
        
        # 计算被选中的频率 f_i (近似计算)
        # 创建一个 one-hot 矩阵表示哪些专家被选中
        mask = torch.zeros_like(probs).scatter_(1, top_k_indices, 1.0)
        frequency = mask.mean(dim=0)
        
        # 辅助损失 (假设 alpha = 0.01)
        aux_loss = 0.01 * self.num_experts * torch.sum(frequency * mean_probs)
        
        return top_k_indices, top_k_probs, aux_loss

正是得益于 MoE 这种精巧的架构设计，像 Claude 3 这样的模型才能在保持极速响应的同时，展现出逼近甚至超越人类专家的知识储备与推理深度。

五、从 4K 到 200K：超长上下文背后的工程奇迹

在 GPT-3 时代，4K 的上下文窗口是常态。但今天，Claude 3 已经支持高达 200K 的上下文（甚至实验中达到 100 万），这也是它能够在一分钟内读完整本《红楼梦》并给出总结的关键。

支持超长上下文，不仅仅是简单地增加 RoPE 的长度。如果粗暴地将序列长度从 4K 扩大到 200K，其计算复杂度和显存占用（主要是 KV Cache）将呈平方级爆炸。

1. 注意力机制的终极优化：FlashAttention

为了解决算力瓶颈，Stanford 提出了 FlashAttention 系列算法。这虽然不是模型结构上的改变，但却是现代大模型工程架构中不可或缺的一环。

传统的 Attention 计算由于受到 GPU 内存层级（SRAM 与 HBM 之间频繁的数据拷贝）的限制，存在严重的 IO 瓶颈。FlashAttention 通过分块计算和内核融合技术，避免了将巨大的 N×NN \times N 注意力矩阵写回显存，直接在 GPU 极速但微小的 SRAM 中完成计算，从而实现了 2-4 倍的加速。

2. 显存保卫战：GQA 与 MQA

在推理阶段，生成每一个 Token 都需要用到之前所有 Token 的 Key 和 Value 矩阵（即 KV Cache）。在多头发注意力（MHA）中，每个头都有一套独立的 KV，在长文本下极易导致显存溢出（OOM）。

现代主流架构（包括 LLaMA-2/3, Claude 等）采用了 GQA（Grouped-Query Attention） 或 MQA（Multi-Query Attention）。

  • MHA：每个 Head 独享 Q, K, V。
  • MQA：所有的 Head 共享一套 K, V，只有 Q 是独立的。极大地节省了显存，但可能轻微损失精度。
  • GQA：折中方案。将 Heads 分组，同一组内的 Heads 共享一套 K, V。

通过 GQA，大模型在超长文本推理时，其 KV Cache 占用的显存体积骤减，使得 200K 甚至更长的上下文推理在单张或少量 GPU 上成为可能。

六、从“对话”到“对齐”：架构之外的灵魂（RLHF）

如果仅仅看底层结构，哪怕是 Claude 和 GPT，其核心依然是自回归的 Transformer。那为什么 Claude 会以“安全、无害、乐于助人”且具有极高的指令遵循能力而著称呢？

这就涉及到大模型架构中最后，也是最神秘的一块拼图：对齐训练。

预训练出来的基座模型（Base Model，如原始的 LLaMA）只是一个“文字接龙”机器，它没有自我意识，也不知道如何与人对话。为了让它变成 Claude 这样的助手，需要经历基于人类反馈的强化学习（RLHF）或更新的 DPO（直接偏好优化）算法。

在此过程中，我们需要一个额外的架构：奖励模型。这是一种基于 Transformer 顶层加上一个标量输出头的网络，它学习了人类的偏好。当大模型生成回答时，RM 会给回答打分，然后大模型根据这个分数去调整自己的参数，以生成更符合人类期望的内容。

虽然 RLHF 不属于前向传播的基础拓扑结构，但它已经成为现代大模型发布前必不可少的“灵魂注入”步骤。

七、总结：大模型架构的未来走向何方？

回顾从 GPT 到 Claude 的架构演进，我们可以清晰地看到一条技术脉络：

  1. 拓扑结构的收敛：学术界经历了种种尝试后，工业界最终一致收敛于 Decoder-only 架构，证明了极简主义结合大数据的威力。
  2. 极致的工程优化：从 RoPE 到 SwiGLU，再到 GQA，模型结构上的每一处微调，都是在“榨干” GPU 的最后一滴算力。
  3. 稀疏性与效率：MoE 架构的广泛应用，打破了 Scaling Law 中的算力枷锁，使得万亿参数模型的日常推理成为现实。

展望未来，大模型架构将走向何方？

  • 超越纯注意力机制：基于状态空间模型的 Mamba 等架构正在崛起，试图以线性复杂度取代 Transformer 的平方级复杂度，为无限上下文推理提供新的解法。
  • 端侧架构的微型化：随着苹果、高通入局，大模型架构正在向异构计算、量化（如 4-bit, 2-bit 推理）和端侧低功耗架构演进。

大模型的竞争依然在加速。从 GPT-4 到 Claude 3，再到未来的未知模型，每一次智能的涌现，背后都是无数工程师在矩阵乘法、显存带宽和梯度曲线上进行的最极致的架构雕琢。理解这些架构，不仅能让我们更好地使用这些工具，更能让我们看透 AI 发展的底层逻辑。