第 6 章：模型训练与前沿架构

从 LLaMA 2 到 Kimi K2.5，从"人类偏好对齐"到"自主工具使用"，LLM 的训练方法论经历了一次范式跃迁。本章沿着这条主线展开：先拆解 LLaMA 2 开创性的对齐训练哲学，再分析 Qwen3 的蒸馏范式如何让小模型继承大模型能力，然后进入 DeepSeek-R1 的推理模型训练框架，接着深入 Kimi 系列的 Agentic 架构设计，最后探讨 Engram 在表示学习上的全新思路。

---

6.1 LLaMA 2 训练流程解析

LLaMA 2 给出了一条简洁却影响深远的数据准则，奠定了后续几乎所有对齐工作的方法论基础。

6.1.1 核心训练哲学：SFT 在精不在多，RM 在多不在精

LLaMA 2 论文中明确指出了两个训练阶段对数据的截然不同的需求：

SFT（监督微调）重质量。SFT 的本质是向模型展示"理想回复长什么样"——指令格式、语言风格、推理步骤的组织方式。这些"模式"只需少量精心设计的高质量示例（几千到几万条）就能被模型内化。数量堆砌反而引入噪声，稀释高质量信号。

RM（奖励模型）重数量。RM 是一个判别器：给定两个回复，判断哪个更好。这种排序能力依赖于覆盖广泛场景和边界情况的大量对比数据。单条数据的质量可以放宽要求，但场景覆盖的广度决定了 RM 的泛化上限。

直觉理解：SFT 像是教一个画家"什么是好画"——给他看几幅大师作品就够了；RM 像是训练一个美术评审——他需要看过成千上万幅不同水平的作品，才能准确判断优劣。

6.1.2 四阶段训练管线

LLaMA 2-Chat 的完整训练流程：

预训练（大规模无标注文本语料，Next Token Prediction）
    |
    v
SFT（精选高质量人工对话，数量 ~万级）
    |
    v
奖励模型训练（大量人工偏好标注，二元比较格式）
    |
    v
RLHF（PPO 算法 + KL 散度约束 + Safety 迭代）

几个关键设计选择：

• 偏好数据采用二元比较（Binary Comparison）而非绝对打分。标注者只需回答"A 和 B 哪个更好"，而不是给出 1-5 分的评级。这大幅降低了标注者间的主观差异。
• 奖励模型训练规模远大于 SFT。Meta 收集了超过 100 万条偏好对比数据用于训练 RM，而 SFT 数据只用了约 27,540 条。
• PPO 训练加入 KL 散度惩罚，防止策略与参考模型差距过大。

6.1.3 PPO 目标函数

RLHF 阶段的核心优化目标：

$${\mathcal{L}}_{\text{PPO}}={\mathbb{E}}_{x\sim \mathcal{D},y\sim {\pi }_{\theta }}[r_{\varphi }(x,y)-\beta \cdot \text{KL}({\pi }_{\theta }(y|x)\mid {\pi }_{\text{ref}}(y|x))]$$

其中：

符号	含义
$r_{\varphi }(x,y)$	奖励模型对回复 $y$ 的打分
${\pi }_{\theta }$	当前策略（正在训练的模型）
${\pi }_{\text{ref}}$	参考策略（SFT 后的模型快照，训练期间冻结）
$\beta$	KL 惩罚系数，控制策略漂移幅度

$\beta$ 的作用：如果没有 KL 项，模型会"过度讨好"奖励模型——学会一些能刷高分但实际质量低下的 trick（reward hacking）。KL 约束确保优化后的模型不会偏离 SFT 模型太远，保留基础语言能力。

6.1.4 LLaMA 2 的方法论遗产

LLaMA 2 的训练哲学被后续工作广泛继承：

• SFT 数据越精越好：Anthropic 的 Claude、OpenAI 的 InstructGPT 系列都验证了这一点——几千条精标数据可以打败数万条低质量数据。
• RLHF 三阶段管线（SFT -> RM -> PPO）成为行业标准范式，直到 DPO 等直接偏好优化方法提出后才出现替代路径。
• 二元比较格式成为偏好数据标注的事实标准。

---

6.2 Qwen3 训练流程解析

Qwen3 系列展示了如何通过蒸馏让小模型继承大模型的推理能力，核心在于 off-policy 与 on-policy 蒸馏的取舍。

6.2.1 Strong-to-Weak 蒸馏范式

Qwen3 后训练采用了 strong-to-weak distillation（强到弱蒸馏）——用大参数量的教师模型（如 Qwen3-235B）指导小参数量的学生模型（如 Qwen3-7B）学习推理能力。这与经典知识蒸馏方向一致，但在 LLM 语境下发展出了两种截然不同的实现路径。

6.2.2 Off-Policy 蒸馏

核心思路：教师模型的输出作为固定的静态数据集，学生在其上做监督学习。

# Off-policy 蒸馏伪代码
teacher_data = teacher_model.generate(prompts)  # 一次性离线生成
student_model.finetune(teacher_data)              # 学生在静态数据上学习

特点：

• 教师推理成本只发生一次，数据可以反复使用
• 训练过程稳定、可控
• 核心缺陷：分布偏移（Distribution Shift）——教师生成的数据分布与学生推理时的实际分布不同。学生在训练时看到的都是教师的"正确路径"，但自己推理时一旦偏离这条路径，就没有被纠正过，容易"雪崩"

适用场景：初始阶段的大规模能力注入，尤其是 CoT（Chain-of-Thought）推理链数据的构造。教师模型生成大量高质量的思维链样本，学生通过模仿学习内化推理模式。

6.2.3 On-Policy 蒸馏

核心思路：学生在自己当前策略的输出分布上采样，教师对这些输出进行评判或提供对比信号。

$${\mathcal{L}}_{\text{on-policy}}={\mathbb{E}}_{y\sim {\pi }_{\text{student}}}[\ell (y,{\pi }_{\text{teacher}})]$$

关键区别在于采样来源：$y$ 是从 ${\pi }_{\text{student}}$ 中采样的，而不是从 ${\pi }_{\text{teacher}}$ 中。这意味着学生会在"自己容易犯错的地方"得到教师的纠正。

特点：

• 直接消除分布偏移——学生在自己的错误分布上被纠正
• 需要实时调用教师模型对学生输出进行打分或排序，计算开销显著增大
• 训练动态更复杂：随着学生变强，它的输出分布也在变化，教师需要持续提供有效信号

适用场景：精细化打磨阶段，在 off-policy 蒸馏的基础上进一步提升学生在自身弱项上的表现。

6.2.4 两种蒸馏的对比

维度	Off-Policy 蒸馏	On-Policy 蒸馏
数据来源	教师生成（离线）	学生生成（在线）
分布偏移	存在	不存在
计算成本	低（教师只推理一次）	高（教师需持续在线）
训练稳定性	高	较低
典型应用	初始能力注入	精细化打磨

直觉理解：Off-policy 像是学生看老师录播课，效率高但无法针对自己的困惑提问；On-policy 像是一对一辅导，老师能看到学生的作业错误并针对性纠正，但成本高得多。

6.2.5 实践意义

对于 Qwen3 这样的系列模型，小参数版本（1.7B、7B）能以较低成本达到接近大模型的推理性能，关键在于蒸馏数据的构造质量。用 Qwen3-235B 生成的高质量 CoT 链条训练小模型，相当于将数千 GPU 小时的大模型推理能力"压缩"进了小模型的参数中。这使得部署成本降低一到两个数量级，同时保留了大部分推理能力。

---

6.3 DeepSeek-R1：推理模型的诞生

DeepSeek-R1 展示了如何通过精细的工程设计，让强化学习在推理型 LLM 上真正跑通。

6.3.1 核心工程挑战：序列长度不均匀

推理型 LLM 生成的思维链长度差异极大：简单问题可能只需 50 个 token，复杂数学题可能需要 8000+ token。在分布式训练中，如果将所有序列 padding 到 batch 内的最大长度，GPU 计算中大部分都花在了 padding 的无效位置上。

6.3.2 三步数据打包策略（Pack Data）

DeepSeek-R1 设计了一套精细的数据打包策略来解决这个问题：

第一步：全局排序与分配

将全局 batch 内的所有数据按序列长度排序，然后按长度分布将它们分配到数据并行组的各个进程中。长序列集中在一起，短序列集中在一起，避免极端长度差异出现在同一进程内。

第二步：Best-Fit 装箱

在每个进程内部，用 Best-Fit 策略将多条序列"打包"进固定长度的 chunk 中。这本质上是一个经典的 装箱问题（Bin Packing）：

固定 chunk 长度 = 4096 tokens

进程 0 的序列: [1200, 800, 600, 2000, 1500, ...]

Best-Fit 装箱结果:
  chunk_0: [2000, 1500, 596_padding]  → 利用率 85.5%
  chunk_1: [1200, 800, 600, 1396_padding] → 利用率 63.5%
  ...

相比全部 padding 到最大长度（利用率可能低于 10%），装箱后的利用率大幅提升。

第三步：进程间均衡

调整各进程的 chunk 数量使其相等。在数据并行（DP）训练中，所有进程在每个 step 必须同步。如果某个进程的 chunk 数量更多，其他进程就会空等。均衡 chunk 数量消除了这种同步浪费。

6.3.3 GRPO：无 Critic 的强化学习

DeepSeek-R1 使用 GRPO（Group Relative Policy Optimization） 作为核心 RL 算法，其最大创新在于不需要独立的 Critic/Value 网络：

$$L_{RL}(\theta )={\mathbb{E}}_{x\sim \mathcal{D}}[\frac{1}{N}\sum _{j=1}^K\sum _{i=1}^{|y_j|}\text{Clip}(\frac{{\pi }_{\theta }(y_i^j\mid x,y_{0:i}^j)}{{\pi }_{\text{old}}(y_i^j\mid x,y_{0:i}^j)},\alpha ,\beta )\cdot (r(x,y^j)-\overline{r}(x))]$$

逐项拆解：

组件	作用
$\frac{{\pi }_{\theta }}{{\pi }_{\text{old}}}$	新旧策略的概率比（Importance Sampling Ratio）
$\text{Clip}(\cdot ,\alpha ,\beta )$	将比率截断在 $[\alpha ,\beta ]$ 内，防止单步更新过大
$r(x,y^j)-\overline{r}(x)$	组内相对优势：某个回复的奖励减去该组所有回复的平均奖励

为什么不需要 Critic？ 传统 PPO 需要一个 Critic 网络来估计 $V(s)$（状态价值函数），从而计算优势 $A_t=r_t+\gamma V(s_{t+1})-V(s_t)$。对于 LLM 来说，这个 Critic 本身就是一个与策略模型同等规模的网络，显存开销翻倍。GRPO 的做法是：对同一个 prompt $x$ 采样 $K$ 个回复，用组内平均奖励 $\overline{r}(x)$ 作为 baseline 替代 $V(s)$。只要 $K$ 足够大，这个 baseline 就是无偏的。

直觉理解：不告诉模型"这道题应该得多少分"（Value function），而是让它做 $K$ 次同一道题，然后告诉它"你这次做得比平均水平好/差多少"（Group Relative Advantage）。省去了"出题评分标准"的训练成本。

---

6.4 Kimi K2 / K2.5 架构分析

从 K1.5 的 "Scaling Reinforcement Learning with LLMs"，到 K2 的 "Open Agentic Intelligence"，再到 K2.5 的 "Visual Agentic Intelligence"，Kimi 系列在每一代都推进了 LLM 的能力边界。

6.4.1 K2 与 K2.5 的 MoE 架构参数

两代模型共享同一套 MoE 骨架：

参数项	Kimi K2	Kimi K2.5
架构	Mixture-of-Experts (MoE)	Mixture-of-Experts (MoE)
总参数量	1T	1T
激活参数量	32B	32B
层数	61（含 1 Dense 层）	61（含 1 Dense 层）
Attention 隐层维度	7168	7168
MoE 隐层维度	2048（per Expert）	2048（per Expert）
注意力头数	64	64
专家总数	384	384
每 Token 激活专家数	8	8
共享专家数	1	1
词表大小	160K	160K
上下文长度	256K	256K
注意力机制	MLA	MLA
激活函数	SwiGLU	SwiGLU
视觉编码器	无	MoonViT（400M 参数）

K2.5 在 K2 的基础上增加了 MoonViT 视觉编码器，其他架构参数完全一致。

6.4.2 Kimi K2 Thinking：交错推理

从单次长推理到多步交错

大多数推理模型采用 <cot, ans> 模式——先在一段长推理中想完所有步骤，再给出答案。这有一个致命缺陷：前面一步错了，后面全错，且无法在中途借助外部工具纠正。

Kimi K2 Thinking 引入了 Interleaved Reasoning（交错推理）：<think, ans> * n，即"想一点 -> 用工具 -> 看结果 -> 再想 -> 再用工具"的循环：

plan -> act -> verify -> reflect -> refine
  |         |           |            |
  v         v           v            v
 思考     工具调用    检查结果    修正方向     ...重复

每个 step（一次 <think, act> 循环）都可以：

• 独立定义和计算 reward
• 维护有状态的推理记忆（支持 plan 和 refine）
• 根据工具返回结果动态调整后续策略

K2 Thinking 在测试中展示了通过 23 步交错推理与工具调用解决 PhD 级数学题的能力，支持 200-300 次连续工具调用而不丧失推理连贯性。

与 ReAct 的区别：ReAct 是外部编排框架驱动的"推理-行动"交替；K2 Thinking 是模型内生的交错能力——模型在端到端训练中学会了"什么时候该继续推理、什么时候该调用工具、工具失败时要不要换方法"。

Chat Template：K2-Instruct vs K2-Thinking

两个模型版本的 chat template 有本质区别：

K2-Instruct（不暴露推理过程）：

<|im_assistant|>assistant<|im_middle|>
可见回答内容
<|tool_calls_section_begin|>...<|tool_calls_section_end|>
<|im_end|>

没有 <think> 标签——所有推理都在模型内部完成，模板只负责拼对话历史和工具调用。

K2-Thinking（推理过程可见）：

<|im_assistant|>assistant<|im_middle|>
<think>reasoning_content...</think>
可见回答内容
<|tool_calls_section_begin|>...<|tool_calls_section_end|>
<|im_end|>

K2-Thinking 的 template 还有一个精巧设计——区分 history 和 suffix：

• History（已完成的历史轮次）：<think></think> 为空，不保留历史推理内容
• Suffix（当前 turn 的最新推理链）：<think>最新 reasoning_content...</think> + 可见内容

划分逻辑是找"最后一条没有 tool_calls 的 assistant 消息"来切分。这样做的原因是：只有当前轮次的推理过程对模型有续写参考价值，历史推理已经"结晶"为最终回答，无需重复传入。

# 多轮交错推理的消息序列结构
messages = [
    {"role": "system", "content": "..."},
    {"role": "user", "content": "用户问题"},
    # Step 1: 思考 + 调用工具 A
    {"role": "assistant", "content": "", "reasoning_content": "先调 A...",
     "tool_calls": [{"id": "call_A", "function": {"name": "tool_A", "arguments": "..."}}]},
    {"role": "tool", "tool_call_id": "call_A", "content": "{A 的结果}"},
    # Step 2: 基于 A 的结果，思考 + 调用工具 B
    {"role": "assistant", "content": "", "reasoning_content": "基于 A 的结果，调 B...",
     "tool_calls": [{"id": "call_B", "function": {"name": "tool_B", "arguments": "..."}}]},
    {"role": "tool", "tool_call_id": "call_B", "content": "{B 的结果}"},
]

每一轮新的工具调用必须由一条新的 assistant 消息发起——这保证了推理和行动的边界清晰。

数据合成与训练

K2 Thinking 的训练数据通过合成大量多轮 tool-use 轨迹来构造：

想一点 -> call tool A -> 看结果 -> 想一点 -> call tool B -> ... -> 完成任务

模型在这些轨迹中学习的不是单轮回答，而是三种决策：

1. 什么时候继续写 reasoning token？
2. 什么时候切换成 function call？
3. tool 失败时要不要反思、改参数、换工具？

QAT：推理模型的量化挑战

推理模型因为生成大量 token，量化误差会累积得很严重。K2 Thinking 在后训练阶段引入 QAT（Quantization-Aware Training），对 MoE 组件做 INT4 权重量化感知训练。效果：

• 约 2x 生成速度提升
• 性能基本无损（所有 benchmark 均在 INT4 精度下报告）

6.4.3 Kimi K2.5：视觉 Agentic 智能

K2.5 在 K2 的基础上引入了三大核心升级：MoonViT-3D 视觉编码器、Zero-Vision SFT 和 Joint Multimodal RL。

MoonViT-3D 视觉编码器

传统的后期融合（Late-fusion）策略让视觉和文本能力此消彼长。K2.5 从预训练阶段就开始文本-视觉联合优化，核心组件是 MoonViT-3D。

前向传播完整流程：

Step 1：输入

输入张量 $X_{\text{raw}}\in {\mathbb{R}}^{T\times H_{\text{in}}\times W_{\text{in}}\times 3}$，其中图像视为 $T=1$ 的视频，视频以 $T=4$ 帧为一组处理。图像和视频共享同一套权重。

Step 2：NaViT Resize & Padding

保持原始纵横比，仅调整尺寸使 $H,W$ 能被 Patch Size $P=14$ 整除。右侧和下侧填充 0 至精确匹配网格。NaViT 策略支持不同分辨率的图像在同一个序列中打包，通过 Block Diagonal Attention Mask 实现样本间隔离：

$$\text{Packed Attention Mask}=\left[\begin{array}{ccccc}\mathbf{1}& \mathbf{0}& \mathbf{0}& 0& 0\\ \mathbf{1}& \mathbf{1}& \mathbf{0}& 0& 0\\ \mathbf{1}& \mathbf{1}& \mathbf{1}& 0& 0\\ 0& 0& 0& \mathbf{1}& \mathbf{0}\\ 0& 0& 0& \mathbf{1}& \mathbf{1}\end{array}\right]$$

图片 A 的 patch 只能看到图片 A 的 patch，图片 B 只能看到图片 B。

Step 3：Patchify

使用 Conv2d(in_channels=3, out_channels=1152, kernel_size=14, stride=14) 切分：

$$(B,3,H,W)\stackrel{\text{Conv2d}}{\to }(B,1152,\frac{H}{14},\frac{W}{14})\stackrel{\text{reshape}}{\to }(B,L,1152)$$

其中 $L=T\times \frac{H}{14}\times \frac{W}{14}$。卷积核大小和步长都等于 Patch Size，在图像上无重叠滑动，每个 patch 被线性投影为 1152 维向量。

Step 4：3D 位置编码

$$\text{Pos}(t,h,w)={\text{Pos}}_{\text{space}}(h,w)+{\text{Pos}}_{\text{time}}(t)$$

空间部分基于可学习 2D Embedding（分辨率变化时通过插值调整），时间部分仅在 $T>1$（视频）时叠加。Transformer 本质上是置换不变的，位置编码是让模型感知空间和时间结构的关键。

Step 5：Transformer Blocks + 2D RoPE

根据 $\text{grid\_thws}$ 计算 $(h,w)$ 坐标的频率，应用 2D RoPE。即使在 Patch Packing（多分辨率图像拼在同一 batch）的情况下，模型仍能感知每个 Patch 的绝对 2D 空间位置。

Step 6：Temporal Pooling（时序压缩）

在 Encoder 输出后执行 4x 时间压缩：

$$Z_{\text{view}}\in {\mathbb{R}}^{T\times h\times w\times D}\stackrel{\text{Mean over }T}{\to }{Z}_{\text{pooled}}\in {\mathbb{R}}^{1\times h\times w\times D}$$

即在同一空间位置 $(x,y)$ 上对 $T$ 帧取平均：

$${\text{Token}}_{(x,y)}^{\text{new}}=\frac{1}{T}\sum _{t=1}^T{\text{Token}}_{(x,y)}^{{\text{frame}}_t}$$

4 帧视频被压缩为 1 帧的特征表示，极大降低了 LLM 的 Context 占用。

Step 7：Spatial Merge + MLP 投影

将 $2\times 2$ 相邻 Patch 特征拼接：

$$Z_{\text{spatial}}\in {\mathbb{R}}^{\frac{h}{2}\times \frac{w}{2}\times (4\cdot D)}\stackrel{\text{MLP}}{\to }{Z}_{\text{llm}}\in {\mathbb{R}}^{\frac{h}{2}\times \frac{w}{2}\times 7168}$$

最终输出维度映射到 LLM 的 Hidden Size（7168）。

Zero-Vision SFT：代码即视觉

K2.5 提出了一个反直觉的方法——不使用任何视觉数据做 SFT，只用纯文本数据就能激活视觉能力。

核心观察：高质量文本 SFT 数据量大且多样，视觉 SFT 数据稀少且质量参差不齐。

做法：将所有图像操作代理为 IPython 代码操作：

# Zero-Vision SFT 训练样本示例
# Task: 计算图像中的物体数量（连通域计数）
import cv2
import numpy as np

gray = img.mean(axis=2).astype(np.uint8)
_, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
num_labels, _ = cv2.connectedComponents(binary)
print(f"物体数量: {num_labels - 1}")

训练数据的构造：

• 不真正加载图片，而是给出文字描述："假设 img 是一个 1024x1024 的 numpy 数组"
• 包含多种任务类型：计数（connectedComponents）、定位（img.shape）、裁剪（img[:100, :100]）、像素级分析（二值化 + BFS）
• 本质上是训练模型将"视觉意图"翻译成"API 调用"的能力

为什么有效？ 因为模型在预训练阶段已经将视觉 Token 和文本 Token 映射到了同一个 Embedding 空间（Joint Optimization）。当模型学会了文本中"先思考、再写代码、再解决问题"的模式后，这种模式自动迁移到视觉任务上。

一个反直觉的发现：引入包含人工设计视觉推理轨迹的 Text-Vision SFT 数据，模型表现反而不如只用纯文本 SFT。可能原因是现有视觉 SFT 数据多样性不足，限制了泛化能力。

Joint Multimodal RL

K2.5 的 RL 目标函数在 GRPO 基础上加入了特殊的正则项：

$$L_{RL}(\theta )={\mathbb{E}}_{x\sim \mathcal{D}}[\frac{1}{N}\sum _{j=1}^K\sum _{i=1}^{|y_j|}\text{Clip}(\frac{{\pi }_{\theta }(y_i^j\mid x,y_{0:i}^j)}{{\pi }_{\text{old}}(y_i^j\mid x,y_{0:i}^j)},\alpha ,\beta )(r(x,y^j)-\overline{r}(x))-\tau {(\log \frac{{\pi }_{\theta }(y_i^j\mid x,y_{0:i}^j)}{{\pi }_{\text{old}}(y_i^j\mid x,y_{0:i}^j)})}^2]$$

与标准 GRPO 相比，多了最后一项 $\tau (\log \frac{{\pi }_{\theta }}{{\pi }_{\text{old}}}{)}^2$，即 $k_2$ estimator 正则项（squared log-ratio）。这个正则的特殊之处：当新旧策略的概率比率超出截断范围 $[\alpha ,\beta ]$ 时，该 Token 的梯度被直接置零——无论优势函数的符号如何。这防止了策略在单次更新中发生过大的漂移。

奖励模型设计：除了 Rule-based Reward，K2.5 还引入了 GRM（Generative Reward Models），即让模型自己当"裁判"。K2 Actor 和 K2 Critic 本质上是同一个模型（Kimi K2），Critic 对多个候选回复进行成对比较和排序。

跨模态知识迁移：实验表明，视觉 RL 训练反向提升了纯文本任务的性能（如 MMLU-Pro 和 GPQA），验证了联合优化策略下模态间的知识迁移。

Token-Efficient RL：Toggle 算法

推理模型有一个天然倾向：不断延长思维链来换取更高准确率。但推理效率同样重要。K2.5 提出 Toggle 算法，在两个阶段之间周期性切换：

$$\tilde{r}(x,y)=\{\begin{array}{ll}r(x,y)\cdot \mathbb{I}\{|y|<\text{budget}(x)\}& \text{if }\lfloor t/m\rfloor mod2=0(\text{Phase 0: Budget})\\ r(x,y)& \text{if }\lfloor t/m\rfloor mod2=1(\text{Phase 1: Scale})\end{array}$$

参数	含义
$m$	切换周期（如每 100 步切换一次）
Phase 0（Budget）	只有在 token 预算内完成的正确回答才获得奖励
Phase 1（Scale）	正常奖励，鼓励探索更长思维链
$\text{budget}(x)$	动态预算，取所有正确回复中第 $\rho$ 分位的长度

Budget 的计算方式：

$$\text{budget}(x)=\text{Percentile}(\{|y_j|\mid r(x,y_j)=1,j=1\dots K\},\rho )$$

即从所有做对了的回复中，取第 $\rho$ 分位（如 75% 或 90%）的长度作为预算上限。模型必须学会"用更少的 token 做对同一道题"。

直觉理解：Phase 0 说"做对了也不给奖励，除非你足够精简"，Phase 1 说"做对就给奖励，想多长都行"。交替训练让模型同时学会两件事——能思考得深（Scale），也能思考得精炼（Budget）。这防止了 test-time scaling 时 token 数量无限膨胀。

6.4.4 Agent Swarm：并行多智能体协作

K2.5 引入了 Agent Swarm——Orchestrator（编排器）动态分解复杂任务并派发给异构 sub-agents 并行执行。

PARL 训练框架

训练采用 PARL（Parallel Agent Reinforcement Learning），关键设计：

• 只训练 Orchestrator，sub-agents 在训练期间冻结。Sub-agents 的角色类似于"环境工具"——被调用并返回结果。
• "先用小模型做子代理训练编排器，再迁移到大模型"——训练阶段 sub-agent 可以是轻量级模型，以加快 rollout。

奖励函数：

$$R_t={\lambda }_{\text{aux}}(e)\cdot \underset{\text{并行实例化奖励}}{\underbrace{r_{\text{parallel}}}}+(1-{\lambda }_{\text{aux}}(e))\cdot \underset{\text{任务级结果奖励}}{\underbrace{(\mathbb{I}[\text{success}]\cdot Q(\tau ))}}$$

其中 ${\lambda }_{\text{aux}}(e)$ 初始为 0.1，随训练进程退火至 0。训练策略是渐进式的：先学会分解和并行化，再优化最终任务成功率。这种渐进训练防止了 serial collapse——模型退化为只会串行执行。

Critical Steps：延迟导向的效率度量

$$\text{CriticalSteps}=\sum _{t=1}^T(S_{\text{main}}^{(t)}+\underset{i}{max}{S}_{\text{sub},i}^{(t)})$$

$S_{\text{main}}^{(t)}$ 是 Orchestrator 在第 $t$ 轮的协调开销，$\underset{i}{max}{S}_{\text{sub},i}^{(t)}$ 是该轮最慢的子智能体步数。总耗时取决于关键路径——不是所有 sub-agent 步数之和，而是协调开销加最慢子智能体。

场景对比：

重型任务（70 步工作量）：

• 串行：1（协调）+ 70（执行）= 71 Critical Steps
• 并行 4 路：4（协调）+ max(40, 10, 10, 10) = 44 Critical Steps
• 结论：并行有效，RL 正向奖励

轻型任务（4 步工作量）：

• 串行：1（协调）+ 4（执行）= 5 Critical Steps
• 并行 4 路：4（协调）+ max(1, 1, 1, 1) = 5 Critical Steps
• 结论：并行无收益，RL 抑制无效并行

$Q(\tau )$ 的设计直接与 Critical Steps 挂钩：

$$Q(\tau )\propto \frac{1}{\text{CriticalSteps}(\tau )}$$

模型被训练去判断"什么时候该并行、什么时候该串行"，而不是盲目追求并行度。

6.4.5 训练基础设施

K2.5 的分布式训练基础设施有几个值得注意的设计：

Unified Agentic RL Env：采用类 Gym 接口的异步协程架构，Rollout Manager 可同时编排 100,000 个并发 Agent 任务。

Token-in-Token-out 与 Mismatch Correction：在多轮 Agent 交互中，tool 返回的 token 不是模型生成的——它们来自外部环境。当计算 $\exp (\log \frac{{\pi }_{\theta }}{{\pi }_{\text{ref}}})$ 时，这些外部 token 会导致 ${\pi }_{\text{ref}}(a_t^{\prime })$ 异常低，破坏 Off-policy 数据一致性。Infra 层通过记录推理时的 Log Probabilities 来进行 mismatch correction。

白盒/黑盒环境分离：白盒环境（自有工具）可以获取底层 log probabilities；黑盒环境（第三方 API）通过 LLM Gateway 代理，将标准请求/响应转换为符合内部 RL 协议的日志格式。

---

6.5 Engram：表示学习新思路

Engram 提出了一个根本性的问题：LLM 的每一层都在"重新计算"那些本可以"直接查表"得到的知识，这值得吗？

6.5.1 核心动机：计算 vs 检索

现有 LLM（包括 MoE 架构）的 FFN 层本质上是在用计算来模拟检索。以预测 "Alexander the Great" 为例：模型需要消耗多层 Attention 和 FFN 逐步构建这个实体的表示。但 "Alexander the Great" 是一个固定知识——它不依赖于上下文，无论出现在什么语境下，其基本表示都是相同的。

Engram 的核心洞察：将模型的工作分为两类：

1. 静态知识检索——不依赖上下文的固定事实（实体、常识），应该通过确定性查表获取
2. 动态上下文推理——依赖上下文的逻辑推理、语义理解，是 Attention 应该专注的工作

通过外挂记忆检索来承担第一类工作，Attention 层被从"静态模式重建"中解放出来，可以全力投入复杂推理。

6.5.2 归一化 N-gram 作为检索键

Engram 的检索基于归一化的 n-gram 键。首先对词表做归一化映射：

$$x^{\prime }=\mathcal{P}(x),x\in V,x^{\prime }\in V^{\prime }$$

其中 $\mathcal{P}$ 是归一化操作（如大小写统一、标点去除等），将原始 128K 词表压缩约 23%。这意味着 "Apple"、"apple"、"APPLE" 共享同一个归一化 key——因为它们指向同一个实体知识。

对于位置 $t$ 的上下文，n-gram 特征定义为：

$$X^{\prime }=\{x_1^{\prime },\dots ,x_T^{\prime }\},g_{t,n}=(x_{t-n+1}^{\prime },\dots ,x_t^{\prime })$$

即以当前 token 为结尾的 $n$ 个 token 序列。这个 n-gram 作为确定性 key，在预计算的记忆库中执行精确匹配，获取对应的 Memory Embedding。

直觉理解：当模型看到 "...was conquered by Alexander" 时，n-gram "by Alexander" 就是一个确定性 key，可以直接从记忆库中检索出 "Alexander the Great" 相关的实体表示，无需消耗多层计算来"重新发现"这个实体是谁。

6.5.3 基础设施感知的效率设计

Engram 的检索是确定性的——给定 n-gram，对应的 Memory Embedding 是固定的。这个特性带来了一个重要的系统优化机会：

• 当 GPU 正在计算当前 Transformer 层的 Attention 和 FFN 时
• CPU 可以**异步 Prefetch（预取）**下一层需要的 Memory Embedding
• 实现计算（GPU）与 IO（CPU 查表）的流水线并行

这种 computation-IO overlap 进一步降低了端到端推理延迟，因为 Memory Embedding 的获取完全隐藏在 GPU 计算时间内。

---

本章小结

模型/方法	核心贡献	关键词
LLaMA 2	SFT 重质量、RM 重数量的数据哲学；RLHF 标准管线	偏好对齐、KL 惩罚、二元比较
Qwen3	Strong-to-weak 蒸馏；off/on-policy 蒸馏的互补	知识蒸馏、分布偏移、CoT 压缩
DeepSeek-R1	GRPO 无 Critic RL；Best-Fit 数据打包	组内相对优势、装箱问题、负载均衡
Kimi K2	Interleaved Thinking；QAT 量化感知训练	交错推理、内生工具调用、数据合成
Kimi K2.5	MoonViT-3D；Zero-Vision SFT；Toggle RL；Agent Swarm	联合预训练、代码即视觉、PARL
Engram	N-gram 键检索替代 FFN 知识存储	知识-推理解耦、异步 Prefetch

本章揭示了现代 LLM 训练与架构设计的三条主线：

1. 数据质量 vs 数量的辩证：SFT 重精（LLaMA 2）、RM 重广（LLaMA 2）、蒸馏数据重源头质量（Qwen3）。不同阶段的数据需求截然不同，没有万能配方。

2. 推理能力的多维度解耦：从单次长推理到多步交错推理（K2 Thinking），从隐式 FFN 知识存储到显式记忆检索（Engram），从手工编排到模型自主决定并行策略（Agent Swarm）。

3. 多模态的原生融合：不是"训完语言模型再接视觉编码器"（late-fusion），而是从预训练起就让视觉与语言共享表示空间（K2.5 Joint Optimization），甚至不需要视觉数据就能激活视觉能力（Zero-Vision SFT）。

---

延伸阅读

• LLaMA 2: Touvron et al., LLaMA 2: Open Foundation and Fine-Tuned Chat Models, Meta AI, 2023. arXiv:2307.09288
• DeepSeek-R1: DeepSeek AI, DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning, 2025. arXiv:2501.12948
• Kimi K2: Moonshot AI, Kimi K2: Open Agentic Intelligence, 2025. 技术报告
• Kimi K2.5: Moonshot AI, Kimi K2.5: Visual Agentic Intelligence, 2025. 技术报告
• GRPO: DeepSeekMath 论文中提出的 Group Relative Policy Optimization 算法
• NaViT: Dehghani et al., Patch n' Pack: NaViT, a Vision Transformer for any Aspect Ratio and Resolution, Google, 2024
• veRL: 分布式强化学习训练框架，支持 GRPO 等算法的多轮 Agent 训练