只激活 23B 的稀疏 MoE:省下来的算力到底花在哪

原创2026-10-23 20:15:411,831 阅读
文章标签:人工智能大模型多模态基础模型代码模型本地部署

只激活 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

三个细节值得展开:

  1. sigmoid 而非 softmax。softmax 让所有专家的分数耦合,一个专家涨必然压低其他;sigmoid 独立打分,再用 top-4 截断。这种设计在专家数多(128)时更稳定,但分数不再归一化,所以需要 routed_scaling_factor: 2.0 把加权和拉回合理量级。
  2. use_routing_bias: true 意味着存在一组可学习(或可统计更新)的偏置项,用来对热门专家做负偏、冷门专家做正偏。这是负载均衡的显式干预手段——说明训练时确实出现过路由塌缩。
  3. 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 差异,很大一部分就来自这里,而不是算力峰值。

七、社区实测里那笔"看不见的账"

技术账算完,还要看真实世界的账。综合各家实测,有三个数据点值得放在一起看:

  1. 官方口径 200+ TPS,实测中位数 170+ TPS。这个 gap 就是路由、all-to-all、KV 读取、验证失败重算的总和,属于稀疏架构的固定开销。
  2. 官方称 Agent 任务成本降 70%,第三方测算约 57%(单任务 0.51 → 0.22 美元)。差额来自"回答时倾向消耗更多 token"——第三方明确指出,实际费用取决于具体工作负载。
  3. 有开发者把两款 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 说话"。它没有、也不可能解决"如何让一次任务更便宜"——那件事取决于你怎么用它。

登录后查看全文
MiniMax-M3.1-Flash