Stepfun on Jiang Yi(姜祎)'s Homepage

Notes on Step3-VL 10B

Fri, 13 Feb 2026 18:05:47 +0800

Introduction

Step3-VL-10B 基于 Perception Encoder 和 Qwen3 开发得到，模型在预训练阶段使用了 1.2T 多模态 token, 在 post training 阶段使用了 PaCoRe 来提高模型的表现。作者强调关键改进在于高质量的预训练数据以及 RL 阶段的提升。

总的来说，感觉这是阶跃在多模态大模型领域的一次初步尝试，使用的技术路线都比较成熟。

Method

Architecture

Step3-VL-10B 包含 3 个模块：

ViT: 基于 Perception Encoder, 大小为 1.8B
MLP: 基于 DeepSeek-OCR 构建了一个两层的卷积层，将视觉 token 个数压缩为原来的 16 倍，对应代码如下

1
2
3
4
5
6
7


# vision_encoder.py StepRoboticsVisionEncoder
self.vit_downsampler1 = nn.Conv2d(self.hidden_size, self.hidden_size * 2, kernel_size=3, stride=2, padding=1)
self.vit_downsampler2 = nn.Conv2d(self.hidden_size * 2, self.hidden_size * 4, kernel_size=3, stride=2, padding=1)

# modeling_step_vl.py _process_image_features
image_features = self.vision_model.vit_downsampler1(image_features)
image_features = self.vision_model.vit_downsampler2(image_features)

LLM: 基于 Qwen3 的 Qwen3-8B

对于输入的图片，Step3-VL-10B 采用了 LLaVA-OneVision 的做法，即将图片分为 $728\times 728$ 的 global thumnail 和 $504\times 504$ 的 local crop.

1
2
3
4


# modeling_step_vl.py _process_image_input
image_features = self._process_image_features(image_features)
patch_image_features = self._process_image_features(
 patch_image_features) if patch_image_features is not None else None

Pre-training

预训练的数据包括：

knowledge: knowledge 数据又包括图文交错数据，image-text pairs 数据
education: 15M K12, university, adult education 数据
OCR: 又分为以下几类
- image to text: 10M (real-world) + 30M (synthetic) 数据
- image to code: 10M markup-based code (latex, matplotlib 等) 数据，15M 合成的 infographics 数据，5M reconstruction (tikz) 数据
- document to text: 80M full-page 数据
- document to code: HTML, markdown, latex 等数据，共 4M tables 和 100M formulas
grounding and counting: 400M 数据
VQA: 10M 数据
GUI: 23M 数据

训练使用了 AdamW 优化器，一共训练了 1.2T token, batch size 为 8192, 上下文长度为 4096.

Post-training

post-training 包括 SFT 和 RL 两个阶段

SFT 阶段又包括了两个小的 stage, 第一个 stage 用于提高模型的纯文本推理能力，纯文本数据和多模态数据的比例为 9:1,训练使用了 190B token; 第二个 stage 用于提高模型的多模态推理能力，纯文本数据和多模态数据的比例为 1:1. 训练使用了 36B token. SFT 训练时 batch size 为 32, 上下文长度为 128K

RL 阶段作者使用了 PPO 算法进行训练。reward function 也是分为 rule-based 和 model-based

在 RLVR 之后，作者还进行了 RLHF 来提高模型的对齐能力。

作者进一步使用了 PaCoRe 来提高模型的并行推理能力。

Experiments

Step3-VL-10B 的表现如下所示，可以看到在 10B 模型下面，Step3-VL-10B 的表现达到了 SOTA.

Ablation Study

作者首先对比了 perception encoder 和 DINOv3 作为 vision encoder 的表现，结果如下表所示

Vision Encoder	Perception BLINK	Perception Omni.	Perception MMVP	Perception OCRBench	General MMStar	General SVQA	General CCBench	General V*	General MMMU	General ReMI
DINOv3	42.35	43.31	28.00	57.60	41.43	22.18	56.32	34.55	46.56	24.50
PE-lang (Ours)	41.19	43.57	32.00	70.10	42.10	21.15	59.39	37.17	47.67	26.08
Δ	-1.16	+0.26	+4.00	+12.50	+0.67	-1.03	+3.07	+2.62	+1.11	+1.58

作者分析认为由于 DINOv3 在纯视觉任务上进行训练，其表现不如使用语言监督信号的 perception encoder

作者还对比了 AdamW 和 Muon 两种优化器，结果如下表所示

Optimizer	Perception BLINK	Perception Omni.	Perception MMVP	Perception OCRBench	General MMStar	General SVQA	General CCBench	General V*	General MMMU	General ReMI
Muon	41.14	42.73	32.00	67.70	44.58	27.08	60.72	36.65	47.56	22.23
Adam (Ours)	40.72	44.94	29.33	71.10	41.77	20.60	60.13	39.27	46.11	25.00
Δ	-0.42	+2.21	-2.67	+3.40	-2.81	-6.48	-0.59	+2.62	-1.45	+2.77

结果发现 Muon 可以解决大规模数据的噪声和不平衡问题，但是作者没有使用 Muon, 原因是 Muon 对参数的初始化比较敏感

作者还探究了 Qwen3-VL 使用的 Deepstack 的有效性，结果如下表所示

Technique	Perception BLINK	Perception Omni.	Perception MMVP	Perception OCRBench	General MMStar	General SVQA	General CCBench	General V*	General MMMU	General ReMI
w/ DeepStack	40.72	42.92	26.00	71.20	43.31	28.66	63.94	36.65	47.44	26.96
w/o DeepStack (Ours)	40.61	43.57	31.33	69.30	42.44	25.20	62.80	38.22	47.78	26.96
Δ	-0.11	+0.65	+5.33	-1.90	-0.87	-3.46	-1.14	+1.57	+0.34	+0.00

结果发现，尽管 DeepStack 可以加速训练，但是对于下游任务的提升非常有限，因此作者没有使用这个策略。

对于 RL 训练，作者发现随着训练进行，模型的 reward 稳步提升。但是其输出长度并不是单调提升的，如下图所示

作者分析认为这是由于模型在 reasoning 任务和 perception 任务上模型使用的模式不同导致的，reasoning 任务上模型使用更长的输出长度来解决问题，而对于 perception 任务，由于答案唯一且确定，因此模型通过多次探索后会逐渐收敛到唯一的确定性模式，直接给出对应的答案。因此，其输出长度会越来越短。作者针对这种现象给出了一个假设，即针对 perception 任务，我们的训练数据并不包含思考的过程，而这种数据则让模型只能选择直接回答或者瞎猜，而不是先思考再回答。为了解决这个问题，作者使用了 PaCoRe 来让模型通过 proposal-then-refinement 策略来提高模型的思考长度

Conclusion

作者介绍了 Step3-VL，一个 10B 的多模态大模型，作者详细介绍了模型的架构，训练以及数据。

作者认为后续工作有：

通过 universal RL Scaling 提高 token efficiency:
1. 将算力重心从 pre-training 迁移到 RL, 这一点与 DeepSeek-V3.2 一致
2. 消除过度思考，提高模型的 reasoning efficiency
提高模型理解物理世界的能力
1. 构建 world model 帮助模型理解世界
2. 使用 high-fidelity environment 来提高模型对于物理定律的理解能力
3. 具身智能

References

arxiv

Notes on MFA

Sat, 23 Aug 2025 16:04:34 +0800

阶跃星辰等提出了 Multi-matrix Factorization Attention (MFA), 一个新型注意力机制，用于在 KV cache 限制下最大化模型的表现。

Introduction

multi-head attention (MHA) 的问题在于，其 KV cache 的内存占用（memory footprint）随 sequence length 以及 batch size 线性增长，从而成为了 LLM 在 decoding 阶段的瓶颈。

为了解决 MHA 的内存占用过高问题，已有的工作如 MQA, GQA 等通过共享 key, value projection 来降低 KV cache size. 而 DeepSeek-V3 提出的 MLA 则是通过对 key, value projection 进行 low-rank compression, 然后只存储 latents 的方法来降低 KV cache size.

但是，已有的这些方法的问题在于，当我们设置 KV cache budget 之后，它们的表现就比标准的 MHA 要差。

基于以上这些发现，作者首先分析了已有 attention 机制的 modeling capacity, 然后使用一个统一的框架来表示这些 attention 机制。作者发现，attention heads 的个数以及 dimension 对模型表现有较大影响。

基于这个发现，作者提出了 Multi-matrix Factorization Attention (MFA), 以及其变体 MFA-Key-Reuse (MFA-KR). MFA 的主要目的是在有限的 KV cache size 下提高模型的表现。

Background

作者首先介绍了 GMHA 的概念，GMHA 由三部分组成：

QK circuit: 决定了信息之间如何交互
valueoutput (VO) circuits：决定了信息如何传递
per-head softmax attention.

接下来，作者介绍了 Fully Parameterized Bilinear Attention (FPBA), FPBA 的定义如下：

$$ O = \sum_{c=1}^d\left(\sum_{j=1}^N\phi\left(\frac{xW_cx_j}{H}\right)x_jU_c\right) $$

其中 $\phi$ 是 softmax 函数，$d$ 是模型的 hidden dimension, $N$ 是 sequence length, $W_c,U_c\in\mathbb{R}^{d\times d}$ 每个 channel 上的参数矩阵

每个 channel 都有各自的参数 $W_c, U_c$ 来获取 $x_i$ 与 $x_j$ 之间的信息
提高泛化性，所有 channel 的 $U_c$ 组合起来可以遍历 $d$ 维空间中的任意一个 permutation, 这样就避免来的信息损失
利用率高，FPBA 获取了 $x_i$ 与 $x_j$ 之间 $d$ 维空间可能的表示

基于以上这三个特点，作者认为 FPBA 是 GMHA 框架的一个 capacity upper bound. 此时每个 token 的 KV cache 占用为 $2d^2$ (key and value).

然后，作者分析了 MHA 及其变体与 GMHA 的关系，MHA 可以写作如下形式

$$ \begin{aligned} O &= \sum_{c=1}^h\left(\sum_{j=1}^N\phi\left(\frac{xQ_c(x_jK_c)^T}{\sqrt{d}}\right)x_jV_c\right)O_c^T\\ &= \sum_{c=1}^h\left(\sum_{j=1}^N\phi\left(\frac{x(Q_cK_c^T)x_j^T}{\sqrt{d}}\right)x_jV_cO_c^T\right) \end{aligned} $$

其中 $Q_c,K_c,V_c\in\mathbb{R}^{d\times h_d}$, $O_c\in\mathbb{R}^{d\times h_d}$ 分别是 query, key, value, output projection layer 对应的权重矩阵，$n$ 是 attention head 的个数，令 $h_d$ 为每个 attention 的 head dimension，则我们有 $nh_d=d$.

可以看到，MHA 实际上是一个特殊的 FPBA, 其中，$W_c$ 和 $U_c$ 分别由秩为 $h_d$ 的低秩分解 $Q_cK_c^T$ 以及 $V_cO_c^T$ 近似。此时每个 token 的 KV cache 占用为 $2d$ (key and value).

MQA 可以看作是 GQA 的一个特殊情况。对于 GQA 来说，我们有一个 group size $g\in[1, h]$, 当 $g=1$ 时，GQA 就是 MHA. 当 $g=h$ 时，GQA 就是 MQA, 通常 $g$ 满足 $h\ \%\ g=0$. GQA 的表达式与 MHA 基本相同，只是多个 head 会共享一个 $K_c$ 以及 $V_c$. 此时，每个 token 的 KV cache 占用为 $2gh_d$. 对于 MQA，其每个 token 的 KV cache 占用为 $2h_d$.

对于 MLA, 其表达式如下所示

$$ \begin{aligned} O &= \sum_{c=1}^m\left(\sum_{j=1}^N\phi\left(\frac{xS_QQ_c(x_jS_KK_c)^T}{\sqrt{d}}\right)x_jS_VV_c\right)O_c^T\\ &= \sum_{c=1}^m\left(\sum_{j=1}^N\phi\left(\frac{x(S_QQ_cK_c^TS_K^T)x_j^T}{\sqrt{d}}\right)x_jS_VV_cO_c^T\right) \end{aligned} $$

其中，$S_Q,S_K,S_V\in\mathbb{R}^{d\times C}$ 在所有的 heads 中是共享的，$Q_c,K_c,V_c\in\mathbb{R}^{C\times h_d}$ 是每个 head 的 query, key, value projection layer 的参数，是 latent factorization 的维度。与 FPBA 相比，我们可以看到，MLA 实际上是在 $d/m$ 个 head 上共享了参数，其中，$W_c$ 和 $U_c$ 分别由秩为的低秩分解 $S_QQ_cK_c^TS_K^T$ 以及 $S_VV_cO_c^T$ 近似。尽管模型中 $C>h_d$, 但是最终的 rank 仍然是 $h_d$, 因此模型的表现也就受到了限制。

Method

对已有的 attention 分析之后，作者认为，要提高模型的表现，attention 需要做到亮点：

最小化 KV cache 占用和参数量
attention 的 capacity 尽可能接近 FPBA

基于这两个原则，作者提出了 MFA, MFA 主要依赖三个策略：

提升 attention heads 的 head dimension, 通过提高 head dimension, 我们可以有效提高 attention head 的表达能力
使用矩阵分解来降低参数量
使用单一的 KV head 来降低 KV cache 内存占用

最终，MFA 的表达式如下所示

$$ \begin{aligned} O &= \sum_{c=1}^m\left(\sum_{j=1}^N\phi\left(\frac{xS_QQ_c(x_jS_K)^T}{\sqrt{d}}\right)x_jS_V\right)O_c^T\\ &= \sum_{c=1}^m\left(\sum_{j=1}^N\left(\frac{x(S_QQ_cS_K^T)x_j^T}{\sqrt{d}}\right)x_jS_VO_c^T\right) \end{aligned} $$

其中 $S_Q,S_K,S_V\in\mathbb{R}^{d\times C}$ 是所有的 attention head 所共享的，$Q_c,O_c\in\mathbb{R}^{C\times C}$ 是每个 head 的 query up projection 和 output projection, $C$ 是 latent factorization 的维度。

在 inference 的时候，由于我们只需要保存 $x_jS_K$ 和 $x_jS_V$, 因此所需要的 KV cache size 为 $2C$. 与 FPBA 相比，MFA 分别使用 $S_QQ_cS_K^T$ 和 $S_VO_c^T$ 来近似 $W_c$ 和 $U_c$, 近似矩阵的 rank 为 $C$. 由于 $C>d$, 因此其表达能力也更强，MFA 有如下优势：

scalable head count: MFA 可以支持使用更多的 attention heads, 每增加一个 heads, 所需要的额外参数为 $2C^2$. 并且，增加 attention heads 个数不会增加 KV cache 占用
enhanced head expressiveness: MFA 近似矩阵的 rank 为 $C>d$, 因此表达能力更强
Compatibility with position encodings: MFA 可以无缝集成 position encoding.

为了进一步降低 MFA 的 KV cache 占用，作者提出了 MFA-Key-Reuse (MFA-KA). 核心思想是使用 $S_K$ 来表示 $S_V$, 这样可以额外降低 $50\%$ 的 KV cache 占用，表示方法如下所示

$$ S_V = S_K + \alpha\odot NS_K = (I +\mathrm{diag}(\alpha)N)S_K $$

其中 $N\in\mathbb{R}^{N\times N}$, $\alpha\in\mathbb{R}^C$.

最终，MFA, MFA-KR 与 GQA 的对比如下图所示

不同 attention 的量化对比如下表所示

Method	KV Cache	Parameter	Heads	Factor. rank per head	Shared latent subspace Dim.	Total effec. rank
FPBA	$2d^2$	$2d^3$	$d$	$d$	$d$	$d^2$
MHA	$2d$	$4d^2$	$n$	$h_d$	$d$	$nh_d$
MQA	$2h_d$	$(2 + 2/n)d^2$	$n$	$h_d$	$h_d$	$nh_d$
GQA	$2gh_d$	$(2 + 2g/n)d^2$	$n$	$h_d$	$gh_d$	$nh_d$
MLA	$2C$	$5dC + d^2$	$m$	$h_d$	$C$	$mh_d$
MFA	$2C$	$3Cd + 2mC^2$	$m$	$C$	$C$	$mC$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


class Step3vAttention(nn.Module):
 def __init__(self, config: Step3VLConfig, layer_idx):
 super().__init__()
 self.config = config
 self.layer_idx = layer_idx
 self.head_dim = getattr(config, "head_dim", config.hidden_size // config.num_attention_heads)
 self.num_key_value_heads = 1
 self.total_num_kv_heads = self.num_key_value_heads
 self.num_attention_heads = config.num_attention_heads
 self.num_key_value_groups = config.num_attention_heads // self.num_key_value_heads
 self.q_size = getattr(config, "share_q_dim", self.head_dim)
 self.kv_size = self.num_key_value_heads * self.head_dim
 self.scaling = self.head_dim**-0.5
 self.is_causal = True

 self.q_proj = nn.Linear(config.hidden_size, self.q_size , bias=False)
 self.k_proj = nn.Linear(config.hidden_size, self.head_dim, bias=False)
 self.v_proj = nn.Linear(config.hidden_size, self.head_dim, bias=False)
 self.o_proj = nn.Linear(config.num_attention_heads * self.head_dim, config.hidden_size, bias=False)
 # query down projection normalization
 self.inter_norm = Step3vRMSNorm(self.q_size, eps=config.rms_norm_eps)
 # query up projection
 self.wq = nn.Linear(self.q_size, self.head_dim * self.num_attention_heads, bias=False)

 def forward(
 self,
 hidden_states: torch.Tensor,
 position_embeddings: Tuple[torch.Tensor, torch.Tensor],
 attention_mask: Optional[torch.Tensor],
 past_key_value: Optional[Cache] = None,
 cache_position: Optional[torch.LongTensor] = None,
 **kwargs: Unpack[FlashAttentionKwargs],
 ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
 input_shape = hidden_states.shape[:-1]

 query_states = self.q_proj(hidden_states)
 key_states = self.k_proj(hidden_states).view((*input_shape, -1, self.head_dim)).transpose(1, 2)
 value_states = self.v_proj(hidden_states).view((*input_shape, -1, self.head_dim)).transpose(1, 2)

 query_states = self.inter_norm(query_states)
 query_states = self.wq(query_states).view((*input_shape, -1, self.head_dim)).transpose(1, 2)

 cos, sin = position_embeddings
 query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)

 ...

Conclusion

作者在本文中提出了 MFA 以及 MFA-KR, 一个在 KV cache 有限的条件下最大限度提高 attention 表达能力的 attention 机制。