Qwen on Jiang Yi(姜祎)'s Homepage

Notes on Qwen3-Next

Fri, 23 Jan 2026 10:29:56 +0800

Introduction

当前大语言模型在性能与效率上面临双重挑战：纯 Softmax 注意力计算成本高，而纯线性注意力则性能不足。Qwen3-Next 尝试通过混合注意力机制解决这一矛盾，同时结合 MoE 架构与多项训练优化策略，实现在保持高性能的同时大幅提升训练与推理效率。

Qwen3-Next 包含三个模型：

Qwen3-Next-80B-A3B-Base
Qwen3-Next-80B-A3B-Instruct
Qwen3-Next-80B-A3B-Thinking

Method

Architecture

模型架构如下图所示

Hybrid Attention

作者首先总结了 linear attention 和 softmax attention 各自的优缺点。

	pros	cons
linear attention	fast	low performance
softmax attention	slow	high performance

因此，作者的动机就是是结合 linear attention 与 softmax attention, 在局部利用 linear attention 的高效性来提高训练和推理效率，在关键部分使用 softmax attention 来提高模型的能力。这种混合注意力机制之前也有很多模型采用，比如 MiniMax-01 等。最终 Qwen3-Next 使用了 Gated DeltaNet+Gated Attention 的混合注意力机制，模型的 transformer layers 按照 4 个为一组，前三层使用 Gated DeltaNet, 第四层使用 Gated Attention.

下面是一些细节：

Gated DeltaNet 相比于 SWA 和 Mamba2, 其 in-context learning 能力更强
对于 softmax attention:
1. 使用了 Gated Attention 提出的 gating 机制来解决 massive activation 和 attention sink 问题
2. 将 attention head 的 dimension 从 128 提高到 256
3. 使用了和 DeepSeek-V3 类似的 partial RoPE 机制，仅对前 $25\%$ 的元素进行旋转

MoE

1 个共享专家，512 个路由专家，其中激活专家个数为 10 个。
对于 MoE router 的参数，作者还进行了 normalization 来保证每个专家被选择的概率相同。
与 Qwen3 一致，Qwen3-Next 也是用了 Global-batch load balancing 策略，在保持激活专家数不变的情况下，通过提高总专家个数来降低训练损失。

Normalization and Training

使用 Gemma 提出的 Zero-Centered RMSNorm 以及 weight decay 来避免过大的权重出现
为了提高数据使用效率，作者还使用了 MTP 策略来提高训练效率，模型表现以及 Speculative decoding 的接受率。
预训练时，Qwen3-Next 使用了15T token 进行训练，训练时间相比于 Qwen3-30B-A3B 有了大幅度的提升

Experiments

Efficiency

下图是 Qwen3-Next 与 Qwen3-32B 模型的训练效率对比

从结果可以看出，相比于 Qwen3-32B, Qwen3-Next 只用了 $9.3\%$ 的算力就达到了更强的表现。

并且，在 inference 阶段，由于使用了 linear attention, Qwen3-Next 的效率也更高，下面是 Qwen3-Next 相比于 Qwen3-32B 的效率提升

	4K	32K
Prefilling	$7\times$	$10\times$
Decoding	$4\times$	$10\times$

Performance

下面是 Qwen3-Next-Base 的表现

可以看到，Qwen3-Next-Base 在多个 Benchmark 上的表现仅次于 Qwen3-235B-A22B

Qwen3-Next-Instruct 的表现如下表所示

Benchmark	Qwen3-Next-80B-A3B-Instruct	Qwen3-235B-A22B-Instruct-2507	Qwen3-32B Non-thinking	Qwen3-30B-A3B-Instruct-2507
SuperGPQA	58.8	62.6	43.2	53.4
AIME25	69.5	70.3	20.2	61.3
LiveCodeBench v6	56.6	51.8	29.1	43.2
Arena-Hard v2	82.7	79.2	34.1	69.0
LiveBench	75.8	75.4	59.8	69.0

Qwen3-Next-Instruct 的长文本表现（RULER Benchmark）如下

Model	Avg.	4K	8K	16K	32K	64K	96k	128K	192k	256k	384k	512k	640k	768k	896k	1M
Qwen3-30B-A3B-Instruct-2507	86.8	98.0	96.7	96.9	97.2	93.4	91.0	89.1	89.8	82.5	83.6	78.4	79.7	77.6	75.7	72.8
Qwen3-235B-A22B-Instruct-2507	92.5	98.5	97.6	96.9	97.3	95.8	94.9	93.9	94.5	91.0	92.2	90.9	87.8	84.8	86.5	84.5
Qwen3-Next-80B-A3B-Instruct	91.8	98.5	99.0	98.0	98.7	97.6	95.0	96.0	94.0	93.5	91.7	86.9	85.5	81.7	80.3	80.3

可以看到， Qwen3-Next-Instruct 在 1M 长度范围内保持稳定性能，整体平均得分 91.8，接近 Qwen3-235B（92.5）。

Qwen3-Next-Thinking 的表现如下表所示

Benchmark	Qwen3-Next-80B-A3B-Thinking	Gemini-2.5-Flash Thinking	Qwen3-32B Thinking	Qwen3-30B-A3B-Thinking2507
SuperGPQA	60.8	57.8	54.1	56.8
AIME25	87.8	72.0	72.9	85.0
LiveCodeBench v6	68.7	61.2	60.6	66.0
Arena-Hard v2	62.3	56.7	48.4	56.0
LiveBench	76.6	74.3	74.9	76.8

可以看到，Qwen3-Next-Thinking 的表现在除了 Livebench 之外的三个 Benchmark 均达到了 SOTA

Conclusion

Qwen3-Next 通过混合注意力架构与精细化 MoE 设计，在训练与推理效率上实现突破性提升。其仅以较小计算代价达到接近超大模型性能的表现，为下一代高效大语言模型的设计提供了重要参考。

References

Qwen3-Next: Towards Ultimate Training & Inference Efficiency

Notes on Gated Attention

Tue, 20 Jan 2026 15:41:52 +0800

Introduction

现有的大部分模型都基于 Transformer 提出的 softmax attention (SDPA), 虽然也有相关的改进工作，但是主要集中于降低 attention 计算复杂度，提高 attention 在推理时的内存使用效率等。之前的工作提出了关于 attention 的两个问题：

attention sink, 即模型的注意力会放在初始几个 token 上, 这限制了模型的上下文扩展能力
massive activation, 少部分 token 的 hidden states 会非常大，这限制了模型的训练稳定性

在本文中，作者通过在 attention 中加入 gating 机制来探索 gating 对模型表现和训练稳定性的影响。尽管 gating 并没有降低 attention 计算复杂度，但是 gating 提出了一个新的视角，即 sparity 与 attention sink 和 massive activation 息息相关，这为后面 sparse attention 的研究提供了 Insight.

作者发现，对 Multi head attention 的输出进行 head-specific gating 的效果最好，并且这种方式还可以提高训练稳定性，模型的表达能力和长上下文能力。作者还进一步分析了这种 gating 方式更好的原因，发现有两点：

non-linearity: 通过 gating 可以有效提高 output projection layer 输入的秩，进而提高表达能力
sparsity: gating 可以降低 massive activation 和 attention sink 的影响

作者最终推荐使用 element-wise SDPA gating 方式来进行训练

作者主要介绍了 gating 和 attention sink 这两部分的工作。

gating 早在 LSTM 和 GRU 使其就得到了广泛的运用，在 transformer 之后，相关的现行注意力也有应用，比如 MiniMax-01 所使用的 Lightning Attention 等，但是这些工作没有系统性探究 gating 背后的机制。

第二部分是 attention sink, attention sink 现象由 StreamingLLM 提出，即模型会将相当一部分注意力权重方开始开始的几个 token 上。而本文提出的 gating 机制可以缓解 attention sink 现象。

Method

首先是标准 MHA 定义：

$$ \begin{aligned} Q &= XW_Q, K=XW_K, V=XW_V\\ \mathrm{Attn}_i(Q,K,V) &= \mathrm{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V, i=1,\dots,h\\ \mathrm{MHA}(Q, K, V) &= \mathrm{Concat}([\mathrm{Attn}_1,\dots,\mathrm{Attn}_h])\\ O &= \mathrm{MHA}(Q, K, V) W_O \end{aligned} $$

这里 $X\in\mathbb{R}^{n\times d}$ 是 transformer layer pre-normalization 的输出（或者 attention block 的输入）, $n$ 是 sequence length, $d$ 是 hidden size, $h$ 是 number of heads, $d_k$ 是 head dimension.

接下来，作者介绍了不同的 gating 策略。这里作者用同一的公式来进行表示

$$ Y' = g(Y,X,W_\theta, \sigma) = Y\odot \sigma(XW_\theta) $$

这里 $Y$ 是输入， $X$ 是 attention 的输入，$W_\theta$ 是可学习权重

Position 首先是位置，作者考虑了如下几种变体：

$$ \begin{align} \mathrm{MHA}(Q, K, V)' &= \mathrm{MHA}(Q, K, V)\odot \sigma\left(X W_\theta)\right) \tag{G1}\\ Q' &= Q\odot \sigma\left(XW_\theta\right) \tag{G2}\\ K' &= K\odot \sigma\left(XW_\theta\right) \tag{G3}\\ V' &= V\odot \sigma\left(XW_\theta\right) \tag{G4}\\ O' &= O\odot \sigma\left(XW_\theta\right) \tag{G5}\\ \end{align} $$

这里 $\sigma$ 是激活函数，$W_\theta$ 是激活函数的可学习参数，我们可以将其理解为一个 linear layer, 即当前模块的输出取决于输入 hidden sates 经过一个线性层和激活层之后的结果，相似的做法还有 MoE 中的 gating layer, NSA 中的 gating layer 等。对应的示意图如下所示

granularity 作者设计了不同粒度的 gating（假设输入为 $X\in\mathbb{R}^{n\times h\times d_k}$）：

head-shared: 不同 head 共享 gating score, Y'[i,h,k]=gate[i,k]*Y[i,h,k]
head-wise: 同一个 head 共享 gating score, Y'[i,h,:]=gate[i,h]*Y[i,h,:]
element-wise: 不同元素不共享 gating score, Y'[i,h,k]=gate[i,h,k]*Y[i,h,k]

从 attention 的角度看，不同 head 本身就承担不同的语义子空间，如果强行共享 gating，会破坏这种分工。

format 作者还构建了 multiplication 和 addition 两种形式：

multiplication: $Y'=Y\odot \sigma(XW_\theta)$
addition: $Y'=Y+\sigma(XW_\theta)$

activation function 本文中作者使用了 SiLU 和 sigmoid 两种形式，即

$$ \sigma_{\mathrm{sigmoid}}(x) = \frac{1}{1+e^{-x}},\quad \sigma_{\mathrm{SiLU}} = x*\sigma_{\mathrm{sigmoid}}(x)=\frac{x}{1+e^{-x}} $$

Experiments

作者构建了三个模型进行实验，模型配置如下表所示

Model	1.7B-28 layers	1.7B-48 layers	15B-A2.4B MoE
Layers	28	48	24
query heads	16	16	32
key/value heads	8	8	4
head dim	128	128	128
tie embedding	yes	yes	no
QK normalization	yes	yes	yes
hidden size	2048	1536	2048
ffn hidden size	6144	4608	768
experts	-	-	128
top-K	-	-	8

首先是不同 gating 方法对 MoE model 影响，结果如下图所示

结论如下：

对 SDPA 的输出 (G1) 或者 value (G2) 进行 gating 效果最好
head-specific gating 效果更好
multiplication 效果比 addition 效果更好
sigmoid 效果比 SiLU 效果更好

总的来说，position 对最终结果提升最明显，其次是 granularity 和 activation function.

接下来是不同 gating 方法对 dense model 的影响，作者构建了两个 dense 模型，参数都是 1.7B, 这两个模型的 layers 和 FFN hidden size 不同（通过调整保持总参数一致）。作者对比了 G1 和 baseline 的表现，结果如下图所示

结论验证了 gating 机制可以有效提高模型的表现。作者还发现使用 gating 之后，模型的训练也更加稳定，训练的损失变化曲线如下图所示

Analysis

首先，作者对 multi head attention 进行了重写，得到如下形式

$$ o_i^k = \sum_{j=1}^i\left(S_{ij}^k X_jW_V^k\right)W_O^k = \sum_{j=1}^i S_{ij}^k X_j(W_V^kW_O^k) $$

也就是说，$W_K$ 和 $W_O$ 可以吸收到一起，由于 $W_V^j\in\mathbb{R}^{d\times d_k}$, $W_O^k\in\mathbb{R}^{d_k\times d}$, 从而 $\mathrm{rank}(W_V^jW_O^k)\leq \max(\mathrm{rank}(W_V^j), \mathrm{rank}(W_O^k))\leq d_k$. 对于 GQA 和 MQA, 最终的有效秩会进一步降低。

而使用本文提到的 G1 和 G2 gating 策略之后，我们相当于是通过非线性机制提高了上面的秩，进而解决了 softmax attention 表达能力不足的问题, 实际上，StepFun 的 MFA 也是类似的思想。下面是 G1 和 G2 做的改进：

$$ \begin{align} o_i^k &= \sum_{j=1}^i\left(S_{ij}^k \mathrm{gating}(X_jW_V^k)\right)W_O^k\tag{G1}\\ o_i^k &= \mathrm{gating}\left(\sum_{j=1}^iS_{ij}^k X_jW_V^k\right)W_O^k \tag{G2} \end{align} $$

通过 gating 的非线性机制，我们提高的矩阵的秩，进而提高了模型的表达能力，而 G5 提升有限的原因也在于此。实验结果如下图所示

可以看到，不同的 non-linearity 方法对模型表现都有提升，这验证了矩阵秩会影响模型表达能力的分析。

接下来，作者探究了 gating 机制对 attention score distribution 的影响，结果如下图所示

实验结果说明：

有效的 gating 机制对应的 attention score 是非常稀疏的
head-specific sparsity 非常重要，当在不同的 head 共享 gating 时，模型表现会有所下降
gating 必须与 query 相关，与 G2 先比，G1 的表现更好，这说明 gating score 更依赖于 query. 作者认为基于当前 query token 构建 gating, 可以有效过滤历史 token 的噪音信息
non-sparse gating 效果比较差，作者构建了一个 non-sparse 版本的 sigmoid, 结果发现模型表现非常差，这说明了 attention score 应该是一个稀疏形式

通过前面的分析和实验结果，作者认为 gating 机制还可以缓解 attention sink 现象，作者对 baseline 以及 G1 两种方法的 attention 分布进行了可视化，结果如下图所示

实验结果整理如下表所示

method	massive activation	attention sink
baseline	high	high
input-independence	high	high
head-shared gating	low	high
head-specific gating	low	low

因此，作者的结论为，input-dependent, head-specific gating 可以提高 attention score distribution 的 sparsity, 进而减缓 attention sink. 并且引入 spaisity 之后，我们还可以避免 massive activation, 进而使用更低的精度进行训练。

最后，作者探究了以下 gating 机制的上下文扩展能力，作者在已有的模型上基于 32k 上下文长度使用了 80B token 进行 continue pre-training, 然后使用 YARN 将模型上下文长度扩展到了 128K。测试的结果如下图所示

Method	4k	8k	16k	32k	64k	128k
Baseline	88.89	85.88	83.15	79.50	-	-
SDPA-Gate	90.56	87.11	84.61	79.77	-	-
		YaRN Extended
Baseline	82.90 (-6.0)	71.52 (-14.4)	61.23 (-21.9)	37.94 (-41.56)	37.51	31.65
SDPA-Gate	88.13 (-2.4)	80.01 (-7.1)	76.74 (-7.87)	72.88 (-6.89)	66.60	58.82

可以看到，对于短上下文，虽然两者表现都有所下降，但是本文提出的 gating 表现下降程度较小。而对于长上下文，本文提出的 gating 机制效果明显更好。作者分析原因认为这是由于 softmax attention 倾向于退化为对少数 token 的依赖，而 gating 通过引入 token-level sparsity，避免了这种路径依赖。

Conclusion

在本文中，作者系统性探究了 attention 中的 gating 机制，包括 gating 对模型表现，训练稳定性以及训练动态的影响。作者发现，通过提高 non-linearity 和 sparsity 我们可以有效提高模型的上下文能力以及减缓 attention sink 现象。

从更高层次看，本文的结果可以总结为一点：

attention 的问题不在于 softmax 本身，而在于线性 aggregation 的表达上限与缺乏选择性。而 gating 提供了一种几乎零成本、却极其有效的方式来引入非线性与稀疏性。

References

Gated Attention for Large Language Models: Non-linearity, Sparsity, and Attention-Sink-Free

Appendix

作者在附录中还进一步分析了 massive activation 以及 attention sink.

massive activation 并不是 attention sink 产生的必要原因，并且 sparsity 可以减缓这一现象
head-specific gating 会提升 gating score 的值，因此不同的 head 需要安排不同的 sparsity
并不能通过 clipping 的方式来提高训练稳定性
在 continue pre-training 阶段加入 gating 机制并不能提高模型的表现

Notes on Global-batch load balancing

Thu, 11 Dec 2025 16:09:34 +0800

Qwen 在 25 年 2 月提出了 global batching load balancing loss strategy, 其在 global level 上考虑每个专家的负载均衡，从而提高模型的表现

Introduction

实现 MoE 模型负载均衡的原因有两点：

Effectiveness: 通过负载均衡才能更高效地利用各个专家
Efficiency: 一般需要使用 expert parallel 来部署 MoE 模型，不均衡的负载会大幅度降低前向过程

已有的框架如 DeepSpeed, Megablocks 和 Megatron-Core 都是在 micro-batch level 上计算负载均衡损失的，但是，一个 micro-batch 通常只包含少数序列，因此 load balancing loss 就要求各个专家在每个序列上均匀分布。

针对这个问题，作者在本文中提出的解决方法是在 global-batch 层面考虑负载均衡，

Method

MoE 模型定义如下

$$ y = \sum_{i\in N_E,g_i\in\mathrm{TopK}(g)}g_i(x)E_i(x) $$

其中 $E_i$ 是对应的专家, $g_i$ 是对应的权重

Load balancing loss 定义如下

$$ \mathrm{LBL} = N_E\sum_{i=1}^{N_E}f_iP_i $$

一般来说，MoE 模型训练时会使用 expert parallel 策略，此时 load balancing loss 修改为

$$ \mathrm{LBL}_{\mathrm{micro}}= \frac{1}{N_P}\sum_{j=1}^{N_P}\left(N_E\sum_{i=1}^{N_E}f_i^hP_i^j\right) $$

其中 $N_P$ 是 parallel groups 的个数。在这种情况下，模型需要再每个 parallel group 中实现负载均衡。但是某一个 mircro-batch 里可能只包含某一个 domain 的序列，因此各个专家被强制要求在每一个 domain 中也均衡分布。作者认为，这种方式会限制专家的能力，进而影响模型的表现。

作者的解决方法在于，获取每个 parallel group 的 $f_i$ 然后求 global-batch 的 $\bar{f}_i$.

$$ \mathrm{LBL}_{\mathrm{global}}=N_E\sum_{i=1}^{N_E}\bar{f}_i\bar{P}_i=N_E\sum_{i=1}^{N_E}\bar{f}_i\left(\frac{1}{N_P}\sum_{j=1}^{N_P}P_j\right) = \frac{1}{N_P}\sum_{j=1}^{N_P}\left(N_E\sum_{i=1}^{N_E}\bar{f}_iP_i^j\right) $$

实际中，由于计算节点数量有限，micro-batch size 之和可能会小于 global-batch size, 因此我们会使用 gradient accumulation. 在这种情况下，作者使用了一个 buffer 来保存多个 micro-batch 的专家选择次数，最终算法实现过程如下所示

Experiments

作者使用了不同大小的模型来进行实验，作者用 Balance BSZ 来表现计算 expert selection frequency 时的 token 数，结果如下图所示

可以看到，global LBL 可以提高模型的表现，并且，当 Balance BSZ 增加时，模型的表现也会提升。作者发现对于 Loss-Free Balancing 来说，使用 global batch 的效果也更好。

作者还发现，global LBL 会提高专家的特化程度，结果如下图所示

可以看到，使用默认的 LBL loss, 各个专家的特化程度很低，而使用本文的 global LBL 之后，专家的特化程度有了大幅度的提高。

作者还进一步发现，随着 Balance BSZ 的提高，模型表现也持续提升，结果如下图所示

作者认为，synchronization 和 buffer 机制相比于 micro-batch 来说可以带来大幅度提升。

Analysis

首先，为了分析 global batch LBL 优于 Micro batch 的关键原因，作者先同步所有 group 的矩阵 $G$, 然后再从全局 token 中随机选一批，用这批 token 计算专家选择频率。通过这个方法，我们可以保证 token 数量与 micro-batch 一致，但是分布于 Global-batch 一致。实验结果发现，这种方法的表现优于 micro-batch LBL, 说明 global batch LBL 的优势在于 Token 分布更全局，而不是 token 数量更多。

作者还分析了 global batch LBL 和 micro batch LBL 两种模式，作者认为前者是后者的一个宽松版约束，作者发现从后者切换为前者之后，模型的表现可以得到进一步提升，但是其表现仍然不如一开始就使用 global batch LBL 更好。作者分析原因认为，这是因为 expert 收敛速度比较快。

作者进一步通过降低 micro batch LBL 权重来探究是否可以达到同样的表现，结果发现适度江都权重确实可以提高模型的表现，但是降低太多会损害模型的表现，即此时出现了负载不均衡的现象

作者对比了 global batch LBL 和 micro batch LBL 效率发现，前者比后者慢 $2\%$ 左右，这个差距几乎可以忽略不计

作者进一步分析了不同 balancing 方式的专家特化程度，结果如下图所示

实验结果发现：

使用 global batch LBL 之后，topK sum 明显变大，这说明 routing 和 language modeling 任务对齐地更好
global batch LBL 的专家在不同任务上的特化程度更明显
micro batch LBL 的 topK sum 比较小
Loss-free balancing 的 topK sum 介于 micro batch LBL 和 global batch LBL 之间

Conclusion

作者在本文中提出了 global LBL 来在全局为负载均衡提供指导，结果发现通过在更大的范围进行负载均衡的计算，我们可以有效提高专家的特化程度以及提高模型在下游任务上的表现

References

Arxiv

Notes on Qwen3 VL

Fri, 05 Dec 2025 10:12:01 +0800

Introduction

作者在本文中提出了 Qwen3-VL 系列多模态大模型，包括 4 个 dense 模型和两个 MoE 模型，模型的上下文长度为 256K, 通过数据和训练上的优化，作者保持了模型的纯文本能力。最终 Qwen3-VL 包括 non-thinking 和 thinking variants.

在架构上，Qwen3-VL 进行了三点改进：

Interleaved MRoPE: 作者解决了 Qwen2.5-VL 提出的 MRoPE 在长视频理解场景下的频谱不平衡问题
DeepStack: 作者使用了 DeepStack 来提取 ViT 不同 layer 的视觉特征
Explicit Video timestamps: 作者使用了绝对时间来标记 frame 来提供更直接的时间信息

在数据上，作者使用了 image caption, OCR, grounding, spatial reasoning, code, long documents 以及 temporally grounded video 等数据，作者还是用了 GUI-agent interaction 数据来提高模型的 action 能力

在训练上，Qwen3-VL 包含两个大的阶段：pre-training 和 post-traing, pre-training 包含 4 个小阶段，post-training 包含 3 个阶段。

Architecture

Qwen3-VL 的架构如下所示

其中，

LLM: LLM 使用了 Qwen3 系列大语言模型，包括 2B, 4B, 8B, 32B 四个 dense model 以及 30B-A3B, 235B-A22B 两个 moe 模型
Vision Encoder: encoder 基于 [[SigLip-2]] 初始化，然后使用了 dynamic input resolutions 进行 continue training, 作者使用了 CoMP 提出的 2D-RoPE 以及 interpolate absolute position embedding, 最终包括 SigLip2-SO-400M 和 SigLip-Large (300M) 两个 size, 后者用于 2B 和 4B 两个 size
Patch Merger: 一个 2 层的 MLP, 将四个 visual token 压缩为 1 个

Interleaved MRoPE

这部分介绍见 [[MRoPE-Interleave]]

DeepStack

受 Deepstack 启发，作者从 vision encoder 的中间层（具体来说是第 8， 16， 24 层）提取对应的视觉特征，然后经过 MLP 与 LLM 对应 layer 的视觉 token 直接进行相加。

Video Timestamp

作者发现，Qwen2.5-VL 中使用的 MRoPE 存在如下问题：

将 temporal position 与绝对时间绑定之后，对于长视频会产生非常大且稀疏的 temporal position ids
需要使用不同的 FPS 进行采样来提高模型的泛化性

为了解决这个问题，作者使用了一个 textual token-based time encoding strategy, 其中每个 video temporal patch 对应的 timestamp 表示为 <3.0 seconds>, 这样视频会被处理为以下格式

1

<0.0 seconds> <video token> <video token> ... <4.0 seconds> <video token> <video token>

在训练时，作者还使用了 seconds 以及 HMS 两种格式来提高模型对于不同格式的泛化能力。作者认为，虽然这种表示会提高上下文长度，但是也能够提高模型 video grounding 或者 dense captioning 等时序信息敏感任务的表现

Pre-training

Training Recipe

预训练阶段包含 4 个阶段，如下图所示

Stage 0: 这一阶段的目的是对齐视觉特征和文本特征，只训练 Patch merger, 训练使用了 67B token, 覆盖 image-caption, knowledge, OCR 数据，上下文长度为 8192
Stage 1: 这一阶段所有参数都参加训练，训练使用了 1Ttoken, 作者在训练是加入了纯文本数据，最终数据包含 interleaved image-text, visual grounding, VQA, STEM, video 数据，上下文长度为 8192
Stage 2: 这一阶段的目的是扩展模型的上下文长度到 32K, 训练使用了 1T token, 数据包括长视频以及 agent-oriented instruction-following 数据
Stage 3: 这一阶段的目的是将模型的上下文长度进一步扩展到 262K, 训练使用了 100B token. 数据包括长视频以及长文本

Data

Image Caption Data: 作者使用了 Qwen2.5-VL 32B 来进行 re-captioning, 然后进行了 de-duplication 以及 clustering 来提高数据的质量和多样性
Interleaved Text-Image Data: 作者对文档进行分裂，然后使用微调的 Qwen2.5-VL 7B 来进行解析，对于长文本，作者将连续页面拼接在一起。作者使用了对齐以及页数来保证数据的质量
Knowledge Data: 作者构建了多个类别的数据，然后对这些数据进行 refine
OCR: 作者构造了 30M 的数据以及 1M 的多语种数据
Document Parsing Data: 作者从 CC 上收集了 3M PDF 以及处理了自有的 4M 数据，最终数据集里包含合成数据和真实数据；对于长文档理解数据，作者通过将 single-page 数据 merge 在一起得到，然后作者构造了 long document VQA 数据
Grounding and counting Data: grounding 数据包括 box-based 和 Point-based 两种形式，均从开源数据集收集得到，前者包括 RefCOCO, Object365, 后者包括 PixMo; 对于 Counting, 作者基于 grounding 数据构造了 direct counting, box-based counting 以及 point-based counting 三种形式
Spatial Understanding: 数据包括 spatial understanding 和 3D grounding 两类数据，前者的数据使用了相对位置关系来提高 spatial reasoning 的 robustness; 后者使用了 Omni3D 来统一数据格式
Code: 包括 Qwen3, Qwen3-Coder 的纯文本 coding 数据，以及多模态 coding 数据，覆盖了将 UI 截图转换为 HTML/CSS 以及从图片生成 SVG 等任务
Video: 包括 Dense Caption Synthesis 以及 Spatial-Temporal Video Grounding 两个任务。作者还对不同来源不同长度的数据进行了平衡
STEM: 作者构造了一个合成数据 pipeline, 合成了 1M point-grounding samples, 2M perception-oriented VQA 数据，最终数据集包含 6M 标注图表数据，覆盖了 STEM 相关学科；对于多模态推理数据，作者收集了 60M 的 K12 以及本科生级别的练习题，作者还合成了 12M 的多模态推理数据。除了多模态推理数据，作者还加入了纯文本推理数据
Agent: 这部分数据包括 GUI, function calling 以及 Search 三部分， GUI 数据通过数据合成得到，Function calling 数据通过强模型生成轨迹得到，search 数据通过收集执行搜索轨迹得到

Post-training

Post-training 包含三个阶段：

SFT: 提高模型的指令跟随能力，SFT 又分为了两个小阶段，上下文长度分别为 32K 和 256K, 对于 instruct 和 reasoning 版本，作者设计了不同的数据格式，后者包含 CoT reasoning trace
Strong-to-Weak Distillation: 提高小模型的能力，这里应该是和 Qwen3 一样，将大模型的能力蒸馏到小模型里
RL: 提高模型的 reasoning 能力以及人类偏好对齐。这里包含了 Reasoning RL 以及 General RL 两个阶段，覆盖了 math, OCR, grounding, instruction following 等 domain

整体的训练 pipeline 我猜测应该是这样：

Code-start Data

Code-start Data 分为 SFT 数据和 Long CoT SFT 数据，前者用于训练 instruct 版模型，后者用于训练 reasoning 版模型

Data	tasks	samples	training	filtering
SFT	spatial reasoning image-grounded reasoning spatio-temporal grounding long document understanding	1.2M (1/3 are text-only)	- stage 1: 32K - stage 2: 256K	- query - rule-based - model-based
Long CoT SFT	VQA, OCR, 2D/3D grounding, video analysis, STEM, agent	text:multimodal = 1:1		- difficulty - multi-modal - response quality

Strong-to-Weak Distillation

蒸馏过程包括两个阶段：

off-policy Distillation: 使用教师模型的输出进行训练提高模型基本的 reasoning 能力
On-policy Distillation: 使用教师模型输出的 logit 作为蒸馏信号提高模型的 reasoning 能力

RL

Reasoning RL

作者收集了 30K 的 RL 数据，然后对通过率超过 90% 的数据进行过滤 (16 responses per query), 对于 reward, 作者构建了一个 unified reward framework 来提供奖励

训练时，作者使用了 SAPO 算法进行训练

General RL

作者采用了一个 multi-task RL 的范式来提高模型在不同任务上的表现，reward 主要包含两个方面：

instruction following: 评估模型遵循用户指令的能力，包括内容，格式，长度等
preference alignment: 对于开放式问题，评估模型帮助性，事实准确性等方面的表现

基于这两个方面 reward 有两个部分组成：

rule-based reward: 基于规则的 reward, 比如格式要求等
model-based reward: 使用 Qwen2.5-VL 72B 和 Qwen3 作为 judge model 来提供奖励

为了解决模型的重复性实处，中英文混杂等问题，作者构造了一个数据集来故意触发模型这些问题然后加以改正。

Thinking with Images

作者还够在了数据提高模型的 “thinking with images” 的能力，训练包含两个阶段：

Stage 1: 作者构造了 10K Grounding 数据，然后对 Qwen2.5-VL 32B 进行 SFT 来模仿 agent 的行为: think -> act -> analyze feedback -> answer, 然后作者使用 multi-turn, tool-integrated RL 来进一步提高模型的 reasoning 能力
Stage 2: 作者从 Qwen2.5-VL 32B 蒸馏得到 120K multi-turn agentic interactions 数据集，然后作者使用了相似的 cold-start SFT 以及 tool-integrated RL pipeline 来训练 Qwen3-VL

这里 RL 训练的 reward 包含以下几部分：

answer accuracy reward
multi-turn reasoning reward
tool-calling reward

Experiments

Performance

Qwen3-VL 235B-A22B 的表现如下图所示

Ablation Study

作者对比了以下 Qwen3-ViT 和 SigLIP-2 的表现，结果如下图所示

实验结果显示，使用 1.7B 的 Qwen3 和 1.5T tokens 进行训练之后，Qwen3-ViT 的表现超过了 SigLIP2 的表现，验证了 Qwen3-ViT 的有效性

作者对比了 Deepseek 和 baseline 的表现，结果如下图所示

可以看到，相比于 baseline, DeepStack 的表现更好，说明了 DeepStack 可以提供更丰富的视觉信息。

作者还评估了以下 Qwen3-VL 在视频版大海捞针任务上的表现，实验结果发现，对于 30 分钟的视频，Qwen3-VL 的准确率为 $100\%$, 通过 YARN 上下文扩展策略，模型在 2 个小时视频上的准确率为 $99.5\%$.

Conclusion

作者在本文中提出了 Qwen3-VL 系列多模态大模型，在架构上，作者使用了 interleaved-MRoPE, DeepStack 等改进策略，在数据上，作者扩展了训练数据的多样性，在训练上，作者分别训练了 instruct 版本和 reasoning 版本。最终评估发现，Qwen3-VL 达到了 SOTA 表现。

作者认为，未来的工作在于

基于 Qwen3-VL 构建具身智能 agent
提高模型的可交互感知，tool-augmented reasoning 以及 real-time multimodal control 能力
提高模型与人类学习，合作的能力
统一理解与生成多模态大模型

References

blog
Arxiv

Notes on SAPO

Fri, 05 Dec 2025 10:09:06 +0800

Introduction

Method

作者首先给出了 SAPO 的目标函数如下：

$$ \mathcal{J}_{\mathrm{SAPO}}(\theta) = \mathbb{E}_{(x, y)\sim\mathcal{D},\{y_i\}_{i=1}^G\sim \pi_{\theta_{old}}(\cdot\mid x)}\left[ \frac{1}{G}\sum_{i=1}^G\frac{1}{|y_i|}\sum_{t=1}^{|y_i|}f_{i,t}(r_{i,t}(\theta))\hat{A}_{i,t} \right], $$

其中，

$$ f_{i,t}(x) = \sigma(\tau_{i,t}(x-1))\cdot \frac{4}{\tau_{i,t}}, \tau_{i,t} = \begin{cases} \tau_{pos}, & \text{if }\hat{A}_{i,t}>0\\ \tau_{neg}, &\text{otherwise} \end{cases} $$

这里

$$ \hat{A}_{i,t} = \hat{A}_{i} = \frac{r(x,y_i) - \mathrm{mean}(\{r(x,y_i)\}_{i=1}^G)}{\mathrm{std}(\{r(x,y_i)\}_{i=1}^G)},\quad r_{i,t}(\theta) = \frac{\pi_{\theta}(y_{i,t}\mid x, y_{i,< t})}{\pi_{\theta_{old}}(y_{i,t}\mid x, y_{i,< t})} $$

$\tau_{pos}$ 和 $\tau_{neg}$ 分别是 positive token 以及 negative token 对应的温度, $\sigma(x)=1/(1+e^{-x})$ 是 sigmoid function.

对 $\mathcal{J}_{\mathrm{SAPO}}(\theta)$ 求导得到

$$ \nabla_\theta \mathcal{J}_{\mathrm{SAPO}}(\theta) = \mathbb{E}_{(x, y)\sim\mathcal{D},\{y_i\}_{i=1}^G\sim \pi_{\theta_{old}}(\cdot\mid q)}\left[ \frac{1}{G}\sum_{i=1}^G\frac{1}{|y_i|}\sum_{t=1}^{|y_i|}w_{i,t}(\theta)r_{i,t}(\theta)\nabla_\theta \log \pi_\theta(y_{i,t}\mid q, y_{i, 其中

$$ w_{i,t}(\theta) = 4p_{i,t}(\theta)(1-p_{i,t}(\theta)),\quad p_{i,t}(\theta) = \sigma(\tau_{i,t} (r_{i,t}(\theta)-1)), $$

$\mathcal{J}_{\mathrm{SAPO}}(\theta)$ 和 $w_{i,t}(\theta)$ 与 $r_{i,t}(\theta)$ 的关系如下图所示

为了保证当 $r_{i,t}(\theta)=1$ 时，SAPO 等价于 $r_{i,t}(\theta)\hat{A}_{i,t}$ 而与 $\tau_{i,t}$ 无关，作者在 $f_{i,t}(x)$ 加入了系数 $4/\tau_{i,t}$.

Comparison

作者接下来对比了 GSPO 以及 GRPO 两个算法

首先作者使用了一下统一的目标函数公式来表示三个算法

$$ \mathcal{J}(\theta) = \mathbb{E}_{(x, y)\sim\mathcal{D},\{y_i\}_{i=1}^G\sim \pi_{\theta_{old}}(\cdot\mid x)}\left[ \frac{1}{G}\sum_{i=1}^G\frac{1}{|y_i|}\sum_{t=1}^{|y_i|}f_{i,t}(r_{i,t}(\theta))\hat{A}_{i,t} \right], $$

其中不同算法的 $f_{i,t}(\cdot)$ 不一样，三种算法的定义如下

$$ \begin{aligned} \mathrm{SAPO}&:f_{i,t}^{\mathrm{SAPO}}(r_{i,t}(\theta))=\sigma(\tau_{i,t}(x-1))\cdot \frac{4}{\tau_{i,t}}, \tau_{i,t} = \begin{cases} \tau_{pos}, & \text{if }\hat{A}_{i,t}>0\\ \tau_{neg}, &\text{otherwise} \end{cases}\\ \mathrm{GRPO}&:f_{i,t}^{\mathrm{GRPO}}(r_{i,t}(\theta), \hat{A}_{i,t})=\begin{cases} \min(r_{i,t}(\theta), 1+\epsilon) & \hat{A}_{i,t}>0\\ \max(r_{i,t}(\theta), 1-\epsilon) & \hat{A}_{i,t}\leq0 \end{cases}\\ \mathrm{GSPO}&:f_{i,t}^{\mathrm{GSPO}}(r_{i,t}(\theta), \hat{A}_{i,t})=f_{i,t}^{\mathrm{seq}}(r_{i,t}(\theta), \hat{A}_{i,t})=\begin{cases} \min(s_{i,t}(\theta), 1+\epsilon) & \hat{A}_{i,t}>0\\ \max(s_{i,t}(\theta), 1-\epsilon) & \hat{A}_{i,t}\leq0 \end{cases} \end{aligned} $$

其中

$$ s_i(\theta) = \left(\frac{\pi_{\theta}(y_{i}\mid x)}{\pi_{\theta_{old}}(y_{i}\mid x)}\right)^{\frac{1}{|y_i|}}, s_{i,t}(\theta) = \mathrm{sg}[s_i(\theta)]\frac{\pi_{\theta}(y_{i,t}\mid x, y_{i,< t})}{\mathrm{sg}[\pi_{\theta}(y_{i,t}\mid x, y_{i,< t})]} $$

首先是与 GSPO 的对比，通过一些假设和简化，我们得到

$$ \begin{aligned} \nabla_\theta \mathcal{J}_{\mathrm{SAPO}}(\theta) &=\mathbb{E}\left[\frac1G\sum_{i=1}^G g_{\tau_i}(\log s_i(\theta))\nabla_\theta \log s_i(\theta)\hat{A}_i\right]\\ \nabla_\theta \mathcal{J}_{\mathrm{GSPO}}(\theta) &=\mathbb{E}\left[\frac1G\sum_{i=1}^G s_i(\theta)\nabla_\theta \log s_i(\theta)\hat{A}_i\right] \end{aligned} $$

其中 $g_{\tau_i}(\log s_i(\theta)) = \mathrm{sech}^2\left(\tau_i/2\log s_i(\theta)\right)$. 相比于 GSPO, SAPO 有两个优势：

smoothness and stability, soft gate 避免了 hard clipping 带来的不连续性
token-level adaptivity with sequence-level coherence. 当假设不成立的时候，SAPO 退化为 token-level gating, 这样可以降低 outliers 的权重

GRPO 的函数可以进一步简化为

$$ f_{i,t}^{\mathrm{GRPO}}(r_{i,t}(\theta), \hat{A}_{i,t})= \begin{cases} 1, & \text{if }\hat{A}_{i,t}>0\text{ and }r_{i,t}(\theta)\leq 1+ \epsilon\\ 0, & \text{if }\hat{A}_{i,t}>0\text{ and }r_{i,t}(\theta)> 1+ \epsilon\\ 1, & \text{if }\hat{A}_{i,t}\leq0\text{ and }r_{i,t}(\theta)\geq 1- \epsilon\\ 0, & \text{if }\hat{A}_{i,t}\leq0\text{ and }r_{i,t}(\theta)< 1- \epsilon \end{cases}\\ $$

可以看到，GRPO 对应一个 binary trust region. 与 GRPO 相比，SAPO 将对应的 hard indicator 替换未来一个 smooth kernel $f_{i,t}^{\mathrm{SAPO}}(r_{i,t}(\theta))=\mathrm{sech}^2\left(\tau_i/2r_{i,t}(\theta)-1\right)$, 这样可以避免 gradient vanishing 以及提高训练的稳定性。

最终结论为：

相比于 GSPO, SAPO 对于 off-policy 的数据利用率更高
相比于 GRPO, SAPO 避免了 hard token level clipping 导致的 zero-gradient 问题

Experiments

作者对比了 SAPO, GSPO 以及 GRPO-R2(GRPO with routing replay) 三种方法，实验结果如下图所示

实验结果显示，SAPO 的表现超过了 GSPO 以及 GRPO

作者还探究了超参数 $\tau_{pos}$ 和 $\tau_{neg}$ 的影响，结果如下图所示

实验结果显示，当 $\tau_{neg}>\tau_{pos}$ 时，模型训练最稳定，这说明了 negative token 是导致训练不稳定的主要原因。

作者还在 Qwen3-VL 上进行了验证，结果如下图所示

实验结果显示，SAPO 的表现超过了 GSPO 以及 GRPO-R2

Conclusion

在本文中，作者提出了 SAPO, 一个解决 hard-clipping 训练不稳定性以及低效率的策略优化算法，作者使用了基于温度的 soft gate 来代替 clipping, 以及对于 positive token 和 negative token 使用了不同的 temperature 这两点改进。结果验证了 SAPO 的有效性，作者认为使用 smooth 以及 adaptive gating 机制可以有效提高 RL 训练的稳健性以及有效性。

References

arxiv

Notes on GSPO

Wed, 06 Aug 2025 11:26:26 +0800

Qwen 提出了 Group Sequence Policy Optimization (GSPO), 一个针对 GRPO 进行改进的 RL 算法。GSPO 在 sequence 层面计算 importance ratio, 避免了 token-level 计算带来的训练不稳定性。

Introduction

GRPO 的问题在于训练超大规模的 LLM 时，会出现 model collapse, Qwen3 和 MiniMax-01 均对 GRPO 算法进行了改进。

在本文中，作者认为 GRPO 算法的问题在于 Importance sampling weight 的计算是有问题的，这导致了误差随生成回答长度累积，最后被 clipping 机制放大，从而导致模型崩溃。

为了解决这个问题，作者提出了 GSPO, 一个在 sequence 层面进行 Importance sampling 的 RL 算法，GSPO 还对 reward 进行 normalization 来保持训练的稳定性

Method

Preliminary

对于一个大语言模型 $\pi_{\theta}$, 我们将 $x$ 记为 query, 将 $y$ 记为 $\pi_{\theta}$ 针对 $x$ 的 response, 即

$$ \pi_{\theta}(y\mid x) = \prod_{t=1}^{|y|}\pi_{\theta}(y_t\mid x, y_{其中 $|y|$ 代表 response $y$ 的长度, 一般我们还有一个 reward model $r$, 用于生成奖励 $r(x,y)\in[0, 1]$.

[!tip] Note 本文中没有提及 KL divergence, 作者认为这不是重点，所以没有在公式中标出。

PPO 算法包含四个模型：reference model, 也就是 $\pi_{old}$, policy model, 也就是 $\pi_{\theta}$, value model, 用于计算 advantage, 以及 reward model, 用于计算奖励。 PPO 算法如下面公式所示

$$ \mathcal{J}_{\mathrm{PPO}}(\theta) = \mathbb{E}_{(x,y)\sim\mathcal{D},y_{\leq t}\sim \pi_{\theta_{old}}(\cdot\mid q)}\left[ \min\left(r_t(\theta)\hat{A}_t,\mathrm{clip}\left(r_t(\theta), 1-\epsilon, 1+\epsilon\right)\hat{A}_t\right) \right] $$

其中

$$ r_t(\theta) = \frac{\pi_{\theta}(y_t\mid x, y_{< t})}{\pi_{\theta_{old}}(y_t\mid x, y_{< t})} $$

是 token $y_t$ 的 importance ratio, $\hat{A}_t$ 是 $y_t$ 的 advantage estimation.

PPO 算法的问题在于其严重依赖 value model, 一般 value model 与 policy model 的大小相当，以保持内存和算力的负载均衡。

为了解决 PPO 的这个问题，GRPO 通过多次采样然后计算 relative advantage 来避免使用 value model. 其目标函数为

$$ \mathcal{J}_{\mathrm{GRPO}}(\theta) = \mathbb{E}_{(x, y)\sim\mathcal{D},\{y_i\}_{i=1}^G\sim \pi_{\theta_{old}}(\cdot\mid q)}\left[ \frac{1}{G}\sum_{i=1}^G\frac{1}{|y_i|}\sum_{t=1}^{|y_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) \right] $$

其中，$G$ 是针对 query $x$ 的多次采样 response,

$$ r_{i,t}(\theta) = \frac{\pi_{\theta}(y_{i,t}\mid x, y_{i,< t})}{\pi_{\theta_{old}}(y_{i,t}\mid x, y_{i,< t})} $$

是 importance ratio,

$$ \hat{A}_{i,t} = \hat{A}_{i} = \frac{r(x,y_i) - \mathrm{mean}(\{r(x,y_i)\}_{i=1}^G)}{\mathrm{std}(\{r(x,y_i)\}_{i=1}^G)} $$

是使用 group response 估计得到的 advantage.

Motivation

在 Qwen3 中已经提到，对于稀疏的 MoE 模型，我们必须使用更大的 batch size 来最大化内存和算力使用效率。但是，更大的 batch 意味着有一些数据必须是 off-policy 的，因此 PPO 和 GRPO 就需要使用 clipping 来降低 off-policy sample 对模型表现产生过大影响。

基于 clipping 机制，作者认为 GRPO 的目标函数是 “ill-pose” 的，其原因在于 GRPO 计算的 Importance ratio 是与 RL 训练目标不匹配的。

通常，importance sampling 的公式如下：

$$ \mathbb{E}_{z\sim\pi_{\mathrm{tar}}}[f(z)] = \mathbb{E}_{z\sim\pi_{\mathrm{beh}}}\left[\frac{\pi_{\mathrm{tar}}(z)}{\pi_{\mathrm{beh}}(z)}f(z)\right] $$

其中 $\pi_{\mathrm{tar}}$ 是目标分布， $\pi_{\mathrm{beh}}$ 是采样分布, importance ratio $\pi_{\mathrm{tar}}(z)/\pi_{\mathrm{beh}}(z)$ 负责对采样进行修正。

对于 GRPO, 其 importance ratio 是在 token 层面定义的，而一次采样是在 sequence 层面定义的，因此这种区别就导致了 GRPO 存在 high-variance noise.

因此，作者认为，Importance ratio 的关键在于优化目标应该与 reward 的粒度是一致的。

GSPO

基于上面的想法，作者就提出了 GSPO, 作者首先针对 LLM 改写了上面的 importance sampling 的公式

$$ \mathbb{E}_{x\sim \mathcal{D}, y\sim\pi_{\theta}(\cdot\mid x)}[r(x,y)] = \mathbb{E}_{x\sim\mathcal{D}, y\sim\pi_{\theta_{old}}(\cdot\mid x)}\left[\frac{\pi_{\theta}(y\mid x)}{\pi_{\theta_{old}}(y\mid x)}r(x,y)\right] $$

这里的 Importance ratio 表现了采样的回答 $\pi_{old}(y\mid x)$ 与目标回答 $\pi_{\theta}(y\mid x)$ 之间的差距，这是从 sequence 层面上体现的。

因此，作者基于上面的式子，构建出了 GSPO 的目标函数

$$ \mathcal{J}_{\mathrm{GSPO}}(\theta) = \mathbb{E}_{(x, y)\sim\mathcal{D},\{y_i\}_{i=1}^G\sim \pi_{\theta_{old}}(\cdot\mid q)}\left[ \frac{1}{G}\sum_{i=1}^G\min\left(s_{i}(\theta)\hat{A}_{i},\mathrm{clip}\left(s_{i}(\theta), 1-\epsilon, 1+\epsilon\right)\hat{A}_{i}\right) \right] $$

这里 $\hat{A}_{i}$ 与 GRPO 一致， $s_i(\theta)$ 是 normalize 之后的 importance ratio, 定义如下

$$ s_i(\theta) = \left(\frac{\pi_{\theta}(y_{i}\mid x)}{\pi_{\theta_{old}}(y_{i}\mid x)}\right)^{\frac{1}{|y_i|}} = \exp\left(\frac{1}{|y_i|}\sum_{i=1}^{|y_i|}\frac{\pi_{\theta}(y_{i,t}\mid x, y_{i,< t})}{\pi_{\theta_{old}}(y_{i,t}\mid x, y_{i,< t})}\right) $$

这里作者使用了 length normalization 来控制 variance.

作者对比了以下 GSPO 和 GRPO 两者的梯度，我们忽略期望的计算，直接写出内部的梯度，有

$$ \begin{aligned} \nabla_\theta \mathcal{J}_{\mathrm{GSPO}}(\theta) &= \frac{1}{G}\sum_{i=1}^G\left(\frac{\pi_{\theta}(y_{i}\mid x)}{\pi_{\theta_{old}}(y_{i}\mid x)}\right)^{\frac{1}{|y_i|}}\hat{A}_i\cdot \frac{1}{|y_i|}\sum_{t=1}^{|y_i|} \nabla_{\theta} \log\pi_{\theta}(y_{i,t}\mid x, y_{可以看到，两者不同的地方在于 token 的 reweight 方式，GRPO 中先加权再求和；而 GSPO 中则是先求和，然后在 sequence 层面进行加权

GSPO-token

为了支持 multi-turn RL 等需要细粒度 advantage 的场景，作者对 GSPO 的目标函数进行了改进，得到了 GSPO-token, 其目标函数为

$$ \mathcal{J}_{\mathrm{GSPO-token}}(\theta) = \mathbb{E}_{(x, y)\sim\mathcal{D},\{y_i\}_{i=1}^G\sim \pi_{\theta_{old}}(\cdot\mid q)}\left[ \frac{1}{G}\sum_{i=1}^G\frac{1}{|y_i|}\sum_{t=1}^{|y_i|}\min\left(s_{i,t}(\theta)\hat{A}_{i},\mathrm{clip}\left(s_{i,t}(\theta), 1-\epsilon, 1+\epsilon\right)\hat{A}_{i}\right) \right] $$

其中，

$$ s_{i,t}(\theta) = \mathrm{sg}[s_i(\theta)]\frac{\pi_{\theta_{old}}(y_{i,t}\mid x, y_{i,< t})}{\mathrm{sg}[\pi_{\theta_{old}}(y_{i,t}\mid x, y_{i,< t})]} $$

这里 $\mathrm{sg}$ 是 stop gradient operation. 通过这种改写方式，GSPO-token 与 GSPO 的优化目标一致，但是可以在更细粒度的 token 层面进行优化。

Evaluation

作者使用 Qwen3-30B-A3B 进行测试。对于 GRPO，作者发现必须使用 Routing Replay training strategy 才能提升 MoE RL 的收敛性， Routing Replay 的具体做法就是保留 $\pi_{\theta_{old}}$ 的激活专家，在 $\pi_{\theta}$ 中使用相同的专家来保持稳定性。但是，GSPO 则不需要这个技巧。

实验结果如下图所示。

从实验结果可以看到，GSPO 比 GRPO 更加高效，效果也更好。

作者带对比了 GSPO 与 GRPO 的 clipping 比例，结果发现，GSPO clipping 的 token 比例比 GRPO 高几个数量级，作者认为，尽管 GSPO clip 了更多 token, 但是 GSPO 更加高效，这也说明 GRPOtoken 层面的梯度估计是存在噪声的。

作者还介绍了以下 MoE 模型中 RL 训练的 expert-activation volatility 现象，也就是说，MoE 模型参数更新之后，对于同一个 response, 激活的专家可能飞铲个不同。作者举例说明，对于 Qwen3-30B-A3B, 更新一次梯度之后，有 $10\%$ 左右的激活专家变得不一样了。

作者最后介绍了以下 GSPO 的两个优势，一个是解决了 GRPO 依赖于 Routing Replay 的问题；第二个是支持 SGLang 和 vLLM 等推理框架。

Conclusion

作者提出了 GSPO，一个在 sequence 层面计算 importance ratio 的 RL 算法，解决了 GRPO 在训练大规模 MoE LLM 时出现的训练不稳定性以及 mode collapse 现象。

References

Group Sequence Policy Optimization

Notes on Qwen2.5-1M

Sat, 12 Jul 2025 11:00:47 +0800

Qwen 在 2025 年 1 月提出了 Qwen2.5-1M，一个拥有 1M 上下文长度的大语言模型系列。包含 7B，14B 两个开源模型以及 API 模型 Qwen2.5-Turbo. 主要改进方法包括长上下文数据合成，渐进式预训练以及多阶段 post-training 等。作者还对 inference 进行了优化，提高了 inference 的效率。

Method

架构上，Qwen2.5-1M 与 Qwen2.5 的架构一致，Qwen2.5-1M 包括 7B，14B 两个 size，还包括一个基于 MoE 的 API 模型 Qwen2.5-Turbo，不同的点在于，Qwen2.5-1M 的上下文长度为 1M，最大生成长度为 8K

Pretraining

Data 作者首先从 CC, arxiv, book, code repositories 等 domain 收集了原始数据。但是，作者发现，原始数据的局部相关性强，但是全局相关性弱。因此，作者基于原始数据进行了增广，来提高数据的长上下文依赖关系。具体有三个任务：

Fill in the middle: FIM 是 openAI 提出来的一个做法，核心思想就是将填空类问题转化为 next-token-prediction 的问题。通过这种方式，作者希望提升模型理解长上下文依赖的能力
Keyword-based and Position-based retrieval: 基于 keywords 或者 position 来找到对应的 paragraph，这个任务的目的是提高模型识别并连接相关信息的能力
Paragraph Reordering: 对输入的 paragraphs 进行随机打乱，然后要求模型重新组织段落的关系

Training 作者将训练拆分为了 5 个 stage：

stage 1 和 stage 2 与 Qwen2.5 的训练过程一致，stage 1 的上下文长度为 4096，stage 2 的上下文长度为 32768, 训练时，作者使用了 ABF 技巧来将 RoPE 的 base frequency 从 10,000 调整到了 1,000,000.
stage 3, stage 4 和 stage 5 分别将模型的上下文长度扩展到了 65,536 tokens, 131,072 tokens 以及 262,144 tokens, 对应的 RoPE base frequency 分别为 1M, 5M 和 10M. 训练时，作者使用了 75% 的长文本和 25% 的短文本，这样可以保证模型在短文本任务上的表现

最后，作者在评估了一下每个 stage 的表现，结果如下表所示

Training Length				RULER
	Avg.	4K	8K	16K	32K	64K	128K
32,768 Tokens	82.3	96.8	94.7	95.9	92.2	76.4	37.6
65,536 Tokens	86.8	96.5	95.5	93.6	92.5	86.7	56.0
131,072 Tokens	92.5	96.5	95.9	93.0	92.6	93.0	83.8
262,144 Tokens	92.7	95.6	93.8	93.1	94.1	91.9	87.6

可以看到，随着训练的上下文长度的提升，模型在更长上下文下的能力也有提升，说明模型具有一定的泛化性。

Post-training

Post-training 阶段与 Qwen2.5 一样，也分为了 SFT 和 RL 两个阶段。

在 SFT 阶段，作者从预训练预料中选择了一部分长文档的片段，然后让 Qwen2.5 来生成对应的 query，query 类型包括 summarization, information retrieval, multi-hop QA 等任务。接下来，作者使用 Qwen-Agent 框架基于全文来回答这些问题。最后，作者基于生成的 query，全文，以及模型产生的回答作为训练数据。

SFT 训练时，作者拆分为了两个 stage。 stage 1 作者在 32768 的上下文上进行训练，来提高模型短文本回答能力。第二个阶段，作者混合了 262,144 和 32768 上下文长度的训练数据。

RL 训练时，与 Qwen2.5 不一样的是，作者进使用了 offline RL，也就是 DPO。作者仅在 8192 的上下文长度上面进行训练。作者认为，长上下文的 RL 训练是非常耗时的，并且作者发现，短文本上进行 RL 的训练之后，模型在长文本上的表现也能得到提升。结果如下表所示

Model	Before RL	After RL
Qwen2.5-7B-Instruct-1M	7.32	8.08 (+0.75)
Qwen2.5-14B-Instruct-1M	8.56	8.76 (+0.20)
Qwen2.5-Turbo	7.60	8.34 (+0.74)

Inference

前面是训练部分的优化，主要是提升模型的上下文能力。接下来，作者详细介绍了如何在 Inference 阶段提升整体的推理效率和减少内存占用。

Length Extrapolation

与 Qwen2.5 一样，Qwen2.5-1M 也是用了 Dual Chunk Attention 和 YARN 来在推理阶段扩展模型的上下文长度，作者做了如下实验，来对比 Qwen2.5, Qwen2.5-1M 加上 DCA 之后的影响

结果显示，Qwen2.5-1M 的表现比 Qwen2.5 更好，并且加上 DCA 之后，两者的表现都有进一步的提升。

Sparse Attention

为了进一步提高计算效率，作者基于 MInference 来加速 perfilling phase. 并结合了前面的技巧来防止模型性能下降。

MInference MInference 的主要思想就是在长上下文中，有一些 critical token 对最终结果的影响是更大的。因此我们可以识别出这些 critical token 并只计算这些 token 对应的 attention score. 这些 critical token 对应的 pattern 被称为 Vertical-Slash pattern.

为了识别出这个 pattern，作者首先进行离线搜索，来决定最优的 configuration。这个 configuration 决定了 attention 应该如何计算。在 Inference 阶段，MInference 首先计算最后一个 query 和前面所有 key 的 attention，然后基于 configuration 来动态选择 pattern。通过 MInference，我们可以降低 10 倍以上的内存和算力消耗。

Integrating with Chunked prefill 但是 MInference 的问题在于，整个 sequence 是并行处理的，这会导致内存占用持续上升。为了解决这个问题，作者提出了 chunked prefilling 的技巧，来降低 VRAM 的消耗。具体做法就是，将整个 sequence 分为若干个 chunk，然后每个 chunk 里，选取最后 64 个 token 作为 query，在每个 chunk 中分别识别出 critical token，这样就降低了 MInference 的内存占用

接下来，作者在集成 DCA 的时候，发现性能有所下降。作者认为，这是由于 DCA 的 position id 信息不连续所导致的，为了解决这个问题，作者在选择 critical token 的时候，使用了连续版的 position id 信息。在最终推理的时候，还是使用 DCA 本身的位置信息。

Sparsity refinement 前面提到，MInference 需要先进行离线搜索决定最优的 configuration，但是对于 1M token 的上下文，这个过程还是非常耗时的。因此，作者构建了一个加速离线搜索的方法，具体做法就是定义两个 attention score，一个是 full attention, 另一个是 sparse attention，然后计算两者的差值，如果说相差比较小，则说明 critical token 抓住了全局信息，这个配置是有效的。其公式定义如下：

$$ \mathrm{Attention\_Recall} = \exp\left(\log\sum_{0\leq j\leq i}\exp \left(\frac{q^Tk_j}{\sqrt {d}}\right) - \log\sum_{j\in\mathcal{critical}}\exp \left(\frac{q^Tk_j}{\sqrt {d}}\right)\right) $$

Attention Recall 越高，说明选取的 critical token 越好，其 configuration 也就越好。

作者进一步分析了 sparse attention 对 accuracy 的影响，结果如下

可以看到，仅使用 MInference 会导致模型性能下降，但是加入 refinement 之后，模型的表现基本上和 full attention 差不太多。

Inference Engine

Kernel Optimization 作者还对 inference engine 进行了优化，作者使用 BladeLLM 作为 Qwen2.5-1M 的推理引擎。

作者主要做了两点优化，第一是对 sparse attention kernel 进行了优化，提高了 sparse attention 的计算效率，结果发现，在 1M 的上下文下，BladeLLM 比 flash attention 要快 27.8 倍。

第二是针对 MoE kernel 的优化。作者发现，decoding 的表现是与 memory access speed 相关的。具体来讲，当 batch size 超过 32 之后，获取模型参数成了效率的瓶颈。因此，作者使用了一系列技巧来提高 memory access 的效率

Pipeline parallelism 作者还对 Chunked pipeline parallelism 进行了优化，Chunked pipeline parallelism 的问题在于，在长上下文的场景下，不同长度的 chunk 会对 attention 的计算时间产生很大影响。不同的计算时间会产生 pipeline bubbles.

BladeLLm 使用了 Dynamic Chunked pipeline parallelism 来解决这个问题，该方法通过计算复杂度来调整每个 chunk 的大小，进而使得最终的处理时间尽可能一致

Scheduling 作者还在 Scheduling 上进行了优化，已有的推理引擎主要分为四个模块：API server, scheduler, model runner 以及 decoder

已有方法的问题在于，non-GPU 的操作会占用大量时间，导致 GPU 利用率非常低。因此，作者在 BladeLLM 中进行了改进，使用了 Totally Asynchronous Generator (TAG) 的架构，主要有：

Scheduler：动态分配 KV cache，类似于 speculative sampling, 而不必等前面的结果完成
Runner: 基于 Scheduler 分配的任务直接进行处理，处理完之后直接处理下一个任务
Decoder：基于 token id，进行解码，然后发送给前端的 API server

Evaluation

作者主要在三个 benchmark 上进行了评测：

RULER: RULER 是 Needle-in-ahaystack 任务的一个扩展笨笨，其要求模型从不相关的上下文中找到多个 “needles” 或者回答多个问题，数据最长为 128K tokens.
LV-Eval: LV-Eval 要求模型从上文本中同时理解多个 evidence fragments，数据最长为 256K tokens
Longbench-Chat: 评估模型在长上下文下与人类偏好对齐的程度，数据最长为 100K tokens

Qwen2.5-1M 与 Qwen2.5 的对比表现如下

可以看到，相比于 Qwen2.5，Qwen2.5 模型的表现有了大幅度的提升。

Conclusion

在本文中，作者提出了 Qwen2.5-1M 系列大语言模型，包括 7B，14B 两个 size，以及一个 MoE 架构的 API 模型 Qwen2.5-Turbo。作者在训练和推理两方面进行了改进，最终将模型的上下文长度扩展到了 1M。从现在的角度来看，不管是 Reasoning model 还是 agent 的训练都依赖 long Context 作为基础能力。

References

Qwen2.5-1M Technical Report

Notes on Qwen2.5

Sat, 12 Jul 2025 10:51:42 +0800

2024 年 12 月 Qwen 发布了 Qwen 2.5 系列大语言模型，包括 7 个 dense 模型以及两个 MoE 模型，Qwen2.5 在 pre-training 阶段使用了 18T token 进行。在 post-training 阶段使用了 1M 的样本，还使用了 DPO 以及 GRPO 来进行 RL 的训练

Qwen2.5 主要在以下方面进行了改进

模型方面，提供了更多的 size，Qwen2 中只有 0.5B, 1.5B, 7B, 72B 四个 size, 在 Qwen2.5 中，加入了 3B, 14B 和 32B 三个 size 的模型
数据方面，pre-training 阶段使用了 18T 的 token， post-training 阶段使用了 1M 的样本
功能方面，Qwen2.5 支持更长的上下文长度（8K），支持结构化输入和输出，拥有更强的工具调用能力。

Method

Architecture

模型架构这方面，Qwen2.5 和 Qwen2 的模型架构是一致的，tokenizer 页没有太大变化。为了支持工具调用，作者额外增加了 18 个 control token

Pre-training

data Qwen2.5 从以下方面提高了预训练数据的质量

Better data filtering: 使用 Qwen2-Instruct 来过滤掉质量的数据，然后从多维度对训练数据进行打分，从而提高数据的质量
Better math and code data: 加入了 Qwen2.5 Math 以及 Qwen2.5 Coder 的训练数据来提高模型的数学和代码能力
Better synthetic data: 作者使用 Qwen2-72B-Instruct 以及 Qwen2-Math-72B-Instruct 来合成 math, code, knowledge domain 的数据，然后通过过滤以及 Qwen2-Math-RM-72B 来提高数据的质量
Better data mixture: 作者使用 Qwen2-Instruct 来分类，然后平衡不同 domain 的数据分布。作者发现 e-commerce, social media 以及 entertainment 的数据重复性高，且大多都是机器生成的。而 technology, science 以及 academic research 等 domain 的数据质量更高。作者对不同 domain 的数据进行了上采样或者下采样。

基于这个过程，作者一共收集了18T tokens

Hyper-parameters 作者构建了针对超参数的 scaling law，即决定最优的训练超参数如 batch size, learning rate 等

作者通过实验得到了 model size $N$ 以及 pre-training data size $D$ 与 learning rate $\mu_{opt}$ 和 batch size $B_{opt}$ 之间的关系。

Long context pre-training 为了提升模型的上下文长度，作者将 pre-training 拆分为两个 stage，第一个 stage 的上下文长度为 4096，第二个 stage，作者将上下文长度从 4096 扩展到 32768.

在提升模型上下文过程中，作者使用 ABF 技巧将 Position Encoding 的 base frequency 从 10,000 提升到了 1,000,000.

对于 Qwen2-5-Turbo，作者实现了渐进式上下文长度扩展策略，模型上下文长度扩展经历四个阶段：32768, 65536, 131072 到最终的 262,144. 此时，RoPE 的 base frequency 为 10,000,000. 在训练的每个阶段，作者都使用了 40% 的长文本以及 60% 的短文本，以保证在扩展模型上下文长度的同时，还能保持模型在不同上下文长度下的表现。

为了提高模型在 inference 时的长上下文表现，作者使用了 Dual Chunk Attention 和 YARN 两个技巧。通过这两个技巧，作者将 Qwen2.5-Turbo 的上锈阿文扩展到了 1M，将其他模型的上下文长度扩展到了 131072.

Post-training

Qwen2.5 的 post-training 分为两个大的 stage: SFT 和 RL，其中 RL 又分为两个小的 stage，分别是 offline RL 和 online RL

在 SFT 阶段，作者主要做了以下改进：

Long-sequence generation: 作者将 Qwen2.5 的输出长度提升到了 8192, 为了扩展模型输出的长度，作者构建了 Long-response 数据集，然后基于 back-translation 来生成对应的 query，最后使用 Qwen2 来过滤低质量的数据
Math: 作者在 SFT 阶段加入了 Qwen2.5-Math 的 CoT 数据，包括公开数据集，K12 问题集一集合成数据等。作者通过 rejection sampling 以及 annotated answers 来生成 CoT 过程
Code: 作者加入了 Qwen2.5-Coder 的 SFT 数据，作者基于多个 agent 来生成多样化高质量的 Instruction, 然后还从 code-related QA website 以及 Github 上获取数据来扩展数据集。对于最终的数据，作者使用了 sandbox 来保证代码的质量
Instruction following: 作者构建了一个基于 code 的验证框架，让 LLM 同时生成 Instruction 和对应的验证代码，验证的单元测试。最后，通过 rejection sampling 来得到最终的数据集
Structured Data Understanding: 作者还构建了针对 tabular QA, fact verification, error correction 以及 structured understanding 等数据集。作者在回答中加入 CoT，作者提高了模型对 structured data 的理解能力
Logical Reasoning: 作者构建了 70,000 个不同 domain 的 query，有多种格式，覆盖了 analogical reasoning, causal reasoning 等 domain
Cross-Lingual Transfer: 作者使用了一个翻译模型，来将 Instruction 转换到 low-resource language 上，进而提高模型在对应语种上的表现
Robust System Instruction: 作者构建了不同的 system prompt 用于提升 system prompt 的多样性。作者发现，使用不同的 system prompt 可以减少模型的 variance, 提高模型的 robustness.
Response Filtering: 作者使用了多种自动化标注方法来保证最终 response 的质量

最终，作者一共收集到 1M 的 SFT 样本，模型训练了两个 epoch

在 RL 阶段，作者首先基于 SFT model 来进行采样，然后将高质量的回答作为正样本，低质量的回答作为负样本，通过这个过程，一共采集到了150K的样本。最后，作者使用 DPO 来进行训练。

然后，作者进行了 online stage 的 RL 训练，这一阶段主要是对齐模型与人类的价值观。这一阶段的数据包括公开数据集，私有数据集。作者使用不同的 checkpoint 来进行采样，然后作者使用 GRPO 来进行训练.

Long Cotnext Fine-tuning

作者还针对 Qwen2.5-Turbo 做了额外的 post-training, 来进一步提高其在长上下文下的表现。

在 SFT 阶段，作者使用了一个两阶段方法，第一阶段仅在短文本上进行训练（上下文长度为 32768），这一阶段的训练数据与其他 Qwen2.5 的模型训练数据相同。第二个阶段，作者混合了短文本和长文本（262144）来进行训练，来提高模型在长上下文情景下的指令跟随能力

在 RL 阶段，作者使用了和其他 Qwen2.5 模型相同的训练策略。作者认为：

长上下文下训练 RL 代价很大
reward model 更偏向于长文本
RL 尽管只在短文本上进行训练，其还是可以提高模型在长上下文下的表现。

Evaluation

我们仅关注 instruction 版本的 72B,32B 和 7B 模型

可以看到，Qwen2.5 72B 模型表现和 LLaMA3.1 405B 表现差不多，其他两个 size 的模型基本上达到了 SOTA

最后，作者评估了一下 DCA+YaRN v.s. Full attention 的表现，结果如下图所示

可以看到，使用 DCA+YaRN 之后，模型的推理效率比 full attention 要快 3-4 倍。

Conclusion

在本文中，作者提出了 Qwen2.5 系列大语言模型，包括 7 个 dense 模型以及两个 MoE 模型，作者详细介绍了模型的 pre-training 和 post-training. 评测结果发现 Qwen2.5 模型基本上达到了 SOTA.

作者认为，未来工作有：

使用更多更多样化的 pre-training 和 post-training 数据
多模态大模型的构建，特别是 omni-modal
提高模型的 Reasoning 能力

References

Arxiv

Dual Chunk Attention

Sat, 12 Jul 2025 10:41:12 +0800

Dual Chunk Attention (DCA) 由阿里巴巴在 2024 年 9 月份提出，DCA 是一个无需训练的，扩展 LLM 上下文长度的方法，后续，DCA 被应用于 Qwen2, Qwen2.5, Qwen2.5-1M 以及 Qwen3 中，与 YARN 一起作为扩展模型上下文的有效手段

Introduction

提升 LLM 上下文长度的方法可以分为两类：一类是 training-free 的，包括 LM-infinite 和 StreamingLLM 等，这些方法以损失 long range dependency 为代价来保持较低的 perplexity。另一类为了保留全局信息，则是通过外插来扩展模型的上下文，主要工作我们在 YARN 中已经回顾了。

第二类方法的问题在于，其依赖训练，在 training-free 的 setting 下，这些方法也会导致 perplexity 的上升

因此，在本文中，作者就提出了 Dual Chunk Attention (DCA) ，一个无需训练的，扩展 LLM 上下文长度的方法。DCA 的主要做法是将 attention 的计算进行分块，这样就可以提高计算效率。

通过实验，作者给出了三点关键发现：

Extrapolation： DCA 可以在无需训练的情况下，将 LLM 的上下文提升到 32K，而不导致 Perplexity 大幅度增加
Orthogonality： DCA 可以和其他方法一起使用，如 YARN, 这一点已经在 Qwen2.5-1M 以及 Qwen3 中得到了应用
Long Context Understanding: DCA 可以在无需训练的情况下，在长上下文设置下，达到已有 SOTA 模型的表现

Preliminary

对于一个长度为 $L$ 的 token 序列，我们首先定义对应的 position id 如下

$$ P_{\mathbf{q}} = [0,1,\dots,L-1],\quad P_{\mathbf{k}} = [0,1,\dots,L-1] $$

然后，对于第 $i$ 个位置和第 $j$ 个位置的 token，其 attention score 定义为：

$$ \langle f(\mathbf{q}, i), f(\mathbf{k}, j)\rangle =\langle R_{\theta,i}\mathbf{q}, R_{\theta,j}\mathbf{k}\rangle =\mathbf{q}^TR_{\theta, i-j}\mathbf{k} $$

具体细节参考 Position Encoding 中的 RoPE 部分介绍。这里面的关键在于，最后的结果只与相对位置 $i-j$ 相关，而与绝对位置 $i$ 和 $j$ 无关。因此，我们可以用一个相对位置矩阵 $M\in\mathbb{R}^{L\times L}$ 来表示这个信息，其中 $M_{ij}=P_{\mathbf{q},i}- P_{\mathbf{k},j}$ 代表了第 $i$ 个位置的 query $\mathbf{q}$ 和第 $j$ 个位置的 key $\mathbf{k}$ 的相对位置信息，其示意图如下所示

原始版本的 RoPE 的问题在于，在训练时，模型没有见过更长的上下文，因此其泛化性也最差，这一点在 YARN 已经得到了验证

Method

DCA 的关键在于将 sequence 分割为若干个 Chunk，然后将 attention 的计算拆分为三个部分：

intra-chunk：负责计算每个 chunk 内部的 attention
inter-chunk ：负责计算 chunk 之间的 attention
successive-chunk：负责计算相邻两个 chunk 之间的 attention

为了更好理解 DCA，我们接下来假设 $L=12$, 这时我们有

$$ P_{\mathbf{q}} = [0,1,\dots,11],\quad P_{\mathbf{k}} = [0,1,\dots,11] $$

Intra-Chunk Attention

我们首先定义个超参数 chunk size $s>0$, 然后我们将我们的 sequence 分割成 $L/s$ 个 chunk，然后每个 chunk 重新进行编号，就得到了如下的 position id

$$ P_{\mathbf{q}}^{Intra} = [0,1,\dots,L-1]\mod s,\quad P_{\mathbf{k}}^{Intra} = [0,1,\dots,L-1]\mod s $$

接下来，我们定义 intra-chunk 的相对位置矩阵 $M$，此时，我们仅在每个 chunk 内部进行计算 attention，即

$$ M[i][j] = \begin{cases} P_{\mathbf{q},i}^{Intra} - P_{\mathbf{k},j}^{Intra},&\text{if}\lfloor P_{\mathbf{q},i}/s \rfloor = \lfloor P_{\mathbf{k},j} /s\rfloor ,\\ 0,&\text{otherwise} \end{cases} $$

在上面的例子中，假设 $s=6$, 那么我们新的 position id 就变成了

$$ \begin{aligned} P_{\mathbf{q}}^{Intra} = [0,1,2,3,4,5,0,1,2,3,4,5]\\ P_{\mathbf{k}}^{Intra} = [\underbrace{0,1,2,3,4,5}_{\text{Chunk 0}},\underbrace{0,1,2,3,4,5}_{\text{Chunk 1}}] \end{aligned} $$

对其进行可视化，我们就得到

Inter-Chunk Attention

接下来，我们来看一下不同 chunk 之间如何计算彼此的 attention。在 Intra-chunk attention 计算中，我们忽略了跨 chunk 的信息，而且，由于现在的 position id 不再是单调递增的了，我们直接使用 $P_{\mathbf{q}}^{Intra}$ 和 $P_{\mathbf{k}}^{Intra}$ 给出的位置信息不对，这也是为什么我们在 Intra-chunk attention 中要求 query 和 key 在同一个 chunk 中才能计算的原因。

为了解决这个问题，作者构建了一个新的 position id。首先我们引入一个新的超参数 $c>\max_i P_{\mathbf{q},i}$, $c$ 代表了模型预训练时的上下文长度，如 4096。

接下来，基于 $c$, 我们定义新的 position id 如下：

$$ P_{\mathbf{q}}^{Inter} = [c-1,c-1,\dots,c-1]\in\mathbb{R}^s,\quad P_{\mathbf{k}}^{Inter} = P_{\mathbf{k}}^{Intra} $$

注：这里的 $P_{\mathbf{q}}^{Inter}$ 指的是某一个 chunk 中的 position id，每个 chunk 中的 position id 都相同，请参考例子理解，后面不再赘述。

也就是说，在计算跨 chunk 的 attention 的时候，我们直接把 query 的 position id 设置为最大值，然后 key 的 position id 依然使用 intra-chunk 的位置信息。由于 $\max_i P_{\mathbf{k},i}=s-1$, 因此我们有

$$ M[i][j] = P_{\mathbf{q},i}^{Inter} - P_{\mathbf{k},j}^{Inter} = c - 1 - P_{\mathbf{k},j}^{Inter}\geq c - 1 - (s- 1) \geq c-s. $$

最后，我们对于 inter chunk 的位置矩阵 $M$ 定义如下：

$$ M[i][j] = \begin{cases} P_{\mathbf{q},i}^{Inter} - P_{\mathbf{k},j}^{Inter},&\text{if}\lfloor P_{\mathbf{q},i}/s \rfloor \neq \lfloor P_{\mathbf{k},j} /s\rfloor ,\\ 0,&\text{otherwise} \end{cases} $$

在上面的例子中，当 $c=10$ 时，$c-1=9$, 我们有

$$ P_{\mathbf{q}}^{Inter}=[\underbrace{9,9,9,9,9,9}_{\text{Chunk 0}},\underbrace{9,9,9,9,9,9}_{\text{Chunk 1}}] $$

对其进行可视化，得到

Successive-Chunk Attention

现在我们既可以计算 intra-chunk，也可以计算 inter-block 的 attention，但是问题是对于相邻的 chunk，其位置信息不对了，从上面的可视化中，我们可以看到，当 $P_{\mathbf{q},i}=6$ , $P_{\mathbf{k},j}=5$ 时，我们有

$$ P_{\mathbf{q},i}^{Inter} - P_{\mathbf{k},j}^{Inter}=9-5=4\neq 1 = P_{\mathbf{q},i}-P_{\mathbf{k},j} $$

也就是说，inter-block 的 attention 会破坏原有的相对位置信息，因此我们就通过 successive chunk attention 来解决这个问题，使得 $P_{\mathbf{q},i}^{Inter} - P_{\mathbf{k},j}^{Inter}\approx P_{\mathbf{q},i}-P_{\mathbf{k},j}$.

作者发现，这个问题不是所有的 chunk 都有，而是只存在于相邻的 chunk 中，因此，作者又加入了一个超参数 $w>0$ 代表了 local window size，我们可以直接将其设置为 $c-s$, 通过这个 local window，我们调整对应的 position id 如下：

$$ P_{\mathbf{q}}^{Succ} = [\overbrace{s,s+1,\dots,s+w-1}^{w \text{ elements}},c-1, \dots,c-1]\in\mathbb{R}^s,\quad P_{\mathbf{k}}^{Succ} = P_{\mathbf{k}}^{Inter} $$

对于 successive chunk 的位置矩阵 $M$ 定义如下：

$$ M[i][j] = \begin{cases} P_{\mathbf{q},i}^{Inter} - P_{\mathbf{k},j}^{Inter},&\text{if}\lfloor P_{\mathbf{q},i}/s \rfloor - \lfloor P_{\mathbf{k},j} /s\rfloor=1 ,\\ 0,&\text{otherwise} \end{cases} $$

在上面的例子中，我们设置 $w=4$, 就得到

$$ P_{\mathbf{q}}^{Succ}=[\underbrace{6,7,8,9,9,9}_{\text{Chunk 0}},\underbrace{6,7,8,9,9,9}_{\text{Chunk 1}}] $$

对其进行可视化，得到

Computation

接下来，我们把所有的改进放在一起，就得到

$$ M[i][j] = \begin{cases} P_{\mathbf{q},i}^{Intra} - P_{\mathbf{k},j},&\text{if}\lfloor P_{\mathbf{q},i}/s \rfloor - \lfloor P_{\mathbf{k},j} /s\rfloor=0 ,\\ P_{\mathbf{q},i}^{Succ} - P_{\mathbf{k},j},&\text{if}\lfloor P_{\mathbf{q},i}/s \rfloor - \lfloor P_{\mathbf{k},j} /s\rfloor=1 ,\\ P_{\mathbf{q},i}^{Inter} - P_{\mathbf{k},j},&\text{if}\lfloor P_{\mathbf{q},i}/s \rfloor - \lfloor P_{\mathbf{k},j} /s\rfloor>1. \end{cases} $$

基于上面的位置矩阵 $M$，我们再依次计算对应的 attention score

$$ \langle f(\mathbf{q}, i), f(\mathbf{k}, j)\rangle = \begin{cases} \langle f(\mathbf{q}, P_{\mathbf{q},i}^{Intra}) , f(\mathbf{k}, P_{\mathbf{k},j})\rangle,&\text{if}\lfloor P_{\mathbf{q},i}/s \rfloor - \lfloor P_{\mathbf{k},j} /s\rfloor=0 ,\\ \langle f(\mathbf{q}, P_{\mathbf{q},i}^{Succ}) , f(\mathbf{k}, P_{\mathbf{k},j})\rangle,&\text{if}\lfloor P_{\mathbf{q},i}/s \rfloor - \lfloor P_{\mathbf{k},j} /s\rfloor=1 ,\\ \langle f(\mathbf{q}, P_{\mathbf{q},i}^{Inter}) , f(\mathbf{k}, P_{\mathbf{k},j})\rangle,&\text{if}\lfloor P_{\mathbf{q},i}/s \rfloor - \lfloor P_{\mathbf{k},j} /s\rfloor>1. \end{cases} $$

Code

首先是 RotaryEmbedding 部分的修改

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


class DCARotaryEmbedding(nn.Module):
 def __init__(self, max_len, chunk_size, local_window):
 self.max_len = max_len
 self.chunk_size = chunk_size
 self.local_window = local_window

 self.inv_freq = ...

 def forward(self, x):
 q_t = torch.arange(self.chunk_size)
 qc_t = (q_t + self.chunk_size).clamp(max=self.chunk_size)
 k_t = torch.arange(seq_len) % self.chunk_size

 q_freqs = torch.outer(q_t, self.inv_freq) # seq_len x dim/2
 qc_freqs = torch.outer(qc_t, self.inv_freq)
 k_freqs = torch.outer(k_t, self.inv_freq) # seq_len x dim/2

 q_emb = torch.cat((q_freqs, q_freqs), dim=-1) # seq_len x dim
 qc_emb = torch.cat((qc_freqs, qc_freqs), dim=-1)
 k_emb = torch.cat((k_freqs, k_freqs), dim=-1) # seq_len x dim
 # compute related sin, cos
 return q_sin, q_cos, qc_sin, qc_cos, k_sin, k_cos

attention 计算时的逻辑

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


class Attention(nn.Module):
 def forward(...):

 key_states = apply_rotary_pos_emb(key_states, k_cos, k_sin, position_ids)
 q_states_intra = apply_rotary_pos_emb(query_states[:, :, :chunk_len, :], q_cos, q_sin,
 position_ids[:, :chunk_len])
 k_states_prev = key_states[:, :, :chunk_len, :]
 v_states_prev = value_states[:, :, :chunk_len, :]
 # first chunk
 flash_result = do_flash_attn(q_states_intra, k_states_prev, v_states_prev)
 flash_results.append(flash_result)
 remain_len = kv_seq_len - chunk_len

 while remain_len > 0:
 flash_per_chunk = []
 begin = kv_seq_len - remain_len
 curr_chunk_len = min(chunk_len, remain_len)
 end = begin + curr_chunk_len
 # current chunk, intra-chunk attention
 q_states_intra = apply_rotary_pos_emb(query_states[:, :, begin:end, :], q_cos, q_sin,
 position_ids[:, begin:end])

 k_states_intra = key_states[:, :, begin:end, :]
 v_states_intra = value_states[:, :, begin:end, :]
 flash_result = do_flash_attn(q_states_intra, k_states_intra, v_states_intra)
 flash_per_chunk.append(flash_result)
 # successive chunk attention
 q_states_succ = apply_rotary_pos_emb(query_states[:, :, begin:end, :], qc_cos, qc_sin,
 position_ids[:, begin:end])
 flash_result = do_flash_attn(q_states_succ, k_states_prev, v_states_prev, False)
 flash_per_chunk.append(flash_result)
 # inter chunk attention
 if begin - (k_states_prev.size(-2)) > 0:
 prev_len = k_states_prev.size(-2)
 q_states_inter = apply_rotary_pos_emb(query_states[:, :, begin:end, :], qc_cos, qc_sin,
 position_ids[:, chunk_len - 1][:, None].repeat(1, curr_chunk_len))
 k_states_inter = key_states[:, :, :begin - prev_len, :]
 v_states_inter = value_states[:, :, :begin - prev_len, :]
 flash_result = do_flash_attn(q_states_inter, k_states_inter, v_states_inter, False)
 flash_per_chunk.append(flash_result)

 flash_results.append(flash_per_chunk)
 k_states_prev = k_states_intra
 v_states_prev = v_states_intra
 remain_len = remain_len - chunk_len
 # merge the final results
 attn_output = merge_attn_outputs(flash_results)

Evaluation

作者还分析了一下 DCA 的效率，结果如下

可以看到，在 flash attention 的基础上加上 DCA 之后，内存占用和推理时间并没有发生太大变化

作者还分析了三种 attention 对结果的贡献，如下图所示

结果显示，intra block 的 perplexity 是最低的，但是其在下游任务上表现是最差的。当三者结合在一起之后，perplexity 和下游任务上的表现都是最好的。

Conclusion

本文中，我们回顾了 Qwen 系列扩展大模型上下文的方法 Dual Chunk Attention （DCA）通过将 attention 切分成更小的 chunk，然后将 attention 的计算分为 intra-chunk，inter-chunk 和 successive-chunk，分别处理 chunk 内部，chunk 之间以及相邻 chunk 的 attention，通过这种方式，在无需训练的情况下，我们可以有效将模型上下文长度扩展 4 倍以上。

References

Arxiv
Github

Notes on Qwen2

Sat, 12 Jul 2025 10:36:43 +0800

Introduction

2024 年 9 月 Qwen 发布了 Qwen2 系列技术报告，Qwen2 系列包括 4 个 dense 模型（0.5B, 1.5B, 7B, 72B）和一个 MoE 模型（总参数 57B，激活参数 14B），作者主要在架构，数据和长上下文上进行了改进。

Method

Model

对于 dense 模型，Qwen2 在 Qwen-LLM 的基础上做了如下改动：

使用 Group Query Attention (GQA) 替换 MHA，来优化 KV cache，提高 throughput
使用 Dual Chunk Attention 和 YARN 来提高模型上下文长度和训练效率

其余与 Qwen 一致，包括 SwiGLU，RoPE，RMSNorm 和 pre-normalization

对于 MoE 模型，Qwen2-MoE 基于 Qwen1.5 进行了改进，主要是 3 点：

作者使用了更细粒度的专家个数，作者认为细粒度的专家可以提供更丰富的 combination，这一点与 olmoe 的结论相同
与 DeepSeek-MoE 一样，作者使用了共享专家和路由专家
作者使用了类似 upcycling 的方法来初始化模型。假设一共有 $n$ 个专家，每个专家的维度为 $h_E$, 原始 dense 模型的维度为 $h_{FFN}$, 那么我们会把 dense 模型的参数复制 $[nh_E/h_{FFN}]$ 次，这样就可以扩展到任意个数的 MoE 模型上。作者还对参数进行 shuffle，来提高 diversity。最后，作者还对 50% 的参数进行随机初始化，来提高模型的 capacity。

模型配置如下

Configuration	0.5B	1.5B	7B	72B	57B-A14B
Hidden Size	896	1,536	3,584	8,192	3,584
# Layers	24	28	28	80	28
# Query Heads	14	12	28	64	28
# KV Heads	2	2	4	8	4
Head Size	64	128	128	128	128
Intermediate Size	4,864	8,960	18,944	29,568	2,560
# Routed Experts	-	-	-	-	64
# Activated Experts	-	-	-	-	8
# Shared Experts	-	-	-	-	8
Embedding Tying	True	True	False	False	False
Vocabulary Size	151,646	151,646	151,646	151,646	151,646
# Trained Tokens	12T	7T	7T	7T	4.5T

Pre-training

预训练阶段的数据基于 Qwen 和 Qwen1.5，数据处理策略如下：

使用基于 heuristic 和 model-based 方法来过滤掉低质量的数据
加入了 code， math 和 multilingual 的数据
平衡了各个类别的数据分布

初始数据包括 12T token，经过过滤得到 7T token。作者发现，使用 12T token 进行训练，模型的表现不如使用 7B token 训练得到的模型效果好。因此除了 0.5B 的模型，其他模型使用的都是 7T 的 token

对于 MoE 模型，作者使用了额外的 4.5T token 来进行预训练。

在训练过程中，作者还加入了 multi-task instruction 数据，来提高模型的上下文学习能力和指令跟随能力。

作者还将 Qwen2 模型系列的上下文长度从 4096 扩展到 32768，扩展过程中作了三个改动：

加入了更多高质量的长上下文数据
将 RoPE 的 frequency 从 10,000 提升到了 1,000,000
使用了 YARN 来扩展上下文长度
使用了 Dual Chunk Attention 来优化 attention 的计算

Post-training

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

数据包括 SFT 数据和 RLHF 使用的偏好数据

数据标注过程有：

使用 InsTag 对数据进行打标
选取高质量的 instruction
构建了一个 self-evolution 策略，来扩展 instruction 数据
请人类来标注数据

作者还合成了一些数据，合成数据的过程如下：

rejection sampling：对 LLM 进行多次采样，然后保留结论正确的数据作为 SFT 数据，以正确和错误的数据对作为偏好数据
Execution feedback：对于代码任务，使用 Python 来验证答案的正确性
Data Repurposing：对于写作类任务，以文档为输入，让 LLM 生成对应的 instruction
Constitutional Feeback：基于预设的 principle 来生成回答

最终，SFT 数据包括 500, 000 条样本

RLHF 的训练包括 offline stage 和 online stage，offline stage 就是用收集到的偏好数据。在 online stage，作者使用 reward model 来给输出的回答进行打分，然后再使用 DPO 进行训练。

与 Qwen 不同，Qwen2 中作者使用了 Online Merging Optimizer 来解决因为 alignment 导致的性能降低

Conclusion

本文提出了 Qwen2 系列，在 Qwen2 中，首次使用了 GQA 代替 MHA，Qwen2 在上下文上做出了初步探索

References

Qwen2 tech report

Notes on Qwen1.5

Thu, 03 Jul 2025 17:37:39 +0800

Qwen 在 24 年 1 月份发布了 Qwen1.5，包含 0.5B, 1.8B, 4B, 7B, 14B, 32B, 72B, 以及 110B 6 个 size，还有一个 MoE 模型。

介绍

Qwen1.5 的主要特点：

支持 12 中语言
统一支持 32768 tokens 上下文长度。
提供量化版本（Int4、Int8、AWQ、GGUF）以适应低资源环境或部署需求。

训练过程使用了 DPO 以及 PPO 来进行对齐

Qwen1.5-MoE

Qwen1.5-MoE 的激活参数为 2.7B，一共包含 64 个专家，其中激活 4 个专家，共享 4 个专家

相比于 Qwen1.5-7B，去训练的 FLOPS 降低了 75%，inference 的速度提高了 174%

Qwen1.5-MoE 采用了改进的 MoE 架构，主要优化包括：

细粒度专家（Fine-grained experts） ：通过将 FFN 层划分为多个片段，构建更多专家而不增加参数总量。
初始化策略（Upcycling） ：基于 Qwen-1.8B 初始化模型，并引入随机性以加速收敛。
路由机制（Routing Mechanism） ：在每个 MoE 层中使用 64 个专家，其中 4 个共享专家始终激活，60 个路由专家中有 4 个被激活，提高了灵活性和效率。

效率对比

作者对比了 throughput (requests processed per second) 以及 tokens per second (TPS):

Model	Throughput	TPS
Qwen1.5-7B-Chat	1.15	2298.89
Qwen1.5-MoE-A2.7B-Chat	2.01	4010.27

References

Notes on YaRN

Thu, 03 Jul 2025 14:40:49 +0800

Introduction

YaRN (Yet Another RoPE extentionN method) 时23年9月EleutherAI等提出来的一个扩展LLM上下文长度的方法，后来被Qwen系列模型所应用。

Preliminary

作者首先回顾了一下RoPE, 具体内容请参见上一篇blog。并使用了 $f_{W}(x_m, m, \theta_d)$ 来表示RoPE：

$$ f_{W}(x_m, m, \theta_{d}) = \Theta_{\theta, m}^d W x_m $$

其中 $\Theta_{\theta, m}^d\in\mathbb{R}^{d\times d}$ 是多维旋转矩阵, $\theta_d=[\theta_{0,d},\dots,\theta_{(d-2)/2,d}]\in\mathbb{R}^{d/2}$, $\theta_{i,d}=\theta^{2i/d}$, $\theta>0$ 是一个超参数，RoPE中设置为 $\theta=10000$, $W\in\{W_q,W_k\}\subset\mathbb{R}^{d\times d}$ 是对应的query/key projection layer的权重矩阵， $x\in\mathbb{R}^{d}$ 是输入的hidden states.

接下来，作者定义了两个新的变量：

scaling factor 假设预训练的上下文长度为 $L$, 扩展的上下文长度为 $L'>L$, 则我们定义scaling factor 为

$$ s = \frac{L'}{L} $$

易知 $s>1$.

wavelength 我们将 $\lambda_d$ 定义为 $i$-th 维的RoPE embedding对应的 wavelength：

$$ \lambda_{i,d} = \frac{2\pi}{\theta_{i,d}} = 2\pi\theta^{2i/d}, \ i=0,\dots,(d-2)/2 $$

wavelength描述了对于第$i$ 个维度，RoPE旋转一周 ($2\pi$) 所需要的上下文长度。

基于 $f_{W}(x_m, m, \theta_d)$, 作者统一了已有的扩展上下文长度的方法，作者将不同的扩展方法使用一个通用函数 $f_W(x_m,g(m), h(\theta_d))$ 来表示，这里 $g(m)$ 和 $h(\theta_d)$ 分别代表了不同的长度外推方法所使用的变换。

Position Interpolation

Position Interpolation (PI) 的核心思想在于，我们可以通过Interpolation，将超过预训练长度的文本给压缩到当前最大长度，以此来避免RoPE外推产生的问题，其对应的公式为

$$ f'_W(x_m,m,\theta_d) = f_W(x_m, \frac{mL}{L'}, \theta_d) $$

其中 $L'>L$ 为我们扩展之后的上下文长度， $L$ 为我们预训练的上下文长度。使用通用函数表示的话，我们有

$$ g(m) = \frac{m}{s},\quad h(\theta_d) = \theta_d $$

NTK-aware Interpolation

PI的问题是，并没有考虑不同维度的wavelength。基于NTK理论，DNN当输入维度比较低，且embedding缺少高频内容时，模型就会很难学习到高频信息。对应到RoPE里面，输入的token position id是低位信息（1维），而输出的RoPE是一个 $d$ 维的复杂向量。因此，当输入token非常相似却距离非常近时，RoPE就会丢失高频的细节信息

因此，为了解决这个问题，作者对不同的维度使用了不同的缩放策略：维度比较小时，其缩放的更多，维度比较大是，其缩放的更少。

基于这个策略，作者提出了NTK-aware interpolation，其定义如下：

$$ g(m) = m, \quad h(\theta_{i,d}) = \theta'^{-2i/d}, i=0,\dots,(d-2)/2 $$

其中

$$ \theta' = \theta\cdot s^{\frac{d}{d-2}} $$

实际中，这种方法会产生out-of-bound的值，因此最终结果会比PI要差一点，为了解决这个问题，一般会使用比 $s$ 更大的scaling factor.

上式的推导基于一个简单的假设：我们希望最后一个维度的wavelength在scaling之后，是线性变化的，即 $\theta'_{(d-2)/2,d}=s\theta_{(d-2)/2,d}$, 求解之后，我们就得到了上面的定义

PI 和NTK-aware interpolation的问题在于，我们对不同的维度的处理都是一样的。这类不在乎wavelength的方法被称为blind interpolation methods, 接下来要介绍的就是基于wavelength的方法，即target interpolation methods.

NTK-by-parts Interpolation

与NTK-aware interpolation， NTK-by-parts interpolation基于wavelength来考虑不同维度上所做的变换。

对于低维度，其 $\theta_{i,d}$ 非常大，因此旋转一周所需要的上下文长度也非常大。实际上就导致某些维度的embedding并不是均匀分布的，（比如说只有 $0\sim\pi$ 这个区间的embedding），这个时候，模型就只能访问到绝对位置信息，而访问不到相对位置信息。另外，当我们对所有的维度都进行scale的时候，所有的token都会与彼此更加靠近，这损害了模型对于局部信息的获取能力。基于这些认知，作者基于wavelength，对不同的维度分别进行处理：

如果wavelength远小于上下文长度 $L$，则我们不做任何处理
如果wavelength等于或者大于上下文长度 $L$，则我们使用NTK-aware interpolation 进行处理
对于中间的其他维度，我们进行了一个trade off

作者定义了一个ratio $r$ 来描述原始上下文长度 $L$ 和 wavelength 之间的关系

$$ r(i,d) = \frac{L}{\lambda_{i,d}} = \frac{L}{2\pi\theta'^{2i/d}} $$

基于这个ratio，我们可以定义上面的三种处理方式对应的权重

$$ \gamma(r) = \begin{cases} 0, &\text{if } r < \alpha\\ 1, &\text{if } r > \beta\\ \frac{r-\alpha}{\beta-\alpha}, &\text{otherwise} \end{cases} $$

其中， $\beta>\alpha>0$ 是超参数， $r<\alpha$, $r<\beta$ 分别代表了上面的第1种，第2种情况。

最后，NTK-by-parts interpolation的定义如下

$$ g(m) = m, \quad h(\theta_i) = \left(1-\gamma(r(i,d)\right)\frac{\theta_i}{s} + \gamma(r(i,d))\theta_i $$

作者通过实验发现，在LLaMA上，$\alpha=1$ 和 $\beta=32$ 是一个比较好的选择

Dynamic NTK Interpolation

在实际中，一个经常遇到的场景就是sequence length会从1逐步上升到最大上下文长度，比如说inference的时候。对于这种情况，我们有两种解决方法：

在整个inference周期中，RoPE的scaling factor都设置为 $s=K'/L$, 其中$L'$ 是扩展后的上下文长度
在每次foward的过程汇总，都更新sclaing factor $s=\max(1, \ell'/L)$, 这里 $\ell'$ 是当前sequence的长度

作者发现，方案1在sequence长度小于 $L$的时候性能会下降，并且当上下文长度超过 $L'$ 时，性能下降的更快。但是，方案2可以让模型的性能下降曲线更平缓。因此，作者将这种inference-time方法称为 Dynamic Scaling method, 当其与NTK-aware方法结合时，就得到了 Dynamic NTK interpolation

作者通过实验发现，Dynamic NTK interpolation在$L'=L$ 时，效果非常好

YaRN

在YaRN中，作者针对Dynamic NTK interpolation做了进一步改进，也就是在计算attention softmax时，加入了一个温度参数 $t>0$, 这样attention的计算就变成了

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

作者发现，通过这种scaling的方式，YaRN可以在不改变代码的前提下，更改attention的机制。并且，其不增加训练和推理的cost

作者将YaRN定义为结合了NTK-by-parts interpolation和上述scaling技巧的方法

对于LLaMA，作者推荐使用如下参数：

$$ \sqrt{\frac{1}{t}} = 0.1\ln(s) + 1. $$

实验结果如下

作者发现：

对于合适的 $t$, 扩展上下文之后，perplexity会变的更好
最好的$t$ 对于不同的位置和样本提升都是一样的

Evaluation

实验结果如下

Extension Method	Trained Tokens	Context Window			Evaluation Context Window Size
			2048	4096	6144	8192	10240
PI (s = 2)	1B	8k	3.92	3.51	3.51	3.34	8.07
NTK ($\theta$ = 20k)	1B	8k	4.20	3.75	3.74	3.59	6.24
YaRN (s = 2)	400M	8k	3.91	3.50	3.51	3.35	6.04

可以看到，YaRN使用的数据更少，并且当模型扩展到10240的时候，其表现下降的最慢，这说明了YaRN在扩展上下文长度时的有效性

原始RoPE，dynamic-PI和dynamic-YaRN的对比

可以看到，RoPE的上下文扩展能力很差，Dynamic-YaRN的表现最好。

Code

YaRN的实现在HuggingFace/src/transformers/modeling_rope_utils.py 里的 _compute_yarn_parameters 函数里，其返回 inv_freq 以及 attention_factor 两个量，前者代表了 $\theta_d$, 后者代表 $t\sqrt{d}$.

 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



def get_mscale(scale):
 if scale <= 1:
 return 1.0
 return 0.1 * math.log(scale) + 1.0

def find_correction_dim(num_rotations, dim, base, max_position_embeddings):
 """Inverse dimension formula to find the dimension based on the number of rotations"""
 return (dim * math.log(max_position_embeddings / (num_rotations * 2 * math.pi))) / (2 * math.log(base))

def find_correction_range(low_rot, high_rot, dim, base, max_position_embeddings):
 """Find dimension range bounds based on rotations"""
 low = math.floor(find_correction_dim(low_rot, dim, base, max_position_embeddings))
 high = math.ceil(find_correction_dim(high_rot, dim, base, max_position_embeddings))
 return max(low, 0), min(high, dim - 1)

def linear_ramp_factor(min, max, dim):
 if min == max:
 max += 0.001 # Prevent singularity

 linear_func = (torch.arange(dim, dtype=torch.float32) - min) / (max - min)
 ramp_func = torch.clamp(linear_func, 0, 1)
 return ramp_func


class YaRNRotaryEmbedding(nn.Module):
 def __init__(self, config):
 beta_fast = config.get("beta_fast") or 32
 beta_slow = config.get("beta_slow") or 1
 dim = config["head_dim"]
 factor = config.max_position_embeddings / original_max_position_embeddings
 pos_freqs = base ** (torch.arange(0, dim, 2) / dim)
 inv_freq_extrapolation = 1.0 / pos_freqs
 inv_freq_interpolation = 1.0 / (factor * pos_freqs)

 low, high = find_correction_range(beta_fast, beta_slow, dim, base, original_max_position_embeddings)

 # Get n-dimensional rotational scaling corrected for extrapolation
 inv_freq_extrapolation_factor = 1 - linear_ramp_factor(low, high, dim // 2)
 inv_freq = (inv_freq_interpolation * (1 - inv_freq_extrapolation_factor) + inv_freq_extrapolation * inv_freq_extrapolation_factor)

 attention_factor = get_mscale(factor)

 def forward(self, x, position_ids):
 ...
 return cos, sin

实际的transformers代码中，Qwen使用的还是默认的RoPE，在inference时如果我们需要扩展上下文，可以通过修改config的形式：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


from transformers import pipeline

model_name_or_path = "Qwen/Qwen3-8B"

generator = pipeline(
 "text-generation",
 model_name_or_path,
 torch_dtype="auto",
 device_map="auto",
 model_kwargs={
 "max_position_embeddings": 131072,
 "rope_scaling": {
 "rope_type": "yarn",
 "factor": 4.0,
 "original_max_position_embeddings": 32768,
 },
 }
)

Conclusion

在本文中，作者首先构建了一个统一的表征不同上下文长度扩展的形式，接下来作者分析了不同上下文长度扩展的不足，并提出了YaRN这种上下文长度扩展方式，结果发现，YaRN不仅在短上下文长度下面表现很好，当上下文长度扩展之后，其表现依然非常优秀。

References

Notes on Qwen-LLM

Thu, 03 Jul 2025 10:47:27 +0800

Qwen 在 23 年 9 月份发布了 Qwen 系列大语言模型，包括 1.8B， 7B，14B 三个 size，训练过程使用了 3T token. 作者还基于 Qwen，构建了 Code-Qwen-Chat，Math-Qwen-Chat 等系列领域大语言模型。

Pre-training

Data

数据一共使用了 3T token，主要是 public web documents, encyclopedia, books, codes, etc，覆盖了中文和英文两种语言

数据处理：

语言识别
去重，包括 MinHash 和 LSH 算法
质量过滤，包括基于规则和和基于 ML 的方法
上采样，特定数据会进行上采样
加入指令数据，提高模型的 zero-shot 和 few-shot 表现

Tokenization

BPE tokenizer，最终的 tokenizer 大小为 152K

Architecture

模型架构基于 LLaMA，改动：

tie embdding: input embdding 和 output embdding 使用的权重相同
position encoding:RoPE, inverse frequency 的精度为 FP32
bias: 取消了大部分的 bias，增加了 QKV bias，来提高模型的外推能力
Pre-Norm & RMSNorm
Activation function: SwiGLU

Training

上下文长度：2048
attention：flash attention
optimizer：AdamW， $\beta_1=0.9$, $\beta_2=0.95$, $\epsilon=10^{-8}$.
data type: BF16

Context Extention

使用了三个技巧：

NTK-aware position interpolation
log-N scaling
window attention

后续前两个统一成了 YARN.

observation: lower layer 对上下文长度扩展更敏感, 因此作者动态调整了 window size

Post-training

包括 SFT 和 RLHF 两个阶段

SFT

data：使用了 ChatML 格式

RLHF

PPO 算法

reward model 构建：基于 Qwen-base model

RL 训练：先更新 value model 50 steps

发现：top-p 设置为 0.9 比设置为 1.0 更好

Tool-use and Agent

作者使用了 self-instruct 来进行 SFT，基于 ReAct 构建数据，数据包括 2000 条高质量数据

Specialization

Code-Qwen

code-qwen 基于 qwen continue Pretraining 得到，然后基于 code-qwen 进行 sft 得到 code-qwen-chat，包括 7B 和 14B 两个 size

Math-Qwen

基于 qwen 直接 SFT 得到，包括 7B 和 14B 两个 size

Conclusion

作者在本文中介绍了 Qwen 系列大语言模型，模型使用了 3T token，作者介绍了训练的细节以及如何扩展到领域大语言模型 Code-Qwen 和 Math-Qwen

References

Notes on Qwen3

Thu, 15 May 2025 14:48:11 +0800

Qwen 在 2025 年 5 月发布了 Qwen3 系列大语言模型，Qwen3 包括 6 个 dense 模型和 2 个 MoE 模型，主要亮点为多语种能力，自适应快慢思考能力以及支持用户设置 thinking budget.

Qwen3 包括 6 个 dense 模型和 2 个 MoE 模型，其旗舰模型是一个 235B 的 MoE 模型，激活参数为 22B. Qwen3 系列的主要亮点如下:

快慢思考融合，模型原生支持在 reasoning/non-reasoning 模式之间切换
Reasoning budget, 用户可以指定思考需要的 budget，来平衡 latency 和 performance
Distillation, 使用蒸馏的方法训练小模型，大幅度提高模型的表现
多语种支持，相比于 Qwen2.5，Qwen3 支持 119 中语言和方言

Method

Model

Qwen3 的 dense 模型的架构与 Qwen2.5 基本一致，包括使用 GQA , SwiGLU, RoPE, RMSNorm 和 pre-normalization. Qwen3 进一步移除了 QKV bias, 然后加入了 QK-Norm 来提高训练的稳定性。

Qwen3 的 MoE 架构使用了 128 个专家，激活专家个数为 8 个。与 Qwen2.5-MoE 不同，Qwen3 里没有使用 shard experts。并且，Qwen3 加入了 global-batch load balancing loss,来提高 expert 的特化程度。

在 tokenizer 方面，Qwen 系列的 tokenizer 一直都是一样的，这也是 Qwen 系列领先的一点。

模型的具体参数如下两张表所示。

MoE 架构：上下文长度为 128K，128 个专家，每个 token 由 8 个专家负责处理

Qwen3-235B-A22B, 总参数 235B，激活参数 22B
Qwen3-30B-A3B, 总参数 30B，激活参数 3B

Models	Layers	Heads (Q / KV)	# Experts (Total / Activated)	Context Length
Qwen3-30B-A3B	48	32 / 4	128 / 8	128K
Qwen3-235B-A22B	94	64 / 4	128 / 8	128K

dense 架构: Qwen3-32B, Qwen3-14B, Qwen3-8B, Qwen3-4B, Qwen3-1.7B, and Qwen3-0.6B

Models	Layers	Heads (Q / KV)	Tie Embedding	Context Length
Qwen3-0.6B	28	16 / 8	Yes	32K
Qwen3-1.7B	28	16 / 8	Yes	32K
Qwen3-4B	36	32 / 8	Yes	32K
Qwen3-8B	36	32 / 8	No	128K
Qwen3-14B	40	40 / 8	No	128K
Qwen3-32B	64	64 / 8	No	128K

Pre-training

预训练数据一共包括 36T token，覆盖了 119 种语言。数据包括 coding, STEM, reasoning, books, multilingual texts 以及合成数据。

为了扩展训练数据，作者微调了 Qwen2.5-VL 来从 PDF 文档中提取文字，然后使用 Qwen2.5 来进行修正。最终收集到了几 T 的 token。另外，作者还使用 Qwen2.5, Qwen2.5-Math, Qwen2.5-Coder 来合成不同格式的数据，包括教科书，QA，指令以及代码片段等。最后，作者加入了更多的多语种数据。

作者从 educational value, fields, domains 以及 safety 对数据进行了标注。在数据混合时，Qwen3 在 instance 层面进行操作。

预训练阶段包括 3 个 stage：

General Stage (S1): 这一阶段的目的是让模型掌握世界知识，使用了 30T 的 token，模型上下文长度为 4096
Reasoning Stage (S2): 这一阶段的目的是提高模型的推理能力，使用了 5T 的高质量 token，模型上下文长度为 4096，数据包括 STEM, coding, reasoning 以及合成数据
Long Context Stage (S3): 这一阶段的目的是提升模型的长上下文能力，使用了几百 B的 token，模型上下文长度为 32768.训练时数据混合 75% 的长文档数据，25% 的短文本数据。作者将 RoPE 的 frequency 从 10000 提升到了 1,000,000. 作者还是用 YARN 以及 Dual Chunk Attention 来提高 inference 效率

对 pre-training 的 base model 进行评测之后，作者发现：

Qwen3-235B-A22B-Base 超过了其他 base 模型的表现，包括 DeepSeek-V3 Base, Llama-4-Maverick Base, Qwen2.5-72B Base
Qwen3-MoE 模型与相同大小的 Qwen3-Dense 模型参数相比，其只需要 1/5 的参数就可以达到相同的表现
Qwen3-MoE 模型与 2 倍参数量的 Qwen2.5-MoE 模型表现差不多
Qwen3-Dense 模型与大一个量级的 Qwen2.5-Dense 模型表现差不多

Post-training

Qwen3 的 post-training 如下图所示：

对于旗舰模型 (Qwen3-235B-A22B, Qwen3-32B) 的训练，Qwen3 使用了一个四阶段的训练 pipeline。对于轻量化模型（其他模型）的训练，Qwen3 使用了知识蒸馏。

旗舰模型的训练包括四个阶段，前两个阶段用于提升模型的 reasoning 能力，后两个阶段用于将 reasoning 和 non-reasoning 能力结合起来。

Flashship Model

Stage 1 (Long CoT Cold Start) 这个阶段的目的是让模型掌握 reasoning 的基础。这个阶段使用了数学，代码，逻辑推理和通用的 STEM 相关问题。每个问题都有参考答案或者 test-cases. 作者使用了 Qwen2.5-72B 来过滤数据，包括 non-verifiable prompts 以及太简单的 prompt. 作者认为，这一阶段应该减少训练使用的样本和训练步数。

Stage 2 (Reasoning RL) 这个阶段的目的是提升模型的 reasoning 能力。该阶段使用了 3,995 条过滤得到的样本，算法为 GRPO. 作者发现提高 batch size 和每个 query 的 rollouts 可以提高模型的表现。作者通过调整模型的 entropy 来控制 exploration 和 exploitation 的平衡

Stage 3 (Thinking Mode Fusion) 这一阶段的目的是将 non-reasoning 能力加入到之前的 reasoning 模型中。作者在第二阶段的 model 上进行了 continual SFT，然后构建了一个 chat template 用于融合两种模式。

reasoning 数据来源于 stage1 的 rejection sampling 和 stage 2 的模型. non-reasoning 数据来源于各种任务，如 coding, math, multilingual 等。为了保证模型的多语种能力，作者还加入了一些翻译相关的数据。

作者还构建了一个 chat template, 用于统一数据格式。chat template 如下图所示

作者使用 /think 和 /no_think 来标记两种模式，对于 non-reasoning mode, 其 <think></think> 会被置空。模型在默认情况下处于 reasoning mode, 因此作者加入了一些不包含 /think 的 reasoning 数据。

作者发现，通过这种 Think mode fusion, 模型可以学会在 reasoning mode 和 non-reasoning mode 下进行回答，因此，模型也可以基于中间结果来给出最终的答案。当超出 budget 之后，作者使用以下 Instruction

Considering the limit time by the user. I have to give the solution based on the thinking directly now. \n</think>.\n\n

来让模型直接终止思考二给出最终的答案。

Stage 4 (General RL) 这个阶段的目的是提升模型在不同场景下的能力。作者构建了一个 reward system 来覆盖 20 多种不同的任务。这些任务包括：instruction following, format following, preference alignment, agent ability 以及 abilities for specialized scenarios.

作者构建了三种不同的 rewards:

Rule-based rewards: 覆盖的任务包括 instruction following 和 format following
Model-based rewards: 作者使用 Qwen2.5-72B 来判别答案的正确性
Model-based Reward without reference answer: 作者训练一个 reward model 来给模型的回答进行打分

Lightweight Model

对于轻量化的模型，作者发现直接通过蒸馏可以有效提高学生模型的表现，并且训练效率也更高。蒸馏训练包括两个阶段：

Off-policy Distillation: 这个阶段的目的是让模型拥有基本的 reasoning 能力并且可以在不同的模式中进行切换。作者使用了教师模型的 reasoning 输出和 non-reasoning 输出来蒸馏学生模型
On-policy Distillation: 在这个阶段，学生模型生成回答，然后基于教师模型的输出，使用 KL-divergence 来更新学生模型的参数

Evaluation

Thinking budget. 作者发现当我们提高 Thinking budget 之后，模型的表现是可以持续提升的。结果如下图

Efficiency of distillation. 作者发现使用 distillation 可以大幅度提高模型的表现和训练效率。下面是结果如下图所示

Effects of Thinking mode fusion and RL 作者进一步探究了三个 stage 对模型表现的影响，为此，作者构建了 in-house benchmarks 来评估模型的表现，这些 benchmarks 包括：

CounterFactrQA. 问题是不符合事实的，用于评估模型的幻觉
LengthCtrl. 有长度要求的写作任务，评估生成内容长度和给定长度之间的差别
ThinkFollow. 多轮对话，每轮对话随机插入 /think 和 /no_think flag，评估模型是否能在两种模式之间切换
Tooluse. 评估模型的工具调用能力

结果如下

结论如下：

Stage3 可以提高模型在两种 reasoning mode 切换的能力，并且 stage3 还可以提高模型的通用以及 instruction following 能力
Stage4 进一步提高模型在两种模式下的通用，instruction following 和 agent 能力
Stage3 和 stage4 并没有显著提高模型在 knowledge, STEM, math 和 coding 相关任务上的表现。甚至在一些竞赛如 AIME24 上模型的表现还有所下降，作者认为这是由于我们提升了模型的通用能力而导致其特化能力下降导致的，作者认为作为一个通用模型，这是可以接受的。

Conclusion

在本文中，作者提出了 Qwen3 系列大语言模型，包括 6 个 Dense 模型和 2 个 MoE 模型。Qwen3 模型标志了一个新的 SOTA，其特点主要是快慢思考结合，thinking budget，以及多语种。

作者认为后续工作有以下几点：

使用更高质量的数据来进行预训练
优化模型架构和训练方式，提升模型的上下文
提高针对 RL 的计算资源，来进一步提高模型的 agent 能力

References

Arxiv
Github

Notes on Qwen3 blog

Tue, 29 Apr 2025 11:23:04 +0800

介绍

Qwen3发布，包含两种架构的模型，每种架构均包含对应的base model和post-trained model.

MoE架构：上下文长度为128K，128个专家，每个token由8个专家负责处理

Qwen3-235B-A22B, 总参数235B，激活参数22B，
Qwen3-30B-A3B, 总参数30B，激活参数3B

Models	Layers	Heads (Q / KV)	# Experts (Total / Activated)	Context Length
Qwen3-30B-A3B	48	32 / 4	128 / 8	128K
Qwen3-235B-A22B	94	64 / 4	128 / 8	128K

dense架构: Qwen3-32B, Qwen3-14B, Qwen3-8B, Qwen3-4B, Qwen3-1.7B, and Qwen3-0.6B

Models	Layers	Heads (Q / KV)	Tie Embedding	Context Length
Qwen3-0.6B	28	16 / 8	Yes	32K
Qwen3-1.7B	28	16 / 8	Yes	32K
Qwen3-4B	36	32 / 8	Yes	32K
Qwen3-8B	36	32 / 8	No	128K
Qwen3-14B	40	40 / 8	No	128K
Qwen3-32B	64	64 / 8	No	128K

亮点

Hybrid Thinking modes qwen3支持两种思考模式： thinking mode 和 non-thinking mode，前者用于解决复杂的问题，后者用于解决简单的问题
multilingual support qwen3支持119中语言和方言
Improved agentic capabilities 提升了qwen3的coding和agentic能力，并支持MCP

训练

Pre-training

Qwen3使用了36T token进行训练（与之相比，Qwen2.5使用方的token数量为18T），数据来源于互联网和PDF，作者使用Qwen2.5-VL来提取内容，然后使用Qwen2.5来提升内容质量。作者还基于Qwen2.5-Math和Qwen2.5-Coder来合成数学以及代码数据

训练包含三个stage：

上下文长度为4K tokens，训练数据为30T tokens, 目标是让模型掌握初步的语言能力和知识
上下文长度为4K tokens，训练数据为5T tokens,这部分数据主要是knowledge intensive的数据，比如STEM, coding和reasoning等
上下文长度扩展到32K tokens，训练数据主要是高质量长上下文的数据

Post-training

Post-training包含四个阶段，如下图所示

Stage 1, Long CoT code start: 作者基于math, coding, logical reasoning, STEM等domain的Long CoT数据来微调模型，让模型拥有初步的推理能力，这和Kimi-VL是类似的
Stage 2, reasoning-based RL: 作者使用rule-based rewards来提供奖励，然后使用RL来训练模型，经一部提高模型的exploration和exploitation能力
Stage 3, thinking mode fusion: 作者混合了一部分instruction-following和Long CoT数据来提升模型的non-thinking能力，这样可以让模型在两种思考模式之间切换
Stage 4,general RL：作者使用RL在20多个general-domain任务上进一步提高模型的通用能力，包括instruction following, format following以及agent capability等

Future work

作者希望在未来能够在模型架构和训练方式上进行提升，包括：scaling data, increasing model size, extending context length, broadening modalities, advancing RL with environmental feedback for long-horizon reasoning.

结论

与Gemini2.5 pro，Kimi-VL等reaosning model不同，qwen3可以在快思考和慢思考之间进行转换。感觉未来有两个趋势，一个是如何在快思考和慢思考之间进行切换，切换的逻辑是什么？第二个就是qwen3以及qwen2.5-vl都在强调的agent能力，也就是我们不仅仅是在做一个LLM，而是逐步延伸到了agent这个层面。

参考文献

blog

Notes on Qwen2.5 omni

Tue, 01 Apr 2025 10:29:00 +0800

介绍

2025年3月26号，Qwen团队发布了Qwen2.5 omni，Qwen2.5 omni是一个多模态模型，支持文本、音频、视频、图像等多个模态的输入，支持文本，音频的输出。作者提出了TMRoPE来对齐不同的模态，然后还是用了Thinker-Talker的架构来同时生成文本和音频。 Thinker是一个大语言模型，Talker是一个dual-track自回归模型，Talker基于Thinker的hideen states来生成audio token，最后通过一个sliding-window DiT来解码audio token

现有omni-model存在的问题：

缺乏一个系统的，联合训练多个不同模态的方法
需要处理不同模态输出时互相干扰的问题
不能实时理解或者流式输出多模态信息

Qwen2.5 omni的解决方法：

使用TMRoPE来对齐不同的模态。作者将audio以及video frame按照时间顺序组织成一个交替的架构，然后使用TMRoPE来对齐
使用Thinker-Talker的架构来同时生成文本和音频。Thinker负责文本输出，Talker负责音频的流式输出。
在multimodal encoder中使用Block-wise streaming处理技巧来实现实时理解；在输出时，实现了一个dual-track自回归架构来生成audio token，以及一个DiT模型来解码audio token

Qwen2.5 omni的贡献：

提出了Qwen2.5-omni,可以实时理解多模态信息，并流式输出文本和音频
提出了TMRoPE，一个可以对齐不同模态的RoPE算法
提出了Thinker-Talker的架构，来完成实时理解和音频输出
在多个benchmark上取得了SOTA

架构

总览

Qwen2.5-omni的架构如下图所示

其中Talker类似于人的嘴，负责基于脑中的信息来生成对话；Thinker类似于人的大脑，负责理解输入的信息，并生成对话的上下文。

输入

text: Qwen的tokenizer
audio： Qwen2-Audio的tokenizer
vision： Qwen2.5-VL的vision tokenizer

视频以及TMRoPE。对于视频来说，Qwen2.5-omni采取了和Qwen2.5-VL一样的MRoPE算法。只是这里的temporal ID对应40ms

音频：对于音频来说，Qwen2.5-omni也是以40ms进行采样然后encoding。

视频+音频：对于视频+音频来说，Qwen2.5-omni将视频和音频的token进行交替的排列，来保证时间上信息一致

输出

Text：text由Thinker直接输出，这和LLM的输出方式是一样的。
Speech：Qwen2.5-omni首先构建了qwen-tts-tokenizer，一个speech codec，用于表示speech的关键信息。然后基于这些关键信息，Talker通过自回归的方式生成audio tokens以及text tokens。

流式输出

对于流式输出来说，现在的模型存在latency，具体影响因素如下：

处理多模态输入的延迟
TTFT （time to first token）
将第一段speech token解码为audio的时间
模型架构导致的latency，如模型参数等

为了解决这个问题，Qwen2.5-omni采取了以下措施：

Support prefilling. 作者修改了audio以及vision encoder来在temporal dimension上支持block-wise attention. 具体来讲，audio encoder只关注2秒内的信息，而vision encoder和Qwen2.5-VL一样，使用了一个MLP patch merger来压缩视觉token
Streaming Codec generation. 为了提高流式输出的效率，作者还是用了基于Flow-Matching的DiT，输出的code收线使用Flow-Matching转化为一个mel-spectrogram. 然后再通过一个BigVGAN来重建得到对应的waveform. 作者在这里修改了DiT的attention，将其receptive field 限制为4个block，包括lookback of 2 blocks以及lookahead of 1 block.

Pre Training

模型参数初始化：

LLM：从Qwen2.5进行初始化
vision encoder：从Qwen2.5-VL的vision encoder进行初始化
audio encoder：从Whisper-large-v3进行初始化

Pretraining和Qwen2.5-VL的训练过程类似，分成了3个stage：

冻结LLM的参数，仅训练vision encoder和audio encoder，该阶段使用了audio-text以及image-text pairs来进行训练。数据：image-text, video-text, video-audio, audio-text以及text corpus，跟Qwen2-Audio类似，作者将hierarchical tags用自然语言prompt进行替换
训练所有参数，使用更多的多模态数据进行训练。数据包括800B token的image和Video相关数据，300B token的audio数据，100B token的video-audio相关数据。
将模型的上下文扩展到32K。前两个阶段的上下文长度为8192，本阶段使用了long video data等数据来将模型的上下文扩展到32K。

Post Training

Thinker

数据格式为ChatML，数据类型包括pure text-based dialogue data, visual-modality conversation data, audio-modality conversation data and mix-modality conversation data.

Talker

包括三个阶段

ICL training: 训练Talker学习context continuation
DPO training: 提升speech generation的stability
multi-speaker instruction fine-tuning: 提升模型的naturalness和controllability

Evaluation

Qwen2.5-omni在两类benchmark上进行来的评测，分别时多模态理解（X->text）以及音频生成(X-> Speech)

我们这里主要关注一下speech understanding以及speech generation的benchmark.

总结

Qwen2.5-omni相当于是结合了Qwen2.5-VL以及Mini-omni，跟mini-omni2的输入输出是类似的。不同的点在于，Qwen2.5-omni使用了Thinker-Talker的架构，然后还使用了TMRoPE来对齐不同的模态。总的来说，感觉模型还是更偏重于audio的理解与生成。

Reference

Overview of Qwen-VL series

Sun, 09 Mar 2025 15:11:29 +0800

Timeline

时间	模型系列	Feature
2023.08	Qwen-VL	Vision-centric understanding
		Multi-lingual
		Multi-image
		Fine-grained visual understanding
2024.09	Qwen2-VL	Image understanding
		Video understanding (20min)
		Agent capability
		Multilingual support
2025.02	Qwen2.5-VL	Document parsing
		Object grounding
		Long video understadning and grouding (1 hour)
		Agent functionality

Models

	name	size	Vision	Adapter	LLM
1.0	Qwen-VL	9.6B	ViT(1.9B)	Cross-attention(0.08B)	Qwen-LLM(7B)
2.0	Qwen2-VL-2B	2B	ViT(675M)	MLP(0.0341B)	Qwen2-LLM(1.5B)
	Qwen2-VL-7B	7B		MLP(0.0446B)	Qwen2-LLM(7.6B)
	Qwen2-VL-72B	72B		MLP(0.0682B)	Qwen2-LLM(72B)
2.5	Qwen2.5-VL-3B	3B	ViT(675M)	MLP(0.1817B)	Qwen2.5-LLM(3B)
	Qwen2.5-VL-7B	7B		MLP(0.3179B)	Qwen2.5-LLM(7.6B)
	Qwe2.5n-VL-72B	72B		MLP(0.7267B)	Qwen2.5-LLM(72B)

Remark

Qwen2-VL的MLP使用的是LayerNorm
Qwen2.5-VL的MLP使用的是RMSNorm
出了Qwen-VL之外，所有模型均有对应的Instruct版本，这里为了方便没有列出。Qwen-VL对应的是Qwen-VL-chat。

Data & training

Model series	stage	data	Vision	Adapter	LLM
Qwen-VL	pretraining	1.4B	✅	✅
	Multi-task pretraining	96.8M	✅	✅	✅
	SFT	350K		✅	✅
Qwen2-VL	pretraining	600b tokens	✅？	✅？
	Multi-task pretraining	800b tokens	✅？	✅？	✅？
	SFT			✅？	✅？
Qwen2.5-VL	Visual Pre-Training	1.5T token	✅？	✅？
	Multimodal Pre-Training	2T token	✅	✅	✅
	Long-Context Pre-Training	0.6T token	✅？	✅？	✅？
	SFT	2M samples		✅	✅
	DPO			✅	✅

Remark

Qwen2-VL按照技术报告的说法是follow了Qwen-VL的训练方式，因此这里也使用了同样的表示
带问号的地方代表不确定，为个人猜测。请谨慎参考。
难以确定的原因是Qwen-VL系列将projection layer和ViT作为一个模块，因此比较难区分是否训练了projection layer

技术报告的训练框架图

References

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 Qwen2.5 VL

Tue, 04 Mar 2025 10:46:42 +0800

Introduction

2025年2月20号Qwen团队发布了Qwen2.5 VL技术报告，Qwen2.5 VL包括3B，7B， 72B三个size。Qwen2.5-VL主要在架构，数据上进行了改进。通过评测，Qwen2.5-VL在多个benchmark上取得了SOTA。

Qwen2.5 VL认为已有模型的缺点为：

计算复杂度高
上下文理解能力有限
细粒度visual perception能力不足
在不同上下文长度下表现不一致

Qwen2.5 VL的贡献为：

使用了一个从零开始训练的ViT作为vision encoder，并且在ViT中使用了window attention，来提高计算效率
使用了dynamic FPS sampling，用于处理不同采样率的视频输入
将MRoPE扩展到了temporal domain上，进一步提高了模型在与时间相关任务上的表现
使用了更高质量的数据集，其中预训练阶段使用了4.1T的token

Qwen2.5 VL的主要亮点为：

优秀的document parsing能力
精确的object grounding能力
针对长视频的理解和细粒度grounding能力
针对UI的agent functionality

模型架构

总览

Qwen2.5 VL和Qwen2 VL的架构基本一致，包括Vision Encoder，Language Encoder，以及projector layer三个部分，其架构图如下：

LLM：使用Qwen2.5 LLM作为LLM，并且将1D-RoPE升级为了MRoPE
Vision Encoder：使用一个从零开始训练的ViT架构，patch_size为14，position embedding为2D-RoPE， attention为window attention和self-attention的混合，其中，只有四层使用的是self-attention.对于输入的图片，ViT会将图片resize到28的整数倍。
Projector Layer：使用的是一个两层的MLP

模型的参数配置如下图

Vision Encoder

Vision encoder的主要改进点为：

使用了window attention来提升计算效率，window attention的size为 $112\times 112$，对应为 $8\times 8$ 个patch. 这样做的好处是可以不用对图片做scaling
使用了2D RoPE来捕捉空间信息，使用3D RoPE来捕捉视频输入的时间信息
与LLM的结构进行对齐，包括使用RMSNorm替换LayerNorm，使用SwiGLU替换ReLU

输入处理

对于图片输入，Qwen2.5 VL使用原始图片的空间信息来构建坐标，而不是将坐标normalize到[0, 1000]之间，这样让模型可以处理不同精度的图片输入。

对于视频输入，因为使用了3D RoPE，因此Qwen2.5 VL可以处理不同帧率的视频输入，这样就避免了不同帧率视频对模型视频理解带来的影响。这一点和Apollo里的想法是一样的。具体来说，Qwen2.5 VL首先将连续的两帧group到了一起，然后使用了temporal ID来将position和视频所对应的时间进行对齐。这里可以看Qwen2.5 VL的代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


Temporal (Time): 3 patches, representing different segments of the video in time.
Height: 2 patches, dividing each frame vertically.
Width: 2 patches, dividing each frame horizontally.
We also have some important parameters:
fps (Frames Per Second): The video's frame rate, set to 1. This means one frame is processed each second.
tokens_per_second: This is a crucial parameter. It dictates how many "time-steps" or "temporal tokens" are conceptually packed into a one-second interval of the video. In this case, we have 25 tokens per second. So each second of the video will be represented with 25 separate time points. It essentially defines the temporal granularity.
temporal_patch_size: The number of frames that compose one temporal patch. Here, it's 2 frames.
interval: The step size for the temporal position IDs, calculated as tokens_per_second * temporal_patch_size / fps. In this case, 25 * 2 / 1 = 50. This means that each temporal patch will be have a difference of 50 in the temporal position IDs.
input_ids: [V V V V V V V V V V V V T T T T T], here V is for vision.
vision temporal position_ids: [0, 0, 0, 0, 50, 50, 50, 50, 100, 100, 100, 100]
vision height position_ids: [0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1]
vision width position_ids: [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
text temporal position_ids: [101, 102, 103, 104, 105]
text height position_ids: [101, 102, 103, 104, 105]
text width position_ids: [101, 102, 103, 104, 105]
Here we calculate the text start position_ids as the max vision position_ids plus 1.

这里fps为1，表示每一帧对应一秒，tokens_per_second为25，表示每秒包含25个token，temporal_patch_size为2，表示每个temporal patch包含2个frame。因此一个patch里面，就包含了2frame, 对应50tokens. 然后前面提到连续两帧会被group到一起，因此每个temporal patch对应4个spatial patches. 其position_ids为：

1

[(t, 0, 0), (t, 0, 1), (t, 1, 0), (t, 1, 1)]

训练

预训练

数据

预训练阶段使用了4.1T的token，包括image captions, interleaved image-text data, optical character recognition (OCR) data, visual knowledge (e.g., celebrity, landmark, flora, and fauna identification), multi-modal academic questions, localization data, document parsing data, video descriptions, video localization, and agent-based interaction data. 作者详细介绍了以下几种数据：

Interleaved image-text data：主要1. 提高模型的上下文学习能力；2. 保持模型的text-only能力；3.包含一些通用信息。数据清洗包括：1. 基于text-only quality过滤； 2. 基于image-text相关性过滤；3. 基于image-text互补程度过滤；4.基于information density balance过滤.
Grounding data：作者使用了Grounding DINO, SAM等模型来生成一些grounding data.为了提升模型在open-vocabulary detection上的能力，作者将训练数据集扩展到了1万个object category上，作者还使用了一些point-based object grounding data来提升模型的能力
Document Parsing data：作者基于text,image, music sheets和chemical formulas合成了一些HTML格式的数据，然后根据tag和bounding box来提升模型document parsing的能力
OCR data：作者使用了开源，合成和in-house的数据集，数据集主要提到multi-lingual以及1M的chart-type数据
Video data：作者通过pipeline构建了long video caption来提升模型长视频的理解能力
Agent data：作者收集了一些mobile device和网页的screenshots,然后基于agent框架来合成控制轨迹

训练

如上图所示，Qwen2.5 VL的预训练阶段包括了三个阶段：

Visual Pretraining:这一阶段使用了image-caption, knowledge, OCR数据集，旨在提升ViT提取视觉特征的能力
multimodal pretraining:这一阶段在第一阶段的基础上增加了pure-text, interleaved data, VQA, Video grounding, agent data, 旨在提升模型处理复杂视觉信息的能力
long-context pretraining: 这一阶段，在第二阶段的基础上，增加了long video, long agent, long document data，旨在提升模型处理长上下文的能力

后训练

数据

SFT阶段使用大概2M的样本进行训练，其中纯文本和多模态数据占比为1:1，语言主要是中文和英文。

为了保证数据质量，作者提供了一个数据清洗的pipeline，包括：

domain-specific categorization: 作者基于Qwen2-VL-72B构建了Qwen2-VL-Instag，用于将QA pair分为8个大类别，30个小类别
Domain-tailed filtering:作者使用了rule-based和model-based方法来提升数据的质量
- rule-based filtering: 重复性检测，格式检测等
- model-based filtering: 使用基于Qwen2.5-VL训练的reward model来从多个维度评估QA pair的质量

为了进一步提升模型的推理能力，作者还是用了rejection sampling来refine 数据集。

训练

post-training阶段分为SFT和DPO两个小阶段，这个阶段都会冻结VIT. SFT阶段使用大多数的训练数据，而DPO阶段专注于image-text data和pure text data，以更好地进行对齐。具体做法就是基于Grounding truth，使用checkpoint来评估数据的质量，然后只保留答案正确的数据来训练。

评测

通用VQA
文档理解和OCR
空间理解
视频理解和Grounding
Agent

Reference

Github
Paper

Qwen on Jiang Yi(姜祎)'s Homepage

Notes on Qwen3-Next

Introduction

Method

Architecture

Hybrid Attention

MoE

Normalization and Training

Experiments

Efficiency

Performance

Conclusion

References

Notes on Gated Attention

Introduction

Related Work

Method

Experiments

Analysis

Conclusion

References

Appendix

Notes on Global-batch load balancing

Introduction

Method

Experiments

Analysis

Conclusion

References

Notes on Qwen3 VL

Introduction

Architecture

Interleaved MRoPE

DeepStack

Video Timestamp

Pre-training

Training Recipe

Data

Post-training

Code-start Data

Strong-to-Weak Distillation

RL

Reasoning RL

General RL

Thinking with Images

Experiments

Performance

Ablation Study

Conclusion

References

Notes on SAPO

Introduction

Method

Comparison

Experiments

Conclusion

References

Notes on GSPO

Introduction

Method

Preliminary

Motivation

GSPO

GSPO-token

Evaluation

Conclusion

References

Notes on Qwen2.5-1M

Method

Pretraining

Post-training

Inference

Length Extrapolation

Sparse Attention

Inference Engine

Evaluation

Conclusion

References

Notes on Qwen2.5

Method