AI 八股:大模型基础知识

Last updated on November 9, 2026 pm

本文用于整理大语言模型训练与推理中的基础知识、常见方法及其背后的原理,并持续补充相关内容。

一、Tokenization 与 Causal Language Model

大语言模型并不能直接接收字符串。对于一段原始文本,需要先经过下面的过程:

1
2
3
4
5
6
7
原始文本
→ Tokenizer
→ Tokens
→ Token IDs
→ Embedding Vectors
→ Transformer
→ Next-token Logits

这一章先说明文本如何变成模型输入,再介绍 Decoder-only Language Model 如何通过 Next-token Prediction 进行训练。

1.1 Token、Vocabulary 与 Token ID

模型为什么不能直接处理文本?

计算机中的字符串最终虽然也以数字形式存储,但字符的 Unicode 编码只表示“这是哪个字符”,并不是适合神经网络学习的语义表示。例如,字符“猫”的 Unicode 编码和字符“狗”的 Unicode 编码之间的数值距离,并不表示二者在语义上有多相似。

神经网络真正处理的是具有固定 Shape 的数值 Tensor。因此,文本进入模型前需要经过两个步骤:

  1. Tokenizer 将字符串切分为离散的 Tokens;
  2. 模型再根据每个 Token 的 ID 查找对应的可学习 Embedding Vector。

Token 是什么?

Token 是 Tokenizer 处理文本时使用的基本离散单位。现代 LLM 通常采用 Subword Tokenization,因此一个普通 Token 可能对应:

  • 一个高频的完整单词或汉字;
  • 一个词的一部分,即 Subword;
  • 标点符号、空格或其他常见字符串;
  • <bos>、<eos> 等人为加入的 Special Token。

例如,假设某个简单 Tokenizer 将文本:

1
unbelievable!

切分成:

1
["un", "believ", "able", "!"]

那么这个句子包含 4 个 Tokens。这里只是为了说明概念;真实切分结果由具体 Tokenizer 的 Vocabulary 和分词算法决定,同一段文本使用不同 Tokenizer 时可能得到完全不同的结果。

Vocabulary 与 Token ID

Vocabulary,记作:

V,\mathcal V,

是 Tokenizer 能够表示的全部 Tokens 的集合,其大小记作:

V=∣V∣.V=|\mathcal V|.

Tokenizer 会为 Vocabulary 中的每个 Token 分配唯一的整数编号,这个编号就是 Token ID。Token ID 的取值范围是 00 到 V−1V-1。

例如,一个教学用 Vocabulary 可以是:

1
2
3
4
5
6
7
0 → <pad>
1 → <bos>
2 → <eos>
3 → un
4 → believ
5 → able
6 → !

使用这个 Vocabulary,完整编码过程是:

1
2
3
"unbelievable!"
→ ["un", "believ", "able", "!"]
→ [3, 4, 5, 6]

其中 "able" 是 Token,5 是它的 Token ID。模型真正接收的是最后的整数序列。

如果一段文本被切成 TT 个 Tokens,它对应的 Token ID Sequence 可以记作:

x=(x1,x2,…,xT),x=(x_1,x_2,\ldots,x_T),

其中 xtx_t 表示第 tt 个位置上的 Token ID。

Token ID 只是查表索引,本身没有大小或距离上的语义。例如,ID 为 4 的 Token 不代表它在语义上比 ID 为 3 的 Token“更大”。

常见 Special Tokens

Vocabulary 中通常还包含一些特殊 Tokens:

  • <bos>:Beginning of Sequence,表示序列开始;
  • <eos>:End of Sequence,表示序列结束;
  • <pad>:Padding,用于将 Batch 中不同长度的序列补成相同长度;
  • <unk>:Unknown Token,表示 Vocabulary 无法直接表示的内容;
  • Chat Template 使用的角色或边界 Tokens,例如 System、User、Assistant 的起止标记。

并不是每个模型都会同时使用以上所有 Special Tokens。

Token ID 如何变成向量?

Token ID 只是整数索引,不能直接表示语义。模型内部包含一个可学习的 Embedding Matrix:

E∈RV×D.E\in\mathbb R^{V\times D}.

其中 VV 是 Vocabulary Size,DD 是 Hidden Size。Token ID 为 xtx_t 时,模型取出矩阵的第 xtx_t 行:

Ext,:∈RD.E_{x_t,:}\in\mathbb R^D.

这就是该 Token 对应的 DD 维 Embedding Vector。

同一个 Batch 中,不同文本经过 Tokenization 后的长度通常不同,但 Tensor 需要具有规则的矩形 Shape。因此,组成普通 Batch 时,会使用 <pad> 将较短序列补到当前 Batch 中最长序列的 Token Length。这些补齐位置不属于真实文本,后续会通过相应的 Mask 避免它们参与有效 Attention 或 Loss。设 Batch Size 为 BB、Padding 后的 Sequence Length 为 TT,那么 Shape 变化是:

1
2
3
Token IDs: [B, T]
→ Embedding
Embedding Vectors: [B, T, D]

Embedding Matrix EE 是模型参数,会在训练中更新;Token IDs 只是查表使用的整数索引,不是可学习参数。

1.2 为什么现代 LLM 使用 Subword Tokenization?

现代 LLM 通常使用 Subword Tokenization。它不要求一个 Token 必须是完整单词或单个字符,而是允许使用大小不同、可以重复组合的字符串片段。例如,"replaying" 可以被切成 "re"、"play" 和 "ing"。具体为什么采用这种方式,下面继续说明。

为什么不直接按单词或字符切分?

最直接的文本切分方式是按单词或按字符切分,但二者都有明显问题。

按单词切分

如果每个完整单词对应一个 Token:

  • Vocabulary 会非常大;
  • 新出现的人名、术语、拼写变化可能不在 Vocabulary 中;
  • "play"、"playing"、"played" 会被当成彼此无关的 Tokens,难以复用词根信息;
  • 多语言场景下 Vocabulary 膨胀更加明显。
只按字符或单个字节切分

字符或字节的集合较小,也很少出现无法表示的输入,但:

  • 同一段文本会被切成更多 Tokens;
  • Sequence Length 增加,使训练和推理成本上升;
  • 模型需要用更多层计算自行组合局部字符,才能形成词或语义单位。
Subword 的折中

Subword Tokenization 同时保留常见词和可组合的词片段:

  • 高频字符串可以直接成为一个 Token,缩短序列;
  • 低频词可以拆成多个已知 Subwords;
  • Vocabulary 不需要包含所有可能出现的完整单词;
  • 不同词可以共享词根、前缀和后缀。

因此,Tokenizer 实际上在两个目标之间做权衡:

1
2
3
4
5
6
7
Vocabulary 越大
→ 常见文本使用的 Tokens 可能越少
→ Embedding 和 Output Head 的参数量越大

Vocabulary 越小
→ Embedding 和 Output Head 更小
→ 同一段文本通常会产生更长的 Token Sequence

1.3 BPE 如何训练和编码?

现代 LLM 主要使用哪些分词算法?

当前主流 Decoder-only LLM 基本采用 BPE 系列:通过反复合并高频相邻单位构造 Vocabulary,实际通常采用 Byte-level BPE。Qwen3、DeepSeek-V3/R1、LLaMA 4、Kimi K2 和 Gemma 3 都属于这条路线。

Unigram Language Model 是另一种成熟的 Subword 算法,T5/mT5 是经典代表,目前仍用于部分多语言、小型或专用模型,但不是当前主流 Decoder-only 基座模型的主要选择。因此,本节只重点介绍 BPE。

BPE 的核心思想

BPE(Byte Pair Encoding)的核心思想是:

从很小的基础单位开始,反复把语料中最常一起出现的相邻单位合并成一个新 Token。

训练开始时,每个单词可以先拆成字符。随着合并不断进行,常见字符组合会逐渐变成更长的 Subwords。

从训练语料学习 Merge Rules

假设训练语料为:

1
2
3
4
low_:    出现 5 次
lowest_: 出现 2 次
newer_: 出现 3 次
wider_: 出现 6 次

这里使用 _ 表示 Word End。初始时,每个单词被拆成单个字符:

1
2
3
4
low_    → l o w _
lowest_ → l o w e s t _
newer_ → n e w e r _
wider_ → w i d e r _

初始 Token Vocabulary 为:

1
{l, o, w, e, s, t, n, r, i, d, _}

然后重复以下过程:

  1. 统计所有相邻 Token Pair 的出现次数;
  2. 找到出现次数最多的 Pair;
  3. 将这个 Pair 在所有单词中合并成一个新 Token;
  4. 将新 Token 加入 Vocabulary,并记录本次 Merge Rule;
  5. 重复以上步骤,直到达到设定的 Merge 次数或 Vocabulary Size。

统计 Pair 时需要乘上单词频次。这个例子中:

  • ("r", "_") 在 "newer_" 和 "wider_" 中分别出现 3 次和 6 次,总频次为 9;
  • ("e", "r") 的总频次也是 9;
  • ("l", "o") 和 ("o", "w") 的总频次都是 7。

当多个 Pair 并列最高频时,实际选择哪一个取决于具体实现。下面的 Python 代码使用 Counter.most_common(1),并列时选择统计过程中更早遇到的 Pair。

四轮合并过程为:

1
2
3
4
第 1 轮:e + r  → er,频次为 9
第 2 轮:er + _ → er_,频次为 9
第 3 轮:l + o → lo,频次为 7
第 4 轮:lo + w → low,频次为 7

因此新产生的 Tokens 为:

1
{er, er_, lo, low}

每轮合并产生一个新 Token,所以最终 Vocabulary Size 为:

11+4=15.11+4=15.

手写一个最小 BPE Trainer

下面的实现使用字符作为初始单位,只保留 BPE 的核心逻辑:

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
from collections import Counter


# 单词及其在训练语料中的出现次数
corpus = {
"low_": 5,
"lowest_": 2,
"newer_": 3,
"wider_": 6,
}

# 当前每个单词被切成哪些 Tokens
word_splits = {
tuple(word): freq
for word, freq in corpus.items()
}

# 初始 Token Vocabulary:所有不同的单字符
token_vocab = {
symbol
for symbols in word_splits
for symbol in symbols
}

print("initial token vocab:", sorted(token_vocab))
# initial token vocab: ['_', 'd', 'e', 'i', 'l', 'n', 'o', 'r', 's', 't', 'w']


def count_pairs(word_splits):
"""统计所有相邻 Token Pair 的加权频次。"""
pair_counts = Counter()

for symbols, word_freq in word_splits.items():
# zip(symbols, symbols[1:]) 枚举所有相邻 Pair
for pair in zip(symbols, symbols[1:]):
pair_counts[pair] += word_freq

return pair_counts


def merge_symbols(symbols, target_pair):
"""把一个 Token Sequence 中的目标 Pair 合并。"""
result = []
i = 0

while i < len(symbols):
if (
i + 1 < len(symbols)
and (symbols[i], symbols[i + 1]) == target_pair
):
# 例如 ("e", "r") 合并成 "er"
result.append(symbols[i] + symbols[i + 1])
i += 2
else:
result.append(symbols[i])
i += 1

return tuple(result)


def apply_merge(word_splits, target_pair):
"""在所有单词的当前切分结果中应用 Merge Rule。"""
return {
merge_symbols(symbols, target_pair): word_freq
for symbols, word_freq in word_splits.items()
}


num_merges = 4
merge_rules = []

for step in range(num_merges):
pair_counts = count_pairs(word_splits)
max_count = max(pair_counts.values())
tied_pairs = sorted(
pair
for pair, count in pair_counts.items()
if count == max_count
)

# 并列时,Counter 会返回统计过程中更早遇到的 Pair
best_pair, _ = pair_counts.most_common(1)[0]
new_token = "".join(best_pair)

print(
f"step {step + 1}: count={max_count}, "
f"tied={tied_pairs}, merge={best_pair} -> {new_token}"
)

merge_rules.append(best_pair)
token_vocab.add(new_token)
word_splits = apply_merge(word_splits, best_pair)

# step 1: count=9, tied=[('e', 'r'), ('r', '_')], merge=('e', 'r') -> er
# step 2: count=9, tied=[('er', '_')], merge=('er', '_') -> er_
# step 3: count=7, tied=[('l', 'o'), ('o', 'w')], merge=('l', 'o') -> lo
# step 4: count=7, tied=[('lo', 'w')], merge=('lo', 'w') -> low

print("final word splits:", word_splits)
# final word splits: {
# ('low', '_'): 5,
# ('low', 'e', 's', 't', '_'): 2,
# ('n', 'e', 'w', 'er_'): 3,
# ('w', 'i', 'd', 'er_'): 6
# }

print("final token vocab:", sorted(token_vocab))
# final token vocab:
# ['_', 'd', 'e', 'er', 'er_', 'i', 'l', 'lo',
# 'low', 'n', 'o', 'r', 's', 't', 'w']

print("vocab size:", len(token_vocab))
# vocab size: 15

BPE 训练完成后会得到:

  1. 最终 Vocabulary;
  2. 按训练顺序排列的 Merge Rules。

如何使用 Merge Rules 编码新文本?

编码新单词时,先把它拆成与训练阶段相同的基础单位,再按照学到的 Merge Rules 依次进行合并:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def encode_word(word, merge_rules):
"""使用训练得到的 Merge Rules 编码一个单词。"""
# 编码时使用与训练阶段相同的 Word End 标记
symbols = tuple(word) + ("_",)

for pair in merge_rules:
symbols = merge_symbols(symbols, pair)

return symbols


print("lower:", encode_word("lower", merge_rules))
# lower: ('low', 'er_')

print("lowest:", encode_word("lowest", merge_rules))
# lowest: ('low', 'e', 's', 't', '_')

虽然训练语料中没有 "lower",但它仍然可以由已经学到的 "low" 和 "er_" 组成。这就是 Subword 可以表示未完整收录单词的原因。

需要注意,BPE 根据统计频次学习 Merge Rules,并不真正理解词根或语义。它可能学到类似 "play"、"ing" 的直观词片段,也可能学到只是在训练语料中频繁出现、但没有独立语义的字符串。

Byte-level BPE 与上述示例有什么区别?

上面的教学实现从字符开始训练。Byte-level BPE 的合并过程基本相同,区别是初始单位变成 UTF-8 Bytes:

1
2
字符级 BPE:Character → Merge → Subword
Byte-level BPE:UTF-8 Byte → Merge → Byte Sequence Token

Bytes 只有 256 种可能取值,因此任意文本都能先表示成字节序列,再使用相同的 BPE 思路进行合并。实际 LLM Tokenizer 还需要确定空格、换行、Unicode 和 Special Tokens 的处理方式。

1.4 Tokenizer 在什么阶段训练?

Tokenizer 通常在 LLM 预训练开始前训练。训练语料一般来自预训练语料的代表性样本,需要覆盖模型将要处理的主要语言和领域,例如网页、书籍、百科、论文、代码和数学文本等。训练 Tokenizer 主要依赖字符串频次统计,通常不需要遍历完整的预训练语料,但抽样分布应尽量接近最终训练数据。

Tokenizer 训练完成后,会确定:

  1. Vocabulary 及其大小 VV;
  2. Token 与 Token ID 的映射;
  3. BPE Merge Rules 或其他分词规则;
  4. 文本预处理方式;
  5. Special Tokens。

模型预训练开始以后,Tokenizer 通常保持不变。因为预训练数据已经按照这套规则转换成 Token IDs,模型的 Embedding Matrix 和 Output Head 也按照 Vocabulary Size 创建,并逐渐学习了每个 Token ID 对应的含义。此时直接更换 Tokenizer,会使原来的 Token-ID 映射与模型参数错位。

SFT、Preference Optimization 和 RL 后训练通常继续使用预训练阶段的 Tokenizer。某些 Chat、Tool-use 或多模态版本会在原 Vocabulary 末尾追加少量 Special Tokens;此时需要同步扩展 Embedding Matrix 和 Output Head,并训练新增的参数行,同时保持已有 Token IDs 不变。

同一代模型的不同参数规模通常会共享 Tokenizer,但同系列模型跨代时可能重新设计 Tokenizer。反过来,不同系列的模型也可能复用同一套 Tokenizer。因此,是否相同应以实际 Tokenizer 配置和 Token-ID 映射为准。

1.5 Embedding 是如何学习的?

Tokenizer 只负责把文本转换成 Token IDs,并不会直接提供每个 Token 的语义。模型内部使用可学习的 Embedding Matrix:

E∈RV×D,E\in\mathbb R^{V\times D},

其中:

  • VV:Vocabulary Size;
  • DD:Hidden Size;
  • i∈{0,…,V−1}i\in\{0,\ldots,V-1\}:一个 Token ID;
  • Ei,:∈RDE_{i,:}\in\mathbb R^D:Embedding Matrix 的第 ii 行,也就是 Token ID 为 ii 时查到的 Embedding Vector。

设一个 Batch 的 Token IDs 为:

Xids=(xb,t)∈{0,…,V−1}B×T,X_{\mathrm{ids}} = (x_{b,t}) \in \{0,\ldots,V-1\}^{B\times T},

其中:

  • BB:Batch Size,样本下标为 1≤b≤B1\leq b\leq B;
  • TT:Padding 后的 Sequence Length,位置下标为 1≤t≤T1\leq t\leq T;
  • xb,tx_{b,t}:第 bb 个样本中第 tt 个位置的 Token ID。

对每个 Token ID 查找 Embedding Matrix 中对应的行,得到:

X(0)∈RB×T×D,Xb,t,:(0)=Exb,t,:.X^{(0)} \in \mathbb R^{B\times T\times D}, \qquad X^{(0)}_{b,t,:} = E_{x_{b,t},:}.

这里,Xb,t,:(0)∈RDX^{(0)}_{b,t,:}\in\mathbb R^D 是第 bb 个样本中第 tt 个 Token 的 Embedding Vector;X(0)X^{(0)} 是整个 Batch 进入第一个 Transformer Block 前的初始 Token Representations。

Embedding Matrix 的参数如何更新?

Embedding Matrix 一开始通常是随机初始化的。预训练时,模型根据前文预测下一个 Token,并计算 Cross Entropy Loss。反向传播会把 Loss 的梯度依次传过:

1
2
3
4
Loss
→ LM Head
→ Transformer Blocks
→ Embedding Matrix

因此,出现在当前 Batch 中的 Token 对应的 Embedding Rows 会收到梯度并被 Optimizer 更新。大量语料训练之后,经常出现在相似上下文中的 Tokens 会逐渐学到对模型有用的表示。

需要区分两种向量:

  1. Token Embedding:查表得到的初始向量 Exb,t,:E_{x_{b,t},:}。相同 Token ID 查到的是同一行参数;
  2. Contextual Hidden State:经过 Transformer 后得到的向量 Hb,t,:H_{b,t,:}。它融合了当前 Token 之前的上下文,因此同一个 Token 出现在不同句子中时,Hb,t,:H_{b,t,:} 通常不同。

例如,两个位置都出现同一个 Token ID 时,它们最初查到相同的 Token Embedding;但经过 Causal Self-Attention 后,因为可见的前文不同,最终 Hidden States 可以完全不同。

下面用一个最小例子观察 Embedding 的 Shape,以及哪些参数行获得了梯度:

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


torch.manual_seed(0)

vocab_size = 8
hidden_size = 4
embedding = nn.Embedding(vocab_size, hidden_size)

input_ids = torch.tensor([
[1, 3, 5],
[1, 4, 5],
]) # Shape: (B=2, T=3)

token_embeddings = embedding(input_ids)
print("embedding shape:", token_embeddings.shape)
# embedding shape: torch.Size([2, 3, 4])

# 这里只用求和构造一个便于观察梯度的标量。
# 真正训练 LLM 时,梯度来自 Next-token Cross Entropy Loss。
loss = token_embeddings.sum()
loss.backward()

rows_with_grad = (
embedding.weight.grad.abs().sum(dim=-1) > 0
).nonzero().squeeze(-1)

print("token ids with gradients:", rows_with_grad)
# token ids with gradients: tensor([1, 3, 4, 5])

没有出现在这个 Batch 中的 Token 不会直接通过本次 Embedding Lookup 获得梯度;它们会在后续包含这些 Token 的 Batch 中更新。

Input Embedding 与 LM Head

最后一个 Transformer Block 输出:

H∈RB×T×D.H\in\mathbb R^{B\times T\times D}.

为了预测 Vocabulary 中每个 Token 的分数,需要使用 LM Head 将 Hidden Dimension 投影到 Vocabulary Dimension:

Z=HWoutT,Z=HW_{\mathrm{out}}^{T},

其中:

Wout∈RV×D,Z∈RB×T×V.W_{\mathrm{out}}\in\mathbb R^{V\times D}, \qquad Z\in\mathbb R^{B\times T\times V}.

Zb,t,vZ_{b,t,v} 是第 bb 个样本在位置 tt 对 Vocabulary 中第 vv 个 Token 给出的 Logit。Logit 是未经归一化的分数,还不是概率。

许多 LLM 会采用 Weight Tying:

Wout=E.W_{\mathrm{out}}=E.

也就是 Input Embedding 和 Output LM Head 共享同一个 V×DV\times D 参数矩阵。输入侧使用它把 Token ID 映射成向量,输出侧使用它比较 Hidden State 与每个 Token 表示的匹配程度。这样既能减少参数量,也能让输入和输出使用同一套 Token 表示空间。

1.6 Causal Language Model 如何训练?

Next-token Prediction

为了说明单个序列的 Next-token Prediction,下面暂时省略 Batch 下标 bb。给定:

x=(x1,x2,…,xT),x=(x_1,x_2,\ldots,x_T),

其中 xtx_t 是位置 tt 的 Token ID,x1x_1 可以是 <bos>,xTx_T 可以是 <eos>。Causal Language Model 在位置 tt 读取:

x≤t=(x1,…,xt),x_{\leq t}=(x_1,\ldots,x_t),

并预测下一个 Token xt+1x_{t+1}。因此,在给定第一个 Token x1x_1 后,后续序列的条件概率可以分解为:

pθ(x2,…,xT∣x1)=∏t=1T−1pθ(xt+1∣x≤t).p_\theta(x_2,\ldots,x_T\mid x_1) = \prod_{t=1}^{T-1} p_\theta(x_{t+1}\mid x_{\leq t}).

这里:

  • θ\theta:模型所有可学习参数;
  • x≤tx_{\leq t}:位置 tt 及其左侧的 Tokens,也是当前位置可见的上下文;
  • pθ(xt+1∣x≤t)p_\theta(x_{t+1}\mid x_{\leq t}):模型根据该上下文预测真实下一个 Token 的概率。

模型的训练任务就是:在每个位置根据左侧上下文,预测右边紧邻的下一个 Token。例如:

1
2
3
4
5
输入上下文              预测目标
<bos> → I
<bos> I → love
<bos> I love → AI
<bos> I love AI → <eos>

为什么需要 Causal Mask?

训练时,Transformer 会一次接收完整序列。如果不作限制,位置 tt 就可能读取右侧的 xt+1x_{t+1},然后直接用已经看见的答案预测 xt+1x_{t+1},训练目标就失去了意义。

因此,Causal Language Model 使用 Causal Mask,规定位置 tt 只能读取位置 11 到 tt,不能读取任何位置 s>ts>t。定义可见性矩阵:

C∈{0,1}T×T,Ct,s={1,s≤t,0,s>t,C\in\{0,1\}^{T\times T}, \qquad C_{t,s} = \begin{cases} 1,&s\leq t,\\ 0,&s>t, \end{cases}

其中:

  • tt:当前正在计算的 Token 位置;
  • ss:它准备读取的 Token 位置;
  • Ct,s=1C_{t,s}=1:位置 tt 可以读取位置 ss;
  • Ct,s=0C_{t,s}=0:位置 tt 不能读取位置 ss。

当 T=5T=5 时,可见关系是一个下三角矩阵:

1
2
3
4
5
6
7
             被读取的位置 s
1 2 3 4 5
当前位置 1 1 0 0 0 0
当前位置 2 1 1 0 0 0
当前位置 3 1 1 1 0 0
当前位置 4 1 1 1 1 0
当前位置 5 1 1 1 1 1

例如,位置 3 可以读取 x1,x2,x3x_1,x_2,x_3,但不能读取 x4,x5x_4,x_5。Causal Mask 在 Self-Attention 内部具体如何生效,会在下一章讲 Attention 时展开;这里先记住它保证了每个位置只能使用左侧上下文。

Teacher Forcing 为什么可以并行训练?

有了 Causal Mask,训练时就可以把完整序列一次送进 Transformer,再把预测位置和目标位置错开一位:

1
2
3
完整序列:          [<bos>, I,    love, AI,    <eos>]
用于预测的位置: [<bos>, I, love, AI]
对应的 Labels: [I, love, AI, <eos>]

Causal Mask 保证位置 tt 只能看到 x≤tx_{\leq t}。虽然所有位置在同一次 Forward 中进行计算,但每个位置使用的上下文仍然符合 Next-token Prediction 的要求。

一次 Forward 会先得到完整 Logits:

Z∈RB×T×V.Z\in\mathbb R^{B\times T\times V}.

其中最后一个位置没有位于当前序列内的下一个 Token 作为 Label。因此,计算 Loss 时只使用前 T−1T-1 个位置的 Logits:

Zpred∈RB×(T−1)×V,Zb,t,:pred=Zb,t,:,1≤t<T.Z^{\mathrm{pred}} \in \mathbb R^{B\times (T-1)\times V}, \qquad Z^{\mathrm{pred}}_{b,t,:} = Z_{b,t,:}, \quad 1\leq t<T.

这种训练方式也称为 Teacher Forcing:预测每个位置时,模型看到的历史 Tokens 来自真实训练文本,而不是模型自己此前生成的结果。

训练和生成的区别是:

1
2
3
4
5
6
7
8
训练:
整段真实 Tokens 一次输入
→ 使用 Causal Mask 并行预测所有下一个 Token

生成:
只有 Prompt 和已经生成的 Tokens
→ 每次采样一个新 Token
→ 把新 Token 接到上下文末尾继续生成

生成时不存在后续的真实 Tokens,所以仍然需要自回归地逐 Token Decoding。

1.7 Logits、Log Probability、Cross Entropy 与 Perplexity

从 Logits 得到概率

恢复 Batch 下标。设完整 Logits 为 Z∈RB×T×VZ\in\mathbb R^{B\times T\times V},第 bb 个样本在位置 tt 输出的 Logit Vector 为:

zb,t=Zb,t,:∈RV,z_{b,t} = Z_{b,t,:} \in\mathbb R^V,

其中 zb,t,vz_{b,t,v} 是 Vocabulary 中第 vv 个 Token 的 Logit。通过 Softmax 得到:

pθ(v∣xb,≤t)=exp⁡(zb,t,v)∑j=0V−1exp⁡(zb,t,j).p_\theta(v\mid x_{b,\leq t}) = \frac{\exp(z_{b,t,v})} {\sum_{j=0}^{V-1}\exp(z_{b,t,j})}.

这里:

  • xb,≤t=(xb,1,…,xb,t)x_{b,\leq t}=(x_{b,1},\ldots,x_{b,t}):第 bb 个样本在位置 tt 能够看到的上下文;
  • v∈{0,…,V−1}v\in\{0,\ldots,V-1\}:一个候选 Token ID。

Softmax 后,Vocabulary 中所有候选 Tokens 的概率都非负且总和为 1。

Token 与 Sequence Log Probability

模型在位置 tt 分配给真实下一个 Token 的概率为:

pθ(xb,t+1∣xb,≤t).p_\theta(x_{b,t+1}\mid x_{b,\leq t}).

对它取自然对数,就得到该 Token 的 Log Probability:

log⁡pθ(xb,t+1∣xb,≤t).\log p_\theta(x_{b,t+1}\mid x_{b,\leq t}).

因为概率位于 (0,1](0,1],所以 Log Probability 不大于 00。模型给真实 Token 的概率越高,它越接近 00;概率越低,它就越负。

根据概率的 Chain Rule,一段序列的条件概率等于每一步条件概率的乘积。对于 xb=(xb,1,…,xb,T)x_b=(x_{b,1},\ldots,x_{b,T}):

pθ(xb,2:T∣xb,1)=∏t=1T−1pθ(xb,t+1∣xb,≤t).p_\theta(x_{b,2:T}\mid x_{b,1}) = \prod_{t=1}^{T-1} p_\theta(x_{b,t+1}\mid x_{b,\leq t}).

取对数后,乘积会变成求和:

log⁡pθ(xb,2:T∣xb,1)=∑t=1T−1log⁡pθ(xb,t+1∣xb,≤t).\log p_\theta(x_{b,2:T}\mid x_{b,1}) = \sum_{t=1}^{T-1} \log p_\theta(x_{b,t+1}\mid x_{b,\leq t}).

右侧就是这段文本的 Sequence Log Probability。实际计算使用 Log Probability 求和,而不直接连乘概率,因为大量小概率连乘很容易发生数值下溢。

同理,给定 Prompt xx 和生成的 Response y=(y1,…,yN)y=(y_1,\ldots,y_N):

log⁡pθ(y∣x)=∑i=1Nlog⁡pθ(yi∣x,y<i).\log p_\theta(y\mid x) = \sum_{i=1}^{N} \log p_\theta(y_i\mid x,y_{<i}).

这个量会用于候选序列排序、Beam Search、DPO 和 RL 等任务。但直接比较不同长度序列的 Log Probability 并不公平:每一项通常都小于或等于 00,序列越长,累加结果往往越负。因此比较不同长度的序列时,通常还要使用平均 Log Probability 或 Length Penalty:

1Nlog⁡pθ(y∣x).\frac{1}{N} \log p_\theta(y\mid x).

这里需要区分:

  • Token Log Probability:某一个已选 Token 的对数概率;
  • Sequence Log Probability:所有已选 Tokens 的 Log Probability 之和;
  • 平均 Log Probability:Sequence Log Probability 除以有效 Token 数,用于减弱长度影响。

Cross Entropy Loss

训练时优化的目标,就是让真实下一个 Token 的概率尽可能高。位置 tt 真正的下一个 Token 是 xb,t+1x_{b,t+1},因此单个位置的 Cross Entropy Loss 就是该 Token Log Probability 的相反数:

ℓb,t=−log⁡pθ(xb,t+1∣xb,≤t).\ell_{b,t} = -\log p_\theta(x_{b,t+1}\mid x_{b,\leq t}).

模型给正确 Token 的概率越高,Loss 越小。例如:

1
2
正确 Token 概率为 0.8 → Loss = -log(0.8),较小
正确 Token 概率为 0.1 → Loss = -log(0.1),较大

先假设 Batch 中的所有序列长度都为 TT,暂时不考虑 Padding。每个样本可以产生 T−1T-1 个 Next-token Prediction,因此整个 Batch 共有 B(T−1)B(T-1) 个预测。对这些位置的 Loss 取平均:

LCLM=−1B(T−1)∑b=1B∑t=1T−1log⁡pθ(xb,t+1∣xb,≤t),\mathcal L_{\mathrm{CLM}} = -\frac{1}{B(T-1)} \sum_{b=1}^{B} \sum_{t=1}^{T-1} \log p_\theta \left( x_{b,t+1}\mid x_{b,\leq t} \right),

其中:

  • b∈{1,…,B}b\in\{1,\ldots,B\}:样本下标;
  • t∈{1,…,T−1}t\in\{1,\ldots,T-1\}:用于预测下一个 Token 的位置;
  • xb,t+1x_{b,t+1}:第 bb 个样本中当前位置要预测的下一个 Token。

实际组成 Batch 时存在 Padding,并不是所有 B(T−1)B(T-1) 个位置都具有真实 Label。我们将在下一节说明如何排除这些位置。

如何在 Tensor 中对齐预测与 Label?

上面的 Loss 公式规定:位置 tt 的输出预测 xb,t+1x_{b,t+1},而不是预测当前位置已经输入模型的 xb,tx_{b,t}。代码实现需要把这组对应关系落实到 Logits 和 Labels 上。

模型接收完整的 Token IDs:

input_ids∈NB×T,\text{input\_ids}\in\mathbb N^{B\times T},

并在每个输入位置输出一组 Vocabulary Logits:

logits∈RB×T×V,\text{logits}\in\mathbb R^{B\times T\times V},

对于一个序列,二者应当按照下面的方式配对:

1
2
3
4
完整 Input IDs: [<bos>, I,    love, AI,    <eos>]
用于计算 Loss: [<bos>, I, love, AI]
↓ ↓ ↓ ↓
对应 Labels: [I, love, AI, <eos>]

因此:

  • Logits 只保留前 T−1T-1 个位置,因为最后一个位置没有对应的下一个 Token Label;
  • Labels 从第二个 Token ID x2x_2 开始,因为第一个 Token ID x1x_1 前面没有对应的 Logits;
  • 这样,第 tt 个位置的 Logit 就与第 t+1t+1 个 Token ID 一一对应。

数学公式中的位置从 11 到 TT 编号;下面的 PyTorch Tensor 下标从 00 到 T−1T-1 编号,所以二者表达的是同一组预测关系:

1
2
shift_logits = logits[:, :-1, :]  # 位置 0 到 T-2 的预测
shift_labels = input_ids[:, 1:] # 位置 1 到 T-1 的真实 Token

Shape 变化为:

1
2
shift_logits: [B, T - 1, V]
shift_labels: [B, T - 1]

这种将 Logits 和 Labels 错开一个位置的操作称为 Label Shift。它不是额外的训练技巧,而是前面

xb,≤t⟶xb,t+1x_{b,\leq t} \longrightarrow x_{b,t+1}

这一 Next-token Prediction 关系在 Tensor 中的直接实现。完整序列仍然一次送入模型,Shift 只发生在计算 Loss 前的 Logits 与 Labels 对齐阶段。

Perplexity

上面的 Causal LM Loss 就是平均负对数概率:

LCLM=−1N∑i=1Nlog⁡qi,\mathcal L_{\mathrm{CLM}} = -\frac{1}{N} \sum_{i=1}^{N} \log q_i,

其中 NN 是有效预测位置数,qiq_i 是模型在第 ii 个位置分配给真实下一个 Token 的概率。这个数值不容易直观解释,因此评测中通常再报告它的指数形式,即 Perplexity(PPL,困惑度):

PPL⁡=exp⁡(LCLM)=exp⁡(−1N∑i=1Nlog⁡qi).\operatorname{PPL} = \exp\left(\mathcal L_{\mathrm{CLM}}\right) = \exp\left( -\frac{1}{N} \sum_{i=1}^{N} \log q_i \right).

它回答的是:

给定前文时,模型对真实下一个 Token 有多不确定?

把指数和对数展开后,也可以写成真实 Token 概率的几何平均数的倒数:

PPL⁡=1∏i=1NqiN.\operatorname{PPL} = \frac{1}{ \sqrt[N]{ \prod_{i=1}^{N}q_i } }.

因此,PPL、平均 Log Probability 和 Cross Entropy 是同一件事的三种写法:

1
2
3
4
平均 Log Probability 越高
→ Cross Entropy 越低
→ Perplexity 越低
→ 模型对真实下一个 Token 越确定

例如平均 Loss 为 log⁡10\log 10 时:

PPL⁡=exp⁡(log⁡10)=10.\operatorname{PPL} = \exp(\log 10) =10.

可以粗略理解为:模型在每个位置的不确定程度相当于在 10 个候选之间选择。但这只是直觉,不能把 PPL 严格解释成模型实际只考虑了 10 个 Tokens。

PPL 常用于观察预训练是否正常收敛,或者比较模型在同一份 Held-out Text 上的 Next-token Prediction 能力。它不直接等于问答正确率、指令遵循能力或生成质量。

比较 PPL 时还需要使用相同的数据、Tokenizer 和 Loss 统计方式。不同 Tokenizer 会把同一段文本切成不同数量的 Tokens,因此不同模型报告的 Token-level PPL 不一定能直接横向比较。

1.8 Padding 与三种 Mask

组成 Batch 时,不同文本的 Token Length 通常不同,需要使用 <pad> 补齐到当前 Batch 的最大长度。例如:

1
2
样本 1:[<bos>, I,  love, AI,    <eos>]
样本 2:[<bos>, Hi, <eos>, <pad>, <pad>]

对应的有效位置标记可以写成:

1
2
样本 1:[1, 1, 1, 1, 1]
样本 2:[1, 1, 1, 0, 0]

这个 Tensor 通常记作:

A∈{0,1}B×T,A\in\{0,1\}^{B\times T},

其中 Ab,t=1A_{b,t}=1 表示真实 Token,Ab,t=0A_{b,t}=0 表示 Padding。训练 Causal LM 时,要区分三种 Mask:

  1. Causal Mask:不允许当前位置看到未来 Tokens;
  2. Padding Mask:不让模型把 <pad> 当成有效上下文,通常直接使用上面的 AA;
  3. Loss Mask:决定哪些目标 Tokens 参与 Loss 平均,也常由同一个 AA 构造。

Causal Mask 与 Padding Mask 作用在 Attention 上,共同决定当前位置可以读取哪些 Tokens;二者通常组合使用。Loss Mask 作用在 Cross Entropy 上,决定哪些位置产生训练目标。即使 Attention 已经忽略了 Padding,如果仍然把 Padding 当作 Label,模型还是会被错误地训练去预测 <pad>。

Logits 本身通常不需要再单独 Mask。Attention 侧的 Mask 已经决定了每个位置的表示怎么算出来,进而影响 Logits;Loss 侧的 Mask 则决定哪些位置的 Logits 参与训练。Padding 位置仍然会算出一组 Logits,只是不把它们计入 Loss。

Padding 位置为什么不能参与 Loss?

预训练通常希望预测所有真实文本 Tokens:

1
2
Text Tokens:          [<bos>, A, B, C, <eos>]
参与 Loss 的 Targets: A, B, C, <eos>

<pad> 只是为了把 Tensor 补成相同 Shape,并不是真实文本。如果把它当作目标计算 Loss,模型就会被错误地训练去预测 Padding。因此,Padding 对应的目标位置必须通过 Loss Mask 排除。

PyTorch 的 F.cross_entropy 支持把不参与 Loss 的 Label 设为 -100。下面实现一个忽略 Padding 位置的 Causal LM 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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
import math

import torch
import torch.nn.functional as F


def causal_lm_loss(
logits,
input_ids,
attention_mask,
):
"""
logits: (B, T, V),模型在每个位置输出的 Vocabulary Logits
input_ids: (B, T),Padding 后的 Token IDs
attention_mask: (B, T),真实 Token 为 1,Padding 为 0
"""
# 第 t 个位置的 Logits 预测第 t+1 个 Token。
shift_logits = logits[:, :-1, :] # (B, T - 1, V)
shift_labels = input_ids[:, 1:].clone() # (B, T - 1)

# Label 对应的是原序列的位置 1 到 T-1,
# 因此 Mask 也必须采用相同的 Shift。
valid_mask = attention_mask[:, 1:].bool()

# 有效 Label 就是 Token ID,取值在 [0, V-1]。
# Padding 位置改成 -100:这不是词表编号,只是“跳过该位置”的标记。
shift_labels[~valid_mask] = -100

# cross_entropy 期望:
# 预测:(N, V),每个样本一行 Vocabulary Logits
# 标签:(N,),每个样本一个真实 Token ID
# 因此先把 (B, T-1, ...) 展平成 N = B*(T-1) 个预测位置。
# ignore_index=-100 表示 Label 为 -100 的位置不参与 Loss。
loss = F.cross_entropy(
shift_logits.reshape(-1, shift_logits.size(-1)), # (B*(T-1), V)
shift_labels.reshape(-1), # (B*(T-1),)
ignore_index=-100,
)
return loss, shift_labels


input_ids = torch.tensor([
[1, 3, 4, 2, 0],
[1, 5, 2, 0, 0],
])
attention_mask = torch.tensor([
[1, 1, 1, 1, 0],
[1, 1, 1, 0, 0],
])

B, T = input_ids.shape
V = 6

# 为了让输出容易验证,令所有 Logits 都为 0。
# 此时 Softmax 是均匀分布,每个有效目标的概率都是 1 / V。
logits = torch.zeros(B, T, V)

loss, labels = causal_lm_loss(
logits,
input_ids,
attention_mask,
)

print("shift labels:")
print(labels)
# tensor([
# [ 3, 4, 2, -100],
# [ 5, 2, -100, -100]
# ])

print("valid target count:", (labels != -100).sum().item())
# valid target count: 5

print("loss:", round(loss.item(), 4))
# loss: 1.7918,即 log(6)

print("perplexity:", round(math.exp(loss.item()), 4))
# perplexity: 6.0

这个例子也说明:模型输入包含 TT 个 Tokens 时,通常只能构造 T−1T-1 个“当前位置预测下一个位置”的训练目标;其中目标为 Padding 的位置还要通过 Loss Mask 排除。

1.9 生成时如何选择下一个 Token?

训练阶段通过 Teacher Forcing 同时预测所有位置;生成阶段没有后续的真实 Tokens,只能重复执行:

1
2
3
4
5
输入 Prompt
→ 模型输出最后一个位置的 Vocabulary Logits
→ 根据解码策略选择下一个 Token
→ 将新 Token 接到上下文末尾
→ 继续 Forward,直到生成 <eos> 或达到长度上限

Training、Prefill 与 Decode

Training 和 Inference 都会执行模型 Forward,但数据流和计算方式不同。

Training 时,模型一次接收完整训练序列,在 Causal Mask 约束下并行计算所有位置的 Logits,再计算 Loss 并反向传播:

1
2
3
4
完整训练序列
→ 一次 Forward 得到所有位置的 Logits
→ Label Shift + Loss
→ Backward 更新参数

Inference 不需要反向传播,可以分成两个阶段:

  1. Prefill:一次处理 Prompt 中的所有 Tokens,得到最后一个位置的 Logits,同时为各层建立 Prompt 的 KV Cache;
  2. Decode:根据 Logits 选出新 Token,此后每一步只输入最新 Token,并复用历史 KV Cache,逐 Token 生成。
1
2
3
4
5
6
7
Prompt Tokens
→ Prefill
→ 建立 Prompt KV Cache + 输出第一个待生成位置的 Logits
→ 选择新 Token
→ Decode:输入新 Token + 复用 KV Cache
→ 输出下一位置的 Logits
→ 重复 Decode,直到停止

Prefill 能并行处理 Prompt 的所有位置,但 Full Attention 仍需处理 Prompt 内的大量 Query-Key Pairs;Decode 每步只处理一个新 Token,却必须反复读取不断增长的 KV Cache。

设当前解码位置的 Logits 为 z∈RVz\in\mathbb R^V。模型只负责输出 Logits,最终选择哪个 Token,由下面的解码策略决定。

Greedy Decoding

Greedy 每一步都选择 Logit 最大的 Token:

yt=arg⁡max⁡vzv.y_t = \arg\max_{v} z_v.

它的优点是简单、速度快、结果确定;缺点是只保留当前一步的最优选择,不能保证整段序列的联合概率最高,也缺少生成多样性。

Greedy 常用于需要可复现结果的评测、分类式回答或结构化任务。需要注意,Greedy 是“每一步取最大值”,不是对完整序列做全局搜索。

Temperature Sampling

Sampling 先把 Logits 转换成概率分布,再从中随机采样。Temperature τ>0\tau>0 用来控制分布的平滑程度:

pτ(v)=exp⁡(zv/τ)∑j=0V−1exp⁡(zj/τ).p_\tau(v) = \frac{\exp(z_v/\tau)} {\sum_{j=0}^{V-1}\exp(z_j/\tau)}.

  • τ=1\tau=1:保持原始 Softmax 分布;
  • 0<τ<10<\tau<1:分布更尖锐,更偏向高概率 Tokens;
  • τ>1\tau>1:分布更平坦,随机性更强。

Temperature 不会直接删除任何候选,只会改变候选之间的相对概率。温度过低容易使输出过于固定,过高则可能生成低概率、低质量内容。

Top-k Sampling

Top-k 只保留 Logit 最高的 kk 个候选,把其余候选概率设为 00,再在保留的候选中重新归一化并采样。

它能避免从长尾的低概率 Tokens 中采样,但 kk 是固定的:无论当前分布非常确定还是非常分散,都保留相同数量的候选。

Top-p Sampling

Top-p 也称 Nucleus Sampling。先按概率从高到低排序,再选择累计概率达到或超过阈值 pp 的最小候选集合,最后在这个集合内重新归一化并采样。

例如:

1
2
3
候选概率:[0.50, 0.25, 0.15, 0.06, 0.04]
top_p = 0.80
保留集合:[0.50, 0.25, 0.15]

前两个候选的累计概率只有 0.750.75,加入第三个后达到 0.900.90,因此保留前三个。

与 Top-k 相比,Top-p 的候选数量会随分布变化:

  • 模型非常确定时,只保留少数 Tokens;
  • 模型不确定时,自动保留更多 Tokens。

Beam Search 不在每一步只保留一个前缀,而是保留得分最高的 KK 条候选序列。每一步分别扩展这些序列,再从所有新候选中选出新的 Top-KK。

候选序列的基础得分通常是 Sequence Log Probability:

s(y)=∑t=1∣y∣log⁡pθ(yt∣x,y<t).s(y) = \sum_{t=1}^{|y|} \log p_\theta(y_t\mid x,y_{<t}).

由于原始 Log Probability 会偏向较短序列,实际还常加入 Length Penalty。Beam Search 的搜索范围比 Greedy 更大,但需要同时维护多条序列,计算和显存开销也随 Beam Size 增长。

Beam Search 适合机器翻译、摘要等输出空间相对受约束、希望寻找高概率完整序列的任务。对于开放式对话和创作,它容易产生相似、保守的候选,因此不是现代 Chat LLM 最常用的默认解码方式。

现代 LLM 最常用哪一种?

不存在适合所有任务的固定策略。现代开放式文本生成通常使用:

1
2
3
4
Temperature
→ Top-k(可选)
→ Top-p
→ 从过滤后的概率分布中采样

更多场景只启用 Temperature + Top-p;如果 Top-k 和 Top-p 同时启用,常见实现会像下面的代码一样先用 Top-k 限制候选数量,再在这些候选中应用 Top-p。不同推理框架的具体实现可能不同,因此实际参数和处理顺序应以模型的 Generation Config 与所用框架为准。

如果任务更强调稳定、可复现和严格格式,通常使用 Greedy、极低随机性设置或约束解码;Beam Search 现在更多用于翻译、摘要等受约束生成,而不是通用 Chat。

下面实现一个最小的 Greedy、Temperature、Top-k 和 Top-p 解码函数:

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
import torch
import torch.nn.functional as F


def select_next_token(
logits,
temperature=1.0,
top_k=None,
top_p=None,
do_sample=True,
):
"""
logits: (B, V),当前解码位置的 Vocabulary Logits
返回: (B, 1),选中的 Token IDs
"""
if not do_sample:
return logits.argmax(dim=-1, keepdim=True)

if temperature <= 0:
raise ValueError("Sampling 时 temperature 必须大于 0")

# 对应公式中的 z / temperature;
# exp 和归一化由后面的 softmax 完成。
filtered_logits = logits / temperature

if top_k is not None:
k = min(top_k, filtered_logits.size(-1))
# topk(...).values 的 Shape 是 (B, k),并按从大到小排列。
# [:, -1:] 取每行最后一个,也就是第 k 大的 Logit;
# 保留维度得到 (B, 1),方便与 (B, V) 广播比较。
threshold = torch.topk(filtered_logits, k, dim=-1).values[:, -1:]
filtered_logits = filtered_logits.masked_fill(
filtered_logits < threshold,
float("-inf"),
)

if top_p is not None:
# 两个 Tensor 的 Shape 都是 (B, V):
# sorted_logits[b, r] 是第 b 个样本中排名第 r 的 Logit;
# sorted_indices[b, r] 是这个 Logit 在原 Vocabulary 中的 Token ID。
sorted_logits, sorted_indices = torch.sort(
filtered_logits,
descending=True,
dim=-1,
)
sorted_probs = F.softmax(sorted_logits, dim=-1)
cumulative_probs = sorted_probs.cumsum(dim=-1)

# sorted_remove: (B, V),按概率从高到低排列的删除标记;
# True 表示该排名对应的 Token 应被删除。
# cumulative_probs > top_p 会连同第一个跨过阈值的 Token 一起标为 True,
# 因此将标记整体右移一位,让这个 Token 保留下来。
sorted_remove = cumulative_probs > top_p
sorted_remove[:, 1:] = sorted_remove[:, :-1].clone()
sorted_remove[:, 0] = False

# sorted_remove 按“概率从高到低”的顺序排列,
# 但 filtered_logits 仍按原始 Token ID 排列。
# scatter_ 将删除标记放回对应的原始 Token ID 位置。
remove_mask = torch.zeros_like(sorted_remove, dtype=torch.bool)
remove_mask.scatter_(
dim=1,
index=sorted_indices,
src=sorted_remove,
)
filtered_logits = filtered_logits.masked_fill(
remove_mask,
float("-inf"),
)

probs = F.softmax(filtered_logits, dim=-1)
return torch.multinomial(probs, num_samples=1)

其中,Greedy 直接执行 argmax;Sampling 则依次调整 Temperature、应用 Top-k 和 Top-p,最后通过 torch.multinomial 按概率抽取一个 Token。

1.10 本章小结

从原始文本到 Causal LM 训练的一条完整链路是:

1
2
3
4
5
6
7
8
9
10
原始文本
→ Tokenizer
→ Tokens 与 Token IDs
→ Padding 组成 Batch
→ Embedding Lookup:[B, T] → [B, T, D]
→ Decoder-only Transformer
→ LM Head:[B, T, D] → [B, T, V]
→ Label Shift
→ 对有效目标 Tokens 计算 Cross Entropy
→ 反向传播更新 Embedding、Transformer 和 LM Head

其中:

  • Tokenizer 在预训练前确定离散切分规则,预训练期间通常保持不变;
  • Embedding Matrix 是模型参数,会通过 Next-token Loss 学习;
  • Causal Mask 保证每个位置只能使用左侧上下文;
  • Teacher Forcing 让训练时所有位置可以并行预测;
  • Label Shift 将位置 tt 的 Logits 与位置 t+1t+1 的真实 Token 对齐;
  • 训练时区分三种 Mask:Causal / Padding 作用于 Attention,Loss Mask 作用于训练目标;
  • Sequence Log Probability 等于各 Token Log Probability 之和,比较不同长度序列时需要考虑长度影响;
  • Cross Entropy 是平均 Log Probability 的相反数,Perplexity 是它的指数,三者描述的是同一件事。
  • 推理分为 Prefill 和 Decode:Prefill 并行处理 Prompt 并建立 KV Cache,Decode 复用 Cache 逐 Token 生成;
  • 生成时常用 Temperature + Top-p Sampling;Greedy 适合确定性任务,Beam Search 更适合受约束的序列生成。

二、Decoder-only Transformer

当前主流生成式 LLM 的主干通常采用 Decoder-only Transformer。上一章已经说明了 Token IDs 如何经过 Embedding 变成 Hidden States,以及模型如何通过 Next-token Prediction 训练;本章进一步拆解主干网络,说明每个 Decoder Block 如何更新 Token 表示。

Embedding 输出的 Hidden States 会依次经过多个 Decoder Blocks。以 RMSNorm、RoPE、GQA 和 SwiGLU 组成的常见结构为例,完整主干是:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Token Embedding
→ [RMSNorm
→ Q/K/V Projection + Split Heads
→ RoPE(Q, K)
→ GQA 中的 K/V Head 共享
→ Scaled Dot-product Attention + Causal/Padding Mask
→ Output Projection
→ Residual Connection
→ RMSNorm
→ SwiGLU
→ Residual Connection] × N
→ Final RMSNorm
→ LM Head
→ Vocabulary Logits

这是一套具有代表性的现代结构,但不是唯一方案。不同模型可能使用 LayerNorm 或 QK-Norm,采用其他位置编码,以 MHA、MQA 或 MLA 替代 GQA,或者使用 GELU FFN、其他 Gated FFN 与 MoE。本章先掌握上面的基础主干;MoE、MLA、QK-Norm 和长上下文 RoPE 等变体放到后续现代 LLM 架构部分。

下面按照模型 Forward 的组成逐步学习 RMSNorm、Q/K/V 与 RoPE、Scaled Dot-product Attention、MHA/MQA/GQA、SwiGLU、Pre-Norm 与 Residual Connection,最后把它们组装成一个最小 Decoder-only Language Model。代码会持续标注 Tensor Shape;FlashAttention、Tensor Parallel、KV Cache 和混合精度等工程优化将在后续相关部分展开。

本章统一使用以下符号:

  • BB:Batch Size;
  • TT:Sequence Length;
  • DD:Hidden Size;
  • HH:标准 Multi-head Attention 的 Head 数;
  • Dh=D/HD_h=D/H:每个 Attention Head 的维度;
  • DffD_{\mathrm{ff}}:FFN Intermediate Size;
  • V\mathcal V:Vocabulary,Vvocab=∣V∣V_{\mathrm{vocab}}=|\mathcal V| 表示 Vocabulary Size。

Attention 中仍按惯例使用 Q,K,VQ,K,V 表示 Query、Key、Value;词表则始终写作 V\mathcal V,避免把 Value Tensor 与 Vocabulary Size 混淆。下标 bb 表示样本,t,st,s 表示 Token Positions,hh 表示 Attention Head,jj 表示 Hidden Dimension,ii 表示 RoPE 中的维度对。

1
2
3
4
5
import math

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

2.1 RMSNorm

为什么需要归一化?

Transformer 会连续堆叠很多层。每一层中的线性变换、Attention、非线性激活和 Residual Addition 都可能改变 Hidden States 的数值尺度。如果不加控制,随着网络加深,不同层接收到的输入尺度可能差异很大:

  • 数值过大时,Attention Logits 可能使 Softmax 进入饱和区域,FFN Activation 和梯度也更容易不稳定;
  • 数值过小时,有效信号和梯度可能变弱;
  • 各层输入尺度不断变化,会增加参数优化难度,使训练对初始化和 Learning Rate 更敏感。

Norm 的作用,是把 Hidden States 控制到相对稳定的尺度。在本章采用的 Pre-Norm 结构中,Attention 和 FFN 会先接收归一化后的输入,从而提高深层网络的训练稳定性。

RMSNorm 如何计算?

设 RMSNorm 的输入为:

X∈RB×T×D,X\in\mathbb R^{B\times T\times D},

其中:

  • BB:Batch Size;
  • TT:Sequence Length;
  • DD:Hidden Size;
  • Xb,t,:∈RDX_{b,t,:}\in\mathbb R^D:第 bb 个样本中第 tt 个 Token 的 Hidden Vector。

RMSNorm 对每个 Token 的 Hidden Dimension 单独计算均方根。也就是说,固定 b,tb,t,只在最后一维 j=1,…,Dj=1,\ldots,D 上求均值:

RMS⁡(Xb,t,:)=1D∑j=1DXb,t,j2+ϵ.\operatorname{RMS}(X_{b,t,:}) = \sqrt{ \frac{1}{D} \sum_{j=1}^{D}X_{b,t,j}^{2} +\epsilon }.

然后对该 Token 的每个 Hidden Dimension 做缩放:

Yb,t,j=wjXb,t,jRMS⁡(Xb,t,:),Y_{b,t,j} = w_j \frac{X_{b,t,j}} {\operatorname{RMS}(X_{b,t,:})},

其中:

  • w∈RDw\in\mathbb R^D:可学习的缩放参数;
  • wjw_j:第 jj 个 Hidden Dimension 对应的参数;
  • ϵ\epsilon:防止分母为零的常数;
  • Y∈RB×T×DY\in\mathbb R^{B\times T\times D}:RMSNorm 的输出。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class RMSNorm(nn.Module):
def __init__(self, hidden_size, eps=1e-6):
super().__init__()
# 每个 Hidden Dimension 都有一个可学习的缩放参数。
self.weight = nn.Parameter(torch.ones(hidden_size))
self.eps = eps

def forward(self, x):
# x: (B, T, D)

# 只在最后一个 Hidden Dimension 上计算平方均值。
# mean_square: (B, T, 1)
mean_square = x.pow(2).mean(dim=-1, keepdim=True)

# rsqrt(z) = 1 / sqrt(z)。
# inv_rms: (B, T, 1)
inv_rms = torch.rsqrt(mean_square + self.eps)

# inv_rms 在 D 维广播,weight 在 B、T 维广播。
# output: (B, T, D)
return x * inv_rms * self.weight

与 LayerNorm 相比,RMSNorm 不计算并减去均值,只根据均方根控制向量尺度,因此计算更简单。

LayerNorm 与 BatchNorm 分别在哪些维度计算?

仍然设 LLM 的 Hidden States 为:

X∈RB×T×D.X\in\mathbb R^{B\times T\times D}.

LayerNorm 与 RMSNorm 一样,都是固定一个样本和一个 Token,只沿 Hidden Dimension DD 计算统计量。 LayerNorm 对每个 Xb,t,:X_{b,t,:} 分别计算:

μb,t=1D∑j=1DXb,t,j,σb,t2=1D∑j=1D(Xb,t,j−μb,t)2,\mu_{b,t} = \frac{1}{D}\sum_{j=1}^{D}X_{b,t,j}, \qquad \sigma_{b,t}^{2} = \frac{1}{D}\sum_{j=1}^{D} \left(X_{b,t,j}-\mu_{b,t}\right)^2,

然后得到:

Yb,t,j=γjXb,t,j−μb,tσb,t2+ϵ+βj.Y_{b,t,j} = \gamma_j \frac{X_{b,t,j}-\mu_{b,t}} {\sqrt{\sigma_{b,t}^{2}+\epsilon}} +\beta_j.

因此,不同样本和不同 Token 之间不会共同计算均值与方差;LayerNorm 的输入和输出 Shape 都是 (B,T,D)(B,T,D),可学习参数 γ,β∈RD\gamma,\beta\in\mathbb R^D。

BatchNorm 则固定 Hidden Feature jj,沿 Batch 以及通常的 Sequence Dimension 统计。 如果使用常见的 BatchNorm1d,会先把 Tensor 看成 (B,D,T)(B,D,T),对每个 Feature 计算:

μj=1BT∑b=1B∑t=1TXb,t,j,σj2=1BT∑b=1B∑t=1T(Xb,t,j−μj)2.\mu_j = \frac{1}{BT} \sum_{b=1}^{B}\sum_{t=1}^{T}X_{b,t,j}, \qquad \sigma_j^2 = \frac{1}{BT} \sum_{b=1}^{B}\sum_{t=1}^{T} \left(X_{b,t,j}-\mu_j\right)^2.

然后得到:

Yb,t,j=γjXb,t,j−μjσj2+ϵ+βj.Y_{b,t,j} = \gamma_j \frac{X_{b,t,j}-\mu_j} {\sqrt{\sigma_j^2+\epsilon}} +\beta_j.

因此,同一个 Hidden Feature jj 在不同样本和 Token Positions 上共享同一组 Batch Statistics。也就是说:

  • LayerNorm:每个 Token 内部,在 DD 个 Hidden Features 之间归一化;
  • BatchNorm:每个 Hidden Feature 单独,在不同样本和 Token Positions 之间归一化。

LLM 通常使用 LayerNorm 或 RMSNorm,而很少使用 BatchNorm。因为文本序列长度不同且含有 Padding,训练中的 Micro Batch 也可能很小;BatchNorm 的统计量会依赖 Batch 组成、序列长度和不同 GPU 上的数据,并且推理时还需要使用 Running Mean 与 Running Variance。LayerNorm/RMSNorm 只依赖当前 Token 自己的 Hidden Vector,不需要跨样本统计,因此更适合自回归语言模型。

2.2 Query、Key、Value 与 RoPE

Self-Attention 接收 Hidden States:

X∈RB×T×D,X\in\mathbb R^{B\times T\times D},

并通过三组可学习的线性投影得到 Query、Key 和 Value。暂时以 MHA 为例,WQ,WK,WV∈RD×DW_Q,W_K,W_V\in\mathbb R^{D\times D}:

Q=XWQ,K=XWK,V=XWV.Q=XW_Q,\qquad K=XW_K,\qquad V=XW_V.

三者再从 (B,T,D)(B,T,D) 拆分成 HH 个 Heads,使不同 Heads 可以在不同表示子空间中学习不同的关联模式:

Q,K,V∈RB×H×T×Dh,Q,K,V\in \mathbb R^{B\times H\times T\times D_h},

其中:

  • DhD_h:每个 Head 的维度,要求是偶数;
  • Qb,h,t,:Q_{b,h,t,:}:第 bb 个样本、第 hh 个 Head 在位置 tt 的 Query;
  • Kb,h,s,:K_{b,h,s,:}:第 bb 个样本、第 hh 个 Head 在位置 ss 的 Key。

Query 表示“当前位置想读取什么”,Key 表示“各位置可以用什么特征来匹配”,Value 则保存匹配后真正被聚合的内容。

如果只做上述投影,不同 Token Positions 使用的是同一组参数,Attention 本身无法知道 Token 的先后顺序。RoPE(Rotary Position Embedding)通过旋转 Query 和 Key 注入位置信息。

RoPE 不把 Position Embedding 加到 Token Hidden State 上,而是根据位置分别旋转 QQ 和 KK。它把 Head Dimension 中相邻的两个维度看作一个二维向量:

[Qt,2iQt,2i+1],i=0,1,…,Dh2−1.\begin{bmatrix} Q_{t,2i}\\ Q_{t,2i+1} \end{bmatrix}, \qquad i=0,1,\ldots,\frac{D_h}{2}-1.

第 ii 对维度使用的角频率定义为:

ωi=β−2iDh,\omega_i = \beta^{-\frac{2i}{D_h}},

其中 β\beta 是 RoPE Base,这里取 1000010000。RoPE 的位置从 00 开始编号,因此 t∈{0,…,T−1}t\in\{0,\ldots,T-1\},位置 tt 对应的旋转角度为:

θt,i=tωi.\theta_{t,i}=t\omega_i.

二维旋转矩阵为:

R(θt,i)=[cos⁡θt,i−sin⁡θt,isin⁡θt,icos⁡θt,i].R(\theta_{t,i}) = \begin{bmatrix} \cos\theta_{t,i} & -\sin\theta_{t,i}\\ \sin\theta_{t,i} & \cos\theta_{t,i} \end{bmatrix}.

因此旋转后的 Query 为:

[Qt,2i′Qt,2i+1′]=R(θt,i)[Qt,2iQt,2i+1].\begin{bmatrix} Q'_{t,2i}\\ Q'_{t,2i+1} \end{bmatrix} = R(\theta_{t,i}) \begin{bmatrix} Q_{t,2i}\\ Q_{t,2i+1} \end{bmatrix}.

展开后:

Qt,2i′=Qt,2icos⁡θt,i−Qt,2i+1sin⁡θt,i,Qt,2i+1′=Qt,2isin⁡θt,i+Qt,2i+1cos⁡θt,i.\begin{aligned} Q'_{t,2i} &= Q_{t,2i}\cos\theta_{t,i} - Q_{t,2i+1}\sin\theta_{t,i},\\ Q'_{t,2i+1} &= Q_{t,2i}\sin\theta_{t,i} + Q_{t,2i+1}\cos\theta_{t,i}. \end{aligned}

Key 使用完全相同的方式旋转;Value 不使用 RoPE。旋转不会改变 Query 和 Key 的 Shape。

为什么旋转以后包含相对位置?

下面省略 Batch 和 Head 下标,并用 RtR_t 表示位置 tt 上所有二维旋转矩阵组成的 Block-diagonal Matrix。

位置 tt 的 Query 与位置 ss 的 Key 做点积时:

(RtQt)T(RsKs)=QtTRtTRsKs=QtTRs−tKs.\begin{aligned} (R_tQ_t)^T(R_sK_s) &= Q_t^TR_t^TR_sK_s\\ &= Q_t^TR_{s-t}K_s. \end{aligned}

因为二维旋转矩阵满足:

RtTRs=Rs−t,R_t^TR_s=R_{s-t},

所以旋转后 Query–Key 的点积不仅与内容有关,还与相对位置 s−ts-t 有关。这就是 RoPE 能把相对位置信息注入 Attention Score 的原因。

代码可以先用一个四维向量理解。若:

1
x = [a, b, c, d]

则将相邻维度两两配对为 (a,b)(a,b) 和 (c,d)(c,d),rotate_half(x) 的结果为:

1
[-b, a, -d, c]

再计算:

1
x * cos(theta) + rotate_half(x) * sin(theta)

就分别完成了两个二维向量的旋转。

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
def rotate_half(x):
"""
对最后一个维度中每一对相邻元素执行:
(x_0, x_1) -> (-x_1, x_0)。

x: (..., head_dim)
返回值 Shape 与 x 相同。
"""
# 取偶数下标:
# [x_0, x_2, ..., x_{Dh-2}]
# Shape: (..., head_dim / 2)
x_even = x[..., 0::2]

# 取奇数下标:
# [x_1, x_3, ..., x_{Dh-1}]
# Shape: (..., head_dim / 2)
x_odd = x[..., 1::2]

# 每一对 (x_{2i}, x_{2i+1}) 变成
# (-x_{2i+1}, x_{2i})。
#
# stack 后:
# Shape: (..., head_dim / 2, 2)
# 内容类似:
# [[-x_1, x_0], [-x_3, x_2], ...]
rotated = torch.stack((-x_odd, x_even), dim=-1)

# 把最后两个维度重新合并:
# (..., head_dim / 2, 2) -> (..., head_dim)
# 得到 [-x_1, x_0, -x_3, x_2, ...]。
return rotated.flatten(start_dim=-2)


def build_rope_cache(seq_len, head_dim, device, base=10000.0):
"""
为所有 Token Position 预先计算旋转所需的 cos 和 sin。

seq_len: Sequence Length T
head_dim: 每个 Attention Head 的维度 Dh

返回:
cos, sin: (1, 1, T, Dh)
"""
assert head_dim % 2 == 0

# Head Dimension 被两两配对,共有 Dh / 2 对。
#
# 例如 Dh = 8:
# pair_index = [0, 1, 2, 3]
#
# Shape: (Dh / 2,)
pair_index = torch.arange(
head_dim // 2,
device=device,
dtype=torch.float32,
)

# 为每一对维度分配不同的角频率:
# omega_i = base^(-2i / Dh)。
#
# i 越小,频率越高、随位置旋转越快;
# i 越大,频率越低、随位置旋转越慢。
#
# Shape: (Dh / 2,)
frequencies = base ** (-2 * pair_index / head_dim)

# 所有 Token 的位置编号 t = 0, 1, ..., T - 1。
# Shape: (T,)
positions = torch.arange(
seq_len,
device=device,
dtype=torch.float32,
)

# positions[:, None]: (T, 1)
# frequencies[None, :]: (1, Dh / 2)
#
# 利用广播得到每个位置、每对维度的旋转角:
# angles[t, i] = t * omega_i。
#
# Shape: (T, Dh / 2)
angles = positions[:, None] * frequencies[None, :]

# 同一对中的两个维度必须使用同一个旋转角。
#
# [theta_0, theta_1, ...]
# -> [theta_0, theta_0, theta_1, theta_1, ...]
#
# Shape: (T, Dh)
angles = torch.repeat_interleave(angles, repeats=2, dim=-1)

# 原本是 (T, Dh),在前面加入两个长度为 1 的维度:
# (T, Dh) -> (1, 1, T, Dh)。
#
# q、k: (B, H, T, Dh)。
# cos/sin 会在 Batch 和 Head 维度上广播。
cos = angles.cos()[None, None, :, :]
sin = angles.sin()[None, None, :, :]
return cos, sin


def apply_rope(q, k):
"""
q, k: (batch_size, num_heads, seq_len, head_dim)

返回:
旋转后的 q, k,各自 Shape 均保持不变。
"""
# q 的倒数第二维是 Sequence Length T。
seq_len = q.size(-2)

# q 的最后一维是每个 Head 的维度 Dh。
head_dim = q.size(-1)

# cos, sin: (1, 1, T, Dh)
cos, sin = build_rope_cache(seq_len, head_dim, q.device)

# 让 cos、sin 与 q、k 使用相同的数据类型,
# 避免 BF16/FP16 计算时发生不必要的类型提升。
cos = cos.to(dtype=q.dtype)
sin = sin.to(dtype=q.dtype)

# 对 Q 的每一对相邻维度:
#
# q_even' = q_even * cos(theta) - q_odd * sin(theta)
# q_odd' = q_even * sin(theta) + q_odd * cos(theta)
#
# rotate_half(q) 恰好提供 [-q_odd, q_even],
# 因此可以把两条公式合并成下面这一行。
q = q * cos + rotate_half(q) * sin

# K 使用相同的位置角度旋转;V 不做 RoPE。
k = k * cos + rotate_half(k) * sin
return q, k

2.3 Scaled Dot-product Attention

为避免符号过重,本节继续用 Q,KQ,K 表示已经应用 RoPE 的 Query 和 Key。Value 不经过 RoPE。

Attention 的输入 Shape 为:

Q,K,V∈RB×H×T×Dh,Q,K,V\in \mathbb R^{B\times H\times T\times D_h},

对每个 Head,Attention 计算:

Attention⁡(Q,K,V)=Softmax⁡(QKTDh+M)V.\operatorname{Attention}(Q,K,V) = \operatorname{Softmax} \left( \frac{QK^T}{\sqrt{D_h}}+M \right)V.

其中 MM 是 Attention Mask:允许读取的位置取 00,禁止读取的位置取 −∞-\infty,并在 Batch 和 Head 维度上广播。

可以分成三步理解:

  1. QKTQK^T:计算每个 Query 与所有 Keys 的相关性,得到 Attention Scores;
  2. Softmax:把每个 Query 对所有 Keys 的 Scores 变成权重;
  3. 乘以 VV:按照权重对 Value Vectors 加权求和。

Score Tensor 的 Shape 为 (B,H,T,T)(B,H,T,T)。其中最后两个维度分别表示 Query Position 和 Key Position:

Sb,h,t,s=Qb,h,t,:⋅Kb,h,s,:Dh.S_{b,h,t,s} = \frac{ Q_{b,h,t,:}\cdot K_{b,h,s,:} }{ \sqrt{D_h} }.

也就是说,Sb,h,t,sS_{b,h,t,s} 表示位置 tt 在更新自身表示时,对位置 ss 的关注程度。

为什么要除以 Dh\sqrt{D_h}?Query 与 Key 的点积是 DhD_h 项之和。假设各维近似独立且方差为 11,点积的方差会增长到约 DhD_h,标准差约为 Dh\sqrt{D_h}。因此 Head Dimension 越大,未经缩放的 Scores 通常越大,容易让 Softmax 过早接近 One-hot、梯度变小。除以 Dh\sqrt{D_h} 可以把 Score 的方差重新控制在约 11,使训练更加稳定。

Mask 会在 Softmax 前把禁止读取的位置加上 −∞-\infty:

  • Causal Mask:当 s>ts>t 时屏蔽,禁止读取未来 Token;
  • Padding Mask:当位置 ss 是 <pad> 时屏蔽,禁止把 Padding 当作上下文。

经过 Softmax 后,这些位置的 Attention Weight 就变成 00。

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
42
43
44
45
46
47
48
49
50
51
def scaled_dot_product_attention(
q,
k,
v,
attention_mask=None,
):
"""
q, k, v: (batch_size, num_heads, seq_len, head_dim)
attention_mask: (batch_size, seq_len)
真实 Token 为 1,Padding 为 0
"""
head_dim = q.size(-1)
seq_len = q.size(-2)

# (B, H, T, Dh) @ (B, H, Dh, T) -> (B, H, T, T)
scores = q @ k.transpose(-2, -1)
scores = scores / math.sqrt(head_dim)

# 第 t 个 Token 不能看到 t 之后的 Token。
# 例如 T=4 时,True 表示需要屏蔽:
# [[False, True, True, True],
# [False, False, True, True],
# [False, False, False, True],
# [False, False, False, False]]
causal_mask = torch.triu(
torch.ones(
seq_len,
seq_len,
device=q.device,
dtype=torch.bool,
),
# 从主对角线上方第 1 条对角线开始保留,
# 即只把 s > t 的未来位置设为 True。
diagonal=1,
)
scores = scores.masked_fill(causal_mask, float("-inf"))

if attention_mask is not None:
# (B, T) -> (B, 1, 1, T)
# 只在 Key Position 所在的最后一维屏蔽 Padding。
key_padding_mask = ~attention_mask[:, None, None, :].bool()
scores = scores.masked_fill(
key_padding_mask,
float("-inf"),
)

attention_weights = F.softmax(scores, dim=-1)

# (B, H, T, T) @ (B, H, T, Dh) -> (B, H, T, Dh)
output = attention_weights @ v
return output

这里的 Padding Mask 屏蔽的是 Key Positions,也就是不允许其他位置读取 <pad>。Padding Query Positions 仍可能产生输出,但这些位置随后会被 Loss Mask 排除,不参与训练目标。

2.4 MHA、MQA 与 GQA

前面先用标准 MHA 说明了 Q/K/V 投影、RoPE 和 Attention 计算。MHA、MQA 与 GQA 的核心区别,不在 Attention 公式,而在于 Query Heads 与 Key/Value Heads 的数量关系。

Multi-head Attention

标准 Multi-head Attention(MHA)中,Q/K/V 都有 HH 个 Heads:

Q,K,V∈RB×H×T×Dh.Q,K,V\in\mathbb R^{B\times H\times T\times D_h}.

每个 Query Head 都有自己对应的 Key Head 和 Value Head。各 Head 独立计算 Attention 后,再拼接回 Hidden Size:

(B,H,T,Dh)⟶(B,T,H,Dh)⟶(B,T,D).(B,H,T,D_h) \longrightarrow (B,T,H,D_h) \longrightarrow (B,T,D).

Multi-query Attention

为了描述 MQA 和 GQA,下面进一步区分:

  • HqH_q:Query Head 数;
  • HkvH_{kv}:Key/Value Head 数;
  • Dh=D/HqD_h=D/H_q:每个 Head 的维度。

Multi-query Attention(MQA)保留 HqH_q 个 Query Heads,但令 Hkv=1H_{kv}=1,所有 Query Heads 共享同一组 Key 和 Value:

Q∈RB×Hq×T×Dh,K,V∈RB×1×T×Dh.\begin{aligned} Q&\in\mathbb R^{B\times H_q\times T\times D_h},\\ K,V&\in\mathbb R^{B\times 1\times T\times D_h}. \end{aligned}

生成时需要为历史 Tokens 保存 K 和 V。MQA 把 KV Head 数从 HqH_q 降到 11,因此可以显著减少 KV Cache 和读取带宽;代价是所有 Query Heads 只能共享同一组 K/V 表示,模型能力可能受到影响。

Grouped-query Attention

Grouped-query Attention(GQA)位于 MHA 和 MQA 之间。设:

  • G=Hq/HkvG=H_q/H_{kv}:每组共享同一组 K/V 的 Query Heads 数。

对应 Shape 为:

Q∈RB×Hq×T×Dh,K,V∈RB×Hkv×T×Dh.\begin{aligned} Q&\in\mathbb R^{B\times H_q\times T\times D_h},\\ K,V&\in\mathbb R^{B\times H_{kv}\times T\times D_h}. \end{aligned}

并要求 HqH_q 能被 HkvH_{kv} 整除。按照 Head 连续编号,每连续 GG 个 Query Heads 共享同一个 K/V Head。三种结构可以统一理解为:

1
2
3
MHA:H_kv = H_q       每个 Query Head 独享一组 K/V
GQA:1 < H_kv < H_q 一组 Query Heads 共享一组 K/V
MQA:H_kv = 1 所有 Query Heads 共享一组 K/V

其中,标准 MHA 就是 Hq=Hkv=HH_q=H_{kv}=H 的特殊情况。GQA 在模型质量和 KV Cache 成本之间折中,因此是现代 Decoder-only LLM 的常见选择。

下面用一个类统一实现三种 Attention。Q 和 K 各自应用 RoPE 后,教学代码使用 repeat_interleave 让每组 Query Heads 读取同一个 K/V Head,再调用前面的 Attention 函数。高性能实现通常不会真的复制整份 K/V,而是在 Kernel 内完成共享。

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
class GroupedQuerySelfAttention(nn.Module):
"""
同时支持 MHA、MQA 和 GQA。

hidden_size: Hidden Size D
num_query_heads: Query Head 数 H_q
num_kv_heads: Key/Value Head 数 H_kv
"""
def __init__(
self,
hidden_size,
num_query_heads,
num_kv_heads,
):
super().__init__()

# D 必须能平均拆成 H_q 个 Query Heads。
assert hidden_size % num_query_heads == 0

# 每个 K/V Head 必须对应整数个 Query Heads。
assert num_query_heads % num_kv_heads == 0

self.num_query_heads = num_query_heads
self.num_kv_heads = num_kv_heads

# G = H_q / H_kv:每个 K/V Head 被多少个 Query Heads 共享。
self.num_groups = num_query_heads // num_kv_heads

# 每个 Q/K/V Head 使用相同的 Head Dimension。
self.head_dim = hidden_size // num_query_heads

# Q 使用 H_q 个 Heads,输出维度仍为 D。
self.q_proj = nn.Linear(
hidden_size,
num_query_heads * self.head_dim,
bias=False,
)

# K/V 只使用 H_kv 个 Heads。
kv_hidden_size = num_kv_heads * self.head_dim
self.k_proj = nn.Linear(
hidden_size,
kv_hidden_size,
bias=False,
)
self.v_proj = nn.Linear(
hidden_size,
kv_hidden_size,
bias=False,
)

# 合并所有 Query Heads 后,再映射回 Hidden Size D。
self.out_proj = nn.Linear(
hidden_size,
hidden_size,
bias=False,
)

def _split_heads(self, x, num_heads):
"""
(B, T, num_heads * Dh)
-> (B, num_heads, T, Dh)
"""
batch_size, seq_len, _ = x.shape
x = x.reshape(
batch_size,
seq_len,
num_heads,
self.head_dim,
)
# (B, T, num_heads, Dh) -> (B, num_heads, T, Dh)
return x.transpose(1, 2)

def forward(self, x, attention_mask=None):
"""
x: (B, T, D)
attention_mask: (B, T),真实 Token 为 1,Padding 为 0
"""
batch_size, seq_len, hidden_size = x.shape

# Q Projection: (B, T, D) -> (B, T, H_q * Dh)
# Split Heads: (B, T, H_q * Dh) -> (B, H_q, T, Dh)
q = self._split_heads(
self.q_proj(x),
self.num_query_heads,
)

# K/V Projection: (B, T, D) -> (B, T, H_kv * Dh)
# Split Heads: (B, T, H_kv * Dh) -> (B, H_kv, T, Dh)
k = self._split_heads(
self.k_proj(x),
self.num_kv_heads,
)
v = self._split_heads(
self.v_proj(x),
self.num_kv_heads,
)

# q: (B, H_q, T, Dh)
# k: (B, H_kv, T, Dh)
# v: (B, H_kv, T, Dh)
# RoPE 只旋转 Q 和 K,不改变 Shape。
q, k = apply_rope(q, k)

# 每组 G 个 Query Heads 共享一个 K/V Head。
# 例如 H_q=8、H_kv=2 时,每个 K/V Head 连续重复 4 次。
# (B, H_kv, T, Dh) -> (B, H_q, T, Dh)
aligned_k = k.repeat_interleave(
self.num_groups,
dim=1,
)
aligned_v = v.repeat_interleave(
self.num_groups,
dim=1,
)

# output: (B, H_q, T, Dh)
output = scaled_dot_product_attention(
q,
aligned_k,
aligned_v,
attention_mask,
)

# (B, H_q, T, Dh) -> (B, T, H_q, Dh) -> (B, T, D)
output = output.transpose(1, 2).contiguous()
output = output.view(batch_size, seq_len, hidden_size)

# Output Projection: (B, T, D) -> (B, T, D)
return self.out_proj(output)

设置 num_kv_heads=num_query_heads 时是 MHA;设置 num_kv_heads=1 时是 MQA;取二者之间的值时就是 GQA。

2.5 SwiGLU Feed-forward Network

Attention 后面通常还会接一个逐 Token 的 Feed-forward Network(FFN)。它不会混合不同 Token,只对每个 Token 的 Hidden Vector 独立执行相同的变换。

原始 Transformer 使用 ReLU FFN:

FFN⁡(x)=W2ReLU⁡(W1x+b1)+b2.\operatorname{FFN}(x) = W_2\operatorname{ReLU}(W_1x+b_1)+b_2.

其过程是:

D→W1Dff→ReLU⁡Dff→W2D,D \xrightarrow{W_1} D_{\mathrm{ff}} \xrightarrow{\operatorname{ReLU}} D_{\mathrm{ff}} \xrightarrow{W_2} D,

其中:

  • DD:模型的 Hidden Size;
  • DffD_{\mathrm{ff}}:FFN 的 Intermediate Size,通常大于 DD;
  • ReLU:ReLU⁡(z)=max⁡(0,z)\operatorname{ReLU}(z)=\max(0,z)。

GPT、BERT 等模型后来常把 ReLU 换成更平滑的 GELU。SwiGLU 则在此基础上引入了 Gating Mechanism。

从 GLU 到 SwiGLU

SwiGLU 将同一个输入 xx 投影成两个向量:

g=Wgatex,u=Wupx.\begin{aligned} g&=W_{\mathrm{gate}}x,\\ u&=W_{\mathrm{up}}x. \end{aligned}

其中 g,u∈RDffg,u\in\mathbb R^{D_{\mathrm{ff}}}。Gate 分支 gg 经过 SiLU:

SiLU⁡(g)=g⊙σ(g),\operatorname{SiLU}(g) = g\odot\sigma(g),

其中 σ\sigma 是 Sigmoid,⊙\odot 表示逐元素乘法。

最终:

SwiGLU⁡(x)=Wdown[SiLU⁡(Wgatex)⊙(Wupx)].\operatorname{SwiGLU}(x) = W_{\mathrm{down}} \left[ \operatorname{SiLU}(W_{\mathrm{gate}}x) \odot (W_{\mathrm{up}}x) \right].

可以将两条分支理解为:

  • WupxW_{\mathrm{up}}x:生成候选内容;
  • SiLU⁡(Wgatex)\operatorname{SiLU}(W_{\mathrm{gate}}x):生成一个数据相关的 Gate;
  • 两者逐元素相乘:决定每个 Intermediate Dimension 应保留多少信息;
  • WdownW_{\mathrm{down}}:将维度从 DffD_{\mathrm{ff}} 投影回 DD。

设输入:

X∈RB×T×D,X\in\mathbb R^{B\times T\times D},

则各阶段 Shape 为:

WgateX,  WupX∈RB×T×Dff,SwiGLU⁡(X)∈RB×T×D.\begin{aligned} W_{\mathrm{gate}}X,\;W_{\mathrm{up}}X &\in\mathbb R^{B\times T\times D_{\mathrm{ff}}},\\ \operatorname{SwiGLU}(X) &\in\mathbb R^{B\times T\times D}. \end{aligned}

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
class SwiGLU(nn.Module):
def __init__(self, hidden_size, intermediate_size):
super().__init__()

# Gate 分支:D -> D_ff。
self.gate_proj = nn.Linear(
hidden_size,
intermediate_size,
bias=False,
)

# 内容分支:D -> D_ff。
self.up_proj = nn.Linear(
hidden_size,
intermediate_size,
bias=False,
)

# 输出投影:D_ff -> D。
self.down_proj = nn.Linear(
intermediate_size,
hidden_size,
bias=False,
)

def forward(self, x):
# x: (B, T, D)

# gate、up: (B, T, D_ff)
gate = self.gate_proj(x)
up = self.up_proj(x)

# SiLU(gate) 作为门控信号,与候选内容逐元素相乘。
# gated: (B, T, D_ff)
gated = F.silu(gate) * up

# output: (B, T, D)
return self.down_proj(gated)

SwiGLU 可以认为是现代 Decoder-only LLM 的主流 FFN 结构之一,LLaMA、PaLM、Mistral 和 Qwen 等模型均使用了 SwiGLU 或相近的 Gated FFN。

2.6 Transformer Block

一个 Transformer Block 包含 Attention 和 FFN 两个子层,每个子层外都有 Norm 与 Residual Connection。

原始 Transformer 使用 Post-Norm:

x′=Norm⁡(x+f(x)).x' = \operatorname{Norm}\left(x+f(x)\right).

现代 Decoder-only LLM 通常使用 Pre-Norm:

x′=x+f(Norm⁡(x)).x' = x+f\left(\operatorname{Norm}(x)\right).

Pre-Norm 先归一化再进入子层,Residual Path 本身仍保持直接的恒等路径,既保留子层变换前的信息,也有利于梯度在深层网络中传播。应用到完整 Block:

X′=X+Attention⁡(RMSNorm⁡(X)),Y=X′+SwiGLU⁡(RMSNorm⁡(X′)).\begin{aligned} X'&=X+\operatorname{Attention}(\operatorname{RMSNorm}(X)),\\ Y&=X'+\operatorname{SwiGLU}(\operatorname{RMSNorm}(X')). \end{aligned}

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
class TransformerBlock(nn.Module):
def __init__(
self,
hidden_size,
num_query_heads,
num_kv_heads,
intermediate_size,
):
super().__init__()
self.attn_norm = RMSNorm(hidden_size)
self.attn = GroupedQuerySelfAttention(
hidden_size,
num_query_heads,
num_kv_heads,
)

self.ffn_norm = RMSNorm(hidden_size)
self.ffn = SwiGLU(
hidden_size,
intermediate_size,
)

def forward(self, x, attention_mask=None):
# Attention 子层:Pre-Norm + Residual。
x = x + self.attn(
self.attn_norm(x),
attention_mask,
)

# FFN 子层:Pre-Norm + Residual。
x = x + self.ffn(self.ffn_norm(x))
return x

2.7 组装最小 Decoder-only Language Model

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
42
43
44
45
46
47
48
class TinyDecoderLM(nn.Module):
def __init__(
self,
vocab_size,
hidden_size,
num_query_heads,
num_kv_heads,
intermediate_size,
num_layers,
):
super().__init__()
self.token_embedding = nn.Embedding(
vocab_size,
hidden_size,
)
self.layers = nn.ModuleList(
[
TransformerBlock(
hidden_size,
num_query_heads,
num_kv_heads,
intermediate_size,
)
for _ in range(num_layers)
]
)
self.final_norm = RMSNorm(hidden_size)
self.lm_head = nn.Linear(
hidden_size,
vocab_size,
bias=False,
)

# Weight Tying:输入 Embedding 与输出 LM Head 共享参数。
self.lm_head.weight = self.token_embedding.weight

def forward(self, input_ids, attention_mask=None):
# (B, T) -> (B, T, D)
x = self.token_embedding(input_ids)

for layer in self.layers:
x = layer(x, attention_mask)

x = self.final_norm(x)

# (B, T, D) -> (B, T, V_vocab)
logits = self.lm_head(x)
return logits

模型输出 logits 的 Shape 为 (B,T,∣V∣)(B,T,|\mathcal V|)。第一章已经实现了 Label Shift、Padding Loss Mask 和 Cross Entropy,这里直接复用 causal_lm_loss,运行一次完整 Forward:

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
model = TinyDecoderLM(
vocab_size=32000,
hidden_size=512,
num_query_heads=8,
num_kv_heads=2,
intermediate_size=1408,
num_layers=4,
)

input_ids = torch.tensor([
[1, 10, 20, 2, 0],
[1, 30, 40, 50, 2],
])
attention_mask = torch.tensor([
[1, 1, 1, 1, 0],
[1, 1, 1, 1, 1],
])

logits = model(input_ids, attention_mask)
loss, _ = causal_lm_loss(
logits,
input_ids,
attention_mask,
)

print("logits shape:", logits.shape)
# logits shape: torch.Size([2, 5, 32000])

print("loss shape:", loss.shape)
# loss shape: torch.Size([])

2.8 模型的宽度、深度与参数量

真实 LLM 并不只是抽象地“堆叠很多 Transformer Blocks”,还需要确定每个 Block 多宽、总共堆多少层。最重要的结构参数包括:

  • DD:Hidden Size,决定 Residual Stream 的宽度;
  • DffD_{\mathrm{ff}}:FFN Intermediate Size,通常是 DD 的数倍;
  • LL:Transformer Block 数量,也就是模型深度。

Attention 中还有 Head 数 HH 和 Head Dimension DhD_h,满足 D=HDhD=HD_h。但增加 Head 数不一定是在加宽:如果 DD 不变,增加 HH 只会让每个 Head 的 DhD_h 相应减小。

参数量大致由什么决定?

先看使用 MHA 和 SwiGLU 的 Dense Block,并忽略 Bias 与 Norm 的少量参数:

  • Attention 的 Q/K/V/Output Projections 约有 4D24D^2 个参数;
  • SwiGLU 的 Gate/Up/Down Projections 约有 3DDff3DD_{\mathrm{ff}} 个参数。

因此一个 Block 的参数量近似为:

Pblock≈4D2+3DDff.P_{\mathrm{block}} \approx 4D^2+3DD_{\mathrm{ff}}.

整个模型还要加上 Token Embedding,因此可以粗略写成:

P≈∣V∣D+L(4D2+3DDff).P \approx |\mathcal V|D + L\left(4D^2+3DD_{\mathrm{ff}}\right).

GQA 会减少 K/V Projection 的参数,但不改变整体判断:当 DffD_{\mathrm{ff}} 与 DD 保持固定比例时,主干参数量大致满足:

P∝LD2.P\propto LD^2.

这意味着:

  • 深度 LL 增加一倍,Block 参数量大致增加一倍;
  • 宽度 DD 增加一倍,Block 参数量通常接近增加到四倍。

真实模型大概有多宽、多深?

以几个有代表性的 Dense Model 为例:

  • Llama 3.1 8B:D=4096D=4096,L=32L=32;
  • Llama 3.1 70B:D=8192D=8192,L=80L=80;
  • Llama 3.1 405B:D=16384D=16384,L=126L=126;
  • Qwen2.5 7B:D=3584D=3584,L=28L=28;
  • Qwen2.5 72B:D=8192D=8192,L=80L=80。

可以看到,7B~8B Dense Model 通常已有约 30 层、接近 4K 的 Hidden Size;70B 左右的模型则可以达到约 80 层、8K 的 Hidden Size。Context Length TT 是另一个独立维度:它不直接增加参数量,但会增加 Attention 计算量和 KV Cache。

现代 LLM 是加宽还是加深?

从上面的模型配置看,规模增大时确实会同时加宽和加深,但新增参数通常更多由加宽贡献,因为主干参数量近似与 LD2LD^2 成正比:

  • DD 增加一倍,单层参数量接近增加到四倍,而且更大的矩阵乘法通常更容易发挥 GPU 的并行计算能力;
  • LL 增加一倍,参数量约增加一倍,但推理必须串行经过更多层,延迟也会随之增加。

因此可以说,现代大模型扩展时通常更依赖加宽来快速增加容量,但并不是只加宽。模型仍然需要足够的深度来完成多层特征变换,实际设计会在模型能力、GPU 利用率与推理延迟之间平衡宽度和深度。MoE 则提供了另一条路线:增加 Expert 总参数量,但每个 Token 只激活少量 Experts。

2.9 本章小结

一个现代 Dense Decoder-only Language Model 的完整数据流是:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Token IDs
→ Token Embedding
→ N 个 Transformer Blocks
→ RMSNorm
→ Q/K/V Projection + Split Heads
→ RoPE(Q, K)
→ GQA 中的 K/V Head 共享
→ Scaled Dot-product Attention + Causal/Padding Mask
→ Output Projection
→ Residual
→ RMSNorm
→ SwiGLU
→ Residual
→ Final RMSNorm
→ LM Head
→ Vocabulary Logits

实现时需要满足以下条件:

  • Attention Scores 需要除以 Dh\sqrt{D_h};
  • Causal Mask 只屏蔽满足 s>ts>t 的未来位置;
  • Padding Mask 负责屏蔽 Attention 中的 <pad>,Loss Mask 负责排除训练目标中的 <pad>;
  • Query 拆分 Heads 后,Shape 应从 (B,T,D)(B,T,D) 变为 (B,Hq,T,Dh)(B,H_q,T,D_h);
  • GQA 要求 HqH_q 能被 HkvH_{kv} 整除;
  • RoPE 只应用于 Q,KQ,K,不应用于 VV;
  • Next-token Prediction 计算 Loss 前,需要对 Logits 和 Labels 执行 Label Shift;
  • transpose 后需要先调用 contiguous(),再使用 view() 合并 Heads。

三、现代 LLM 架构

上一章实现的是一套常见的 Dense Decoder-only Transformer:每个 Token 都经过相同的 Attention 和 SwiGLU FFN,每个位置只预测一个下一个 Token。这仍是现代 LLM 的基础,但模型规模和上下文长度继续增长后,主要出现了四条演化路线:

1
2
3
4
参数容量:Dense FFN → Sparse MoE
KV 表示:MHA / GQA → MLA
序列建模:Full Attention → Linear / Recurrent / Hybrid Attention
预测目标:Single-token Prediction → Multi-token Prediction

它们分别解决不同问题:

  • MoE:在不按相同比例增加每个 Token 计算量的情况下扩大参数容量;
  • MLA:压缩推理时需要保存的 KV Cache;
  • Linear / Recurrent / Hybrid Attention:降低长序列的计算和状态开销;
  • MTP:让每个训练位置提供更密集的未来 Token 监督,并可辅助投机解码。

3.1 Dense FFN 为什么会演化成 MoE?

在上一章的 Dense Transformer 中,每个 Token 都经过同一个 SwiGLU FFN:

FFN⁡(x)=Wdown[SiLU⁡(Wgatex)⊙(Wupx)].\operatorname{FFN}(x) = W_{\mathrm{down}} \left[ \operatorname{SiLU}(W_{\mathrm{gate}}x) \odot (W_{\mathrm{up}}x) \right].

如果直接扩大 Intermediate Size,模型参数量和每个 Token 的计算量会同时增加。Mixture-of-Experts(MoE)的思路是准备多个 FFN Experts,但每个 Token 只激活其中少数几个。每个 Expert 通常仍然是一个 SwiGLU FFN,只是拥有各自独立的参数:

1
2
3
4
5
Token Hidden State x
→ Router 为所有 Experts 打分
→ 选择 Top-k Experts
→ 只运行被选中的 Experts
→ 按 Router 权重合并输出

设共有 EE 个 Routed Experts,Router 输出:

r(x)=Wrx∈RE,p(x)=Softmax⁡(r(x)).r(x)=W_rx\in\mathbb R^E, \qquad p(x)=\operatorname{Softmax}(r(x)).

这是经典 Softmax Router 的写法。不同 MoE 的 Router 并不完全相同,例如 DeepSeekMoE 使用 Sigmoid Affinity、分组限制和 Top-k Routing,但“为 Experts 打分并选择少量 Experts”的主线相同。

取分数最高的 kk 个 Experts,记它们的集合为 S(x)\mathcal S(x),MoE 输出为:

y=∑e∈S(x)αe(x)Expert⁡e(x),y = \sum_{e\in\mathcal S(x)} \alpha_e(x)\operatorname{Expert}_e(x),

对于上面的 Softmax Router,可以令:

αe(x)=pe(x)∑j∈S(x)pj(x),e∈S(x).\alpha_e(x) = \frac{p_e(x)} {\sum_{j\in\mathcal S(x)}p_j(x)}, \qquad e\in\mathcal S(x).

也就是只在选中的 Experts 之间重新归一化。不同模型可能使用不同的 Scoring 与 Scaling 方式。

总参数量与激活参数量

MoE 需要区分:

  • Total Parameters:所有 Experts 的参数总和;
  • Activated Parameters:处理一个 Token 时实际参与计算的 Experts 参数量。

例如共有 64 个 Experts、每个 Token 只激活 2 个时,模型可以拥有很大的总参数容量,但每个 Token 只计算 2 个 Experts。MoE 降低的是“激活计算量相对于总参数量的比例”,并不意味着所有成本都会下降:所有 Expert Weights 仍需存储和分布到设备上,Router 与跨卡通信也会带来额外开销。

Routed Experts 与 Shared Experts

一些现代 MoE 同时包含:

  • Routed Experts:由 Router 为每个 Token 动态选择;
  • Shared Experts:所有 Tokens 都会经过,用于承载更通用的知识。

可以写成:

y=SharedExpert⁡(x)+∑e∈S(x)αe(x)RoutedExpert⁡e(x).y = \operatorname{SharedExpert}(x) + \sum_{e\in\mathcal S(x)} \alpha_e(x)\operatorname{RoutedExpert}_e(x).

Shared Experts 保证通用变换始终存在,Routed Experts 则提供更大的稀疏参数容量。

为什么需要 Load Balancing?

如果 Router 总把 Tokens 发给少数几个 Experts,就会出现:

  • 热门 Experts 负载过高,成为计算和通信瓶颈;
  • 其他 Experts 很少收到 Token,训练不足;
  • 不同 GPU 工作量不均,产生 Straggler。

传统做法是在主任务 Loss 外加入 Load Balancing Loss:

L=Ltask+λLbalance.\mathcal L = \mathcal L_{\mathrm{task}} + \lambda\mathcal L_{\mathrm{balance}}.

它通过反向传播调整 Router,使各 Experts 接收的 Tokens 数量更接近。但 λ\lambda 太大时,均衡目标可能干扰主任务训练以及 Experts 的自然分工。

DeepSeek-V3 的 Auxiliary-loss-free Load Balancing 不使用较强的 Expert-level Balance Loss,而是为每个 Expert 维护一个动态校正 Bias beb_e。沿用前文的记号,pe(x)p_e(x) 表示 Router 为当前 Token xx 分配给 Expert ee 的原始分数;选择 Top-k Experts 时使用校正后的分数:

p~e(x)=pe(x)+be.\widetilde p_e(x)=p_e(x)+b_e.

如果某个 Expert 最近负载过高,就减小它的 beb_e;负载过低则增大 beb_e,从而让后续 Tokens 更少或更多地选择它。这个 Bias 只影响 Expert 选择,合并输出时的权重仍由原始分数 pe(x)p_e(x) 计算,因此不会直接改变 Router 原本学到的相对分数。

Expert Parallel 为什么需要 All-to-All?

大规模 MoE 的 Experts 很多,通常无法全部放在同一张 GPU 上,因此会把不同 Experts 分布到不同 GPUs,这称为 Expert Parallel(EP)。

假设每张 GPU 最初持有一部分 Tokens,但 Router 可能把这些 Tokens 分配给任意 GPU 上的 Experts。例如,GPU 0 上的三个 Tokens 可能分别要发给 GPU 1、GPU 2 和 GPU 3。此时需要一次 All-to-All:

每张 GPU 都按目标设备拆分自己的 Tokens,同时向其他 GPUs 发送,并接收其他 GPUs 发给自己的 Tokens。

第一次 All-to-All 结束后,每张 GPU 就收集到了所有需要由本地 Experts 处理的 Tokens。Expert 计算完成后,还要进行第二次 All-to-All,把结果送回 Tokens 原来所在的 GPU,以便恢复原顺序并继续后续 Transformer 计算:

1
2
3
4
5
6
各 GPU 持有自己的 Tokens
→ 按目标 Expert 重新分组
→ 第一次 All-to-All:发送到 Expert 所在的 GPU
→ 各 GPU 运行本地 Experts
→ 第二次 All-to-All:把 Expert 输出送回原 GPU
→ 恢复原 Token 顺序

因此,MoE 虽然减少了每个 Token 激活的参数量,但会引入 Token Dispatch、All-to-All 通信和负载不均等系统开销。

3.2 MLA 如何压缩 KV Cache?

标准 MHA/GQA 在自回归生成时,需要为每层保存所有历史 Tokens 的 Key 和 Value。若当前缓存长度为 TcacheT_{\mathrm{cache}},每层 KV Cache 的元素数量为:

2TcacheHkvDh.2T_{\mathrm{cache}}H_{kv}D_h.

其中 HkvH_{kv} 是 KV Head 数,DhD_h 是每个 Head 的维度,前面的 22 分别对应 K 和 V。GQA 通过减少 HkvH_{kv} 来降低缓存;MLA 则采用另一种方法:不缓存展开后的完整 K/V,而是缓存它们共享的低维表示。

第一步:把 K/V 压缩到同一个 Latent

下文用 tt 表示当前 Query 的位置,用 ss 表示某个历史 Token 的位置。MLA 先把历史 Hidden State hs∈RDh_s\in\mathbb R^D 压缩成低维 Latent:

csKV=WDKVhs∈RDc.c_s^{KV} = W^{DKV}h_s \in\mathbb R^{D_c}.

其中:

  • DD 是模型的 Hidden Size;
  • DcD_c 是 KV Compression Dimension,通常远小于完整多头 K/V 展开后的维度;
  • WDKVW^{DKV} 是 KV Down Projection,其中 DD 表示 Down,负责将 DD 维 Hidden State 压缩到 DcD_c 维。

需要 K/V 时,理论上可以再通过两个 Up Projections 将它恢复出来:

ksC=WUKcsKV,vs=WUVcsKV.k_s^C=W^{UK}c_s^{KV}, \qquad v_s=W^{UV}c_s^{KV}.

这里:

  • WUKW^{UK} 是 Key Up Projection;
  • WUVW^{UV} 是 Value Up Projection;
  • ksCk_s^C 是历史位置 ss 的 Content Key,上标 CC 表示它只包含内容信息;
  • vsv_s 是历史位置 ss 的 Value。

整个过程是:

1
2
3
                         → Key Up Projection   → Content Key
Hidden State → Latent c
→ Value Up Projection → Value

从矩阵角度看,Content Key Projection 和 Value Projection 被分解成:

WKC=WUKWDKV,WV=WUVWDKV.W^{KC}=W^{UK}W^{DKV}, \qquad W^V=W^{UV}W^{DKV}.

K 和 V 共用同一个 Down Projection,因此历史 Token 只需缓存一份 csKVc_s^{KV}。这就是 MLA 的低秩压缩。

第二步:不用为所有历史 Tokens 恢复完整 K/V

如果每生成一个 Token,都把所有历史 Latents 重新展开成完整 K/V,虽然节省了缓存,却会增加大量重复计算。MLA 利用矩阵乘法结合律改变计算顺序。

暂时忽略多头拆分和 RoPE。设 qtCq_t^C 是当前位置 tt 的 Content Query,其维度与 ksCk_s^C 相同。以 Key 一侧为例:

(qtC)TksC=(qtC)TWUKcsKV=((WUK)TqtC)TcsKV.(q_t^C)^Tk_s^C = (q_t^C)^TW^{UK}c_s^{KV} = \left((W^{UK})^Tq_t^C\right)^Tc_s^{KV}.

等式左边是“先从 Latent 恢复 Key,再与 Query 计算点积”;右边则是“先变换当前 Query,再直接与缓存的 Latent 计算点积”。两者结果相同,但右边不需要为每个历史 Token 恢复完整 Key。

Value 一侧也可以利用矩阵乘法的线性性质改变顺序。设 at,sa_{t,s} 是当前 Query 对历史 Token ss 的 Attention Weight:

∑sat,svs=∑sat,sWUVcsKV=WUV(∑sat,scsKV).\sum_s a_{t,s}v_s = \sum_s a_{t,s}W^{UV}c_s^{KV} = W^{UV} \left(\sum_s a_{t,s}c_s^{KV}\right).

等式左边需要先为每个历史 Token 恢复完整 Value,再进行加权求和;右边则先对低维 Latents 加权求和,最后只进行一次 Value Up Projection。

Key 一侧把 Key Up Projection 吸收到 Query 上,Value 一侧把 Value Up Projection 移到加权求和之后,这两种变换合称为 Weight Absorption。

1
2
3
4
5
6
7
8
KV Cache:保存所有历史 Latents

当前 Query
→ 吸收 Key Up Projection
→ 与历史 Latents 计算 Attention
→ 对历史 Latents 加权求和
→ Value Up Projection
→ Attention Output

因此,MLA 并不是“缓存 Latent,然后每一步恢复全部 K/V”,而是尽量让 Attention 直接在 Latent 上完成。

第三步:单独处理 RoPE

上面的 Weight Absorption 依赖固定的线性投影,但 RoPE 会根据每个 Token 的位置对 Key 进行不同的旋转。如果把 RoPE 直接应用在恢复后的 Content Key 上,Key Up Projection 与位置旋转交织在一起,就无法简单地吸收到 Query 一侧。

MLA 因此把 Key 拆成两部分:

  • Content Key ksCk_s^C:由 csKVc_s^{KV} 通过 Key Up Projection 得到,负责内容匹配;它只是逻辑上恢复出的 Key,不以展开形式存入 KV Cache;
  • RoPE Key ksRk_s^R:单独生成并应用 RoPE,负责位置匹配;它的维度较小,会直接存入 KV Cache。

设 DrD_r 是低维 RoPE Part 的维度,通常远小于完整多头 Content Key 展开后的维度。简化地写,历史位置 ss 的 RoPE Key 为:

ksR=RoPE⁡(WKRhs,s)∈RDr,k_s^R = \operatorname{RoPE}(W^{KR}h_s,s) \in\mathbb R^{D_r},

其中 WKRW^{KR} 是 RoPE Key Projection,RR 表示 RoPE Part。这个 ksRk_s^R 会与 csKVc_s^{KV} 一起缓存。

Query 也拆成前面定义的 Content Query qtCq_t^C 和低维 RoPE Query qtRq_t^R。对当前 Hidden State hth_t,可以简化写成:

qtR=RoPE⁡(WQRht,t)∈RDr,q_t^R = \operatorname{RoPE}(W^{QR}h_t,t) \in\mathbb R^{D_r},

其中 WQRW^{QR} 是 RoPE Query Projection。最终 Attention Score 可以理解为:

Score⁡(t,s)=(qtC)TksC+(qtR)TksR.\operatorname{Score}(t,s) = (q_t^C)^Tk_s^C + (q_t^R)^Tk_s^R.

上式中的 ksCk_s^C 表示逻辑上的 Content Key;实际计算第一项时,通过 Weight Absorption 直接使用缓存的 csKVc_s^{KV},不会缓存或显式恢复全部 ksCk_s^C。第二项则直接使用缓存的低维 RoPE Key ksRk_s^R。

缓存量对比

由上可知,MLA 为每个历史 Token 缓存 csKVc_s^{KV} 和 ksRk_s^R,二者的维度分别为 DcD_c 和 DrD_r。因此,每层缓存元素数量约为:

Tcache(Dc+Dr),T_{\mathrm{cache}}(D_c+D_r),

而 MHA/GQA 需要缓存展开后的 K/V,元素数量为 2TcacheHkvDh2T_{\mathrm{cache}}H_{kv}D_h。MLA 不再缓存展开后的 Content Key ksCk_s^C 和 Value vsv_s,所以能够显著降低 KV Cache。

相应的代价是引入低秩投影、Weight Absorption、Decoupled RoPE 和专用 Kernel,结构与实现都比 MHA/GQA 更复杂。

3.3 Full Attention、Sparse Attention 与长上下文

Full Attention 为什么难以扩展到长上下文?

为简化符号,下面省略 Batch 和 Head 维度。设序列长度为 TT,单个 Head 的 Query、Key、Value 为:

Q,K,V∈RT×Dh.Q,K,V\in\mathbb R^{T\times D_h}.

标准 Full Attention 需要显式处理所有 Query-Key Pairs,其 Attention Score Matrix 为:

QKT∈RT×T.QK^T\in\mathbb R^{T\times T}.

在 Causal LM 中,位置 tt 的 Query 可以读取位置 11 到 tt 的所有 Keys。整条序列需要处理的 Query-Key Pairs 数量约为:

1+2+⋯+T=T(T+1)2≈O(T2).1+2+\cdots+T = \frac{T(T+1)}{2} \approx O(T^2).

所谓长上下文,就是让模型一次处理更长的 Token Sequence,也就是增大 TT。但随着 TT 增大:

  • Training 和 Prefill 需要计算的 Query-Key Pairs 按 T2T^2 增长;
  • 朴素实现中的 Attention Matrix 也按 T2T^2 增长;
  • Decode 阶段的 KV Cache 按 TT 增长,这部分已在 MLA 小节讨论。

因此,序列长度翻倍时,Full Attention 需要处理的位置对数量约变成四倍。Sparse Attention 主要解决前两个二次增长问题。

什么是 Sparse Attention?

Full Attention 在位置 tt 的可读范围是全部历史位置:

Afull(t)={1,2,…,t}.\mathcal A_{\mathrm{full}}(t) = \{1,2,\ldots,t\}.

Sparse Attention 则提前规定一个更小的可读位置集合:

Asparse(t)⊂{1,2,…,t}.\mathcal A_{\mathrm{sparse}}(t) \subset \{1,2,\ldots,t\}.

位置 tt 只和集合 Asparse(t)\mathcal A_{\mathrm{sparse}}(t) 中的 Keys 计算 Attention,其他位置在进入 Softmax 前被 Mask 掉。它仍然使用标准的 Query-Key 相似度和 Softmax,只是跳过大量不允许连接的 Token Pairs。

常见连接模式包括:

  • Sliding Window Attention:位置 tt 只读取最近 WW 个 Tokens。若每个位置最多连接 WW 个 Keys,总 Pair 数从 O(T2)O(T^2) 降到约 O(TW)O(TW);
  • Block Sparse Attention:先把 Tokens 分成 Blocks,再规定每个 Query Block 可以读取哪些 Key Blocks,以 Block 为单位跳过大片连接;
  • Global + Local Attention:大多数 Tokens 只读取局部窗口,同时保留少量 Global Tokens 连接整条序列,为远距离信息提供中转节点。

Sparse Attention 能在相同计算预算下处理更大的 TT,但代价是删除了部分 Token-to-token 直接连接:

  • 纯 Sliding Window 中,相距很远的两个 Tokens 不能在一层内直接交互,只能依靠多层逐步传递;
  • Block Pattern 如果设计不合理,可能遗漏重要的跨块依赖;
  • Global Tokens 可以建立远距离通路,但数量有限,也可能成为信息瓶颈。

所以,Sparse Attention 的核心是在保留显式 Token-to-token Attention 的前提下减少连接数量。下一节的 Linear/Recurrent Attention 更进一步:它不再保留一组不断增长的历史 K/V,而是把历史压缩进固定大小的状态。

3.4 Linear、Recurrent 与 Hybrid Attention

Linear Attention 的核心重排

标准 Softmax Attention 需要先形成 QKTQK^T。Linear Attention 使用 Feature Map ϕ(⋅)\phi(\cdot),把 Query 和 Key 映射到 DϕD_\phi 维特征空间:

ϕ:RDh→RDϕ.\phi:\mathbb R^{D_h}\rightarrow\mathbb R^{D_\phi}.

对矩阵 QQ 和 KK 逐行应用 ϕ\phi 后,可以利用矩阵乘法结合律,把核心计算从:

[ϕ(Q)ϕ(K)T]V\left[\phi(Q)\phi(K)^T\right]V

重排为:

ϕ(Q)[ϕ(K)TV].\phi(Q) \left[ \phi(K)^TV \right].

两种计算顺序的结果相同,但右边先得到大小与序列长度无关的 ϕ(K)TV\phi(K)^TV。上式省略了归一化,并且先表达非因果情况下的核心重排。

真正用于 Causal LM 时,不能把未来 Tokens 聚合进来。沿用前文的位置记号,设 tt 是当前位置,单个 Head 的 qt,kt,vt∈RDhq_t,k_t,v_t\in\mathbb R^{D_h}。可以维护两个只包含位置 11 到 tt 的历史状态:

St=St−1+ϕ(kt)vtT,zt=zt−1+ϕ(kt),S_t = S_{t-1} + \phi(k_t)v_t^T, \qquad z_t = z_{t-1} + \phi(k_t),

其中:

  • St∈RDϕ×DhS_t\in\mathbb R^{D_\phi\times D_h}:历史 Key-Value 的聚合状态;
  • zt∈RDϕz_t\in\mathbb R^{D_\phi}:用于归一化的历史 Key 聚合;
  • 初始状态 S0=0S_0=0、z0=0z_0=0。

当前位置使用 qtq_t 读取状态:

ot=ϕ(qt)TStϕ(qt)Tzt,o_t = \frac{\phi(q_t)^TS_t} {\phi(q_t)^Tz_t},

其中 ot∈RDho_t\in\mathbb R^{D_h} 是当前 Head 的输出。这样就不再显式保存或计算完整的 T×TT\times T Attention Matrix。不同 Linear/Recurrent Attention 可能修改或省略上述归一化,并加入衰减、门控或更复杂的 State Update Rule。

对于纯 Linear/Recurrent Layers,这类结构的优势是:

  • 长序列训练不需要显式构造完整 Attention Matrix;
  • Decode 时可以维护固定大小的 Recurrent State,而不是不断增长的完整 KV Cache;
  • 计算和状态开销更接近随序列长度线性增长。

但固定大小状态需要压缩历史信息,纯 Linear/Recurrent 模型通常更难做到 Full Attention 那样精确的任意位置检索。

Mamba、Gated DeltaNet 与 Kimi Delta Attention

这些结构都可以使用固定状态递推处理序列,但更新规则不同:

  • Mamba / Mamba-2:使用 Selective State Space Model,让输入控制状态的写入、保留和读取;
  • Gated DeltaNet:使用带 Forget Gate 的 Delta Rule,允许新信息修正已有状态,而不只是不断累加;
  • Kimi Delta Attention(KDA):在 Gated DeltaNet 基础上使用更细粒度的 Channel-wise Forget Gate,让不同特征维度具有不同衰减速度。

它们不能简单等同于“把 Softmax 去掉”,关键在于如何用有限状态选择性地记住、覆盖和遗忘历史信息。

为什么现代模型常采用 Hybrid Attention?

Linear/Recurrent Attention 长上下文效率高,但精确检索能力通常弱于 Full Attention;Full Attention 检索能力强,但长序列成本高。Hybrid Architecture 会交替堆叠两类 Layers:

1
2
3
若干 Linear / Recurrent Attention Layers
→ 一个 Full Attention Layer
→ 重复

大部分 Layers 负责高效压缩和传播上下文,少量 Full Attention Layers 提供全局、精确的 Token-to-token 交互。

Qwen3-Next 使用 Gated DeltaNet 与 Gated Full Attention 的混合结构;Kimi Linear 使用 KDA 与 Full MLA 的混合结构。这里的 Full MLA 仍然允许 Query 读取所有历史位置,只是使用 MLA 压缩缓存。两者的代表性配置都是连续三个 Linear/Recurrent Layers 后接一个 Full Attention Layer,但具体 Attention、Position Encoding 和 MoE 设计并不相同。

Hybrid Model 中,标准 Full Attention Layers 仍需保存随上下文增长的 K/V,Full MLA Layers 仍需保存 csKVc_s^{KV} 和 ksRk_s^R;只是这类 Layers 的占比更低。

3.5 Multi-token Prediction

标准 Causal LM 在位置 tt 只预测一个下一个 Token:

x≤t⟶xt+1.x_{\le t} \longrightarrow x_{t+1}.

Multi-token Prediction(MTP)让同一个位置或一组附加预测模块继续预测更远的未来 Tokens:

x≤t⟶xt+1,xt+2,…,xt+K.x_{\le t} \longrightarrow x_{t+1},x_{t+2},\ldots,x_{t+K}.

训练目标可以写成:

L=Lnext+λ∑k=2KLMTP,k.\mathcal L = \mathcal L_{\mathrm{next}} + \lambda \sum_{k=2}^{K} \mathcal L_{\mathrm{MTP},k}.

MTP 的主要作用包括:

  • 为每个位置提供更密集的训练信号;
  • 让 Hidden States 学习对更远未来 Tokens 也具有预测力的表示;
  • 训练得到的附加模块可以作为 Speculative Decoding 的 Draft Predictor。

MTP 不表示主模型在普通自回归生成时可以无条件一次接受多个 Tokens。若用于加速推理,额外预测出的 Tokens 仍需要由主模型验证;不用于投机解码时,MTP Modules 可以在推理阶段移除。

DeepSeek-V3 使用 Sequential MTP Modules,让多个未来 Token 的预测保持因果依赖;Qwen3-Next 也使用原生 MTP,并针对多步投机解码进行优化。

3.6 其他常见结构改进

QK-Norm

QK-Norm 在计算 Attention Score 前,分别归一化每个 Query Head 和 Key Head:

1
2
3
Q → Norm → Q'
K → Norm → K'
→ Q'K'^T

它直接控制 Q/K 的尺度,减少 Attention Logits 过大和训练不稳定的问题。QK-Norm 是 Attention 内部的额外归一化,不替代 Block 外的 RMSNorm。

Attention Output Gate

Attention Gate 会根据当前输入生成门控信号,再调节 Attention Output:

Y=g(X)⊙Attention⁡(X).Y = g(X)\odot\operatorname{Attention}(X).

模型可以按 Token、Head 或 Channel 控制 Attention 信息写回 Residual Stream 的强度。

Qwen3-Next 所说的 Gated Attention,指的是保留 Full Softmax Attention、同时在输出侧加入这种 Gate 的 Attention Layer;它与 Gated DeltaNet 是两种不同的 Token Mixing Layers。

Zero-centered RMSNorm

普通 RMSNorm 的缩放参数通常初始化为 11。Zero-centered RMSNorm 将实际缩放写成 1+w1+w,并把 ww 初始化为 00。初始行为仍等价于单位缩放,但可学习参数以 00 为中心,便于配合 Weight Decay 和训练稳定性设计。

Partial RoPE 与长上下文 RoPE

并非所有模型都对完整 Head Dimension 应用 RoPE。Partial RoPE 只旋转其中一部分维度,其余维度保留为纯 Content Features。长上下文模型还会使用 RoPE Scaling、YaRN 等方法调整频率,使模型能够处理超过原始训练长度的上下文。

这些改进通常不是单独决定模型能力的主干,而是与 Attention、MoE 和长上下文设计共同使用。

3.7 如何理解代表模型的结构?

LLaMA 与 Qwen2.5

可以把它们看成上一章 Dense Decoder-only Transformer 的代表:

1
RoPE + MHA/GQA + RMSNorm + SwiGLU Dense FFN

它们适合用来理解现代 LLM 的基础骨架。

Mixtral 与 Qwen3 MoE

它们主要把 Dense FFN 替换为 Sparse MoE,Attention 仍属于标准 Transformer 路线:

1
2
Standard Attention
→ Sparse MoE FFN

重点是 Routing、Top-k Experts、Load Balancing 和 Expert Parallel。

DeepSeek-V3

DeepSeek-V3 同时沿三条路线优化:

1
2
3
MLA:压缩 KV Cache
DeepSeekMoE:扩大稀疏参数容量
MTP:增强训练信号并支持投机解码

它仍然属于 Transformer 框架,并不是 Linear Attention 模型。

Kimi K2

Kimi K2 采用 MLA 与高稀疏 MoE,重点同样是降低 KV Cache 和每个 Token 的激活计算量。

Qwen3-Next

Qwen3-Next 面向超长上下文和高稀疏参数扩展,组合了:

1
2
3
4
3 × Gated DeltaNet
→ 1 × Gated Attention
→ 高稀疏 MoE
→ MTP

标准 Attention Layers 还加入 Output Gate、Partial RoPE 等设计,并使用 Zero-centered RMSNorm 提高训练稳定性。

Kimi Linear

Kimi Linear 使用:

1
2
3
3 × Kimi Delta Attention
→ 1 × Full MLA
→ Shared + Routed MoE

KDA 负责大部分高效序列建模,周期性的 Full MLA 弥补长距离精确检索能力。

3.8 四条演化路线如何配合?

这些技术不是互相替代关系:

1
2
3
4
5
6
7
8
9
10
11
MoE
→ 主要优化参数容量与每 Token 激活计算

MLA
→ 主要优化 Full Attention 的 KV Cache

Linear / Recurrent / Hybrid Attention
→ 主要优化长序列计算与状态表示

MTP
→ 主要改变训练目标,并可服务于投机解码

一个模型可以同时使用多条路线。例如 DeepSeek-V3 同时使用 MLA、MoE 和 MTP;Qwen3-Next 同时使用 Hybrid Attention、MoE 和 MTP;Kimi Linear 同时使用 KDA、MLA 和 MoE。

3.9 本章小结

  • Dense FFN 为每个 Token 激活全部参数;Sparse MoE 只激活少量 Experts,以较小的激活计算获得更大的总参数容量;
  • GQA 通过减少 K/V Heads 降低 KV Cache,MLA 则将多头 K/V 联合压缩为 Latent Representation;
  • Full Attention 提供精确的 Token-to-token 交互,但长序列成本高;
  • Linear/Recurrent Attention 使用固定状态压缩历史,效率更高,但精确检索能力通常较弱;
  • Hybrid Attention 用少量 Full Attention Layers 弥补 Linear/Recurrent Layers 的检索能力;
  • MTP 增加未来 Token 监督,并可为 Speculative Decoding 提供 Draft Tokens;
  • 现代 LLM 的架构改进通常同时围绕参数容量、KV Cache、长上下文和训练信号展开。

四、主流 DiT 模型架构

DiT(Diffusion Transformer)和 VLM(Vision-Language Model)都使用 Transformer,但解决的问题不同:

  • DiT 使用 Transformer 处理带噪图像或视频表示,目标是逐步生成视觉内容;
  • VLM 将视觉信息接入语言模型,目标是理解图像并生成文本。

4.1 DiT:用 Transformer 完成去噪

DiT(Diffusion Transformer)首先是一个 Diffusion Model 的去噪网络。它要解决的问题是:

已知一份被噪声污染的图像表示、当前噪声强度以及生成条件,预测应该去掉什么噪声,从而逐步还原出图像。

传统 Diffusion Model 通常使用 U-Net 完成这个预测,DiT 则把去噪 Backbone 换成 Transformer。因此,DiT 并不是新的扩散过程,而是 Diffusion Model 的一种网络架构。

训练数据是如何构造的?

先考虑最常见的 Noise Prediction 目标。设:

  • x0x_0:一张干净图像,或者它经过 VAE 编码后的干净 Latent;
  • TT:总 Diffusion Steps;
  • t∈{1,…,T}t\in\{1,\ldots,T\}:随机采样的时间步;
  • ϵ∼N(0,I)\epsilon\sim\mathcal N(0,I):与 x0x_0 Shape 相同的 Gaussian Noise;
  • αˉt∈(0,1]\bar\alpha_t\in(0,1]:由预先设定的 Noise Schedule 决定的信号保留比例;
  • xtx_t:在时间步 tt 得到的带噪样本。

Forward Noising Process 为:

xt=αˉt x0+1−αˉt ϵ.x_t = \sqrt{\bar\alpha_t}\,x_0 + \sqrt{1-\bar\alpha_t}\,\epsilon.

当 tt 较小时,αˉt\bar\alpha_t 较大,xtx_t 中保留的原始图像较多;当 tt 接近 TT 时,αˉt\bar\alpha_t 很小,xtx_t 接近纯 Gaussian Noise。

训练样本并不是事先保存的所有带噪图像,而是每次从真实样本 x0x_0 出发,随机选择 tt 和 ϵ\epsilon,即时构造 xtx_t。

DiT 具体学习什么?

DiT 接收:

  1. 带噪样本 xtx_t;
  2. 当前时间步 tt;
  3. 可选生成条件 cc,例如类别标签或 Text Prompt。

在 Noise Prediction 参数化下,模型输出对噪声的预测:

ϵ^=ϵθ(xt,t,c),\hat\epsilon = \epsilon_\theta(x_t,t,c),

其中 θ\theta 表示 DiT 的全部可训练参数。因为构造 xtx_t 时使用的真实噪声 ϵ\epsilon 是已知的,所以可以直接使用 MSE Loss:

Lsimple=Ex0,t,ϵ[∥ϵ−ϵθ(xt,t,c)∥22].\mathcal L_{\mathrm{simple}} = \mathbb E_{x_0,t,\epsilon} \left[ \left\| \epsilon-\epsilon_\theta(x_t,t,c) \right\|_2^2 \right].

也就是说,训练过程可以概括为:

1
2
3
4
5
干净样本 x_0
→ 随机采样时间步 t 和噪声 ε
→ 构造带噪样本 x_t
→ DiT 根据 x_t、t、条件 c 预测噪声 ε̂
→ 计算 ε̂ 与真实噪声 ε 的误差

不同模型也可能预测 Clean Sample x0x_0、Velocity vv,或者 Flow Matching 中的 Vector Field。它们的输出定义和训练目标不同,但核心任务相同:学习从当前带噪状态向干净数据分布移动的方向。

推理时如何生成图像?

推理时没有干净图像 x0x_0,而是从纯噪声开始:

xT∼N(0,I).x_T\sim\mathcal N(0,I).

在第 tt 步,DiT 根据当前 xtx_t 预测噪声或其他去噪目标,Sampler 再利用该预测计算噪声更少的 xt−1x_{t-1}:

xt→ ϵθ(xt,t,c) xt−1.x_t \xrightarrow{\ \epsilon_\theta(x_t,t,c)\ } x_{t-1}.

不断重复:

xT→xT−1→⋯→x1→x0,x_T \rightarrow x_{T-1} \rightarrow \cdots \rightarrow x_1 \rightarrow x_0,

最终得到生成结果。因此,DiT 通常不是一次 Forward 就生成图像,而是在多个采样步中反复调用同一个网络。

4.2 图像如何进入 DiT?

直接在高分辨率 RGB Image 上做 Diffusion 成本很高,因此现代图像生成模型通常先使用 VAE 将图像压缩到 Latent Space,再让 DiT 处理 Latent。

设:

  • BB:Batch Size;
  • Himg,WimgH_{\mathrm{img}},W_{\mathrm{img}}:原图的高度和宽度;
  • CC:Latent Channels;
  • H,WH,W:Latent Feature Map 的高度和宽度;
  • DD:Transformer Hidden Size;
  • PP:每个方形 Latent Patch 的边长。

输入图像与 VAE 输出分别为:

I∈RB×3×Himg×Wimg,I \in \mathbb R^{B\times3\times H_{\mathrm{img}}\times W_{\mathrm{img}}},

z0=VAEEnc⁡(I)∈RB×C×H×W.z_0 = \operatorname{VAEEnc}(I) \in \mathbb R^{B\times C\times H\times W}.

z0z_0 是干净 Image Latent。训练时向它加噪,得到 Shape 不变的:

zt∈RB×C×H×W.z_t \in \mathbb R^{B\times C\times H\times W}.

第一步:Patchify

DiT 不能直接把四维 Feature Map 送入标准 Transformer,因此先把 ztz_t 划分为不重叠的 P×PP\times P Patches。假设 HH 和 WW 都能被 PP 整除,Patch 数量为:

N=HPWP.N = \frac{H}{P}\frac{W}{P}.

每个 Patch 包含 C×P×PC\times P\times P 个数,展平后的维度为 CP2CP^2。因此 Patchify 后的 Shape 为:

Zpatch∈RB×N×CP2.Z_{\mathrm{patch}} \in \mathbb R^{B\times N\times CP^2}.

第二步:转换成 Transformer Tokens

使用可学习的 Linear Projection:

Z(0)=ZpatchWin+bin,Z^{(0)} = Z_{\mathrm{patch}}W_{\mathrm{in}}+b_{\mathrm{in}},

其中:

Win∈RCP2×D,Z(0)∈RB×N×D.W_{\mathrm{in}} \in \mathbb R^{CP^2\times D}, \qquad Z^{(0)} \in \mathbb R^{B\times N\times D}.

再加入 Position Embedding,使模型知道每个 Token 对应原图中的哪个 Patch。此时,NN 相当于序列长度,DD 相当于每个 Token 的 Hidden Dimension。

第三步:经过 DiT Blocks

Image Tokens 会依次经过 LL 个 DiT Blocks。每个 Block 的输入与输出 Shape 都保持不变:

Z(0),Z(1),…,Z(L)∈RB×N×D.Z^{(0)},Z^{(1)},\ldots,Z^{(L)} \in \mathbb R^{B\times N\times D}.

每个 DiT Block 都会通过 Self-Attention 和 FFN 更新这些 Image Tokens,并根据 Timestep 改变处理方式。这里先说明 DiT 的 Attention 与 LLM 有什么区别,完整 Block 结构和条件注入统一放在下一节展开。

DiT 的 Self-Attention 使用 Bidirectional Attention。这里的 Bidirectional 不是两套方向相反的网络,而是指第 ii 个 Image Token 可以关注全部 NN 个 Image Tokens:

Token i⟶{Token 1,…,Token N}.\text{Token }i \longrightarrow \{\text{Token }1,\ldots,\text{Token }N\}.

因为整张带噪 Latent 已经同时输入模型,不存在“尚未生成的未来 Patch”,所以 DiT 不需要 Causal Mask。相比之下,Decoder-only LLM 需要逐 Token 生成文本,第 ii 个 Token 只能关注第 11 到第 ii 个位置。

通过这种 Attention,左上角 Patch 也能使用右下角 Patch 的信息,从而根据整张图像的结构预测局部噪声。

经过全部 DiT Blocks 后得到:

Z(L)∈RB×N×D,Z^{(L)} \in \mathbb R^{B\times N\times D},

其中 LL 是 Transformer Blocks 的数量。

第四步:恢复 Latent Shape

最后使用 Linear Layer 把每个 DD 维 Token 投影回 CP2CP^2 维,再执行 Unpatchify:

ϵ^patch∈RB×N×CP2⟶ϵ^∈RB×C×H×W.\hat\epsilon_{\mathrm{patch}} \in \mathbb R^{B\times N\times CP^2} \longrightarrow \hat\epsilon \in \mathbb R^{B\times C\times H\times W}.

ϵ^\hat\epsilon 与输入 ztz_t 的 Shape 相同,表示模型对每个 Latent 位置中噪声的预测。

Latent DiT 的整体流程为:

1
2
3
4
5
6
7
8
Image I
→ VAE Encoder 得到干净 Latent z_0
→ 加噪得到 z_t
→ Patchify + Linear Projection,得到 Image Tokens
→ 加入 Position、Timestep 与生成条件
→ 多个 DiT Blocks
→ Linear Projection + Unpatchify
→ 预测与 z_t Shape 相同的噪声 ε̂

训练时用 ϵ^\hat\epsilon 计算 Loss;推理时由 Sampler 使用 ϵ^\hat\epsilon 逐步更新 Latent,最后把去噪完成的 z0z_0 送入 VAE Decoder,还原为 RGB Image。

4.3 一个 DiT Block 如何工作?

这一节先理解不带条件的普通 Transformer Block,再逐步加入两类信息:

  1. 通过 adaLN-Zero 注入 Timestep、Class Label 等全局条件;
  2. 通过 Cross-Attention 注入 Text Prompt 等包含多个 Tokens 的 Context。

这样既能看清 DiT Block 的基本结构,也能区分不同条件分别如何进入模型。

4.3.1 先看不带条件的 Block

设一个 Block 接收:

H∈RB×N×D,H\in\mathbb R^{B\times N\times D},

其中 BB 是 Batch Size,NN 是 Image Tokens 数量,DD 是每个 Token 的维度。

Block 中依次有两个模块:

1
2
3
4
5
H
→ Self-Attention:让不同 Patches 交换信息
→ H_1
→ FFN:分别变换每个 Patch 的特征
→ H_{\mathrm{out}}

第一个模块是 Self-Attention:

H1=H+SelfAttn⁡(LN⁡(H)).H_1 = H + \operatorname{SelfAttn}\bigl(\operatorname{LN}(H)\bigr).

这里先对 HH 做 LayerNorm,再让所有 Image Tokens 通过 Self-Attention 交换信息,最后把得到的新信息加回原来的 HH。

第二个模块是 FFN:

Hout=H1+FFN⁡(LN⁡(H1)).H_{\mathrm{out}} = H_1 + \operatorname{FFN}\bigl(\operatorname{LN}(H_1)\bigr).

FFN 不负责 Token 之间的交流,而是对每个 Token 分别做同样的非线性变换。两条公式中的“加回原输入”称为 Residual Connection。

因此,普通 Block 的逻辑很简单:

1
2
3
Attention 负责 Token 之间交流
→ FFN 负责各 Token 内部的特征变换
→ 两个模块都通过 Residual Connection 写入新信息

4.3.2 为什么还要输入 Timestep?

DiT 会在所有去噪时间步复用同一套网络参数,但不同阶段的任务并不相同:

  • tt 较大时噪声多,模型主要恢复图像的整体结构;
  • tt 较小时噪声少,模型主要修正局部细节。

如果 Block 只看到带噪 Image Tokens,它不知道当前处于哪个阶段。因此还要把时间步 tt 告诉每个 DiT Block。

对一个 Batch,时间步为:

t∈RB.t\in\mathbb R^B.

第 bb 个数对应第 bb 张图。但整数 tt 本身只有一个数,不能直接表达不同噪声阶段之间的丰富关系,因此先使用多组不同频率的正弦和余弦把它展开成向量。

假设 DD 为偶数,并令:

m=D2.m=\frac{D}{2}.

先设置 mm 个从高频到低频变化的频率:

ωk=exp⁡(−km−1log⁡M),k=0,1,…,m−1,\omega_k = \exp \left( -\frac{k}{m-1}\log M \right), \qquad k=0,1,\ldots,m-1,

其中:

  • kk:频率的索引;
  • MM:控制最小频率范围的常数,通常取一个较大的值;
  • ωk\omega_k:第 kk 个频率。

对一个时间步 tt,分别计算:

s(t)2k=sin⁡(tωk),s(t)2k+1=cos⁡(tωk),s(t)_{2k} = \sin(t\omega_k), \qquad s(t)_{2k+1} = \cos(t\omega_k),

得到:

s(t)∈RD.s(t) \in \mathbb R^D.

也就是说,每一个时间步都会被表示成由多组不同频率的 Sin/Cos 值组成的 DD 维向量。低频分量随 tt 变化较慢,用来表示较大尺度的时间关系;高频分量变化较快,用来区分相近的时间步。

对整个 Batch 同时计算后:

S=SinusoidalEmbedding⁡(t)∈RB×D.S = \operatorname{SinusoidalEmbedding}(t) \in \mathbb R^{B\times D}.

Sinusoidal Embedding 本身没有可学习参数。随后再使用可学习的 MLP 对时间表示进行变换:

et=MLP⁡(S)∈RB×D.e_t = \operatorname{MLP}(S) \in \mathbb R^{B\times D}.

ete_t 是最终的 Timestep Embedding。Sinusoidal Embedding 先提供固定、连续且可区分的时间位置表示,MLP 再学习如何把这些频率特征转换成适合当前去噪任务的条件向量。ete_t 随后会被送给每一个 DiT Block。

如果还有类别标签,则先得到 Class Embedding:

ec∈RB×D,e_c\in\mathbb R^{B\times D},

再将两种全局条件合并:

e=et+ec.e=e_t+e_c.

没有类别条件时,e=ete=e_t。

4.3.3 adaLN-Zero 如何把条件放进 Block?

最关键的一点是:原始 DiT 不是把 ee 直接作为一个新 Token 插入序列,而是让它改变 Block 处理 HH 的方式。

当前 Block 使用一个小 MLP,将条件向量 ee 转换成两套参数:

1
2
3
4
条件 e
→ Modulation MLP
→ Attention 使用的 Scale、Shift、Gate
→ FFN 使用的 Scale、Shift、Gate

用符号表示为:

(γA,βA,gA,γF,βF,gF)=MLP⁡mod(e).(\gamma_A,\beta_A,g_A,\gamma_F,\beta_F,g_F) = \operatorname{MLP}_{\mathrm{mod}}(e).

下标 AA 表示 Attention,下标 FF 表示 FFN。每个参数的 Shape 都为:

γ,β,g∈RB×1×D.\gamma,\beta,g \in \mathbb R^{B\times1\times D}.

而 Image Hidden States 的 Shape 是 B×N×DB\times N\times D。运算时,中间长度为 11 的维度会 Broadcast 到 NN,所以:

同一张图的 NN 个 Image Tokens 都会收到相同的 Timestep/Class 全局条件。

这个条件不会覆盖 Token 原本的内容,而是通过三个参数调节计算:

  • γ\gamma(Scale):各 Hidden Channels 缩放多少;
  • β\beta(Shift):各 Hidden Channels 平移多少;
  • gg(Gate):模块产生的新信息以多大强度加回原输入。

4.3.4 加入条件后的完整计算

先处理 Self-Attention。原来直接使用 LN⁡(H)\operatorname{LN}(H),现在先用全局条件 ee 生成的 Scale 和 Shift 调整它:

H~A=(1+γA)⊙LN⁡(H)+βA.\widetilde H_A = \bigl(1+\gamma_A\bigr) \odot\operatorname{LN}(H) + \beta_A.

再执行 Attention,并用 Gate 控制写回强度:

H1=H+gA⊙SelfAttn⁡(H~A).H_1 = H + g_A\odot \operatorname{SelfAttn}(\widetilde H_A).

然后对 FFN 做完全对应的处理:

H~F=(1+γF)⊙LN⁡(H1)+βF,\widetilde H_F = \bigl(1+\gamma_F\bigr) \odot\operatorname{LN}(H_1) + \beta_F,

Hout=H1+gF⊙FFN⁡(H~F).H_{\mathrm{out}} = H_1 + g_F\odot \operatorname{FFN}(\widetilde H_F).

与普通 Transformer Block 对比,adaLN-Zero 只增加了三件事:

  1. 用 γ\gamma 缩放 LayerNorm 的结果;
  2. 用 β\beta 平移 LayerNorm 的结果;
  3. 用 gg 控制 Attention 或 FFN 输出的写回强度。

因为 γ\gamma、β\beta 和 gg 都由全局条件 ee 产生,所以同一个 Block 会根据当前 Timestep 和 Class Label 采用不同的处理方式。这就是 Timestep/Class Condition 通过 adaLN-Zero 注入 DiT Block 的具体含义。

虽然一张图的 NN 个 Tokens 共享这些参数,但每个 Token 自身的 Hidden State 不同,所以它们不会变成相同的表示。

adaLN-Zero 中的 “Zero” 表示 Modulation MLP 的最后一层采用 Zero Initialization。训练开始时 gAg_A 和 gFg_F 接近 00:

H1≈H,Hout≈H1.H_1\approx H, \qquad H_{\mathrm{out}}\approx H_1.

因此每个 Block 初始接近 Identity Mapping,随后再逐渐学会写入多少新信息,训练会更加稳定。

完整数据流可以总结为:

1
2
3
4
5
6
7
8
时间步 t → Timestep Embedding e_t ─┐
类别 c → Class Embedding e_c ────┴→ 条件 e
↓
Modulation MLP
↓
两套 Scale、Shift、Gate
↓
Image Tokens H → 条件化 Attention → 条件化 FFN → H_out

4.3.5 Text Prompt 如何注入?

Timestep 和类别都是整张图共享的全局条件。Text Prompt 则包含多个词,不同 Patches 可能需要读取不同的词,因此 Text-to-image DiT 通常还会使用 Cross-Attention。

Text Encoder 将 Prompt 转换成:

Ctext∈RB×Nc×Dc,C_{\mathrm{text}} \in \mathbb R^{B\times N_c\times D_c},

其中 NcN_c 是 Text Tokens 数量,DcD_c 是 Text Encoder Hidden Size。

在常见的 Text-conditioned DiT Block 中,Cross-Attention 插在 Image Self-Attention 之后、FFN 之前。因此,Block 结构从原来的:

1
2
Image Self-Attention
→ FFN

变成:

1
2
3
Image Self-Attention
→ Text Cross-Attention
→ FFN

联系前面的符号,H1H_1 是 Image Self-Attention 更新后的结果:

H1=H+Image Self-Attention 的输出.H_1 = H + \text{Image Self-Attention 的输出}.

Cross-Attention 接下来以 H1H_1 中的 Image Tokens 作为 Query,以 Text Tokens 作为 Key 和 Value:

Q=H1WQ,K=CtextWK,V=CtextWV.Q=H_1W_Q, \qquad K=C_{\mathrm{text}}W_K, \qquad V=C_{\mathrm{text}}W_V.

计算 Cross-Attention:

X=softmax⁡(QK⊤dh)V,X = \operatorname{softmax} \left( \frac{QK^\top}{\sqrt{d_h}} \right)V,

其中 dhd_h 是每个 Attention Head 的维度,X∈RB×N×DX\in\mathbb R^{B\times N\times D} 是每个 Image Token 从 Text Tokens 中读取到的信息。

与 Self-Attention 一样,Cross-Attention 的结果也通过 Residual Connection 加回 Image Hidden States:

H2=H1+X.H_2=H_1+X.

然后 FFN 不再处理原来的 H1H_1,而是处理已经融合文本信息的 H2H_2:

Hout=H2+FFN⁡(LN⁡(H2)).H_{\mathrm{out}} = H_2 + \operatorname{FFN}\bigl(\operatorname{LN}(H_2)\bigr).

这里为了突出 Cross-Attention 的插入位置,省略了上一节的 γ\gamma、β\beta 和 Gate;实际模型仍然可以继续使用 Timestep/Class Condition 对 Normalization 和 Residual Update 进行调制。

所以一层 Text-conditioned DiT Block 的信息流为:

1
2
3
4
5
6
7
Image Tokens H
→ Image Self-Attention:Image Patches 之间交流
→ H_1
→ Text Cross-Attention:每个 Image Patch 读取相关 Text Tokens
→ H_2
→ FFN:进一步变换融合后的特征
→ H_out

不同实现可能调整 Cross-Attention 的具体位置、Normalization 和 Gate,但“Image Tokens 作为 Query 读取 Text Context”这一核心不变。

4.4 主流 DiT 架构

现代 Text-to-image DiT 的主要区别在于:Image Tokens 和 Text Tokens 如何交互。沿着这条主线,可以分成以下几类。

原始 DiT

原始 DiT 面向 Class-conditional Image Generation:

1
2
3
4
5
Noisy Image Latent
→ Patchify 成单一 Image Token Stream
→ 使用 adaLN-Zero 注入 Timestep 和 Class Label
→ 多个 DiT Blocks
→ 预测每个 Latent Patch 中的噪声

它只有 Image Token Stream,类别信息不是作为另一段 Token Sequence 参与 Attention,而是通过 adaLN-Zero 调制每个 Block。

Image Stream + Text Cross-Attention

Text-to-image DiT 增加 Text Encoder,并通过 Cross-Attention 或条件调制注入 Prompt。以 Cross-Attention 路线为例,每个 Block 大致执行:

1
2
3
Image Self-Attention:Image Tokens 之间交换信息
→ Text Cross-Attention:Image Tokens 读取 Text Tokens
→ FFN:更新每个 Image Token

PixArt-α\alpha 属于这种路线。它始终以 Image Tokens 为主要状态,Text Features 主要作为外部条件供 Image Tokens 查询。

这类架构中,Image Stream 会随着每层不断更新;Text Tokens 通常由 Text Encoder 预先计算,并在各层中作为 Key/Value 被读取。Cross-Attention 主要更新 Image Tokens,不会反过来更新 Text Tokens。

Single-stream Joint Attention

另一种方式是将 Image Tokens 和 Text Tokens 映射到相同 Hidden Size,再沿 Token 维度直接拼接:

Hjoint=[HI;HT]∈RB×(NI+NT)×D,H_{\mathrm{joint}} = [H_I;H_T] \in \mathbb R^{B\times(N_I+N_T)\times D},

其中:

  • HI∈RB×NI×DH_I\in\mathbb R^{B\times N_I\times D}:Image Tokens;
  • HT∈RB×NT×DH_T\in\mathbb R^{B\times N_T\times D}:Text Tokens;
  • [ ; ][\ ;\ ]:沿 Token 维度拼接。

拼接后的所有 Tokens 使用同一套 Transformer Parameters:

1
2
3
4
[Image Tokens; Text Tokens]
→ Shared Self-Attention
→ Shared FFN
→ 更新后的 [Image Tokens; Text Tokens]

Attention 的 Key/Value 同时包含两种 Tokens,所以 Image 和 Text 可以双向读取彼此的信息。它结构简单、融合充分,但两种模态从较早阶段就共享参数,对模态差异的显式保留较少。

MMDiT

MMDiT(Multimodal Diffusion Transformer)可以理解为:

Image 和 Text 保留各自的参数,但在同一次 Joint Attention 中交换信息。

设一个 MMDiT Block 的两路输入为:

HI∈RB×NI×D,HT∈RB×NT×D.H_I\in\mathbb R^{B\times N_I\times D}, \qquad H_T\in\mathbb R^{B\times N_T\times D}.

两种模态先使用各自的参数产生 Query、Key 和 Value:

(QI,KI,VI)=HI(WQI,WKI,WVI),(Q_I,K_I,V_I) = H_I(W_Q^I,W_K^I,W_V^I),

(QT,KT,VT)=HT(WQT,WKT,WVT).(Q_T,K_T,V_T) = H_T(W_Q^T,W_K^T,W_V^T).

上标 II 和 TT 表示两种模态使用不同的 Projection Parameters。接着沿 Token 维度拼接两路 QQ、KK 和 VV:

Qjoint=[QI;QT],Kjoint=[KI;KT],Vjoint=[VI;VT].Q_{\mathrm{joint}}=[Q_I;Q_T], \qquad K_{\mathrm{joint}}=[K_I;K_T], \qquad V_{\mathrm{joint}}=[V_I;V_T].

然后统一计算一次 Joint Attention:

Ojoint=softmax⁡(QjointKjoint⊤dh)Vjoint.O_{\mathrm{joint}} = \operatorname{softmax} \left( \frac{ Q_{\mathrm{joint}}K_{\mathrm{joint}}^\top }{ \sqrt{d_h} } \right) V_{\mathrm{joint}}.

由于 Joint Key/Value 同时包含 Image 和 Text:

  • Image Query 可以读取 Image Tokens 和 Text Tokens;
  • Text Query 也可以读取 Text Tokens 和 Image Tokens。

因此,两种模态会双向交换信息。Attention 输出再按照原来的 Token 数拆回两路:

Ojoint⟶(OI,OT),O_{\mathrm{joint}} \longrightarrow (O_I,O_T),

其中:

OI∈RB×NI×D,OT∈RB×NT×D.O_I\in\mathbb R^{B\times N_I\times D}, \qquad O_T\in\mathbb R^{B\times N_T\times D}.

两路输出随后继续使用各自的 Output Projection、Residual Connection 和 FFN:

1
2
3
4
5
Image Stream → Image-specific Q/K/V ┐
├→ Joint Attention → 拆回两路
Text Stream → Text-specific Q/K/V ┘
↓
Image-specific FFN / Text-specific FFN

它与普通 Cross-Attention 的关键区别是:

  • Cross-Attention:Image Stream 读取 Text Features,主要更新 Image Stream;
  • MMDiT:Image/Text 都参与 Joint Attention,两路 Hidden States 都会继续更新。

Stable Diffusion 3 使用了 MMDiT。它既保留两种模态各自适合的参数,又让它们在 Attention 中直接交互。

Double-stream + Single-stream Hybrid

FLUX 等模型进一步组合了 Double-stream 与 Single-stream 两个阶段。

在 Double-stream Blocks 中:

1
2
3
Image Tokens → Image-specific Parameters ┐
├→ Joint Attention
Text Tokens → Text-specific Parameters ┘

这一阶段与 MMDiT 思路相近:两种 Tokens 保持各自的 Hidden States 和部分独立参数,同时通过 Joint Attention 交换信息。这样可以先保留 Image 与 Text 的模态差异。

经过若干 Double-stream Blocks 后,再将两种 Tokens 合并:

Hjoint=[HI;HT].H_{\mathrm{joint}}=[H_I;H_T].

接着进入 Single-stream Blocks:

1
2
3
[Image Tokens; Text Tokens]
→ Shared Transformer Parameters
→ 联合更新两种 Tokens

此时两种模态不再使用两套独立的 Block 参数,而是作为一个统一 Sequence 继续处理,从而进行更充分的融合。

因此,两个阶段的分工是:

  • Double-stream:先保留模态差异,同时开始交换信息;
  • Single-stream:再共享参数,对融合后的多模态 Sequence 做统一建模。

如何理解当前主流路线?

当前主流 Text-to-image DiT 基本可以用以下交互方式来理解:

  1. Cross-Attention:Image Stream 单向读取 Text Context,例如 PixArt 类架构;
  2. Single-stream Joint Attention:Image/Text Tokens 较早拼接并共享 Transformer;
  3. MMDiT / Double-stream Joint Attention:两种模态使用不同参数,但在 Attention 中双向交互,例如 Stable Diffusion 3;
  4. Double-stream + Single-stream Hybrid:先分流处理,再合流统一建模,例如 FLUX。

不同模型还会在 Attention 类型、Position Encoding、Token Compression、Skip Connection,以及 Diffusion 或 Flow Matching Objective 上继续改进;但就 Backbone 中 Image/Text 的组织方式而言,上述四类覆盖了当前最主要的 DiT 架构路线。

4.5 DiT 与 U-Net 的主要区别

U-Net 和 DiT 在 Diffusion Model 中承担相同职责:输入当前带噪表示和条件,输出噪声或其他去噪目标。区别主要在 Backbone。

U-Net 使用 Convolution,并通过 Downsampling 和 Upsampling 构建多尺度 Feature Maps,再用 Skip Connections 融合不同分辨率的信息。它具有较强的局部性和图像多尺度先验。

DiT 把 Feature Map 转换成 Token Sequence,主要依靠 Self-Attention 和 FFN 处理:

  • Global Attention 可以直接建模相距很远的 Image Patches;
  • 架构规则,容易复用 LLM 领域的 Scaling、并行训练和高效 Attention 技术;
  • 随着 Model Size、Data 和 Compute 增加,通常具有较好的扩展性;
  • 但标准 Self-Attention 对 Token 数 NN 的计算复杂度为 O(N2D)O(N^2D),高分辨率或较小 Patch Size 会显著增加成本;
  • 相比 U-Net,DiT 的图像局部性与多尺度结构更多需要从数据中学习。

因此,使用 DiT 并没有改变“逐步去噪生成图像”这一基本过程,改变的是每一步中负责理解带噪图像并预测去噪方向的网络。

五、主流 VLM 模型架构

5.1 VLM 的基本组成

VLM(Vision-Language Model)的核心任务是:把图像或视频转换成语言模型能够读取的信息,再根据视觉内容和用户指令生成回答。

当前主流生成式 VLM 通常包含三个核心部分:

1
2
3
4
5
Image
→ Vision Encoder
→ Vision-Language Connector
→ LLM
→ Text Response

下面按照真实的数据流逐步说明。

第一步:Vision Encoder 提取视觉特征

设输入图像为:

I∈RB×3×H×W,I \in \mathbb R^{B\times3\times H\times W},

其中 BB 是 Batch Size,H,WH,W 是图像高度和宽度。

Vision Encoder 通常采用 ViT。若 Patch Size 为 P×PP\times P,图像首先被切成:

Nv=HPWPN_v = \frac{H}{P}\frac{W}{P}

个 Patches,再经过 ViT 得到:

Fv∈RB×Nv×Dv,F_v \in \mathbb R^{B\times N_v\times D_v},

其中:

  • NvN_v:Visual Tokens 数量;
  • DvD_v:Vision Encoder 的 Hidden Size。

此时第 ii 个 Visual Token 表示图像中某个 Patch 或局部区域的视觉特征,但它还不能直接作为 LLM 的输入,因为 Vision Encoder 与 LLM 的 Hidden Size 和表示空间通常不同。

第二步:Connector 对齐视觉与语言空间

Connector 接收 FvF_v,主要完成两个任务:

  1. 把特征维度从 DvD_v 转换成 LLM Hidden Size DlD_l;
  2. 可选地压缩 Visual Tokens 数量,降低 LLM 的计算成本。

其输出为:

Zv=fconnector(Fv)∈RB×Nv′×Dl,Z_v = f_{\mathrm{connector}}(F_v) \in \mathbb R^{B\times N'_v\times D_l},

其中:

  • DlD_l:LLM Hidden Size;
  • Nv′N'_v:送入 LLM 的 Visual Tokens 数量。

如果 Connector 只是逐 Token Linear/MLP Projector,则通常 Nv′=NvN'_v=N_v;如果使用 Patch Merge、Q-Former 或 Resampler,则 Nv′<NvN'_v<N_v。

第三步:Visual Tokens 如何进入 LLM?

设用户文本经过 Token Embedding 后得到:

Zt∈RB×Nt×Dl,Z_t \in \mathbb R^{B\times N_t\times D_l},

其中 NtN_t 是 Text Tokens 数量。由于 ZvZ_v 与 ZtZ_t 的最后一维都为 DlD_l,可以沿序列维度拼接:

Zinput=[Zsystem;Zuser;Zv;Zprompt].Z_{\mathrm{input}} = [Z_{\mathrm{system}};Z_{\mathrm{user}};Z_v;Z_{\mathrm{prompt}}].

实际输入序列可以理解为:

1
2
3
4
5
6
[System Tokens]
[User Text Tokens]
[Image Start]
[Visual Token 1] ... [Visual Token N'_v]
[Image End]
[Remaining Prompt Tokens]

其中 <image> 等占位符通常会在模型内部被替换为真正的 Visual Embeddings,而不是让 LLM 只看到一个普通文本 Token。

LLM 对拼接后的 Sequence 做 Causal Self-Attention。生成回答时,每个新生成的 Text Token 都可以关注前面的 System Prompt、User Prompt 和全部 Visual Tokens,因此能够根据图像内容作答。

最后,LLM 自回归生成:

y=(y1,y2,…,yT),y=(y_1,y_2,\ldots,y_T),

其中 yty_t 是回答中的第 tt 个 Text Token。完整流程为:

1
2
3
4
5
6
Image
→ Vision Encoder 得到 Visual Features
→ Connector 对齐维度并可选压缩
→ Visual Tokens 与 Text Tokens 拼接
→ LLM 统一读取视觉和文字上下文
→ 自回归生成 Text Response

大多数理解型 VLM 并不是让 LLM 自回归生成 Visual Tokens。图像被编码为输入上下文,模型最终仍然逐 Token 生成文本。

5.2 当前主流 VLM 架构

Dual Encoder

CLIP 分别使用 Image Encoder 和 Text Encoder 得到两个全局向量,再通过 Contrastive Learning 拉近匹配图文、推远不匹配图文:

1
2
Image → Image Encoder → Image Embedding
Text → Text Encoder → Text Embedding

这种架构适合图文检索、分类和跨模态对齐,但它本身不是自回归文本生成模型。它训练出的 Vision Encoder 常被后续生成式 VLM 复用。

Vision Encoder + Projector + LLM

这是当前开源生成式 VLM 最主流的架构,也常概括为:

1
ViT → MLP/Projector → LLM

Projector 可以是 Linear Layer、MLP 或带 Patch Merge 的轻量模块。它把 Visual Features 转换成 LLM 可以接收的 Visual Tokens,再直接插入 Text Sequence:

1
2
3
[Text Tokens Before Image]
[Projected Visual Tokens]
[Text Tokens After Image]

LLaVA 使用较简单的 MLP Projector;InternVL 系列采用 ViT–MLP–LLM;Qwen-VL/Qwen2.5-VL 也遵循 Vision Encoder、Visual Merger/Projector 与 LLM 组合的总体结构。

这条路线成为主流,主要因为:

  • 可以直接复用预训练 Vision Encoder 和 LLM;
  • Connector 较轻,训练和工程实现相对简单;
  • Visual Tokens 进入 LLM 后,可以直接利用 LLM 原有的推理与生成能力;
  • 可以自然扩展到多图和视频输入。

代价是 Visual Tokens 会占用 LLM Context Length。图像分辨率越高、输入图片或视频帧越多,Prefill 计算和 KV Cache 占用越大。

Query/Resampler Connector

简单 MLP 通常保留所有 Visual Tokens。为了减少 Token 数量,可以使用一组固定数量的可学习 Queries,从 Vision Features 中主动提取信息。

以 BLIP-2 的 Q-Former 为例,设:

Qlearned∈RB×Nq×DqQ_{\mathrm{learned}} \in \mathbb R^{B\times N_q\times D_q}

为 NqN_q 个 Learned Query Tokens,其中:

  • NqN_q:Query Tokens 数量,由模型预先设定;
  • DqD_q:Q-Former Hidden Size;
  • “Learned” 表示这些 Queries 是可训练参数,不是由图像中的某些 Patches 直接产生;
  • 同一组初始 Queries 会复制到 Batch 中的每张图像上,再根据各自的图像特征产生不同输出。

Vision Encoder 已经输出:

Fv∈RB×Nv×Dv.F_v \in \mathbb R^{B\times N_v\times D_v}.

Cross-Attention 中,Learned Queries 产生 Query,全部 Visual Tokens 产生 Key 和 Value:

Q=QlearnedWQ,K=FvWK,V=FvWV.Q=Q_{\mathrm{learned}}W_Q, \qquad K=F_vW_K, \qquad V=F_vW_V.

对于一个 Attention Head,Shape 可以写成:

Q∈RB×Nq×dh,K,V∈RB×Nv×dh,Q\in\mathbb R^{B\times N_q\times d_h}, \qquad K,V\in\mathbb R^{B\times N_v\times d_h},

其中 dhd_h 是每个 Head 的维度。Attention Weight 为:

A=softmax⁡(QK⊤dh)∈RB×Nq×Nv.A = \operatorname{softmax} \left( \frac{QK^\top}{\sqrt{d_h}} \right) \in \mathbb R^{B\times N_q\times N_v}.

其中 Ab,i,jA_{b,i,j} 表示:第 bb 张图的第 ii 个 Learned Query 应该从第 jj 个 Visual Token 中读取多少信息。

再对所有 Visual Values 做加权求和:

O=AV∈RB×Nq×dh.O = AV \in \mathbb R^{B\times N_q\times d_h}.

OO 是一个 Attention Head 的输出。多头输出合并后,仍然得到 NqN_q 个 Query Outputs。Q-Former 通常堆叠多层:

1
2
3
Query Self-Attention:不同 Queries 之间交换已提取的信息
→ Query–Image Cross-Attention:Queries 再次读取全部 Visual Tokens
→ FFN:更新每个 Query 的特征

最终输出记为:

Zq∈RB×Nq×Dq.Z_q \in \mathbb R^{B\times N_q\times D_q}.

再通过 Linear Projection 将最后一维从 DqD_q 转换成 LLM Hidden Size DlD_l:

Zv=ZqWproj∈RB×Nq×Dl.Z_v = Z_qW_{\mathrm{proj}} \in \mathbb R^{B\times N_q\times D_l}.

于是,无论 Vision Encoder 最初输出多少个 Visual Tokens,进入 LLM 的始终是固定的 NqN_q 个 Tokens。例如原来有几百个 Patch Tokens,而 Nq=32N_q=32 时,Q-Former 会把整张图的信息汇总成 32 个 Tokens。

这些 Learned Queries 会在训练中逐渐形成不同的信息提取方式,例如有的更关注主体,有的更关注局部属性或空间关系。但它们不是人工指定的“主体 Query”或“颜色 Query”,具体分工由训练数据和目标自动学出。

Perceiver Resampler 采用相似思路:也使用少量可学习 Latent Queries,通过多层 Attention 汇总大量 Image/Video Features。二者的共同核心是把“数量随分辨率变化的 Visual Tokens”转换成“固定数量的视觉表示”。

这类结构的特点是:

  • 可以压缩 Visual Token 数量;
  • Learned Queries 会从全部 Visual Tokens 中提取对训练目标有用的信息;
  • Connector 本身具有更强的信息筛选能力;
  • 但固定数量的 Queries 也可能形成信息瓶颈,丢失细粒度视觉内容。

Cross-Attention Bridge

另一条路线不把 Visual Tokens 直接插入 LLM Token Sequence,而是在 LLM 的部分层中额外加入 Cross-Attention:

1
2
3
Text Hidden States → LLM Self-Attention ┐
├→ Gated Cross-Attention → FFN
Visual Features ─────────────────────────┘

Flamingo 先用 Perceiver Resampler 压缩视觉特征,再在冻结 LLM 的若干层中插入 Gated Cross-Attention。此时:

  • Query 来自 Text Hidden States;
  • Key/Value 来自 Visual Features;
  • Text Tokens 可以读取图像信息,但视觉特征不必作为普通 LLM Tokens 拼接到输入中。

这种方式可以较明确地控制哪些 LLM Layers 访问视觉信息,但需要修改 LLM Block 结构,不像简单 Projector 那样容易复用现有语言模型。

Unified Multimodal Decoder

还有一类模型尝试把图像和文本都转换成统一的 Token Sequence,再由同一个 Autoregressive Transformer 建模:

1
2
3
Image → Image Tokenizer → Discrete Image Tokens ┐
├→ Unified Transformer
Text → Text Tokenizer → Text Tokens ──────────┘

Chameleon 属于 Mixed-modal Early-fusion 路线。它可以在一个序列中联合建模 Image/Text Tokens,不仅理解图像,也可以生成交错的图文内容。

这类架构统一性更强,但需要同时处理:

  • Image/Text Vocabulary 的差异;
  • 不同模态 Token 数量和信息密度的差异;
  • 图像生成与文本生成的训练目标和解码成本。

因此,对于以视觉理解和文本回答为主的 VLM,Vision Encoder + Projector + LLM 仍是更常见的工程选择;Unified Decoder 则是统一多模态理解与生成的重要路线。

如何理解当前主流路线?

当前 VLM 可以沿以下主线理解:

  1. Dual Encoder:分别编码图像和文本,适合检索与对齐,代表是 CLIP;
  2. ViT–Projector–LLM:Visual Tokens 投影后直接进入 LLM,是当前生成式 VLM 的主流;
  3. Query/Resampler:先筛选并压缩视觉信息,再交给 LLM,代表是 BLIP-2;
  4. Cross-Attention Bridge:在 LLM 内部读取独立视觉特征,代表是 Flamingo;
  5. Unified Multimodal Decoder:统一建模 Image/Text Tokens,兼顾理解与生成,代表是 Chameleon。

具体模型可能混合多种设计。例如 Flamingo 同时使用 Resampler 与 Cross-Attention,现代 ViT–Projector–LLM 也经常在 Projector 中加入 Patch Merge 或 Token Compression。

5.3 Visual Tokens 与位置编码

固定分辨率的问题

对于固定分辨率 ViT,若 Patch Size 为 PP,原始 Patch Tokens 数量为:

Nv=HPWP.N_v = \frac{H}{P}\frac{W}{P}.

若图像边长扩大为原来的 rr 倍,Patch Tokens 数量会扩大约 r2r^2 倍。固定缩放到较小尺寸虽然计算便宜,但可能导致:

  • 小字和细节丢失;
  • 长宽比失真;
  • 文档、图表和高分辨率场景理解能力下降。

高分辨率图像如何处理?

主流 VLM 常使用:

  1. Dynamic Resolution:尽量保留原始长宽比,根据图像大小产生不同数量的 Visual Tokens;
  2. Tiling:把高分辨率图像切成多个局部 Tiles,并可额外保留一张全局缩略图;
  3. Patch Merge/Token Pooling:合并相邻 Patches,减少送入 LLM 的 Tokens;
  4. Resampler/Q-Former:用固定数量 Queries 压缩视觉特征;
  5. Window Attention:在 Vision Encoder 中限制局部 Attention 范围,降低高分辨率编码成本。

例如,InternVL 使用 Dynamic High-resolution/Tiling 思路;Qwen2.5-VL 使用 Dynamic Resolution 和 Visual Token Merge,在保留细节的同时控制进入 LLM 的 Token 数量。

视觉位置如何表示?

视觉 Token 不仅包含某个 Patch 的内容,还需要记录它位于图像中的什么位置。

假设第 ii 个 Visual Token 位于 Patch Grid 的第 hih_i 行、第 wiw_i 列,则其二维坐标为:

(hi,wi).(h_i,w_i).

常见的二维 Position Embedding 会分别编码行坐标和列坐标,再把两者加入 Visual Token,使模型能够区分上下和左右关系。

Qwen2-VL 等模型使用 Multimodal RoPE(M-RoPE)。它把 Attention 中 Query/Key 的部分维度分别用于表示:

  • Temporal Position τi\tau_i;
  • Height Position hih_i;
  • Width Position wiw_i。

因此,一个视频 Visual Token 的位置可以写成:

(τi,hi,wi).(\tau_i,h_i,w_i).

对于单张图像,所有 Tokens 的时间坐标可以相同,只使用不同的行、列坐标;对于视频,时间坐标还会随帧变化;对于普通 Text Tokens,则仍按一维文本顺序编码。

这样同一套 Attention 既能理解文本先后顺序,也能感知图像和视频中的相对时空位置。

为什么 Visual Tokens 数量很重要?

设 LLM 输入总长度为:

L=Nv′+Nt,L=N'_v+N_t,

其中 Nv′N'_v 是 Connector 输出的 Visual Tokens 数量,NtN_t 是 Text Tokens 数量。标准 Self-Attention 的计算量随 L2L^2 增长;同时,更多 Visual Tokens 也会增加 Prefill 延迟和 KV Cache 占用。

因此,高分辨率 VLM 的核心权衡是:

保留足够多的 Visual Tokens 来看清细节,同时避免它们占满 Context Window 和计算预算。

5.4 VLM 的训练流程

VLM 通常从已经预训练好的 Vision Encoder 和 LLM 开始,再分阶段建立视觉与语言之间的连接。不同模型的具体阶段不完全相同,但主线如下。

Vision-Language Alignment

训练数据通常是 Image–Caption Pair。先冻结或部分冻结 Vision Encoder 与 LLM,主要训练 Connector:

1
Image → Vision Encoder → Connector → LLM → Caption

这一阶段的目标是让 Connector 学会把 Visual Features 映射到 LLM 能够理解的表示空间,而不是重新训练全部模型能力。

Multimodal Instruction Tuning

接着使用图像问答、OCR、文档与图表理解、视觉推理、多图任务和视频问答等数据,使模型学会根据视觉内容和用户指令生成回答。

这一阶段可以只更新 Connector,也可以解冻 Vision Encoder、LLM 的部分或全部参数。是否解冻取决于数据规模、显存和对视觉能力的要求。

Loss 计算在哪些 Tokens 上?

设送入 LLM 的完整序列为:

1
[System] [User Text] [Visual Tokens] [Assistant Response]

生成式 VLM 仍然使用 Next-token Prediction。设 mt∈{0,1}m_t\in\{0,1\} 是 Loss Mask:

  • Assistant Response Token:mt=1m_t=1;
  • System/User Prompt 和 Visual Tokens:mt=0m_t=0。

训练目标可以写为:

L=−∑tmtlog⁡pθ(yt∣y<t,I)∑tmt.\mathcal L = - \frac{ \sum_t m_t \log p_\theta(y_t\mid y_{<t},I) }{ \sum_t m_t }.

其中:

  • II:输入图像;
  • yty_t:序列中第 tt 个目标 Text Token;
  • pθp_\theta:VLM 给出的下一个 Token 概率;
  • mtm_t:决定该位置是否计入 Loss。

Visual Tokens 和用户指令虽然通常不直接计算 Language Modeling Loss,但它们作为上下文参与 Attention,并影响 Assistant Response 的预测。

可选的多模态后训练

Instruction Tuning 之后,还可以使用 Preference Optimization、RL 或基于 Verifier 的训练,进一步改善视觉指令遵循、视觉推理和幻觉问题。这属于可选的 Post-training 阶段,并不是所有 VLM 都采用同一种方案。

推理过程

推理时:

  1. Vision Encoder 对图像编码一次;
  2. Connector 生成 Visual Tokens;
  3. LLM 对 Visual Tokens 和 Prompt 做一次 Prefill;
  4. LLM 使用 KV Cache 自回归生成回答。

Vision Encoder 不需要在每生成一个 Text Token 时重新处理图像;视觉信息已经保存在 Prefill 得到的上下文表示和 KV Cache 中。后续每一步只需生成下一个 Text Token。


六、大模型 RL 后训练

6.1 什么是大模型后训练?

大模型的训练通常可以粗略分为三个阶段:

  1. Pre-training(预训练):在海量文本上做 Next-token Prediction,学习语言、知识和一定的推理能力。
  2. Supervised Fine-tuning,SFT(监督微调):使用“指令—回答”数据训练模型,使其学会遵循指令和使用目标输出格式。
  3. Post-training(后训练):进一步利用偏好、规则或环境反馈优化模型,使其回答更符合人类偏好,或者在数学、代码等任务上取得更高的最终正确率。

大模型 RL 后训练的核心目标是:训练信号不再只是“模仿参考答案中的每个 Token”,而是利用 Reward 直接优化模型自己生成的结果。

SFT 与 RL 的区别可以概括为:

SFT:模仿给定 DemonstrationRL:优化模型自己生成的 Outcome\boxed{ \text{SFT:模仿给定 Demonstration} \qquad \text{RL:优化模型自己生成的 Outcome} }

同一道数学题可能有多条正确推理路径。SFT 通常提高某一条参考回答的似然,而 RL 可以让模型自行生成不同的 Response,再根据最终答案是否正确给予 Reward。因此,具有可自动验证结果的数学、代码和形式化证明任务尤其适合 RL。


6.2 统一符号:把语言模型看作策略

6.2.1 Prompt、Response 与 Token

记:

  • xx:输入模型的 Prompt;
  • y=(y1,y2,…,yT)y=(y_1,y_2,\ldots,y_T):模型生成的完整 Response;
  • TT:Response 的 Token 数量;
  • yty_t:Response 中第 tt 个 Token;
  • y<t=(y1,…,yt−1)y_{<t}=(y_1,\ldots,y_{t-1}):生成 yty_t 之前的所有 Response Tokens;
  • V\mathcal V:模型的 Vocabulary(词表);
  • θ\theta:Policy Model 的可训练参数。

自回归语言模型在第 tt 步给出下一个 Token 的概率分布:

πθ(⋅∣x,y<t).\pi_\theta(\cdot\mid x,y_{<t}).

其中 πθ\pi_\theta 表示由参数 θ\theta 决定的策略。选中 Token yty_t 的概率为:

πθ(yt∣x,y<t).\pi_\theta(y_t\mid x,y_{<t}).

一条完整 Response 的条件概率是各 Token 条件概率的乘积:

πθ(y∣x)=∏t=1Tπθ(yt∣x,y<t).\pi_\theta(y\mid x) = \prod_{t=1}^{T} \pi_\theta(y_t\mid x,y_{<t}).

实际计算通常使用 Log Probability:

log⁡πθ(y∣x)=∑t=1Tlog⁡πθ(yt∣x,y<t),\log\pi_\theta(y\mid x) = \sum_{t=1}^{T} \log\pi_\theta(y_t\mid x,y_{<t}),

因为求和比大量小概率相乘更稳定。

6.2.2 LLM 生成如何对应强化学习?

一条 Response 的生成可以看作一个有限长度的 Markov Decision Process(MDP):

  • State:

    st=(x,y<t),s_t=(x,y_{<t}),

    即 Prompt 加上已经生成的 Tokens。

  • Action:

    at=yt,a_t=y_t,

    即选择下一个 Token。

  • Policy:

    πθ(at∣st)=πθ(yt∣x,y<t).\pi_\theta(a_t\mid s_t) = \pi_\theta(y_t\mid x,y_{<t}).

  • State Transition:将新 Token 追加到上下文中:

    st+1=(x,y≤t).s_{t+1}=(x,y_{\le t}).

  • Reward:可以是每一步的即时 Reward rtr_t,也可以只在完整回答结束时给出 Terminal Reward。

在数学正确性这类 Outcome Reward 中,常见设置是:

r1=⋯=rT−1=0,rT=R(x,y).r_1 =\cdots= r_{T-1}=0, \qquad r_T=R(x,y).

这里 R(x,y)R(x,y) 是完整回答的得分,例如答案正确为 11、错误为 00。

6.2.3 Return、Value、Q Value 与 Advantage

从第 tt 步开始的折扣累计回报称为 Return:

Gt=∑l=0T−tγlrt+l,G_t= \sum_{l=0}^{T-t} \gamma^l r_{t+l},

这里使用 GtG_t 是强化学习中的常见记号约定:小写 rtr_t 表示第 tt 步的即时 Reward,而 GtG_t 表示从第 tt 步开始累积得到的 Return。字母本身没有强制规定,也有资料将 Return 记作 RtR_t;本文使用 GtG_t,是为了与单步 Reward rtr_t 以及整条回答的评分函数 R(x,y)R(x,y) 区分。

其中 γ∈[0,1]\gamma\in[0,1] 是 Discount Factor。LLM 的一条 Response 通常是有限长度序列,而且主要关注最终结果,因此实践中经常取 γ\gamma 接近或等于 11。

状态价值函数表示:从状态 sts_t 出发,继续按照当前策略生成,预期能获得多少 Return:

Vπ(st)=Eπ[Gt∣st].V^\pi(s_t) = \mathbb E_\pi[G_t\mid s_t].

动作价值函数表示:在状态 sts_t 选择动作 ata_t 后继续按照当前策略生成,预期能获得多少 Return:

Qπ(st,at)=Eπ[Gt∣st,at].Q^\pi(s_t,a_t) = \mathbb E_\pi[G_t\mid s_t,a_t].

Advantage 衡量某个动作相对于当前状态下“平均表现”好多少:

Aπ(st,at)=Qπ(st,at)−Vπ(st).A^\pi(s_t,a_t) = Q^\pi(s_t,a_t)-V^\pi(s_t).

  • At>0A_t>0:这个 Token 选择比当前策略通常会做出的选择更好,应提高其概率;
  • At<0A_t<0:这个选择比平均水平更差,应降低其概率;
  • At≈0A_t\approx0:这个选择没有明显优于或劣于 Baseline。

6.3 在线 RL 后训练的完整流程

在线(Online)表示训练数据中的 Response 由当前或最近版本的 Policy 在训练过程中不断生成,而不是完全来自一个固定数据集。

先区分 Online / Offline 与 On-policy / Off-policy

这两组概念描述的是两个不同问题:

  • Online / Offline 关心训练数据是在训练过程中不断生成,还是来自训练前准备好的固定数据集;
  • On-policy / Off-policy 关心生成数据的 Behavior Policy,与当前正在更新的 Target Policy 是否接近。
Online 与 Offline:数据从哪里来?

Online RL 会在训练过程中不断与环境交互并采集新数据。对 LLM 来说,就是反复使用当前或最近版本的模型生成 Response、计算 Reward,再用这些新轨迹更新模型:

Rollout→Update→New Rollout.\text{Rollout} \rightarrow \text{Update} \rightarrow \text{New Rollout}.

PPO、GRPO 和 DAPO 的常见训练方式都属于 Online RL,因为 Response 会随着 Policy 更新而不断重新生成。

Offline RL 则只使用训练开始前已经收集好的固定轨迹,不再调用当前 Policy 生成新数据。数据可能来自其他模型、人类行为或历史日志,因此训练中的 Policy 无法主动探索新状态,也必须处理固定数据分布与当前 Policy 之间的差异。

需要注意,SFT 和 DPO 虽然也使用固定数据集,可以称为 Offline Data Training,但它们不一定属于严格意义上的 Offline RL,仍要根据其目标函数和算法定义判断。

On-policy 与 Off-policy:数据由谁生成?

设生成训练轨迹的策略为 Behavior Policy πb\pi_{\mathrm b},当前希望更新的策略为 Target Policy πθ\pi_\theta。

  • On-policy:轨迹来自当前或非常接近当前的 Policy,即 πb≈πθ\pi_{\mathrm b}\approx\pi_\theta。数据生成后通常很快用于更新,Policy 变化后再重新 Rollout;
  • Off-policy:轨迹来自与当前 Policy 不同的策略,例如更旧的模型、其他模型或 Replay Buffer,即 πb\pi_{\mathrm b} 与 πθ\pi_\theta 可能存在明显差异。

这两个维度可以组合:

  • 同步 PPO 通常是 Online + 近似 On-policy:每轮用更新前的 Actor 生成新轨迹,只做有限次更新后便丢弃;
  • 异步 RL 可以是 Online + Off-policy:训练期间仍在持续生成数据,但 Rollout Policy 落后于 Trainer,导致 Policy Staleness;
  • 使用固定历史轨迹训练通常是 Offline + Off-policy:数据不再更新,而且通常不是由当前 Policy 生成。

因此,Online 不等于 On-policy。前者描述数据是否在训练期间持续产生,后者描述数据分布与当前 Policy 是否匹配。PPO 虽然使用 πold\pi_{\mathrm{old}} 生成数据、更新 πθ\pi_\theta,但二者初始相同且更新幅度受限,所以仍被归类为 On-policy 算法;Importance Ratio 和 Clipping 用来控制一批数据内部逐渐产生的 Policy 差异。

完整 Pipeline 可以表示为:

Prompt Sampling→Policy Rollout→Reward→Advantage→Policy Update→Evaluation\boxed{ \text{Prompt Sampling} \rightarrow \text{Policy Rollout} \rightarrow \text{Reward} \rightarrow \text{Advantage} \rightarrow \text{Policy Update} \rightarrow \text{Evaluation} }

6.3.1 第一步:采样 Prompt

从 Prompt Dataset 中采样一批输入:

x1,x2,…,xB∼Dprompt,x_1,x_2,\ldots,x_B\sim D_{\mathrm{prompt}},

其中:

  • DpromptD_{\mathrm{prompt}} 是 Prompt 的数据分布;
  • BB 是一个 Rollout Batch 中的 Prompt 数量。

数据可以来自数学、问答、选择题和代码等多个任务。多任务训练时,任务采样比例会直接改变不同任务对总梯度的贡献。

6.3.2 第二步:Policy Rollout

使用生成当前数据的 Behavior Policy πθold\pi_{\theta_{\mathrm{old}}} 为每个 Prompt 生成回答:

yi∼πθold(⋅∣xi).y_i\sim\pi_{\theta_{\mathrm{old}}}(\cdot\mid x_i).

如果每个 Prompt 生成 GG 条 Response,则记为:

yi,1,yi,2,…,yi,G.y_{i,1},y_{i,2},\ldots,y_{i,G}.

Rollout 时需要确定:

  • Sampling Temperature;
  • Top-pp 或 Top-kk;
  • 每个 Prompt 的 Rollout 数 GG;
  • Max Response Length;
  • Stop Tokens。

探索强度太低时,多个 Response 可能几乎完全相同;探索强度太高时,又可能生成大量无意义文本。

6.3.3 第三步:计算 Reward

每条 Response 得到 Reward:

Ri,j=R(xi,yi,j).R_{i,j}=R(x_i,y_{i,j}).

常见 Reward 来源包括:

  1. Rule-based / Verifiable Reward:使用答案匹配、单元测试、编译器或定理验证器自动判断;
  2. Reward Model:训练一个模型预测人类更喜欢哪种回答;
  3. AI Feedback:使用更强模型充当 Judge;
  4. Process Reward:对中间推理步骤评分;
  5. Format Reward:检查是否满足规定格式。

从理论上看,Reward Function 是一个将 Prompt 与 Response 映射为标量的函数:

R:X×Y→R,R:\mathcal X\times\mathcal Y\rightarrow\mathbb R,

其中 X\mathcal X 和 Y\mathcal Y 分别表示 Prompt Space 与 Response Space。R(x,y)R(x,y) 越大,表示回答 yy 在 Prompt xx 下越符合优化目标。

例如,对于答案可以自动验证的任务,可以使用二值 Outcome Reward:

R(x,y)=1[extract⁡(y)=a∗],R(x,y) = \mathbf 1[\operatorname{extract}(y)=a^*],

其中 1[⋅]\mathbf 1[\cdot] 是示性函数,条件成立时为 11,否则为 00;extract⁡(y)\operatorname{extract}(y) 表示从回答中提取最终答案;a∗a^* 是标准答案。

6.3.4 第四步:估计 Advantage

不同算法主要在这里产生分歧:

  • PPO:训练 Critic 估计 Vϕ(st)V_\phi(s_t),再通过 GAE 计算 Token-level Advantage;
  • GRPO / DAPO:不训练 Critic,而是用同一 Prompt 下多个 Response 的相对 Reward 构造 Group-relative Advantage;
  • REINFORCE / RLOO:使用完整 Return,并配合不同形式的 Baseline 降低方差。

其中 ϕ\phi 表示 Critic 的参数,与 Actor 参数 θ\theta 相互独立。

6.3.5 第五步:更新 Policy

利用 Advantage 更新 Actor。Policy Gradient 的核心直觉是:

At>0⇒提高动作 at 的概率\boxed{ A_t>0\Rightarrow \text{提高动作 }a_t\text{ 的概率} }

At<0⇒降低动作 at 的概率\boxed{ A_t<0\Rightarrow \text{降低动作 }a_t\text{ 的概率} }

PPO、GRPO 和 DAPO 都会限制一次更新的幅度,避免新 Policy 相对生成数据的 Old Policy 变化过大。

6.3.6 第六步:同步与评测

完成参数更新后,将当前策略作为下一轮生成数据的 Behavior Policy:

θold←θ.\theta_{\mathrm{old}}\leftarrow\theta.

然后使用更新后的 Policy 重新 Rollout、计算 Reward 并继续优化,由此形成 Online RL 的迭代闭环。训练过程中还需要在独立 Validation Set 上定期评测,判断策略的真实任务能力是否随优化目标一起提高。


6.4 训练中到底有哪些模型?

不同算法需要的模型数量不同。先区分以下角色。

6.4.1 Actor / Policy Model

Actor 就是实际生成回答并接受更新的语言模型:

πθ(yt∣x,y<t).\pi_\theta(y_t\mid x,y_{<t}).

训练完成后,最终部署的一般也是 Actor。

6.4.2 Critic / Value Model

Critic 预测每个 State 的价值:

Vϕ(st)∈R.V_\phi(s_t)\in\mathbb R.

它通常由 Transformer Backbone 加 Scalar Value Head 构成。Critic 不负责生成 Token,也不是 Reward Model。它的任务只是给 Actor 提供更稳定的 Advantage Baseline。

6.4.3 Reward Model

Reward Model 接收 Prompt 和完整 Response,输出一个标量分数:

rψ(x,y)∈R,r_\psi(x,y)\in\mathbb R,

其中 ψ\psi 是 Reward Model 的参数。Reward Model 表示回答质量,而 Critic 表示“从当前生成状态继续生成的预期回报”,两者含义不同。

6.4.4 Old Policy

Old Policy πθold\pi_{\theta_{\mathrm{old}}} 是生成当前 Rollout 数据的 Behavior Policy。PPO 类算法需要比较新旧 Policy:

πθ(at∣st)πθold(at∣st).\frac{\pi_\theta(a_t\mid s_t)} {\pi_{\theta_{\mathrm{old}}}(a_t\mid s_t)}.

实现中不一定长期保存一份独立 Old Model,常见做法是保存 Rollout 时动作的 old_log_probs。

6.4.5 Reference Policy

Reference Policy πref\pi_{\mathrm{ref}} 通常是冻结的 SFT Model,用于约束 Actor 不要偏离初始模型过远:

DKL(πθ∥πref).D_{\mathrm{KL}} (\pi_\theta\Vert\pi_{\mathrm{ref}}).

Reference Policy 与 Old Policy 不是一回事:

  • Old Policy 会随训练迭代更新,用来构造 Importance Ratio;
  • Reference Policy 通常长期冻结,用来提供 KL 锚点;
  • 如果算法没有使用 KL,Reference Policy 可以完全不加载。

6.5 从 Policy Gradient 开始理解

6.5.1 最基本的目标

希望最大化模型生成回答的期望 Reward:

J(θ)=Ex∼D, y∼πθ(⋅∣x)[R(x,y)].J(\theta) = \mathbb E_{x\sim D,\ y\sim\pi_\theta(\cdot\mid x)} [R(x,y)].

其中 DD 是 Prompt 分布。

利用 Log-derivative Trick,可以得到 REINFORCE 形式的梯度:

∇θJ(θ)=E[R(x,y)∇θlog⁡πθ(y∣x)].\nabla_\theta J(\theta) = \mathbb E \left[ R(x,y) \nabla_\theta\log\pi_\theta(y\mid x) \right].

展开到 Token:

∇θJ(θ)=E[∑t=1TR(x,y)∇θlog⁡πθ(yt∣x,y<t)].\nabla_\theta J(\theta) = \mathbb E \left[ \sum_{t=1}^{T} R(x,y) \nabla_\theta \log\pi_\theta(y_t\mid x,y_{<t}) \right].

这说明:如果一条回答 Reward 高,就提高其中已采样 Tokens 的概率;如果 Reward 低,就降低这些 Tokens 的概率。

6.5.2 为什么不直接使用 Reward?

绝对 Reward 没有考虑题目难度。例如两道题分别得到 0.60.6:

  • 对简单题而言,模型通常能得到 0.90.9,那么 0.60.6 其实较差;
  • 对困难题而言,模型通常只能得到 0.10.1,那么 0.60.6 已经很好。

因此引入 Baseline:

At=Gt−b(st).A_t=G_t-b(s_t).

只要 Baseline 不依赖当前采样动作,它不会改变 Policy Gradient 的期望,但可以降低方差。PPO 使用 Learned Critic:

b(st)=Vϕ(st).b(s_t)=V_\phi(s_t).

6.5.3 TD Residual 与 GAE

从 Bellman 关系理解 TD Residual

对于当前策略 π\pi,真实状态价值满足 Bellman Expectation Equation:

Vπ(st)=Eπ[rt+γVπ(st+1)∣st].V^\pi(s_t) = \mathbb E_\pi \left[ r_t+\gamma V^\pi(s_{t+1}) \mid s_t \right].

也就是说,一个 State 的价值应等于“执行下一步后获得的即时 Reward”与“下一个 State 的折扣价值”之和的期望。

实际训练中并不知道真实的 VπV^\pi,只能让 Critic VϕV_\phi 对它进行近似。对于一次真实采样到的 Transition:

(st,at,rt,st+1),(s_t,a_t,r_t,s_{t+1}),

可以用:

rt+γVϕ(st+1)r_t+\gamma V_\phi(s_{t+1})

作为 Vϕ(st)V_\phi(s_t) 的一步 Bootstrap Target。这里的 Bootstrap 指:目标中使用了模型自身对下一个 State 的 Value 估计,而不是必须等到整条轨迹结束后再计算完整 Return。

两者之差称为 Temporal Difference Residual(TD 残差):

δt=rt+γVϕ(st+1)−Vϕ(st).\delta_t = r_t +\gamma V_\phi(s_{t+1}) -V_\phi(s_t).

其中:

  • sts_t:生成第 tt 个 Token 前的 State;
  • ata_t:在 sts_t 下选择的 Token;
  • rtr_t:执行 ata_t 后得到的即时 Reward;
  • st+1s_{t+1}:追加该 Token 后的新 State;
  • Vϕ(st)V_\phi(s_t):Critic 对当前 State Value 的估计;
  • γ\gamma:Discount Factor。

TD Residual 可以理解为一次 Transition 带来的“超出预期程度”:

  • δt>0\delta_t>0:实际得到的“即时 Reward + 下一状态价值”高于 Critic 原本对 sts_t 的估计;
  • δt<0\delta_t<0:这一步之后的结果低于预期;
  • 如果 Critic 已经准确,在给定 sts_t 的条件下,δt\delta_t 的期望应接近 00。

但只用:

A^t=δt\hat A_t=\delta_t

估计 Advantage 时,只显式观察一步 Transition,虽然方差较低,却会比较依赖 Critic 对 Vϕ(st+1)V_\phi(s_{t+1}) 的估计。另一方面,如果直接使用完整 Monte Carlo Return:

A^t=Gt−Vϕ(st),\hat A_t=G_t-V_\phi(s_t),

就能利用整条轨迹的真实 Reward,但长序列上的方差通常更大,导致梯度估计更容易受单次采样结果影响、训练波动更明显,并且需要更多样本取平均。GAE 的目的就是在这两个极端之间进行折中。

GAE 的定义

Generalized Advantage Estimation(GAE)将当前及未来的 TD Residual 加权求和:

A^tGAE=∑l=0T−t(γλ)lδt+l,\hat A_t^{\mathrm{GAE}} = \sum_{l=0}^{T-t} (\gamma\lambda)^l\delta_{t+l},

将前几项展开:

A^tGAE=δt+γλδt+1+(γλ)2δt+2+⋯ .\hat A_t^{\mathrm{GAE}} = \delta_t +\gamma\lambda\delta_{t+1} +(\gamma\lambda)^2\delta_{t+2} +\cdots.

其中:

  • ll:从当前时间步向后移动的步数;
  • γ∈[0,1]\gamma\in[0,1]:控制未来 Reward 的折扣;
  • λ∈[0,1]\lambda\in[0,1]:控制未来 TD Residual 参与当前 Advantage 的程度;
  • TT:Response 的最后一个生成时间步。

实际实现通常从序列末尾向前递推:

A^t=δt+γλA^t+1.\hat A_t = \delta_t +\gamma\lambda\hat A_{t+1}.

对于 Episode 结束后的 Terminal State,规定:

Vϕ(sT+1)=0,A^T+1=0.V_\phi(s_{T+1})=0, \qquad \hat A_{T+1}=0.

因此可以先算最后一个 Token 的 A^T\hat A_T,再依次计算 A^T−1,…,A^1\hat A_{T-1},\ldots,\hat A_1,时间复杂度为 O(T)O(T),不需要对每个位置重复计算后续和。

λ\lambda 如何控制 Bias-Variance Trade-off?
  • 当 λ=0\lambda=0 时:

    A^t=δt.\hat A_t=\delta_t.

    此时只使用一步 TD 信息,方差较低,但高度依赖 Critic 的 Bootstrap 估计,因此 Bias 可能较大。

  • 当 λ\lambda 接近 11 时:

    A^t≈δt+γδt+1+γ2δt+2+⋯ .\hat A_t \approx \delta_t+\gamma\delta_{t+1} +\gamma^2\delta_{t+2}+\cdots.

    在完整 Episode 且 Terminal State Value 为 00 时,中间的 Value 项会发生 Telescope Cancellation,最终近似:

    A^t≈Gt−Vϕ(st).\hat A_t \approx G_t-V_\phi(s_t).

    此时更接近 Monte Carlo Advantage,Bias 较小,但会引入更多未来随机性,方差通常更大。

因此,GAE 可以理解为对不同长度的 nn-step Advantage Estimator 进行指数加权:较小的 λ\lambda 更相信短期 Bootstrap,较大的 λ\lambda 更相信完整轨迹的实际结果。

Terminal Reward 如何向前传递?

LLM Reasoning 常只有最终 Outcome Reward:

r1=⋯=rT−1=0,rT=R(x,y).r_1=\cdots=r_{T-1}=0, \qquad r_T=R(x,y).

为了看清传播过程,暂时假设 Critic 在所有位置的初始预测都是 00,并取 γ=1\gamma=1。此时:

δT=R(x,y),δ1=⋯=δT−1=0.\delta_T=R(x,y), \qquad \delta_1=\cdots=\delta_{T-1}=0.

通过 GAE 递推:

A^t=λT−tR(x,y).\hat A_t = \lambda^{T-t}R(x,y).

因此,最终 Reward 可以沿着 Response 从后向前影响更早的 Tokens;距离结尾越远,信号会经过越多次 λ\lambda 衰减。实际训练中 Critic 不为零,每一步的 Advantage 还会受到相邻 State Value 差异的影响。

Value Target

GAE 得到的 Advantage 表示 Return 相对 Value Baseline 高出多少,因此有:

A^t≈G^t−Vϕ(st).\hat A_t \approx \hat G_t-V_\phi(s_t).

所以将 Advantage 加回计算它时使用的 Value Baseline,就能得到 Critic 的回归目标:

G^t=A^t+Vϕ(st).\hat G_t = \hat A_t+V_\phi(s_t).

右侧的 A^t\hat A_t 和 Vϕ(st)V_\phi(s_t) 都是在本轮 Critic 更新前计算并保存的数值。G^t\hat G_t 是由 GAE 构造的 Return Estimate,并不是环境直接提供的真实标签。构造完成后会对 G^t\hat G_t 停止梯度传播,将它作为固定目标,再用当前 Critic Vϕ(st)V_\phi(s_t) 最小化:

Lvalue(ϕ)=Et[(Vϕ(st)−G^t)2].L_{\mathrm{value}}(\phi) = \mathbb E_t \left[ \left( V_\phi(s_t)-\hat G_t \right)^2 \right].

Loss 会在所有有效 Response Tokens 上取平均,Padding 位置通过 Mask 排除。这样,Actor 使用 A^t\hat A_t 更新策略,Critic 使用 G^t\hat G_t 学习新的 Value Baseline。


6.6 PPO:使用 Critic 的稳定 On-policy 更新

PPO(Proximal Policy Optimization)的核心是:利用当前 Rollout 学习,但限制新 Policy 一次不要偏离生成这些数据的 Old Policy 太远。

6.6.1 Importance Ratio

Rollout 完成后,每个已采样动作都有一个固定的 Advantage A^t\hat A_t:

  • A^t>0\hat A_t>0:这个动作比预期好,应提高它的概率;
  • A^t<0\hat A_t<0:这个动作比预期差,应降低它的概率。

Advantage 只负责评价动作好坏,本身不包含待更新参数 θ\theta。要更新 Policy,需要让动作的概率参与目标。对于一个状态 ss,希望最大化 Current Policy 下的期望 Advantage:

Js(θ)=∑aπθ(a∣s)A^old(s,a).J_s(\theta) = \sum_a \pi_\theta(a\mid s) \hat A^{\mathrm{old}}(s,a).

这个式子就是“动作被 Current Policy 选中的概率 × 动作的好坏”。最大化它时,正 Advantage 动作的概率会提高,负 Advantage 动作的概率会降低。

但现有样本不是由 Current Policy 生成的,而是来自 Old Policy。为了使用这批旧样本,将上式改写为:

∑aπθ(a∣s)A^old(s,a)=∑aπθold(a∣s)πθ(a∣s)πθold(a∣s)A^old(s,a).\sum_a\pi_\theta(a\mid s)\hat A^{\mathrm{old}}(s,a) = \sum_a\pi_{\theta_{\mathrm{old}}}(a\mid s) \frac{\pi_\theta(a\mid s)} {\pi_{\theta_{\mathrm{old}}}(a\mid s)} \hat A^{\mathrm{old}}(s,a).

因此定义概率比:

ρt(θ)=πθ(at∣st)πθold(at∣st).\rho_t(\theta) = \frac{ \pi_\theta(a_t\mid s_t) }{ \pi_{\theta_{\mathrm{old}}}(a_t\mid s_t) }.

于是可以使用 Old Policy 的样本估计 Current Policy 的目标:

Jsurrogate(θ)=E(st,at)∼πθold[ρt(θ)A^t].J_{\mathrm{surrogate}}(\theta) = \mathbb E_{(s_t,a_t)\sim\pi_{\theta_{\mathrm{old}}}} \left[ \rho_t(\theta)\hat A_t \right].

这里 ρt\rho_t 与 A^t\hat A_t 的关系很简单:

  • ρt=1\rho_t=1:新旧 Policy 给该 Token 的概率相同;

  • ρt>1\rho_t>1:新 Policy 提高了该 Token 的概率;

  • ρt<1\rho_t<1:新 Policy 降低了该 Token 的概率。

  • 当 A^t>0\hat A_t>0 时,最大化 ρtA^t\rho_t\hat A_t 会推动 ρt\rho_t 增大,也就是提高该 Token 的概率;

  • 当 A^t<0\hat A_t<0 时,ρtA^t\rho_t\hat A_t 是负数。减小 ρt\rho_t 会让它更接近 00、从而使目标变大,也就是降低该 Token 的概率。

所以 ρtA^t\rho_t\hat A_t 不是“概率已经提高后,再把更新幅度放大”,而是把 Current Policy 对该动作的相对概率与动作好坏结合起来,形成一个可以对 θ\theta 优化的目标。

6.6.2 PPO Clipped Objective

问题是,如果一直最大化 ρtA^t\rho_t\hat A_t:

  • 正 Advantage 会持续推动 ρt\rho_t 增大;
  • 负 Advantage 会持续推动 ρt\rho_t 减小。

而 A^t\hat A_t 只是根据一批 Old Policy Rollout 得到的估计,可能有噪声。不能因为一次判断就把 Token 概率改得过多,所以 PPO 只允许这批数据推动 Policy 变化一小段范围。

PPO 的目标为:

JPPO(θ)=Et[min⁡(ρt(θ)A^t, clip⁡(ρt(θ),1−ϵ,1+ϵ)A^t)].J_{\mathrm{PPO}}(\theta) = \mathbb E_t \left[ \min \left( \rho_t(\theta)\hat A_t,\, \operatorname{clip} (\rho_t(\theta),1-\epsilon,1+\epsilon)\hat A_t \right) \right].

其中:

  • ϵ>0\epsilon>0 控制允许的相对概率变化范围;
  • clip⁡(ρt,1−ϵ,1+ϵ)\operatorname{clip}(\rho_t,1-\epsilon,1+\epsilon) 将 ρt\rho_t 截到该区间内;
  • min 在未裁剪项和裁剪项中选择更小、更保守的一个。

现在重新理解“提高到 Old Policy 的 1+ϵ1+\epsilon 倍”。因为:

πθ(at∣st)=ρt πθold(at∣st),\pi_\theta(a_t\mid s_t) = \rho_t\, \pi_{\theta_{\mathrm{old}}}(a_t\mid s_t),

所以 ρt=1+ϵ\rho_t=1+\epsilon 表示:在当前这轮参数更新中,该 Token 的概率已经变成旧概率的 1+ϵ1+\epsilon 倍。

  • 若 A^t>0\hat A_t>0,提高概率是正确方向;但当 ρt>1+ϵ\rho_t>1+\epsilon 后,裁剪项保持不变,这个样本不再奖励继续提高概率;
  • 若 A^t<0\hat A_t<0,降低概率是正确方向;但当 ρt<1−ϵ\rho_t<1-\epsilon 后,裁剪项保持不变,这个样本不再奖励继续降低概率。

注意,这不是把概率硬性锁在边界上,而只是让当前样本在越过边界后不再提供更多收益。

min 用来处理错误方向。PPO 在最大化目标,因此取较小值意味着:

  • 如果 Policy 朝正确方向走得过远,选择裁剪项,停止额外奖励;
  • 如果 Policy 朝错误方向变化,选择更差的未裁剪项,仍然保留纠正它的梯度。

因此,PPO Clipping 的作用可以概括为:限制一次更新从旧 Rollout 中获得的收益,但不掩盖错误方向带来的损失。

6.6.3 Critic Loss

Critic 回归 Value Target:

Lvalue(ϕ)=Et[(Vϕ(st)−G^t)2].L_{\mathrm{value}}(\phi) = \mathbb E_t \left[ \left( V_\phi(s_t)-\hat G_t \right)^2 \right].

实际 PPO 常对 Value Update 也进行 Clipping,避免 Critic 一次变化过大。

6.6.4 Entropy Bonus 与 KL

Policy Entropy 为:

H(πθ(⋅∣st))=−∑a∈Vπθ(a∣st)log⁡πθ(a∣st).\mathcal H(\pi_\theta(\cdot\mid s_t)) = - \sum_{a\in\mathcal V} \pi_\theta(a\mid s_t) \log\pi_\theta(a\mid s_t).

Entropy 高表示分布更分散、探索更强;Entropy 过低可能发生 Entropy Collapse,模型过早变得确定。

PPO/RLHF 还经常加入相对 Reference Policy 的 KL 惩罚:

J(θ)=E[R]−βDKL(πθ∥πref),J(\theta) = \mathbb E[R] - \beta D_{\mathrm{KL}} (\pi_\theta\Vert\pi_{\mathrm{ref}}),

其中 β≥0\beta\ge0 是 KL Coefficient。它是可选设计,并非所有 PPO 训练都必须加载 Reference Model。

6.6.5 PPO 的完整训练过程

一次 PPO Iteration 可以分为四个阶段。记 Rollout Batch 中有 BB 个 Prompt,第 bb 个 Prompt 为 xbx_b;用 mb,t∈{0,1}m_{b,t}\in\{0,1\} 标记第 tt 个位置是否为有效 Response Token。

阶段一:采集 Rollout

先固定当前 Actor 的参数快照 θold\theta_{\mathrm{old}},再从 Prompt Dataset 采样:

x1,…,xB∼Dprompt.x_1,\ldots,x_B\sim D_{\mathrm{prompt}}.

Old Policy 为每个 Prompt 生成一条 Response:

yb=(yb,1,…,yb,Tb)∼πθold(⋅∣xb).y_b=(y_{b,1},\ldots,y_{b,T_b}) \sim \pi_{\theta_{\mathrm{old}}}(\cdot\mid x_b).

PPO 更新前还需要获得每个已采样 Token 在 Old Policy 下的 Log Probability:

ℓb,told=log⁡πθold(yb,t∣xb,yb,<t).\ell_{b,t}^{\mathrm{old}} = \log\pi_{\theta_{\mathrm{old}}} (y_{b,t}\mid x_b,y_{b,<t}).

它既可以由 Rollout Engine 在生成时返回,也可以在生成结束后、Actor 更新前,用相同的 θold\theta_{\mathrm{old}} 对 Prompt + Response 重新 Forward 得到。

无论采用哪种实现,Actor 开始更新后,ℓb,told\ell_{b,t}^{\mathrm{old}} 都保持不变,因为它表示生成这批数据的 Policy 对已采样 Tokens 给出的概率。至此得到 Prompt、Response、Response Mask 和 Old Log Probability。

阶段二:为 Rollout 构造训练信号

Reward Function 或 Reward Model 先给完整 Response 打分:

Rb=R(xb,yb).R_b=R(x_b,y_b).

如果使用 Terminal Outcome Reward,则只在最后一个有效 Token 放置 RbR_b,前面位置的即时 Reward 为 00。

接着,更新前的 Critic 对每个状态:

sb,t=(xb,yb,<t)s_{b,t}=(x_b,y_{b,<t})

预测 Value。记这次固定预测为:

vb,t=Vϕold(sb,t).v_{b,t}=V_{\phi_{\mathrm{old}}}(s_{b,t}).

利用 Reward 和 vb,tv_{b,t} 计算:

δb,t=rb,t+γvb,t+1−vb,t,\delta_{b,t} = r_{b,t} +\gamma v_{b,t+1} -v_{b,t},

再从 Response 末尾向前递推:

A^b,t=δb,t+γλA^b,t+1.\hat A_{b,t} = \delta_{b,t} +\gamma\lambda\hat A_{b,t+1}.

最后构造 Critic 的监督目标:

G^b,t=A^b,t+vb,t.\hat G_{b,t} = \hat A_{b,t}+v_{b,t}.

至此,一条用于 PPO 更新的训练样本包含:

  • 输入:xbx_b 与 yby_b;
  • Actor 更新前保存的 Old Log Probability:ℓb,told\ell_{b,t}^{\mathrm{old}};
  • Actor 的监督信号:A^b,t\hat A_{b,t};
  • Critic 的监督信号:G^b,t\hat G_{b,t};
  • 用于忽略 Padding 的 mb,tm_{b,t}。

这些量在随后使用这批 Rollout 训练时全部固定,不参与梯度传播。

阶段三:使用 Mini Batch 更新 Actor 和 Critic

将 BB 条轨迹 Shuffle 后拆成 Mini Batches。对于每个 Mini Batch,Current Actor 使用最新参数 θ\theta 重新计算同一批 Tokens 的 Log Probability:

ℓb,tnew=log⁡πθ(yb,t∣xb,yb,<t).\ell_{b,t}^{\mathrm{new}} = \log\pi_\theta (y_{b,t}\mid x_b,y_{b,<t}).

因此 Importance Ratio 为:

ρb,t(θ)=exp⁡(ℓb,tnew−ℓb,told).\rho_{b,t}(\theta) = \exp\left( \ell_{b,t}^{\mathrm{new}} -\ell_{b,t}^{\mathrm{old}} \right).

Actor 最小化 PPO Loss:

Lactor(θ)=−1∑b,tmb,t∑b,tmb,tmin⁡(ρb,tA^b,t,clip⁡(ρb,t,1−ϵ,1+ϵ)A^b,t).\begin{aligned} L_{\mathrm{actor}}(\theta) =- \frac{1}{\sum_{b,t}m_{b,t}} \sum_{b,t}m_{b,t} \min\Big( &\rho_{b,t}\hat A_{b,t},\\ &\operatorname{clip} (\rho_{b,t},1-\epsilon,1+\epsilon) \hat A_{b,t} \Big). \end{aligned}

Current Critic 使用最新参数 ϕ\phi 重新预测 Vϕ(sb,t)V_\phi(s_{b,t}),并拟合阶段二中固定的 Value Target:

Lvalue(ϕ)=∑b,tmb,t(Vϕ(sb,t)−G^b,t)2∑b,tmb,t.L_{\mathrm{value}}(\phi) = \frac{ \sum_{b,t}m_{b,t} \left( V_\phi(s_{b,t})-\hat G_{b,t} \right)^2 }{ \sum_{b,t}m_{b,t} }.

Actor 与 Critic 使用同一批轨迹,但分别计算 Loss、反向传播,并由各自的 Optimizer 更新参数。

阶段四:同步 Policy,开始下一轮

一批 Rollout 可以被 Shuffle 并训练一个或多个 PPO Epochs。完成预定更新后,丢弃这批 Rollout,并将更新后的 Actor 作为下一轮 Behavior Policy:

θold←θ.\theta_{\mathrm{old}}\leftarrow\theta.

然后重新采样 Prompt、生成 Response,并重复上述过程。旧 Rollout 不能无限复用,因为 Current Policy 与 Old Policy 的差距会越来越大,数据也会越来越 Off-policy。

6.6.6 PPO 核心与面试手写代码

PPO 面试中最常见的手写内容包括:

  1. Masked Mean 与 Advantage Whitening;
  2. GAE 反向递推;
  3. 从 Causal LM Logits 中取出实际 Token 的 Log Probability;
  4. Importance Ratio 与 PPO Clipped Loss。

下面将这些代码集中在一起,并省略文本生成和分布式训练。开始计算前,已经获得:

  • 阶段一得到的 old_log_probs 和 response_mask;
  • 阶段二得到的 rewards 和旧 Critic values。

所有 Tensor 的形状均为 (B,T)(B,T),其中 BB 是轨迹数量,TT 是 Padding 后的 Response 长度。

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
import torch


def masked_mean(x, mask):
"""忽略 Padding,只对有效 Response Tokens 求平均。"""
return (x * mask).sum() / mask.sum().clamp_min(1.0)


@torch.no_grad()
def compute_gae(rewards, values, response_mask, gamma=1.0, lam=0.95):
"""
对应阶段二:由 Reward 和旧 Critic Value 计算 GAE 与 Value Target。

rewards: 每个 Token 的即时 Reward
只有 Outcome Reward 时,通常仅最后一个有效位置非零
values: 阶段二中旧 Critic 给出的固定 V(s_t)
response_mask: 有效 Response Token 为 1,Padding 为 0

返回:
advantages: Actor 更新使用的 A_hat_t
returns: Critic 回归使用的 G_hat_t
"""
batch_size, seq_len = rewards.shape
advantages = torch.zeros_like(rewards)

# 保存递推式中的 A_hat_{t+1},从 Response 末尾向前计算。
last_advantage = torch.zeros(
batch_size, device=rewards.device, dtype=rewards.dtype
)

for t in reversed(range(seq_len)):
if t == seq_len - 1:
# Tensor 最后一个位置之后没有下一个 State。
next_value = torch.zeros_like(last_advantage)
next_valid = torch.zeros_like(last_advantage)
else:
next_value = values[:, t + 1]
# 若下一个位置是 Padding,当前 Token 就是轨迹终点,
# 不应 Bootstrap 到 Padding 位置的 Value。
next_valid = response_mask[:, t + 1]

# delta_t = r_t + gamma * V(s_{t+1}) - V(s_t)
delta = (
rewards[:, t]
+ gamma * next_value * next_valid
- values[:, t]
)

# A_hat_t = delta_t + gamma * lambda * A_hat_{t+1}
last_advantage = (
delta
+ gamma * lam * next_valid * last_advantage
)
advantages[:, t] = last_advantage

# Padding 位置不参与任何 Loss。
advantages = advantages * response_mask

# G_hat_t = A_hat_t + V(s_t),作为阶段三的 Critic Target。
returns = (advantages + values) * response_mask
return advantages, returns


def ppo_losses(
new_log_probs,
old_log_probs,
advantages,
new_values,
returns,
response_mask,
clip_eps=0.2,
):
"""
对应阶段三:计算一个 Mini Batch 的 Actor/Critic Loss。

new_log_probs: Actor 当前参数重新计算的 Log Probability
old_log_probs: 阶段一保存的 Old Policy Log Probability
advantages: 阶段二得到的 A_hat_t
new_values: Critic 当前参数重新计算的 V(s_t)
returns: 阶段二得到的固定 Value Target G_hat_t
"""

# 这些量来自固定 Rollout Batch,只作为监督信号,不反向传播。
old_log_probs = old_log_probs.detach()
advantages = advantages.detach()
returns = returns.detach()

# 阶段三(Actor):rho_t = exp(log pi_theta - log pi_old)
ratio = torch.exp(new_log_probs - old_log_probs)

# PPO 未裁剪目标与裁剪目标。
surrogate_1 = ratio * advantages
surrogate_2 = torch.clamp(
ratio, 1.0 - clip_eps, 1.0 + clip_eps
) * advantages

# PPO 最大化 min(surrogate_1, surrogate_2),
# 因此作为 Loss 最小化时需要添加负号。
actor_objective = torch.minimum(surrogate_1, surrogate_2)
actor_loss = -masked_mean(actor_objective, response_mask)

# 阶段三(Critic):拟合固定的 Value Target。
value_error = (new_values - returns) ** 2
critic_loss = masked_mean(value_error, response_mask)

return actor_loss, critic_loss

阶段三先将 Rollout Batch 切成 Mini Batches。对于每个 Mini Batch,Actor 重新计算 new_log_probs,Critic 重新计算 new_values,然后分别更新:

1
2
3
4
5
6
7
8
9
# 阶段三:只更新 Actor 参数 theta。
actor_optimizer.zero_grad()
actor_loss.backward()
actor_optimizer.step()

# 阶段三:只更新 Critic 参数 phi。
critic_optimizer.zero_grad()
critic_loss.backward()
critic_optimizer.step()

这段代码只展示 PPO 的核心数学结构。完整实现还通常包含 Advantage Whitening、Value Clipping、Entropy Bonus、KL Penalty、Gradient Clipping 和分布式 Mask 处理。

从 Logits 取出实际 Token 的 Log Probability

Causal LM 在第 tt 个位置输出的 Logits 用于预测第 t+1t+1 个 Token。PPO 不需要保存整个 Vocabulary 的概率,只需要取出轨迹中实际 Token 对应的 Log Probability:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import torch.nn.functional as F


def get_token_log_probs(logits, input_ids):
"""
logits: (batch_size, seq_len, vocab_size)
input_ids: (batch_size, seq_len)

返回每个实际 Next Token 的 Log Probability,
形状为 (batch_size, seq_len - 1)。
"""
# 位置 t 的 Logits 预测位置 t+1 的 Token。
next_token_logits = logits[:, :-1, :]
next_tokens = input_ids[:, 1:]

log_probs = F.log_softmax(next_token_logits, dim=-1)

# 只取实际生成 Token 对应的那一项,而不是保留整个 Vocabulary。
selected_log_probs = torch.gather(
log_probs,
dim=-1,
index=next_tokens.unsqueeze(-1),
)
return selected_log_probs.squeeze(-1)

对于 Prompt–Response 拼接序列,再从结果中切出 Response 对应的位置,就得到 PPO 使用的 Token-level Log Probability。

带 Mask 的 Advantage Whitening

不同 Batch 的 Advantage 尺度可能不同,通常会在有效 Response Tokens 上做归一化:

1
2
3
4
5
6
7
8
9
def masked_whiten(x, mask, eps=1e-8):
"""
只使用有效 Response Tokens 计算均值和方差,
Padding 位置不参与统计,输出也保持为 0。
"""
mean = masked_mean(x, mask)
variance = masked_mean((x - mean) ** 2, mask)
whitened = (x - mean) / torch.sqrt(variance + eps)
return whitened * mask

因此,PPO 常见的手写重点可以归纳为:

  1. 根据 Reward 和 Value 反向递推 GAE;
  2. 从 Causal LM Logits 中 Gather 实际 Token 的 Log Probability;
  3. 使用 exp(new_log_prob - old_log_prob) 计算 Importance Ratio;
  4. 实现 PPO 的 minimum + clip Actor Loss;
  5. 使用 Mask 排除 Prompt 和 Padding;
  6. 对有效 Tokens 做 Advantage Whitening。

6.6.7 PPO 的优势与局限

优势:

  • Learned Critic 可以跨 Prompt 和跨样本学习 Value Baseline;
  • GAE 能提供随 Token/State 变化的 Advantage;
  • Clipping 能控制更新幅度,工程上相对稳定;
  • 同一批 Rollout 可以通过 Mini Batch 和多个 PPO Epoch 重复利用。

局限:

  • 需要额外训练 Critic,显存和计算成本较高;
  • Actor、Critic、Old Log Prob、Reference Model 之间的数据流复杂;
  • Critic 训练不好时,Advantage 估计反而可能产生偏差;
  • On-policy 数据很快过期,不能无限重复使用旧 Rollout;
  • Rollout 往往比梯度更新更耗时。

6.7 GRPO:用组内相对 Reward 代替 Critic

GRPO(Group Relative Policy Optimization)最关键的变化是:删除 Critic,使用同一 Prompt 下多个 Response 的相对 Reward 作为 Baseline。

6.7.1 Group Rollout

对一个 Prompt xx,Old Policy 生成 GG 条回答:

y1,y2,…,yG∼πθold(⋅∣x).y_1,y_2,\ldots,y_G \sim \pi_{\theta_{\mathrm{old}}}(\cdot\mid x).

得到对应 Reward:

R1,R2,…,RG.R_1,R_2,\ldots,R_G.

计算组内均值和标准差:

Rˉ=1G∑i=1GRi,\bar R = \frac{1}{G} \sum_{i=1}^{G}R_i,

σR=1G∑i=1G(Ri−Rˉ)2.\sigma_R = \sqrt{ \frac{1}{G} \sum_{i=1}^{G} (R_i-\bar R)^2 }.

第 ii 条 Response 的 Group-relative Advantage 为:

A^i=Ri−RˉσR+εnum,\hat A_i = \frac{ R_i-\bar R }{ \sigma_R+\varepsilon_{\mathrm{num}} },

其中 εnum\varepsilon_{\mathrm{num}} 是防止除零的数值稳定项。通常同一 Response 内的所有 Tokens 共享同一个 A^i\hat A_i:

A^i,t=A^i.\hat A_{i,t}=\hat A_i.

6.7.2 GRPO Objective

定义第 ii 条 Response 中第 tt 个 Token 的 Importance Ratio:

ρi,t(θ)=πθ(yi,t∣x,yi,<t)πθold(yi,t∣x,yi,<t).\rho_{i,t}(\theta) = \frac{ \pi_\theta(y_{i,t}\mid x,y_{i,<t}) }{ \pi_{\theta_{\mathrm{old}}}(y_{i,t}\mid x,y_{i,<t}) }.

经典 GRPO 的 Sample-level Objective 可以写为:

JGRPO(θ)=E[1G∑i=1G1∣yi∣∑t=1∣yi∣min⁡(ρi,tA^i,clip⁡(ρi,t,1−ϵ,1+ϵ)A^i)−βDKL].\begin{aligned} J_{\mathrm{GRPO}}(\theta) = \mathbb E \Bigg[ &\frac{1}{G} \sum_{i=1}^{G} \frac{1}{|y_i|} \sum_{t=1}^{|y_i|} \min\Big( \rho_{i,t}\hat A_i,\\ &\operatorname{clip} (\rho_{i,t},1-\epsilon,1+\epsilon)\hat A_i \Big) - \beta D_{\mathrm{KL}} \Bigg]. \end{aligned}

这里:

  • ∣yi∣|y_i| 是第 ii 条 Response 的 Token 数;
  • 先对每条 Response 内部的 Tokens 求平均,再对 GG 条 Response 求平均;
  • KL 项是否启用取决于具体实现;很多 Reasoning RL 实现会取 β=0\beta=0。

6.7.3 GRPO 的完整训练过程

记一个 Rollout Batch 包含 BB 个 Prompt,每个 Prompt 生成 GG 条 Response。一次 GRPO Iteration 包括:

  1. 采样 Prompt

    x1,…,xB∼Dprompt.x_1,\ldots,x_B\sim D_{\mathrm{prompt}}.

  2. 为每个 Prompt 生成一组 Response

    对第 bb 个 Prompt:

    yb,1,…,yb,G∼πθold(⋅∣xb).y_{b,1},\ldots,y_{b,G} \sim \pi_{\theta_{\mathrm{old}}}(\cdot\mid x_b).

    Rollout 时保存每个 Token 的 Old Log Probability。与 PPO 不同,GRPO 需要同一 Prompt 的多条回答,以构造组内 Baseline。

  3. 计算每条 Response 的 Reward

    Rb,i=R(xb,yb,i),i=1,…,G.R_{b,i} = R(x_b,y_{b,i}), \qquad i=1,\ldots,G.

  4. 在每个 Prompt 的组内计算 Advantage

    先计算第 bb 组 Reward 的均值和标准差:

    Rˉb=1G∑i=1GRb,i,\bar R_b = \frac{1}{G} \sum_{i=1}^{G}R_{b,i},

    σb=1G∑i=1G(Rb,i−Rˉb)2.\sigma_b = \sqrt{ \frac{1}{G} \sum_{i=1}^{G} (R_{b,i}-\bar R_b)^2 }.

    再得到第 ii 条 Response 的相对 Advantage:

    A^b,i=Rb,i−Rˉbσb+εnum.\hat A_{b,i} = \frac{ R_{b,i}-\bar R_b }{ \sigma_b+\varepsilon_{\mathrm{num}} }.

    同一 Response 中的 Tokens 通常共享该值:

    A^b,i,t=A^b,i.\hat A_{b,i,t}=\hat A_{b,i}.

    GRPO 在这里不调用 Critic,也不计算 GAE 或 Value Target。

  5. 计算 Current Policy 的 Probability Ratio

    对 Response yb,iy_{b,i} 中第 tt 个 Token:

    ρb,i,t(θ)=πθ(yb,i,t∣xb,yb,i,<t)πθold(yb,i,t∣xb,yb,i,<t).\rho_{b,i,t}(\theta) = \frac{ \pi_\theta(y_{b,i,t}\mid x_b,y_{b,i,<t}) }{ \pi_{\theta_{\mathrm{old}}}(y_{b,i,t}\mid x_b,y_{b,i,<t}) }.

  6. 更新 Actor

    将 B×GB\times G 条 Response Shuffle 并切成 Mini Batches。训练时最小化:

    LGRPO(θ)=−JGRPO(θ),L_{\mathrm{GRPO}}(\theta) = -J_{\mathrm{GRPO}}(\theta),

    其中 JGRPOJ_{\mathrm{GRPO}} 是上一节给出的 Clipped Objective。如果启用了 Reference Policy,还会同时计算 KL Penalty;若 β=0\beta=0,则不需要该项。

  7. 同步 Policy 并重新 Rollout

    完成当前数据上的一个或多个更新 Epoch 后:

    θold←θ,\theta_{\mathrm{old}}\leftarrow\theta,

    再使用新 Policy 生成下一批 Group Rollout。

整个过程与 PPO 最本质的区别发生在第四步:

PPO:Critic + GAEGRPO:Group Reward Normalization.\text{PPO:Critic + GAE} \qquad \text{GRPO:Group Reward Normalization}.

如果同一组内所有 Reward 都相同,则 Rb,i−Rˉb=0R_{b,i}-\bar R_b=0,该 Prompt 的所有 Advantage 都为 00,不会产生有效的 Policy Gradient。

6.7.4 GRPO 为什么不需要 Critic?

PPO 的 Baseline 来自 Learned Value:

A^t≈Gt−Vϕ(st).\hat A_t\approx G_t-V_\phi(s_t).

GRPO 的 Baseline 来自同一 Prompt 下多个回答的平均 Reward:

A^i≈Ri−Rˉ.\hat A_i \approx R_i-\bar R.

因此 GRPO 用更多 Rollout 计算换掉了 Critic:

PPO:Learned Critic BaselineGRPO:Group-relative Baseline\boxed{ \text{PPO:Learned Critic Baseline} \qquad \text{GRPO:Group-relative Baseline} }

6.7.5 GRPO 的优势

  • 不需要训练 Critic,减少模型状态、Value Forward 和 Value Update 的开销;
  • 同一 Prompt 内做相对比较,能一定程度上抵消题目难度差异;
  • 很适合具有可验证 Outcome Reward 的数学和代码任务;
  • Pipeline 比 PPO 更简单。

6.7.6 GRPO 的问题

全对或全错时没有有效信号

如果:

R1=R2=⋯=RG,R_1=R_2=\cdots=R_G,

则:

Ri−Rˉ=0⇒A^i=0.R_i-\bar R=0 \quad\Rightarrow\quad \hat A_i=0.

简单题全部正确、难题全部错误时,这一组 Rollout 几乎不产生 Policy Gradient。

Group Size 有限导致 Baseline 噪声

GG 较小时,Rˉ\bar R 和 σR\sigma_R 只是基于少量样本的局部估计。多任务、难度跨度较大的数据中,Group Baseline 可能具有较高方差。

Rollout 成本增加

为了得到组内比较,每个 Prompt 必须生成多条 Response。Critic 成本下降了,但生成成本增加了。

Response-level Advantage 不等于过程监督

同一 Response 内所有 Tokens 常共享一个 Advantage。模型知道整条回答相对较好或较差,但不知道具体哪一步推理正确。


6.8 DAPO:面向 Long-CoT 的 GRPO 改进

DAPO(Decoupled Clip and Dynamic sAmpling Policy Optimization)建立在 Group-relative Advantage 和 Rule-based Outcome Reward 之上。它针对大规模 Long Chain-of-Thought RL 中的训练稳定性和效率问题,引入四项关键技术:

Clip-Higher+Dynamic Sampling+Token-level Loss+Overlong Reward Shaping\boxed{ \text{Clip-Higher} + \text{Dynamic Sampling} + \text{Token-level Loss} + \text{Overlong Reward Shaping} }

DAPO 原始方案还移除了 KL 项,允许 Reasoning Policy 更自由地偏离初始模型。

6.8.1 Clip-Higher:解耦上下 Clip Bound

普通 PPO/GRPO 使用对称区间:

[1−ϵ,1+ϵ].[1-\epsilon,1+\epsilon].

DAPO 将其改为:

[1−ϵlow,1+ϵhigh],[1-\epsilon_{\mathrm{low}}, 1+\epsilon_{\mathrm{high}}],

并设置:

ϵhigh>ϵlow.\epsilon_{\mathrm{high}}> \epsilon_{\mathrm{low}}.

对应目标中的裁剪项为:

clip⁡(ρi,t,1−ϵlow,1+ϵhigh).\operatorname{clip} \left( \rho_{i,t}, 1-\epsilon_{\mathrm{low}}, 1+\epsilon_{\mathrm{high}} \right).

为什么上界需要更大?假设一个低概率探索 Token 的旧概率只有 0.010.01。若 ϵ=0.2\epsilon=0.2,一次更新中可获得目标收益的概率上界只有:

0.01(1+0.2)=0.012.0.01(1+0.2)=0.012.

它很难获得明显提升。提高 ϵhigh\epsilon_{\mathrm{high}} 可以给正 Advantage、低概率的探索 Tokens 更大的上升空间,缓解 Entropy Collapse。

下界仍保持较保守,是为了避免某些 Tokens 的概率被迅速压到接近零,造成探索空间收缩。

6.8.2 Dynamic Sampling:只保留有组内差异的 Prompt

对于二值正确性 Reward:

  • 一组全部正确:组内 Advantage 全为 00;
  • 一组全部错误:组内 Advantage也全为 00;
  • 只有同时存在正确与错误 Response 时,Group-relative Advantage 才有区分度。

DAPO 在生成阶段 Oversample,并过滤满足以下情况的 Prompt Group:

#{correct responses}=0\#\{\text{correct responses}\}=0

或:

#{correct responses}=G.\#\{\text{correct responses}\}=G.

直到 Batch 中填满:

0<#{correct responses}<G0< \#\{\text{correct responses}\} <G

的有效 Prompt。

这里的 Dynamic 指每轮为了凑齐有效训练 Batch,实际需要生成的 Prompt 数量会变化,不是根据任务 Reward 在线调整多任务数据比例。

它提高了梯度更新中的有效样本比例,但不能凭空解决极难任务:如果模型对某一类题几乎永远答错,可能需要大量 Oversampling,甚至根本无法填满有效 Batch。这时仍需要 Curriculum、SFT Cold Start 或更稠密的 Reward。

6.8.3 Token-level Policy Gradient Loss

原始 GRPO 常先对每条 Response 的 Tokens 求平均,再对 Response 求平均:

Jsample=1G∑i=1G1∣yi∣∑t=1∣yi∣ℓi,t.J_{\mathrm{sample}} = \frac{1}{G} \sum_{i=1}^{G} \frac{1}{|y_i|} \sum_{t=1}^{|y_i|} \ell_{i,t}.

其中 ℓi,t\ell_{i,t} 表示第 ii 条 Response 中第 tt 个 Token 的 Clipped Policy Objective。

这种聚合方式让每条 Response 的总权重相同,因此长回答中的每个 Token 权重更小。

DAPO 改为在整个 Batch 的所有有效 Tokens 上直接取平均:

Jtoken=1∑i=1G∣yi∣∑i=1G∑t=1∣yi∣ℓi,t.J_{\mathrm{token}} = \frac{1}{ \sum_{i=1}^{G}|y_i| } \sum_{i=1}^{G} \sum_{t=1}^{|y_i|} \ell_{i,t}.

这样每个 Token 的基础权重相同,长 Response 会对总梯度产生更大影响。对于 Long-CoT:

  • 高质量长推理中的模式可以获得充分学习;
  • 低质量长文本中的重复、乱码等模式也能受到更充分惩罚。

这并不表示长回答一定更好,而是在 Loss Aggregation 时不再先将每条 Response 强行归一成相同总权重。

6.8.4 Overlong Reward Shaping

生成通常存在最大长度 Lmax⁡L_{\max}。如果 Response 达到上限后被截断,直接将其视为完全错误会引入噪声:它可能具有合理推理,只是尚未来得及输出最终答案。

设:

  • L=∣y∣L=|y|:实际 Response 长度;
  • Lmax⁡L_{\max}:硬长度上限;
  • LbufL_{\mathrm{buf}}:Overlong Buffer 长度;
  • Lstart=Lmax⁡−LbufL_{\mathrm{start}}=L_{\max}-L_{\mathrm{buf}}:开始惩罚的长度;
  • α>0\alpha>0:最大长度惩罚。

可以定义线性惩罚:

Rlen(L)={0,L≤Lstart,−αL−LstartLbuf,Lstart<L≤Lmax⁡.R_{\mathrm{len}}(L) = \begin{cases} 0, &L\le L_{\mathrm{start}},\\[4pt] -\alpha \dfrac{L-L_{\mathrm{start}}} {L_{\mathrm{buf}}}, &L_{\mathrm{start}}<L\le L_{\max}. \end{cases}

最终 Reward 为:

Rfinal=Rtask+Rlen.R_{\mathrm{final}} = R_{\mathrm{task}} +R_{\mathrm{len}}.

Response 越接近硬上限,惩罚越强,从而提前告诉模型应该收敛并给出答案,而不是等到真正截断时突然给予不连续的惩罚。

另一种处理是直接 Mask 掉被截断样本的 Loss,即 Overlong Filtering。但这会浪费数据;Soft Overlong Punishment 提供了更连续的训练信号。

6.8.5 DAPO 的整体目标

忽略长度 Reward 的具体写法后,DAPO 的核心 Policy Objective 可以写为:

JDAPO(θ)=E[1∑i∣yi∣∑i=1G∑t=1∣yi∣min⁡(ρi,tA^i,clip⁡(ρi,t,1−ϵlow,1+ϵhigh)A^i)],\begin{aligned} J_{\mathrm{DAPO}}(\theta) = \mathbb E\Bigg[ \frac{1}{\sum_i|y_i|} \sum_{i=1}^{G} \sum_{t=1}^{|y_i|} \min\Big( &\rho_{i,t}\hat A_i,\\ &\operatorname{clip} (\rho_{i,t}, 1-\epsilon_{\mathrm{low}}, 1+\epsilon_{\mathrm{high}}) \hat A_i \Big) \Bigg], \end{aligned}

并要求参与训练的 Prompt Group 具有非零 Reward 方差。

可以把它理解为:

DAPO=GRPO-style Advantage+更适合 Long-CoT 的训练 Recipe\boxed{ \text{DAPO} = \text{GRPO-style Advantage} + \text{更适合 Long-CoT 的训练 Recipe} }


6.9 veRL:大模型 RL 后训练框架

6.9.1 veRL 解决什么问题?

veRL(Volcano Engine Reinforcement Learning)是面向大模型 RL 后训练的分布式训练框架,也是 HybridFlow 的开源实现。PPO、GRPO 和 DAPO 回答的是“模型应该怎样更新”,veRL 回答的则是“如何让这套算法在多机多卡上真正运行起来”。

一次在线 RL 训练不只有 Forward 和 Backward,还需要反复执行:

1
2
3
4
5
6
取 Prompt
→ 生成 Response
→ 计算 Reward
→ 计算 Advantage
→ 更新模型
→ 用新模型继续生成

这条链涉及多种模型和计算引擎:

  • Actor 负责训练,需要保存 Gradient 和 Optimizer State;
  • Rollout Engine 负责生成,需要 KV Cache 和高吞吐推理;
  • PPO 还需要 Critic 计算 Value;
  • KL 正则可能需要冻结的 Reference Policy;
  • Reward 可能来自规则、代码执行器或 Reward Model。

它们使用的并行方式、显存和执行时机都不相同。veRL 的作用,就是把这些角色组织成一条完整的数据流,并管理分布式执行、GPU 分配、Batch 传递以及 Actor 到 Rollout Engine 的权重同步。

veRL 也提供 SFT 等能力,但其核心优势仍然是 PPO、GRPO 等包含在线 Rollout 的 RL 训练。

6.9.2 先看 veRL 的整体运行结构

理解 veRL 时,可以先只记住三层:

1
2
3
4
5
6
7
8
9
10
算法控制层(Algorithm Control / Driver)
RayPPOTrainer
↓ 调用 WorkerGroup
分布式执行层(Distributed Workers)
ActorRollout WorkerGroup / Critic WorkerGroup
Ref WorkerGroup(可选)/ Reward Model WorkerGroup(可选)
↓ Worker 调用具体 Backend
计算引擎层(Execution Engine / Backend)
Training Engine:FSDP / FSDP2 / Megatron
Rollout Engine:vLLM / SGLang
第一层:Trainer / Driver 决定执行顺序

RayPPOTrainer 通常运行在 Driver Process 中。它维护 PPO 的全局控制流,决定什么时候生成、什么时候计算 Reward、什么时候更新 Critic 和 Actor。

Driver 本身不执行大模型的分布式 Forward 或 Backward。它更像调度者:准备 Batch,调用对应角色,接收结果,再把结果交给下一阶段。

第二层:Worker / WorkerGroup 执行某个模型角色

Actor、Rollout、Critic 等角色由远程 Workers 执行。多个共同运行一个分布式模型的 Workers 组成一个 WorkerGroup。

例如,Driver 调用:

1
actor_rollout_wg.generate_sequences(batch)

表示让 Actor/Rollout WorkerGroup 使用多张 GPU 生成 Response。Driver 只发起一次调用,WorkerGroup 内部会完成数据分发、分布式计算和结果收集。

第三层:Engine / Backend 完成真正的模型计算

Worker 内部再调用具体计算引擎:

  • Actor/Critic Training 可以使用 FSDP、FSDP2 或 Megatron;
  • Rollout Generation 可以使用 vLLM 或 SGLang。

因此可以把三层的职责概括为:

1
2
3
Trainer:下一步做什么?
WorkerGroup:由哪些进程和 GPU 来做?
Engine:模型具体怎样并行计算?

HybridFlow 所谓 Hybrid,主要体现在它既保留了清晰的集中式算法控制流,又允许每个模型角色在内部使用自己的分布式执行方式。

6.9.3 把算法角色映射到 GPU

上一节说明了程序由 Trainer 调用 WorkerGroup。接下来还要解决两个问题:需要创建哪些 WorkerGroup,以及它们分别放在哪些 GPU 上。

Role:需要哪些计算角色?

Role 是算法中的逻辑角色:

  • ActorRollout:训练 Policy,并使用 Policy 生成 Response;
  • Critic:PPO 中的 Value Model;
  • RefPolicy:计算 KL 时使用的冻结 Reference Policy;
  • RewardModel:使用模型打分时的 Reward Model。

不是每次训练都需要全部角色。例如 PPO 需要 Actor/Rollout 和 Critic,但 Reference Policy、Reward Model 都是可选的;GRPO 一般不需要 Critic。

veRL 会根据配置把这些 Role 映射为相应的 WorkerGroup。理解时重点关注每个角色的输入和输出,不需要死记具体的 Worker Class 名称。

ResourcePool:这些角色放在哪些 GPU 上?

ResourcePool 表示一组可供 Worker 使用的 GPU。Role 到 ResourcePool 的 Mapping 决定每个角色部署在哪里。

如果多个角色映射到同一个 ResourcePool,它们会共享同一批 GPU,并在不同训练阶段分时运行,这称为 Colocation。例如 Rollout 结束后释放或休眠 KV Cache,再使用这些 GPU 更新 Actor。

如果给 Rollout 和 Training 分配不同 Resource Pools,则两者可以独立运行,减少显存切换和资源竞争,但需要更多 GPU,也要承担跨资源池同步权重的开销。

DataProto:阶段之间传递什么?

不同 WorkerGroup 之间不直接传递零散变量,而是通过统一的 DataProto 传递一个 Batch。它包含:

  • Tensor Batch:input_ids、responses、old_log_probs 等;
  • Non-tensor Batch:原始文本、数据来源、Ground Truth 等;
  • Meta Info:动态 Batch、Timing 等控制信息。

可以把 DataProto 理解成贯穿一次 RL Iteration 的数据包:Rollout 向其中加入 Response,Critic 加入 Value,Reward Function 加入 Reward,Advantage Estimator 再加入 Advantage 和 Return。后面的 PPO 流程会具体说明这些字段怎样逐步产生。

6.9.4 从启动脚本到训练循环

运行一个 veRL PPO 脚本时,程序首先完成初始化:

  1. 读取 Hydra 配置,确定模型、数据、算法和集群参数;
  2. 启动 Ray,获得当前节点上的 GPU 资源;
  3. 加载 Dataset、Tokenizer 和 Reward Function;
  4. 根据配置确定需要 Actor/Rollout、Critic、Reference、Reward Model 中的哪些角色;
  5. 将这些 Role 映射到 ResourcePool,并初始化对应的 WorkerGroup;
  6. 构造 RayPPOTrainer,调用 fit() 进入训练循环。

这部分只是在“搭建舞台”。真正的数据流发生在 RayPPOTrainer.fit() 中:它每次从 DataLoader 取得一批 Prompt,让各个 WorkerGroup 按照 PPO 顺序处理这批数据。

6.9.5 一次 PPO 在 veRL 中如何执行?

这一节只跟踪一批 Prompt,重点看每一步由谁执行、返回什么,以及结果怎样交给下一步。

第一步:取出 Prompt

DataLoader 从训练集中取出一批样本。每条样本主要包含两部分:

  • 给模型的问题,例如一道数学题或一段用户指令;
  • 计算 Reward 所需的信息,例如标准答案、测试用例或任务类型。

Tokenizer 将文本 Prompt 转换成 Token IDs,并通过 Padding 把同一 Batch 补到相同长度。最终得到的不是新的训练结果,只是一批已经整理好、可以送入模型生成的 Prompt。

第二步:生成 Response

Rollout Worker 接收上一阶段整理好的 Prompt,使用当前 Policy 生成答案。底层通常由 vLLM 或 SGLang 执行高吞吐推理。

如果每个 Prompt 采样 GG 次,就会得到 GG 条不同的 Response。每个“Prompt + Response”组成一条完整轨迹。

这一步的主要输出就是一批模型答案,同时还会记录每条答案的有效长度,避免后续把补齐长度使用的 Padding 当成模型真正生成的内容。

第三步:计算 Reward

Trainer 将每条 Prompt、生成的 Response 和标准答案等验证信息交给 Reward Function 或 Reward Model。

例如,数学题可以检查最终答案,代码题可以运行测试用例,主观问答可以由 Reward Model 打分。这一步通常为每条完整 Response 返回一个标量,表示这条答案整体有多好。

为了与后续按 Token 计算的 GAE 对齐,veRL 会把这个分数放在 Response 的最后一个有效 Token 上。如果启用了 KL Reward,还会减去 Actor 偏离 Reference Policy 的惩罚。

第四步:确定这批数据的 Old Log Probability

这批 Response 是由更新前的 Policy 生成的。为了进行 PPO 更新,需要知道旧策略当时认为每个已生成 Token 有多大概率。

Training Actor 会重新读取固定的 Prompt–Response,不再生成新答案,而是一次性计算旧策略赋予每个 Response Token 的 Log Probability,这就是 Teacher-forcing Forward。

之所以由 Training Actor 重新计算,而不直接使用 Rollout Engine 返回的概率,是因为生成与训练可能分别使用 vLLM/SGLang 和 FSDP/Megatron。重新计算可以让 Old Log Probability 与后面 Current Log Probability 使用一致的模型计算路径,减少不同引擎造成的数值偏差。

这些旧概率在整轮 PPO 更新中保持不变,后面会与更新中的 Current Actor 概率比较,计算 Importance Ratio。

第五步:补齐 PPO 所需的其他量

如果启用了 KL,Reference Policy 会读取同一批 Prompt–Response,计算自己赋予每个 Response Token 的概率。将它与 Actor 的概率比较,就能衡量 Actor 偏离 Reference Policy 的程度。

Critic 也会读取这些完整轨迹。与 Actor 预测“下一个 Token 是什么”不同,Critic 为每个生成位置预测“从这里继续生成,最终预计能得到多少回报”,也就是 Value。

至此,每条轨迹已经有了实际 Reward、旧策略概率和 Critic 对未来回报的预测。

第六步:计算 Advantage 与 Return

Trainer 将实际 Reward 与 Critic 预测的 Value 交给 GAE,产生两种训练信号:

  • Advantage:这次实际生成相对于 Critic 原本预期好多少,用于训练 Actor;
  • Return:Critic 后续应该拟合的目标,用于训练 Critic。

简单来说,这一步把“模型最终得了多少分”转换成 Actor 和 Critic 各自可以直接学习的目标。具体计算公式对应前文的 GAE。

第七步:先更新 Critic

Trainer 把完整轨迹和刚刚算出的 Return 交给 Critic WorkerGroup。

Critic 重新预测每个生成位置的 Value,并与 Return 比较,计算 Value Loss,然后反向传播更新 Critic。这个阶段只让 Critic 的估值更加准确,不会直接改变 Actor 的生成概率。

第八步:再更新 Actor

Trainer 再把固定轨迹、旧策略概率和 Advantage 交给 Actor WorkerGroup。Actor 会:

  1. 重新计算 Current Actor 对这些 Response Tokens 的概率;
  2. 与生成数据时的旧策略概率比较,构造 Importance Ratio;
  3. 结合 Advantage 计算 PPO Clipped Objective;
  4. 执行 Backward 和 Optimizer Step。

这里不会重新生成 Response,而是在同一批固定 Tokens 上更新 Actor。

同一批 Rollout 可以重复训练多轮,但作为比较基准的旧策略概率始终不变。

第九步:同步新权重,开始下一轮

Actor 更新后,新权重需要进入 Rollout Engine。下一批 Prompt 必须由更新后的 Policy 生成,否则 Rollout Policy 会一直停留在旧版本。

veRL 将更新后的 Actor 权重同步给 Rollout Engine。Trainer 随后记录 Reward、KL、Clip Fraction、Value Loss 和各阶段耗时,并按配置执行 Validation 或保存 Checkpoint,再读取下一批 Prompt。

因此,一次 veRL PPO Iteration 的主线是:

1
2
3
4
5
6
7
8
9
Prompt
→ Rollout 得到 Response
→ Reward
→ Old Log Probability
→ Critic Value
→ GAE
→ 更新 Critic
→ 更新 Actor
→ 同步权重后继续 Rollout

对应到代码,RayPPOTrainer.fit() 的核心调用关系可以简化为下面的伪代码。这里省略了 DataProto 合并、分布式调度和日志等细节:

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
for prompt_batch in train_dataloader:
# 第一步、第二步:取出 Prompt,并用当前 Policy 生成 Response
rollout_batch = actor_rollout_wg.generate_sequences(prompt_batch)

# 第三步:根据 Prompt、Response 和标准答案计算整条轨迹的 Reward
rewards = reward_fn(rollout_batch)

# 第四步:Training Actor 在固定 Response 上重算 Old Log Probability
old_log_probs = actor_rollout_wg.compute_log_prob(rollout_batch)

# 第五步:可选地计算 Reference Probability;Critic 预测 Value
if use_reference_policy:
ref_log_probs = ref_policy_wg.compute_ref_log_prob(rollout_batch)
values = critic_wg.compute_values(rollout_batch)

# 第六步:由 Reward 和 Value 计算 Advantage 与 Return
train_batch = compute_advantage(
rollout_batch,
rewards=rewards,
values=values,
old_log_probs=old_log_probs,
)

# 第七步、第八步:分别更新 Critic 和 Actor
critic_wg.update_critic(train_batch)
actor_rollout_wg.update_actor(train_batch)

# 第九步:Actor 新权重同步到 Rollout Engine,进入下一轮

若运行 GRPO,整体控制流基本相同,但会去掉 Critic 的 Value 计算和更新,并将 GAE 换成同一 Prompt 多条 Response 的 Group-relative Advantage。

6.9.6 同步与异步强化学习范式

前面描述的是同步(Synchronous)训练。每一轮严格按照以下顺序执行:

1
2
3
4
5
6
Rollout
→ 等待整批 Response 全部生成
→ Reward / Advantage
→ 更新 Actor
→ 同步新权重
→ 下一轮 Rollout

它的优点是每批数据都由最新或非常接近当前的 Policy 生成,算法关系清晰、训练相对稳定。问题是 Rollout 和 Training 不能重叠:Trainer 等待生成时处于空闲状态,Rollout Workers 等待训练时也可能处于空闲状态。若少数 Response 特别长,整批训练还必须等待这些 Long-tail Samples。

One-step Asynchronous

一种简单的异步方法是让下一批 Rollout 与当前批训练并行:

1
2
3
Rollout Workers:生成 Batch k+1
↕ 同时进行
Training Workers:训练 Batch k

Training 和 Rollout 使用不同 GPU 资源。Trainer 使用第 kk 批数据更新参数时,Rollout Workers 已经使用更新前的 Policy 生成第 k+1k+1 批数据。因此第 k+1k+1 批数据被训练时,通常落后当前 Actor 一个版本,这也称为 One-step Off-policy。

veRL 的 One-step Off-policy Async Pipeline 会:

  1. 将 Actor Training 与 Rollout 分配到不同 Resource Pools;
  2. 训练当前 Batch 时,异步生成下一个 Batch;
  3. 使用 NCCL 在 Actor 与 Rollout Workers 之间同步参数;
  4. 用较小的 Policy Staleness 换取 Rollout 与 Training 的时间重叠。
Fully Asynchronous

Fully Asynchronous 进一步取消“一批生成完成后再交给 Trainer”的固定边界:

1
2
3
4
Rollouter
→ 持续生成样本
→ Message Queue
→ Trainer 持续取样并更新

Rollouter 是 Producer,生成一条或一小批轨迹后放入 Message Queue;Trainer 是 Consumer,积累到足够样本后立即训练。Parameter Synchronizer 每隔若干次更新再把最新 Actor 权重同步给 Rollouter。

这样可以进一步减少全局等待,并支持 Streaming Rollout、Partial Rollout 和更灵活的资源分配。但 Queue 中的样本可能由更旧的 Policy 生成,异步程度越高,Policy Staleness 通常越严重。

异步训练的核心问题:Policy Staleness

设一条轨迹由 Behavior Policy πb\pi_{\mathrm{b}} 生成,而 Trainer 更新时的 Current Policy 已经是 πθ\pi_\theta。PPO 的 Importance Ratio 应写为:

ρt=πθ(yt∣st)πb(yt∣st).\rho_t = \frac{ \pi_\theta(y_t\mid s_t) }{ \pi_{\mathrm{b}}(y_t\mid s_t) }.

异步训练中,分母必须对应真正生成该 Token 的 Rollout Policy。因此通常需要让 Rollout 同时保存其 Log Probability 和 Policy Version,而不能随意使用 Trainer 当前参数重新构造 Old Log Probability。

若 πb\pi_{\mathrm{b}} 过旧,核心矛盾是:不做 Off-policy Correction 会产生有偏梯度;使用 Importance Sampling Correction 又会产生高方差。

具体后果可以沿下面的因果链理解。

  1. Importance Ratio 变得极端,导致 Gradient Estimate 不稳定。

    Current Policy 与 Behavior Policy 差距越大,ρt\rho_t 越容易远大于 11 或接近 00。Policy Gradient 中每个 Token 的贡献大致包含:

    ρtAt∇θlog⁡πθ(yt∣st).\rho_t A_t\nabla_\theta\log\pi_\theta(y_t\mid s_t).

    在未裁剪的 Importance Sampling Objective 中,ρt\rho_t 会直接缩放每个 Token 的梯度贡献,因此极大的 Ratio 会放大对应梯度。PPO 使用 min 在未裁剪目标与裁剪目标之间做选择,是否保留该梯度取决于 Advantage 的符号:

    • 当 At>0A_t>0 且 ρt>1+ϵ\rho_t>1+\epsilon 时,说明好 Token 的概率已经提高过多,目标选择常数分支,该 Token 的 Actor Gradient 为 00;
    • 当 At<0A_t<0 且 ρt\rho_t 很大时,说明坏 Token 的概率反而提高了。此时 min 仍选择 ρtAt\rho_tA_t,保留较大的纠正梯度,而不会将它截断。

    因此 Clip 能抑制“沿正确方向更新过远”产生的极端梯度,但不会裁掉所有大 Ratio。Policy 非常 Stale 时,未被裁掉的极端项仍可能使不同 Mini Batches 的 Gradient Norm 和方向剧烈波动。

  2. PPO Clip 会降低部分风险,但也会降低旧样本的有效利用率。

    PPO 会限制过于极端的 Ratio。对于 Positive Advantage,ρt>1+ϵ\rho_t>1+\epsilon 后不再继续提供正向梯度;对于 Negative Advantage,ρt<1−ϵ\rho_t<1-\epsilon 后也进入裁剪区间。

    因此 Policy 越 Stale,一部分 Tokens 会进入常数分支而不再贡献 Actor Gradient;另一部分处在错误方向上的极端 Tokens 仍可能产生很大的纠正梯度。前者表现为 Clip Fraction 升高、Sample Efficiency 下降,后者仍可能带来梯度波动。PPO Clip 缓解了问题,但无法让严重 Off-policy 的数据重新等价于 On-policy 数据。

  3. 旧轨迹覆盖的行为与 Current Policy 当前的问题不一致。

    Stale Rollout 主要包含旧 Policy 容易访问的 Prefix 和 Action,而 Current Policy 的输出分布可能已经变化。Trainer 继续优化这些旧行为时,可能没有覆盖 Current Policy 新出现的错误;新的错误又要等后续 Rollout 才能进入 Queue。

    结果是训练反馈存在延迟:模型可能已经发生变化,梯度却仍在修正若干步以前的问题,学习速度下降,并可能出现来回修正的震荡。

  4. Critic 也会受到 State Distribution Shift 的影响。

    Critic 持续在旧 Policy 访问的 States 上拟合 Return,而对 Current Policy 新访问的 States 缺少训练。这样下一轮为 Current Policy 估计 Value 时误差可能更大,进而使 Advantage 更噪,最终又影响 Actor Gradient 的稳定性。

因此,Policy Staleness 过大通常会同时表现为:Importance Ratio 分布极端、Clip Fraction 升高、有效梯度比例下降、Reward 波动,以及单位 Rollout Compute 带来的能力提升减少。

常见控制方式包括:

  • 限制允许使用的最大 Staleness;
  • 更频繁地同步 Actor 到 Rollouter;
  • 丢弃过旧样本;
  • 使用 Importance Sampling 或 Rollout Correction;
  • 在吞吐与 On-policy 程度之间调整 Rollout/Training 资源比例。

异步 RL 不是新的 Advantage Estimator 或 Policy Loss,而是一种执行范式。PPO、GRPO 和 DAPO 都可以构建同步或异步 Pipeline。还要注意:Rollout Engine 使用异步 API 并不一定代表“异步 RL”;只有 Rollout 与 Training 真正重叠,并允许 Trainer 消费旧 Policy 产生的数据时,才涉及这里讨论的异步训练和 Policy Staleness。

6.9.7 配置文件应该怎么看?

veRL 使用层级配置。阅读一个 PPO 启动脚本时,可以按以下顺序理解。

Data
1
2
3
4
5
data.train_files
data.val_files
data.train_batch_size
data.max_prompt_length
data.max_response_length

train_batch_size 表示每个 Rollout Step 的全局 Prompt 数。若 rollout.n=G,最终生成的轨迹数通常为:

num trajectories=train batch size×G.\text{num trajectories} = \text{train batch size}\times G.

Model 与 Actor
1
2
3
4
5
6
actor_rollout_ref.model.path
actor_rollout_ref.actor.strategy
actor_rollout_ref.actor.optim.lr
actor_rollout_ref.actor.ppo_mini_batch_size
actor_rollout_ref.actor.ppo_epochs
actor_rollout_ref.actor.clip_ratio
  • strategy 决定 Training Backend;
  • ppo_mini_batch_size 是全局 Mini Batch Size;
  • ppo_epochs 决定一批 Rollout 被重复训练多少轮;
  • clip_ratio 对应 PPO 的 ϵ\epsilon。
Rollout
1
2
3
4
5
6
actor_rollout_ref.rollout.name
actor_rollout_ref.rollout.n
actor_rollout_ref.rollout.tensor_model_parallel_size
actor_rollout_ref.rollout.gpu_memory_utilization
actor_rollout_ref.rollout.temperature
actor_rollout_ref.rollout.top_p
  • name 选择 vLLM、SGLang 等 Rollout Backend;
  • n 表示每个 Prompt 生成几条 Response;
  • tensor_model_parallel_size 决定一个 Rollout Replica 使用多少张 GPU;
  • gpu_memory_utilization 表示 Rollout Engine 可以使用的 GPU 显存比例,影响模型权重、Activation 和 KV Cache 的可用显存预算。
Critic 与 Algorithm
1
2
3
4
5
6
7
critic.model.path
critic.optim.lr
critic.ppo_mini_batch_size
algorithm.adv_estimator
algorithm.gamma
algorithm.lam
algorithm.use_kl_in_reward

PPO 通常使用 adv_estimator=gae 并启用 Critic;GRPO 通常使用 adv_estimator=grpo,不需要 Critic。

Trainer
1
2
3
4
5
6
trainer.n_gpus_per_node
trainer.nnodes
trainer.total_epochs
trainer.test_freq
trainer.save_freq
trainer.logger

这些参数控制 Cluster 规模、训练轮数、验证、Checkpoint 和日志。

6.9.8 Train Batch、Mini Batch 与 Micro Batch

这三个 Batch Size 位于不同层级:

  1. data.train_batch_size:一次 Rollout 取多少个 Prompt;
  2. ppo_mini_batch_size:一次 Optimizer Step 使用多少条 Trajectories;
  3. micro_batch_size_per_gpu:每张 GPU 单次 Forward/Backward 实际处理多少条 Trajectories。

假设:

1
2
3
4
5
train_batch_size = 128
rollout.n = 1
ppo_mini_batch_size = 16
4 GPUs
micro_batch_size_per_gpu = 1

那么 128 条 Rollout 会拆成 8 个 Mini Batches。每个 Mini Batch 全局有 16 条轨迹,平均每张 GPU 处理 4 条;每卡再以 Micro Batch 1 连续处理并累积梯度,最后完成该 Mini Batch 的 Optimizer Step。

Micro Batch 主要影响峰值显存与吞吐,不应改变算法上的有效 Mini Batch。veRL 还支持 Dynamic Batch:

1
2
use_dynamic_bsz = True
ppo_max_token_len_per_gpu = ...

它不再只按“样本条数”切 Batch,而是限制每张 GPU 一次处理的最大 Token 数,更适合 Response 长度差异很大的 RL Rollout。

6.9.9 并行策略如何选择?

Training Backend
  • FSDP/FSDP2:按参数切分模型状态,适合常见 Hugging Face 模型和中等规模训练;
  • Megatron-LM:支持更完整的 Tensor/Pipeline/Sequence Parallel,适合更大模型。
Rollout Tensor Parallel

rollout.tensor_model_parallel_size=TP 表示一个 Rollout Replica 由 TPTP 张 GPU 协同运行。

  • 较大 TP:降低每卡模型权重和 KV Cache 压力,但跨卡通信更多、Replica 数更少;
  • 较小 TP:可以启动更多 Data-parallel Rollout Replicas,通常吞吐更高,但每卡显存压力更大。

因此能放下模型时,Rollout 不一定是 TP 越大越好。

Sequence Parallel

长上下文训练可以使用 Ulysses Sequence Parallel,把 Sequence 维度切到多张 GPU。相关配置通常是:

1
ulysses_sequence_parallel_size

它主要缓解长序列 Activation 和 Attention 的显存压力,但会增加通信。

6.9.10 显存与性能调优

定位性能问题时,应先区分发生在哪个阶段。

Rollout OOM 或吞吐低

重点检查:

  • max_prompt_length 与 max_response_length;
  • rollout.n;
  • tensor_model_parallel_size;
  • gpu_memory_utilization;
  • max_num_batched_tokens;
  • max_num_seqs;
  • KV Cache 是否在角色切换时正确释放或休眠。
Actor/Critic Update OOM

重点检查:

  • PPO Micro Batch;
  • Dynamic Batch 的 Max Tokens per GPU;
  • Gradient Checkpointing;
  • Remove Padding;
  • FSDP Parameter/Optimizer Offload;
  • Sequence Parallel Size;
  • Model、Gradient、Optimizer State 与 Activation 的显存占用。
GPU 利用率低

常见原因包括:

  • Response 长度差异导致 Straggler;
  • Micro Batch 太小;
  • Rollout TP 太大、Replica 太少;
  • 生成阶段 max_num_batched_tokens 太低;
  • Worker 之间存在同步等待;
  • Reward Function 或外部 Sandbox 成为 CPU/Network Bottleneck。

veRL 的 Timing Metrics 会将 gen、reward、old_log_prob、values、adv、update_actor 和 update_critic 分开记录,应先找到耗时最大的阶段,再调整对应配置。

6.9.11 阅读 veRL 源码的主线

阅读 veRL 源码时,可以沿以下顺序:

  1. PPO 入口:配置、Dataset、Reward、Role Mapping;
  2. RayPPOTrainer.init_workers():WorkerGroup 和模型如何初始化;
  3. RayPPOTrainer.fit():整个算法控制流;
  4. generate_sequences():Rollout Backend;
  5. compute_advantage():GAE、GRPO 等 Advantage Estimator;
  6. update_actor():Mini/Micro Batch 与 PPO Loss;
  7. update_critic():Value Loss;
  8. DataProto:各阶段传递的数据字段;
  9. Sharding Manager:Actor Training 与 Rollout Engine 如何同步权重。

不必死记所有文件名,重点是能回答:

  • 算法控制流在哪里?
  • 每个分布式模型由哪个 WorkerGroup 执行?
  • 一个字段在 DataProto 的哪一步产生、被谁消费?
  • Actor 更新后,权重如何进入 Rollout Engine?
  • 当前 OOM 或性能瓶颈属于 Rollout、Forward 还是 Backward?

6.10 PPO、GRPO、DAPO 的关系

6.10.1 PPO 与 GRPO

两者都使用:

  • Online Rollout;
  • Importance Ratio;
  • Clipped Policy Objective;
  • Reward 驱动的策略更新。

主要区别是 Advantage Baseline:

PPO:Critic + GAE\boxed{ \text{PPO:Critic + GAE} }

GRPO:同 Prompt 多 Response 的组内相对 Reward\boxed{ \text{GRPO:同 Prompt 多 Response 的组内相对 Reward} }

PPO 节省同 Prompt 的多次采样,但需要训练 Critic;GRPO 去掉 Critic,但依赖多个 Rollout 形成可靠的 Group Baseline。

6.10.2 GRPO 与 DAPO

DAPO 继承了 GRPO 的 Group-relative Advantage,但针对 Long-CoT 做了系统改进:

  • 对称 Clip 改成 Clip-Higher;
  • 随机 Prompt Batch 改成过滤零方差 Group 的 Dynamic Sampling;
  • Sample-level Loss 改成 Token-level Loss;
  • 对硬截断改成平滑的 Overlong Reward Shaping;
  • 原始 DAPO Recipe 移除了 KL。

因此 DAPO 不是完全不同的理论框架,更像是围绕 GRPO-style RL 构建的一套大规模 Reasoning RL Recipe。


6.11 实践中最容易忽略的问题

6.11.1 Reward Hacking

Policy 优化的是给定 Reward,而不是开发者心中真正想要的能力。如果 Reward Function 存在漏洞,模型可能学会钻漏洞。

例如只检查最终答案字符串时,模型可能碰巧输出正确答案,但推理过程完全错误。解决思路包括:

  • 改进答案解析和等价性判断;
  • 使用隐藏测试用例;
  • 同时检查格式、过程与最终结果;
  • 定期人工审查高 Reward 样本;
  • 在训练外使用独立 Evaluation。

6.11.2 Sparse Reward

如果困难题几乎全部得到 00:

P(R>0)≈0,P(R>0)\approx0,

就没有足够的正向信号。可以使用:

  • SFT Cold Start;
  • Curriculum Learning;
  • 增加每个 Prompt 的 Rollout 数;
  • Process / Partial Reward;
  • 将任务分解成更容易的子任务。

6.11.3 Entropy Collapse

Policy 过早变得确定时,多条 Rollout 几乎一致,探索能力下降。应监控:

H(πθ),\mathcal H(\pi_\theta),

并结合 Sampling Temperature、Entropy Bonus、Clip Range 和 DAPO Clip-Higher 调整。

Entropy 也不是越大越好。过高可能表示输出随机、无法收敛;目标是在探索与利用之间取得平衡。

6.11.4 长度偏差与截断

长 Response 会带来:

  • 更高 Rollout 延迟;
  • 更大的 KV Cache;
  • 更多训练激活值;
  • 更高的截断概率;
  • Sample-level 与 Token-level Loss 权重差异。

因此应同时监控:

  • Mean Response Length;
  • Max-length Hit Rate;
  • Truncation Rate;
  • 正确与错误样本各自的长度分布;
  • Reward 与长度的相关性。

6.11.5 Prompt 分布偏移

训练与最终评测的 Prompt Template 不一致时,表现可能下降。变化可能来自:

  • System Prompt;
  • 是否要求输出推理过程;
  • 最终答案格式;
  • Few-shot Examples;
  • 中英文指令;
  • Stop Tokens 与 Chat Template。

稳妥做法是让训练 Prompt 覆盖可能的评测格式,并单独做 Prompt Robustness Evaluation,而不是只在单一 Template 上报告结果。

6.11.6 多任务 Mixture 与 Task Interference

多任务目标可写为:

J(θ)=∑k=1KwkJk(θ),J(\theta) = \sum_{k=1}^{K} w_kJ_k(\theta),

其中:

  • KK:任务数量;
  • JkJ_k:第 kk 个任务的目标;
  • wkw_k:该任务在总目标中的权重。

改变采样比例,本质上会改变各任务对总梯度的贡献。比例选择不应只看哪个任务当前 Reward 最低,而应看:

  • 各任务独立 Held-out Validation;
  • Reward / Accuracy 的改善趋势;
  • 是否已经 Plateau;
  • 增加训练预算后的边际收益;
  • 是否存在一个任务提升、另一个任务持续退化。

如果两个任务梯度满足:

giTgj<0,g_i^Tg_j<0,

说明它们的更新方向存在冲突,可能出现 Task Interference。这时除了调 Mixture,还可以考虑更小的 Learning Rate、分阶段训练或 Multi-task Gradient Balancing。

6.11.7 Online RL 的 Off-policy 程度

Rollout 来自 πθold\pi_{\theta_{\mathrm{old}}},更新的是 πθ\pi_\theta。如果同一批数据训练太多轮,新旧 Policy 差距会越来越大:

πθ≉πθold.\pi_\theta \not\approx \pi_{\theta_{\mathrm{old}}}.

Importance Sampling 的方差增大,大量 Tokens 会被 Clip。因此应结合:

  • PPO Epochs;
  • Learning Rate;
  • Clip Fraction;
  • Approximate KL;
  • Rollout 更新频率;

判断是否过度重复使用旧数据。


6.12 总结

理解大模型 RL 后训练,可以抓住两条主线。

第一条是统一 Pipeline:

Prompt→Rollout→Reward→Advantage→Policy Update.\text{Prompt} \rightarrow \text{Rollout} \rightarrow \text{Reward} \rightarrow \text{Advantage} \rightarrow \text{Policy Update}.

第二条是不同算法如何构造 Advantage 并稳定更新 Policy:

PPO:CriticGRPO / DAPO:Group Reward\text{PPO:Critic} \qquad \text{GRPO / DAPO:Group Reward}

PPO 通过 Critic 与 GAE 提供较稳定的 Advantage,但需要额外训练 Value Model;GRPO 用同一 Prompt 下的组内 Reward 比较删除 Critic,但依赖多次 Rollout 和有效的组内 Reward 方差;DAPO 则进一步针对 Long-CoT 中的探索、有效采样、Loss 聚合和截断问题改进 GRPO-style Training。

最终选择哪种方法,取决于 Reward 是否可验证、Rollout 预算、显存限制、任务难度以及 Critic 能否提供可靠的 Value Estimation。

参考资料

  1. Attention Is All You Need
  2. RoFormer: Enhanced Transformer with Rotary Position Embedding
  3. Root Mean Square Layer Normalization
  4. GLU Variants Improve Transformer
  5. LLaMA: Open and Efficient Foundation Language Models
  6. Proximal Policy Optimization Algorithms
  7. High-Dimensional Continuous Control Using Generalized Advantage Estimation
  8. DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models
  9. DAPO: An Open-Source LLM Reinforcement Learning System at Scale
  10. HybridFlow: A Flexible and Efficient RLHF Framework
  11. AReaL: A Large-Scale Asynchronous Reinforcement Learning System for Language Reasoning
  12. veRL: One Step Off Policy Async Trainer
  13. veRL: Fully Async Policy Trainer
  14. veRL GitHub Repository
  15. veRL Documentation
  16. Scalable Diffusion Models with Transformers
  17. Scaling Rectified Flow Transformers for High-Resolution Image Synthesis
  18. Learning Transferable Visual Models From Natural Language Supervision
  19. Flamingo: a Visual Language Model for Few-Shot Learning
  20. BLIP-2: Bootstrapping Language-Image Pre-training with Frozen Image Encoders and Large Language Models
  21. Visual Instruction Tuning
  22. Qwen2-VL: Enhancing Vision-Language Model’s Perception of the World at Any Resolution
  23. PixArt-α\alpha: Fast Training of Diffusion Transformer for Photorealistic Text-to-Image Synthesis
  24. Demystifying FLUX Architecture
  25. Qwen2.5-VL Technical Report
  26. InternVL3: Exploring Advanced Training and Test-Time Recipes for Open-Source Multimodal Models
  27. Chameleon: Mixed-Modal Early-Fusion Foundation Models
  28. LLaVA-OneVision: Easy Visual Task Transfer
  29. Switch Transformers: Scaling to Trillion Parameter Models with Simple and Efficient Sparsity
  30. DeepSeek-V2: A Strong, Economical, and Efficient Mixture-of-Experts Language Model
  31. DeepSeek-V3 Technical Report
  32. Mamba: Linear-Time Sequence Modeling with Selective State Spaces
  33. Gated Delta Networks: Improving Mamba2 with Delta Rule
  34. Qwen3-Next: Towards Ultimate Training & Inference Efficiency
  35. Kimi Linear: An Expressive, Efficient Attention Architecture
  36. Better & Faster Large Language Models via Multi-token Prediction

AI 八股:大模型基础知识
https://cny123222.github.io/2026/09/30/AI-八股:大模型基础知识/
Author
Nuoyan Chen
Posted on
September 30, 2026
Licensed under