大语言模型(LLM)的本质是一个自回归的概率语言模型:给定 Token 序列,输出词表上的条件概率分布。本文从这个定义出发,拆解它的目标函数、架构、训练流程和推理工程,全文配可运行的代码。
一、目标函数:一切始于 Next-Token Prediction
设词表大小为 $|V|$,Token 序列为 $x_{1:t-1}$,语言模型建模的是:
$$P(x_t \mid x_{
其中 $h_t$ 是网络在位置 $t$ 的隐藏状态,$\theta$ 是待学习的参数。整个模型的训练目标是对语料库的负对数似然(等价于交叉熵损失):
$$\mathcal{L}(\theta) = -\sum_t \log P(x_t \mid x_{
这个目标看起来平平无奇,但注意一个关键事实:为了压低这个损失,模型被迫学会语法、事实、推理。要在 "The capital of France is ___" 后输出 "Paris",模型必须存储世界知识;要在长代码中匹配括号,模型必须学会结构化追踪。GPT-3 论文里明确展示了:损失随规模的下降曲线上,"小样本学习能力"作为副产品涌现。
用 PyTorch 写一个最小训练循环(约 30 行,这就是 LLM 预训练的骨架):
import torch
import torch.nn.functional as F
def training_step(model, batch, optimizer):
"""batch: (B, T) 的 token id 矩阵"""
x, y = batch[:, :-1], batch[:, 1:] # 输入右移一位即标签
logits = model(x) # (B, T-1, |V|)
loss = F.cross_entropy(
logits.reshape(-1, logits.size(-1)), # 展平成 (B*(T-1), |V|)
y.reshape(-1),
)
optimizer.zero_grad()
loss.backward() # 反向传播算梯度
optimizer.step() # 参数更新
return loss.item()
# 困惑度(Perplexity)= exp(loss),语言模型最通用的评价指标
# loss=2.0 → PPL≈7.4,即模型对下一个词的"有效猜测数"约7.4个
注意 x, y = batch[:, :-1], batch[:, 1:] 这一行:标签就是输入左移一位。训练信号完全免费——任何文本自己就是自己的标签。这就是为什么预训练能用"整个互联网"当数据集,不需要人工标注。
二、Tokenizer:字节对编码(BPE)
现代 LLM 的词表几乎都由 BPE(Byte-Pair Encoding)或其变体生成。算法逻辑:从字节级字符开始,反复合并语料中最高频的相邻对,直到达到目标词表大小。
一个可运行的最小 BPE 实现:
from collections import Counter
def train_bpe(corpus: str, vocab_size: int):
"""极简 BPE:空格分词(仅演示英文),返回合并规则"""
tokens = [list(w) + ["</w>"] for w in corpus.split()]
merges = {
}
for i in range(vocab_size - 256):
# 统计所有相邻 token 对的频率
pairs = Counter()
for seq in tokens:
pairs.update(zip(seq, seq[1:]))
best, freq = pairs.most_common(1)[0]
merges[best] = i
# 应用最优合并
tokens = [
merge_seq(seq, best)
for seq in tokens
]
return merges
def merge_seq(seq, pair):
out, i = [], 0
while i < len(seq):
if i < len(seq) - 1 and (seq[i], seq[i+1]) == pair:
out.append(seq[i] + seq[i+1]); i += 2
else:
out.append(seq[i]); i += 1
return out
生产级的实现(如 GPT-4o 使用的 o200k_base,词表 20 万)要复杂得多,但核心思想一致。工程上真正需要记住的是:
- 中文大约 1~2 字/Token,英文约 0.75 词/Token,这直接决定 API 计费和上下文有效长度
- 数字、生僻 Unicode、代码缩进是分词的重灾区——这是模型算术差、对空白敏感的架构级根源
- 上下文窗口长度(8K/128K/1M)指的是 Token 数,不是字符数
import tiktoken
enc = tiktoken.get_encoding("o200k_base")
print(len(enc.encode("我只需要被处理,不需要被理解")))
# 15 —— 每个 Token 对应词表中的一个整数 id
三、Transformer:只有注意力是主角
整型 Token id 先过 Embedding 查表变成向量,加上位置信息,然后流经 N 层重复的块,每层是"注意力 + 前馈网络"两个子层,各配残差连接和 LayerNorm:
$$h = h + \mathrm{Attention}(\mathrm{LN}(h)), \quad h = h + \mathrm{FFN}(\mathrm{LN}(h))$$
3.1 Scaled Dot-Product Attention
$$\mathrm{Attention}(Q, K, V) = \mathrm{softmax}\!\left(\frac{QK^\top}{\sqrt{d_k}}\right)V$$
$Q$(query)、$K$(key)、$V$(value)由同一输入经三个不同投影矩阵得到。除以 $\sqrt{d_k}$ 是因为点积方差随维度线性增长,大量纲会让 softmax 饱和、梯度消失。NumPy 版骨架:
import numpy as np
def softmax(x, axis=-1):
e = np.exp(x - x.max(axis=axis, keepdims=True))
return e / e.sum(axis=axis, keepdims=True)
def attention(Q, K, V, mask=None):
d_k = Q.shape[-1]
scores = Q @ K.swapaxes(-2, -1) / np.sqrt(d_k) # (B, H, T, T)
if mask is not None:
scores = np.where(mask, scores, -1e9) # 因果掩码
A = softmax(scores) # 注意力权重
return A @ V, A # 加权聚合
T, d = 5, 8
X = np.random.randn(T, d)
Wq, Wk, Wv = (np.random.randn(d, d) for _ in range(3))
Q, K, V = X @ Wq, X @ Wk, X @ Wv
causal_mask = np.tril(np.ones((T, T), dtype=bool)) # 下三角:只许看过去
out, A = attention(Q, K, V, causal_mask)
print(A.round(2)) # 上三角全为0 —— 未来词被掩码屏蔽
因果掩码(causal mask)是理解训练与推理一致性的关键:训练时整个序列并行计算,但每个位置只允许 attend 自己之前的 Token,否则就是在偷看答案。
3.2 多头注意力(Multi-Head)
单头注意力只有一个相似度度量。多头机制把 $d_{model}$ 维切成 $h$ 份,每头在 $dk = d{model}/h$ 维独立做注意力再拼接。不同的头在训练后自发分工:有头专管指代消解、有头追踪句法依赖、有头做位置对齐(这部分可解释性来自 Anthropic、DeepMind 的电路分析工作)。
class MultiHeadAttention:
def __init__(self, d_model, n_heads):
assert d_model % n_heads == 0
self.d_k = d_model // n_heads
self.n_heads = n_heads
self.Wq, self.Wk, self.Wv, self.Wo = (
np.random.randn(d_model, d_model) for _ in range(4))
def __call__(self, X, mask=None):
B, T, _ = X.shape
# (B, T, d_model) → 拆头 → (B, n_heads, T, d_k)
def split(x, W):
x = x @ W
return x.reshape(B, T, self.n_heads, self.d_k).transpose(0, 2, 1, 3)
Q, K, V = split(X, self.Wq), split(X, self.Wk), split(X, self.Wv)
out, _ = attention(Q, K, V, mask)
# 合头还原形状,过输出投影
out = out.transpose(0, 2, 1, 3).reshape(B, T, -1)
return out @ self.Wo
3.3 FFN:知识主要存在这里
注意力负责"搬运信息",而模型约 2/3 的参数在前馈网络(FFN)里,通常是两层 MLP 加一个非线性:
def ffn(x, W1, W2):
# 现代 LLM 普遍用 SwiGLU 替代原始 GELU 版本
return (gelu(x @ W1)) @ W2 # d_model → 4*d_model → d_model
插一句目前的主流共识:注意力层像"寻址-读取",FFN 层像 key-value 记忆库——大量探针实验表明事实性知识("巴黎是法国首都")主要编码在 FFN 的权重里。
3.4 位置编码
注意力本身是置换等变的——不打乱顺序标记,"狗咬人"和"人咬狗"没有区别。必须注入位置信息。从正弦编码到可学习编码,再到如今主流的 RoPE(旋转位置编码):把 Query/Key 在二维平面上按位置旋转,使得 $q_m \cdot k_n$ 只依赖于相对距离 $m - n$。RoPE 外推性好,是 LLaMA 系列能拉长上下文的关键组件之一。
3.5 组装一个微型 GPT
把上述组件拼起来,就是一个结构上与 GPT-2 同源的模型(Llama 系列的差异主要在:RMSNorm 替代 LayerNorm、SwiGLU 替代 GELU FFN、RoPE 替代学习式位置编码):
import torch, torch.nn as nn
class Block(nn.Module):
def __init__(self, d_model, n_heads):
super().__init__()
self.ln1, self.ln2 = nn.LayerNorm(d_model), nn.LayerNorm(d_model)
self.attn = nn.MultiheadAttention(d_model, n_heads, batch_first=True)
self.ffn = nn.Sequential(
nn.Linear(d_model, 4 * d_model), nn.GELU(),
nn.Linear(4 * d_model, d_model))
def forward(self, x, attn_mask):
a, _ = self.attn(self.ln1(x), self.ln1(x), self.ln1(x),
attn_mask=attn_mask, need_weights=False)
x = x + a # 残差
return x + self.ffn(self.ln2(x))
class MiniGPT(nn.Module):
def __init__(self, vocab_size, d_model=512, n_layers=8, n_heads=8, ctx=256):
super().__init__()
self.ctx = ctx
self.tok_emb = nn.Embedding(vocab_size, d_model)
self.pos_emb = nn.Embedding(ctx, d_model)
self.blocks = nn.ModuleList(Block(d_model, n_heads) for _ in range(n_layers))
self.ln_f = nn.LayerNorm(d_model)
self.head = nn.Linear(d_model, vocab_size, bias=False)
def forward(self, idx):
B, T = idx.shape
mask = torch.triu(torch.full((T, T), float("-inf")), diagonal=1)
x = self.tok_emb(idx) + self.pos_emb(torch.arange(T, device=idx.device))
for blk in self.blocks:
x = blk(x, mask)
return self.head(self.ln_f(x)) # (B, T, vocab_size) 未归一化 logits
四、解码策略:从概率分布到文本
模型输出的是词表上的 logits,怎么采样直接决定输出质量。常用的策略一族:
import torch
import torch.nn.functional as F
def sample_next(logits, temperature=0.8, top_k=50, top_p=0.9):
# 1. 温度缩放:调节分布熵
logits = logits / temperature
# 2. Top-k:只保留概率最高的 k 个
if top_k:
kth = torch.topk(logits, top_k).values[..., -1, None]
logits = logits.masked_fill(logits < kth, float("-inf"))
# 3. Top-p(nucleus):保留累计概率达 p 的最小集合
if top_p < 1.0:
sorted_logits, idx = torch.sort(logits, descending=True)
cum = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
drop = cum - F.softmax(sorted_logits, dim=-1) > top_p
logits[idx[drop]] = float("-inf")
# 4. 归一化后按概率采样
return torch.multinomial(F.softmax(logits, dim=-1), 1)
| 策略 | 行为 | 适用 |
|---|---|---|
| Greedy(argmax) | 永远选最优 | 确定性任务,但易重复 |
| Temperature | 缩放整个分布 | 创造性任务调高,代码任务调低 |
| Top-k | 截断长尾 | 防止极低概率词污染输出 |
| Top-p | 动态截断 | 候选数随分布形状自适应 |
推理时逐 Token 生成还有一个工程现实:每生成一个 Token,都要对整个前缀重新计算注意力。KV Cache 的思路是把每层的 K、V 缓存下来,每步只算最新一个 Token 的 QKV,把每步复杂度从 $O(t^2)$ 降到 $O(t)$:
# vLLM / llama.cpp 这类推理框架的核心就是高效 KV Cache 管理
# 代价:显存占用 ∝ 2 × layers × heads × d_k × seq_len × batch × bytes
# 7B 模型、4K 上下文、fp16,KV Cache 约 2GB —— 这就是长上下文贵的原因
由此也能立刻推出几个工程事实:显存是长上下文的硬约束、Prompt 前缀相同可复用 KV(prefix caching)、批处理是吞吐的关键。
五、训练流水线:Pretrain → SFT → RLHF/RLAIF
预训练:上述交叉熵目标 + 万亿级 Token + 数千卡集群。训练本身是个系统工程:数据清洗与去重(质量比数量重要)、混合数据配比(代码数据显著提升推理能力)、分布式并行(数据并行 + 张量并行 + 流水线并行)、检查点容错。前沿模型单次预训练成本以千万美元计。
监督微调(SFT):几十万条人工写的(指令, 回复)对,依然用同一个交叉熵损失——只是数据从"任意网页文本"换成了"指令对话格式"。损失通常只计算在回复部分,避免浪费容量在复述指令上。
对齐(RLHF / DPO):这一步解决的问题是"什么是好的回复"难以写成可微的损失函数。经典 RLHF 流程:
- 收集人类偏好数据(同一 prompt 的两个回复,人标注哪个更好)
- 训练奖励模型(Reward Model)模仿人类打分
- 用 PPO 等强化学习算法优化策略模型,使奖励最大化,同时用 KL 散度惩罚防止模型漂移过远
# RLHF 的目标函数(简化形式)
def rlhf_objective(response, reward_model, ref_model, beta=0.1):
r = reward_model(response) # 人类偏好代理
kl = KL(policy(response) || ref_model(response)) # 别把语言能力跑崩了
return r - beta * kl
DPO(Direct Preference Optimization)是后来的简化:跳过显式的奖励模型,直接从偏好对导出一个闭式分类损失,训练稳定性好、成本低,已成为开源社区对齐的默认选项。
测试时扩展(Test-time Compute):o1/o3、DeepSeek-R1 这一代模型的新变量——不再只堆训练算力,而是在推理时生成长思维链并用 RL 训练,用"想得更久"换"答得更准"。这把 Scaling Law 从训练时扩展到了推理时。
六、幻觉与评测
幻觉的机理可以直接从目标函数推出:模型被训练去最大化 $\log P(xt \mid x{<t})$,即"似然",而用户要的是"真值"。二者在训练数据可靠时高度相关,在长尾知识上彻底脱钩——模型会用高概率的"论文体文本"续写一篇不存在的论文。这不是 bug,是目标的错位。
缓解手段与其原理一一对应:
- RAG:把外部检索结果放进上下文,把"从参数里回忆"改造成"从上下文里抄写"——后者对 Transformer 是分布内任务,可靠得多
- logprobs 监控:低置信度输出触发拒答或人工复核
- 自一致性(Self-Consistency):同一问题采样多次投票,降低单次采样噪声
评测方面,单选准确率(MMLU 风格)已不足以刻画能力,主流转向:竞争性编程(LiveCodeBench)、研究生级推理(GPQA)、长上下文检索(RULER)、以及最难防止污染的——人类偏好盲测(Chatbot Arena 的 Elo 评分)。
七、小结
用一张表收束全文:
| 组件 | 解决的问题 | 代表技术 |
|---|---|---|
| BPE Tokenizer | 文本 → 整数序列 | 字节级 BPE |
| Embedding + RoPE | 序列 → 向量 + 位置 | 旋转位置编码 |
| Multi-Head Attention | 上下文信息路由 | GQA / FlashAttention |
| FFN | 知识存储 | SwiGLU |
| 交叉熵预训练 | 从数据中学习语言与世界 | Scaling Law |
| SFT + RLHF/DPO | 从续写器到助手 | PPO, DPO, RLVR |
| 解码与 KV Cache | 概率 → 文本,工程提速 | Top-p, vLLM/PagedAttention |
剥掉所有工程外壳,LLM 就是:在互联网语料上最小化下一个 Token 交叉熵的自回归 Transformer,再用对齐技术把"统计续写"扭转成"遵循指令"。理解了这一点,它的能力边界、失效模式和改进方向,都可以从第一性原理推导出来。