Qwen3-Next：混合线性注意力与超稀疏 MoE

总参数约 80B，每个 token 只激活约 3B；训练花的 GPU 时不到 Qwen3-32B 的十分之一，32K 以上的推理吞吐却是它的 10 倍多。这是 Qwen 团队 2025 年 9 月发布的 Qwen3-Next-80B-A3B。它在架构上一口气改了好几处：混合注意力（Gated DeltaNet 加 Gated Attention，比例 3:1）、512 个 expert 的高稀疏 MoE、零中心且带权重衰减的 LayerNorm、归一化的 router 初始化、多 token 预测（MTP）。每一项背后都有一两篇论文，单看名字很难知道它们解决什么问题。

这套架构后来没有停在 Qwen3-Next：Qwen3-Coder-Next、Qwen3.5、Qwen3.6、Qwen3.8 都沿用了它（对照表）。

1. 全局：一个 80B-A3B 的模型长什么样

先看骨架。Qwen3-Next-80B-A3B 有 48 层，隐藏维度 \(d=2048\)。每一层都是 Pre-Norm 残差结构：「token 混合器」（负责在序列维度上交换信息）加「通道混合器」（逐 token 的 FFN）。和 Qwen3 相比，有三处不同：

• token 混合器有两种。每 4 层里，前 3 层用 Gated DeltaNet（一种线性注意力），第 4 层用 Gated Attention（带输出门的标准 softmax 注意力）。整体就是 12 × (3 × (Gated DeltaNet → MoE) → 1 × (Gated Attention → MoE))：第 \(i\) 层（从 0 数）当 \((i+1)\bmod 4 = 0\) 时是全注意力，也就是第 3、7、11、…、47 层。
• 每一层的 FFN 都是 MoE。512 个 routed expert，每个 token 选 10 个，再加 1 个所有 token 都走的 shared expert；每个 expert 是中间维度 512 的 SwiGLU。
• 主干之外还有一个 MTP 模块，训练时预测更远的 token，推理时当投机解码的草稿模型。

按各模块的形状逐项累加，参数分布如下（合计约 80B，其中非嵌入参数约 79B）：

可以看到 97% 的参数在 expert 里，而 token 混合器总共才 1.5B。权重文件里还有一个 mtp.* 模块（约 1.65B），所以 safetensors 的总大小是 162.6 GB（bf16，约 81.3B 个数）。

2. 从 softmax 注意力到线性注意力

2.1 softmax 注意力的成本在哪里

先固定记号。一个注意力头里，第 \(t\) 个 token 有查询 \(q_t\in\mathbb R^{d_k}\)、键 \(k_t\in\mathbb R^{d_k}\)、值 \(v_t\in\mathbb R^{d_v}\)。因果 softmax 注意力的输出是

写成矩阵：\(O=\mathrm{softmax}\big((QK^\top/\sqrt{d_k})\odot M\big)V\)，\(M\) 是因果掩码。两个成本：

• 训练与 prefill（一次性处理整段输入）：要算 \(N\times N\) 的分数矩阵，FLOPs 是 \(O(N^2 d)\)。FlashAttention 不存这个矩阵，但计算量还是平方的。
• decode（逐个生成新 token）：生成第 \(t\) 个 token 时要和之前所有 \(t-1\) 个键值做点积，所以每步 \(O(t\,d)\)，并且要把所有 \(k_j, v_j\) 存成 KV cache，显存随长度线性增长。在 256K 上下文下，KV cache 往往比模型权重还大。

根源在于 softmax：\(\exp(q^\top k)\) 不能拆成「只依赖 \(q\)」乘「只依赖 \(k\)」的形式，所以每个查询都得重新扫一遍所有键。

2.2 核化：把 exp 换成特征内积

线性注意力的想法是把相似度 \(\exp(q^\top k)\) 换成某个特征映射的内积 \(\phi(q)^\top\phi(k)\)：

第二个等号只用了矩阵乘法的结合律：\(\big(\phi(q)^\top\phi(k)\big)v = \big(v\,\phi(k)^\top\big)\phi(q)\)。括号里的求和与 \(q_t\) 无关，可以提前累加。

现代线性注意力（包括 Qwen3-Next 用的 Gated DeltaNet）做了两处简化：\(\phi\) 取恒等（或在 \(q,k\) 上做 L2 归一化之类的简单变换），并且去掉分母的归一化项（实践中归一化项数值上不稳定，输出端改用 RMSNorm 来控制尺度）。下面都用这个简化版：

2.3 递推形式：线性注意力是一个 RNN

令 \(S_t=\sum_{j\le t}v_jk_j^\top\in\mathbb R^{d_v\times d_k}\)，就得到

这就是一个以矩阵 \(S_t\) 为隐状态的 RNN。decode 时每步只做一次外积更新和一次矩阵-向量乘，代价 \(O(d_kd_v)\)，和已经生成了多少 token 无关；显存也只需要存 \(S_t\)，不需要 KV cache。

\(S\) 可以理解为一个联想记忆（associative memory）：写入时把「键 → 值」的映射以外积形式叠加进去，读出时用查询去「检索」：\(S q=\sum_j v_j(k_j^\top q)\)，即所有存过的值按键与查询的相似度加权求和。这和 90 年代的 fast weight programmer 是同一个东西：\(S\) 是一组「快权重」，由慢权重（投影矩阵）在每一步编程。

2.4 并行形式与分块形式

训练时不想一个个 token 地递推（GPU 上串行很慢）。展开递推得到并行形式：

和 softmax 注意力只差一个 softmax，但这样又回到了 \(O(N^2)\)。实际用的是两者的折中——分块形式（chunkwise）：把序列切成长度为 \(C\) 的块，块与块之间用递推传状态，块内部用并行形式。设第 \([i]\) 块开始时的状态为 \(S_{[i]}\)，块内的 \(Q_{[i]},K_{[i]},V_{[i]}\in\mathbb R^{C\times d}\)，则

每块的成本是 \(O(C^2d+Cd^2)\)，总成本 \(O(NCd+Nd^2)\)，对 \(N\) 线性；而且全部是稠密矩阵乘，能吃满 Tensor Core。串行步数从 \(N\) 降到 \(N/C\)。Qwen3-Next 用的块长是 \(C=64\)。

2.5 问题：加性记忆会「撑爆」

线性注意力在语言建模困惑度上能接近 Transformer，但在需要精确回忆的任务（在上下文里找某个 key 对应的 value、多跳检索、长文问答）上明显落后。原因可以从联想记忆的角度直接看出来。假设所有键都是单位向量，读出第 \(i\) 个键：

第二项是串扰。如果存的键两两正交，串扰为 0，检索精确；但 \(\mathbb R^{d_k}\) 里最多只有 \(d_k\) 个两两正交的向量。一旦存的东西多于 \(d_k\) 个（长上下文里必然如此），串扰不可避免，而且只会越积越多——加性更新只能往里加，不能删、不能改。同一个键先后写入两个不同的值，读出来的是两者之和，而不是最新的那个。

解决办法有两条，正好对应 Gated DeltaNet 的两个组成部分：

1. 遗忘：给旧状态乘一个衰减系数 \(\alpha_t\in(0,1)\)，让旧记忆逐渐淡出（RetNet、GLA、Mamba2 走的是这条路）。
2. 修改：写入之前先看看记忆里对这个键已经存了什么，只写入「差值」（DeltaNet 的 Delta 规则）。

3. Delta 规则：把记忆当成在线回归

3.1 推导

把 \(S\) 看成一个线性回归器，它的任务是「给定 \(k\)，预测 \(v\)」。在第 \(t\) 步，我们拿到一个新样本 \((k_t,v_t)\)，用一步在线梯度下降更新 \(S\)。损失取平方误差：

步长为 \(\beta_t\) 的一步梯度下降：

这就是 Delta 规则（Widrow–Hoff 规则）。括号里是「目标值减去当前预测」：如果记忆已经能正确地把 \(k_t\) 映射到 \(v_t\)，就什么都不写；如果存的是错的值，就只写入修正量。整理一下：

对比一下，普通线性注意力 \(S_t=S_{t-1}+v_tk_t^\top\) 也能看成梯度下降，只不过损失是 \(-\langle Sk_t,v_t\rangle\)（线性损失，永远不会饱和）。换成平方损失，就多出了「先擦再写」这一项 \(-\beta_t S_{t-1}k_tk_t^\top\)。

几个性质：

• 如果 \(\lVert k_t\rVert=1\)、\(\beta_t=1\)，那么 \(I-k_tk_t^\top\) 是向 \(k_t\) 正交补的投影。更新后 \(S_tk_t=v_t\) 精确成立：键 \(k_t\) 方向上的旧内容被整个替换成新值，其它与 \(k_t\) 正交的方向不受影响。这就是「改写」。
• \(\beta_t\in(0,1)\) 时是部分改写：\(S_tk_t=(1-\beta_t)S_{t-1}k_t+\beta_tv_t\)，在旧值和新值之间插值。\(\beta_t\) 由网络根据当前 token 决定（Qwen3-Next 里是 \(\sigma(W_bx_t)\)），相当于一个数据依赖的学习率。
• 转移矩阵 \(I-\beta_tk_tk_t^\top\) 是广义 Householder 矩阵。当 \(\lVert k_t\rVert=1\)、\(0\le\beta_t\le 2\) 时，它的特征值是 \(1-\beta_t\)（在 \(k_t\) 方向）和 1（其它方向），谱范数不超过 1，递推不会爆炸。这也是为什么 Gated DeltaNet 要对 \(k\) 做 L2 归一化。

演示 1 用 \(d_k=d_v=4\) 的玩具状态逐个 token 写入键值对：左边用加性更新（线性注意力），右边用（门控）Delta 规则，并实时显示每个已写入键的检索误差 \(\lVert S k_i - v_i^{\text{最新}}\rVert\)。键和值由固定随机种子生成（示意）。

值得自己试的几件事：

• 正交键：两边误差都是 0。\(d\) 个正交键以内，加性记忆没有问题。
• 改写同一个键：第 4 个 token 用第 1 个 token 的键写入新值。加性更新读出的是两个值之和，误差很大；Delta 规则在 \(\beta=1\) 时精确地把旧值替换掉。
• 8 个随机键：超过容量后两边都有误差，但 Delta 规则保证「最近写入的那个」总是精确的（\(\beta=1\) 时），误差集中在较早的键上；加性更新的误差摊在所有键上，而且整体更大。
• 把 α 调小：旧记忆按指数衰减，早期键的误差趋向 \(\lVert v_i\rVert\)（被忘掉了），但给新内容腾出了空间。这就是门控的作用。

4. Gated DeltaNet：遗忘门 + Delta 规则

4.1 门控线性注意力

给加性更新加一个数据依赖的标量衰减 \(\alpha_t\in(0,1)\)：

这就是 Mamba2（在每个头上用标量衰减）所对应的线性注意力形式；GLA 用的是逐维（向量）衰减。展开后，第 \(j\) 个 token 对第 \(t\) 步的贡献被乘上 \(\prod_{s=j+1}^{t}\alpha_s\)，即它「经过的所有门」的乘积。\(\alpha_t\) 接近 0 时整块清空记忆（比如遇到文档边界），接近 1 时保留。

门控擅长快速、整体地遗忘，但它对所有内容一视同仁：想忘掉某一个键值对，就必须连带衰减所有别的。Delta 规则正相反，擅长精确地修改某个键，但不能快速清空。两者正好互补，Gated DeltaNet 就是把它们合在一起。

4.2 门控 Delta 规则

把两者合起来：

从在线学习的角度看，这等价于：先对旧状态做一步权重衰减（\(S\leftarrow\alpha_tS\)），再对平方损失做一步梯度下降。写成逐 token 的代码：

# 每个头，S 的形状是 [d_k, d_v]（代码里是转置的约定：读出用 qᵀS）
S = S * exp(g_t)                     # α_t = exp(g_t)，g_t ≤ 0
pred = S.T @ k_t                     # 旧记忆对 k_t 的预测
S = S + outer(k_t, beta_t * (v_t - pred))   # 只写入差值
o_t = S.T @ q_t

注意顺序：先衰减，再用衰减后的状态算预测。这和上面的公式一致：\(\alpha_tS_{t-1}(I-\beta_tk_tk_t^\top)=\alpha_tS_{t-1}-\beta_t(\alpha_tS_{t-1}k_t)k_t^\top\)。

4.3 门怎么参数化

Qwen3-Next 的 \(\alpha_t\) 沿用 Mamba2 的「离散化」写法。每个值头 \(h\) 有一个可学习的 \(A_h>0\)（以 \(\log A_h\) 存储）和偏置 \(\Delta_h\)，输入投影给出一个标量 \(a_t\)：

softplus 保证步长 \(\mathrm{softplus}(\cdot)>0\)，\(A_h>0\) 保证 \(g_t\lt 0\)。在 Mamba 的连续时间视角下，\(\mathrm{softplus}(a_t+\Delta_h)\) 是时间步长 \(\Delta t\)，\(e^{-A\Delta t}\) 是零阶保持离散化下的衰减。初始化时 \(A\) 取 \([0.01,16]\) 上的均匀分布，\(\Delta\) 取 1，于是不同的头一开始就有快慢不同的遗忘速度。写入强度 \(\beta_t=\sigma(b_t)\)，也是每个值头一个标量。在 log 空间里计算 \(g_t\) 有个好处：分块算法需要的累积衰减 \(\prod\alpha\) 变成 \(g\) 的前缀和，不会下溢。

5. 分块并行算法：训练时怎么算得快

门控 Delta 规则的转移矩阵 \(\alpha_t(I-\beta_tk_tk_t^\top)\) 依赖于状态本身的投影，不再是简单的加法，所以 2.4 节那种「块内并行、块间加」的写法不能直接用。解决办法是用 WY 表示和 UT 变换，把一串 Householder 乘积压缩成低秩形式。

5.1 块内展开

考虑一个长度为 \(C\) 的块，块开始时的状态为 \(S_0\)，块内位置记为 \(r=1,\dots,C\)。定义块内累积衰减

先看没有门控（\(\alpha\equiv1\)）的情况。可以用归纳法证明，块内第 \(r\) 步的状态总能写成

其中 \(w_j\in\mathbb R^{d_k},u_j\in\mathbb R^{d_v}\) 满足

（归纳步：把 \(S_{r-1}\) 的表达式代入 \(S_r=S_{r-1}+\beta_r(v_r-S_{r-1}k_r)k_r^\top\)，\(S_{r-1}k_r=S_0k_r+\sum_{j\lt r}(u_j-S_0w_j)(k_j^\top k_r)\)，整理即得。）

这两个递推是串行的：\(w_r\) 依赖于所有更早的 \(w_j\)。但把它们移项就会发现，它们其实是「下三角线性方程组」。记 \(A\) 为严格下三角矩阵，\(A_{rj}=\beta_r\,k_r^\top k_j\)（\(j\lt r\)），则

\(T=(I+A)^{-1}\) 只是一个 \(C\times C\) 的单位下三角矩阵求逆（前代法，或者 solve_triangular），这一步叫 UT 变换。一个块里所有的 Householder 乘积，被压缩成了 \(W,U\) 两个 \(C\times d\) 的矩阵。

5.2 加上门控

有衰减时，第 \(j\) 个 token 写入的内容到第 \(r\) 步时已经被乘上了 \(\Gamma_{rj}\)，所以把每个贡献按「它之后经过的衰减」缩放即可。归纳过程完全相同，结果是：

再定义「真正要写入的新值」\(\Delta=U-WS_0^\top\in\mathbb R^{C\times d_v}\)（第 \(r\) 行是 \(u_r-S_0w_r\)：目标值减去旧状态对它的预测，正是 Delta 规则里的那个差）。于是块的输出和下一块的初始状态都是普通矩阵乘：

这里 \(M\) 是含对角线的下三角掩码。第一项是「从历史状态读」（带上从块首到当前位置的衰减），第二项是块内的小注意力。整体流程：

for 每个块 i（串行，共 N/C 次）:
    # 以下全是 C×C 或 C×d 的稠密矩阵运算
    A   = tril(β·(K Kᵀ)·Γ, -1)                # 块内键之间的相互作用
    T   = (I + A)⁻¹                           # UT 变换（三角求解）
    U   = T · diag(β) V ;  W = T · diag(βγ) K   # 可以对所有块并行预先算好
    Δ   = U − W S₀ᵀ                            # 减去旧状态的预测
    O_i = diag(γ) Q S₀ᵀ + (Q Kᵀ ⊙ Γ ⊙ M) Δ
    S₀  = γ_C S₀ + Δᵀ diag(γ_C/γ) K

成本分析：每块有若干 \(C\times C\times d\) 和 \(C\times d\times d\) 的矩阵乘，加一个 \(C\times C\) 三角求解，总 FLOPs 约 \(O(N(Cd+d^2))\)；串行深度是 \(N/C\)。和 softmax 注意力的 \(O(N^2d)\) 相比，长序列时省下的是整整一个 \(N/C\) 的因子。实际训练和推理用的是 flash-linear-attention 库里的 Triton kernel chunk_gated_delta_rule，它在这个流程的基础上还做了块内的进一步分解和 kernel 融合。

decode 阶段不需要分块：每生成一个 token 就按 4.2 节的递推式走一步，代价是常数。

6. Qwen3-Next 里的 Gated DeltaNet 层

核心递推之外，一个完整的 Gated DeltaNet 层前后还包了一圈东西。按数据流依次是（\(x_t\in\mathbb R^{2048}\) 是 RMSNorm 之后的输入）：

1. 输入投影。in_proj_qkvz：\(2048\to12288\)，切成 \(q\)（16 头 × 128）、\(k\)（16 头 × 128）、\(v\)（32 头 × 128）、\(z\)（32 头 × 128）。in_proj_ba：\(2048\to64\)，切成 32 个 \(b\) 和 32 个 \(a\)（每个值头各一个）。
2. 短卷积。把 \(q,k,v\) 拼成 8192 个通道，做核长 4 的因果 depthwise 1D 卷积，再接 SiLU。它让每个 token 的 \(q,k,v\) 看到前 3 个 token 的局部信息，这对「归纳头」类型的模式（看到 A B … A 时预测 B）很有帮助——线性注意力本身没有位置编码，局部的位置感主要靠它。decode 时只要缓存最近 3 个 token 的这 8192 维输入。
3. 归一化。对每个头的 \(q,k\) 做 L2 归一化（保证 \(\lVert k\rVert=1\)，Delta 规则的转移矩阵稳定），\(q\) 再乘 \(1/\sqrt{128}\)。
4. QK 头少于 V 头：16 个 QK 头、32 个 V 头，每个 \(q,k\) 头被 repeat_interleave 复制给 2 个值头使用。这和 GQA 方向相反（GQA 是多个 Q 头共享一组 KV），这里是两个值头共享一组 \((q,k)\)，但各自有独立的 \(v\)、\(\alpha\)、\(\beta\) 和状态。所以状态一共 32 份，每份 \(128\times128\)。
5. 核心递推：门控 Delta 规则，训练 / prefill 用分块算法，decode 用逐 token 递推。
6. 输出门。对每个头的输出（128 维）做 RMSNorm，乘上 \(\mathrm{SiLU}(z)\)，32 个头拼成 4096 维，再经 out_proj 回到 2048。这个「norm 后乘门」的结构和 Mamba2、Gated DeltaNet 的块设计一样。

每层参数量：\(2048\times12288+2048\times64+8192\times4+4096\times2048+\dots\approx33.7\text{M}\)。

decode 状态有多大？每层 32 头 × \(128\times128\) = 524,288 个数。若以 fp32 存（后来的 Qwen3.5 在配置里明确指定了 fp32 状态），36 层共 72 MiB；卷积缓存 36 × 8192 × 3 个 bf16 约 1.7 MiB。这些和上下文长度无关。作为对比，12 个全注意力层的 KV cache 是每 token 24 KiB（下一节细算），所以大约在 3K token 时两者相当，再往后 KV cache 就占大头了。

7. Gated Attention：SDPA 之后加一个门

7.1 Qwen3-Next 的注意力层长什么样

那 12 个全注意力层是在 Qwen3 的 GQA 注意力上改的：

• 16 个查询头，2 个 KV 头（GQA，每 8 个查询头共享一组 KV）；
• 每头维度从 128 提到 256；
• 保留 Qwen3 的 QK-Norm（对每个头的 \(q,k\) 做 RMSNorm 后再算点积）；
• 部分 RoPE：partial_rotary_factor = 0.25，只对 256 维里的前 64 维施加旋转位置编码，剩下 192 维不带位置信息；rope_theta = 10,000,000。目的是改善向更长序列的外推；
• 输出门：SDPA 的输出逐元素乘一个 sigmoid 门。

7.2 门的位置和形式

在注意力里加门的方式有很多。Qwen 团队系统比较了 30 多种在注意力里加门的方式（门放在 \(Q\)、\(K\)、\(V\) 投影之后，放在 SDPA 输出之后，放在输出投影之后；逐元素还是逐头；各头独立还是共享；乘性还是加性），用 15B MoE 和 1.7B 稠密模型在 3.5T token 上训练。结论是：在 SDPA（scaled dot-product attention）输出之后、输出投影之前，加一个逐元素、各头独立、依赖当前查询 token 的 sigmoid 门效果最好：

具体实现上，q_proj 的输出维度是 \(16\times256\times2=8192\)：每个头输出 512 维，前 256 维是查询，后 256 维是门的 logit。注意力输出（16 × 256 = 4096 维）逐元素乘 \(\sigma(\text{gate})\)，再进 o_proj。多出来的参数是 \(2048\times4096\approx8.4\)M 每层。

7.3 为什么有用（一）：给低秩映射加非线性

看单个头。如果没有门，值投影 \(W_V\in\mathbb R^{d\times d_h}\) 和输出投影里对应这个头的那块 \(W_O^{(h)}\in\mathbb R^{d_h\times d}\) 之间只隔着一个「对 token 加权平均」：

\(W_VW_O^{(h)}\) 是一个秩不超过 \(d_h\) 的 \(d\times d\) 矩阵，而且在 \(j\) 维的加权平均是线性的，所以两个投影可以合并成一个低秩线性映射。在 SDPA 之后（或在 \(V\) 之后）插入一个非线性门，就打断了这个合并，提升了这段低秩映射的表达能力。实验中这一改动让困惑度最多降约 0.2，MMLU 提升约 2 个点。

7.4 为什么有用（二）：attention sink 与 massive activation

Attention sink：训练好的 LLM 里，很多头会把大量注意力分给序列第一个 token，即使它没有语义。一种解释是 softmax 的权重必须加起来等于 1：当一个头在当前位置「什么都不想看」时，它也得把概率放在某处，于是学会了一个无害的垃圾桶——第一个 token。

Massive activation：残差流里少数几个维度会出现比典型值大几个数量级的激活，常出现在第一个 token 或分隔符上，和 attention sink 相伴出现。这些巨大的值在 bf16 训练里容易带来数值问题。

输出门给了模型另一种「什么都不输出」的方式：直接把门关成接近 0。实测 SDPA 输出门的分数大多远小于 0.5，平均约 0.116，也就是门是稀疏的。在 1.7B 稠密模型上的对比：

还有一个有意思的对照：只在 \(V\) 投影后加门，massive activation 也会降下来，但 attention sink 仍然存在。可见 massive activation 不是 attention sink 的必要条件，消除 sink 的关键是依赖查询、各头独立的稀疏门。对 Qwen3-Next 来说，这首先是一个训练稳定性的设计：消除 attention sink 和 massive activation，整个模型的数值就更稳定。

Gated DeltaNet 层里的 \(\mathrm{SiLU}(z)\) 输出门是同一个思路在线性注意力上的版本，所以 Qwen3-Next 的 48 个 token 混合器全部带有输出门。

8. 3:1 混合布局与长上下文成本

8.1 为什么不全用线性注意力

道理很直接：只用线性注意力，速度快但「回忆」能力弱；只用标准注意力，推理贵且慢。线性注意力的状态是固定大小的（这里每层 32 × 128 × 128），无论 Delta 规则写得多聪明，它都是对过去的有损压缩；而 softmax 注意力的 KV cache 原样保留了每个 token，精确检索没有容量上限。混合的思路是：大部分层用线性注意力处理局部和「可压缩」的信息，少数全注意力层负责精确的长程检索。

Qwen 团队的系统实验有两点结论：

• 在线性注意力的候选里，Gated DeltaNet 的 in-context learning 能力强于常用的滑动窗口注意力和 Mamba2；
• 把 Gated DeltaNet 和标准注意力按 3:1 混合（75% 的层用 Gated DeltaNet，25% 用标准注意力），效果稳定地优于任何单一架构，同时效率更高。

至于为什么是 3:1 而不是 7:1，比例的消融数据没有公开。

8.2 算账：KV cache 与 FLOPs

decode 时的缓存和计算如下，记 \(L\) 为上下文长度。

KV cache。每个全注意力层每 token 存 \(2\times n_{kv}\times d_h=2\times2\times256=1024\) 个数，12 层共 12,288 个，bf16 下 24 KiB/token。256K（262,144）token 时是 6 GiB。如果 48 层全是同样的注意力层，就是 96 KiB/token、256K 时 24 GiB。作为参照，Qwen3-32B（64 层、8 个 KV 头、头维 128）是 256 KiB/token，256K 时 64 GiB。

每 token decode FLOPs。一个注意力层读 \(L\) 个 KV 的核心计算是 \(QK^\top\) 和 \(AV\) 各 \(2n_hd_hL\)，共 \(4n_hd_hL=16384L\)。一个 Gated DeltaNet 层的核心递推每头约 \(7d_kd_v\)（衰减、预测、外积写入、读出），32 头共约 3.7 MFLOPs，与 \(L\) 无关。其余（所有线性投影、MoE、输出头）按 \(2\times\) 激活参数计。

演示 2 的计算器用的就是这些式子。「全注意力版」是一个假想的对照：48 层都用 Qwen3-Next 的 Gated Attention 层，其它不变。

拖一拖就能看出几件事：

• 短上下文时差别不大。4K token 时，混合版和全注意力版的 decode FLOPs 都被 MoE 和投影主导，注意力核心只占一小部分。这时候 Qwen3-Next 的优势主要来自 MoE 的稀疏（与 Qwen3-32B 相比）。
• 长上下文时缓存成了主角。256K 时混合版每序列 6 GiB KV + 72 MiB 状态，全注意力版 24 GiB。decode 是访存受限的：每生成一个 token，都要把这条序列的整份 KV cache 从显存读一遍。缓存小 4 倍，同样显存能并发的序列数就多约 4 倍，每步读的字节也少 4 倍。
• 即便是混合版，到三四万 token 时，12 层注意力核心的 decode FLOPs 就和模型其余部分（MoE、投影、输出头）相当了；256K 时占到近九成。这也是为什么后来的 Qwen3.8-Flash-Next 进一步把这 12 层换成了稀疏注意力（见第 14 节）。

9. 高稀疏 MoE：512 选 10 + 1

9.1 MoE 层回顾

Mixture-of-Experts 把一个大 FFN 换成 \(E\) 个小 FFN（expert），每个 token 只用其中 \(k\) 个，由一个 router 打分决定用哪几个。Qwen3-Next 的 MoE 层（和 Qwen2-MoE 的结构相同）是：

• router \(W_r\in\mathbb R^{512\times2048}\)，softmax 之后取 top-10，再在这 10 个上重新归一化（norm_topk_prob = true）。
• 每个 expert \(E_i\) 是 SwiGLU：\(E_i(x)=W_2^{(i)}\big(\mathrm{SiLU}(W_1^{(i)}x)\odot W_3^{(i)}x\big)\)，中间维度 512，参数 \(3\times2048\times512\approx3.15\)M。
• shared expert 结构相同（中间维度 512），所有 token 都过，但输出乘一个由 token 决定的标量门 \(\sigma(w_s^\top x)\)。

每层 MoE 总参数 \(512\times3.15\text{M}+3.15\text{M}+1.05\text{M}\approx1.615\)B，每 token 激活 \(11\times3.15\text{M}+1.05\text{M}\approx35.7\)M，expert 部分的激活比约 \(11/513\approx2.1\%\)。

9.2 和 Qwen3 的 MoE 比

激活的 FFN 宽度几乎没变，expert 总数翻了 4 倍、单个 expert 变窄。这样做的依据是 Qwen 团队的一个实验观察：在使用全局负载均衡的前提下，固定激活 expert 不变、增加 expert 总参数，训练 loss 会稳定下降。直观理解：激活参数决定每 token 的计算量，总参数决定模型能存多少知识；在激活量固定时，把 expert 切细、切多，还会让可选的 expert 组合数暴涨（\(\binom{128}{8}\approx10^{12}\)，\(\binom{512}{10}\approx3\times10^{20}\)），路由能做更细的专门化。代价是总参数（显存、expert 并行的通信）上涨。Qwen 团队把它概括为「只激活 3.7% 的参数」，这是 3B / 80B 的粗略比值；按非嵌入参数算是 3.25B / 79.05B ≈ 4.1%。

9.3 负载均衡：全局 batch 上的辅助损失

MoE 训练要防止路由塌缩到少数 expert。标准的负载均衡损失（LBL）是

\(f_i\) 是被路由到 expert \(i\) 的 token 比例，\(P_i\) 是 expert \(i\) 的平均路由概率。均匀分布时该损失取最小值。这里有一个容易忽略的实现细节：常见框架在每个 micro-batch 里单独算 \(f_i\)，而一个 micro-batch 里往往只有几条序列，于是约束实际上变成了「每条序列内部都要均匀用所有 expert」，连一段纯代码都要均匀分给所有 expert，抑制了 expert 的专门化。改进的做法是跨 micro-batch / 数据并行组同步 \(f_i\)，在全局 batch 上算 LBL，只要求整个 batch 上的负载均匀。Qwen3-Next 的稀疏 MoE 就是在这种全局负载均衡下训练的，损失系数 router_aux_loss_coef 是 0.001。

9.4 激活参数计算器

选一个预设，或者自己拖参数。总参数和激活参数都按模型结构逐模块计算（包括注意力 / 线性注意力层、嵌入、输出头），预设模型算出来的总参数分别是 30.5B、79.7B、约 397B 和约 2.4T，和它们名字里的规模一致。

10. 训练稳定性：零中心 Norm 与 router 初始化

10.1 零中心、带权重衰减的 RMSNorm

RMSNorm 的标准形式是 \(y=\dfrac{x}{\mathrm{rms}(x)}\odot\gamma\)，\(\mathrm{rms}(x)=\sqrt{\tfrac1d\sum_ix_i^2+\epsilon}\)，可学习的增益 \(\gamma\) 初始化为 1。Qwen3 用了 QK-Norm，训练中却观察到一些 LayerNorm 的权重变得异常大。Norm 的增益直接乘在激活上，在 QK-Norm 里它更是直接缩放注意力 logit，权重过大会让 softmax 过尖、数值不稳定。

自然的想法是给增益加权重衰减，但普通参数化下这不合理：权重衰减把参数往 0 拉，而 \(\gamma=0\) 意味着把输出清零，这不是「没有效果」的默认状态。所以通常 Norm 的增益是被排除在权重衰减之外的。

Qwen3-Next 的做法是换成零中心参数化（Gemma 用的也是这种形式）：

这和原来的形式表达能力完全一样（\(\gamma=1+w\)），区别在于参数的「零点」变成了「增益为 1」。这时再对 \(w\) 施加权重衰减，拉向的是 \(\gamma=1\)，即恒等缩放，这是一个合理的先验，能防止增益无限增长。这种 Norm 用在每层的输入 / 注意力后 Norm、最终 Norm 和注意力里的 q_norm / k_norm 上；线性注意力输出端的门控 RMSNorm 则是普通参数化（权重初始化为 1）。

10.2 归一化的 router 初始化

router 的打分是 \(s_i=w_i^\top x\)，\(w_i\) 是 \(W_r\) 的第 \(i\) 行。如果随机初始化，不同行的范数 \(\lVert w_i\rVert\) 会有随机差异，范数大的 expert 在训练一开始就系统性地得到更高分，被选得更多，于是被训练得更多，形成「先发优势」。Qwen3-Next 在初始化时对 router 参数做了归一化，让每个 expert 在训练早期被无偏地选择。具体做法来自 σ-MoE：先从 \(\mathcal N(0,1)\) 采样，把每一行缩放到单位范数，再整体缩放到所需的标准差。这样初始打分 \(s_i=\lVert w_i\rVert\lVert x\rVert\cos\theta_i\) 只取决于夹角 \(\theta_i\)，不再带有每个 expert 固定的随机放大系数。512 个 expert 时这件事更重要：expert 越多，行范数的极值偏差越大。

10.3 小结：几处稳定性设计

• 注意力输出门：消除 attention sink 和 massive activation（第 7 节）；
• 零中心 + 权重衰减的 Norm：防止 Norm 权重异常增长；
• 归一化 router 初始化：避免早期路由的随机偏向；
• Gated DeltaNet 内部：\(q,k\) 的 L2 归一化让转移矩阵谱范数不超过 1，输出 RMSNorm 控制尺度。

这些设计让小规模实验更可靠，大规模训练更平稳。对做预训练的人来说，前半句其实更重要——小模型上的消融结论能不能外推，很大程度取决于训练是否稳定。

11. 多 token 预测与投机解码

11.1 MTP 模块的结构

标准语言模型在位置 \(t\) 只预测 \(x_{t+1}\)。多 token 预测（MTP）在训练时额外让模型预测 \(x_{t+2}\) 等更远的 token，给主干更密的训练信号；推理时，这个额外的预测头可以当草稿模型用。Qwen3-Next 的 MTP 模块和 DeepSeek-V3 一样是串行组织的，结构如下：

1. 输入两样东西：主干最后一层在位置 \(t\) 的隐状态 \(h_t\)，以及下一个 token \(x_{t+1}\) 的嵌入 \(e(x_{t+1})\)（与主干共享嵌入表）；
2. 两者各自过一个 RMSNorm（pre_fc_norm_embedding、pre_fc_norm_hidden），拼接成 4096 维，经线性层 fc 投回 2048 维；
3. 过 1 个完整的 Transformer 层（全注意力 + MoE，和主干的注意力层同构）；
4. 最后一个 RMSNorm，再用（共享的）输出头预测 \(x_{t+2}\)。

训练目标是在主干的下一 token 交叉熵之外加上 MTP 头的交叉熵（DeepSeek-V3 的做法是乘一个权重 \(\lambda\) 后相加；Qwen3-Next 用的权重没有公开）。MTP 有两个作用：一是更密的训练信号本身提升了模型的整体表现；二是推理时当草稿模型。Qwen3-Next 只有 1 层 MTP，要起草多个 token，就把同一个 MTP 层递归地用多次：第二步的输入是它自己第一步的输出。如果训练时只见过主干给的隐状态，这种递归用法就和训练不一致，越往后猜得越差。所以 Qwen3-Next 专门做了「训练与推理一致的多步训练」，以提高多步起草时的接受率。

11.2 投机解码

投机解码的流程：便宜的草稿模型先连续猜 \(\gamma\) 个 token；大模型用一次前向（相当于一次长度为 \(\gamma+1\) 的 prefill）并行地验证这些猜测，从头开始接受，直到第一个被拒的位置，并在那里补上一个自己采样的 token。用拒绝采样的接受规则，输出分布和只用大模型采样完全一致。

如果每个草稿 token 被接受的概率是独立同分布的 \(p\)，一次验证平均产出的 token 数是

MTP 头当草稿模型的好处：它只有一层，起草很便宜；它读的是主干的隐状态，比独立的小模型更「懂」主干，接受率更高；而且是和主干一起训练出来的，不用另外蒸馏。推荐的部署参数是 SGLang --speculative-num-steps 3 --speculative-num-draft-tokens 4、vLLM num_speculative_tokens: 2。

对混合模型来说，投机解码还有一个工程上的麻烦：全注意力层里被拒绝的 token 只要把 KV cache 截断即可，但 Gated DeltaNet 的状态是原地更新的，没法“截断”。回滚需要保留验证过程中每个位置的状态（或者能从接受位置重新算），推理框架要为这类模型专门适配。

12. 训练效率与长上下文的实测结果

12.1 预训练

• 训练数据：从 Qwen3 的 36T token 预训练语料中均匀采样的 15T token 子集。
• GPU 时：不到 Qwen3-30B-A3B 的 80%；是 Qwen3-32B 计算成本的 9.3%。
• Qwen3-Next-80B-A3B-Base 只激活 Qwen3-32B-Base 约 1/10 的非嵌入参数（3.25B / 31.2B ≈ 10.4%），在大多数基准上超过 Qwen3-32B-Base，并显著超过 Qwen3-30B-A3B。

12.2 推理吞吐（相对 Qwen3-32B）

这和第 8 节的计算吻合：4K 时差异主要来自激活参数（3.25B vs 31.2B 非嵌入）；32K 以上 KV cache 的差距（24 KiB vs 256 KiB / token，约 10.7 倍）开始主导 decode，正好是「超过 10 倍」的量级。当然，实际的效率提升高度依赖推理框架的实现，SGLang 和 vLLM 都已经支持。

12.3 长上下文

• 原生上下文 262,144 token。超过这个长度时用 YaRN（RoPE 缩放）外推，在 100 万 token 上验证过，推荐配置 factor: 4.0, original_max_position_embeddings: 262144，最大长度 1,010,000。由于开源框架实现的是静态 YaRN（缩放因子不随输入长度变），可能影响短文本表现，所以只在需要时开启，并按实际长度调整 factor（例如常用长度 524,288 时用 2.0）。注意 YaRN 只作用于 12 个全注意力层的 RoPE 维度（每头前 64 维）；线性注意力层本身没有位置编码。
• RULER（100 万 token 版本，每个长度 260 个样本）上，Qwen3-Next-80B-A3B-Instruct 的平均分 91.8，高于 Qwen3-30B-A3B-Instruct-2507 的 86.8，略低于 Qwen3-235B-A22B-Instruct-2507 的 92.5。在原生的 256K 以内，它全面超过 Qwen3-30B-A3B-Instruct-2507，基本也不输 Qwen3-235B-A22B-Instruct-2507。部分数据点：

Qwen3-Next 评测时开了 YaRN，Qwen3-2507 系列开了 Dual Chunk Attention。逐列看，256K 以内 Qwen3-Next 只在 192K 一列略低于 235B（94.0 对 94.5），其余持平或更高；超过原生长度（256K）以后，它的下降比 235B 快。

12.4 后训练

发布了 Instruct（不输出思考过程）和 Thinking 两个版本。Qwen 团队称解决了「混合注意力 + 高稀疏 MoE」架构在强化学习训练中的稳定性和效率问题，具体方法没有公开。Instruct 版在不少基准上接近 Qwen3-235B-A22B-Instruct-2507（比如 Arena-Hard v2 为 82.7 对 79.2，LiveCodeBench v6 为 56.6 对 51.8，但 Aider-Polyglot 为 49.8 对 57.3、TAU2-Retail 为 57.3 对 74.6，并非全面持平）。

13. 完整配置表

Qwen3-Next-80B-A3B 的 config.json 主要字段（Instruct 与 Thinking 两个版本相同）：

14. 后来：Qwen3.5、3.6、3.8 与 Flash-Next

Qwen3-Next 发布时，Qwen 团队说会在这一架构上继续开发 Qwen3.5。事后看，这套「3 × Gated DeltaNet + 1 × Gated Attention、高稀疏 MoE、MTP」的骨架确实成了之后 Qwen 主线模型的基础：

几点观察：

• Qwen3-Coder-Next 与 Qwen3-Next 结构完全相同（只有 rope_theta 改成了 5,000,000），是同一架构上的代码 Agent 模型。
• Qwen3.5 成为原生多模态模型（带视觉编码器，early fusion），词表扩到 248,320，位置编码改成交织的多维 RoPE（mrope_section [11, 11, 10]，合起来正好是部分 RoPE 的 64 维的一半频率数），但语言模型的骨架就是 Qwen3-Next：3:1 的 Gated DeltaNet / Gated Attention（注意力输出门 attn_output_gate: true）、部分 RoPE 0.25、头维 256、2 个 KV 头、1 层 MTP（同样做了多步训练），线性注意力状态用 fp32。规模扩大时，变的主要是 V 头数（32 → 64 → 128）和 expert 宽度（512 → 1024 → 2048），QK 头一直是 16、expert 数一直是 512 选 10 + 1。
• Qwen3.5-27B 说明这套混合注意力也被用在了稠密模型上。
• Qwen3.8-2.4T-A95B 建立在 Qwen3.5 的架构上，把同一骨架推到了 2.4T 总参数。
• Qwen3.8-Flash-Next 定位是 Qwen4 架构的实验性预览，开始改动骨架本身：把 Gated Attention 换成了 Qwen Sparse Attention（QSA，按微块而非单个 token 做选择，带一个 MQA 结构的索引器，预算 512 块或 2048 token），加入 Gated Residual（4 个分支的加宽残差流，带数据依赖的读门和逐分支的写门）、n-gram 嵌入（2000 万个二元 / 三元组嵌入，挂在第 2 层），训练上对不同权重分别使用 Muon 和 AdamW。Gated DeltaNet 层和 512 选 10 + 1 的 MoE 保留了下来。它的细节值得单独写一篇。

换句话说，从 Qwen3-Next 到 Qwen3.8，「3:1 的 Gated DeltaNet 混合 + 512 expert + MTP」这个组合在一年里被沿用到了从 35B 到 2.4T 的模型上；到 Flash-Next，被替换掉的是那 1/4 的全注意力层——这正好对应第 8 节的观察：长上下文下，剩下的全注意力层成了新的瓶颈。

15. 小结

• 线性注意力把 softmax 换成内积后，注意力变成一个以 \(d_k\times d_v\) 矩阵为状态的 RNN：训练可以分块并行，decode 每步常数代价，没有 KV cache。代价是固定容量的有损记忆。
• Delta 规则把写入改成「对平方损失做一步在线梯度下降」，能改写已有的键；门控能整体遗忘。Gated DeltaNet 把两者结合，靠 UT 变换做到块内并行。
• Gated Attention 在 SDPA 输出后加逐元素 sigmoid 门，给低秩的 \(W_VW_O\) 加了非线性，并通过稀疏门消除 attention sink 和 massive activation。
• 3:1 混合：36 层线性注意力 + 12 层全注意力，KV cache 降到全注意力版的 1/4，长上下文下仍保留精确检索能力。
• 512 选 10 + 1 的 MoE：激活宽度和 Qwen3-30B-A3B 相当，总参数多 2.6 倍；配合全局 batch 的负载均衡和归一化的 router 初始化。
• 零中心 Norm + 权重衰减：让 Norm 增益的权重衰减拉向 1 而不是 0。
• MTP：一层的串行 MTP 模块，训练时提升效果，推理时做投机解码的草稿，并做了多步训练以提高多步起草的接受率。

如果只记一件事：Qwen3-Next 的效率来自两个正交的方向——沿序列方向用线性注意力把大部分层的成本从 \(O(L)\) 降到 \(O(1)\)，沿参数方向用高稀疏 MoE 把每 token 的计算和总参数解耦。两者叠在一起，才有「训练成本约为 Qwen3-32B 的 9.3%、32K 以上吞吐超过 10 倍」的结果。

参考与延伸阅读

Qwen3-Next 没有单独的技术报告，架构细节和实验结果来自官方博客、模型卡和 config.json；文中的参数量、缓存大小和 FLOPs 是按 config 和 transformers 的实现算出来的。想对着代码读一遍，推荐从 transformers 的 modular_qwen3_next.py 开始，它很短，Gated DeltaNet 的逐 token 递推和分块算法（torch_recurrent_gated_delta_rule、torch_chunk_gated_delta_rule）都有纯 PyTorch 版本。

1. Qwen Team. Qwen3-Next: Towards Ultimate Training & Inference Efficiency（博客，2025-09-10）：Key Features、Pre-training、Post-training 各节。
2. Qwen3-Next-80B-A3B-Instruct 模型卡（Model Overview、Processing Ultra-Long Texts、Long-Context Performance）与 config.json；Thinking 版模型卡。
3. Hugging Face transformers：modular_qwen3_next.py（Gated DeltaNet、Gated Attention、RMSNorm 的参考实现）。
4. vLLM：qwen3_next_mtp.py（MTP 模块）。
5. Katharopoulos et al. Transformers are RNNs: Fast Autoregressive Transformers with Linear Attention. 2020.（§3.2 线性注意力、§3.4 RNN 形式）
6. Schlag, Irie, Schmidhuber. Linear Transformers Are Secretly Fast Weight Programmers. 2021.（容量分析与 Delta 规则）
7. Yang et al. Parallelizing Linear Transformers with the Delta Rule over Sequence Length. 2024.（WY 表示与分块算法）
8. Yang, Kautz, Hatamizadeh. Gated Delta Networks: Improving Mamba2 with Delta Rule. 2024.（门控 Delta 规则与分块训练）
9. Yang et al. Gated Linear Attention Transformers with Hardware-Efficient Training. 2023.
10. Dao, Gu. Transformers are SSMs (Mamba2). 2024.
11. Qiu et al. Gated Attention for Large Language Models: Non-linearity, Sparsity, and Attention-Sink-Free. 2025.（§4、表 4、附录 A.3）
12. Xiao et al. Efficient Streaming Language Models with Attention Sinks. 2023.
13. Sun et al. Massive Activations in Large Language Models. 2024.
14. Gemma Team. Gemma: Open Models Based on Gemini Research and Technology. 2024.
15. Csordás, Irie, Schmidhuber. Approximating Two-Layer Feedforward Networks for Efficient Transformers. 2023.（σ-MoE 初始化）
16. Qiu et al. Demons in the Detail: On Implementing Load Balancing Loss for Training Specialized Mixture-of-Expert Models. 2025.
17. DeepSeek-AI. DeepSeek-V3 Technical Report. 2024.（§2.2 Multi-Token Prediction）
18. Gloeckle et al. Better & Faster Large Language Models via Multi-token Prediction. 2024；Qi et al. ProphetNet. 2020.
19. Leviathan, Kalman, Matias. Fast Inference from Transformers via Speculative Decoding. 2023.
20. Peng et al. YaRN. 2023；Hsieh et al. RULER. 2024.
21. 后续模型卡：Qwen3-Coder-Next、Qwen3.5-397B-A17B、Qwen3.5-35B-A3B、Qwen3.5-27B、Qwen3.6-35B-A3B、Qwen3.8-2.4T-A95B、Qwen3.8-Flash-Next（各自的 Model Overview 与 config.json）。