模型结构深度解读 · 混合注意力 · 含 modeling 源码逐行 · Qwen4 预览架构

Qwen3.8-Flash-Next 逐层拆解 3× Gated DeltaNet ＋ 1× Qwen Sparse Attention 的混合骨干

这是 Qwen 团队作为「未来 Qwen4 架构预览」放出的首个开源权重模型。它把此前 Qwen3-Next 的「Gated DeltaNet + 门控全注意力」骨干，替换成了「Gated DeltaNet + Qwen Sparse Attention（QSA）」，并配上 Gated Residual、N-gram Embedding、MTP 与 Muon/AdamW 混合优化器。本文按官方模型卡与 config.json 逐字段拆开，重点把注意力那一层——尤其是 QSA 的 indexer 与 micro-block 稀疏机制——讲到每个符号。

Qwen Team · Alibaba Group · 2026-08 · 125B 总参 / 6B 激活 · +51B N-gram Embedding · +4B MTP · 原生 262K，可扩到 1M

五句话讲完这个架构

混合层，不是全注意力。48 层里 3/4 是线性注意力（Gated DeltaNet），1/4 是稀疏全注意力（QSA），严格按「3 GDN → 1 QSA」的节奏交错。全局精确检索交给少数 QSA 层兜底，绝大多数序列建模由 O(N) 的 GDN 承担。
QSA 的核心是「块级」稀疏，不是「token 级」。它不为每个 query 挑单个 token，而是先用一个轻量 indexer 给 KV micro-block 打分，只在 Top-k 个块（预算 512 块 ≈ 2048 token）上做精确注意力——把长上下文延迟砍下来，这对 agentic 负载至关重要。
参数扩展走了三条不同的轴。MoE（512 专家选 10+1）扩容量、N-gram Embedding（2000 万条 bi/trigram，51B 参数）扩记忆但几乎不加计算、MTP（多 token 预测）加训练信号。三者可分别 offload，对显存受限的加速卡友好。
Gated Residual 让残差流「可读可写」。加宽的残差流上挂 4 条分支，用逐元素、数据相关的读门 + 每分支标量写门调制信息，兼顾表达力与训练稳定性。
训练配方也重写了。Muon 与 AdamW 按权重类别分工，用重新拟合的 scaling law 直接从目标 batch size 起步、砍掉 warmup，减少总优化步数并支持更大学习率。

125B

总参数
（不含 n-gram / MTP）

每 token
激活参数

3 : 1

GDN 层 : QSA 层
混合比例

2048

QSA 每 query
注意力预算（token）

⚠ 关于这个模型的一句说明

Qwen3.8-Flash-Next 被官方定位为「支撑 Qwen4 的实验性架构预览」。本文所有结构、维度、超参数均严格来自其 HuggingFace 模型卡与 config.json，我把它当作权威一手规格来解读；文中凡属我基于公开机制（DeltaNet / Mamba2 / DeepSeek Sparse Attention 等技术线）做的推断与延伸，都会明确标注为「解读」而非原文断言。

01 全局总览：一张图看懂它长什么样

先把官方架构图放上来。这张图的信息密度很高，右侧是放大的「一个 Hybrid Block」内部，左侧是整体堆叠。

图 1 · 官方架构图。输入 token → 词表 embedding，第 2 层额外叠加 N-gram Embedding；主干由 Hybrid Block × (L/4) 堆成，每个 block = 3× GDN Layer + 1× QSA Layer；每层内部是「(GDN 或 Qwen Sparse Attn) → MoE」，并用 Gated Residual（GR Write / GR Read）在加宽的残差流（Expanded Residual）上读写；顶部经 MTP 模块接 Prediction Head。来源：Qwen 官方模型卡。

把 config.json 里的关键数字对齐到这张图，就是下面这张「配置总表」。后面每一节会把其中一块拎出来单独拆。

模块	关键配置	数值（来自 config.json）
整体	总参 / 激活 / 层数 / hidden	125B / 6B / 48 层 / `hidden_size=2560`
词表	vocab / n-gram / 输出	248320 · n-gram 2000 万（`ngram_size=3`）· LM 输出 248320
层布局	`full_attention_interval=4`	每 4 层出现 1 层 full(=QSA)，其余 3 层 linear(=GDN)
QSA（全注意力层）	Q/KV 头 · head_dim · RoPE	24 Q 头 / 2 KV 头（GQA）· `head_dim=256` · 旋转维 64（`partial_rotary_factor=0.25`）
QSA · Indexer	结构 · 预算	MQA 4 Q 头 / 1 KV 头 · `indexer_head_dim=128` · 预算 512 块 / 2048 token（`indexer_budget=2048`, 压缩比 4）
GDN（线性注意力层）	V/QK 头 · head_dim · conv	48 V 头 / 16 QK 头 · `head_dim=128` · 短卷积核 `linear_conv_kernel_dim=4`
MoE	专家数 · 激活 · 中间维	512 专家，选 10 路由 + 1 共享 · `moe_intermediate_size=640`
Gated Residual	分支 · 瓶颈秩	4 分支 · `hc_lowrank=320`（bottleneck rank）
MTP	层数 · 训练	1 层，multi-step 训练（`mtp_num_hidden_layers=1`）
上下文	原生 · 可扩	262144 原生，YaRN 扩到 1,000,000
视觉塔	ViT	`depth=27`, hidden 1152, patch 16, 输出对齐 2560

💡 解读：为什么是「3:1」而不是「全稀疏」或「全线性」

线性注意力（GDN）把状态压成固定大小，擅长顺序建模但天然记不准细节；一旦任务需要「回头精确检索上文某个具体 token」，纯线性会掉链子。所以 Qwen 从 Qwen3-Next 起就用混合骨干：多数层用便宜的 GDN 扛住 O(N) 的长序列，少数层（这里是每 4 层 1 层）保留能精确寻址的全注意力做兜底。Qwen3.8-Flash-Next 的新意在于——把那 1/4 的「全注意力」进一步换成稀疏的 QSA，让兜底层本身也不再是 O(N²)。

02 层布局：把 48 层摊开看

config.json 里的 layer_types 数组是这个模型最诚实的「设计蓝图」——它逐层列出了每一层是 linear_attention（GDN）还是 full_attention（QSA）。规律非常干净：linear, linear, linear, full 每 4 层一循环，共 12 个循环 = 48 层。这正对应模型卡里写的 12 × (3 × (Gated DeltaNet → MoE) → 1 × (Qwen Sparse Attention → MoE))。

GDN Gated DeltaNet → MoE

GDN Gated DeltaNet → MoE　＋ N-gram Embedding 在此注入

QSA Qwen Sparse Attention → MoE　← 第 1 个全注意力层

L4–6

GDN ×3 …

QSA 第 2 个全注意力层

…

循环 12 次：L11, L15, L19, L23, L27, L31, L35, L39, L43 都是 QSA

L47

QSA 第 12 个（最后一个）全注意力层

MTP

MTP 1 层 full_attention，multi-step 训练（额外 ~4B 参数）

full_attention
_interval = 4

每隔 4 层放一个全注意力层。数组里 index 3, 7, 11, …, 47 是 full，其余是 linear。48 / 4 = 12 个 QSA 层。

ple_layer_ids
= [2]

N-gram Embedding（PLE, Parameter-Lookup Embedding）只在第 2 层注入。早注入，让局部 n-gram 语义尽早融进残差流。

mtp.hybrid
= true

MTP 头本身也是一个 full_attention 小层，独立 rope_theta=1e7，用于多 token 预测的训练时监督。

💡 解读：把「精确检索」层放在序列后段更划算吗？

QSA 层均匀分布（每 4 层一个），并没有像某些设计那样「全堆在顶部」。均匀交错的好处是：每经过 3 层便宜的 GDN 做完局部/顺序聚合后，就有一个能全局精确寻址的层来「校准」一次表示，信息不会在纯线性层里漂太久才被纠正。这与混合架构里「让全注意力层周期性充当锚点」的经验一致。

03 ★ 重点：Qwen Sparse Attention（QSA）—— 对照 modeling 源码逐行拆

这是全文的核心，也是这次基于官方 modeling_qwen4_exp.py 源码重写的部分。QSA 是 Qwen3.8-Flash-Next 相对 Qwen3-Next 最大的改动——把那 1/4 的「门控全注意力」换成了「块级稀疏注意力」。它落到代码里是两个类协作：Qwen4ExpTextQSAIndexer（选块、产出稀疏 mask）+ Qwen4ExpTextAttention（拿 mask 做门控注意力）。下面先立靶子，再照着 Qwen4ExpTextQSAIndexer.forward() 一行一行走。

🔑 读源码得到的 3 个「与初版推断不同 / 更精确」的结论（先摆出来）

打分不是普通点积，而是 relu(·) 后按 head 求和再 /√d。——初版我猜的是「max / 均值点积」，源码给的是 ReLU + sum-over-heads，这是一个刻意的非负、多头投票式打分。
块的代表向量 = 该块 4 个 token key 的均值池化（mean-pool），再过 k_layernorm、再按块首 token位置打 RoPE。不是简单取压缩表示。
indexer 不 gather KV，而是产出一张布尔/加性 mask，叠加到主因果 mask 上，主注意力照常 dense 跑但被 mask 掐成稀疏。这解释了它为什么能直接复用标准 attention kernel。

3.1 先立靶子：标准因果全注意力，贵在哪

对每个 query 位置 t、每个 head h，标准注意力计算：

对第 t 个 query，要和它之前所有 i≤t 个 key 算内积、做 softmax、再对 value 加权求和。

逐符号拆开看它到底贵在哪：

q_t, k_i, v_i

query / key / value 向量，维度 d_h。在 QSA 里 head_dim=256。

⟨q_t, k_i⟩

内积打分。对长度 N 的序列，一共要算 O(N^2) 个内积——这就是二次方成本的来源。

/ √d_h

缩放，防止内积随维度增大而把 softmax 推向饱和（梯度消失）。

α_t,i

归一化后的注意力权重，\sum_i \alpha_{t,i}=1。这是一个严格的概率分布——约束 Σα=1 不是「显然」，它来自 softmax 分母的归一化，正是它让输出是 value 的凸组合。

Σ_i≤t

因果掩码：只看过去。推理时要缓存所有历史 k,v（KV-Cache），显存随 N 线性增长、算力随 N² 增长。

✗ 关键痛点（为什么要稀疏）

当上下文拉到 26 万甚至 100 万 token，每生成一个新 token 都要对全部历史做一遍内积——prefill 的 O(N²) 和 decode 每步的 O(N) 都变得难以承受。agent 场景（多轮工具调用、长文档、代码库）恰恰把 N 推到极大。QSA 的目标：让每个 query 实际参与注意力的 token 数从「全部历史」降到一个固定的小预算。

3.2 数据流总览：indexer 产 mask，attention 吃 mask

先看 Qwen4ExpTextAttention.forward() 的头两行——它把整个 QSA 的调用关系摊开了：

selected_token_mask = self.indexer(hidden_states, position_embeddings, attention_mask, past_key_values) # 把稀疏 mask 叠加到主因果 mask 上（eager 用加法、sdpa 用按位与） if attention_mask.is_floating_point(): attention_mask = attention_mask + selected_token_mask else: attention_mask = attention_mask & selected_token_mask

所以 QSA = 「indexer 决定每个 query 能看见哪些 KV」→「把不该看的位置在 mask 里屏蔽掉」→「主注意力照常算，但只有选中的位置参与 softmax」。它没有 gather、没有搬运 KV——纯靠一张 mask 把稠密注意力掐成稀疏。下面把 indexer 逐段走完。

Step 1

投影 q / k

index_qk_proj 把 hidden 投成 4 个 indexer-query 头 + 1 个 key 头（各 128 维），q 过 RMSNorm + RoPE。

→

Step 2

分块 + 池化

可见 key 每 4 个（compress_ratio）切一块，块内 key 均值池化→k_layernorm→按块首位置打 RoPE，得块代表向量。

→

Step 3

打分 + Top-k

relu(q·kᵀ) 按 head 求和 /√d 得块分数，取 Top-512 块。

→

Step 4

块→token→mask

选中块展开回 token 下标，散射（scatter）成布尔 mask 返回。

Step 1 · 投影：一个 Linear 同时出 indexer 的 q 和 k

# __init__：注意 out 维度 = (4 + 1) × 128 self.index_qk_proj = nn.Linear(hidden_size, (index_n_heads + index_kv_heads) * index_head_dim, bias=False) self.q_layernorm = RMSNorm(index_head_dim); self.k_layernorm = RMSNorm(index_head_dim) self.block_topk = token_budget // compress_ratio # = 2048 // 4 = 512 # forward：一次投影，再劈成 q(4头) 和 token_k(1头) qk = self.index_qk_proj(hidden_states) q, token_k = torch.split(qk, [index_n_heads*index_head_dim, index_kv_heads*index_head_dim], dim=-1) q = self.q_layernorm(q.reshape(B, S, 4, 128)) raw_keys = token_k.reshape(B, S, 1, 128).squeeze(2) # 每个 token 一个 128 维 key q = apply_rotary_pos_emb(q, cos=current_cos, sin=current_sin) # indexer 自己的 RoPE

index_qk_proj

indexer 有自己独立的 q/k 投影参数，与主分支的 q_proj/k_proj 完全无关——它是一个「专门用来选块的迷你注意力」。out 维 = (4+1)×128 = 640。

q_layernorm
k_layernorm

q 和 key 各自过一个 RMSNorm（index_head_dim=128 上归一），稳定打分尺度。

block_topk
= 512

源码原话 token_budget // compress_ratio = 2048 // 4 = 512。这行代码就是「预算 2048 token = 512 块」换算的出处——每个 query 最多选 512 个块。

4 Q / 1 K 头

indexer_n_heads=4, indexer_kv_heads=1：4 个 query 头共享 1 个 key 头（MQA 极致），打分成本极低。

Step 2 · 分块与池化：块代表 = 4 个 token key 的均值

对每个 (batch, query) 位置，取它可见的 key 下标，每 compress_ratio=4 个连续可见 token 组成一个「完整块」；不足 4 个的尾巴单独处理（见 Step 4）。块代表向量这样算：

block_token_indices = local_visible_indices[:n_blocks*4].view(n_blocks, 4) # 每行 4 个 token 下标 key_groups = raw_keys[b].index_select(0, block_token_indices.flatten()).view(n_blocks, 4, 128) pooled_keys = key_groups.float().mean(dim=1).to(dtype) # ← 块内 4 个 key 均值池化 pooled_keys = self.k_layernorm(pooled_keys) group_starts = block_token_indices[:, 0] # 块的“首 token”位置 block_key_states = apply_rotary_pos_emb(pooled_keys.unsqueeze(1), cos=full_cos[b].index_select(0, group_starts), sin=full_sin[b].index_select(0, group_starts)).squeeze(1)

k̄_B：块 B 的代表向量 = 块内 4 个 token 的 key 均值 → RMSNorm → 按块首 token 位置 p₀(B) 打 RoPE。用块首位置而非块中心，是个务实的近似（整块共享一个位置编码）。

Step 3 · 打分：ReLU 后按 head 求和 —— 这里和初版推断不同

scores = torch.matmul(q[b, qi].float(), block_key_states.float().transpose(-1, -2)).transpose(-1, -2) scores = torch.relu(scores).sum(dim=-1) / math.sqrt(self.index_head_dim) selected_block_indices = scores.topk(min(self.block_topk, n_blocks), dim=0).indices

逐符号：q̃_i^(h) 是第 i 个 query 的第 h 个 indexer 头（共 4 个）；和块代表 k̄_B 做内积，先 ReLU 把负相关截成 0，再对 4 个 head 求和，最后 /√d 缩放。得到每个块一个标量分数 s_i,B，取分数最高的 512 个块。

relu(·)

非负打分。只有「正相关」的头才为这个块投票，负相关被截断为 0——避免负项互相抵消，让打分更像「有多少个头觉得这块相关」的投票强度。这是源码的真实设计，初版我误写成 max/均值点积，此处已按代码更正。

sum over 4 heads

4 个 indexer 头的分数直接相加（不是取 max、不是平均）。多头在此充当「多个独立评委」，票数累加。

/ √d (d=128)

用 indexer 的 head_dim 而非主分支的 256 做缩放。

topk(min(512,
n_blocks))

块数不足 512 时全选。预算是「上限」，短序列自然不受限。

Step 4 · 块→token→mask：把选中块散射成布尔掩码

selected_tokens = block_token_indices.index_select(0, selected_block_indices).flatten() # 块展开回 token tail = local_visible_indices[n_blocks*4:] # ← 不足一块的尾巴：无条件保留 selected_tokens = torch.cat([selected_tokens, tail]) ... scatter_indices = torch.where(selected_token_indices >= 0, selected_token_indices, kv_length) # -1 占位丢到末列 selected_token_mask = zeros(..., kv_length+1, bool).scatter(-1, scatter_indices, True)[..., :kv_length] if attention_mask.is_floating_point(): # eager：布尔→加性 float mask selected_token_mask = torch.where(selected_token_mask, 0.0, min_dtype) # 未选中 = -inf

块→token 展开

选中的是「块」，但主注意力按 token 算，所以把每个选中块的 4 个 token 下标全部展开，得到实际可见 token 集合。

tail 尾块
无条件保留

不足 compress_ratio(4) 的最后几个可见 token 永远保留，不参与打分竞争。通常是最近的、离 query 最近的 token——保证「近处上文」不会被稀疏掉。

scatter 成 mask

用 -1 做占位符，散射时把 -1 全丢到「第 kv_length 列」再切掉，干净地得到布尔可见矩阵；eager 模式再转成 0 / −inf 的加性 mask。

叠加主 mask

返回后与主因果 mask 相加（或按位与）：既满足因果、又只保留选中块——主注意力 softmax 时，未选中位置权重被 −inf 压成 0。

💡 为什么「产 mask」而不是「gather KV」是聪明的工程选择

产 mask 的最大好处：主注意力 eager_attention_forward 完全不用改——它就是标准的 softmax(QKᵀ·scaling + mask)·V，mask 里已经包含了稀疏信息。这样 QSA 能直接复用现成的 attention kernel（含 SDPA），不需要为「选中块」写专门的 gather-attention kernel。代价是：训练/短序列时它逻辑上仍算了全部 QKᵀ（只是 mask 掉），真正的省算要靠推理引擎（vLLM/SGLang）识别 mask 结构做块稀疏 kernel。换句话说：这份 modeling 是「参考实现」，重在语义正确与可复用；生产提速靠 serving 引擎的稀疏 kernel。

3.3 主分支：Gated Attention（源码里的输出门）

indexer 给完 mask，主注意力还有一个初版没细讲的细节——输出门控。看 Qwen4ExpTextAttention：q_proj 的输出宽度是 2×，劈成「真正的 query」和「门 gate」：

self.q_proj = nn.Linear(hidden_size, num_attention_heads * head_dim * 2, bias=False) ... query_states, gate = torch.chunk(self.q_proj(hidden_states).view(*shape, -1, head_dim*2), 2, dim=-1) query_states = self.q_norm(query_states...) # QK-Norm：q/k 各过 RMSNorm key_states = self.k_norm(self.k_proj(...)...) query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin) # partial RoPE 64 维 attn_output = attention_interface(self, q, k, v, attention_mask, scaling=head_dim**-0.5) # 带稀疏 mask attn_output = attn_output * torch.sigmoid(gate) # ← 逐元素输出门控 attn_output = self.o_proj(attn_output)

q_proj × 2

Gated Attention：query 投影多出一半宽度当门。注意力输出 o 再乘 sigmoid(gate) ——逐元素、数据相关地缩放每个通道，等价于给注意力输出加了个 SiLU/GLU 式的自门控。

q_norm / k_norm
(QK-Norm)

q、k 在 head_dim=256 上各过 RMSNorm 再算注意力——稳定长上下文下的注意力分数尺度（QK-Norm，近年大模型标配）。

num_key_value
_heads = 2

激进 GQA：24 Q 头分 2 组，每 12 Q 头共享 1 组 KV。KV-Cache 缩到 2/24 ≈ 1/12（repeat_kv 在算之前把 KV 复制回 24 头）。

scaling
= 256^-0.5

主分支缩放用 head_dim=256（区别于 indexer 的 128）。

partial RoPE：只旋转前 64 维

apply_rotary_pos_emb 里 rotary_dim = cos.shape[-1]，只对 q/k 的前 rotary_dim 维施加旋转、后面维度原样拼回：

q_rope, q_nope = q[..., :rotary_dim], q[..., rotary_dim:] # rotary_dim = 256×0.25 = 64 q_rope = (q_rope * cos) + (rotate_half(q_rope) * sin) q_rotated = torch.cat([q_rope, q_nope], dim=-1) # 前 64 维带位置，后 192 维“无位置内容通道”

partial_rotary
_factor = 0.25

256 × 0.25 = 64 维旋转（对应模型卡「RoPE Dimension: 64」），其余 192 维不带位置——一部分容量专注内容匹配、不被位置扰动。

rope_theta = 1e7

大基频拉长旋转波长，原生支持 26 万上下文的前提。

mrope_section
=[11,11,10]

M-RoPE（多模态 RoPE，interleaved）：32 个旋转对分给时间/高/宽（11+11+10=32=64/2），同时表达文本序号与图像/视频坐标。apply_interleaved_mrope 负责交织。

YaRN factor=4

扩 100 万上下文时把 rope_type 改 yarn、factor=4。官方提醒 YaRN 是静态缩放，略伤短文本，只在需要时开。

⚠ 关于「稀疏选择不可导」与训练：这份 modeling 没有暴露训练细节

这份 modeling 是推理/前向参考实现：indexer 的 Top-k 是硬选择（不可导），代码里没有出现对齐 indexer 打分的辅助损失——它假定 indexer 已训好。按同技术线（DeepSeek Sparse Attention）的通行做法，通常会用一个 KL / 蒸馏损失让 indexer 的块打分去逼近主分支真实注意力分布（配 stop-gradient）。这部分仍以 Qwen 技术报告为准，本文只如实说明「前向代码里看不到训练 loss」。

💡 一句话把 QSA 串起来

QSA = 一个自带迷你 MQA 打分器（indexer）的门控 GQA。indexer 用「4 头 ReLU 投票」给每 4 个 token 组成的块打分、选 Top-512 块、散射成一张稀疏 mask；主分支是带 QK-Norm、partial-RoPE、sigmoid 输出门的 GQA，吃这张 mask 后只在选中块上做精确 softmax。整套设计的工程精髓在于——用 mask 而非 gather 实现稀疏，从而免写专用 kernel、直接复用标准注意力。

04 另外 3/4 层：Gated DeltaNet（线性注意力骨干）

QSA 讲透了，再看承担 3/4 层的 GDN。它是 Qwen3-Next 就在用的线性注意力，核心是「用一个固定大小的状态矩阵 S_t 概括全部历史」，从而把复杂度从 O(N²) 降到 O(N)。它的递推式把「自适应遗忘」和「定点改写」合二为一：

S_t：t 时刻的记忆状态矩阵（固定大小，不随 N 增长）。整条式子＝先「淡忘 + 擦掉旧的、写入新的」，再产出。

α_t ∈ (0,1)

标量门控（来自 Mamba2 思路）：自适应遗忘。α→1 记得牢，α→0 快速淡忘整块旧记忆。数据相关，逐 token 决定。

I − β_tk_tk_t^⊤

Householder 型的 delta 规则（来自 DeltaNet）：定点擦改。这个投影只在 k_t 方向上修正记忆——「把旧的关于 k_t 的内容擦掉」，实现误差修正式的精确改写，而非线性注意力常见的「只会累加」。

β_t

写入强度 / 学习率，控制这次改写的力度。

v_tk_t^⊤

外积，把新的 (key→value) 关联写进状态。

linear_num
_value_heads=48

48 个 value 头

linear_num
_key_heads=16

16 个 QK 头（V 头比 QK 头多，48 vs 16，是一种头维度上的不对称设计）。

linear_*_head_dim
=128

K/V head 维度均 128。

linear_conv
_kernel_dim=4

GDN 前有个 核长 4 的短因果卷积，先做局部混合（类 Mamba 的 short conv），再进线性注意力递推。

🔗 已有专文：这部分我们之前拆得更细

Gated DeltaNet 的完整数学（从 softmax→线性注意力→DeltaNet→Mamba2→GDN 的技术线、WY 表示与 chunk 并行训练）在知识库另有一篇专文：《Gated DeltaNet：会精确改写记忆的线性注意力》。本文只把它作为「3/4 层的骨干」定位，不重复展开。

💡 GDN 与 QSA 的分工，一句话

GDN 是「压缩的、顺序的、O(N) 的工作记忆」——擅长顺着序列往下捋、维护一个不断被改写的状态；QSA 是「稀疏的、可寻址的、精确检索」——需要回头精确翻某段上文时靠它。两者相乘式互补，正是混合架构长上下文既快又准的原因。

05 Gated Residual：让残差流「可读可写」

残差连接（residual + norm）是深层 LLM 能训起来的基础。Qwen3.8-Flash-Next 在此之上做了 Gated Residual：在一条加宽的（expanded）残差流上，用数据相关的门控来调制信息进出。架构图里的 GR Write / GR Read 就是它。

📖

读门（GR Read）

逐元素、数据相关的 read gate：决定当前层从加宽残差流里「读多少、读哪些通道」。element-wise 意味着每个维度独立开关，粒度很细。

✍️

写门（GR Write）

每分支一个标量的 write gate：控制这一层的计算结果以多大权重写回残差流。per-branch scalar 保持稳定、开销极小。

hc_count = 4

4 条分支（branches）：加宽的残差流被组织成 4 路，Gated Residual 分别在这 4 路上读写。

hc_lowrank
= 320

瓶颈秩 320：门控不是在全维 2560 上直接算，而是先降到 320 维的低秩瓶颈再算——省参省算，同时够表达。

output_gate
_type=sigmoid

输出门用 sigmoid（0~1 的软开关）。

💡 解读：为什么「读门逐元素、写门标量」这样不对称？

读的时候需要细粒度地挑通道（哪些特征此刻有用是高度数据相关的），所以用 element-wise 向量门；写的时候若也逐元素，会引入大量参数并可能破坏残差流的尺度稳定性——所以写门退化成每分支一个标量，只调「整体写入强度」，既保住深层训练的稳定性，又几乎不加推理开销。这就是模型卡说的「finer-grained expressiveness … while preserving training stability and keeping inference overhead low」。

06 N-gram Embedding：用「查表」换「算力」的第三条扩展轴

这是很有意思的一块：51B 参数几乎全砸在一张巨大的 n-gram 查找表上，但它几乎不增加计算量。

2000万

n-gram 词表大小
(bigram/trigram)

51B

n-gram embedding
参数量

ngram_size
(最长 trigram)

注入层
(ple_layer_ids)

机制：把输入里连续的 2~3 个 token 拼成一个 n-gram，用它去索引一张 2000 万行的 embedding 表，取出的向量加进第 2 层的表示。

索引，不是矩阵乘

MoE 扩容量要「路由 + 算专家」，n-gram 扩容量只需一次查表（gather）——计算量几乎为零，参数却能堆到 51B。

易 offload

这张大表访问稀疏（只有出现过的 n-gram 才被取），可以放到 CPU 内存/慢速存储里按需取，对显存受限的加速卡极友好——模型卡明确说这比 MoE 更容易 offload。

heads_per_ngram
=8, split=128

工程细节：每个 n-gram 表项切成 8 个头、词表按 128 分片，兼顾查表效率与分布式存储。

💡 解读：为什么这是「独立的扩展轴」

现代大模型主要靠 MoE 扩参数（容量）和 加长上下文扩能力。N-gram Embedding 提供了第三条正交的轴：用记忆（memorization）换计算。语言里大量高频固定搭配（「机器学习」「与此同时」）本质是可以「背下来」的，与其让每层网络反复算，不如直接查表命中。它把「该记的」从参数里的隐式记忆变成显式查找表——省算、可 offload、且不占激活参数（所以 6B 激活量里不含这 51B）。

07 MoE、MTP 与训练配方

7.1 MoE：512 专家，选 10 路由 + 1 共享

num_experts
=512

每个 MoE 层有 512 个专家（细粒度专家，intermediate 维只有 640，很「瘦」）。

experts_per_tok
=10

每个 token 路由到 10 个专家。

+1 shared

外加 1 个共享专家（所有 token 都过），承接通用能力，让路由专家专注差异化。10+1 是激活的专家数。

aux_loss_coef
=0.001

负载均衡辅助损失系数 0.001，防止专家塌缩（少数专家被抢光）。→ MoE 负载均衡的数学专文

「512 个瘦专家、每 token 选 10+1」是典型的细粒度 MoE：专家越多越小，组合数越大、专精度越高，是 6B 激活量却有 125B 总参的直接原因。

7.2 MTP：多 token 预测

顶部挂一个 1 层的 MTP（Multi-Token Prediction）模块（约 4B 参数，multi-step 训练）。训练时不止预测「下一个 token」，还预测再往后几个，给模型更密的监督信号、提升样本效率；推理时可用作投机解码的草稿头，加速生成。

7.3 训练配方：Muon + AdamW 分工，砍掉 batch warmup

⚙️

Muon + AdamW 按权重分类

不同权重类别用不同优化器：Muon 处理适合它的矩阵参数（更快），AdamW 兜底其余。各取所长最大化效率。→ Muon vs AdamW 专文

🚀

直接从目标 batch size 起步

用重新拟合的 scaling law指导，取消传统的 batch-size warmup，一开始就用目标大 batch。总优化步数大幅减少，还能安全用更大学习率、更稳收敛。

08 评测：6B 激活能打到什么位置

模型卡给出的语言能力横评（对比 Qwen3.8-27B 稠密、Qwen3.7-Plus 397B MoE、DeepSeek-V4-Flash、Claude-Opus-4.6）。Qwen3.8-Flash-Next 只激活 6B，却在多数项领先，尤其 agentic 类。

能力 / Benchmark	Flash-Next (6B act)	Qwen3.8-27B	3.7-Plus (397B)	DS-V4-Flash	Opus-4.6
Agentic coding · DeepSWE 1.1	58.7	42.2	16.5	54.4	—
SWE-bench Pro	62.5	61.7	55.8	56.0	53.4
SWE-bench Multilingual	81.0	73.8	75.8	—	77.5
Long-horizon office · CoWorkBench	73.9	70.7	65.1	45.1	68.2
JobBench（职业任务）	55.7	33.4	27.6	41.3	36.6
Real-world tool use · Toolathlon	73.5	67.1	50.6	70.3	—
指令遵循 · IFBench	81.3	79.5	79.1	79.2	62.5
科学推理 · GPQA Diamond	91.7	89.2	90.3	90.8	91.3
竞赛编程 · LiveCodeBench v6	91.9	90.3	89.6	90.6	88.8
多学科推理 · HLE	35.9	30.8	34.7	33.8	40.0

JobBench（职业任务）· Flash-Next 领先第二名 +14.455.7

Agentic coding DeepSWE · vs 同族 27B 稠密（42.2）58.7

指令遵循 IFBench · 大幅甩开 Opus-4.6（62.5）81.3

⚠ 看这张表要抓的两个「呈现细节」

(1) 激活量不对等。Flash-Next 只激活 6B，对手多是 13B~27B 甚至 397B 总参——「小激活打平大模型」是它的卖点，但也意味着单看某个绝对分数不能直接等同「更强」，要连着激活成本一起看。(2) 评测口径有脚注。SWE-bench 系用 temp=1.0/top_p=0.95/256K harness、HLE 由 GPT-4o 评判、MathVision 修正过标注——横评公平性依赖这些口径一致，脱离脚注比大小会被误导。

09 落地要点与真实反馈

🧠

默认开思考 + 保留思考

默认 thinking mode，且 preserve_thinking=true——保留全对话历史的思考块，利于 agent 决策一致性，还能提升 KV-Cache 复用率。可用 reasoning_effort（xhigh/medium/low）调。

📏

输出长度要给足

官方建议 1M 上下文内：推理内容上限 262K token、最终回答上限 131K token。给足空间才不会在复杂 agent 任务里被截断。

🔧

推理框架

SGLang / vLLM / TokenSpeed 均有官方 recipe。生产/高吞吐强烈建议用专用引擎，而非裸 Transformers。

🎛️

采样参数分两套

思考模式 temp=1.0/top_p=0.95；非思考 temp=0.7/top_p=0.80/presence_penalty=1.5。用错会明显掉效果或语言混杂。

💡 结合我们自己的痛点：QSA 对「可预测 prefill 上界」的意义

QSA 把每 query 的注意力预算钉死在 2048 token（512 块）——无论上下文 10K 还是 1M，主分支精算的 KV 量恒定。这带来一个工程上极有价值的性质：prefill 的注意力算力有一个可预测的上界，不再随上下文平方爆炸。对多轮 agent 请求里 KV-Cache 跨机命中难、请求漂移导致 cache miss 后重算 prefill、TTFT 飙升的问题，这类「预算恒定」的稀疏注意力比全注意力更容易做前缀缓存与路由的容量规划。（此为结合实践的延伸解读，非官方结论。）

⚠ 真实反馈现状：一手评测尚少

截至整理时，Qwen3.8-Flash-Next 作为「Qwen4 预览架构」刚放出，社区（小红书/知乎/Reddit）尚无大量深度实测沉淀，官方也把不少 QSA/训练细节留给了尚未完全公开的技术报告。因此本文以模型卡 + config.json 的一手规格为准，对训练细节（如 indexer 如何反传）明确标注为技术线推断。等技术报告与社区实测出来后，本页会补一节「真实反馈」。