OPD 是近期后训练里很值得关注的一条路线。它和 GRPO / RLVR 的目标有些相似：都想让模型在自己的生成分布上变强。但它给训练信号的方式不一样。

GRPO 通常是：

student 自己生成 response，然后 verifier / reward model 给一个 scalar reward。

OPD 更像是：

student 自己生成 response，然后 teacher 在这些 on-policy responses 上给 dense supervision。

所以 OPD 的关键词是：on-policy、teacher、distillation、dense signal。

1. 普通 distillation 是什么

Knowledge distillation 的基本想法是：用强 teacher model 指导弱 student model。

最简单的 supervised distillation 是让 student 模仿 teacher 的输出：

$$
\mathcal{L}{KD} = D{KL}(p_{\mathrm{teacher}}(\cdot \mid x) || p_{\mathrm{student}}(\cdot \mid x))
$$

在 LLM 里，可以让 teacher 生成高质量 answers，然后 student 做 SFT。

这类方法的优点是简单。

但它通常是 off-policy 的：训练数据来自 teacher 或静态数据集，不一定来自 student 当前会生成的分布。

这会带来一个问题：student 在推理时遇到的状态，可能和训练时看到的不一样。

2. 为什么需要 on-policy

语言模型生成是自回归的。

一旦前面某个 token 偏了，后面的上下文就变成 student 自己制造出来的分布。

如果训练时只看 teacher 的完美轨迹，student 没有学会在自己的错误轨迹上恢复。

这就是 distribution shift。

On-policy 的意思是：训练数据来自当前 student policy。

OPD 会让 student 先 rollout，生成它自己会生成的 responses，然后 teacher 在这些 responses 或中间 token 上提供监督。

直觉上：

不要只教学生看标准答案，也要在学生自己的解题过程上指出应该怎么走。

这点和 RL 类似。PPO/GRPO 也是在当前 policy 的 outputs 上学习。

区别在于，RL 用 reward；OPD 用 teacher distribution。

3. RLVR 的 sparse reward 问题

以数学题为例。

GRPO 可能只知道最终答案是否正确：

$$
r(y) \in {0,1}
$$

如果答案错了，模型不知道哪一步错。

如果答案对了，模型也不知道中间哪些 token 真的关键。

这种 scalar reward 很稀疏。

OPD 希望用 teacher 提供更密集的信号。比如在 student rollout 的每个 token 位置，teacher 都可以给出概率分布或 log probability。

这样 student 不只是知道整段 response 好不好，而是能看到 teacher 在每个位置上更倾向什么。

4. OPD 的基本流程

一个简化的 OPD 流程可以写成：

1. 从 prompt dataset 里取一批 prompts
2. student policy $\pi_\theta$ 生成 responses
3. teacher model $\pi_T$ 对这些 on-policy responses 计算 token-level supervision
4. student 用 distillation loss 更新

如果 student 生成：

$$
y = (y_1, y_2, …, y_T)
$$

teacher 可以在每个位置给：

$$
\log \pi_T(y_t \mid x, y_{<t})
$$

student 则优化自己在这些 on-policy tokens 上的行为。

这和纯 SFT 不一样。SFT 的 response 通常来自数据集；OPD 的 response 来自 student 当前 policy。

5. Reverse KL 的直觉

OPD 论文里经常会出现 KL objective。

Forward KL 和 reverse KL 的行为不一样。

Forward KL：

$$
D_{KL}(p_T || p_\theta)
$$

倾向于让 student 覆盖 teacher 的分布。

Reverse KL：

$$
D_{KL}(p_\theta || p_T)
$$

倾向于让 student 避开 teacher 认为低概率的区域。

在生成模型里，reverse KL 往往更 mode-seeking。它会鼓励 student 更集中地落到 teacher 支持的高质量区域。

这对后训练很有吸引力，因为 student 的 on-policy rollout 可能包含很多质量一般的 token。Teacher 的 dense signal 可以把它往更好的区域拉。

6. OPD 和 GRPO 的核心差别

GRPO 的训练信号通常是 response-level reward。

比如：

$$
A_i = \frac{r_i - \mu}{\sigma}
$$

它告诉模型：这一组 responses 里哪个更好。

OPD 的训练信号来自 teacher 对 token distribution 的判断。

它告诉模型：在 student 自己走到的上下文里，teacher 会怎么分布概率。

所以两者的区别是：

• GRPO：用 scalar reward 做 outcome-driven learning
• OPD：用 teacher probabilities 做 dense behavior shaping

这也是 OPD 可能更高效的原因。Scalar reward 只在终点给信号，teacher distribution 可以在每一步给信号。

7. OPD 和 SFT 的核心差别

SFT 是在静态数据上模仿。

OPD 是在 student 当前 rollout 上蒸馏。

如果 student 已经接近 teacher，SFT 可能足够。

如果 student 会生成很多偏离 teacher 的中间状态，OPD 更有价值，因为 teacher 可以在这些状态上给反馈。

这有点像老师批改学生自己的草稿，而不是只给学生看范文。

8. Online OPD 的成本

标准 OPD 的一个问题是成本。

训练时需要 student rollout，然后 teacher 对这些 rollouts 计算 supervision。

如果 teacher 很大，就需要 live teacher inference server。

这会带来：

• 推理成本高
• 系统复杂
• 训练吞吐低
• teacher 服务和 student 训练要同步
• 多机异步时容易出现 stale samples

所以 OPD 虽然训练信号更密集，但系统上并不轻。

这也是 Lightning OPD、StableOPD、f-OPD 这些工作的背景。

9. Lightning OPD：把 online teacher 变成 offline

Lightning OPD 关注一个问题：能不能不用 live teacher server？

它的思路是 offline on-policy distillation。

核心是预计算 teacher log-probabilities，然后训练时复用。

但这里有一个关键条件：teacher consistency。

如果 SFT 阶段和 OPD 阶段使用的 teacher 不一致，或者 teacher 对 student rollouts 的分布不一致，就可能引入不可消除的 gradient bias。

Lightning OPD 的一个重要结论是：只要保持 teacher consistency，offline OPD 可以接近 standard OPD 的 optimum，同时显著降低系统成本。

这对个人或学术实验很重要。因为 live teacher server 是很高的门槛。

10. StableOPD：长度膨胀和重复崩溃

OPD 也有自己的失败模式。

一个问题是 length inflation。

Student on-policy rollouts 可能越来越长，训练目标又在这些 rollouts 上蒸馏，最后导致长而重复的输出变多。

如果 responses 被截断，训练数据里会出现大量 truncated trajectories。这会造成 biased gradient signal。

StableOPD 这类方法尝试用 reference-based divergence constraint 和 rollout mixture distillation 稳定训练。

直觉上，它在防止 student 被自己的坏 rollout 分布拖走。

这说明 OPD 虽然不用 scalar reward，但仍然有 policy drift 问题。

11. f-OPD：异步训练里的 freshness

大规模训练通常不是完全同步的。

Rollout 生成、teacher 计算、student 更新可能是异步执行。

这会带来 stale sample 问题。

一个样本生成时对应的是旧 student policy，但真正训练时 student 已经更新过很多步。

Teacher supervision 的上下文也可能变旧。

f-OPD 把这种偏差拆成 rollout drift 和 supervision drift，并引入 freshness score 来判断样本是否还可靠。

直觉上：

样本不是越多越好，旧到一定程度的样本会偏离 on-policy 目标。

这对 long-horizon agentic tasks 尤其重要。任务越长，轨迹越复杂，staleness 的影响越大。

12. OPD 适合什么任务

OPD 适合这些场景：

• 有强 teacher model
• Student 需要在自己的生成分布上学习
• Sparse reward 太弱
• 希望 token-level dense supervision
• 任务轨迹较长，单一 scalar reward 不够

比如数学 reasoning、代码生成、视频定位、agentic tool use，都可能适合 OPD。

但 OPD 不是所有场景都合适。

如果没有强 teacher，OPD 的上限会受限。

如果 teacher 推理成本太高，系统负担很重。

如果 student rollout 质量太差，teacher supervision 可能长期在很差的状态上补救，训练效率不一定高。

13. OPD 和 RL 能不能结合

可以。

OPD 和 RLVR 不是互斥关系。

一种可能是先用 OPD 做 dense behavior shaping，让 student 接近 teacher 的高质量 reasoning 分布。

再用 RLVR 针对最终正确率做强化。

另一种可能是在 RL 过程中加入 teacher regularization，防止模型为了 reward 走向奇怪分布。

也可以把 OPD 看成一种替代 sparse reward 的中间路线：它不像 SFT 那么离线，也不像 RL 那么依赖 scalar reward。

14. OPD 的风险

第一，teacher bias。

Student 会继承 teacher 的偏好和错误。

第二，teacher ceiling。

如果目标任务需要超过 teacher 的能力，单纯 OPD 很难突破 teacher。

第三，计算成本。

Teacher log-probs 对大模型来说很贵。

第四，length / repetition instability。

On-policy rollouts 可能产生越来越长、越来越重复的样本。

第五，staleness。

异步训练时，rollout 和 supervision 可能过期。

所以 OPD 不是“比 RL 更简单”的万能方法。它只是把问题从 reward design 转移到 teacher supervision 和系统效率上。

15. 读 OPD 论文时看什么

我会看这些问题：

• Teacher model 是什么
• Student model 是什么
• Rollouts 来自当前 student 还是旧 policy
• Teacher supervision 是 token-level 还是 response-level
• 用 forward KL 还是 reverse KL
• 是否需要 live teacher server
• 是否 offline 预计算 teacher log-probs
• 如何处理 length inflation
• 如何处理 stale samples
• 是否和 GRPO / PPO 在同等 compute 下比较
• 推理时是否真的提升 greedy performance

尤其要注意 compute。OPD 如果性能提升但 teacher 成本巨大，实际价值要重新评估。

16. 小结

OPD 可以理解成一条介于 SFT 和 RLVR 之间的后训练路线。

SFT 在静态数据上模仿。

GRPO 在 on-policy samples 上用 scalar reward 学。

OPD 在 on-policy samples 上用 teacher dense supervision 学。

我的理解是：

OPD 的价值在于，它保留了 on-policy 学习的分布匹配，又用 teacher 分布缓解了 sparse reward 的问题。

但它的难点也很明确：teacher 成本、teacher consistency、长度膨胀、异步 staleness。

如果后面 reasoning / coding / agentic post-training 继续发展，OPD 这条线很可能会越来越重要。

参考资料

• Hinton et al., Distilling the Knowledge in a Neural Network
• DeepSeek-AI, DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning
• Wu et al., Lightning OPD: Efficient Post-Training for Large Reasoning Models with Offline On-Policy Distillation
• Luo et al., Demystifying OPD: Length Inflation and Stabilization Strategies for Large Language Models
• Chen et al., f-OPD: Stabilizing Long-Horizon On-Policy Distillation with Freshness-Aware Control
• Li et al., Video-OPD: Efficient Post-Training of Multimodal Large Language Models for Temporal Video Grounding via On-Policy Distillation

大模型后训练里的 RL 和传统 RL 不太一样。传统 RL 常见场景是 agent 在环境里反复交互，比如机器人控制、游戏、推荐系统。LLM 后训练里的“环境”往往更窄：给一个 prompt，模型生成 response，然后由人类偏好、reward model、规则 verifier、测试用例或者答案匹配器给出反馈。

所以这里不用先背完整 RL 教材。先抓住一条主线：

后训练里的 RL，本质上是在让模型生成的回答更容易得到高 reward，同时又不能偏离原模型太远。

这句话里有三个关键词：policy、reward、reference。

1. 语言模型里的 policy 是什么

在 RL 里，policy 通常写成：

$$
\pi_\theta(a \mid s)
$$

它表示在状态 $s$ 下采取动作 $a$ 的概率。

放到语言模型里，可以这样对应：

• 状态（state）：当前 prompt 加上已经生成的 tokens
• 动作（action）：下一个 token
• policy：语言模型给下一个 token 的概率分布

如果把完整回答看成一个 token 序列：

$$
y = (y_1, y_2, …, y_T)
$$

那么模型生成这个回答的概率是：

$$
\pi_\theta(y \mid x) = \prod_{t=1}^{T} \pi_\theta(y_t \mid x, y_{<t})
$$

其中 $x$ 是 prompt。

这也是为什么很多后训练算法会用 log probability：

$$
\log \pi_\theta(y \mid x) = \sum_{t=1}^{T} \log \pi_\theta(y_t \mid x, y_{<t})
$$

因为整段 response 的概率是 token 概率连乘，直接乘容易数值很小，取 log 后就变成求和。

2. Token-level action 和 response-level action

理论上，LLM 每一步生成 token 都是一个 action。

但很多 reward 是 response-level 的。比如数学题最后答案对不对、代码是否通过测试、回答是否更符合人类偏好，这些通常是整段回答生成完之后才知道。

这就带来一个 credit assignment 问题：

如果最终回答错了，到底是哪几个 token 造成的？

PPO 里会尝试用 value model 和 advantage estimation，把整段 reward 分摊到 token-level 更新上。

GRPO 里则常见做法是对同一个 prompt 采样多个 responses，再用组内 reward 相对大小得到 advantage。

DPO 更进一步，不显式做在线 RL，而是直接比较 chosen response 和 rejected response 的 log probability。

这些算法看起来差很多，但都绕不开同一个问题：训练信号怎样从“整段回答好不好”传回到模型参数。

3. Reward：后训练真正优化的目标

Reward 可以来自很多地方。

在人类偏好场景里，reward 可能来自 reward model：

$$
r_\phi(x, y)
$$

它输入 prompt 和 response，输出一个标量分数。

在 reasoning / coding 场景里，reward 经常是 verifiable reward：

• 数学题最终答案是否匹配
• 代码是否通过单元测试
• 格式是否满足要求
• 工具调用是否成功

这类方法常被叫做 RLVR，也就是 reinforcement learning from verifiable rewards。

RLVR 的优势是 reward 更客观，不需要每个样本都人工标注偏好。

但它也有明显局限：reward 很稀疏。一个数学题只有最终答案对/错，模型并不知道中间哪一步推理值得奖励。

这也是为什么 reasoning model 训练里经常会关心：

• 如何采样更多候选
• 如何过滤高质量 reasoning traces
• 如何避免只学会猜答案
• 如何让 reward 不只看最终答案

4. Return、value 和 advantage

在一般 RL 里，return 是从当前时刻往后能拿到的累计 reward：

$$
G_t = \sum_{k=t}^{T} \gamma^{k-t} r_k
$$

LLM 后训练里，很多任务只有最终 reward，所以可以粗略理解为整段回答的得分。

Value function 估计的是某个状态下未来能拿到多少 reward：

$$
V^\pi(s) = \mathbb{E}_{\pi}[G_t \mid s_t=s]
$$

Advantage 衡量的是某个 action 比平均水平好多少：

$$
A_t = G_t - V^\pi(s_t)
$$

这个量很重要。

如果一个回答得分是 0.8，不一定说明它很值得加强。也许这个 prompt 很简单，随便生成都能 0.8。

如果另一个回答得分是 0.6，也不一定差。也许这个 prompt 很难，大多数回答都是 0.1。

Advantage 想表达的是：相对于当前状态的预期表现，这个 action / response 到底更好还是更差。

5. Policy gradient 的直觉

Policy gradient 的经典形式可以写成：

$$
\nabla_\theta J(\theta) = \underset{\pi_\theta}{\mathbb{E}}[\nabla_\theta \log \pi_\theta(a \mid s) A(s,a)]
$$

放到 LLM 里，可以粗略理解成：

如果某个 response 的 advantage 为正，就提高它的生成概率；如果 advantage 为负，就降低它的生成概率。

但这里有两个细节。

第一，提高的是整段 response 里 tokens 的 log probability，不是直接给最终答案加分。

第二，更新不能太大。语言模型是高维分布，一次更新如果把概率分布拉得太远，可能会破坏原来的语言能力。

这就引出 KL constraint。

6. KL constraint：为什么需要 reference model

后训练里通常会保留一个 reference model，记作 $\pi_{\mathrm{ref}}$。

它通常是 SFT 后的模型，或者训练开始前的 policy snapshot。

更新 policy 时，会惩罚当前模型和 reference model 的差异：

$$
D_{KL}(\pi_\theta || \pi_{\mathrm{ref}})
$$

直觉上，KL constraint 在说：

可以朝高 reward 方向走，但不要走到完全不像原来的模型。

没有 KL 约束会有什么问题？

模型可能为了骗 reward model 生成奇怪模式。比如 reward model 偏好长回答，模型就越来越啰嗦；reward model 偏好自信语气，模型就更容易胡说；verifier 只看最终答案，模型可能学会投机格式。

所以后训练不是简单最大化 reward，而是：

$$
\max_\theta \mathbb{E}[r(x,y)] - \beta D_{KL}(\pi_\theta || \pi_{\mathrm{ref}})
$$

这里 $\beta$ 控制 reward 优化和保持原模型分布之间的平衡。

7. On-policy 和 off-policy

On-policy 指训练数据来自当前 policy。

Off-policy 指训练数据来自旧 policy、其他模型，或者离线数据集。

LLM 后训练里，这个区别非常关键。

如果模型训练时看到的是自己当前会生成的回答，那训练分布和推理分布更接近。这是 on-policy 的优势。

但 on-policy 代价高，因为训练过程中要不断采样新 responses。

Off-policy 成本低，可以直接用已有数据训练。但如果数据分布和当前模型差很多，模型学到的更新可能不稳定。

这就是为什么 PPO / GRPO / OPD 都强调 on-policy 或接近 on-policy。它们希望模型在自己的生成分布上学习，而不是只模仿静态数据。

8. RLHF、RLVR 和 preference optimization

这几个词容易混。

RLHF 通常指 reinforcement learning from human feedback。经典流程是：人类偏好数据 -> reward model -> PPO 优化 policy。

RLVR 是 reinforcement learning from verifiable rewards。它不一定需要人类偏好，而是用规则、答案、测试来给 reward。

Preference optimization 更宽，包括 DPO、IPO、KTO 等直接从偏好或二元反馈训练的算法。它们不一定显式训练 reward model，也不一定跑在线 RL。

可以这样记：

• RLHF：人类偏好先变 reward model，再做 RL
• RLVR：可验证任务直接给 reward
• DPO/KTO：从偏好数据直接优化 policy，不显式训练 reward model
• OPD：用 teacher 的 dense supervision 替代 sparse reward

这些路线都属于后训练，但训练信号来源不一样。

9. 为什么 reasoning model 更依赖 RL

SFT 可以让模型学会解题格式，但它本质上是模仿。

如果 SFT 数据里有高质量 reasoning traces，模型会学到“像这样推理”。但它没有直接被奖励“答案正确”。

RLVR 可以直接优化最终正确率。比如同一个数学题，模型生成多个答案，只有正确答案拿到 reward。经过训练，模型会提高能得到正确答案的生成轨迹概率。

这也是 DeepSeek-R1 这类 reasoning model 重要的地方：它不是只靠人工写好的 CoT，而是通过可验证 reward 强化推理行为。

不过这也带来风险。

如果 reward 只看最终答案，模型可能学到短路策略。比如中间推理不可靠，但答案格式正确；或者生成更长 reasoning 来提高偶然命中率。

所以 reasoning RL 的关键不是“用了 RL”，而是 reward、采样、过滤、KL、长度控制一起设计。

10. 后训练里的几个常见失败模式

第一，reward hacking。

模型学会利用 reward 的漏洞，而不是真的变好。

第二，mode collapse。

模型输出变得单一，缺少多样性。

第三，length inflation。

模型生成越来越长，因为长回答更容易看起来努力，或者更容易覆盖答案。

第四，over-optimization。

训练集 reward 越来越高，但真实评估变差。

第五，distribution drift。

policy 离 reference model 太远，语言能力或安全边界受损。

这些问题后面讲 PPO、GRPO、OPD 时都会反复出现。

11. 读后训练论文时先看什么

我会先看这几个问题：

• 训练信号来自哪里：人类偏好、reward model、verifier、teacher model？
• 数据是 on-policy 还是 off-policy？
• reward 是 token-level、step-level，还是 response-level？
• 有没有 reference model 和 KL constraint？
• 是否需要 value model？
• 每个 prompt 采样多少 responses？
• 如何处理全对/全错样本？
• 如何控制长度膨胀？
• benchmark 提升是否只是来自更多采样或更长输出？

这些问题比算法名字本身更重要。

12. 小结

后训练里的 RL 可以压缩成一句话：

让模型在自己的生成分布上尝试回答，用 reward 或偏好信号判断好坏，再提高好回答的概率，同时用 reference model 限制分布漂移。

PPO、GRPO、DPO、KTO、OPD 的区别，主要在于训练信号怎么来、advantage 怎么算、是否需要在线采样、是否需要额外模型。

所以这一章先把 RL 语言打通。后面再看具体算法时，就不会只是在背缩写。

参考资料

• Schulman et al., Proximal Policy Optimization Algorithms
• Ouyang et al., Training language models to follow instructions with human feedback
• Rafailov et al., Direct Preference Optimization: Your Language Model is Secretly a Reward Model
• Shao et al., DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models
• DeepSeek-AI, DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning

多模态模型经常被描述成“模型能看图、看视频、听音频”。但从结构上看，问题其实是：

怎么把不同模态的信息变成 LLM 能处理的 representation。

LLM 本来处理的是 token sequence。图像、视频、音频不是离散文本 token，所以要先经过编码、投影、对齐，再接入语言模型。

1. VLM 的基本结构

一个典型 vision-language model 可以拆成三块：

• Vision encoder
• Projector / adapter
• LLM

Vision encoder 把图片编码成视觉特征。

Projector 把视觉特征映射到 LLM 的 hidden dimension。

LLM 把视觉 token 和文本 token 放在一起处理，并生成回答。

粗略写成：

$$
z_v = \mathrm{VisionEncoder}(I)
$$

$$
h_v = \mathrm{Projector}(z_v)
$$

然后把 $h_v$ 和文本 embedding 拼接，送入 LLM。

这个结构很直接，但每一步都有细节。

2. 图像 token 是怎么来的

图像通常会被切成 patches。

ViT 的做法是把图片分成固定大小 patch，然后每个 patch 映射成一个向量。

如果一张图片被切成 $N$ 个 patches，就会得到 $N$ 个视觉 token。

问题是：图片分辨率越高，patch 数越多，视觉 token 越多。

视觉 token 多了以后，LLM 的上下文压力变大。

所以多模态模型经常要做 token compression 或 dynamic resolution。

这里的核心 trade-off 是：

• token 多，视觉细节保留更好，但计算更贵
• token 少，推理更便宜，但细节可能丢失

比如 OCR、图表理解、数学几何题，都需要细粒度视觉信息。普通场景描述可能不需要那么多 token。

3. Projector 不只是维度对齐

很多入门解释会说 projector 只是把 vision encoder 输出维度变成 LLM hidden size。

这不算错，但太简单。

Projector 还承担模态对齐作用。

Vision encoder 的表示空间来自图像预训练，LLM 的表示空间来自文本预训练。两者不是天然兼容。

Projector 要把视觉特征变成 LLM 能理解的“类 token 表示”。

如果 projector 太弱，视觉信息进了 LLM 也不好用。

如果 projector 太强或训练不稳定，又可能破坏语言模型原有能力。

所以多模态训练经常分阶段：

1. 先训练 projector，让视觉特征对齐文本空间
2. 再做 instruction tuning，让模型学会多模态问答
3. 后面再加入更复杂的 reasoning、OCR、video、agent 数据

4. 拼接视觉 token vs cross-attention

视觉信息接入 LLM 有不同方式。

一种是直接把视觉 token 拼到文本 token 前面或中间，让 LLM self-attention 统一处理。

这种方式简单，符合 decoder-only LLM 的接口。

另一种是 cross-attention。语言 token 在某些层通过 cross-attention 去读取视觉特征。

直接拼接的好处是结构统一。

Cross-attention 的好处是视觉特征可以作为单独 memory，控制更灵活。

但两者都绕不开一个问题：视觉 token 太多时，attention 成本会很高。

所以现代 VLM 的关键不是“能不能接图像”，而是“怎么高效接入足够多的视觉信息”。

5. 多图输入更难在哪里

单图问答已经不简单，多图更难。

多图任务需要模型区分不同图片，并在图片之间建立关系。

比如：

图 1 是模型结构图，图 2 是实验结果表。请判断结构改动是否带来了稳定提升。

这时模型不只是描述图像，而是要跨图对齐信息。

多图输入涉及：

• 每张图的边界
• 图片顺序
• 跨图引用
• 视觉信息和文本问题的对应关系

如果视觉 token 全部拼在一起，模型必须学会哪些 token 属于哪张图。

这就是为什么多模态位置编码和 image boundary token 很重要。

6. 视频：多了时间维度

视频不是图片列表这么简单。

视频有时间顺序、运动、事件持续、因果关系。

如果只抽几帧，可能丢掉关键动作。

如果抽很多帧，token 数会爆炸。

所以视频模型通常要处理三个问题：

• frame sampling：取哪些帧
• temporal encoding：怎么表示时间顺序
• long video understanding：怎么保留长时间信息

举个例子。

如果视频里一个人先拿起杯子，再把杯子放进柜子，最后关上柜门。只看最后一帧，模型可能知道柜门关了，但不知道杯子被放进去了。

视频理解需要事件链，而不是静态描述。

7. 音频：连续信号怎么变 token

音频比图像更不一样。

文本是离散 token，音频是连续波形。

音频模型通常会先把波形变成特征，比如 spectrogram，或者用 audio encoder 得到表示。

如果要生成语音，还需要把文本或 hidden states 转成 speech tokens 或 codec tokens，再解码成波形。

Qwen3-Omni 这类模型会涉及 Thinker-Talker 结构。可以粗略理解为：

• Thinker 负责多模态理解和推理
• Talker 负责生成自然语音

这样做的原因是理解和语音生成不是同一个问题。理解需要语义、推理、对齐；语音生成还需要音色、节奏、流式延迟。

8. Omni model 难在哪里

Omni model 希望一个模型同时处理文本、图像、视频、音频，并且可能还要输出文本和语音。

这比 VLM 更难，因为不同模态的时间尺度和信息密度不同。

一张图片可以被压成几百个视觉 token。

一段音频可能每秒产生大量 acoustic tokens。

视频又同时包含空间和时间信息。

把这些东西统一到一个模型里，需要解决：

• 模态表示统一
• 长上下文压力
• 训练数据混合
• 不同任务 loss 的平衡
• 实时交互延迟
• 输出模态控制

所以 omni model 不是简单把 VLM、ASR、TTS 拼起来。真正难的是统一训练和统一推理。

9. 多模态 reasoning

多模态模型最有价值的地方不是“描述图片”，而是跨模态 reasoning。

比如：

• 看图表并推断趋势
• 看论文公式截图并解释推导
• 看 UI 截图并判断用户下一步该点哪里
• 看视频并找出事件因果
• 听语音并结合语气理解意图

这些任务要求模型把视觉或音频证据和语言推理结合。

所以多模态 benchmark 也在从 captioning 走向 MMMU、MathVista、video QA、document understanding 等更复杂任务。

10. 幻觉问题更复杂

文本模型会 hallucinate，多模态模型也会，而且更难检查。

比如模型可能说图片里有某个物体，但实际没有。

或者 OCR 把数字看错，后面推理全错。

或者视频里漏掉关键动作，却生成一个合理故事。

多模态 hallucination 的根源可能来自：

• 视觉 encoder 没捕捉到细节
• projector 对齐不好
• LLM 依赖语言先验脑补
• 图像分辨率不够
• 训练数据里 caption 偏泛化

所以多模态模型的回答要特别注意 evidence grounding。最好能让模型指出依据来自图像哪个区域、哪一帧、哪段音频。

11. 训练数据决定上限

多模态模型很依赖数据。

图片-caption 数据可以教模型描述图片。

OCR 数据可以教模型读文字。

图表问答数据可以教模型理解可视化。

视频问答数据可以教模型时间推理。

音频对话数据可以教模型语音交互。

如果数据只覆盖普通图片描述，模型很难自动变成强视觉推理模型。

这和语言模型一样：结构提供可能性，数据决定能力落点。

12. 读多模态技术报告时看什么

我会看这些问题：

• Vision encoder 是什么
• 视觉 token 数怎么控制
• Projector 是线性层、MLP，还是更复杂结构
• 是否冻结 LLM 或 vision encoder
• 训练分几个阶段
• 支持单图、多图、视频、音频中的哪些输入
• 是否支持语音输出
• benchmark 覆盖 caption、OCR、chart、math、video reasoning 吗
• 长视频或高分辨率图片怎么处理
• 有没有 grounding 或 hallucination 评估

尤其要看“输入支持”和“能力支持”的区别。能输入视频，不等于能理解长视频事件。能输入音频，不等于能做自然低延迟语音对话。

13. 小结

多模态模型的核心问题是模态对齐。

图像、视频、音频都要先变成 LLM 能处理的表示，然后再和文本 token 一起完成理解和生成。

VLM 的关键是视觉 token、projector 和视觉语言对齐。

视频模型多了时间维度。

音频模型多了连续信号、codec、实时生成的问题。

Omni model 则进一步要求一个系统统一处理多个模态的输入和输出。

所以我会把多模态看成现代大模型从“语言接口”走向“世界接口”的一步。但这一步不是靠一个接口参数实现的，而是结构、数据、训练阶段和系统延迟一起决定的。

参考资料

• Radford et al., Learning Transferable Visual Models From Natural Language Supervision
• Liu et al., Visual Instruction Tuning
• Bai et al., Qwen3-VL Technical Report
• Xu et al., Qwen3-Omni Technical Report
• OpenAI, Video generation models as world simulators
• GLM-4.5 Team, GLM-4.5: Agentic, Reasoning, and Coding Foundation Models

现在很多模型会区分 thinking mode 和 non-thinking mode，也会强调数学、代码、复杂推理能力。表面上看，这是“模型回答前多想一会”。但如果只这么理解，就太浅了。

Reasoning model 的变化至少包括三层：

• 推理时愿意花更多 token 和计算
• 训练时用更强的推理数据和偏好信号
• 后训练阶段用 RL 等方法强化可验证任务上的表现

所以这篇从 CoT 开始，逐步过渡到 DeepSeek-R1 这类模型。

1. 普通 next token prediction 的限制

语言模型的基本目标是预测下一个 token：

$$
\max_\theta \sum_t \log p_\theta(x_t \mid x_{<t})
$$

这个目标很强，能学到语法、知识、代码模式、常识关系。

但复杂推理不只是“最像下一个词”。很多题需要中间状态：

• 先拆条件
• 再选择公式
• 再计算
• 再检查结果

如果模型直接从问题跳到答案，中间任何一步错了都很难纠正。

所以 reasoning 的一个核心思路是：不要急着输出最终答案，先生成中间推理过程。

2. Chain-of-thought 的作用

Chain-of-thought（CoT）最早可以理解成一种 prompting 方法。

给模型几个带中间步骤的例子，模型在新问题上也更倾向于写出中间步骤。

比如简单问题：

小明有 3 个苹果，又买了 5 个，吃掉 2 个，还剩几个？

直接回答也能做。

但如果问题变成多条件、多变量、多约束，直接回答容易跳步。

CoT 的作用是把一次复杂映射拆成多步局部映射：

$$
\text{problem} \rightarrow \text{intermediate steps} \rightarrow \text{answer}
$$

这不是魔法。它更像给模型更多计算轨迹，让模型在输出空间里保留中间状态。

3. CoT 为什么会提升能力

我觉得可以从三个角度理解。

第一，token budget 变多了。

模型不是在一个 token 或一句话里压出答案，而是有更多 token 做中间计算。

第二，中间步骤提供了隐式 scratchpad。

模型可以把已经得到的结论写下来，后面继续引用。

第三，训练分布更匹配。

如果模型在训练或示例中见过大量“逐步解题”的文本，它就会学到这种生成模式。

但 CoT 也有问题。模型写出来的推理不一定忠实。有时它只是生成一个看起来合理的解释，而真正导致答案的内部机制未必和文本推理一致。

所以 CoT 提升表现，不等于 CoT 完全可解释。

4. Test-time compute：推理时多花计算

Reasoning model 的一个核心趋势是 test-time compute。

传统模型更强调训练阶段投入：预训练更多数据、更大参数。

Reasoning model 则强调推理阶段也可以多花计算。

比如：

• 生成更长 reasoning trace
• 采样多个解法再选择
• 自我检查
• 用 verifier 打分
• 分解问题再逐步求解

这背后的想法是：对于复杂任务，生成一个短答案太便宜，也太冒险。

如果一道数学题需要 20 步推导，模型只生成 2 行答案，省下的 token 可能就是错误来源。

5. Thinking mode 和 non-thinking mode

Qwen3 这类模型提出 thinking mode 和 non-thinking mode 的统一框架。

这很实际。

不是所有问题都需要长推理。

问“北京今天几点”这种问题，如果模型长篇 reasoning，反而浪费时间。

但问一道复杂证明题、代码 debug、实验设计，就需要更多推理 token。

所以 thinking mode 的关键不是“永远思考”，而是根据任务复杂度分配计算。

这和人也像。简单问题直接答，复杂问题先列步骤。

从系统角度看，这叫 latency-quality trade-off。更长思考可能提高质量，但一定增加延迟和成本。

6. DeepSeek-R1-Zero：只靠 RL 能出现什么

DeepSeek-R1 里最有意思的部分是 R1-Zero。

R1-Zero 不先做 supervised fine-tuning，而是直接对 base model 做大规模 RL，目标是增强 reasoning 能力。

报告里提到，模型在 RL 过程中自然出现了一些推理行为，比如更长的思考、更强的自我验证。

这个结果很重要，因为它说明 reasoning 行为不一定完全依赖人工标注的 CoT 数据，也可以通过可验证奖励被强化出来。

但 R1-Zero 也有问题，比如可读性差、语言混杂、输出格式不稳定。

这说明“能推理”和“能以人类喜欢的方式推理”不是一回事。

7. DeepSeek-R1：cold-start + multi-stage RL

DeepSeek-R1 在 R1-Zero 的基础上加入 cold-start data。

也就是先给模型一些高质量、可读性更好的推理样本，让模型有一个更好的起点，然后再做 RL。

后面再经过多阶段训练，把 reasoning 能力、通用问答能力、可读性等拉到更平衡的状态。

这体现了一个很重要的训练思路：

RL 可以强化能力，但如果起点太乱，最终行为可能不好控制。

SFT 提供格式和初始行为，RL 提供目标导向的能力强化。

两者不是互斥，而是互补。

8. 可验证奖励为什么关键

Reasoning RL 最适合数学、代码这类任务，因为它们容易验证。

数学题可以看最终答案对不对。

代码题可以跑测试。

这类 reward 比“这个回答好不好”更明确。

如果 reward 很模糊，RL 容易学到投机行为。比如生成看起来更自信、更长、更像标准答案的文本，但不一定更正确。

所以 reasoning model 的突破，很大程度来自可验证任务的 reward 设计。

这也解释了为什么数学和代码经常是 reasoning model 的核心 benchmark。

9. Distillation：小模型学 reasoning

DeepSeek-R1 还强调 distillation，把大 reasoning model 的能力蒸馏到较小模型上。

蒸馏的直觉是：大模型生成高质量 reasoning data，小模型用这些数据做 supervised training。

这说明一个现象：

reasoning 能力的一部分可以通过行为模仿迁移。

但蒸馏也有上限。

小模型可以学到大模型的解题风格和部分策略，但参数容量、基础知识、搜索深度都有限。它不可能在所有场景都复制大模型能力。

所以蒸馏模型适合低成本部署，但不能简单等同于原始 teacher model。

10. Reasoning 不是更长越好

一个常见误区是：thinking token 越多，答案越好。

实际不是。

过长 reasoning 可能带来：

• 延迟变高
• 成本变高
• 中间步骤引入错误
• 模型绕远路
• 简单问题过度分析

所以 thinking budget 很重要。

理想状态是：简单任务短思考，复杂任务长思考；模型知道什么时候该停。

这也是 Qwen3 把 thinking budget 作为机制来讲的原因。

11. Reasoning trace 是否可信

模型写出的 reasoning trace 可以帮助人检查，但不能完全等同于模型内部真实推理。

有时模型会先在内部形成答案，再生成一段看似合理的解释。

有时它会在文本推理中走错，但最后答案碰巧对。

有时它的中间推理看起来很漂亮，但关键假设是错的。

所以我更愿意把 reasoning trace 看成一种可检查的输出过程，而不是完整透明的内部机制。

它有用，但不能盲信。

12. 读 reasoning model 报告时看什么

我会看这些问题：

• Base model 是什么
• 有没有 cold-start SFT
• RL reward 怎么设计
• 任务是否可验证
• 是否使用 rejection sampling 或 verifier
• thinking token 平均多长
• 是否支持非 thinking 模式
• benchmark 提升来自训练、采样，还是更长输出
• 蒸馏模型和原模型差距多大

尤其要看成本。一个 reasoning model 如果每题多花 10 倍 token，benchmark 提升就要放在成本背景下理解。

13. 小结

Reasoning model 的本质不是“模型突然会思考”，而是：

训练目标、数据构造、RL reward 和推理阶段计算分配共同改变了模型解决复杂问题的方式。

CoT 给模型 scratchpad。

Test-time compute 让模型推理时多花计算。

RL 在可验证任务上强化正确行为。

Distillation 把昂贵推理模型的行为迁移到小模型。

这几件事合起来，才是现代 reasoning model 的主线。

参考资料

• Wei et al., Chain-of-Thought Prompting Elicits Reasoning in Large Language Models
• Wang et al., Self-Consistency Improves Chain of Thought Reasoning in Language Models
• Shao et al., DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models
• DeepSeek-AI, DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning
• Qwen Team, Qwen3 Technical Report

现在很多前沿开源模型都会强调两个数字：total parameters 和 activated parameters。比如一个模型可能有 235B 总参数，但每个 token 只激活 22B 参数。

第一次看到这个说法时很容易觉得矛盾：到底是 235B 模型，还是 22B 模型？

MoE 的关键就在这里。它不是让所有参数每次都参与计算，而是给每个 token 选择一小部分 expert 来算。

1. Dense model 的问题

普通 Transformer 是 dense model。

每个 token 经过每一层时，都会使用这一层的全部参数。

如果模型变大，计算量也跟着变大。一个 dense 70B 模型和一个 dense 7B 模型相比，容量更大，但每个 token 的计算成本也明显更高。

这带来一个很现实的问题：参数规模、训练成本、推理成本几乎绑在一起。

想要更强模型，就要更大参数；参数越大，每次推理越贵。

MoE 试图拆开这件事：

• 总参数可以很大，用来提供更高容量
• 每个 token 只用一部分参数，用来控制计算成本

也就是说，MoE 想要的是“大容量”和“低激活成本”同时存在。

2. Expert 是什么

在很多 MoE Transformer 里，attention 层仍然是 shared 的，MoE 主要替换 FFN 层。

普通 FFN 是一个大的前馈网络：

$$
\mathrm{FFN}(x)
$$

MoE FFN 则有多个 expert：

$$
E_1(x), E_2(x), …, E_N(x)
$$

每个 expert 本质上可以理解成一个 FFN。区别是，不是每个 token 都跑所有 expert，而是由 router 选择其中几个。

如果使用 top-2 routing，那么 token $x$ 的输出大概是：

$$
y = g_1(x)E_{i}(x) + g_2(x)E_{j}(x)
$$

这里 $E_i$ 和 $E_j$ 是被选中的两个 experts，$g_1$ 和 $g_2$ 是 router 给出的权重。

直觉上，模型在说：

这个 token 更适合交给这些 expert 处理。

3. Router：MoE 的真正难点

MoE 听起来像“多放几个专家，然后自动选择”。但真正难的是 router。

Router 通常会对每个 token 算一个分数：

$$
s = xW_r
$$

再从所有 expert 里选 top-k。

问题是，如果 router 学得不好，所有 token 都挤向少数几个 expert，其他 expert 几乎不用。这样不仅浪费参数，还会导致某些 expert 负载爆炸。

所以 MoE 训练里经常要处理 load balancing。

Switch Transformer 里用了 auxiliary loss 来鼓励 token 更均匀地分配到不同 expert。DeepSeek-V3 则强调 auxiliary-loss-free 的 load balancing，试图减少辅助损失对模型主目标的干扰。

这里有一个技术取舍：

• 加 auxiliary loss，路由更容易均衡，但可能影响语言建模目标
• 不加或弱化 auxiliary loss，主目标更干净，但路由稳定性更难保证

MoE 的难点不是“有多个 expert”，而是“怎么让 expert 被合理使用”。

4. 总参数和激活参数

MoE 报告里经常出现两个数字。

Total parameters 指模型所有参数，包括所有 experts。

Activated parameters 指处理一个 token 时实际参与计算的参数。

比如一个 MoE 模型有 64 个 experts，每次只选 2 个。那总参数可能很大，但每个 token 只走其中一小部分。

这就解释了为什么一个模型可以同时标注为 235B total parameters 和 22B activated parameters。

它的容量接近一个超大模型，但单 token 计算量更接近一个中等模型。

不过这句话不能简单理解成“235B 的效果，22B 的成本”。因为 MoE 还有通信、路由、负载均衡、batching 等额外问题。

5. MoE 为什么适合大规模预训练

预训练阶段，模型会看到海量 token。不同 token 的统计特征差异很大：代码、数学、中文、英文、表格、对话、网页文本。

Dense model 对所有 token 使用同一组 FFN 参数。

MoE 则允许不同 token 走不同 expert。理论上，不同 expert 可以学到不同类型的模式。

比如某些 expert 可能更常处理代码 token，某些 expert 可能更常处理数学符号，某些 expert 更常处理自然语言。

这里要注意，我不会把 expert 理解成非常清晰的人类职业分工。它们不一定真的变成“数学专家”“代码专家”。更准确地说，expert 是被 router 动态选择的参数子空间。

这个区别很重要。技术报告里如果没有分析 expert specialization，就不要强行给每个 expert 贴人类标签。

6. MoE 的通信成本

MoE 在单卡上很容易理解，但大模型训练通常跨很多 GPU。

如果 expert 分布在不同 GPU 上，token 被 router 分配后，就需要在 GPU 之间传输。

这会引入 all-to-all communication。

Dense model 的通信主要来自模型并行、数据并行、梯度同步等。MoE 额外增加了 token dispatch 和 combine 的通信。

这就是为什么 MoE 论文和技术报告会关心：

• expert parallelism
• load balancing
• token dropping
• capacity factor
• communication-computation overlap

这些听起来像工程细节，但它们决定 MoE 能不能真的跑起来。

一个 routing 很漂亮但通信开销巨大的 MoE，在真实训练里可能并不划算。

7. Capacity factor 和 token dropping

每个 expert 每个 batch 能处理的 token 数通常会有限制。

如果某个 expert 被分配了太多 token，超出的 token 可能被 drop，或者走 fallback 路径。

Capacity factor 控制每个 expert 的容量上限。

如果 capacity 太小，容易 drop token，训练信号受损。

如果 capacity 太大，显存和计算浪费增加。

所以 MoE 的训练不是简单调 learning rate。它多了一组系统参数，而且这些参数和硬件拓扑、batch size、sequence length 都有关。

8. DeepSeekMoE 的思路

DeepSeek 系列技术报告里，MoE 是核心结构之一。

DeepSeek-V3 使用 671B total parameters，但每个 token 激活约 37B 参数。它还结合了 MLA、multi-token prediction、FP8 training 等工程优化。

这里值得注意的是：DeepSeek-V3 的强并不只是因为 MoE。

MoE 提供参数容量和计算效率，MLA 降低 KV cache 成本，FP8 降低训练成本，多 token prediction 尝试提高生成效率。

所以读 DeepSeek-V3 时，不要把结论压缩成“MoE 很强”。更准确的说法是：

DeepSeek-V3 是一组结构、训练和系统优化叠加出来的结果，MoE 是其中负责参数容量扩展的一块。

9. Qwen3 MoE 的位置

Qwen3 技术报告里同时有 dense 和 MoE 模型。

这很有意思，因为它说明 dense 和 MoE 不是谁完全替代谁，而是面向不同规模和部署场景的选择。

小模型用 dense 可能更简单、更稳定、更容易部署。

大模型用 MoE 可以把总容量拉高，同时控制每 token 计算。

所以模型家族通常会同时提供 dense 和 MoE 版本，让用户在延迟、成本、能力之间选。

10. MoE 不是免费午餐

MoE 最大的误区是：只看 activated parameters，然后以为成本就等于一个小 dense 模型。

实际不是。

MoE 至少有这些额外代价：

• Router 本身要计算
• Token dispatch 需要通信
• Expert 负载不均衡会降低硬件利用率
• 小 batch 推理时可能不如 dense 规整
• 训练稳定性更复杂
• Serving 系统更难做

这也是为什么 MoE 更像系统工程，而不只是模型结构。

如果部署环境很简单，dense model 可能反而更好。MoE 的优势通常要在足够大规模、足够好的并行系统里才能发挥。

11. 一个简单例子

假设一个客服模型要处理三类问题：

• 订单状态
• 退款政策
• 技术故障

Dense model 会用同一套 FFN 参数处理所有问题。

MoE model 可能学到某些 token 更常走某些 expert。和订单相关的表达经常激活一组 expert，技术故障相关的表达激活另一组 expert。

但真实 LLM 里的分工不会这么干净。一个 token 的意义受上下文影响，同一个词在代码、数学、闲聊里可能完全不同。

所以 MoE 的 router 不是按关键词查表，而是根据 hidden state 做动态选择。

12. 读 MoE 模型报告时看什么

我会重点看这些问题：

• 总参数和激活参数分别是多少
• 每层都有 MoE，还是部分层有 MoE
• 每次 routing 选 top-1、top-2，还是更多 expert
• 有没有 shared expert
• load balancing 怎么做
• 是否使用 auxiliary loss
• expert 数量是多少
• 训练和推理时的通信开销怎么处理
• benchmark 提升是来自 MoE 本身，还是同时叠加了数据、RL、上下文扩展

这些问题比“用了 MoE”更重要。

13. 小结

MoE 的核心思想很直接：

用稀疏激活把总参数容量和单 token 计算成本拆开。

但 MoE 的真实难点也很明确：

参数变稀疏以后，训练和系统复杂度会显著上升。

所以我会把 MoE 看成一种大规模模型扩展路线，而不是一个单纯提升模型能力的小技巧。

它适合的问题是：当 dense scaling 越来越贵时，能不能用更聪明的参数激活方式继续扩展模型容量。

参考资料

• Shazeer et al., Outrageously Large Neural Networks: The Sparsely-Gated Mixture-of-Experts Layer
• Fedus et al., Switch Transformers: Scaling to Trillion Parameter Models with Simple and Efficient Sparsity
• Qwen Team, Qwen3 Technical Report
• DeepSeek-AI, DeepSeek-V3 Technical Report
• GLM-4.5 Team, GLM-4.5: Agentic, Reasoning, and Coding Foundation Models
• Moonshot AI, Kimi K2: Open Agentic Intelligence

很多技术报告会说模型基于 Transformer，但如果只停留在 2017 年原始 Transformer 的结构，很容易读不懂后面的细节。现在主流 LLM 的基本骨架还是 Transformer，但很多关键部件已经换过一轮：decoder-only、pre-norm、RMSNorm、SwiGLU、RoPE、GQA、KV cache、FlashAttention 等等。

这些改动单独看都不复杂，但合在一起，才构成现在 LLM block 的真实样子。

1. 从 encoder-decoder 到 decoder-only

原始 Transformer 是为机器翻译设计的，所以它有 encoder 和 decoder。

Encoder 负责读完整个输入句子，decoder 负责一步一步生成目标句子。

但现在很多通用语言模型，比如 GPT、LLaMA、Qwen、DeepSeek，主要采用 decoder-only 结构。它没有单独的 encoder，而是把所有任务都改写成 next token prediction：

$$
p(x_t \mid x_1, x_2, …, x_{t-1})
$$

也就是说，模型只需要学会一件事：给定前面的 token，预测下一个 token。

这个形式非常统一。翻译、问答、总结、代码生成、数学推理，都可以变成“前面是一段 prompt，后面继续生成答案”。

这里有一个重要区别：

• BERT 这类 encoder-only 模型更像是在理解一整段文本
• GPT 这类 decoder-only 模型更像是在从左到右生成文本

LLM 选择 decoder-only，不是因为 encoder 不好，而是因为自回归生成和大规模预训练的目标天然对齐。

2. Causal attention：只能看过去

Decoder-only 模型使用 causal self-attention。

普通 self-attention 中，每个 token 可以看见所有 token。但语言生成时，当前位置不能偷看未来 token，否则 next token prediction 就变成了作弊。

所以 causal attention 会加一个 mask，让第 $t$ 个位置只能关注 $1$ 到 $t$ 的 token。

如果一句话是：

The cat sits on the

模型预测下一个词时，可以看见 “The cat sits on the”，但不能提前看见答案 “mat”。

这个 mask 看起来只是训练细节，但它决定了模型的能力形态：LLM 是一步一步生成的，不是一次性把完整答案算出来。

这也解释了为什么长回答里有时会出现前后不一致。模型每一步都基于已经生成的内容继续走，如果前面方向偏了，后面会被带偏。

3. Pre-Norm：深层网络更容易训练

原始 Transformer 使用 Post-Norm，大概形式是：

$$
x_{l+1} = \mathrm{LayerNorm}(x_l + F(x_l))
$$

现代 LLM 更常见的是 Pre-Norm：

$$
x_{l+1} = x_l + F(\mathrm{Norm}(x_l))
$$

差别是 normalization 放在 residual branch 前面还是后面。

Pre-Norm 的好处是深层模型训练更稳定。直觉上，residual path 更像一条“干净的高速通道”，梯度可以更直接地往前传，不会每层都被 normalization 包住。

这件事在小模型里可能没那么明显，但模型层数变深后，训练稳定性会变成核心问题。很多现代结构的变化，本质上都不是为了让单层表达力变强，而是为了让几百亿、几千亿参数模型真的能训起来。

4. RMSNorm：少算一点，但保留关键尺度控制

LayerNorm 会减均值、除标准差：

$$
\mathrm{LayerNorm}(x) = \frac{x-\mu}{\sqrt{\sigma^2+\epsilon}} \odot g + b
$$

RMSNorm 去掉了减均值，只保留 root mean square 的尺度归一化：

$$
\mathrm{RMSNorm}(x) = \frac{x}{\sqrt{\frac{1}{d}\sum_i x_i^2+\epsilon}} \odot g
$$

它关心的是向量整体尺度，而不是每一维相对均值的位置。

这有两个好处。

第一，计算更简单。对超大模型来说，每个 block 里省一点，整体就能省很多。

第二，它保留了最关键的稳定性作用：控制 activation 的尺度。

我觉得这里可以这样记：现代 LLM 里很多设计不是追求数学形式最完整，而是在“足够稳定”和“足够便宜”之间找平衡。

5. FFN 从 ReLU 走向 SwiGLU

Transformer block 里除了 attention，还有一个 feed-forward network。

原始 Transformer 用的是：

$$
\mathrm{FFN}(x) = \max(0, xW_1+b_1)W_2+b_2
$$

现代 LLM 常用 SwiGLU 这类 gated FFN：

$$
\mathrm{SwiGLU}(x) = \mathrm{Swish}(xW_1) \odot (xW_2)
$$

再接一个输出投影。

Gating 的直觉是：模型不只是对特征做非线性变换，还学会“哪些通道该打开，哪些通道该压下去”。

如果把 FFN 看成每个 token 独立做一次特征加工，那么 SwiGLU 相当于给这次加工加了一个动态开关。

很多模型报告不会花很大篇幅讲 FFN，但它非常重要。Transformer 里 attention 负责 token 之间的信息混合，FFN 负责每个 token 内部的特征变换。只看 attention，会低估 FFN 对模型容量的贡献。

6. RoPE：把位置信息放进旋转里

Self-attention 本身不包含顺序信息。对 attention 来说，如果不加位置编码，”A B C” 和 “C B A” 只是 token 集合不同排列，很难知道谁在前谁在后。

原始 Transformer 用 absolute positional encoding，把位置向量加到 token embedding 上。

现代 LLM 常用 RoPE，也就是 rotary position embedding。它不是简单把位置向量加进去，而是在 query 和 key 上做旋转，使 attention score 自然带上相对位置信息。

可以粗略理解成：

$$
q_m^\top k_n \rightarrow \text{a function of token content and relative distance } (m-n)
$$

RoPE 的关键好处是相对位置关系更自然，也更适合做一定程度的位置外推。

但这里不能过度神化 RoPE。RoPE scaling 可以帮助模型扩展 context length，但不等于模型自动学会利用超长上下文。位置能编码是一回事，模型能不能从 100K token 里稳定找出关键证据，是另一回事。

7. Multi-head attention 到 MQA / GQA

标准 multi-head attention 里，每个 head 都有自己的 $Q, K, V$：

$$
\mathrm{Attention}(Q,K,V)=\mathrm{softmax}\left(\frac{QK^\top}{\sqrt{d}}\right)V
$$

多头的作用是让模型从不同子空间看 token 之间的关系。

但推理时有一个很大的成本：KV cache。

生成第 $t$ 个 token 时，前面所有 token 的 key 和 value 都要保留下来。context 越长，KV cache 越大。

MQA（multi-query attention）让多个 query heads 共享一组 key/value。GQA（grouped-query attention）则折中一下，让一组 query heads 共享一组 key/value。

直觉上：

• MHA：每个注意力头都有自己的 K/V，效果强但 cache 大
• MQA：所有头共享 K/V，cache 小但可能损失表达力
• GQA：分组共享 K/V，在效果和成本之间折中

这类设计说明一个现实问题：现代 LLM 的结构不只是为了训练 loss，也要考虑 serving 成本。

一个模型如果 benchmark 很强但推理时 KV cache 爆炸，线上使用会很痛苦。

8. KV cache：生成式模型的核心工程问题

自回归生成时，如果每生成一个 token 都重新计算前面所有 token 的 K/V，成本会非常高。

KV cache 的做法是：前面 token 的 key 和 value 已经算过，就缓存起来，后面直接复用。

第一个 token 生成时，模型处理整个 prompt。

之后每一步生成新 token 时，只需要为新 token 计算新的 query、key、value，然后让 query 去关注缓存中的所有 K/V。

这让推理快很多，但代价是显存占用会随着 sequence length 线性增长。

所以长上下文模型的一个核心瓶颈不是参数量，而是 cache。

这也解释了为什么 DeepSeek 的 MLA、Qwen 的 GQA、各种 KV compression 都很重要。它们不是论文里的小优化，而是直接影响模型能不能便宜地跑长上下文。

9. FlashAttention：不是近似 attention

FlashAttention 容易被误解成某种近似 attention。其实它算的是 exact attention，主要优化的是内存访问。

标准 attention 会显式构造很大的 attention matrix：

$$
QK^\top
$$

当 sequence length 很长时，这个矩阵非常大。

FlashAttention 的核心思路是 tiling：把计算分块搬到 GPU SRAM 里做，减少高带宽显存 HBM 的读写次数。

所以它解决的是一个工程瓶颈：不是 FLOPs 看起来多少，而是数据在 GPU 内存层级之间搬来搬去有多贵。

这一点很重要。读现代论文时，不能只看数学复杂度，也要看硬件实际执行。一个理论上复杂度低的方法，如果 GPU 上跑不快，未必有实际价值。

10. 一个现代 LLM block 大概长什么样

把这些东西合起来，一个现代 decoder-only LLM block 可以粗略写成：

$$
x’ = x + \mathrm{Attention}(\mathrm{RMSNorm}(x))
$$

$$
y = x’ + \mathrm{SwiGLU}(\mathrm{RMSNorm}(x’))
$$

attention 里面可能包含 RoPE、GQA、KV cache、FlashAttention 等实现细节。

所以“基于 Transformer”这句话背后，其实已经包含很多工程化选择。

11. 读技术报告时可以看什么

看到一篇新模型技术报告，我会先扫这些点：

• 是 decoder-only、encoder-decoder，还是 mixture 架构
• 用什么 normalization：LayerNorm、RMSNorm，pre-norm 还是 post-norm
• FFN 用什么：普通 FFN、SwiGLU，还是 MoE FFN
• attention 用什么：MHA、MQA、GQA、MLA、sparse attention
• 位置编码用什么：RoPE、ALiBi、RoPE scaling、YaRN
• context length 是多少，怎么扩展出来的
• KV cache 成本有没有特殊优化

这些点比“参数量多大”更能说明模型到底做了什么。

参数量只是结果，结构选择才是模型训练和部署时真正要付出的成本。

12. 小结

现代 LLM 没有抛弃 Transformer，而是在 Transformer 的关键部件上做了系统性替换。

我的理解可以压缩成一句话：

Transformer 提供了大模型的基本计算图，现代 LLM 的创新很多是在稳定训练、提高吞吐、降低推理成本、扩展上下文这几个方向上补工程和结构细节。

所以读后面的 MoE、长上下文、reasoning model、多模态模型时，不要只看最外层的概念。很多真正影响模型能力和成本的东西，藏在 block 级别的设计里。

参考资料

• Vaswani et al., Attention Is All You Need
• Shazeer, GLU Variants Improve Transformer
• Su et al., RoFormer: Enhanced Transformer with Rotary Position Embedding
• Dao et al., FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness
• Ainslie et al., GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints
• Qwen Team, Qwen3 Technical Report
• DeepSeek-AI, DeepSeek-V3 Technical Report

可以先从一个问题出发：

如果 MLP 已经可以拟合复杂函数，为什么还需要 CNN、RNN 这些结构？

答案是：不同数据有不同结构。图像有局部空间结构，序列有时间顺序结构。专门的网络结构把这些先验写进模型里，让模型更高效地学习。

1. 归纳偏置（inductive bias）

Inductive bias 可以理解成模型对数据结构的默认假设。

MLP 的假设很弱。它把输入展开成向量后，每个输入维度和每个 hidden unit 都连接起来。

如果输入是一张图片，MLP 并不知道左上角像素和它旁边像素关系更近，也不知道同一个边缘模式可以出现在图片不同位置。

CNN 就把这些假设写进模型：

• 局部连接：相邻像素更相关
• 权重共享：同一个 pattern 可以出现在不同位置
• 平移等变：输入平移时，feature map 也对应平移

RNN 则把序列假设写进模型：

• 当前状态依赖过去状态
• 同一组参数可以反复处理不同时间步
• 顺序本身有意义

这些结构不只是为了减少参数，也是在告诉模型应该怎样看数据。

2. 卷积神经网络（CNN）为什么适合图像

图像有很强的局部结构。一个像素通常和周围像素关系更大，而不是和很远的像素关系同等重要。

CNN 使用 convolution kernel 在图像上滑动：

1
2
3

small kernel
-> slide over image
-> produce feature map

比如一个 $3 \times 3$ kernel 每次只看局部区域。它可以检测边缘、角点、纹理等局部 pattern。

如果某个 kernel 学会检测垂直边缘，那么它可以在整张图上重复使用。同一个边缘检测器不需要为每个位置单独学一套参数。

这就是 weight sharing。

3. 卷积（convolution）的几个概念

常见概念：

如果 stride 大，输出 feature map 会变小；如果 padding 合适，可以让输出保持原尺寸。

一个直觉例子：检测猫脸时，前面层可能检测边缘和纹理，中间层检测眼睛、耳朵、鼻子，后面层组合成更完整的猫脸结构。

CNN 的层级结构和图像视觉层级比较匹配。

4. 池化（pooling）：降低空间分辨率

Pooling 常用于降低 feature map 尺寸。

Max pooling 取局部窗口里的最大值：

1

2x2 window -> max value

它的作用包括：

• 降低计算量
• 增大感受野
• 提供一定平移不变性

比如一个边缘稍微移动几像素，max pooling 后的响应可能仍然相似。

不过现代 CNN 里不一定大量依赖 pooling，有些结构会用 stride convolution 来完成下采样。

5. ResNet：为什么残差连接（residual connection）重要

网络变深后，训练会变难。一个问题是：更深的网络理论上表达能力更强，但实际训练时可能反而效果变差。

ResNet 的核心是 residual connection：

$$
y = F(x) + x
$$

模型不直接学习完整映射 $H(x)$，而是学习 residual：

$$
F(x) = H(x) - x
$$

直觉上，如果某几层暂时不需要做复杂变换，模型可以让 $F(x)$ 接近 0，这样输出接近 $x$。这让深层网络更容易优化。

Residual connection 也让梯度可以更直接地传回前面层。这个思想后来不只用于 CNN，也广泛出现在 Transformer 里。

6. RNN：处理序列的基本思路

RNN 用 hidden state 记录过去信息。

最基本形式：

$$
h_t = \phi(W_xx_t + W_hh_{t-1} + b)
$$

$$
y_t = W_yh_t
$$

其中，$x_t$ 是当前时间步输入，$h_{t-1}$ 是上一个时间步的 hidden state。

比如句子：

1

I really like this movie

RNN 会按顺序读 token，每一步更新 hidden state。理论上，最后的 hidden state 可以包含前面读到的信息。

RNN 的优点是结构自然适合序列；缺点是长序列训练困难，难以捕捉很长距离的依赖。

7. RNN 的梯度问题

RNN 的反向传播要沿时间展开，也叫 backpropagation through time。

如果序列很长，gradient 会经过很多时间步反传。这和深层网络里的梯度消失/爆炸类似。

一个常见问题是 long-term dependency。

比如：

1

The book that I bought last week and left on the table is interesting.

如果要判断主语和谓语关系，模型需要记住很早之前的 “book”。普通 RNN 很容易在长距离依赖上表现差。

8. LSTM 和 GRU：用门控机制控制记忆

LSTM 的核心是 cell state 和 gate。

它通过门控机制控制：

• 忘掉哪些旧信息
• 写入哪些新信息
• 输出哪些状态

可以把 LSTM 想成比普通 RNN 多了一条更稳定的记忆通道。

GRU 是更简化的门控 RNN，参数更少，训练更轻一些。

常见对比：

LSTM / GRU 不是彻底解决长距离依赖，只是比普通 RNN 更稳定。

9. 为什么注意力机制（attention）后来替代很多 RNN

RNN 有一个天然问题：它按时间一步步处理序列，难以并行。

如果序列长度是 1000，RNN 需要从第 1 步一路算到第 1000 步。后一步依赖前一步 hidden state。

Attention 的思路不同。它允许当前位置直接看序列中其他位置，不一定要把信息压进一个 hidden state 里一步步传递。

这带来两个优势：

• 更容易建模长距离依赖
• 更容易并行训练

所以在 NLP 和大模型里，Transformer 逐渐成为主流。

10. 几个点

CNN 的关键不是“卷积公式”，而是局部连接和权重共享。它利用了图像的空间结构。

ResNet 的 residual connection 让深层网络更容易优化，这个思想后来影响很大。

RNN 适合序列，但长距离依赖和并行效率是它的核心瓶颈。

LSTM / GRU 通过门控机制缓解 RNN 的梯度和记忆问题，但没有完全摆脱序列计算瓶颈。

CNN、RNN、Transformer 的区别，本质上是它们对数据结构的不同假设。

参考资料

• Stanford CS231n: Convolutional Neural Networks
• Deep Residual Learning for Image Recognition
• Understanding LSTM Networks
• Dive into Deep Learning: Recurrent Neural Networks

可以先把训练过程看成一条链：

1
2
3
4
5
6

initialize parameters
-> forward pass
-> compute loss
-> backprop gradients
-> optimizer updates parameters
-> repeat

深度学习训练难，主要不是因为这个流程难写，而是因为每一步都可能影响梯度传播和收敛稳定性。

1. 梯度消失与梯度爆炸

深层网络里，gradient 要从 loss 一层层传回前面层。

如果每一层的梯度因子都小于 1，多层相乘后会越来越小，这就是 vanishing gradients。

如果每一层的梯度因子都大于 1，多层相乘后会越来越大，这就是 exploding gradients。

一个粗略例子：

$$
0.5^{20} \approx 9.5 \times 10^{-7}
$$

如果反向传播里连续乘很多个 0.5，前面层几乎收不到有效梯度。

反过来：

$$
1.5^{20} \approx 3325
$$

如果连续乘很多个大于 1 的因子，梯度可能爆炸，训练变得不稳定。

这也是为什么 deep network 不是简单“多堆几层”就行。层数变深后，梯度能不能稳定传过去本身就是问题。

2. 参数初始化（initialization）

初始化的目标不是找一个好模型，而是给训练一个合适起点。

如果权重太小，信号逐层传递后可能越来越弱；如果权重太大，activation 和 gradient 可能变得不稳定。

常见初始化包括 Xavier initialization 和 He initialization。

Xavier initialization 适合 tanh / sigmoid 这类 activation，核心想法是让每层输入输出的方差保持相对稳定。

He initialization 更适合 ReLU，因为 ReLU 会把一部分负值截断为 0。

直觉上，初始化是在控制每一层信号的尺度。尺度合适，forward 和 backward 都更容易稳定。

3. 归一化（normalization）

Normalization 的作用是让中间表示的分布更稳定。

Batch Normalization 通常对 batch 维度做归一化：

$$
\hat{x} = \frac{x-\mu_B}{\sqrt{\sigma_B^2+\epsilon}}
$$

其中，$\mu_B$ 和 $\sigma_B^2$ 是当前 batch 的均值和方差。

BatchNorm 在 CNN 里很常见。它能让训练更稳定，也允许使用更大的 learning rate。

Layer Normalization 则通常对单个样本内部的 hidden dimension 做归一化。Transformer 里更常用 LayerNorm，因为序列任务里 batch 统计不一定稳定，而且不同 token 长度和并行方式会让 BatchNorm 不方便。

可以这样粗略理解：

Normalization 不只是让数值好看，它会影响优化过程。

4. 随机失活（dropout）：训练时故意丢掉一部分连接

Dropout 是一种正则化方法。训练时随机把一部分 hidden units 置为 0：

1

h = dropout(h, p=0.5)

它的直觉是：不要让模型过度依赖某几个 neuron，而是让不同子网络都能工作。

测试时通常不再随机丢弃，而是使用完整网络，并对激活值做相应缩放。

Dropout 在早期深度网络里很常见。现在大模型里也会用 dropout，但很多大规模预训练模型会把 dropout 设得比较小，甚至某些设置下不用。

5. 学习率（learning rate）和 scheduler

Learning rate 控制每次参数更新的步长。

如果太小，训练慢；如果太大，loss 可能震荡甚至发散。

深度学习里常见 scheduler：

• warmup：训练初期逐渐增大学习率
• step decay：训练到某些 epoch 后降低学习率
• cosine decay：按余弦曲线逐渐降低学习率

Warmup 在 Transformer 训练里尤其常见。训练初期参数还很随机，如果一开始 learning rate 太大，更新可能过猛。Warmup 让模型先稳定进入训练状态。

6. SGD：最基础的随机梯度下降

Stochastic Gradient Descent 使用 mini-batch gradient 更新参数：

$$
\theta_{t+1} = \theta_t - \eta g_t
$$

其中，$\eta$ 是 learning rate，$g_t$ 是当前 mini-batch 上的 gradient。

SGD 的优点是简单、泛化表现常常不错。缺点是更新方向受当前 batch 影响，可能噪声较大，收敛也可能比较慢。

比如 loss surface 像一个狭长山谷，SGD 可能在山谷两侧来回震荡，同时沿着谷底方向前进很慢。

7. 动量法（momentum）：加入历史方向

Momentum 的想法是：不要只看当前 gradient，也看过去一段时间的更新方向。

常见形式：

$$
v_t = \beta v_{t-1} + g_t
$$

$$
\theta_{t+1} = \theta_t - \eta v_t
$$

其中，$v_t$ 是 velocity，$\beta$ 控制保留多少历史方向。

直觉上，如果多个 step 的 gradient 方向一致，Momentum 会加速；如果某个方向来回震荡，正负更新会互相抵消。

这很像推一个球下山。SGD 每一步都只看当前坡度，Momentum 让球带一点惯性。

8. RMSProp：给每个参数自适应学习率

RMSProp 关注的是每个参数最近 gradient 的平方平均。

$$
s_t = \rho s_{t-1} + (1-\rho)g_t^2
$$

$$
\theta_{t+1} = \theta_t - \frac{\eta}{\sqrt{s_t}+\epsilon}g_t
$$

如果某个参数的 gradient 一直很大，$s_t$ 会变大，于是它的有效学习率会变小。

如果某个参数的 gradient 一直很小，$s_t$ 小，有效学习率相对更大。

RMSProp 的直觉是：不同参数不一定应该用同一个步长。频繁大幅变化的方向要走得谨慎，变化小的方向可以走得相对积极。

9. Adam：动量法（momentum）+ RMSProp

Adam 可以看作把 Momentum 和 RMSProp 结合起来。

它维护一阶矩估计：

$$
m_t = \beta_1 m_{t-1} + (1-\beta_1)g_t
$$

也维护二阶矩估计：

$$
v_t = \beta_2 v_{t-1} + (1-\beta_2)g_t^2
$$

然后做 bias correction：

$$
\hat{m}_t = \frac{m_t}{1-\beta_1^t}
$$

$$
\hat{v}_t = \frac{v_t}{1-\beta_2^t}
$$

最后更新：

$$
\theta_{t+1} = \theta_t - \eta \frac{\hat{m}_t}{\sqrt{\hat{v}_t}+\epsilon}
$$

Adam 的直觉：

• $m_t$ 像 Momentum，记录梯度方向的滑动平均
• $v_t$ 像 RMSProp，记录梯度平方的滑动平均
• 分母让每个参数有自适应步长

Adam 的默认参数经常是：

1
2
3

beta1 = 0.9
beta2 = 0.999
epsilon = 1e-8

Adam 的优点是上手快、收敛稳定、对 learning rate 没有 SGD 那么敏感。这也是它在深度学习里非常常用的原因。

10. AdamW：把 weight decay 解耦出来

AdamW 是理解现代训练时很重要的优化器。

先看 Adam 里常见的 L2 regularization。如果把 L2 penalty 加到 loss 里：

$$
L’(\theta)=L(\theta)+\frac{\lambda}{2}|\theta|^2
$$

那么梯度会变成：

$$
g’_t = g_t + \lambda \theta_t
$$

在 SGD 里，这和 weight decay 基本等价：

$$
\theta_{t+1} = \theta_t - \eta(g_t + \lambda\theta_t)
$$

可以整理成：

$$
\theta_{t+1} = (1-\eta\lambda)\theta_t - \eta g_t
$$

也就是每步先把权重衰减一点，再按 gradient 更新。

但在 Adam 里，情况不一样。Adam 会用二阶矩 $\sqrt{\hat{v}_t}$ 对梯度做自适应缩放。如果把 $\lambda\theta_t$ 混进 gradient，它也会被 Adam 的自适应项缩放。

这样 weight decay 就不再是“统一把权重变小”，而是和每个参数的梯度历史纠缠在一起。

AdamW 的做法是把 weight decay 从 gradient update 里解耦出来：

$$
\theta_{t+1} = \theta_t - \eta \frac{\hat{m}_t}{\sqrt{\hat{v}_t}+\epsilon} - \eta\lambda\theta_t
$$

也可以理解成：

• Adam update: use gradient statistics to update parameters
• Weight decay: separately shrink weights

这就是 AdamW 的核心变化：weight decay 不再被 Adam 的自适应梯度缩放影响。

11. Adam 和 AdamW 的区别怎么记

可以用一句话记：

Adam 里的 L2 regularization 是把 weight decay 混进 gradient；AdamW 是把 weight decay 作为单独的参数衰减步骤。

在 Adam 里：

1
2

gradient = gradient + weight_decay * parameter
adaptive_update(gradient)

在 AdamW 里：

1
2

adaptive_update(gradient)
parameter = parameter - lr * weight_decay * parameter

这也是为什么训练 Transformer / LLM 时，AdamW 比 Adam 更常见。它让 weight decay 的作用更接近正则化直觉。

12. 优化器对比

实际训练里，优化器不是越复杂越好。SGD 在一些视觉任务里仍然很强，AdamW 在 Transformer 训练里非常常见。

13. 几个点

深度网络训练的难点不是只会不会写 loss.backward()，而是梯度是否稳定、参数尺度是否合理、优化器是否适合任务。

Initialization 和 normalization 都在服务同一个目标：让信号和梯度在网络中稳定传播。

SGD 只看当前 gradient，Momentum 加入历史方向，RMSProp 加入梯度平方的滑动平均，Adam 同时使用一阶和二阶矩估计。

AdamW 的关键不是“比 Adam 多一个 W”，而是 decoupled weight decay。这个区别在现代大模型训练里很重要。

Learning rate 仍然是最重要的超参数之一。用了 AdamW 也不代表不需要认真调学习率。

参考资料

• Adam: A Method for Stochastic Optimization
• Decoupled Weight Decay Regularization
• Dive into Deep Learning: Optimization Algorithms
• CS231n: Neural Networks Part 3