只激活 23B 的稀疏 MoE:省下来的算力到底花在哪
只激活 23B 的稀疏 MoE:省下来的算力到底花在哪
MiniMax-M3.1-Flash 的模型卡里有一句极易被误读的话:总参数约 428B,每 token 激活约 23B。
很多人第一反应是"那我只花了 5% 的算力"。但真把权重、KV Cache、路由、投机解码这几笔账摊开算一遍会发现:23B 省下的是知识容量的成本,不是延迟的成本。这篇文章不谈发布会的跑分,只用仓库里的 config.json、量化配置、DSpark draft 配置和片上文件大小,把这笔账逐项对平,然后回答标题里的问题——省下来的那部分算力,最后都花到哪去了。
一、先看清 23B 这个数字是怎么来的
config.json 里 text_config 的关键字段是这套账的原始凭据:
"hidden_size": 6144,
"intermediate_size": 3072,
"dense_intermediate_size": 12288,
"num_hidden_layers": 60,
"num_local_experts": 128,
"num_experts_per_tok": 4,
"n_shared_experts": 1,
"moe_layer_freq": [0, 0, 0, 1, 1, ..., 1]
逐项手算(配置原文):
| 组件 | 单层参数 | 层数 | 合计 | 每 token 参与 |
|---|---|---|---|---|
| Attention(q/o 各 6144×8192,k/v 各 6144×512) | 106.95M | 60 | 6.42B | 6.42B(全激活) |
| Routed experts(3×6144×3072 × 128) | 7.25B | 57 | 413.1B | 12.91B(4/128) |
| Shared expert(3×6144×3072) | 56.62M | 57 | 3.23B | 3.23B(全激活) |
| Router gate(6144×128) | 0.79M | 57 | 0.045B | 0.045B |
| Dense FFN(3×6144×12288) | 226.5M | 3 | 0.68B | 0.68B(层 0–2) |
| Embedding + lm_head(不共享) | — | — | 2.46B | 查表,不计入 matmul |
把"每 token 参与"一列相加:6.42 + 12.91 + 3.23 + 0.045 + 0.68 = 23.28B。
这就是官方口径 23B 的全部来源——它正好等于"FFN + Attention 的矩阵乘参与量",不含 embedding 与 lm_head。总参数加起来 426.0B,加上 vision_config 那 0.64B 的 CLIP 视觉塔,约 426.6B,与官方 428B 基本对齐(差额来自未计入的 norm、bias 与对齐口径)。
这里第一个容易被忽略的事实:60 层里有 57 层是 MoE,只有前 3 层是稠密。moe_layer_freq 前三个 0 意味着模型在浅层保留了一段稠密 FFN 做通用特征提取,从第 4 层开始才交给 128 选 4 的路由。稀疏不是"整个模型都稀疏",是"深层的表达容量被放大了 128 倍,而每 token 只走 4 条支路"。
二、显存和算力是两本账,第二本账才决定延迟
仓库里 48 个分片文件头部记录的 size 加起来是 250.1 GB。用它反除参数量:250.1 GB / 426.6B ≈ 0.586 字节/参数。
这个数字很关键。如果全模型 FP8,应该是 1 字节/参数;全 BF16 是 2 字节。0.586 只可能来自混合精度。再看 config.json 的 quantization_config:
"quant_method": "mxfp8",
"weight_block_size": [1, 32],
"moe_quant_algo": "NVFP4",
"moe_quant_format": "nvfp4-pack-quantized",
"ignored_layers": ["...block_sparse_moe.gate", "lm_head", "model.embed_tokens",
"multi_modal_projector", "patch_merge_mlp", "vision_tower"]
也就是说:routed experts 走 NVFP4(约 0.5625 字节/参数,含 scale),其余主体走 MXFP8(1 字节/参数)。验算一下:
- 413.1B × 0.5625 ≈ 232.4 GB
- 13.5B × 1 ≈ 13.5 GB
- 合计 ≈ 245.9 GB,与实测 250.1 GB 相差 1.7%(scale 对齐、部分层保留更高精度)
账目对平,说明这不是"宣传性量化",磁盘上的每个字节都对应一种精度策略。
现在算第二本账:单流 decode 时,每生成一个 token 要从 HBM 里搬多少字节?
- routed experts:12.91B × 0.5625 ≈ 7.26 GB
- shared expert + dense FFN + attention + gate:10.37B × 1 ≈ 10.37 GB
- 合计约 17.6 GB/token
按官方"日常 200+ TPS、中位数 170+ TPS"反推:17.6 GB ÷ 5 ms ≈ 3.5 TB/s。这正好是 H800/H100 级 HBM3 的带宽量级。换句话说,M3.1-Flash 的单流 decode 已经贴在内存带宽上限上了,它不是算力不够,是带宽被榨干。这也解释了为什么"输出 200+ TPS"这类指标在实测里经常只有 170 上下——中间差的那部分是路由、all-to-all、KV 读取的额外开销。
由此得到本文第一个结论:
MoE 省下来的是 FLOPs,不是 bytes。 一个 428B 的稠密模型每 token 要读 428B 参数;MoE 只读 23.28B。省掉的 94% 是"知识容量的搬运成本",而你依然要为一个 token 支付 17.6 GB 的带宽。
对比一下同为 23B 激活量的稠密模型(FP8,每 token 读 23 GB):M3.1-Flash 的 17.6 GB 反而更省——但这份优势几乎全部来自 NVFP4 量化,而不是来自稀疏。如果把 routed experts 也放回 FP8,每 token 就是 23 GB,与稠密 23B 完全打平。稀疏真正买到的东西在别处:250 GB 的常驻权重换来 428B 的知识容量,却只付 23B 的带宽。
代价也很直白:显存门槛从 23 GB 涨到 250 GB,约 11 倍。这是稀疏 MoE 最容易被低估的成本。
三、第二笔开销:KV Cache 不吃稀疏的红利
注意力部分只占 6.42B / 23.28B ≈ 28%,看起来无足轻重。但那是权重占比,不是运行时带宽占比。
config.json 里 num_key_value_heads: 4、head_dim: 128、num_hidden_layers: 60,标准 GQA。每 token 每层的 KV 是 2(K 和 V)× 4 × 128 = 1024 个元素,BF16 下 2 KB,60 层合计 120 KB/token。
- 128K 上下文:120 KB × 131072 ≈ 15.7 GB,与 17.6 GB 的权重读取基本持平;
- 1M 上下文:120 KB × 1048576 ≈ 122.9 GB,是权重读取的 7 倍。
也就是说,上下文一旦超过约 15 万 token,decode 的瓶颈就从"读专家权重"切换成"读 KV Cache"。MoE 在前者上省下来的算力,会在这里被原封不动地吃掉。
这正是 sparse_attention_config 存在的意义:
"sparse_topk_blocks": 16,
"sparse_block_size": 128,
"sparse_local_block": 1,
"sparse_index_dim": 128,
"sparse_num_index_heads": 4,
"sparse_score_type": "max",
"sparse_attention_freq": [1, 1, ..., 1]
每个 query 只对 16 个 128-token 的块打分,加上 1 个 local 块,即 2176 个 key。1M 上下文下有 8192 个块,命中率 17/8192 ≈ 0.2%。按此估算,每 token 的 KV 读取从 122.9 GB 降到 2176 × 120 KB ≈ 261 MB,重新回到"权重主导"的区间。
sparse_attention_freq 全为 1、sparse_disable_index_value 全为 1,说明60 层全部启用稀疏注意力——这也是 README 里"sparse attention throughout the model"的技术含义,M3.1-Flash 相对 M3 的第一个改动就是把原本保留全注意力的前 3 层也换成了稀疏。
但必须点破一个残酷事实:MSA 省的是带宽,不是显存。 block-sparse 仍然要存下全部历史 KV,122.9 GB 一个字节都跑不掉。所以 1M 上下文的真实容量规划是 250 GB 权重 + 123 GB KV ≈ 373 GB,至少要 8 张 80 GB 卡才放得下——这也和 FlagOS 部署文档 里 tensor_parallel_size=8 的示例严丝合缝。
还有一个容易被跳过的成本:索引本身。sparse_index_dim=128、sparse_num_index_heads=4,即每个 token 每层有 512 个索引维度,正好是全量 KV(1024 个元素)的一半。要在 1M 上下文里选出 16 个块,索引打分这一趟不可能凭空完成。如果按 token 粒度扫全量,光索引就要读到 61 GB/token,稀疏收益直接归零。因此合理的工程实现只能是在 block 粒度上做池化后的粗粒度打分——sparse_score_type: "max" 与 sparse_block_size: 128 的组合,指向的正是这种"先在块内取 max,再在块间 top-k"的两段式做法(这一点属于对配置语义的推断,仓库未包含 kernel 实现)。README 里"硬件友好算子优化"这句话的分量,就在这里。
四、路由:128 选 4 的代价不在算力,在均衡
MoE 的路由器只有 6144 × 128 ≈ 79 万参数,计算量可以忽略。但它决定了后面 226.5M × 4 的 FFN 算力花在哪个专家上,所以它错了,后面全白算。
config.json 给出的路由设计是这样的:
"scoring_func": "sigmoid",
"use_routing_bias": true,
"routed_scaling_factor": 2.0,
"n_shared_experts": 1
三个细节值得展开:
- sigmoid 而非 softmax。softmax 让所有专家的分数耦合,一个专家涨必然压低其他;sigmoid 独立打分,再用 top-4 截断。这种设计在专家数多(128)时更稳定,但分数不再归一化,所以需要
routed_scaling_factor: 2.0把加权和拉回合理量级。 use_routing_bias: true意味着存在一组可学习(或可统计更新)的偏置项,用来对热门专家做负偏、冷门专家做正偏。这是负载均衡的显式干预手段——说明训练时确实出现过路由塌缩。- 1 个 shared expert 全激活。这是最关键的兜底:无论路由怎么选,每个 token 都会经过一份共享 FFN。它保证了即使 top-4 选错,模型也不会完全丢失通用能力。代价是 3.23B 参数(占激活量的 14%)永远在线。
而在 quantization_config.ignored_layers 里,所有 57 层的 block_sparse_moe.gate 都被排除在量化之外,lm_head、embed_tokens、vision_tower 同样保持高精度。这不是随手写的:gate 的输出要经过 sigmoid 再参与 top-k 排序,量化误差足以让第 4 名和第 5 名互换;而 top-k 是硬截断,排名互换就等于换了一个专家,误差不可微、不可平滑。路由是"知识索引",索引错了,FFN 算得再准也没用。
多模态输入会把这个问题放大。看视觉侧配置:
"patch_size": 14,
"image_size": 672,
"img_token_compression_config": {
"image_token_compression_method": "patch_merge",
"spatial_merge_size": 2,
"temporal_patch_size": 2
},
"image_seq_length": 576
一张图压成 576 个 token,视频再按 temporal_patch_size: 2 做时间维合并(processor 实现 里的 _prune_video_tokens 就是干这个的,它会按帧丢弃视频 token 并同步删掉对应的时间戳文本)。视觉 token 的分布高度同质:一片天空、一页表格的相邻 patch,其隐状态极为接近,路由很容易把成百上千个 token 送进同几个专家。
在单卡上这只是一次不均衡的 FFN 计算;在专家并行(EP)下,它就是 all-to-all 通信的长尾——某个 rank 的专家被塞满,其余 rank 空转等它。这一点在 config.json 里看不到,但在 8 卡部署的实际吞吐曲线上一定看得到。序列越长、多模态占比越高,长尾越明显。
五、DSpark:把省下的算力再"借"出去
M3.1-Flash 的第三个改动是投机解码。dspark/config.json 是一份信息量极大的文件:
"architectures": ["DSparkMiniMaxDraftModel"],
"num_hidden_layers": 5,
"dspark_block_size": 7,
"dspark_target_layer_ids": [3, 17, 31, 45, 59],
"dspark_markov_rank": 256,
"enable_confidence_head": true,
"confidence_head_with_markov": true,
"use_mtp": false,
"num_nextn_predict_layers": 0,
"layer_types": ["sliding_attention", ...],
"sliding_window": 4096
拆开看,这是一个 5 层、滑动窗口 4096 的草稿模型:它从目标模型的第 3、17、31、45、59 层(正好均匀覆盖 60 层)抽取隐状态作为上下文,一次预测 7 个 token(dspark_block_size: 7),再配一个 256 阶的 Markov head 建模相邻 token 的转移,外加一个 confidence head 逐位置估计接受概率。
注意 use_mtp: false、num_nextn_predict_layers: 0——DSpark 完全替代了 MTP,不是叠加。README 里也写明它取代了此前 EAGLE 风格的 MTP 方案。
这份 draft head 的体积是 2.3 GB(dspark 索引文件 的 total_size 为 2301852674)。它带来两个必须计入的成本:
- 显存:2.3 GB 不算多,但它要和 250 GB 权重、123 GB KV 抢同一批卡;
- 算力:投机解码的本质是"用多余的算力换更少的串行步数"。draft 一次猜 7 个,验证时目标模型要对这 7 个位置做一次并行前向。如果接受率低,这 7 份验证算力大部分是白烧的。
这和 MoE 的方向恰好相反:MoE 是"用显存换算力",投机解码是"用算力换延迟"。两者串在一起,才构成了 200+ TPS 这个数字。单独归功于稀疏 MoE 是不准确的。
六、什么场景稀疏真的省,什么场景反而更贵
把上面四本账合起来,可以得到一张相对清晰的判断表。下表中的带宽数字基于 17.6 GB/token 与 3.5 TB/s 的假设推算,用于比较趋势,不代表具体硬件的实测值。
| 场景 | 稀疏 MoE 的实际表现 | 原因 |
|---|---|---|
| 长上下文 prefill(数十万 token 代码库 / 长文档) | 省,但省得有限 | FFN 部分按 23.28B 计,而稠密 428B 要按 428B 计;但 MSA 只优化注意力,FFN 的 2×23.28B×N FLOPs 一分不少。1M prefill 仍是分钟级 |
| 大 batch 高并发 decode | 最省 | 权重只读一遍,batch 内所有请求共享这 17.6 GB;batch 越大,摊销越彻底 |
| 单流低 batch decode | 不比稠密 23B 便宜 | 带宽受限,17.6 GB/token 就是硬成本;优势全靠 NVFP4 |
| 短请求、高频调用 | 偏贵 | prefill 无法摊销,权重 250 GB 常驻却只用一瞬 |
| 显存受限的单机/边缘 | 明显更贵 | 250 GB 权重 + 123 GB KV,8 卡起步 |
| 多模态长视频 | 不确定 | 视觉 token 同质化导致路由倾斜,EP 下长尾明显 |
| 国产卡 W8A8 部署 | 带宽成本回升 | FlagOS 把原始 NVFP4 重量化成 W8A8,experts 从 0.5625 字节/参数回到 1 字节,每 token 读取从 17.6 GB 涨到约 23 GB |
最后一行值得单独说。FlagOS 文档 明确写了 "FlagOS converts and requantizes the model's original QAT NVFP4 weights into W8A8 deployment versions"。这是多芯适配的必然妥协——九家芯片平台的 FP4 支持成熟度不一,W8A8 是最大公约数。但代价是每 token 多读约 30% 的字节,在带宽受限的 decode 阶段直接体现为吞吐下降。同一份模型权重,在不同芯片上的 TPS 差异,很大一部分就来自这里,而不是算力峰值。
七、社区实测里那笔"看不见的账"
技术账算完,还要看真实世界的账。综合各家实测,有三个数据点值得放在一起看:
- 官方口径 200+ TPS,实测中位数 170+ TPS。这个 gap 就是路由、all-to-all、KV 读取、验证失败重算的总和,属于稀疏架构的固定开销。
- 官方称 Agent 任务成本降 70%,第三方测算约 57%(单任务 0.51 → 0.22 美元)。差额来自"回答时倾向消耗更多 token"——第三方明确指出,实际费用取决于具体工作负载。
- 有开发者把两款 Flash 接进 Claude Code 跑同一道接口修复题,结论是速度都"肉眼跟不上",但账单差异主要来自缓存命中率与幻觉返工,而不是单价。
第三点最关键。省下来的算力,最终会以两种形式花回去:
- token 数量:默认开启的深度思考只留
effort一个旋钮(low / medium / high / xhigh / max)。chat_template.jinja 里可以看到,模板本身不设默认档位,只负责把reasoning_effort或effort注入成<effort>...</effort>标签,真正的默认值在服务端。档位越高,思考 token 越多——23B/token 乘以 5 倍 token 数,等于没省。 - 重试次数:第三方在"自信错误 vs 承认不知道"这类基准上观测到约 93% 的非正确回答是错误答案而非弃权。这个数字不能外推成通用准确率,但它提示了一件事:在 Agent 长链路里,一次幻觉的代价是整条链路重跑。
省算力从来不等于省钱。 真正的成本公式是:任务成功所需步数 × 每步 token 数 × 每 token 带宽成本 × (1 + 返工率)。稀疏 MoE 只优化了第三项里的一个因子。
八、给落地时的几个具体数字
如果你准备把这套权重跑起来,下面这些数是从仓库里直接读出来的,可以拿去当容量规划的锚点:
| 项目 | 数值 | 来源 |
|---|---|---|
| 权重总大小 | 250.1 GB(48 分片) | 分片文件 size 累加 |
| 每 token 激活参数 | 23.28B | config.json 手算 |
| 每 token 权重读取 | ≈17.6 GB | 结合 NVFP4/MXFP8 配置 |
| KV Cache | 120 KB/token | 60 层 × 4 KV head × 128 dim × 2B × 2 |
| 1M 上下文 KV | ≈122.9 GB | 同上 |
| KV 追平权重读取的临界长度 | ≈15 万 token | 17.6 GB ÷ 120 KB |
| DSpark draft 额外显存 | 2.3 GB | dspark/model.safetensors.index.json |
| 最小部署规模 | 8 卡 80 GB | 250 GB 权重 + KV,对应 tensor_parallel_size=8 |
部署时还需要注意 max_position_embeddings: 1048576 只是能力上限,不等于推荐值——README 自己写得很清楚:"Usable context length and throughput depend on GPU memory and the serving configuration"。把 max_model_len 从 1M 调到 256K,省下的 92 GB KV 显存可以用来堆 batch,吞吐收益往往比那 75 万 token 的上下文更实在。
回到标题的问题:只激活 23B,省下来的算力到底花在哪了?
它花在了三个地方。第一,花在知识容量上——用 11 倍的常驻显存,换来 18 倍的参数规模,而 decode 时不必付 18 倍的带宽。第二,花在长上下文上——KV Cache 在 15 万 token 之后就成了主要开销,稀疏注意力正是为了把它按回原位而存在,但显存一分没省。第三,花在token 数量上——深度思考、投机验证、幻觉重试,每一个都在把"每 token 便宜"翻译成"每任务未必便宜"。
稀疏 MoE 真正解决的,是"如何让一个 428B 的模型在 8 张卡上以 200 TPS 说话"。它没有、也不可能解决"如何让一次任务更便宜"——那件事取决于你怎么用它。