Reasoning on Jiang Yi(姜祎)'s Homepage

Notes on Kimi-k2.5

Thu, 12 Feb 2026 11:13:13 +0800

Introduction

Kimi-K2.5 的核心有亮点：

native multi-modal: 通过在预训练，SFT, RL 阶段使用多模态数据来提高模型的多模态能力
agent: 通过并行 multi-agent 的方式来提高模型解决复杂问题的效率和能力

Method

Architecture

Kimi K2.5 是一个标准的 ViT-MLP-LLM 架构，其中

ViT, 基于 Kimi-VL 提出的 MoonViT, 并进行了改进, 参数量为 400M
MLP, 基于 patch merger,
LLM, 基于 Kimi-k2, 参数量为 1.02T-A32B

ViT 作者使用了 Kimi-VL 提出的 MoonViT, MoonViT 基于 SigLIP 提出的 SigLIP-SO-400M 开发得到，MoonViT 使用了 NaViT 来避免切分图片和使用不同精度图片进行训练。

在 MoonViT 的基础上，Kimi-K2.5 还进一步提出了 MoonViT-3D, 将 NaViT 的思想扩展到了 3D 用于提高模型的视频理解能力，具体做法为将连续 4 帧的视频展开为 1D sequence, 这样在图像上的注意力机制就可以无缝衔接到视频上了。并且，通过这种方式，我们可以让模型关注跨帧的信息（注意力在 4 帧的 token 之间进行），简化代码如下所示

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# config.json temporal_merge_kernel_size
# kimi_k25_vision_processing.py split_video_chunks
video_chunk = frames[0:4]
patches = []
for frame in video_chunk:
 patches.extend(split_into_patches(frame))

tokens = patches
# modeling_kimi_k25.py Learnable2DInterpPosEmbDivided_fixed
positions = spatial_embedding + temporal_embedding
# modeling_kimi_k25.py MoonViT3dEncoder
output = transformer(tokens + positions)

最后，在进入 MLP 之前，作者还对每个 temporal chunk 内的特征进行 pooling 操作，将时序长度压缩到了原来的 1/4, 进而提高模型可处理的视频长度。

 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


# modeling_kimi_k25.py tpool_patch_merger
def tpool_patch_merger(
 x: torch.Tensor,
 grid_thws: torch.Tensor,
 merge_kernel_size: tuple[int, int] = (2, 2),
) -> list[torch.Tensor]:
 d_model = x.size(-1)

 outputs = []
 pre_sum = 0
 for t, h, w in grid_thws.tolist():
 # Get the current sequence
 seq = x[pre_sum:pre_sum + t * h * w]
 # Reshape along self.merge_kernel_size and concat to the last dimension
 kernel_height, kernel_width = merge_kernel_size
 new_height, new_width = h // kernel_height, w // kernel_width
 reshaped_seq = seq.view(t, new_height, kernel_height, new_width,
 kernel_width, d_model)
 reshaped_seq = reshaped_seq.permute(0, 1,
 3, 2, 4, 5).contiguous().mean(
 dim=0) # temporal pooling
 padded_seq = reshaped_seq.view(new_height * new_width,
 kernel_height * kernel_width, -1)
 outputs.append(padded_seq)
 pre_sum += t * h * w

 return outputs

MLP MLP 使用了 PatchMerger, 用于减少视觉 token 个数，这个方案在之前的 Qwen-VL 系列里已经得到了应用。

LLM LLM 基于 Kimi-k2 的 MoE 模型，总参数为 1T, 激活参数为 32B

Data

Pre-training

预训练阶段一共使用了 15T token, 分为了三个阶段：

ViT-training: 单独训练 ViT, 实际用了 image caption, grounding, ocr, video 等数据进行训练，训练方式采用了类似 InternVL 的方式，即通过 cross entropy loss 来与一个清凉话的 LLM 进行对齐，这个阶段训练使用了 1T token, 然后作者使用了一个非常短的 stage 来更新 MLP 用于对齐 ViT 和 Kimi-K2
Joint pre-training: 训练所有参数，长下文长度为 4K, 使用了 15T token. 这里主要强调了提升代码数据的比例
Long context mid-training: 使用 YARN 来提高模型的上下文长度

最终预训练阶段 recipe 如下所示

Native Multimodal pre-training 在 Joint pre-training stage, Kimi-K2.5 还采用了一个与 InternVL3 类似的策略，即在预训练一开始直接使用多模态数据进行预训练。

传统的多模态大模型往往基于一个比较成熟的 LLM backbone 来完成多模态大模型的训练，但是其问题在于成熟的 LLM 其表示空间会收敛到语言模态上，多模态信息的迁移能力比较差。InternVL3 虽然也是 native multimodal pre-training, 但是其仍然依赖于成熟的 LLM. Kimi K2.5 则是使用预训练阶段的 Kimi K2 作为 backbone 来避免表示空间的塌缩，在训练一开始即直接加入少量多模态数据来保持模型的多模态能力。

作者探究了预训练阶段不同的数据对比，试验结果如下图所示

	Vision Injection Timing	Vision-Text Ratio	Vision Knowledge	Vision Reasoning	OCR	Text Knowledge	Text Reasoning	Code
Early	0%	10%:90%	25.8	43.8	65.7	45.5	58.5	24.8
Mid	50%	20%:80%	25.0	40.7	64.1	43.9	58.6	24.0
Late	80%	50%:50%	24.2	39.0	61.5	43.1	57.8	24.0

结果显示，在训练早期加入少部分的多模态数据可以有效提高模型的表现。

Post-training

Post-training 分为了 SFT 和 RL, SFT 阶段作者使用了合成的高质量数据，主要提升模型的交互式推理能力以及工具调用能力。为了解决传统 VLM 工具调用能力比较差且扩展性差的问题，Kimi-k2.5 提出了 Zero-Vision SFT, 其核心思想模型在预训练阶段已经完成了多模态对齐，因此我们可以仅使用纯文本 SFT 数据来激活 VLM 的视觉 agent 能力，具体做法就是将所有图像操作通过 IPython 的代码进行代理操作，这样视觉工具的调用就编程了程序化的图像处理指令。

在 RL 阶段，作者基于 Kimi-k1.5 提出的策略优化算法加入了一个 token-level clipping 机制来减少 off-policy divergence, 目标函数如下所示

$$ \mathcal{L}(\theta)=\mathbb{E}_{x\sim\mathcal{D}}\left[\frac{1}{N}\sum_{j=1}^k\sum_{i=1}^{|y_i|}\mathrm{clip}\left(\log\frac{\pi_{\theta}(y_j^i\mid x, y_{j}^{0:i})}{\pi_{\mathrm{old}}(y_j^i\mid x, y_{j}^{0:i})},\alpha,\beta\right)(r(x, y_j) - \bar{r}(x)) - \tau\left(\log\frac{\pi_{\theta}(y_j^i\mid x, y_{j}^{0:i})}{\pi_{\mathrm{old}}(y_j^i\mid x, y_{j}^{0:i})}\right)^2\right] $$

其中 $k$ 是针对每个回答 $x$ 的采样次数，$N=\sum_{j=1}^k|y_j|$ 是一个 batch 里总的 token 个数， $\alpha,\beta,\tau$ 为超参数，$\bar{r}(x)$ 是对 normalization 的估计，这里采用了 Kimi-K1.5 的 mean reward, 即 $\bar{r}(x)=1/k\sum_{j=1}^Kr(x,y_j)$. 这里的 clipping 机制与 PPO 不同的地方在于针对 log-ratio 进行 clipping, 而不依赖于 advantage 的计算。最终训练时使用了 Moonlight 的 MuonClip 算法

对于 reward 的设计，Kimi-k2.5 也使用了基于规则和基于 reward model 的方式，前者针对答案可验证的任务，后者针对开放式的任务。

作者还构建了 length penalty 来提高模型的推理效率，作者发现 Kimi-k1.5 和 Kimi-k2 中的 length penalty 虽然可以生成更准确的 reasoning chain, 但是其很难泛化到更高的算力. 为了解决这个问题，作者提出了 Toggle 策略，即在 inference-time scaling 和 budget-constrained optimization 两种模式之间进行切换优化，对应的 reward 定义为

$$ \tilde{r}(x,y) = \begin{cases} r(x,y)*\mathbb{I}\{1/k\sum_{j=1}^kr(x,y_i<\lambda \text{ or }|y_j|\leq \text{budget}(x)\},&\text{if }\lfloor t/m\rfloor\mod 2 == 0\ (\text{Phase }0)\\ r(x,y),&\text{otherwise } (\text{Phase }1) \end{cases} $$

其中 $\lambda, m$ 都是超参数。budget 基于正确回答的长度的 p 分位得到：

$$ \text{budget}(x) = \text{Percentile}(\{|y_j| \mid r(x,y_j)=1, j\in[k]\},\rho) $$

两种模式每隔 $m$ 个 iteration 切换一次：

phase 0: budget limited phase, 训练模型在给定 token budget 下解决问题，减少 reasoning chain 长度
phase 1: scaling phase, 训练模型使用更多的算力来解决更复杂的问题，提高模型的智能程度

作者评估 Toogle 策略得到的结果如下所示

结果现实，使用 toggle 策略之后，模型的输出长度减少了 30% 左右，且模型的表现并没有明显下降。作者还发现，一些重复的 pattern 也随之降低，且 toggle 策略的泛化程度更高。

在 Zero-Vision SFT 的基础上，Kimi-k2.5 使用了 Joint multimodal RL 训练策略。现有的多模态 RL 存在的问题为：模型很容易忽略视觉输入而过度依赖于纯文本进行推理。为了解决这个问题，作者构建了需要视觉理解才能得到答案的任务来提高模型对于视觉信息的利用程度，这些任务覆盖三个 domain:

visual grounding and counting: 定位和计数
chart and document understanding: 图表文档理解
vision-critical STEM problems: 需要图片来完成求解的数学物理问题

作者在 visual RL 之后评估了模型的表现，发现模型在 MMLU-Pro, GPQA-Diamond 等任务上的表现都有了提升，作者认为 visual RL 可以在不损害模型纯文本能力的情况下提高模型跨模态的泛化性

Agent Swarm

Kimi-k2.5 的另一个重大改进为使用并行机制来提高模型的 agent 能力。传统的 agent 往往序列执行 reasoning, tool-use, 这限制了模型处理复杂任务的能力，Kimi-k2.5 通过 Agent Swarm 和 Parallel Agent Reinforcement Learning (PARL) 来解决这个问题，其核心思想就是并行，框架图如下所示

agent swarm 架构包含了一个 orchestrator 和若干个 subagent, 为了解决 agent swarm 的 reward 比较难以设置的问题，PARL 构建了三个不同 level 的 reward

$$ r_{PARL}(x,y) = \lambda_1 r_{parallel} + \lambda_2r_{finish} + \lambda_3r_{perf}(x,y) $$

其中 $r_{perf}$ 评估了 solution $y$ 的质量， $r_{parallel}$ 则是避免并行模式崩塌，从 multi-agent 崩塌为 single agent, $r_{finish}$ 则是评估模型的完成性。超参数 $\lambda_1,\lambda_2$ 随训练逐渐降为 0 来提高模型整体的表现。

作者还提出了使用 critical steps 来评估 parallel agent 的计算时间消耗，其计算公式如下

$$ CriticalSteps = \sum_{i=1}^T\left(S_{main}^{(t)}+\max_iS_{sub,i}^{(t)}\right) $$

其中 $T$ 为一个 episode 的时间，$S_{main}^{(t)}$ 为 orchestrator 在第 $t$ 步的运行时间， $S_{sub,i}^{(t)}$ 为第 i 个 subagent 的运行时间。

为了提高模型的并行能力，作者构建了一批广度优先搜索和深度优先搜索的数据，通过这些数据的构建，我们可以提高 orchestrator 的并行调用能力。

最终，PARL 的表现如下所示

Infra

Kimi-k2.5 的 infra 基于 Kimi-k2, 作者主要强调了 decouple encoder process (DEP) 这一改进。之前的工作将 vision encoder 和 text embedding 都做为 PP 的第一个 stage, 但是由于 vision encoder 对不同输入的处理时间不同，这个 stage 的算历和内存分配随输入变化比较大。为了解决这个问题，作者提出了 DEP, 包含三个 stage 来提高训练效率:

balanced vision forward: 由于 vision encoder 比较小 (400M), 因此作者将 vision encoder 复制到所有 GPU 上，然后根据负载来将 visual data 分配到不同的 GPU 上进行处理，这个阶段不保存中间激活值，处理完毕之后所有的结果作为 PP Stage0 的输入
backbone training: 正常进行训练，与 LLM 的训练优化一致
vision recomputation & backward: 这个阶段，我们重新计算 vision encoder 的 forward pass, 然后再对 vision encoder 进行反向传播

通过 DEP, Kimi-k2.5 的训练效率达到了 Kimi-k2 的 90%.

Experiments

首先是 Kimi-k2.5 在 general & reasoning 类任务上的表现，可以看到，Kimi-k2.5 超过了 DeeoSeek-V3.2 的表现，

Benchmark	Kimi K2.5	Claude Opus 4.5	GPT-5.2 (xhigh)	Gemini 3 Pro	DeepSeek-V3.2
HLE-Full	30.1	30.8	34.5	37.5	25.1†
HLE-Full w/ tools	50.2	43.2	45.5	45.8	40.8†
AIME 2025	96.1	92.8	100	95.0	93.1
HMMT 2025 (Feb)	95.4	92.9*	99.4	97.3*	92.5
IMO-AnswerBench	81.8	78.5*	86.3	83.1*	78.3
GPQA-Diamond	87.6	87.0	92.4	91.9	82.4
MMLU-Pro	87.1	89.3*	86.7*	90.1	85.0
SimpleQA Verified	36.9	44.1	38.9	72.1	27.5
AdvancedIF	75.6	63.1	81.1	74.7	58.8
LongBench v2	61.0	64.4*	54.5*	68.2*	59.8*

接下来是模型在 coding 任务上的表现

Benchmark	Kimi K2.5	Claude Opus 4.5	GPT-5.2 (xhigh)	Gemini 3 Pro	DeepSeek-V3.2
SWE-Bench Verified	76.8	80.9	80.0	76.2	73.1
SWE-Bench Pro (public)	50.7	55.4*	55.6	-	-
SWE-Bench Multilingual	73.0	77.5	72.0	65.0	70.2
Terminal Bench 2.0	50.8	59.3	54.0	54.2	46.4
PaperBench (CodeDev)	63.5	72.9*	63.7*	-	47.1
CyberGym	41.3	50.6	-	39.9*	17.3*
SciCode	48.7	49.5	52.1	56.1	38.9
OIBench (cpp)	57.4	54.6*	-	68.5*	54.7*
LiveCodeBench (v6)	85.0	82.2*	-	87.4*	83.3

在 agent 任务上的表现

Benchmark	Kimi K2.5	Claude Opus 4.5	GPT-5.2 (xhigh)	Gemini 3 Pro	DeepSeek-V3.2
BrowseComp	60.6	37.0	65.8	37.8	51.4
BrowseComp (w/ ctx manage)	74.9	57.8	-	59.2	67.6
BrowseComp (Agent Swarm)	78.4	-	-	-	-
WideSearch	72.7	76.2*	-	57.0	32.5*
WideSearch (Agent Swarm)	79.0	-	-	-	-
DeepSearchQA	77.1	76.1*	71.3*	63.2*	60.9*
FinSearchCompT2&T3	67.8	66.2*	-	49.9	59.1*
Seal-0	57.4	47.7*	45.0	45.5*	49.5*
GDPVal-AA	41.0	45.0	48.0	35.0	34.0
OSWorld-Verified	63.3	66.3	8.6	20.7	-
WebArena	58.9	63.4	-	-	-

多模态表现

Benchmark	Kimi K2.5	Claude Opus 4.5	GPT-5.2 (xhigh)	Gemini 3 Pro	Qwen3-VL-235B-A22B
Image
MMMU-Pro	78.5	74.0	79.5*	81.0	69.3
MMMU (val)	84.3	80.7	86.7*	87.5*	80.6
CharXiv (RQ)	77.5	67.2*	82.1	81.4	66.1
MathVision	84.2	77.1*	83.0	86.1*	74.6
MathVista (mini)	90.1	80.2*	82.8*	89.8*	85.8
SimpleVQA	71.2	69.7*	55.8*	69.7*	56.8*
WorldVQA	46.3	36.8	28.0	47.4	23.5
ZeroBench	9	3*	9*	8*	4*
ZeroBench w/ tools	11	9*	7*	12*	3*
BabyVision	36.5	14.2	34.4	49.7	22.2
BLINK	78.9	68.8*	-	78.7*	68.9
MMVP	87.0	80.0*	83.0*	90.0*	84.3
OmniDocBench 1.5	88.8	87.7*	85.7	88.5	82.0*
OCRBench	92.3	86.5*	80.7*	90.3*	87.5
InfoVQA (test)	92.6	76.9*	84*	57.2*	89.5
Video
VideoMMMU	86.6	84.4*	85.9	87.6	80.0
MMVU	80.4	77.3*	80.8*	77.5*	71.1
MotionBench	70.4	60.3	64.8	70.3	-
Video-MME	87.4	66.0*	86.0*	88.4*	79.0
LongVideoBench	79.8	67.2*	76.5*	77.7*	65.6*
LVBench	75.9	57.3	-	73.5*	63.6

我们这里基于模型在不同类别任务上的排名来进行可视化，结果如下

从结果可以看出，Kimi-K2.5 的 agent 能力达到了 SOTA 级别，其多模态能力也比较强。

与 DeepSeek-V3.2 一样，作者也对比了不同模型的推理效率，结果如下图所示

可以看到，相比与 Kimi-K2, Kimi-K2.5 通过在 RL 层面进行优化，降低了输出长度，但是相比与 DeepSeel-V3.2 和 Gemini3.0 Pro 之间还存在一定差距。

Conclusion

在本文中，作者提出了 Kimi-k2.5，一个多模态的 agent model, Kimi-k2.5 集成了 Kimi-k2 和 Kimi-VL 的能力，扩展了模型的 agent 能力。

References

Notes on DeepSeek-V3.2

Tue, 06 Jan 2026 17:30:40 +0800

Introduction

作者首先回顾了开源模型如 MiniMax-01, Kimi-k2, Qwen3, GLM-4.5 和闭源模型的进展，作者指出，现在的开源模型和闭源模型在表现上仍然存在较大差距。作者认为这种差距主要是由于三个原因：

Transformer 提出的 softmax attention 在处理长文本时效率非常低
已有的开源模型在 post-training 阶段使用的算力不够
开原模型的泛化和指令跟随能力不如闭源模型

基于这三个问题，DeepSeek-V3.2 分别进行了改进：

在架构上，作者提出了 DSA，一个高效的稀疏注意力机制，用于降低计算复杂度
在 post-training 阶段，作者使用了比 pre-training 阶段高 $10\%$ 的算力，用于提高模型的能力
作者提出了一个 pipeline 用于提高模型在工具调用场景下的 reasoning 能力

通过实验作者发现，模型达到了和 Kimi-k2 以及 GPT-5 差不多的 reasoning 表现。

Method

Architecture

DeepSeek-V3.2 与 DeepSeek-V3.1 不同之处在于使用了 DeepSeek Sparse Attention (DSA). 架构如下图所示

DSA 包含两个模块：

lightning indexer
fine-grained token selection mechanism

其中，lightning indexer 负责计算 query token $h_t\in\mathbb{R}^d$ 和一个 preceding token $h_s\in\mathbb{R}^d$ 之间的 index score $I_{t,s}$ 来决定 query token 选择的 token:

$$ I_{t,s} = \sum_{j=1}^{H_I}w_{t,j}^I \mathrm{ReLU}(q_{t,j}^I\cdot k_s^I) $$

其中， $H^I$ 代表 indexer heads 的个数，$q_{t,j}^I\in\mathbb{R}^{d^I}$ 和 $w_{t,j}^I$ 由 query token $h_t$ 得到，$k_s^I\in\mathbb{R}^{d^I}$ 由 preceding token $h_s$ 得到

给定 query token $h_t$ 对应的 index score $\{I_{t,s}\}$, fine-grained token selection mechanism 负责选取 top-K index score 对应的 key-value entries $\{c_s\}$, 然后 attention 的输出由 query token 个选取的 key value entries 得到：

$$ u_t = \mathrm{Attn}(h_t,\{c_s\mid I_{t,s}\in \mathrm{TopK}(I_{t,:})\}) $$

[!Recall] MoBA 也提出了类似的方法，但是 MoBA 是一个无需训练的策略

受 NSA 启发，作者实现了基于 MQA 模式的 MLA, 其中 latent vector 对于 query token 所有的 query heads 都是共享的。示意图如下所示

Continue Pre-training

作者在 DeepSeek-V3.1 的基础上进行了 continue pre-training. Continue pre-training 包含两个阶段：

Dense Warm-up stage 这个阶段用于训练 lightning indexer, 作者冻结除 lightning indexer 之外的参数，为了对齐 indexer output 和 main attention distribution, 对于第 $t$ 个 query token, 作者首先计算所有 attention heads 的 main attention score 之和，然后在 sequence 层面进行 L1-normalization 得到 $p_{t,:}\in\mathbb{R}^t$, 最后计算 lightning indexer 输出与 $p_{t,:}$ 之间的 KL divergence:

$$ \mathcal{L}^I = \sum_{t}\mathcal{D}_{KL}(p_{t,:}\ \Vert\ \mathrm{Softmax}(I_{t,:})) $$

这个阶段训练一共使用了 2.1B 的 token, lr 为 1e-3, 训练的步数为 1000 steps, batch size 为 16.

Sparse training stage 这个阶段模型所有的参数都参与训练，该阶段的目的是让模型学习到 DSA 的 sparse pattern. 训练时，作者让 lightning indexer 的输出与 $p_{t,S_t}$ 之间的输出进行对齐，其中 $S_t=\{s\mid I_{t,s}\in\mathrm{TopK}(I_{t,:})\}$:

$$ \mathcal{L}^I = \sum_{t}\mathcal{D}_{KL}(p_{t,S_t}\ \Vert\ \mathrm{Softmax}(I_{t,:})) $$

实际训练时，lightning indexer 仅接受 $\mathcal{L}^I$ 的反向传播，而 LLM 则仅接受 next-token prediction loss. 这个阶段模型一共使用了943.7B token, 其中 $K$ 设置为 $2048$. 学习率为 $7.3\times 1e-6$, 训练步数为 15,000 steps, batch size 为 480.

Post-training

post-training 与 DeepSeek-V3.1 一致：

Specialist Distillation 作者基于 DeepSeek-V3.2 base 构建了不同领域的 specialized model, 这些领域包括：

math
competitive programming
general logical reasoning
agentic coding
agentic search

每个 specialized model 都使用 RL 进行训练，训练数据包括 long CoT reasoning 数据以及 direct response generation 数据，specialized model 训练完毕之后，就被用于生产 domain-specific data, 作者通过实验发现，基于这种蒸馏方法，模型的表现仅比 specialized model 低一点，并且这个 gap 可以被后续的 RL 训练所抵消。GLM-4.5 也采取了类似的做法

Mixed RL Training 作者使用了 GRPO 算法进行训练，与 DeepSeek-V3 不同，作者将 reasoning, agent 以及 human alignment 的 RL 训练合并为了一个阶段，作者认为这种方法可以平衡模型在多个 domain 上的表现，并且可以防止 multi-stage training 带来的灾难性遗忘问题。对于 reasoning 和 agent 任务，作者使用了 rule-basd outcome reward, length penalty 以及 language consistency reward. 对于通用任务，作者使用了 generative reward model, 每个 prompt 都有对应的 rubris 用于 evaluation. 作者构建 reward 时主要考虑了:

length versus accuracy
language consistency versus accuracy

DeepSeek-V3.2-Speciale 除了 DeepSeek-V3.2 之外，作者还训练了 DeepSeek-V3.2-Speciale 模型，该模型仅使用 reasoning 数据进行训练，reasoning 数据包含了 DeepSeek-Math-V2 的训练数据以及 reward 方法。训练时，作者降低了 length penalty 的惩罚系数，最终 DeepSeek-V3.2-Speciale 模型拥有更强的 reasoning 能力

Scaling GRPO

作者在 GRPO 的基础上对 KL estimate 进行了改进（见 KL divergence），使用了 importance sampling 对 K3 estimator 进行修正:

$$ \mathcal{D}_{\mathrm{KL}}(\pi_\theta(o_{i,t})\Vert\pi_{\mathrm{ref}}(o_{i,t})) = \frac{\pi_\theta(o_{i,t}\mid q, o_{i,使用 K3 estimator 之后，现在 KL estimator 的梯度估计就变成无偏估计了，从而提高了整体训练的稳定性。作者还发现不同任务对 KL regularization 的需求不一致，对数学等 domain, 我们应该采取较小的 KL penalty 或者不使用 KL penalty 反而能提升性能

Off-Policy Sequence Masking 作者还使用了 sequence masking 来提高 off-policy data 的数据使用效率，由于不同 rollout 的完成时间不一致，训练过程中会出现 off-policy 现象，即某些 mini-batch 不是由当前 policy 产生，这个现象在 Magistral 中也有提到，这种训练 - 推理不一致性会进一步加剧 off-policy 程度，为了提高训练稳定性，作者将 policy divergence 程度比较高的 sequence 给 mask 掉，更新后的损失函数如下所示

$$ \mathcal{J}_{\mathrm{GRPO}}(\theta) = \mathbb{E}_{(q,a)\sim\mathcal{D},\{o_i\}_{i=1}^G\sim \pi_{\theta_{old}}(\cdot\mid q)}\left[ \frac{1}{G}\sum_{i=1}^G\frac{1}{|o_i|}\sum_{t=1}^{|o_i|}\min\left(r_{i,t}(\theta)\hat{A}_{i,t},\mathrm{clip}\left(r_{i,t}(\theta), 1-\epsilon, 1+\epsilon\right)\hat{A}_{i,t}\right)M_{i,t}-\beta \mathcal{D}_{\mathrm{KL}}(\pi_\theta(o_{i,t})\Vert\pi_{\mathrm{ref}}(o_{i,t}))\right] $$

其中，

$$ M_{i,t} = \begin{cases} 0, &\hat{A}_{i,t}<0, \frac{1}{|o_i|}\sum_{t=1}^{|o_i|}\log r_{i,t}(\theta)<\delta\\ 1, &\text{otherwise} \end{cases} $$

用于决定是否对当前 sequence 进行 mask, $\delta$ 是一个超参数控制 policy divergence 程度。作者认为，模型主要从自身的错误进行学习，而 off-policy 的负样本模型学习提升有限甚至有害。作者发现加入这个 masking 策略之后，模型的训练稳定性有所提升。

Keep Routing MoE 模型在进行 On-policy RL 训练是，由于 policy 的更新，新 policy 和旧 policy 专家的 routing 可能会不一致，这种不一致性会降低训练的稳定性以及 off-policy 现象。为了解决这个问题，作者在采样室，保存了训练阶段所使用的 expert routing path, 来保证训练推理的一致性。这种策略可以有效提高针对 MoE 模型的 RL 训练稳定性

Keep Sampling Mask 作者发现，使用 top-p 和 top-K 可以提高 LLM 输出的质量，但是这种采样擦略也会导致 $\pi_{\mathrm{old}}$ 和 $\pi_{\theta}$ action space 的不匹配，因此，作者记录了 $\pi_{\mathrm{old}}$ 采样过程中的 truncation mask, 然后再训练的时候将其应用到 $\pi_{\theta}$ 上，作者发现通过这种方式可以有效提高 RL 训练过程中的 language consistency

Thinking in Tool-Use

本节的目的是希望能够将 reasoning 能力应用到工具调用的场景下。

作者发现，如果使用 DeepSeek-R1 的策略，在下一轮对话到来时，丢弃到当前的 reasoning content 会让模型重新生成针对问题的 CoT, 从而产生 token inefficiency. 为了解决这个问题，作者构建了一个上下文管理策略，如下图所示

具体做法为：

reasoning content 只有当有新的 user message 进入时才会丢弃；如果只有工具调用相关的 message, 则 reasoning content 会保留
移除 reasoning content 时，会保留对应的工具调用及其结果

在训练时，作者认为模型已经掌握了比较好的指令跟随能力，我们仅需要将 reasoning data (non-agentic) 和 non-reasoning data(agentic) 以不同的 prompt 输入给模型就能够得到比较好的结果。

对于训练的数据，作者认为 RL 任务的多样性可以有效提高模型的 robustness, 因此作者构建了不同的环境及其对应的 prompt, 生成的任务如下表所示

	number of tasks	environment	prompt
code agent	24667	real	extracted
search agent	50275	real	synthesized
general agent	4417	synthesized	synthesized
code interpreter	5908	real	extracted

search agent: 作者使用了 multi-agent 的策略，包括 question-construction agent 用于构建 QA pair, multiple answer-generation agent 用于构建不同的 response, 一个 verification agent 用于评估生成的 response. 最后作者使用 generative reward model 来评分
code agent: 作者爬取了 Github 上的 pull request, 然后进行过滤，接下来作者通过一个 environment-setup agent 来构建对应的环境
code interpreter agent: 作者使用 jupyter notebook 作为代码解释器来解决复杂的 reasoning tasks, 包括 math, logic, data science 等
general agent: 作者构建了验证简单解决困难的任务。首先作者基于 agent 和 task category 来生成或检索相关数据；接下来作者合成一个任务相关的工具集合；最后，作者让一个 agent 来提出任务以及对应的解法，并不断提高任务的难度。最后得到 <environment, tools, task, verifier> 的 tuple 格式

Experiments

作者对比了 DeepSeek-V3.2-Exp 和 Claude-4.5 Sonnet, GPT-5, Gemini 3.0 Pro, Kimi-K2 thinking, MiniMax M2 的表现，评测结果如下

结果显示，DeepSeek V 3.2 和 GPT-high 在 reasoning 任务上的表现差不多。作者认为，进一步提高 RL 阶段的算力可以有效提高模型的表现

作者还对比了 DeepSeek-V 3.2-Speciale 的表现，结果显示，提高 token budget 之后，模型的表现显著提高，与 Gemini 3.0 Pro 可以相比，但是其 token efficiency 仍然弱于 Gemini 3.0 Pro, 结果如下图所示

接下来作者验证了 synthesis agentic tasks 对模型表现的影响。首先，作者随机采样一批样本使用闭源 LLM 进行测试，发现闭源模型表现最好为 $62\%$, 这说明了合成数据对于 DeepSeek V3.2 和闭源模型都是有挑战的。

其次，作者探究了合成数据是否能够提高 RL 的泛化性，作者构建了两个额外模型：

SFT: 在 SFT checkpoint 上进行 RL
Exp: 仅在 search 以及 code environment 上进行 RL

对比结果发现，合成数据缺失可以有效提高模型的表现

作者还对比了 DSA 的效率，DSA 可以将 attention 的计算复杂度由 $\mathcal{O}(L^2)$ 降低到 $\mathcal{O}(LK)$, 其中 $K$ 是选取的 top-K tokens. 尽管 lightning indexer 的复杂度仍然是 $\mathcal{O}(L^2)$, 但是其计算量远小于 MLA, 作者对比了两者的效率，实验结果如下图所示

可以看到，DeepSeek-V3.2 的 prefilling 和 decoding 效率都远高于 DeepSeek-V3.1

最后，作者对比了不同上下文管理策略对模型表现的影响，对比策略有：

Summary: 对轨迹进行总结然后重新初始化 rollout
Discard 75%: 丢弃到初始 75% 的工具调用历史
Discard-all: 丢弃掉所有的工具调用历史
Parallel-fewest step: 多次采样然后保留步数最少得轨迹

实验结果如下图所示

结果显示，使用上下文管理策略之后，模型的表现有了显著提升。并且，discard-all 策略虽然很简单，但是其表现非常好。作者认为如何根据不同场景来选取合适的策略是一个待解决的问题。

Conclusion

作者在本文中提出了 DeepSeek-V 3.2, DeepSeek-V 3.2 使用了一个稀疏注意力机制来提高模型在长上下文场景下的计算效率。作者还通过提升 RL 阶段的算力来提高模型在下游任务上的表现。最后，作者合成了大规模的 agentic task 来提升模型的 agent 能力。

作者认为，相比于 Gemini 3.0 Pro, 模型的知识广度仍然有限。并且，目前模型的 token efficiency 仍然是一个问题，模型需要更长的轨迹输出才能达到 Gemini 3.0 Pro 的表现。最后，模型解决复杂问题的能力仍然弱于闭源模型。

References

DeepSeek-V3.2: Pushing the Frontier of Open Large Language Models

Notes on DeepSeek-V3

Mon, 08 Dec 2025 11:14:45 +0800

DeepSeek 在 24 年 11 月发布了 DeepSeek-V3, 一个仅花费 2.8M H800 hours 的大语言模型，且在各个 benchmark 上达到了 SOTA 表现

Introduction

作者在本文中提出了 DeepSeek-V3, 一个 671B-A37B 的 MoE 大语言模型。

在训练目标和架构上，作者做了如下改进：

efficiency inference: 采用了 DeepSeek-V2 提出的 MLA
cost-effective training: 采用了 DeepSeekMoE 提出了 MoE 架构
auxiliary-loss-free strategy: 采用了 Loss-Free Balancing 提出的 loss balancing 策略
multi-token prediction: 采用了 MTP 的训练目标来提升模型的表现

在训练上，作者做了如下改进：

使用了 FP8 混合精度进行训练并验证了其在大规模模型上的有效性
作者构建了 DualPipe 算法用于高效的 pipeline parallelism
构建了 cross-node all-to-all communication kernel 来高效使用 InfiniBand 以及 NVLink bandwidth
优化了 memory footprint, 来避免使用 tensor parallelism

预训练阶段，DeepSeek-V3 使用了14.8T token. 在 mid-training 阶段，作者将模型的上下文长度由 8K 扩展到 32K, 再扩展到 128K.

后训练阶段，作者使用了 SFT 和 RL 两个阶段来提高模型的表现，作者还对 DeepSeek-R1 进行蒸馏来提高模型的 reasoning 能力

Architecture

Basic Architecture

DeepSeek-V3 的架构与 DeepSeek-V2 的架构一致，如下图所示

MLA 的介绍见 MLA, MoE 架构的介绍见 DeepSeekMoE. DeepSeek-V3 在 DeepSeekMoE 的基础上做了两点改变：

受 Loss-Free Balancing 启发，作者使用了 sigmoid fu nction 来计算 affinity score
对于 selected affinity score 应用了 normalization

在 DeepSeekMoE 的基础上，作者使用了 Loss-Free Balancing. 其表达式如下

$$ g_{i,t} = \begin{cases} s_{i,t}, & s_{i,t}+b_i\in\mathrm{Topk}(\{s_{i,j}+b_j\mid 1\leq j\leq N\}, K)\\ 0, &\text{otherwise} \end{cases} $$

其中 $b_i$ 仅影响 routing, 训练时，如果对应的 expert 负载不均衡，则对 $b_i$ 进行更新，更新方式为增加/减少 $\gamma$, 这里 $\gamma$ 是一个超参数

为了提高 routing 在 sequence 层面的负载均衡，作者还是用了一个 complementary sequence-wise balance loss:

$$ \begin{aligned} \mathcal{L}_{\mathrm{Bal}} &= \alpha\sum_{i=1}^{N_r} f_iP_i\\ f_i &= \frac{}{}\sum_{t=1}^T\mathbb{1}(s_{i,t}\in\mathrm{TopK}(\{s_{j,t}\mid 1\leq j \leq N_r\}, K_r))\\ s_{i,y}' &= \frac{s_{i,t}}{\sum_{j=1}^{N_r}s_{j,t}}\\ P_i &= \frac1T\sum_{t=1}^T s_{i,t}' \end{aligned} $$

其中 $\alpha$ 是 balance factor, 为超参数，$T$ 是 sequence length, 加入这个损失后，每个 sequence 上的负载会变得更加均衡

与 DeepSeekMoE 一样，作者也在 node 层面实现负载均衡，具体做法就是，根据 node 中所包含 expert 的 affinity score 之和来选取最高的 $M$ 个 nodes, 这样就可以进一步提高 computation 和 communication 之间的 overlap.

由于 DeepSeek-V3 负载均衡比较好，因此作者使用了 no token-dropping strategy.

MTP

受 MTP 启发，DeepSeek-V3 也构建了 MTP 模块，作者认为 MTP 模块有两个优势：

MTP objective 提供了更多的学习信号，进而提高了数据使用效率
MTP 可以让模型更好预测未来的 token

与 MTP 不同，DeepSeek-V3 【todo】, DeepSeek-V3 所使用的 MTP 模块架构图如下所示

MTP 模块使用了 $D$ sequential modules 来预测未来的 $D$ 个 token. 其中，第 $k$ 个 MTP 模块包含一个共享的 embedding layer $\mathrm{Emb}(\cdot)$ , 一个共享的 output head $\mathrm{OutHead}(\cdot)$, 一个 transformer block $\mathrm{TRM}_k(\cdot)$ 和一个 projection matrix $M_k\in\mathbb{R}^{d\times 2d}$.

对于第 $i$ 个 token 以及第 $k$ 个 MTP 模块，作者首先将第 $k-1$ 个 MTP 模块的第 $i$ 个 token 的 hidden states $h_i^{k-1}\in\mathbb{R}^d$ 和第 $i+k$ 个 token 的 embedding $\mathrm{Emb}(t_{i+1})\in\mathbb{R}^d$ 联合在一起

$$ h_i'^{k}=M_k[\mathrm{RMSNorm(h_{i}^{k-1});\mathrm{RMSNorm(\mathrm{Emb}(t_{i+k}))}}] $$

其中 $[\cdot;\cdot]$ 代表 concatenation 操作。当 $k=1$ 时，$h_{i}^{k-1}$ 就代表了 main model 的输出。每个 MTP 模块的 embedding layer 和 main model 的 embedding layer 是共享的，接下来， $h_i'^k$ 作为第 $k$ 个 MTP 模块 transformer block 的输入，得到

$$ h_{i}^k = \mathrm{TRM}_k(h_{i}'^l) $$

最后，共享的 output head 输出对应的概率分布：

$$ P_{i+k+1}^k = \mathrm{OutHead}(h_i^k) $$

这里的 $\mathrm{OutHead}(\cdot)$ 的权重与 main model 也是共享的。作者这里提到，所使用的思想与 EAGLE 是类似的，但是不同的地方在于，EAGLE 主要是用于 speculative decoding, 而 MTP 主要用于提升训练。

MTP 的训练目标为未来 $T-k-1$ 个 token 的 cross-entropy loss:

$$ \mathcal{L}_{\mathrm{MTP}}^k = \mathrm{CrossEntropy}(P_{2+k:T+1}^k,t_{2+k:T+1}) = -\frac1T\sum_{t=k+2}^{T+1}\log P_i^k[t_i], $$

其中 $T$ 是 sequence length, $t_i$ 是第 $i$ 个位置对应的 ground truth token, $P_i^k[t_i]$ 代表低 $k$ 个 MTP 模块给出的 $t_i$ 的预测概率。最后，作者对所有的 MTP loss 进行求和，得到

$$ \mathcal{L}_{\mathrm{MTP}} = \frac{\lambda}{D}\sum_{k=1}^D \mathcal{L}_{\mathrm{MTP}}^k. $$

Infra

DeepSeek-V3 训练使用了 2048 张 H800, 每个 node 包含 8 张 GPU, node 内部使用 NVLink 和 NVSwitch 进行连接，node 之间使用 InfiniBand 进行连接

与之前的 DeepSeek 系列相同，DeepSeek-V3 也是用了 HAI-LLM 框架来支持训练。训练时，DeepSeek-V3 使用了 16-way PP, 64-way EP (spanning 8 nodes, GShard) 以及 ZeRO-1 DP.

作者主要进行了三点优化：

构建了 DualPipe 用于高效 pipeline parallelism
构建了 cross-node all-to-all communication kernels 来高效利用 IB 以及 NVLink bandwidth
优化了训练时的 memory footprint, 使得训练时不再依赖 TP

Training Framework

DualPipe

DeepSeek-V3 中，由于 cross-node EP, computation-to-communication ratio 近似为 1:1, 为了解决这个问题，作者提出了 DualPipe. DualPipe 的核心思想是将 forward 和 backward 过程中的 computation 以及 communication 进行重叠。与 ZeroBubble 类似，作者将每个 chunk 分为四个部分：attention, all-to-all dispatch, MLP 以及 all-to-all combine. 对于 attention 和 MLP, 作者还进一步将 backward 拆分为针对权重和输入的 backward. 其示意图如下所示，这里橙色部分代表 forward, 绿色代表了针对输入的 backward, 蓝色代表了针对权重的 backward

示意图里包含两个 block, 我们记为 block1, block2, 前向计算过程为

1

dispatch(F, block1) -> MLP(F, block1) -> combine(F, block1) -> attention(F, block2)

其中，dispatch(F, block1) 与 MLP 的反向传播 MLP(B, block1) 计算重叠, MLP(F, block1) 与 MLP 反向传播的 dispatch dispatch(B, block1) 通信重叠，combine(F, block1) 与 attention 反向传播的 attention(B, block2) 重叠，attention(F, block2) 与反向传播的 combine combine(block2) 重叠。下面是一个具体的例子

作者进一步对比了 DualPipe, 1F1B 和 ZeroBubble, 结果如下表所示

Method	Bubble	Parameter	Activation
1F1B	$(PP-1)(F+B)$	$1\times$	$PP$
ZB1P	$(PP-1)(F+B-2W)$	$1\times$	$PP$
DualPipe (Ours)	$(\frac{PP}{2}-1)(F\&B+B-3W)$	$2\times$	$PP+1$

这里 $F$ 是 forward chunk 的执行时间，$B$ 是 backward chunk 执行的时间，$W$ 是一个 chunk “backward for weights” 的执行时间，$F\&B$ 是一个 chunk 前向反向传播重叠的时间。可以看到，DualPipe 只使用了额外的 $1/PP$ 倍的 peak activation memory, 就大幅度降低了 bubble 时间

Cross-node All-to-all Communication

作者针对 DualPipe 构建了 cross-node all-to-all communication kernels 来提高通信效率。

作者提到，跨节点通信使用的是 IB, 节点内部通信使用的是 NVLink，通信方式如下图所示。

对于 H800 来说,NVLink 的带宽为 160GB/s, IB 的带宽为 50GB/s, 因此 NVLInk 的通信效率是 IB 的 3.2 倍，即节点内部通信效率高于节点之间的通信效率。为了提高通信效率，作者限制每个 token 只能被分发到至多 4 个节点上（DeepSeek-V2 里提到的 device limited routing）。其具体通信方式为想传输到目标 node index 相同的 rank 上，然后再通过节点内部通信传输到目标的 rank 上。通过这种方式，我们可以让节点间通信与节点内部通信进行重叠，从而每个 token 可以从一个节点上选取 3.2 个专家，这样 DeepSeek-V3 可以在不损失效率的情况下最高选取 $13$ 个专家。

作者进一步采用了 warp specialization 技巧来将 20 个 SM 划分为 10 个通信 channel. 作者分别针对 dispatching 和 combing 阶段使用了不同数量的 warps.

Memory saving

作者使用了如下技巧来减少内存访问：

Recomputation of RMSNorm and MLA Up-Projection. 在 backward 过程中重新计算 RMSNorm operation 以及 MLA up projection 来避免存储器对应的输出
Exponential Moving Average in CPU. 作者将 EMA 参数保存在 CPU 中，然后进行异步更新来进一步减少内存访问
Shared Embedding and Output Head for Multi-Token Prediction. 作者将 embedding layer 和 output head 放在一个 PP rank 上，这样就可以提高 MTP 的内存访问效率

FP8 Training

作者提出了一个基于 FP8 的混合精度训练框架。作者提出了两个改进方案：

分组量化，将 tensor 按照 tile 分组或者按照 block 分组来分组量化，这样就避免了全局量化的精度损失
高精度累加，作者在乘法计算时，使用了 FP8 格式，然后在累加阶段，使用了更高精度的格式

为了进一步减少内存和通信开销，对于 activation 的 cache 以及 dispatch, 作者使用了 FP8 数据格式，然后对于优化器状态，作者使用了 BF16 数据格式。下面是对上面改进的具体说明。

Mixed Precision Training

作者在本文中提出了使用 FP8 混合精度进行预训练，作者参考了 low precision training 构建 FP8 训练框架，即计算量高的使用 FP8 精度，计算量低的使用原本的数据精度, 框架如下图所示

其中各个模块使用的精度如下表所示

Precision	Modules
FP8	Linear (Fprop, Dgrad, Wgrad)
higher precision	- embedding - output head - Moe gating - normalization - attention operator - master weights - weight gradients - optimizer states

Enhancing Low-precision Training Accuracy

作者介绍了几个策略用于提高 FP8 混合精度训练的表现：

fine-grained quantization: 对于激活值，作者将 tensor 分割为 $1\times 128$ 大小的 groups, 然后每个 group 内部进行 quantization; 对于权重，作者将其分割为 $128\times 128$ 大小的 groups, 然后进行 quantization, 这样可以降低 quantization error, 如上图左图所示
increasing accumulation precision: 低精度训练会带来 underflow 的问题，而 FP8 GEMM 累加仅能保留约 14bit 精度，远低于 FP32 的 32bit 精度。为了解决这个问题，作者采用了 Tensor Core 不分累加 +CUDA core 高精度聚合的协同策略。即在 Tensor Core 上执行 MMA 指令时，先按照 14bit 精度对 $N_C$ 个元素进行累加，当达到 $N_C$ 时，作者将结果复制到 CUDA core 的 FP32 寄存器中，在 FP32 精度下完成累加。过程如上图右图所示
Mantissa over exponents. 与之前的工作不同，作者使用了 E4M3 的数据格式来达到更高的精度
Online Quantization. 为了降低 quantization 的误差，作者实时计算了 activation block 以及 weight block 的最大绝对值来导出 scaling factor 并量化为 FP8 精度

Low Precision Storage and Communication

作者通过压缩 cached activation 和 optimizer states 来进一步减少内存访问以及通信访问次数

Low-precision optimizer states: 对于 optimizer states, 作者使用了 BF16 数据格式来保存 AdamW 的优化器的一阶和二阶动量，但是对于 master weight 和 gradients 作者仍然使用了 FP32 来保证训练的数值稳定性
Low-Precision Activation: 对于 linear operator, 作者将其 cache activation 使用 FP8 格式进行存储，对于 attention 的输出，作者使用了 E5M6 数据格式来存储 activations, 这些 activations 的 tile size 为 $1\times 128$, 作者还是用了 2 的幂次作为 scale factor 来减少 quantizationerror; 对于 SwiGLU, 作者将其输入也保存为 FP8 的数据格式来降低内存消耗
Low-Precision Communication: 在 MoE up-projection 之前，作者将 attention 的输出量化为 FP8 数据格式再执行 dispatch 操作，这样可以降低通信开销。在反向传播的时候同理，先进行 FP8 量化，然后再进行反向 dispatch. 对于 combine 阶段，为了避免精度损失，作者还是使用了 BF16 数据格式

作者对比了 FP8 和 BF16 精度训练，结果如下图所示

实验结果显示，FP8 混合精度训练的损失降低不足 $0.25\%$.

Inference and Deployment

作者在 H800 集群上部署 DeepSeek-V3, 作者分别针对 prefilling 和 decoding 两个阶段进行了优化

Prefilling

prefilling 阶段在 4 节点 32 GPU 上进行，并行策略如下

模块	并行策略	说明
Dense MLP	1-wat TP	减少 TP 通信
Attention	4-way TP, SP, 8-way DP	SP 用于长文本处理
MoE	32-way EP	每个 GPU 包含 8 个专家

为了实现负载均衡，作者提出了redundant experts的策略，具体就是将负载比较高的专家进行复制。模型会周期性进行统计，然后计算出负载比较高的专家，接下来每个 GPU 除了原来的 8 个专家之外，还会 host 一个额外的 redundant expert.

为了提高 throughput, 作者同时处理两个 micro-batch, 来重叠 attention, MoE 和 dispatch, combine 通信，如下图所示

作者还探索了 dynamic redundancy 策略，即每个 GPU host 更多的专家（比如 16 个）然后 inference 的每一步仅激活其中的 9 个，在进行 all-to-all operation 时，作者首先进行 global optimal routing 来计算最合适的专家。作者认为 prefilling 计算量很大，因此 routing 的计算量可以忽略不计

Decoding

在 decoding 阶段，作者在 40 个节点 320 GPU 上进行部署，并行策略如下

模块	并行策略	说明
Attention	4-way TP, SP, 80-way DP	SP 用于长文本处理
MoE	320-way EP	每个 GPU 包含 8 个专家

这个阶段，每个 GPU 只 host 一个专家，64 个 GPU 负责 host redundant expert 以及 shared expert. 作者通过在 IB 上直接进行 P2P 的传输来降低通信的开销，作者还是用了 IBGDA 来进一步最小化 latency 以及提高通信效率

在这个阶段，attention 的计算占据了大部分时间，因此，作者采取了如下的 overlap 策略

由于 decoding 阶段一般 batch size 比较小，因此整个 decoding 的瓶颈在于 memory access, 因此为了避免影响 attention 的计算效率，作者仅安排一小部分 SM 用于 dispatch-MoE-combine.

Suggestions on Hardware Design

Communication Hardware

尽管作者将计算与通信重叠来提高训练效率，但是已有的通信仍然依赖于 SM, 这样限制了计算的效率。作者希望工能够构建专门针对通信的设备，另一方面，作者希望统一 IB 和 NVLink 来降低实现难度

Computation Hardware

提升 FP8 GEMM 的累加精度，当前精度只有 14bit, 作者希望能够在 GPU 设计上进行改进，将这个精度提升到 34-bit
支持 tile 以及 block 层面的 quantization, 尽管前文作者已经设计出了改进的算法，但是 Tensor Core 以及 CUDA 之前平凡的数据移动降低了计算效率，作者希望未来能够支持细粒度的 quantization
online quantization, 作者希望将 FP8 cast 以及 TMA 结合在一起，从而 quantization 可以在传输的时候完成计算，减少了内存读写。作者还建议使用 warp-level cast instruction
Transposed GEMM operations. 本文中，矩阵被切分为不同的 tiles, 在计算的时候需要先加载这些 tiles 然后进行 dequantization, transpose 等操作，作者希望未来能够直接支持 transposed reads of matrices

Pre-training

Pre-training Data

相比于 DeepSeek-V2, DeepSeek-V3 提升了数学和代码数据的比例，以及增加了多语种数据。最终训练数据一共包括 14.8T

作者还使用了 DeepSeekCoder-V2 里应用的 Fill in the middle 策略来让模型基于上下文越策中间的文本，对应的数据格式如下

1

<|fim_begin|>f_pre<|fim_hole|>f_suf<|fim_hole|>f_middle<|fim_end|>

这个结构与 sequence packing 结合在一起。

Tokenizer 基于 BBPE, 大小为 128K tokens. 在训练时，作者将随机一部分 combine token 进行切分来减少 token boundary bias 问题

Hyper-parameters

模型参数如下表所示，最终 DeepSeek-V3 拥有 671B 总参数，激活参数为 37B

variable	notation	value
layers	$\ell$	61
dense layers	-	3
hidden dimension	$d$	7168
num of attention heads	$n_h$	128
head dimension	$d_h$	128
KV compression dimension	$d_c$	512
query compression dimension	$d_c'$	1536
decouple query and key dimension	$d_h^R$	64
routed expert	$N_r$	256
shared expert	$N_s$	1
MoE hidden dimension	$d_{MoE}$	2048
activated experts	$K$	8
limited node routing	$M$	4
MTP depth	$D$	1

训练时，作者使用了 learning rate scheduling, batch size scheduling 等方法。对于 PP, routed expert 会均匀分布为 8node 对应的 64 个 GPU 上，预训练时模型的上下文长度为 4k

Long Context Extension

作者使用了 YARN 来扩展模型的上下文长度，模型上下文长度经过两个额外的训练阶段从 4K 扩展到 32K 再扩展到 128K, 均训练了 1000 步。

YARN 配置与 DeepSeek-V2 基本一致，在额外的 decoupled query and key 上作者没有应用这一点。参数配置如下表

parameter	$s$	$\alpha$	$\beta$	$\sqrt{t}$
value	40	1	32	$0.1\ln s+1$

第一阶段的上下文长度为 32K, batch size 为 1920, 第二个阶段的上下文长度为 128K, batch size 为 480.

Performance

DeepSeek-V3 base 的表现下图所示，作者对比了 DeepSeek-V2, Qwen2.5, LLaMA 3.1

Discussion

作者首先验证了 MTP 的有效性，结果如下图所示

可以看到，在模型架构相同，训练数据相同的情况下，1-MTP 的效果超过了 baseline 的表现，说明了 MTP 策略的有效性

接下来，作者还验证了 Loss-Free Balancing 的有效性，结果如下图所示

可以看到，loss-free Balancing 的效果比 loss balancing 的效果更好

接下来，作者对比了 loss-free balancing 和 sequence-wise auxiliary loss, 即 batch-wise v.s. sequence-wise. 作者认为，前者的约束更灵活，因为其不要求 in-domain balance. 作者在测试集上进行可视化，结果如下图所示

实验结果发现，loss-free 策略对应的 expert specialization 更强。作者进一步设计了一个 batch-wise auxiliary loss 来实现 batch-wise load balance, 结果发现，这种策略也能达到和 loss-free balancing 一样的效果，这说明了 batch-wise load balancing 效果更好

最后，作者提了两点 loss-free 策略的问题：

在特定的 sequence 或者小 batch 里出现负载不均衡。作者通通过增大 batch size 来解决这个问题
在推理阶段因为 domain-shift 导致的负载不均衡。作者实现了一个基于 redundant expert 的推理框架来解决这个问题

Post-training

SFT

post-training 包含 1.5M 样本，数据包括 reasoning 数据以及 non-reasoning 数据，前者由 DeepSeek-R1 合成，后者由 DeepSeek-V2.5 合成

SFT 时，作者训练了两个 epoch, 使用了 sequence packing 技巧

RL

Reward model 包含 rule-based reward model 和 model-based reward model.

RL 训练使用的算法为 GRPO

Post-training Performance

Post-training Discussion

作者首先探究了 Distillation 对模型表现的影响，作者使用 DeepSeek-R1 来蒸馏 DeepSeek-V2.5, 结果如下图所示

Model	LiveCodeBench-CoT		MATH-500
	Pass@1	Length	Pass@1	Length
DeepSeek-V2.5 Baseline	31.1	718	74.6	769
DeepSeek-V2.5 +R1 Distill	37.4	783	83.2	1510

可以看到，distillation 可以显著提高模型的表现。但是其问题在于也会让模型输出的长度增加。作者认为知识蒸馏是 post-training optimization 的一个重要方向。

接下来，作者讨论了 self-rewarding, 具体做法就是使用 DeepSeek-V3 来对评估结果进行投票，结果发现最终的效果很好，作者认为 LLM 可以很好地将非结构化信息转换为 rewards.

最后，作者讨论了 MTP. MTP 可以于 speculative decoding 结合，进一步提高 decoding 的速度。通过实验作者发现，second token prediction 的接受率在 $85\%\sim 90\%$ 之间，说明了其有效性。

Conclusion

在本文中，作者提出了 DeepSeek-V3, 一个 671B-A37B 的 MoE 大语言模型，训练 token 数为 14.8T. 作者使用了 loss-free-balancing strategy 来实现负载均衡。训练时作者使用了 FP8 混合精度。评估发现 DeepSeek-V3 的达到了 SOTA 表现。

作者认为，DeepSeek-V3 model size 太大，不适合部署。第二，部署策略需要进一步改进。

最后，作者认为未来工作有以下几点：

改进模型架构，进一步提高训练以及推理效率，扩展模型的上下文
提升训练数据的数量和质量
提高模型的 reasoning 能力
更详尽的评估

References

Arxiv

Notes on Keye-VL 1.5

Thu, 11 Sep 2025 11:33:31 +0800

快手提出了 Keye-VL 1.5, 一个强调 reasoning, video understanding 的 8B 多模态大模型。作者提出了 slow-fast video encoding strategy 来提高模型的视频理解能力，作者通过在预训练和后训练提高了模型的长上下文能力和 reasoning 能力

Introduction

作者回顾了多模态大模型的进展，然后提到视频理解能力仍然是一个挑战。为了解决这个问题，作者提出了 Keye-VL-1.5, 一个 8B 的视频理解多模态大模型。

Keye-VL-1.5 主要做了三点改进：

在架构上，使用了 Slow-Fast Video Encoding
在预训练阶段，使用多个 stage 来提升模型的长上下文能力
在 post-training 阶段，提高模型的 reasoning 能力和 alignment 表现

Method

Architecture

Keye-VL 1.5 的架构与 Keye-VL 一致。

Keye-VL 1.5 主要做出的改进点为针对视频的 encoding 方式

作者回顾了已有 MLLM 处理视频的方式，比如 Qwen2.5-VL 使用 3D convolution 来 merge 相邻的两帧，Seed1.5-VL 采用了 Dynamic Frame-Resolution Sampling 技巧，来根据 budget 和处理的任务来动态调整采样率 (frame) 和每一帧的图片精度 (resolution)。

但是这些方法很难进行泛化。因此，作者在本文中就提出了 SlowFast video encoding stratrgy:

Slow Pathway: 空间信息丰富（high resolution），时间信息简略 (low number of frames)
Fast Pathway: 时间信息丰富（high number of frames），空间信息简略 (low resolution)

为了区分 slow/fast frames, 作者提出了一个基于 patch similarity 的 metric:

第一帧始终定义为 slow frame
接下来的每一帧，如果其和上一帧的相似度超过 $95\%$, 则定义为 fast frame; 反之则定义为 slow frame.

得到 slow/fast frames 之后，作者将 fast-frame 的 token budget 限制为 slow frame token budget 的 $30\%$ 来平衡时间信息以及空间信息。接下来，作者使用二分搜索来决定 slow frame 的 token budget. 为了区分 slow frame 和 fast frame 的 token, 作者使用了特殊的 token 来进行分离。

最终的处理结果如下图所示

Pre-training

预训练的数据和 Keye-VL 基本一致，我们主要介绍改进的点

对于 Image caption 数据，作者认为这批数据可能会损害模型的指令跟随和 reasoning 能力，因此作者对数据进行了增广，主要是调整了数据的格式：

QA, 数据格式为 <image, caption, [eos], question, answer>
reverse QA, 数据格式为 <image, question, answer, [eos], caption>
instruction following: 随机给一批数据作为输入，然后让模型基于特定 image 输出 caption

作者还构建了一个 trap question 来提高模型的 robustness 以及 faithfulness.

OCR 数据在 Keye-VL 的基础上加入了两点：

Structured Document and Code Understanding: 基于 markdown 和 HTML 等数据来获取 code OCR 数据
Instruction Following OCR: 基于特定指令进行 OCR

对于 grounding 数据，作者进一步加入了 temporal grounding 数据，作者首先使用 TEMPURA

来将短视频分割成若干个 video clips. 然后作者使用 SOTA MLLM 来过滤数据，最后作者基于 Gemini2.5 来生成对应的 QA.

预训练和 Keye-VL 一样，包含 3 个 stage

前两个 stage，作者将模型的上下文限制为 8K, 使用了 DP 和 Zero-2 来减少内存开销。在 stage 3, 作者将模型的上下文从 8K 扩展到 128K, 对应的 base frequency 从 1M 提升到 8M. 训练数据包括长视频，长文本和大规模图片。作者将优化策略调整为 Zero-1, CP 和 PP 来支持 long-context 的训练。训练时数据分布为 video:images:text=24:50:26.

Post-training

SFT 阶段使用了 7.5M 多模态 QA 样本进行训练。

MPO 阶段的数据相比 Keye-VL 有所减少，包含：

250K 开源样本
150K 纯文本数据
26K 人类标注数据

对于 reward model 的训练，作者使用了 SFT 和 RL 两个阶段。SFT 阶段的数据包括 R1-Reward 和 MMPR, 训练之后作者还是用比较短的 good response 来避免产生较长的回答

在 SFT 和 MPO 阶段之后，作者使用 LongCoT code-start 初步激活模型的 reasoning 能力。

作者构建了一个 5 部的自动化数据生成 pipeline, 如下图所示

步骤如下：

Multi-Source Data Collection and Enhancement：收集数据
Multi-Path Reasoning Generation with Confidence Quantification: 基于 confidence 来挑选数据
Comprehensive Two-Level Quality Assessment: 基于答案和过程的正确性来提高数据质量
Human-in-the-Loop Quality Enhancement: 对于中等质量的数据请人类进一步进行标注
Dynamic Quality Scoring and Data Utilization Strategy: 对数据进行打分，高质量数据进行上采样

接下来就是 General RL 过程。

对于通用的 RLVR 训练，作者使用了 GSPO 算法来进行训练。

在训练过程中，作者采取了 progressive hint sampling 方式，也就是提供不同程度的 hint 来提高模型的训练效率。作者将 hint 分为五个等级：

Level 1 (Concept / Observation)
Level 2 (Strategy / Method)
Level 3 (Tools / Formula)
Level 4 (Steps / Calculation)
Level 5 (Complete Solution)

来提供不同程度的辅助，作者使用 Keye-VL 1.5 来确定最小的 hint level, 然后基于这个 level 提供信息进行 RL 的训练

为了进一步提高模型的表现，作者采用了一个和 Seed1.5-VL 一样的迭代式训练策略，即反复进行 SFT 和 RL 来降低训练成本，提高训练效率。

最后，再通用 RL 阶段之后，作者加入了 alignment RL 的训练来进行对齐，reward 包括三个方面：

rule-based reward
generative reward
model-based reward

任务主要包括三个方面：

instruction following
format adherence
preference alignment

数据介绍如下：

instruction following:25 类硬约束，20 类软约束，数据包括 17K 多模态数据和 23K 纯文本数据，奖励包括 rule-based reward 和 generative reward
reasoning: 12K 数学和逻辑推理数据
RAG: 提高模型的搜索能力，作者使用 GSPO 算法进行训练

Experiments

模型表现如下

接下来作者进行了消融实验。

首先是不同训练阶段对模型表现的影响，如下图所示

实验结果显示，提高 SFT 训练数据可以有效提高模型在数学推理，逻辑推理和 OCR 任务上的表现。MPO 可以进一步提高模型的表现，Long CoT cold start 可以有效提高模型的 reasoning 表现。

作者还探究了 model merging 对模型表现的影响，作者首先基于 base model 和 OCR 数据训练得到 OCR expert, 然后进行 merge, 实验结果如下

实验结果显示，model merging 可以有效提高模型在 special domain 上的表现，并且还可以维持模型的通用能力

作者还发现：

expert model 训练时间过长会影响最终 merge model 的表现
expert mode 训练的学习率应该要设置比较小

接下来，作者探究了 alignment RL 对模型表现的影响，

实验结果说明，alignment RL 可以在保持模型 reasoning 能力的同时提高模型的指令跟随能力

作者还探究了 hint 对模型表现的影响，使用不同 level hint 进行训练对模型表现影响的结果如下图所示

实验结果显示，使用 high level 的 hint 可以有效提高模型输出的正确率。

最后作者探究了 rejection sampling 对模型表现的影响，实验结果如下图所示

结果发现，通过 rejection sampling，模型的表现有了进一步的提升。因此作者采用了 ST-RL-(RFT-SFT)-(RFT-RL) 的训练方式来进行训练

Conclusion

作者在本文中提出了 Keye-VL1.5, 一个强调 video understanding 和 reasoning 的 MLLM. Keye-VL 1.5 使用了 SlowFast video encoding strategy 来提高模型的效率和视频理解能力。作者详细介绍了模型的数据，训练和评估。

References

arxiv

Notes on InternVL3.5

Mon, 01 Sep 2025 11:30:50 +0800

上海 AI LAB 提出了 InternVL 3.5 系列多模态大模型，InternVL 3.5 主要强调了模型的 reasoning 能力以及 inference 效率。

Introduction

作者首先介绍了已有多模态大模型的进展，然后提到有两个未解决的问题：

如何构建一个 stable, effective, scalable 的 RL 框架来训练 MLLM
如何降低 MLLM 在长上下文场景下的计算开销过高的问题

为了解决这两个问题，作者提出了 InternVL3.5 多模态大模型系列，相比于 InternVL3, 模型在 reasoning 能力和 efficiency 上均进行了提升。作者主要通过 Cascade RL 框架来提高模型的 reasoning 表现，以及使用 Visual Resolution Router (ViR) 和 Decoupled Vision Language Deployment (DvD) 来提高模型的推理效率。

总结起来，InternVL3.5 模型的贡献如下：

开源了 InternVL3.5 系列多模态大模型，模型拥有先进的 reasoning 能力以及推理效率
提出了 Cascade RL, ViR 以及 DvD 等模块来提高模型的表现/推理效率
系统性评估了模型的表现

Method

Architecture

InternVL3.5 的架构与 InternVL3 的架构基本一致，包括一个 ViT, 一个 MLP 和一个 LLM, 模型的架构如下图所示

模型配置如下表所示

InternVl3.5 延续了 InternVL 系列的做法，即 20B 以下的模型使用 InternViT-300M, 20B 以上的模型使用 InternViT-6B 作为 Visual encoder. 大语言模型基于 Qwen3 和 gpt-oss.

在 InternVL3.5 的基础上，作者还构建了 InternVL3.5-Flash 模型，InternVL3.5-Flash 不同的地方在于，其在 MLP 之前加入了一个 Visual Resolution Router (ViR) 模块，来处理不同分辨率的图片。在 InternVL3.5 中，每个 image patch 由 1024 个视觉 token 来表示，然后通过 pixel shuffle 压缩至 256 个。在 InternVL3.5-Flash 中，ViR 首先会判断每个 patch 的 semantic richness, 然后基于 semantic richness 来将对应的 token 路由到不同的 pixel shuffle 模块中，最高可以将视觉 token 压缩到 64 个，这样就可以大幅度提高模型的推理效率。

Pre-training

Pre-training 使用 next-token-prediction loss 来更新模型权重，给定多模态 sequence $x=(x_1,\dots,x_L)$, 损失函数定义为

$$ \mathcal{L}(\theta) = -\sum_{x_i\text{ is text token}} \log p_{\theta}(x_i \mid x_1,\dots,x_{i-1}) $$

与 InternVL2.5 一样，作者还对不同长度的 sequence 进行了加权，避免模型产生 bias, 加权后的 loss 为

$$ \mathcal{L}(\theta) = -\sum_{x_i\text{ is text token}}\frac{w_i}{\sum_j w_j} \log p_{\theta}(x_i \mid x_1,\dots,x_{i-1}),\quad w_i = \frac{1}{N^{0.5}} $$

其中 $N$ 是训练样本中需要计算损失的 token 个数。

训练数据蛀牙包含两部分：

多模态数据，这部分数据基于 InternVL3
纯文本数据，基于 InternLM 系列和开源的数据集

最终，预训练数据一共包含116M 样本，250B token. 纯文本数据和多模态数据的比例为 $1:2.5$. 模型上下文长度为 $32K$.

Post-training

Post-training 包含三个阶段：

SFT：使用高质量对话数据提高模型表现
Cascade RL: 提高模型的 reasoning 能力
Visual Consistency Learning: 训练 ViR 模块，提高模型处理动态分辨率图片的能力

训练 pipeline 如下图所示

SFT 阶段的训练数据包括三个方面：

InternVL3 的指令跟随数据
多模态 reasoning 数据
能力扩展数据，包括 GUI 交互，具身交互以及 SVG 理解与生成的数据

Cascade RL 阶段结合了 offline RL 和 online RL 的优点。基本思想是先使用 offline RL 来提高模型的能力，降低训练成本。然后再使用 online RL 进一步提高模型的 reasoning 表现。

offline RL 阶段使用的是 InternVL-MPO 算法，其损失函数为

$$ \mathcal{L}_{MPO} = w_p\mathcal{L}_p+w_q\mathcal{L}_q+w_g\mathcal{L}_g $$

其中，$\mathcal{L}_p$ 为 DPO 的损失函数，$\mathcal{L}_q$ 为 Quality loss, $\mathcal{L}_g$ 为 SFT 使用的 next-token-prediction loss.

online RL 阶段使用的是 GSPO 算法，核心思想是在 sample 层面做归一化。这个阶段的目的是进一步提高模型的表现。

Cascade RL 的优势在于：

训练更稳定：offline RL 可以避免模型产生 reward hacking 现象，online RL 阶段可以进一步提高模型的表现
训练效率更高：offline RL 可以有效提高采样效率
表现更好：先 MPO 再 RL 可以达到更好的表现

Visual Consistency Learning (ViCO) 的目的是降低 InternVL3.5 的推理开销。这个阶段主要训练 ViR 模块

ViCO 包括两个 stage:

Stage 1: Consistency training

这一阶段的目的是使得不同压缩率处理的视觉 token 对应的输出与 ground truth 尽可能一致，作者使用另外一个 InternVL3.5 模型作为 reference model, 然后损失函数为

$$ \mathcal{L}_{ViCO} = \mathbb{E}_{\xi\sim\mathcal{R}}\left[\frac{1}{N}\sum_{i=1}^N\mathrm{KL}\left(\pi_{\mathrm{ref}}(y_i\mid y_{$\xi\in\{1/4,1/16\}$ 为 compression rate, 训练是随机采样。$\xi=1/4$ 代表最终会有 256 个视觉 token, $\xi=1/16$ 代表最终会有 64 个 token.

Stage 2: Router training

这个阶段的目的是训练 ViR 来选取合适的精度/压缩率。ViR 此时作为一个 binary classifier 来进行训练，训练的损失函数为 cross-entropy loss. 模型其他部分参数冻结，仅训练 ViR 模块，首先，我们将计算压缩 16 倍后的损失与压缩 4 倍的损失的比例

$$ r_i = \frac{\mathcal{L}_{ViCO}(y_i\mid I_{1/16})}{\mathcal{L}_{ViCO}(y_i\mid I_{1/4})} $$

该比例衡量了压缩 token 之后带来的性能下降程度，接下来，作者设定了一个阈值 $\tau$, 当性能下降超过阈值 $\tau$, 则认为应该使用高精度，也就是 $\xi=1/4$, 反之则说明不需要过度视觉 token, 可以使用低精度，也就是 $\xi=1/16$. 总结得到

$$ y_i^{router} = \begin{cases} 0, &r_i<\tau\\ 1, &r_i>\tau \end{cases} $$

训练时，作者基于 sliding window 中的 $r_i$ 来动态调整 $\tau$ 的值。

post-training 的训练数据如下：

SFT 训练数据包括56M 样本，130B token, 纯文本数据与多模态数据的比例为 $1:3.5$.
Cascade RL 的训练数据主要基于 MMPR, 包含 200K 左右的样本，通过过滤最终得到70K左右的样本。online RL 同样使用这批数据进行训练
ViCO 的训练数据与 SFT 阶段的训练数据一致。主要是 OCR 以及 VQA 数据

Test-time Scaling

test time scaling 主要基于两个方面：

deep thinking: 就是 reasoning mode
parallel thinking: 基于 VisualPRM 进行多次采样，然后基于 BoN 策略得到最终的输出。

Infra

模型使用 XTuner 框架进行训练，使用了包括 FSDP, data packing, FP8, flashattention3 等策略。

作者还提出了 DvD 的策略来提高推理效率，核心思想就是将 ViT-MLP 模块放在一个 server 上，然后将 LLM 放在另一个 server 上，这样就也可以提高整体的通信效率。框架示意图如下所示

Experiments

模型整体表现如下图所示

Ablation Study

作者首先探究了 Cascade RL 对模型表现的影响

实验结果显示，SFT, MPO 和 offline RL 每个阶段都可以提高模型的多模态 reasoning 表现。

作者进一步探究了不同阶段的投入产出比，也就是训练时间与最终模型表现的变化情况，如下表所示

实验结果显示，尽管 GSPO 的效果提升比较明显，但是训练所需要的时间比较长。如果先 MPO 再进行 GSPO 的话，我们可以在较短的时间里取得较好的表现。

接下来，作者探究了 ViR 的有效性和效率。作者首先对比了 InternVL3.5 以及 InternVL3.5-flash 的表现。结果显示，大部分情况下，这两个模型的表现没有较大差距。说明 ViR 不会损害模型的性能。

作者进一步探究了 ViR 和 DvD 对提升模型效率的影响，实验结果如下图所示

实验结果说明，对于高精度图片输入，DvD 和 ViR 均可以提高模型的推理效率。

Conclusion

在本文中，作者提出了 InternVL3.5 系列多模态大模型，作者提出了 Cascade RL 框架，该框架结合了 offline RL 以及 online RL 来提高模型的 reasoning 表现以及训练效率。作者还提出了 ViR 以及 DvD 模块来提高模型处理高分辨率图片的效率。

References

Arxiv

Notes on GLM-4.5

Wed, 13 Aug 2025 12:27:48 +0800

智谱 AI 提出了 GLM4.5, 包含 GLM4.5 和 GLM-4.5-Air,两个 MoE LLM. 模型大小分别为 355B-A22B 和 106B-A12B, GLM4.5 主要关注 agentic, reasoning 以及 coding 三个领域。

Introduction

作者认为，通用模型有三个关键能力，即 ARC：

Agent: 与外部工具以及真实世界进行交互
Reasoning: 解决数学和科学领域的复杂问题
Coding: 解决真实世界软件工程相关问题

已有的商业模型如 o1/o3, Claude Sonnet 4 已经在 ARC 上达到了非常好的表现，但是开源模型仍然比较稀缺

基于这个目标，作者就提出了 GLM4.5 和 GLM-4.5-Air, 来统一完成三个不同的目标。

Method

Pre-training

Architecture

GLM-4.5 是一个基于 MoE 架构的 LLM, 架构与 DeepSeek-MoE 相似，作者做了如下几点改变：

在 MoE layer 中，使用了 loss-free balance routing, 然后使用了 sigmoid function 作为 routing score 的 normalization.
与 Kimi-k2 和 DeepSeek-V3 相比，作者降低了 head dimension, 提升了 number of layers. 作者认为更深的模型更有利于提高模型的 Reasoning 表现
attention 上，作者使用了 GQA, 对于 #RoPE, 作者使用了 partial RoPE, 只旋转每个 token 的前半部分，作者还将 attention heads 的个数增加到了 2.5 倍，作者发现增加 attention heads 可以提高模型的 Reasoning 表现
作者还使用了 QK-Norm 来防止 attention logits 爆炸
作者还使用了一个 MoE layer 作为 MTP layer 来支持 speculative decoding.

模型与 DeepSeek-V3 和 Kimi-k2 的对比如下

Model	GLM-4.5	GLM-4.5-Air	Step 3	Kimi K2
Date	2025/8/8	2025/8/8	2025/7/25	2025/7/28
# Total Parameters	355B	106B	316B	1043B
# Activated Parameters	32B	12B	38B	32B
# Dense Layers	3	1	5	1
# MoE Layers	89	45	56	60
# MTP Layers	1	1	0	0
Hidden Dim	5120	4096	7168	7168
Dense Intermediate Dim	12288	10944	18432	18432
MoE Intermediate Dim	1536	1408	5120	2048
Attention	GQA	GQA	MFA	MLA
Attention Head Dim	128	128	256	192
# Attention Heads	96	96	64	64
# Key-Value Heads	8	8	1	64
scoring	sigmoid	sigmoid	softmax	softmax
# Experts (total)	160	128	48	384
# Experts Active Per Token	8	8	3	8
# Shared Experts	1	1	1	1
QK-Norm	Yes	No	No	No

Pre-training Data

预训练数据包括四个方面

Web: 过滤低质量数据和使用模版产生的数据
Multilingual: 基于 webpages 和 Fineweb-2
Code: 基于 GitHub 和其他代码平台，作者使用了 [[Fill in the middle]] 来训练模型。
Math & Scirence: 训练一个 classifier 来给数据进行打分。

最终，预训练数据一共包括 23T token.

Pre-training Recipe

预训练包括 2 个阶段:

Pre-training: 使用网页数据进行训练
Mid-training: 加入 code, math, science 数据进行训练，在这个阶段，作者使用了 repo-level 的 code 数据，合成的 reasoning 数据以及长上下文数据。作者将模型上下文从 4K 扩展到 32K，然后在扩展到 128K.

作者在 pre-training 的时候使用了 random truncation, 在 mid-training 的时候使用了 best-fit packing 技巧

训练时，与 Kimi-k2 一样，作者使用了 Muon 作为优化器。作者使用了 cosine decay schedule. batch size 从 16M token 到 64M token.

Post-training

Post-training 分为两个阶段：

Stage 1, Expert Training. 构建 agent, reasoning, General chat 三个 domain 的专家模型
Stage 2, Unified Training. 使用 self-distillation 来汇总多个模型的能力

训练框架如下图所示

SFT

两个 stage 都由 SFT 开始，

在 Stage 1 里，SFT 的目标是让 expert model 掌握初步的 chat, reasoning 以及 tool-use 的能力。作者使用了一小部分包含 CoT 的 SFT 数据进行训练
在 Stage 2 中，SFT 的目标是将不同的 expert model 蒸馏到一个模型中，作者使用了百万级的数据，包含 reasoning 任务和通用的 chat 数据，来训练模型的 hybrid reasoning 能力

在训练模型的 tool-use 能力是，作者发现，function call 在 code 场景下会出现混淆，提高了模型的学习成本。因此，作者的解决方法是使用了类似 XML 的 special token tags

Recall 与之相反，Kimi-K2 认为模板应该尽可能简洁，因此 Kimi 采取了 TypeScript 作为 function call 的语言

从专家模型进行采样是，作者进行了数据过滤。还对数据进行了分级结果发现，使用难题进行训练可以提升模型 $2\%\sim4\%$ 的表现，多次采样也可以提高模型的表现

Agentic SFT 数据的构建包括四个步骤：

Agentic Framework and Tool Collection: 收集 MCP 和 tool API
Task Synthesis: 合成不同的 agentic 任务
Trajectory Generation: 采样生成的 rollout
Quality Filtering: 过滤低质量的数据

RL

Reasoning RL

这个阶段使用了 GRPO 算法进行训练，与 DAPO 一样，作者去除了损失函数中的 KL divergence。

首先，作者探究了课程学习对模型表现的影响，结果发现，课程学习可以有效提高模型的性能。因此，作者构建了一个 2 阶段的课程学习框架。实验结果如下图所示

可以看到，在第二个阶段，模型可以进一步通过更难的题目获得提升。

其次，作者探究了以下渐进式扩展模型上下文对模型表现的影响。DeepScaleR 认为，逐步提高模型的上下文长度，可以有效提高模型的表现。但是，本文确认为这种方法会损害模型的性能，原因在于，模型在 SFT 阶段的上下文长度就是 64K, 如果我们降低模型的上下文长度，这会导致训练数据分布不一致，从而影响模型的长上下文表现。因此作者直接在 64K 的上下文上进行训练。

接下来，作者探究了以下采样温度对模型表现的影响，温度太低会导致模型探索能力下降，太高的话会导致输出质量下降。因此作者动态调整采样温度来平衡模型的性能以及探索能力。

[!tip] Kimi-K2 认为随着 RL 训练的进行，我们应该逐步降低采样温度来稳定模型的表现

最后，作者分析了以下 code 以及 Science RL 中的一些问题。对于 code RL, 作者发现，我们应该在 sequence 层面而不是 token 层面进行平均。对于 Science RL, 作者强调了高质量数据的重要性。实验结果如下图所示

Agent RL

作者主要关注 web-search 以及 code generation 两个任务。对于 web-search, 作者构建了一个数据合成 pipeline, 用于生成 multi-step reasoning 的 QA 数据。构建过程包括基于知识图谱的 multi-hop reasoning 和 human-in-the-loop 的内容提取。对于 code generation, 作者基于 GitHub 的 PR 以及 issues 构建了 benchmark

RL 的训练目标如下

$$ \mathcal{L}(\theta) = \mathbb{E}_{x\sim\mathcal{D}}\left[\frac1K\sum_{i=1}^K(r(x,y_i) - \bar{r}(x))\right] $$

其中 $(x,y_i)$ 是基于 $\pi_{\mathrm{old}}$ 采样的 trace, $\bar{r}(x) = 1/k\sum_{i=1}^Kr(x,y_i)$ 是平均的 reward. 计算损失时，只有模型的回答参与计算。

作者发现，通过训练模型的 web-search 以及 code generation 能分，模型在 tool-use 以及 coding 任务上的表现也有了提升。作者还是用了 format penalty 来保证模型输出格式的正确性。如果格式不对的话，模型获得的奖励是 0

Recall 在 GLM-4.V-Thinking 中，作者认为应该在 cold-start SFT 阶段让模型学会格式要求，而不是在 RL 阶段加入 format reward

由于 agent RL 的训练比较耗时，为了提高训练效率。作者首先基于 SFT 模型进行 agent RL 训练，训练到一定步数之后，作者使用 self-distillation 来将能力蒸馏回 SFT model, 接下来再基于 Self-distillation 后的 SFT 模型来进行 agent RL 训练

Recall Seed1.5-VL 和 LlaMA3.2 都提到了使用 multi-round SFT-RL 的形式来提高模型的表现

作者还发现，随着交互轮数的提升，模型的表现也有相应提升。实验结果如下图所示

General RL

General RL 用于提高模型的整体表现，解决潜在的问题以及提升关键能力，作者主要使用了 RLHF 和 RLAIF 两种方法

对于 Holistic RL, 作者收集了 5000 条 prompt, reward 基于人类反馈和 AI 反馈。人类反馈用于训练一个 reward model, 对于 AI 反馈，作者构建了 scoring rubrics. 然后作者将两种反馈结合在一起

对于 Instruction following RL, 作者构建了基于规则的奖励，reward model 的奖励以及 critical model 的奖励。实验结果显示，这种奖励方式可以有效降低模型的 reward hacking

对于 function calling RL, 作者使用了 step-wise rule-based RL 来提高模型表现。对于 end-to-end multi-turn RL, 作者训练了一个 expert model 来蒸馏专家到模型。

最后，对于 Pathology RL, 作者希望通过 RL 来解决潜在的问题，比如语言混合输出，重复输出以及格式错误等。作者构建了一批模型容易出错的数据，然后来训练模型。

Infra

作者针对不同任务分别构建了不同的 scheduling 模式：

对于通用 RL 任务，作者将 training engine 和 inference engine 放在一个 worker 来提高效率
对于 agentic RL 任务，作者将 training 和 inference engine 分开，来提高 data throughput

在训练时，作者使用了 BF16 精度，在推理时，作者使用了 FP8 精度来提高推理效率。

针对 agentic RL 任务，作者还进行了优化。与 Kimi-k2 类似，作者让 inference engine 持续产出 rollout, 然后让 training engine 来更新模型权重，最后同步到 inference engine 上

Experiments

整体表现如下图所示，GLm4.5 在 ARC benchmark 上的平均表现达到了第三名。

具体来看，

在 agentic benchmark 上, GLM4.5 仅次于 o3 的表现
在 coding benchmark 上，GLM4.5 次于 Claude Opus 4 和 Claude Sonnet 4, 排第三名
在通用能力上，GLM

人工对比 coding agent 能力的结果如下图所示

Conclusion

作者提出了 GLM4.5，一个基于 MoE 架构的大语言模型系列，包含 GLM4.5(355B-A22B) 和 GLM4.5-Air(106B-A12B) 两个模型，作者详细介绍了模型的架构，训练，数据和评估。

References

arxiv

Notes on Kimi-k2

Thu, 24 Jul 2025 10:56:50 +0800

Kimi-k2 是一个总参数为 1T, 激活参数为 32B 的 MoE 大语言模型，模型使用 15.5T token 进行训练，optimizer 使用了 MuonClip. 作者主要关注模型的 agent 能力

Introduction

作者首先强调现在 LLM 发展主要是 Agentic Intelligence, 也就是让模型自主感知，规划，思考和与环境交互。

基于这个目标，作者就提出了 Kimi K2, 一个 1.04T 总参数，32B 激活参数的 MoE 模型，用于解决实现 agent Intelligence 中遇到的问题。作者主要进行了三点改进：

MuonClip, 一个基于 Muon 的优化算法，来提高 Kimi K2 对 token 的利用效率以及提高训练的稳定性
大规模的 agentic 数据合成 pipeline: 作者构建了一个用于合成工具调用，agent 数据的 pipeline
通用的 RL 框架，作者将 RLVR 和 self-critic rubric reward mechanism 结合起来，用于提升模型的表现

Pre-training

Architecture

Kimi-K2 的架构与 DeepSeek-V3 相似，配置如下表所示

指标	DeepSeek-V3	Kimi K2	$\Delta$
# Layers	61	61	=
Total Parameters	$671\text{B}$	$1.04\text{T}$	$\uparrow 54\%$
Activated Parameters	$37\text{B}$	$32.6\text{B}$	$\downarrow 13\%$
Experts (total)	256	384	$\uparrow 50\%$
Experts Active per Token	8	8	=
Shared Experts	1	1	=
Attention Heads	128	64	$\downarrow 50\%$
Number of Dense Layers	3	1	$\downarrow 67\%$
Expert Grouping	Yes	No	-

与 DeepSeek-V3 相比，模型主要进行了以下改动：

作者认为提高专家的稀疏性，可以有效提高模型表现。因此作者将专家个数提升了 50%.
为了降低模型在 inference 阶段的算力开销，作者将 attention heads 的个数降低了 50%.

Sparsity Scaling Law 作者首先构建了基于 Muon 的 sparsity law, 这里 sparsity 定义为激活专家个数与总专家个数之比，即：

$$ \mathrm{sparsity} = \frac{\# \mathrm{activated\ experts}}{\# \mathrm{total\ experts}} $$

作者在小规模上的实验结果如下图所示

Observation 实验结果表明，在相同算力（激活专家个数）下，模型的表现随 sparsity 提高而增加。

但是，进一步提高 sparsity, 会让 infra 变的难以优化，因此在 Kimi-K2 里，将 sparsity 定义为 $48$.

Number of attention heads 作者还分析了探究了 attention heads 的最优配置。DeepSeek-V3 将 attention heads 的个数设置为 layers 层数的 2 倍，来提高带宽利用率以及提高计算效率。但是，当上下文长度增加之后，attention head 变成了 computational bound. 作者对比了不同配置模型的表现，实验结果如下：

Observation 实验结果表明，使用双倍 attention head 带来的收益是比较小的，只有 $0.5\%$ 到 $1.2\%$ 左右

因此，作者在 Kimi-K2 中，奖 attention head 的个数设置为 $64$.

Data

Kimi-K2 主要强调了 token efficiency, 即每个 token 对模型表现提升的贡献。token efficiency 越高，说明每个 token 对最终模型的贡献也就越高

相比于 Kimi-k1.5, Kimi-K2 使用了一个 rephrasing pipeline, 来提高高质量 token 的利用率，作者在 knowledge 和 mathematics domain 上进行了实验。

最终，Kimi-K2 的预训练数据包括了 15.5T token, 主要覆盖 Web text, code, mathmatics 以及 Knowledge 四个 domain. 大部分的数据处理与 Kimi-k1.5 相同。

Knowledge Data Rephrasing 作者构建了一个 synthetic rephrasing 框架来提高 knowledge token 的利用率，框架主要包含以下几个模块：

Style and perspective-diverse prompting: 作者构建了一系列 prompt, 来让 LLM 从多个角度和风格来重新表述原始文本
Chunk-wise auto-regressive generation: 为了保持模型在长文档中的 coherence 以及避免信息损失，作者使用了一个 chunk-based rewriting 策略，也就是对每个 chunk 分别进行改写，然后将它门汇总在一起
Fidelity verification: 作者对原始文本和改写文本进行了 fidelity 检查来保证语义的一致性。

作者对比了以下三个设置对模型在 SimpleQA benchmark 上表现的影响，这三个设置分别是：

原始数据集训练 10 epoch
改写数据一次，然后训练 10 epoch
改写数据一次，训练 1 epoch

实验结果如下表所示

# Rephrasings	# Epochs SimpleQA	Accuracy
0 (raw wiki-text)	10	23.76
1	10	27.39
10	1	28.94

可以看到，改写的策略可以有效提高模型在 SimpleQA benchmark 上的表现

Math Data Rephrasing 对于数学相关数据，作者基于 SwallowMath, 将数据改写成了学习笔记 (learning-note) 的风格。然后，作者还将其他语言的高质量文本翻译为英文。

Recall 个人认为，数据改写在一定程度上也算是合成数据，对于合成数据这一块，微软提出的 phi 系列是一个比较好的参考

MuonClip Optimizer

Kimi-K2 使用了 Muon optimizer, 之前的实验结果说明了在相同的 compute budget 下，Muon optimizer 的表现超过了 AdamW. 也就是说，Muon optimizer 更加高效。

但是，Muon optimizer 的问题是训练不稳定。为了解决这个问题，作者提出了 QK-clip, 一个 weight clipping 机制，来显示约束 attention logits. QK-clip 的机制是当输出的 logits 超过某一个阈值之后，就对齐进行截断。

每个 head 的 attention 的计算公式如下

$$ O = \mathrm{softmax}\left(\frac{QK^T}{\sqrt{d}}\right)V $$

其中, $d$ 是 hidden size, $Q, K,V$ 分别是 query, key, value, 定义如下：

$$ Q = XW_Q, K=XW_K, V=XW_V $$

这里 $W_Q,W_K,W_V$ 是模型可学习的参数。

作者定义每个 head 的 max logit 如下：

$$ S_{\max}^h = \frac{1}{\sqrt{d}} \max_{X\in\mathcal{B}}\max_{i,j} [QK^T]_{ij} $$

最简单的做法就是直接进行截断，也就是

$$ W_Q\gets \gamma^\alpha W_q, W_K\gets \gamma^{1-\alpha}W_K $$

其中 $\gamma=\min(1, \tau S_{\max})$, 这里 $S_{\max}=\max_h S_{\max}^h$ 是所有 head 对应 $S_{\max}^h$ 的最大值。

但是，实际中，作者发现只有少部分 head 会出现 logits 爆炸现象。为了提高计算效率，作者针对每个 head 单独进行 scaling, 也就是 $\gamma_{h}=\min(1, \tau S_{\max}^h)$. 对于 MLA 架构，作者仅在 unshared 模块使用 clipping:

$q^c$ 以及 $k^c$, scaling factor 为 $\sqrt{\gamma_h}$
$q^R$, scaling factor 为 $\gamma_h$

最后，作者将 Muon, weight decay, RMS matching 和 QK-clip 汇总在一起，得到 Kimi-k2 使用的 MuonClip optimizer, 算法如下所示：

接下来，作者对比了以下 Muon 和 MuonClip 两个优化器的表现，作者分别使用这两个优化器训练 53B-A9B 的 MoE 模型，实验结果如下

实验结果表明，Muon 优化器在 1000 步左右就出现了 logits 爆炸的现象，但是 MuonClip 通过优化可以避免这个问题。作者还发现，MuonClip 可以减少 loss spike 的产生，整体的 loss 变化情况如下图所示

作者还在附录中说明 QK-clip 并不影响最终的收敛性，并且，为了尽可能减少对模型训练的干扰，作者发现，仅在训练初期 QK-clip 被激活:

在初始的 70, 000 步里，有 12.7% 的 attention heads 至少触发了一次 QK-clip, 并且将它们的 $S_\max$ 降到了 100 以下
接下来的 70, 000 步里，QK-clip 就不再被激活

Infra

Kimi-k2 使用了 16-way 的 PP, 16-way 的 EP 以及 ZeRO-1 Data Parallelism. 具体流程如下

作者发现通过增加 warm-up mircro-batches, 我们可以有效重叠 EP 的 all-to-all communication 以及 computation. 但是，对于 [[DualPipe]], 其要求双倍的存储来保存参数和梯度，并且提高 PP 粒度会引入更多的 bubble, 因此 Kimi-K2 没有使用 DualPipe.

为了减少 [[1F1B]] 的 PP 通信开销，作者在反向传播的过程中同时进行 PP 通信，来进一步重合通信与计算。

作者还发现，使用更小的 EP group 可以提高整体的训练速度，因此作者将 EP 设置为 16.

作者发现，剩余的 GPU 内存不足以存放 MoE 的 activation, 因此作者采取了三个办法解决这个问题：

Selective recomputation: 作者对 LayerNorm, SwiGLU, MLA 的 up-projection 和 MoE 的 down-projections 等进行重新计算。
FP8 storage for insentive activations: 作者使用了 FP8 精度来存储 MoE up-projections 以及 SwiGLU. 作者发现使用 FP8 进行计算可能会导致性能下降，因此作者并没有使用 FP8 进行计算。
Activation CPU offload: 作者将其余的 activation 放在 CPU RAM 上，在 1F1B 的过程中，作者再进行加载

Training Recipe

模型上下文长度为 4096, 使用 MuonClip 进行优化，使用 WSD lr Scheduler.weight decay 为 0.1, global batch size 为 67M tokens.

预训练结束之后，作者加入了一个 long-context activation stage. 这个阶段，作者使用了 400B 的 4K 上下文的 token 和 60B 的 32K 上下文的 60B token. 最后作者使用 YARN 将模型上下文长度扩展到 128K.

Post-training

SFT

数据的构建主要是基于：

prompt 的多样性
Response 的质量

作者构建了一系列的数据生成 pipeline, 然后使用 Kimi-k1.5 来生成多样化的回答，最后再进行质量评估和过滤。这里，作者主要介绍了一下 tool-use 数据的构建

受 ACEBench 启发，作者构建了一个模仿真实世界 tool-use 的数据合成 pipeline. pipeline 如下图所示

pipeline 主要包含三个阶段：

tool spec generation: 作者基于 MCP tools 和 self-evolved 的数据合成策略来构建 tool repository. MCP tools 包括 3000+ 的 tools,合成了 20，000 个 tools
Agent and task generation: 作者还用不同的 system prompt 以及不同的 tools combination 来构建对应的 agent. 然后对不同的 agent, 作者构建了对应的成功标准均，工具调用模式以及评估方式
Trajectory generation: 作者首先构建不同风格的 LLM, 然后作者使用一个 simulator 来执行 tool call 并给予反馈。

最后，作者对数据进行了过滤。

作者还加入了 coding 以及软件工程等任务相关数据来进一步提高模型的 agent 能力

RL

RL 与 Kimi-K1.5 差不多。作者进一步提高了 RL 阶段的算力并做出了亮点改进：

作者构建了类似 Gym 的框架，用于扩展 RL 的能力
作者加入了更多 RLVR 的任务

Data 数据主要包括以下几类：

Math, STEM and logical tasks: 数据构建的原则为多样化和中等难度
Instruction following: 作者基于 hybrid rule verification 和 multi-source instruction generation 来合成复杂的指令跟随数据
Faithfulness: 作者训练了一个 judge model 来提供 reward
Coding & Software Engineering: 作者从开源数据收集并合成了代码相关数据
Safety. 提高模型的安全性，防止 jailbreak

Reward 作者使用了 self-critique rubric reward 的奖励机制。

首先，对于 Kimi-k2 的回答，作者会使用另一个 kimi-k2 作为 critic，基于三个方面进行排序：

core rubric: AI 的核心价值观
prescriptive rubric: 避免 reward hacking
human-annotated rubric: 特定的上下文

在训练的过程中，critic 也会基于 verifiable signals 进行 refine

RL training RL 的训练目标与 Kimi-k1.5 相同

$$ \mathcal{L}(\pi_\theta) = \mathbb{E}_{x\sim \mathcal{D}}\left[\frac1K\sum_{i=1}^K \left(r(x,y_i)-\bar{r}(x) -\tau\log\frac{\pi_{\mathrm{\theta}}(y_i\mid x)}{\pi_{\mathrm{old}}(y_i\mid x)}\right)^2\right] $$

其中 $\bar{r}(x)=1/K\sum_{i=1}^Kr(x,y_i)$ 是 sample response 的平均奖励。

作者做了以下几点改进来提高模型在不同 domain 上的表现：

Budget control: 作者针对不同任务分别设置了最大 token 限制，模型超过这个限制会受到惩罚。猜测应该是 length penalty 或者类似 Qwen3 一样，直接中断思考过程输出最终答案
PTX loss: 作者使用了 PTX loss 来提高模型对于高质量数据的利用率以及降低模型的过拟合
Temperature Decay: 作者发现，训练后期保持较高的采样温度会影响模型的表现，因此作者设置了一个 schedule, 来逐步降低采样温度。

RL Infra

RL infra 与 Kimi-k1.5 类似。主要包含三个模块。其中 train engine 和 inference engine 两者互相切换，一个 engine 进行 training 的时候，另一个 engine 就进行 inference, 为了提高 engine 切换的效率，作者使用了 checkpoint engine 来传输更新后的参数。

Evaluation

模型评估结果如下图所示

评估结果显示，模型在 coding 和通用任务上的表现仅次于 Claude 4, 大部分 benchmark 上都是第二名甚至是 sota.

Conclusion

作者在本文中提出了 Kimi-K2, 一个总参数为 1B 的 MoE 大语言模型。作者在架构，数据和优化器上进行了创新。并且通过 post-training 显著提高了模型的 agent 以及 tool-use 能力

作者发现模型主要存在的问题有：

reasoning 任务过难或者 tool 的定义不清晰的时候，模型会使用很多 token
有时候工具调用可能会降低模型的表现
模型在 agentic coding 任务上的能力需要进一步提升

References

Github

Notes on Keye-VL

Wed, 23 Jul 2025 11:11:43 +0800

Keye-VL 是快手在 25 年 7 月份提出的一个 8B 的多模态大模型，其亮点为短视频理解能力。预训练包括 4 个 stage，使用了 600B token，后训练包括 2 个 stage，用于提升模型的 reasoning 和 non-reasoning 能力。

Introduction

作者首先回顾了已有的 MLLM 工作，然后强调理解短视频仍然是一个很难的任务，特别是要求模型基于 video 和 audio 来理解视频。因此，在本文中，作者提出了 Kwai Keye-VL，一个 8B 的多模态大模型，主要用于短视频理解任务。

Method

Architecture

Keye-VL 是一个标准的 ViT-MLP-LLM 的架构，其中，ViT 是 SigLIP-400M-384-14, MLP 是一个基于 SwiGLU 的 2 层 MLP，使用了和 Qwen2.5-VL 一样的 patch merge 方法，LLM 使用的是 Qwen3-8B，模型架构示意图如下

作者针对 ViT 和 visual encoding 分别做了如下改进

NaViT

作者实现了 native resolution ViT，来处理不同分辨率的图片。

具体做法为，作者基于 SigLIP-400M-384-14 来初始化 ViT。

然后，作者首先采用了 interpolation 来将 ViT 的 position encoding 扩展到不同的图片精度下面去。

接下来，作者提出了 2D RoPE 来进一步提升 position encoding 的表现。

最后，作者加入了 NaViT 的 packing 技巧来继续预训练 ViT.

在 ViT 预训练的过程中，作者使用了 500B 的 token

Visual Encoding

为了提升模型理解图片和视频的能力，作者针对图片和视频进行了进一步的处理。

对于不同精度的图片，作者将最大 token 个数设置为 16384。

对于视频，作者将每帧的 token 数限制在 $[128,768]$, 每个视频的最大 token 个数设置为 24576

对于提取的 frames，作者重新计算了 FPS, 然后在 3D RoPE 中让时间维度与真实时间严格对齐。

Pre-training

Data

预训练数据一共包括 600B token，覆盖了 6 个类别：

Image caption: 包括中英文数据，来源为 LAION, DataComp 以及 Coyo. 作者基于 CLIP 来计算相速度，然后过滤掉相似度比较低的数据，作者还对数据进行了 re-caption，实验发现 re-caption 可以提高模型的细粒度图片理解能力
OCR & VQA: 数据包括开源数据和合成数据。合成数据包括 Synthesis 和 Rendering 两个方法，第一是基于 text-dense image 构建 OCR 数据以及基于 image-caption pair 数据使用 MLLM 构建 VQA 数据。第二是使用字体渲染工具合成高质量的 OCR 数据
Grounding & Counting: Grounding 数据主要包括 RefCoCo, VisualGenome, TolokaVQA, Counting 数据包括 PixMo. 作者仍然使用 CLIP 对数据进行过滤
Interleaved text-image data: 作者发现图文交错数据可以提供通用知识，并且还可以提高模型的视觉语言对齐能力，第三就是提升模型的泛化能力。作者主要从 academic PDF 以及结构化知识中提取对应的数据。作者基于 Garbled character recognition, low-resolution/broken image filtering 以及 text-image similarity validation 来保证数据的质量
Video understanding: 作者使用 Qwen2.5-omni 从 interleaved video-asr 来将视频数据转化图文交错数据，然后基于 ASR 的结果进行 recaption，最后对每一帧进行 OCR. 作者还构建了 Frame-level re-ordering 以及 multiple video matching 两个任务来提高模型的上下文理解能力
Pure Text: 未提及

对于源数据，作者进行了数据清洗：

使用 CLIP 对数据进行打分，然后过滤掉低质量的数据
使用开源的 MLLM 作为 discriminator 来选择高质量的数据
去重

Training Recipe

预训练包括 4 个 stage：

Stage 0: 使用 SigLIP 损失函数来继续训练 ViT
Stage 1: cross-modal Alignment，仅训练 MLP
Stage 2: multi-task pre-training, 解冻所有参数，使用 Multi-task 数据来训练模型
Stage 3: annealing, 在高质量数据集上进行 fine-tune，进一步提升模型的能力

作者发现，预训练后的模型在下游任务上的表现对训练数据配比非常敏感。为了解决这个问题，在最后一个训练阶段，作者使用了一个 merging 的技巧，来保持模型的能力。

Post-training

post-training 阶段一共包含了 2 个 step, 5 个 stage, 第一个 step 包含 2 个 stage，用于提升模型的 non-reasoning 能力。第二个 step 包含 3 个 stage, 用于提升模型的 reasoning 能力

No-reasoning Training

第一个 step 是 non-reasoning training, 包含了 SFT 和 MPO 两个 stage, 训练 pipeline 如下图所示

SFT SFT 阶段一共使用了 5M 的多模态 QA 样本，为了提升数据的多样性，作者使用 TaskGalaxy 来将数据分类为 70,000 种任务类型，然后作者对每条数据，使用 MLLM 评估问题的难度，来过滤掉过于简单的问题。最后，作者请人类来进行标注，保证数据的可靠性。

MPO 训练方面，作者使用了 MPO 进行训练。数据方面，作者使用了：

400,000 开源的数据，作者主要进行了去重以及过滤低质量的数据
50,000 偏好数据，基于 MM-RLHF 和 MMPR 等数据构建，然后构建高质量的 negative examples
10,000 条 self-improvement 样本：基于 benchmark 和人类反馈，使用 SFT model 的回答作为 chosen samples, 然后基于 reward model 或者 rule-based rewards 评估模型输出，选择分数最低的座位 rejected samples
90,000 纯文本样本： in-house data
30,000 人类标注样本：使用开源和闭源模型进行回答，然后请人类进行排序

Reasoning Training

第二个 step 是 reasoning training, 包含了 CoT Cold-Start, Mix-Mode RL 和 Iterative Alignment 三个 stage, 训练 pipeline 如下图所示

CoT cold-start 作者收集了如下数据：

330, 000 条 non-reasoning 样本：和第一个 step 的数据分布类似，但是不重合
230,000 reasoning 样本：作者构建了一个 data construction pipeline,用于保证 long-CoT 的正确性
20,000 automatic reasoning 样本：作者基于 MMPR, MM-Eureka 以及 OpenR1-math 来收集数据，基于这些模型来训练模型自动化决定是否要进行 reasoning
100,000 agentic reasoning 样本：训练模型的 “think with image” 能力。基于 3M QA pairs，作者使用 Qwen2.5-72B 来识别需要进行 manipulating 的问题，然后生成对应的代码。接下来作者构建了一部分 OCR 数据，让模型学会 constrast enhancement 或者 rotation 操作。最后对于数学问题，作者让 Gemini-2.5-Pro 生成对应的思考过程，再让 GPT-4o 将对应的计算转换为可执行的代码。
32, 000 Video data: 包含了 24,000 条 thinking samples 和 80,000 条 non-thinking samples

训练时，所有样本混在一起进行训练。作者认为，将日常使用的 SFT 数据和 reasoning 数据放在一起训练，可以保持模型在通用场景下的能力。

Mix-Mode RL 训练数据主要包括 4 个任务：

Multimodal perception: 复杂文本识别和 counting 任务
Multimodal reasoning: MMPR 和 MM-Eureka
Text-based mathematical reasoning: 数学推理问题
Agentic reasoning: 从 DeepEyes 中获取的 47,000 条样本

作者使用了 GRPO 来训练，reward 基于 MLLM 进行，包括最终结果和思考过程。

作者还使用 RL 来提高模型的短视频理解能力。作者发现 RL 训练之后，模型的短视频理解能力有了大幅度的提升。

Iterative Alignment 这一步主要解决模型的重复性输出，或者 reasoning logic 不对的问题。作者使用了 rejection-sampling 数据，包括 instruction following, OCR, mathematics, charts, counting 等。

作者基于 Rule-based score 和 model-based score 来进行打分，最后使用 MPO 算法进行训练。通过这个过程，模型的输出格式和动态思考能力都有了提升。

Evaluation

作者首先评估了 ViT 的表现，主要有两点：

在 SigLIP 的基础上加入 1D interpolation 之后，模型的表现所有下降，作者认为这是由于 1D 的 position encoding 无法识别 2D 的 patch 排列导致的
加入 2D RoPE 之后，ViT 与 SigLIP 的表现持平

接下来是 Keye-VL 在公开 benchmark 上的表现，如下图所示

作者还构建了一个内部的 benchmark, 用于进一步评估模型的能力。

已有 benchmark 的问题：

contamination
多语种覆盖不足：大部分 benchmark 都是英文的
任务和 domain 覆盖不足：大部分 benchmark 只考虑基本的 perception 和 reasoning 能力
任务难度和评估格式单调

构建 benchmark 的原则：

在中文场景下的真实用户需求，open ended QA, 包括短视频理解能力
细粒度的评估
多样性高
没有 contamination
多角度评估策略: 正确性，相关性，理解性，流畅性和创造性

结果如下：

分析：

Keye-VL 在 OCR 等任务上的表现有所不足，其细粒度的识别能力也有所不足，会认错人。有时候还会忽略掉一些信息
描述 temporal action 时会出现不稳定性，模型对镜头的感知能力不足。需要准确定位时间等
在需要逻辑链条和数学计算时，模型能力不足，对于特定 domain 上的任务会出现事实性错误。写作时，模型倾向于输出通用的回答，而不是定制化的回答。

Discussion

作者讨论了两点关键发现：

reasoning 和 non-reasoning 的数据可以互相促进彼此的表现，这与 ERNIE 4.5 的发现一致。
作者认为通过 mix-mode 的训练，模型在简单和复杂任务上的表现都可以提升，因此作者使用了混合数据来进行训练，结果发现效果很好。

Conclusion

本文中，作者提出了 Keye-VL 8B，一个短视频理解能力出色的多模态大模型，作者详细介绍了 pre-training 和 post-training. 其中，mix-mode training 可以有效提高模型的表现。

作者认为 Keye-VL 有如下改进的地方：

并没有优化 video encoder 或者是改进 video encoding 的策略
Keye-VL 的视觉感知能力有进一步的提升空间，其 “reasoning with image” 能力依然落后于领先的 reasoning model
使用一个额外的 MLLM 作为 reward model 会极大消耗算力，如何构建一个更可靠更高效的 reward model 需要进一步探索。

Reference

Arxiv
Github

Notes on V-Triune

Thu, 17 Jul 2025 09:37:36 +0800

V-Triune 探究了如何使用一套统一的 RL 训练框架，来同时提高模型的 perception 和 reasoning 能力。

Introduction

已有的 RL 训练方法主要提升模型在特定 domain 上的能力，比如 MM-Eureka, Vision-R1 等专注于提升 MLLM 的 reasoning 能力，而 R1-V, DeepPerception 等专注于提升模型的 perception 能力。

因此，本文的 motivation 就是，如何用一套统一的 RL 训练框架，来同时提高模型的 perception 和 reasoning 能力。

V-Triune 包含 3 个关键模块：

Sample-Level data formatting: 即在 sample 的层面定义 reward 等信息
Verifier-Level Computation: 即分离 verifier 和 generator, 提高整体效率
Source-Level Metric Monitoring: 基于 data source 来监控模型的表现

作者还提出了 Dynamic IoU reward, 来提高训练的稳定性。

基于 V-Triune 和 Qwen2.5-VL, 作者提出了 Orsta,一个在 reasoning 和 perception 任务上均有提升的多模态大模型。

论文的主要贡献为：

提出了 V-Triune, 一个统一的 RL 训练框架，来同时提高模型的 reasoning 和 perception 能力
在 infra 上进行了改进，提高整体的训练效率和稳定性
基于 V-Triune, 构建了 Orsta, 相比于 Baseline, 模型的 perception 和 reasoning 能力均有了提升。

Preliminary

作者首先回顾了一下 GRPO 和 DAPO , 我们这里就不再赘述。

然后，作者介绍了一下 reward function, reward function 由两部分组成，第一部分是 format reward, 第二部分是 accuracy reward,.

对于 format reward, 作者采取了和 OpenR1 相同的做法，也就是要求输出仅包含 1 个给定的 token, 这里特定的 token 为 $s_1=\texttt{}$, $s_2=\texttt{}$, $s_3=\texttt{}$, $s_4=\texttt{}$, reward 的定义如下：

$$ R_{\mathrm{format}}(o_q) = 0.25\sum_{i=1}^4 \mathbb{1}(\mathrm{count}(o_q,s_i)=1) $$

这里 $\mathbb{1}(\cdot)$ 是示性函数。

对于 accuracy reward, 作者根据不同的任务分别进行处理。

对于 reasoning 任务，reward function 的定义如下

$$ R_{\mathrm{acc}}(\hat{a},a) = \begin{cases} 1, &\text{ if }\texttt{verify(parse($\hat{a}$), parse($a$))}\text{ is True}\\ 0, &\text{ else} \end{cases} $$

这里 $\hat{a}$, $a$ 分别是 prediction 和 ground truth.

对于 perception 任务，reward function 与我们要处理的子任务相关。如果是 OCR 和 counting 任务，则我们采取和 reasoning 一样的 reward function. 如果我们要处理的是 grounding 和 detection 任务，则我们可以使用 IoU 以及 mAP 两种 reward 形式。

IoU reward 的定义如下：

$$ R_{\mathrm{acc}}(\hat{a},a) = \begin{cases} \mathrm{IoU}(\hat{a}, a), &\text{ if }\mathrm{IoU}(\hat{a},a)\geq \epsilon\\ 0, &\text{ else} \end{cases} $$

这里 $\epsilon>0$ 为超参数， IoU 定义如下

$$ \mathrm{IoU}(\hat{a},a) = \frac{\mathrm{Area}(\hat{a}\cap a)}{\mathrm{Area}(\hat{a}\cup a)} $$

mAP 的定义如下

$$ \mathrm{AP}_c = \int_0^1 \max_{\tilde{r}\geq r}P_c(\tilde{r}) dr,\quad mAP=\frac1C\sum_{c=1}^C \mathrm{AP}_c $$

最终的 reward 是 format reward 和 accuracy reward 的加权求和：

$$ R = \alpha_{\mathrm{acc}}R_{\mathrm{acc}} + \alpha_{\mathrm{format}}R_{\mathrm{format}} $$

V-Triune

V-Triune 框架如下图所示，其包含三个模块

Sample-Level Data Formatting

核心思想就是不同的任务的 reward function 可能是不一样的，如果在 task 层面设计 reward function 的话，RL 训练就没有了 flexibility, 因此，在本文中，作者在 sample 层面设计 reward function. 具体做法就是，每个样本除了 QA 相关信息，还有 reward model 的相关参数，这样就可以更加灵活地调整不同 sample 的损失了。

Verifier-Level Reward Computation

核心思想就是构建多个不同的 Verifier, 来分别处理不同的 sample, 因为我们 reward model 也是在 sample 层面构建的，因此我们可以基于 sample 的 metadata 来动态分配对应的 verifier, 这样就提升了 veriier 的可扩展性。本文作者使用了 MathVerifier 和 DetectionVerifier 两种。

Source-Level Metric Monitoring

核心思想就是根据 sample 的 metadata 信息来监控不同的 metric, 这样可以防止训练不稳定。

Dynamic IoU Reward

核心思想就是根据训练进程，动态调整 IoU 的阈值。

作者发现，如果将 IoU 阈值设置的比较低的话，模型很容易拿到比较高的 reward; 如果将 IoU 阈值设置的比较高的话，模型又很难拿到奖励。

因此，作者的解决方案就是，使用课程学习，随着训练的进行，逐步提高 IoU 的阈值。

Data

数据集列举如下：

Math: mm_math, geometry3K, mmk12
Puzzle: PuzzleVQA, AlgoPuzzleQA, VisualPuzzles
Science: ScienceQA, SciVQA, ViRL39K (Broader STEM topics, (GradeSchool) Science)
Chart: ChartQAPro, ChartX, Table-VQA, ViRL39K (Tables/Diagrams/Charts)
Detection: V3Det, Object365
Grounding: D3
Counting: CLEVR
OCR: LLaVA-OV (OCR questions), EST-VQA

Rule-based filtering 对于 visual reasoning 数据，作者的过滤如下：

多项选择题以及判断题，防止 reward hacking
答案包含特殊符号如 “=”, “[” 等的数据
答案字符数超过 20 个，防止答案太复杂

对于 visual perception 数据，作者过滤流程如下：

Detection: 超过 10 个 bounding box 的，或者 box 占 50% 以上面积的数据，保持 single BB 和 multi BB 的比例为 1:2
Grounding: box 占 50% 以上面积的数据, label 过于复杂的数据
Counting: 保持类别平衡，仅使用英文数据
OCR: 保留英文数据，对 labels 进行 verify

Difficulty-based filtering 主要是移除比较简单的问题。

经过这两个阶段的过滤之后，得到了 20.6K perception samples 以及 27.1K reasoning samples. 数据保存在 Parquet 格式

Training Recipe

Disable ViT Training

作者首先发现，全量微调会导致训练崩溃。作者分析原因发现，主要是 ViT 在反向传播过程中，存在 gradient amplify 的问题，第一层与最后一层的梯度的 norm 相差 5-10 倍。作者认为有两点原因：

RL 会强制要求模型的不同模态之间进行对齐
对比学习训练得到的 VIT 可能使得其不适合 RL 的训练。

基于这两点考虑，作者再进行训练的时候，冻结了 ViT 模块，结果如下图

Spurious Image Special Tokens

作者发现，模型的输出可能会包含一些 <image_pad> 等 token, 因此，作者对输出进行了过滤，然后再进行计算。

CoT Prompt Pool

作者还发现，多样化的 CoT prompt 会损害模型的表现。因此，作者构建了 20 个 prompt 模版，每次随机挑选其中一个加入到 instruction 中。

Training Configuration

模型基于 Qwen2.5-7B-instruct 和 Qwen2.5VL-32B 来进行开发

作者探究了 on-policy 和 off-policy 两种配置。roll-out batch size 设置为 1024, 使用 GRPO 进行训练，GRPO 的 group size 设置为 8

作者还设置 $\epsilon_{high}=0.28$ 以及 $\epsilon_{low}=0.2$ 来提高 token 的采样率。作者去除了 KL divergence loss, 并且在 token 层面上进行平均

Evaluation

Performance

Analysis

on-policy v.s. off-policy 作者首先对比了以下 on-policy RL 和 off-policy RL 两种训练方式的表现，结果如下图所示

结果有两点发现：

on-policy 的表现基本上都是比 off-policy 要好的。
小模型通过 RL 带来的表现提升更明显，大模型的表现则更慢

generalization 作者还评估了以下模型的泛化性，结果如下图所示

结果发现，RL 的训练更像是对齐，而不是泛化。也就是说，模型在 in-domain 的任务上表现较好，在 OOD 的任务上表现就一般。这与已有的结论是不一样的

[!tip] Recall Magistral 发现模型在 math domain 上进行训练，在 code domain 上的表现也会提升

Training Dynamics 作者还分析了不同任务不同指标随训练进行的变化情况，如下图所示

结果显示，reasoning 和 OCR 任务岁训练进行其输出长度和正确率都有所提升。但是 detection 相关任务则变化不是很明显。

Ablation Study

作者进行了三个消融实验：

训练策略：冻结 ViT, 冻结 LLM, 两者都不冻结
任务分解策略：仅使用 reasoning 数据进行训练，仅使用 perception 数据进行训练，同时使用两种数据进行训练。
learning rate: 不同的学习率

实验结果如下图所示

结果发现，

仅训练 ViT 对表现没有任何帮助，只有训练 LLM 才会带来性能的提升。
同时使用两种数据进行训练的效果是最好的，其次是仅使用 reasoning 数据进行训练，最后是仅使用 perception 数据进行训练
较大的学习率会损害模型的表现。

Conclusion

本文中，作者提出了 V-Triune, 一个使用 RL 来同时提高 MLLM 的 reasoning 和 perception 能力的 RL 训练框架。

作者发现 RL 对于 VLM 来说更像是一种 Alignment 策略，而不是一种 Generalization 策略，也就是模型并没有引入新的能力，而是提升模型本身的 utility 以及 robustness.

作者认为本文有以下 Limitation:

在 perception 任务上没有看到明显的 test-time scaling 现象。作者认为，探究使用 o3 类似的方法或许能提高模型的表现
探究 RL-zero 在 VLM 中的应用，也就是直接在 base model 上进行 RL 的训练。

References

arxiv

Notes on Magistral

Wed, 16 Jul 2025 11:04:04 +0800

Magistral 是 Mistral 提出的一个 reasoning model 系列，主要针对 math 和 code 两个 domain

Introduction

Mistral 在 2025 年 6 月 12 日发布了 Magistral ，一个 reasoning model, 包含两个模型，一个是由纯 RL 训练得到的 Magistral Medium, 另一个是由 SFT 和蒸馏 Magistral Medium 得到的 Magistral Small

作者首先介绍了一下本文的贡献：

介绍了如何仅使用 RL (而不是用蒸馏) 来训练 Magistral Medium
infra 上的改进，主要使用最新的权重来更新 generator
多语种能力，支持多种语言
系统性探究了 RLVR 的能力边界
开源了 Magistral small (24B)

Method

RL

RL 算法基于 GRPO 改进，主要有以下几点：

去掉了 KL Divergence loss, 这一点跟 DAPO 是一致的，提升模型的探索能力
Loss Normalization，在 sample 层面做平均，还是跟 DAPO 一致，减少不同长度输出对训练造成的影响
Advantage Normalization, 作者首先将每个 token 的 Advantage 定义为 $\hat{A}_i=R_i-\mu$, 其中 $\mu$ 是每个 group 的 reward 均值，然后在每个 mini-batch 里对 advantage 进行 Normalization (这里 $\hat{A}_{mean}$ 和 $\hat{A}_{std}$ 分别为 mini-batch advantage 的均值和方差)：

$$ \hat{A}_{i,t}^{norm}=\frac{\hat{A}_i-\hat{A}_{mean}}{\hat{A}_{std}} $$

CLIP-Higher, 跟 DAPO 一致，提高稀有 token 的被采样概率
Eliminating non-divsere groups, 跟 DAPO 一致，去掉过于简单和过于难的题目

最终 RL 阶段训练的损失函数为：

$$ \mathcal{L}(\theta) = \mathbb{E}_{q\sim P(Q),\{o_i\}_{i=1}^G\sim \pi_{old}(\cdot\mid q)}\frac{1}{\sum_{i=1}^G|o_i|}\sum_{i=1}^G\sum_{t=1}^{|o_i|}\min\left[r_{i,t}(\theta)\hat{A}_{i,t}^{norm}, \mathrm{clip}(r_{i,t}(\theta), 1-\epsilon_{low}, 1+\epsilon_{high})\hat{A}_{i,t}^{norm}\right], \mathrm{s.t.}, \exists 1\leq m < n \leq G, r_m\neq r_n. $$

其中

$$ r_{i,t}(\theta) = \frac{\pi_{\theta}(o_{i,t}\mid q, o_{i,Reward Shaping

作者还基于四个维度来构建 reward: formatting, correctness, length, 以及 language consistency

Formatting 针对数学和代码问题，作者要求模型输出符合特定的格式

Tag requirements: 思考过程用 <think></think> 包含，且只能包含一个 tag
mathematical responses: 对于数学问题，结果用 \boxed{} 包含
code response：包含一个 markdown block

[!tip] Future 最新的 GLM-4.1V-Thinking 认为，不应该在 RL 训练阶段加入 format reward

correctness 基于答案的正确性分配奖励

math correctness：使用 rule-based verifier 进行打分，使用 parser 和 Sympy 来比较模型输出以及 ground truth
code correctness: 构建单元测试，评估输出代码是否能通过所有的单元测试

Length penalty 与 DAPO 一致，使用 Length penalty 来惩罚过长的回答。

Language consistency 减少模型混合语言输出的问题。作者的做法是将 10% 的问题从英语转化为其他语种，然后使用 fastText 进行分类，确保内容都是一个语言。作者发现，通过这个简单的修改，就提高了模型的语言跟随能力。

[!tip] Recall MiMo 中也遇到了混合语言输出的问题，但是其并没有给出解决办法。

作者还在 system prompt 中规定了输出的格式以及语言。

[!tip] Observation 作者发现，RL 的训练对于 system prompt 非常的敏感，因为 system prompt 会提高 model 的 entropy, 然后提高模型的探索能力。

Data

数据包括 math problems 以及 code problems

Math

作者首先收集了 700K 样本，然后作者通过预处理以及过滤来保证数据的质量：

format filtering 要求问题完整，答案准确且可验证；去掉证明题和 multi-part 的问题；改写多项选择题为解答题，提高难度防止 reward hacking

difficulty filtering 使用两阶段的过滤策略。

第一阶段使用 LLM 进行多次采样，然后去除掉比较简单或者比较复杂的
第二阶段使用 RL checkpoint 进行多次采样，去除掉标准答案可能会存在问题的题目

最终一共得到 38K 的样本

Code

首先去掉没有 solution 和 test 的问题；然后去除掉标准答案不能通过所有 test 的问题。最终一共得到 35K 的样本，包含 Python 和 C++ 两种语言

Training

训练框架如下图所示

对于两个模型，作者采用了不同的方式进行训练

Magistral Medium: 使用 pure RL 进行训练
Magistral small: 使用 SFT + RL 进行训练

Magistral Medium 训练时满足的要求：

dataset is not too easy: 太简单的题目对模型提升没有帮助
Generation length does not stop growing: 逐步提升模型的最大输出长度
KV-cache memory burden is not too large: 降低 batch size 来减少 KV-cache 的内存占用

Magistral small 训练

SFT 数据集包括两部分，一部分是 Magistral Medium 回答正确的这部分数据，第二部分是公开数据集，包括 [[OpenThoughts]] 和 [[OpenR1]] 两个数据集，作者使用 Magistral Medium 来生成回答。作者还加入了 10% 的 instruction tuning 数据来保持模型的通用能力。

RL RL 的训练与 Magistral Medium 一致。

Infra

作者首先介绍了一下 RL 训练的 infra, infra 主要包括三个模块：

Trainers: 用于更新模型的权重
Generators: 用于采样，生成 roll-out
Verifiers: 对模型输出的结果进行打分

分布式 RL 训练的主要问题在于，不同长度的 roll-out 花费的时间不一致，作者发现，最长的 roll-out 和最短的 roll-out 的时间相差超过 5 倍以上。

因此，作者就提出了异步生成这个方法。具体的做法就是

首先由 Generator 生成多条 roll-out
当 roll-out 完成之后，立马用 Verifiers 对轨迹进行打分
收集 roll-out 以及对应的 reward, 直到达到给定的 batch 大小
使用 Trainer 更新 Generator 的权重, 将更新后的权重同步给 Generator，这样其他 generator 在生成新的 token 时用的就是新的权重

[!tip] Recall MiMo 里的做法是，当我们收集到给定数量的 roll-out 之后，我们就基于这些 roll-out 更新权重，然后进行下一次采样

训练时，对于每个 rank, 只要其收集到足够的 roll-out, 就会进行一次梯度更新。

Evaluation

Ablation

RL 的泛化性 作者探究了 RL 的 cross-domain generalization 能力，实验结果如下

Model	AIME’24	LiveCodeBench v5
Starting Checkpoint	32.2	22.7
RL (Math only)	62.5	38.3 (+15.6)
RL (Code only)	49.7 (+17.5)	42.7

可以看到，不管是使用 math 还是 code 数据单独进行训练，模型在另一个 domain 上的表现都有所提升。

[!tip] Future 这个结论与最新的 GLM-4.1V-Thinking 结论一致

Distillation v.s. RL for small models 作者探究了对于小语言模型，使用 RL 进行训练的效果更好，还是使用蒸馏的效果更好。

[!tip] Observation 实验结果发现，仅使用 RL 的效果与蒸馏差不多，甚至更好

Batch size 作者还探究了 batch size $n_{batch}$ 以及 mini-batch size $n_{mini}$ 的影响。这里 batch size 指的是用于更新梯度的 roll-out 数量，mini-batch size 指的是计算梯度的 roll-out 数量，作者还定义了并行生成 roll-out 的数量 $n_{async}$. 当 $n_{async}>> n_{batch}$ 时，生成的 sequence 就很可能是 off-policy 的。作者固定 $n_{async}=4096$, 然后对比了不同的 $n_{batch}$ 和 $n_{mini}$ 对模型表现的影响，结果如下：

![tip] Observation 当 $n_{batch}=n_{mini}$ 时，模型表现差不太多（左图）；当 $n_{batch}$ 为常数，而 $n_{mini}$ 逐渐减小时，模型表现会逐渐变差。

Advantage normalization 作者对比了三种针对 advantage 的 normalization 方式：

mini-batch: 在每个 mini-batch 里对模型进行 normalization
Group normalization: 在每个 group 里进行 normalization
no normalization: 没有 normalization

实验结果如下

作者发现，三种方式的区别并不是很大。

Analysis

length dimension 作者首先保存模型的 weight, 然后使用 PCA 进行降维，并在 2 维上进行可视化，作者对权重进行扰动，然后记录模型的 reward 以及输出长度。结果发现，模型存在一个 length dimension. 可视化结果如下图所示

multimodal extension 由于 Magistral medium 和 Magistral small 都是基于 MLLM 中的 LLM 开发得到的，作者还探究了更换 LLM 的 checkpoint 之后，原始 MLLM 的表现，结果发现，模型在多模态 reasoning 相关任务上的表现也得到了提升，结果如下图所示：

Impact on other capabilities 作者还探究了 RL 训练对模型其他表现的影响，结果发现，RL 训练可以提高模型的 tool calling 和指令跟随能力，实验结果如下表所示

Category	Benchmark	Mistral Medium 3	Magistral Medium
Function calling	Internal bench	87.2	87.4
Instruction following	IFEval	86.8	87.4

failed approaches 作者还介绍了一些尝试失败的做法：

partial Reward: 对于 coding 任务，作者使用 test 的通过率作为奖励，结果发现效果并不好，这是因为一些错误的解法的 test 通过率也很高
entropy bonus loss: 作者发现在损失函数中加入 entropy bonus loss 之后，模型的训练变得不稳定，而且效果不如使用更高的 $\epsilon_{high}$
作者还进一步验证在 PPO loss 中加入 KL divergence loss, 结果发现效果并不好，这与 DAPO 的结论一致
作者还尝试先 SFT Magistral Medium, 再进行 RL, 结果发现 RL 可以大幅度提高 SFT checkpoint 的表现。

Conclusion

本文中，作者提出了 Magistral, 一个针对 math 和 code 的 reasoning model, 作者介绍了训练细节。但是，从方法层面来看，和 DAPO 区别不是很大。关键点应该是作者详细介绍了各种消融实验，为后来相关探索提供了经验。

References

arxiv

Notes on SmolLM3

Tue, 15 Jul 2025 11:01:13 +0800

Hugging Face 在 2025 年 7 月 8 号发布了 SmolLM3, 一个 3B 的，128K 上下文，支持 6 种语言，支持 dual mode reasoning 的小语言模型。

Pre-training

Architecture

SmolLM3 是一个基于 transformer 的小语言模型，其模型架构与 SmolLM2 相似，SmolLM3 做了以下改进：

使用 GQA 代替 multi-head attention. 作者通过消融实验发现 GQA 和 MHA 的效果差不多，并且还可以减少 KV cache 的 size
NoPE: 作者使用了NoPE, 来选择性（每 4 个 layer）移除 position embedding. 这个方法可以在不损害模型短文本能力的同时，提高模型长上下文的表现
Intra-Document Masking: 不同的文档之间使用 attention masking 隔开
Training stability: 与 olmo 2 一样，作者移除了 embedding layer 的 weight decay, 来提升训练的稳定性。

Data

与 SmolLM2 一样，作者使用了11.2T token 进行训练，训练包括 3 个 stage。作者针对数据混合策略进行了消融实验，实验配置如下：

Stage	Stable phase	Stable phase	Decay phase
Description	Base training	High quality injection	LR Decay
Tokens	8T	2T	1.1T
Web	85%	75%	63%
Code	12%	15%	24%
Math	3%	10%	13%
datasets	web: FineWeb-Edu, DCLM, FineWeb2, Fineweb2-HQ code: The Stack v2, StarCoder2 PRS, Jupyter and Kaggle notebooks, Github issues, StackExchange math: FineMath3, InfiWebMath3+	Adding Stack-Edu, FineMath4+, InfiWebMath4+, MegaMath	upsampling of high-quality code data upsampling math data and introducing instruction and reasoning datasets such as OpenMathReasoning

其中，Web data 包含 12% 的多语种数据。

Training Recipe

训练过程中，作者使用了 2.36M tokens 的 batch size, 上下文长度为 4096. 优化器为 AdamW

作者使用了 nanotron 进行训练， datatrove 来处理数据， lighteval 来评估模型的表现。

模型在 384 张 H100 上训练了 24 天。分布式训练的配置如下

Mid-training

Mid-training 的主要目标为扩展模型的上下文以及提升模型的 reasoning 能力。

Long Context Extension

在预训练阶段结束之后，作者使用了额外的 100B tokens 来扩展模型的上下文。作者将扩展过程分为两个 stage:

Stage 1: 将模型的上下文从 4K 提升到 32K. 具体做法是将 RoPE 的 base frequency 提升到 1.5M
Stage 2: 将，模型的上下文从 32K 提升到 64K. 具体做法是将 RoPE 的 base frequency 提升到 5M

训练过程中，作者对 math, code 和 reasoning data 进行了上采样。作者发现，对长文本数据进行上采样并不会提高模型在 RULER 和 HELMET 上的表现。

[!tip] Recall Qwen2.5-1M 里也分析了长文本数据的问题，也就是大部分长文本数据依然是局部相关性强，而全局相关性弱

与 Qwen2.5 一样，作者还是用了 YARN 来在推理阶段进一步提高模型的上下文长度，作者发现模型可以处理 128K 上下文长度的文本。

Reasoning Mid-training

扩展模型上下文长度之后，作者还额外增加了一个 mid-training stage 来提高模型的 reasoning 能力。这个阶段的目标在于提升模型的通用能力。作者希望模型不针对特定的 domain, 如 math 或者 code 等。

训练过程中，作者使用了 35B 的 token. 数据来源包括 Open-Thoughts3-1.2M 以及 NVIDIA 的 Llama-Nemetron-Post-Training-Dataset-v1.1. Reasoning trace 由 DeepSeek-R1 生成。作者使用了 ChatML 的格式，还使用了 Packing 来提升训练效率。训练持续了 4 个 epoch.

Post-training

如何构建 dual instruction model 来同时支持 reasoning 和 non-reasoning 任务并没有一个共识，大部分模型的数据都是非公开的。因此，作者就构建了一个 training pipeline, 用于提升模型在两种模式下的能力。

Chat Template

作者首先构建了一个 chat template, 用于支持 reasoning 和 non-reasoning 两种模式。该 chat template 支持用户使用 /think 和 /no_think flag 来控制模型的思考模式。在 non-reasoning 模式下，作者还在模型输出中 prefill 了 <think>\n\n</think>, 这一点与 Qwen3 一致。

SmolLM3 还支持工具调用，其在 chat template 中加入了两种描述方式：XLM tools 和 Python tools.

SmolLM3 还在 system prompt 中加入了 metadata, 如知识的截止时间，当前的 reasoning mode 等。

SFT

作者针对 math, code, general reasoning, instruction following, 以及 multilinguality 这几个领域来提升模型的表现。

作者首先使用 reasoning mode 的 Qwen3-32B 来合成数据，合成数据的过程如上图所示。

最终，SFT 阶段的数据包括 1.8B token, 其中 1B 为 non-reasoning mode 的 token, 覆盖 12 个数据集， 0.8B 为 reasoning token, 覆盖 10 个数据集。作者训练了 4 个 epoch, 使用了 Packing 的技巧。

APO

SFT 阶段之后，作者使用了 Tulu3 的 preference dataset 用于 non-reasoning mode 的训练，然后合成了一批数据用于 reasoning mode 的训练，这批合成数据使用 Qwen3 32B 和 Qwen3 0.6B 生成得到，具体做法就是 Qwen3 32B 输出的结果定义为正样本，Qwen3 0.6B 输出的结果定义为负样本。

作者使用了 APO 算法来进行训练，APO 是 DPO 的一个变体， DPO 的目标函数为

$$ \mathcal{L}_{DPO}(x,y_w,y_{l}; \theta) = -\log \sigma(r_\theta(x,y_w) - r_\theta(x, y_l)) $$

其中

$$ r_\theta(x,y) = \beta\log \frac{\pi_{\theta}(y\mid x)}{\pi_{ref}(y\mid x)} $$

$\beta>0$ 是一个超参数。APO 的目标函数如下

$$ \mathcal{L}_{APO}(x,y_w,y_l;\theta) = -\sigma(r_\theta(x,y_w)) + \sigma(r_\theta(x,y_l)) $$

作者发现，模型的 reasoning 能力提升之后，其长上下文能力反而下降了。作者认为这是因为在 reasoning mid-training stage 的训练中，提升 reasoning 能力损害了模型的 long context 能力。并且，APO 的训练数据上下文长度大多都在 24K 左右。为了解决这个问题，作者提出了 Model merging 的方法

Model Merging

作者使用 MergeKit 来完成 model merging 的任务。merge 的过程包括两步：

构造一个 model soup, 包括 APO 的每个 checkpoint
将 model soup 与 mid-training 的一个拥有强上下文能力的 checkpoint 结合起来，作者使用了 linear merge, APO model soup 和 mid-training checkpoint 的权重分别为 0.9 和 0.1.

[!tip] Recall Kimi-k1.5 也使用了 model merging 的方法，来将 long CoT 模型的能力迁移到 short-CoT 模型上去

Evaluation

作者首先评估了一下 base model 的表现，评估使用了 12 个 benchmark, 对比的模型包括 Qwen3, Gemma3, LLaMA 3.2. 结果如下图所示

模型的多语种表现如下

Instruction (non-reasoning) 版本的评估结果如下

Reasoning 版本的评估结果如下

可以看到，Qwen3-4B 的表现是最好的。而 SmolLM3 的表现在 3B 左右也是非常强劲的

Conclusion

作者提出了 SmolLM3, 一个拥有长上下，文多语种以及 dual mode reasoning 能力的大语言模型，作者详细介绍了数据，训练以及 model merging 的技巧，来提高模型的表现。

References

blog

Notes on GLM-4.1V-Thinking

Mon, 14 Jul 2025 10:32:04 +0800

智谱 AI 在 25 年 7 月份发布了 GLM-4.1V-Thinking, 一个 9B 的多模态大语言模型，其在多个 benchmark 上达到了相同大小 MLLM 的 SOTA

Introduction

已有工作如 MiMo-VL 和 V-Triune 主要集中在特定的领域，目前还没有一个在所有领域都能超过 non-reasoning model 表现的多模态 reasoning model.

基于这个目标，作者提出了 GLM-4.1V-Thinking, 一个 9B 的，用于通用领域多模态 reasoning 的 MLLM. 在预训练阶段，作者通过构建多样化的数据来提升模型的基础能力。在 post-training 阶段，作者构建了 domain-specific 的数据来让模型学会 reasoning. 最后，作者提出了 Reinforcement Learning with Curriculum Sampling (RLCS) 来扩展模型的 reasoning 能力。

作者主要发现如下：

multi-domain RL 的泛化性非常强，在某一个 domain 上进行 RL 训练也可以提高模型在其他 domain 上的表现
动态选择 RL 训练的数据可以有效提高模型的表现和训练效率
一个 robust 以及 precise 的 reward model 对于 multi-domain RL 是至关重要的

Method

Architecture

GLM-4.1V-Thinking 是一个标准的 ViT-MLP-LLM 架构，其中：

ViT: ViT 使用的是 AIMv2-Huge
MLP: 是一个 3 层的 MLP，架构为 linear-LayerNorm-GELU-SwiGLU, 并且在进入 MLP 之前，GLM-4.1V-Thinking 还会在 spatial 上进行降采样，降采样率为 2
LLM: LLM 使用的是 GLM

与 Qwen2.5-VL 一样，作者将 encoder 的 2D convolution 替换为了 3D convolution，用于处理视频输入，然后对于 single-image inputs，GLM-4.1V-Thinking 会将输入复制，变成一个含有两帧相同图片的 video 输入

为了支持不同分辨率图片输入，作者进行了两点改进：

第一是使用了 2D RoPE 来处理不同分辨率的图片输入

第二是使用 bicubic interpolation 来将不同分辨率的图片适应到 encoder 的 position embedding 上。具体来讲，对一个拥有 $H_p\times W_p$ patches 的图片，每个 patch 的坐标 $(w,h)$ 首先会被 normalized 到 $[-1,1]$ 中：

$$ g_{norm} = (w_{norm}, h_{norm}) = 2* \left(\frac{w+0.5}{W_p}, \frac{h+0.5}{H_p}\right) - 1 $$

然后，我们再使用 bicubic interpolation $\mathcal{I}_{bicubic}$ 将坐标映射到原始的 position embedding 上：

$$ P_{adapted} = \mathcal{I}_{bicubic}(P_{orig}, g_{norm}) $$

对于视频输入，作者在每一帧之后插入了一个 time index token, 用每一帧的 timestamp string 来表示。这个做法与 Qwen2.5-VL 一样。

Pre-training

Pre-training Data

Pre-training 数据包括 image-caption data, interleaved image-text data, OCR data, grounding data, video data 和 instruction tuning data

Image caption data Image caption data 用于提升模型的世界知识。作者从 LAION, DataComp, DNF 以及 Wukong 等数据集收集了 10B 的 image-text pairs, 然后进行数据清洗：

Heuristic-based filtering: 基于规则，如 resolution, caption length 等过滤掉低质量的图片
Relevance filtering: 计算 CLIP score, 过滤掉低质量的数据
Concept-balanced resampling: 基于 MetaCLIP , 来提升数据的覆盖程度，解决长尾分布的问题。这里 Seed1.5-VL 有一个类似的消融实验。
Factual-centered re-captioning: 通过 rewrite caption 来提升 caption 的质量和信息密度。Idefics2 通过实验发现，rewriting caption 可以提高模型的表现。作者在最终的数据集里，混合了一部分 re-caption 的数据。

Interleaved image-text data 相比于 image-caption data, interleaved image-text data 体量更大，且逻辑关系更强。但是噪声也更多，因此作者针对不同来源的数据构建了不同的数据清洗策略：

Web data processing pipeline: 数据来源为 MINT, MMC4, OmniCorpus 等。作者首先基于 CLIP-score，去掉与上下文不相关的图片；然后，作者去除掉广告，二维码等低质量的图片；最后，作者将图多文少的样本也给去除掉，比如相册图片。作者还训练了一个 high-knowledge-density image classifier, 来识别信息密度高的样本。
Academic book processing pipeline: 作者从电子书中收集了 100M 的样本，这些电子书主要是 STEM domain，然后作者构建了一个 PDF parsing tool 来提取文档内容。

OCR data OCR 数据包含220M images, 数据集由三部分组成：

Synthetic document images: 基于预训练语料，使用不同的格式来渲染文字生成不同的图片，然后基于 LAION 的图片作为背景
Natural scene text images: 使用 Paddle-OCR 来从图片中提取文字以及对应的 bounding box
Academic documents: 使用类似 Nougat 的方法来构建 PDF page-Markdown 的数据。

Grounding data 主要包含自然场景和 GUI 两个 domain 的 grounding 数据：

Natural image grounding: 基于 LAION-115M 得到。作者使用 GLIPv2, 来自动化解析 caption 中的实体，然后预测对应的 bounding box, 作者将 bounding box 较少的样本去除掉。最终得到40M高质量的自然场景数据
GUI grounding: 基于 CC 提取对应的 url, 然后使用 Playwright 来与网页进行交互，进而获取到所有的 DOM elements 与其对应的 bounding box. 最终收集到 140M高质量的 QA 样本

Video data Video data 从多个来源得到，作者使用了 fine-grained human annotation 来保证数据质量。作者还标注了 camera motion 等信息

为了保证数据的质量，作者进行了去重，来减少数据语义的相似性。

Instruction tuning data instruction tuning data 的策略如下：

Task coverage and taxonomy: 优化数据分布
Complex scenario augmentation: 构建复杂的指令跟随数据
Data contamination check: 数据污染检查

最终一共收集到 50M样本，覆盖 visual perception, multimodal reasoning, GUI agent 等任务。

Pre-training Training

Pre-training 由两个 stage 组成：

Multimodal pre-training: 提高模型的通用多模态能力，上下文长度为 8192, global batch size 为 1536. 使用了 data packing 策略，使用了 2-way tensor parallelism
Long-context continue training: 提升模型在高精度图片，长视频，长上下文场景下的表现，上下文长度为 32768, 使用了 2-way tensor parallelism 和 4-way context parallelism.

SFT

SFT Data

数据包括 long CoT reasoning 数据，来让模型以标准格式输出 multi-step solution.

数据包括 verifiable tasks 以及 non-verifiable tasks, 覆盖中英两种语言。作者过滤了非常简单和非常困难的样本。

数据格式如下

1

<think> {think_content} </think> <answer> {answer_content} </answer>

对于 verifiable tasks, 输出格式为

1

<answer> <|begin_of_box|> {answer_content} <|end_of_box|> </answer>

数据清洗策略包括：

严格遵守格式要求
reasoning style 不一致或者有噪声
混合语言输出。

作者还使用 RL checkpoints 来生成一部分高质量数据，加入到 SFT 阶段的数据集里面。

SFT Training

全参数微调。上下文长度为 32768， batch size 为 32.数据包括 long-form reasoning data 以及纯文本数据，包括 math, multi-turn conversation, agent planning 以及 instruction following 等.

[!tip] Observation 作者发现，在 SFT 阶段即使是使用带噪声的 reasoning data，模型在 RL 阶段也能继续训练。也就是说，不完美的 reasoning trace 也能提供 guidance. 但是，使用更高质量的数据可以让模型 RL 阶段的训练更稳定且表现更好。

RL

与 Seed1.5-VL 一样，作者在 RL 阶段结合了 RLVR 和 RLHF 两个训练目标。任务包括 STEM problem solving (such as mathematics, physics, chemistry), grounding, optical character recognition (OCR), video understanding, GUI agents, chart and document understanding, logical reasoning, and instruction following.

Data 作者首先构建了一个任务集合，然后基于这些任务，来过滤或者生成对应的 QA pair, 接下来作者基于难度和质量来过滤，最后作者在每个 domain 上进行 RL 的训练来保证数据的有效性。

Reward modelling 作者构建了一个 reward system, 用于给不同 domain 的任务进行奖励。为了探究不同 domain 的 reward 对模型整体表现的影响，作者设计了一个 low-quality reward system，实验结果如下，可以看到模型在训练后期出现了 collapse 或者 reward hacking 的情况。

[!tip] Observation 作者发现，不同任务的不同信号奖励会对模型最终表现产生巨大影响。

在使用 LLM 提取模型回答的 answer 的时候，作者要求模型的最终答案为 <|begin_of_box|> {answer_content} <|end_of_box|> 这种形式，避免大语言模型提取出错。

作者构建的 reward system 包含如下模块：

shared verification functions: 包括格式检查等
domain specific modules: 与 domain 相关的模块
unit testing: 观测 domain 输出的分布，然后基于输出的分布来调整 reward logic

最终 reward 的 design 如下表所示

RLCS 作者使用了 GRPO 来进行优化训练。作者发现，仅需 200 training steps 模型在一半以上问题的准确率就达到了 $90\%$.

为了提升模型的训练效率，作者提出了 Reinforcement Learning with Curriculum Sampling (RLCS), 也就是将课程学习与 RL 结合起来。作者基于模型训练情况动态调整训练样本的难度，来保证每个样本对模型训练的提升都是最大的。

在 RLCS 训练之前，作者先使用模型评测得到每个样本的 pass@k, 然后根据结果将样本进行分类。在训练过程中，作者记录每个样本的 pass@k，然后动态更新其分类结果。在采样的时候，作者基于难度来对样本进行加权，来降低太简单或者太难样本的采样概率。

作者还提出了一些提高 RL 表现的方法：

Larger batch size: 使用更大的 batch size 效果更好
Dynamic sampling expansion via ratio EMA: 作者定义了 naive 样本和高质量样本的比例，然后根据这个比例进行采样，来提升整体的采样效率。
Force answering: 与 Qwen3 一样，对于比较难的问题，当输出的 token 数过长时，作者对模型输出进行截断，然后让模型基于已有思考过程直接输出结果。
Discard KL loss: 与 DAPO 一样，作者也移除了 KL divergence loss
Clip-higher: 与 DAPO 一样，作者通过修改超参数来提高模型的探索能力

[!tip] Observation

RL 阶段的表现与 cold-start SFT 的表现并不完全相关。作者发现，cold-start SFT 取得更好的表现并不一定保证 RL 的表现就更好。

RL 阶段各个 domain 数据的影响是正交的，这与 cold-start SFT 阶段的结果不同。

作者还提出了一些提高训练稳定性的方法：

提高 cold-start SFT 阶段数据的质量
移除 KL divergence loss
使用 top-p 为 1，而不是 0.9 (如 Qwen-LLM 中的设置)，top-p 为 1 可以 cover 整个 vocabulary，避免某些 token 没有参与训练
per-sample loss 和 per-token loss 没有显著区别，但是 per-sample loss 稳定性更高
在 cold-start SFT 阶段让模型学会格式要求，而不是在 RL 阶段加入 format reward

Infra 在 infra 方面，作者做了如下改进：

Load balancing of sequence lengths across DP ranks. 平衡每个 rank 的 sequensequence length 以及 compute load
Intra-rank training with sequence packing and gradient accumulation. 将 sequence packing 和 gradient accumulation 结合起来
Sample packing and reorganization within DP ranks. data packing
Dynamic sampling expansion via ratio EMA. 平衡 naive 样本和高质量样本之间的比例

Evaluation

Performance

可以看到，GLM-4.1V-Thinking 在多个 benchmark 上都达到了 SOTA.

Ablation Study

作者评估了一下不同 domain 的 RL 训练对模型整体表现的影响。作者使用不同的数据来进行训练，然后分析结果的相关性，结果如下

实验结果发现：

在某个 domain 上的训练会提高模型在其他 domain 上的表现
联合多个 domain 进行训练最终的表现会更好

作者还发现，不同的任务之间存在关联，如 GUI-agent 和 grounding 这两个任务是高度相关的。OCR & Chart 以及 GUI-agent 也是高度相关的。

Conclusion

在本文中，作者提出了 GLM-4.1V-Thinking, 一个 9B 的通用多模态 reasoning model, 作者通过构建高质量的数据，多阶段的训练，让模型在 reasoning 和 non-reasoning 任务上均超过了已有的 SOTA 模型的表现

作者认为，模型有以下局限：

模型并没有提升 reasoning 的质量，在某些情况下，模型结果正确，但是中间过程错误。作者分析这是因为目前只有针对结果的奖励机制。因此，未来需要能够评估中间过程的 reward model
RL 的训练具有不稳定性，作者发现模型对设置比较敏感，这对 RL 训练的 scaling 提出了挑战。
模型在复杂场景下表现依旧不太好，比如图片中有物体遮挡的情况，这些感知误差也会影响最终的 reasoning 表现。作者认为如何同时提高 perception 和 reasoning 的表现是一个需要研究的课题。

未来的工作有：

如何构建更好的 reward 机制，来同时评估结果和中间过程。从而防止模型 reward hacking
如何基于 multimodal training 来提升模型在纯文本任务上的表现。探究 visual reasoning 和 text reasoning 如何互相促进也是一个课题
如何更好评估模型的表现，即如何更好评估模型的 failure modes, 比如幻觉，short reasoning 等

References

Appendix

GLM-4.1V-Thinking 的 patch merger 代码

 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



class Glm4vVisionPatchMerger(nn.Module):
 def __init__(self, dim: int, context_dim: int, hidden_act: str, bias: bool = False) -> None:
 super().__init__()
 self.proj = nn.Linear(dim, dim, bias=bias)
 self.post_projection_norm = LayerNorm(dim)
 self.gate_proj = nn.Linear(dim, context_dim, bias=bias)
 self.up_proj = nn.Linear(dim, context_dim, bias=bias)
 self.down_proj = nn.Linear(context_dim, dim, bias=bias)
 self.act1 = nn.GELU()
 self.act_fn = ACT2FN[hidden_act]

 def forward(self, hidden_state: torch.Tensor) -> torch.Tensor:
 hidden_state = self.proj(hidden_state)
 hidden_state = self.act1(self.post_projection_norm(hidden_state))
 return self.down_proj(self.act_fn(self.gate_proj(hidden_state)) * self.up_proj(hidden_state))

class Glm4vVisionModel:
 def __init__(self, config):
 self.downsample = nn.Conv2d(
 in_channels=config.hidden_size,
 out_channels=config.out_hidden_size,
 kernel_size=config.spatial_merge_size,
 stride=config.spatial_merge_size,
 )
 self.merger = Glm4vVisionPatchMerger(
 dim=config.out_hidden_size, context_dim=config.intermediate_size, hidden_act=config.hidden_act
 )

 def forward(self, hidden_states):
 ...
 hidden_states = hidden_states.view(-1, self.spatial_merge_size, self.spatial_merge_size, hidden_states.shape[-1])
 hidden_states = hidden_states.permute(0, 3, 1, 2)
 hidden_states = self.downsample(hidden_states).view(-1, self.config.out_hidden_size)
 hidden_states = self.merger(hidden_states)

Notes on QwQ-32B

Sat, 08 Mar 2025 09:46:16 +0800

Introduction

通义团队在3月6号发布了QwQ-32B，一个基于RL的，32B参数的reasoning model，QwQ-32B的表现可以与DeepSeek-R1相比

模型架构

QwQ-32B基于Qwen2.5-32B开发。主要通过基于outcome-based rewards的RL进行训练。训练过程包括两个stage

Stage 1：本阶段在math和coding domain上进行RL的训练，作者使用了一个verifier来保证最终数学问题结果的正确性，使用了一个code execution server来保证最终生成代码的正确性。
Stage 2：本阶段在通用领域上进行RL的训练。模型基于general reward model和一些rule-based verifier进行训练。应该是类似 DeepSeek-R1 的规则。

实验结果

实验结果如下图所示

Reference

blog
demo

Notes on Kimi k1.5

Sat, 08 Feb 2025 10:09:52 +0800

论文提出了Kimi k1.5，一个基于强化学习训练的多模态推理模型。作者介绍了Kimi k1.5的训练方法，以及infra上的优化。作者的主要贡献如下：

作者发现，模型的上下文长度可以有效提升LLM的推理能力。
作者提出了基于online mirror descent的强化学习训练方法。
作者发现可以通过long context scaling和policy optimization来提升模型的推理能力。
作者提出了long2short的推理方法，可以有效提升short CoT模型的推理能力。

Architecture

论文中包括两个模型，一个是k1.5 base model，其是一个多模态大模型。另一个是Kimi-1.5 reasoning model（简称为k1.5），k1.5是基于kimi-1.5 base model，通过强化学习训练得到的推理模型。

Kimi-1.5 base model

k1.5 base model是一个基于transformer的多模态大模型，论文没有给出详细的模型结构，只有如下的示意图

k1.5 base model的训练包括三个阶段：

Vision-language pretraining stage: 这一阶段的目的是让模型拥有语言和视觉的表征能力。训练时，模型先在纯文本的数据上进行训练，然后提高加入图文交错的数据进行训练，直到训练数据中图文交错的数据占比达到30%。模型的更新方式为先冻结LLM更新visual tower, 然后解冻LLM更新所有参数。
Vision-language cooldown stage: 这一阶段的目的是让模型保持多模态理解能力。作者发现，使用合成数据可以提高模型在这一阶段的表现。因此，作者使用闭源大语言模型，基于math, knowledge和code domain的pretraining data来合成了一些QA pair数据对，然后讲这些QA pair数据对加入到训练数据中。
Long-context activation stage: 这一阶段的目的是让模型在长上下文的数据上进行训练，以提升模型在长上下文上的理解能力。这一阶段包含了40%的full attention data以及60%的partial attention data。其中，full attention data是基于真实数据和合成的QA以及summary数据得到的，partial attention data是在cooldown data找那个通过均匀采样得到的。这一阶段，模型的上下文长度从4096逐步增加到131072。

Kimi k1.5

Kimi k1.5是基于k1.5 base model，通过进一步训练得到的推理模型。k1.5的训练包括四个阶段：

pretraining：这一步就是k1.5 base model的训练，包括三个小阶段。前面已经介绍过了。
vanilla SFT：这一步的目的是使得k1.5 base model具有指令跟随能力。对于non-reasoning任务，作者先使用人类标注产生一个seed dataset，然后基于seed dataset训练一个seed model，最后根据收集的prompt来使用seed model来生成回答。对于reasoning任务，作者使用了rejection sampling来扩展SFT数据集
long-CoT SFT：这一步的目的是让模型能够像人类一样进行推理，能够掌握最基本的推理策略，即：planning，evaluation，reflection和exploration。从而为RL训练提供一个良好的初始化。
RL：这一步就是通过RL来提高模型的推理能力。我们在下一节中进行详细的介绍。

RL

Problem Definition

给定一个训练数据集 $\mathcal{D} = \{(x_i, y_i^\star)\}_ {i=1}^n$，其中 $x_ i$ 是问题， $y_{i}^\star$ 是ground truth。我们希望找到一个模型 $\pi_{\theta}$ ，来解决这个问题。通常问题比较难，因此我们使用chain of thought（CoT）的方法来解决这个问题。具体做法就是让模型输出中间步骤 $z=(z_1, z_2, ..., z_m)$，来连接问题 $x_i$ 和答案 $y$。其中， $z_j$ 是模型在第 $j$ 步的推理结果，即 $z_t\sim\pi_{\theta}(x_i, z_{

通常，我们还会使用一个reward model $r_{\phi}$，来评估模型输出的答案的质量。一个常用的reward model是基于答案的正确性来评估的，即 $r_{\phi}(x_i, y, y^\star) = \mathbb{I}[y=y_i^\star]$ 。这样，我们要求解的问题就变成了最大化中间步骤和最终答案的reward，即

$$ \max_{\theta} \mathbb{E}_ {(x, y^\star)\sim\mathcal{D},(y,z,)\sim\pi_{\theta}} r_{\phi}(x, y, y^\star) $$

Policy Optimization

作者使用了online policy mirror descent来解决上面提到的优化问题。在每个iteration中，存在一个reference model $\pi_{\theta_r}$ ，以及一个当前要更新的模型 $\pi_{\theta}$ 。online policy mirror descent要解决的优化问题为：

$$ \min_{\theta} \mathbb{E}_ {(x, y^\star)\sim\mathcal{D}} \left[\mathbb{E}_ {(y,z,)\sim\pi_{\theta}}\left[r_{\phi}(x, y, y^\star) - \beta \mathcal{D}_ {KL}(\pi_{\theta}(y,z\mid x)\Vert \pi_{\theta_r}(y,z\mid x))\right]\right] $$

其中， $\beta$ 是超参数，用于平衡reward和KL散度 $\mathcal{D}_{KL}(\cdot)$.

上述问题有一个闭式解，即：

$$ \pi^\star(y,z\mid x)=\pi_{\theta_r}(y,z\mid x)\exp\left(\frac{r_{\phi}(x, y, y^\star)}{\beta}\right)/Z(x;\beta) $$

其中，

$$ Z(x;\beta):=\sum_{y,z}\pi_{\theta_r}(y,z\mid x)\exp\left(\frac{r_{\phi}(x, y, y^\star)}{\beta}\right) $$

是归一化因子。在闭式解的表达式中，我们对两边取对数，得到：

$$ r_{\phi}(x, y, y^\star) - \beta \log Z - \beta \log\frac{\pi^\star(y,z\mid x)}{\pi_{\theta_r}(y,z\mid x)}=0 $$

这是最优策略满足的等式。作者这里使用了L2 loss来优化当前策略 $\pi_{\theta}$ ，即：

$$ \min_{\theta} \mathbb{E}_ {(x, y^\star)\sim\mathcal{D}} \left[\mathbb{E}_ {(y,z,)\sim\pi_ {\theta_r}}\left[r_{\phi}(x, y, y^\star) - \beta \log Z - \beta \log\frac{\pi_{\theta}(y,z\mid x)}{\pi_{\theta_r}(y,z\mid x)}\right]^2\right] $$

这里需要注意的一点是response $(y,z)$ 是基于reference model $\pi_{\theta_r}$ 生成的，而不再是基于当前策略 $\pi_{\theta}$ 生成的。这是Kimi-1.5的RL训练和传统RL训练的一个不同点。这也是为什么k1.5说他是off-policy的原因。

接下来，我们就可以对上面的目标函数求梯度，我们将里层的函数展开为 $(a-b-c)^2=(a-b)^2-2(a-b)c+c^2$ 的形式，然后对 $\theta$ 求梯度，得到：

$$ \mathbb{E}_ {(x, y^\star)\sim\mathcal{D}} \left[\mathbb{E}_ {(y,z,)\sim\pi_{\theta_r}}\left[\nabla_{\theta}\log \pi_{\theta}(y,z\mid x)(r_{\phi}(x, y, y^\star) - \beta \log Z) - \frac{\beta}{2} \nabla_{\theta}\left(\log\frac{\pi_{\theta}(y,z\mid x)}{\pi_{\theta_r}(y,z\mid x)}\right)^2\right]\right] $$

如果我们对每个问题$x$,采样 $k$ 个response $(y,z)$ ，那么我们可以近似上式中内部的期望，得到：

$$ \frac{1}{k}\sum_{i=1}^k\left[\nabla_{\theta}\log \pi_{\theta}(y_i,z_i\mid x)(r_{\phi}(x, y_i, y^\star) - \bar{r}) - \frac{\beta}{2} \nabla_{\theta}\left(\log\frac{\pi_{\theta}(y_i,z_i\mid x)}{\pi_{\theta_r}(y_i,z_i\mid x)}\right)^2\right] $$

这里， $\bar{r}$ 是 $\beta \log Z$ 的估计值。作者提供了两种估计方法：

基于采样的 $(y_i,z_i)\sim \pi_{\theta_r}$ 对 $\beta \log Z$ 进行估计：

$$ \bar{r}=\beta\log\frac{1}{k}\sum_{j=1}^k\exp\left(\frac{r_{\phi}(x, y_j, y^\star)}{\beta}\right) $$

直接使用samples rewards的平均值来近似：

$$ \bar{r}=\frac{1}{k}\sum_{i=1}^k r_{\phi}(x, y_i, y^\star) $$

作者提到，第二种方法效果很好并且计算效率更高，因此作者在实验中使用了第二种方法。

训练时，作者每次从数据集中采样一个batch的样本，然后使用上述的梯度更新模型。模型参数更新完之后，作者将新的模型作为reference model，然后重复上述过程。

Remark 作者还探究了为什么不使用value network。作者认为，在强化学习中，value network通常用于评估当前状态的价值，但是在reasoning model中，训练的目的是让模型能够充分探索，以提高模型在不同任务中的泛化性。因此，作者认为使用value network可能会限制模型的探索能力。

Training Strategy

作者提出了两个提高采样效率的方法：

Curriculum Sampling. 这种采样方式会将问题按照难度进行排序，然后按照难度从易到难进行采样。以逐步提高模型的推理能力。
Prioritized Sampling.作者还采用了prioritized sampling来提高采样效率。也就是说，对于回答错误的问题，模型会进行更多的采样。

Infra

Training System

为了高效地进行RL训练，作者构建了一个iterative synchronous RL训练框架。框架如上图所示。框架的创新之处在于Partial Rollout，该方法可以更高效的处理复杂的推理轨迹。框架包含了以下几部分：

rollout worker: 该部分负责生成推理轨迹。然后将生成的推理轨迹加入到replay buffer中。
master: 管理data flow和replay buffer和train worker之间的通信。
train worker: 根据获取的rollout轨迹更新模型。
code execution service: 在代码相关任务中，该部分负责执行代码，并返回执行结果。

Partial Rollout：Partial Rollout的目的是为了整体的训练效率。其做法就是给定一个固定的outpu token budget，然后限制推理轨迹的长度。当长度超过token限制时，没有完成的部分就会被存入到replay buffer中，以供后续的训练使用。

Deployment Framework

根据前面的介绍，我们知道k1.5每个iteration的训练包括两步：

inference phase: 基于Reference model进行采样，生成推理轨迹。
training phase: 基于采样得到的推理轨迹，更新模型。

如果我们直接使用Megatron和vLLM来实现上述的训练和推理，那么会存在以下问题：

Megatron和vLLM的并行策略可能并不一致，因此很难进行参数共享
在训练过程中，vLLM可能会保留一些GPU，这就导致了训练和推理的资源分配不均。
推理和训练的资源需求可能并不一致，无法动态调控显卡资源

因此，作者构建了一个hybrid deployment framework来解决上述问题，其框架如下图所示。

该框架的主要优势在于使用Kubernetes Sidecar containers来在一个pod中共享所有的GPU资源。这样就避免了资源分配不均的问题。

数据

数据处理

RL prompt set. 作者认为prompt的quality和diversity对RL训练至关重要。因此作者基于diverse coverage, balanced difficuty以及accurate evaluation来构建了一个RL prompt set。对于多样性，作者确保数据集覆盖多个domain。对于平衡难度，作者通过多次采样，根据通过率来给每个样本的难易程度打分。对于准确性，作者筛掉了多选题，正确题和证明题，确保模型能够生成正确的推理步骤。最后，作者还让模型进行猜测，如果模型猜测的正确率比较高，那么就认为该样本是easy-to-hack的，就会筛掉。
Test Case Generation for Coding. 作者使用CYaRon来生成coding任务的测试用例。通过与Kimi k1.5结合，作者构建了一个包含323个测试用例的训练集。
Reward modeling for Math. 作者使用了两种方法来提高reward model的准确性。第一个是classic RM，作者基于InstructGPT，构造了大约800K的数据训练了一个value-head based RM。模型会基于问题，参考答案和模型生成的答案来判断模型生成的答案是否正确。第二个是Chain of Thought RM，作者基于收集的800k CoT数据对kimi进行了finetune，然后对模型生成的推理步骤进行打分。最终发现，Chain of Thought RM的效果更好。因此，作者在RL训练中使用了Chain of Thought RM。
Vision RL Data。作者从三个方面构建了vision RL数据集：real-world data, synthetic visual reasoning data以及text-rendered data.

数据集

pretraining：其中，纯文本数据包括Engligh, Chinese, Code, math reasoning以及Knowledge这5个领域。多模态数据包括captioning, image-text interleaving, OCR, Knowledge以及QA数据集等。附录B介绍了数据集的来源和处理过程。
SFT： vanilla SFT数据集包含1M的纯文本数据，其中包含500K的general QA数据，200K的coding数据，200K的数学和科学数据，5K的创作写作数据以及20K的长上下文任务（总结，QA，翻译和写作等）。作者还构建了1M的图文数据，包括chart理解，OCR，grounding，visual coding, visual reasoning以及visual aided math/science problems等
long-CoT SFT：该阶段的数据基于refined RL prompt set，使用了prompt engineering来构建了一个少量但高质量的long-CoT数据集。用于将reasoning能力内化到模型中。

Long2short

为了降低推理成本，作者提出了long2short的推理方法。该方法通过将长上下文推理转化为短上下文推理，让模型能够更加高效的完成推理。作者尝试了几种方法来实现long2short：

Model merging:将long-CoT模型和short-CoT模型进行合并，然后进行推理。这里采用的办法是对两个模型的权重取平均。
shortest rejection sampling：通过对同一个问题进行多次采样（论文中每个问题采样8次），然后选择最短的，正确的推理步骤作为最终答案。
DPO：通过对同一个问题进行多次采样，选择最短的正确的回答作为正样本，最长的回答作为负样本，然后使用DPO进行训练。
Long2short RL：作者在RL阶段，选择一个在performance和token efficiency之间达到平衡的模型作为 base model，然后加入了一个long2short RL训练阶段。该阶段，作者加入了length penalty以及降低了maximum rollout length来鼓励模型生成更短的推理步骤。

Length penalty

Length penalty的目的是降低模型的overthinking和训练成本。作者加入了一个length reward，对于问题 $x$ 和采样的回答 $(y_i,z_i)$ ，回答 $(y_i,z_i)$ 的length定义为 $len(x_i)=\text{length}([z_i, y_i])$ length reward定义为：

$$ r_{\text{length}}(x, (y_i,z_i))=\begin{cases} \lambda, & \text{if } r(x, y_i, y^\star) = 1 \\ \min(0,\lambda), & \text{if } r(x, y_i, y^\star) = 0 \\ \end{cases} $$

其中

$$ \lambda = 0.5 - \frac{len(x_i)-\min_{j}len(x_j)}{\max_{j}len(x_j)-\min_{j}len(x_j)} $$

也就是说，当回答正确时，我们鼓励模型生成更长的推理步骤。反之，我们鼓励模型生成更短的推理步骤。

实验

实验结果

K1.5在long-CoT任务上的表现

K1.5在Short-CoT任务上的表现

Long Context Scaling 作者在实验中还探究了上下文长度对模型推理能力的影响。作者针对几个模型进行了实验，结果在图5和图6里面。结果发现，随着上下文长度的增加，模型的推理能力会逐渐提升。
Long2short

消融实验

Scaling of model size and context length. 作者探究了模型大小和上下文长度对模型推理能力的影响，结果在图8里面。结果发现
1. 小模型可以通过Long CoT来达到大模型的效果
2. 大模型具有更高的token效率
3. 理想情况下，使用具有更长上下文的大模型，可以同时达到更高的推理能力和更高的token效率，否则，使用上下文长度更长的小模型
Effects of using negative gradients. 作者探究了使用负梯度对模型推理能力的影响。作者与ReST方法进行了对比，结果在图10里面。结果发现，ReST回到只模型产生更长的推理步骤。作者认为，选取合适的优化方法，可以有效提升模型的推理能力。
Sampling strategies. 作者还探究了采样策略对模型推理能力的影响。作者与均匀采样进行了对比，结果在图9里面。结果发现，论文提出的采样策略可以有效提升模型的推理能力。

结论

作者提出了Kimi k1.5，一个基于强化学习训练的多模态推理模型。作者介绍了Kimi k1.5的训练方法，数据集，infra上的优化以及long2short的推理方法。作者的主要贡献在于：

作者发现，模型的上下文长度可以有效提升LLM的推理能力。
作者提出了基于online mirror descent的强化学习训练方法。
作者提出了long2short的推理方法，可以有效提升short CoT模型的推理能力。

论文的问题在于对于多模态的内容介绍较少，感觉还是更倾向于文本推理任务。

参考文献

Kimi k1.5: Scaling Reinforcement Learning with LLMs