把 36B 塞进 24G 显存的血泪账:显存放下了,吞吐却没了
把 36B 塞进 24G 显存的血泪账:显存放下了,吞吐却没了
先看一组仓库里的原始数字。model.safetensors.index.json 的 metadata.total_size 写着 71903645408 字节 —— 换算下来是 66.97 GiB / 71.9 GB 的 BF16 权重,按每参数 2 字节反推约 35.95B 参数,这就是标题里"36B"的来源(README 里叫它 35B 级模型,说的是同一个东西)。
一张 24G 显卡,可用显存约 23 GiB。也就是说,至少 44 GiB 的权重必须住在 HBM 之外,这不是"要不要 offload"的选择题,而是"怎么 offload 才不至于退化成 0.3 token/s"的生存题。
这篇文章不写"三步搞定显存"的爽文。我们把 config.json 逐字段拆开,把每个 token 到底要搬多少字节算清楚,然后你会看到一个很硬的结论:MoE 架构让你"放得下",但也给你的吞吐量钉死了一个由 PCIe 带宽决定的天花板。
一、先把账算清楚:36B 里有 60 GiB 是"不会同时上班"的专家
从 config.json 里能读出这台机器的全部骨架:
| 字段 | 值 | 含义 |
|---|---|---|
num_hidden_layers |
40 | 总层数 |
layer_types |
30 × linear_attention + 10 × full_attention |
混合注意力,每 4 层一个全注意力 |
num_experts / num_experts_per_tok |
256 / 8 | 每层 256 个专家,每 token 激活 8 个 |
moe_intermediate_size |
512 | 单个专家的中间维度 |
shared_expert_intermediate_size |
512 | 每层共享专家 |
hidden_size |
2048 | 主干维度 |
num_key_value_heads / head_dim |
2 / 256 | 全注意力层的 KV 极窄 |
vocab_size |
248320 | 词表 |
mtp_num_hidden_layers |
1 | 多 token 预测头,单独一个分片 |
按这些字段把权重逐项乘出来,结果非常偏科:
| 组成 | 参数量 | 大小(BF16) | 占总量 |
|---|---|---|---|
| 256 个专家 × 40 层 | 32.2B | 60.0 GiB | 约 90% |
| 注意力(30 层线性 + 10 层全注意力) | 1.54B | 2.86 GiB | 4.3% |
embed_tokens + lm_head(不共享) |
1.02B | 1.89 GiB | 2.8% |
| 共享专家 + 路由 gate | 0.15B | 0.27 GiB | 0.4% |
| 视觉塔(27 层 ViT) | ~0.44B | 0.82 GiB | 1.2% |
MTP 层(model-mtp.safetensors,1.57 GiB) |
— | 1.57 GiB | 2.3% |
对照文件系统里的真相:14 个主分片每个 size 5368997288 字节(5.00 GiB),最后一个 0.40 GiB,加上 MTP 的 1.57 GiB,合计 66.97 GiB —— 和上表完全对得上。
这个结构决定了三件事:
- 每 token 真正需要的计算只有约 3B 参数(8/256 的专家 + 全部注意力 + 共享专家),所以算力不是瓶颈;
- 权重容量是瓶颈,而且是 90% 的"死重";
- 正因为死重不在计算路径上,你才有 24G 跑 36B 的可能 —— 换成同规模的稠密模型,这条路根本不存在。
二、真正吃掉显存的三个隐形项
社区里讲显存优化的文章,通常把"权重、KV Cache、激活"并列。放到 Sage-A1.5 这个具体结构上,优先级要重排。
2.1 第一位不是 KV,是那 240 个不干活的专家
单层的专家参数量是 3 × hidden × moe_inter × 256 = 805M,而单层注意力只有 27M(全注意力层)到 42M(线性注意力层)。专家占单层参数的 94.6%。
所以 24G 场景下的显存账本长这样:注意力 + Embedding + 共享专家可以老实待在卡上,一共约 5.1 GiB;60 GiB 的专家银行必须挪到 CPU 内存或 NVMe。"把 36B 塞进 24G"的本质,是把 90% 的参数赶出 HBM,然后祈祷它们搬回来的速度够快。
顺带一个容易踩的坑:这 60 GiB 要住在主机内存里,因此你的机器至少需要 64 GB RAM。只盯着显卡型号买机器,是这条路上最常见的第一滴血。
2.2 KV 缓存:这一次,架构帮了大忙
经典的 KV 公式是 2 × layers × kv_heads × head_dim × bytes × seq_len。代入这个模型,但注意只有 10 层是全注意力:
- 单 token 的 KV 字节数 = 2(K/V)× 2(KV 头)× 256(head_dim)× 2(字节)× 10 层 = 20,480 B ≈ 20 KiB
- 256K 上下文单序列:
20 KiB × 262144= 5.0 GiB - 若 40 层全是全注意力:同样上下文要 20 GiB
也就是说,full_attention_interval: 4 这个配置直接帮你省掉了 15 GiB KV。README 里 --max-model-len 262144 敢在单卡上喊出来,靠的就是这个。
再叠加 --kv-cache-dtype fp8,20 KiB/token 变 10 KiB/token,256K 单序列只要 2.5 GiB。这是 24G 卡上最便宜、最不伤精度的显存操作之一(注意力本身仍是 BF16 计算,只有缓存被压)。
2.3 线性注意力状态:一个和上下文长度无关的固定开销
30 层线性注意力(in_proj_qkv / in_proj_z / in_proj_a / in_proj_b / conv1d / out_proj)不产生随序列增长的 KV,它维护的是一个固定大小的递归状态:
- 每层状态 =
linear_num_value_heads × linear_key_head_dim × linear_value_head_dim= 32 × 128 × 128 ≈ 524K 个元素 mamba_ssm_dtype: float32→ 每层 2 MiB,30 层 ≈ 60 MiB/序列
有趣的交叉点:60 MiB ÷ 20 KiB/token ≈ 3,000 token。序列短于 3K 时,这套混合架构的状态开销反而比纯 KV 更大;超过 3K 之后一路碾压。这就是长上下文模型敢于把 max_position_embeddings 设成 262144 的底气。
它还有个隐性代价:这 60 MiB 是 fp32 的,不受 --kv-cache-dtype 影响。并发数上去之后(比如 64 路),仅状态就是 3.8 GiB —— 在 24G 卡上,这是会让你在深夜盯着 OOM 报错发呆的第三个隐形项。
2.4 两个"纯可选"开销:视觉塔与 MTP
- 视觉塔 0.82 GiB:仓库里
model-00013-of-00014.safetensors只有 0.40 GiB,装的就是它。如果你是纯文本/Agent 工具调用场景,README 给了现成开关:--language-model-only,白赚 0.8 GiB。 - MTP 1.57 GiB:
model-mtp.safetensors单独一个分片、785 个张量,里面是一整层 256 专家的 MoE。开投机解码(--speculative-config '{"method":"mtp","num_speculative_tokens":3,...}')就要多背这 1.5 GiB 权重,外加草稿 token 的临时 KV。在 24G 预算里,这 1.5 GiB 往往就是 OOM 与不 OOM 的分界线。
2.5 激活与预分配:最容易被误判的"泄漏"
--max-num-batched-tokens直接决定 prefill 阶段的峰值激活。全注意力层在 8K chunk 上如果朴素地物化注意力矩阵,单层就是16 × 8192 × 8192 × 2B = 2 GiB;真正跑起来靠的是 FlashAttention 类 kernel 把它压成小块,但线性注意力的 chunk 缓冲、MoE 的 token 重排缓冲依然随 chunk 线性增长。- vLLM 的
--gpu-memory-utilization(默认 0.9)在启动时就把 21.6 GiB 全部预占,随后 CUDA Graph 捕获还要再要一块。你会看到"权重明明只有 5 GiB,为什么显存没了" —— 那不是泄漏,是预分配 + graph。 - 想省出这 1~2 GiB:
--enforce-eager(牺牲稳态 decode 性能)或把--gpu-memory-utilization调到 0.85,再用启动日志里那行 KV cache 大小反推真实余量。
三、Offload 之后,每 token 要搬多少字节
这是全文的核心公式。decode 阶段是访存受限的,所以延迟近似等于"本 token 需要的新权重字节数 ÷ 有效带宽"。
每 token 激活的专家权重:
- 单层 = 8 个专家 × 3(gate/up/down)× 2048 × 512 × 2 字节 = 50.3 MB
- 40 层 = 2.01 GB/token
于是不同互连下的天花板(按有效带宽估算,非实测):
| 方案 | 每 token 搬运量 | 有效带宽假设 | 延迟上限 | 聚合吞吐上限 |
|---|---|---|---|---|
| BF16 专家在 CPU 内存,PCIe 4.0 x16 | 2.01 GB | ~22 GB/s | ~91 ms | ~11 token/s |
| BF16 专家在 CPU 内存,PCIe 5.0 x16 | 2.01 GB | ~45 GB/s | ~45 ms | ~22 token/s |
| W4 专家在 CPU 内存,PCIe 4.0 | ~0.53 GB | ~22 GB/s | ~24 ms | ~41 token/s |
| BF16 专家在 NVMe Gen4 | 2.01 GB | ~6 GB/s | ~335 ms | ~3 token/s |
| 层粒度换入(读回整个 expert bank) | 66.97 GiB | ~22 GB/s | ~3.3 s | ~0.3 token/s |
最后一行是"血泪账"的真正来源。同样是 offload,粒度差一个数量级,性能差两个数量级。
vLLM 的 --cpu-offload-gb 走的是模块/层粒度的换入换出(思路与流水线并行同源),对稠密模型没问题;但对 MoE,一个 MoE 模块里躺着 256 个专家,按模块换入就等于每个 token 把 60 GiB 专家全读一遍。这就是为什么很多人在 24G 卡上试完 --cpu-offload-gb 后得出"vLLM 不能跑这个模型"的结论 —— 不是不能跑,是粒度不对。
真正需要的是专家级选择性加载:先算路由,再只取 top-8 的权重(llama.cpp 系的 --n-cpu-moe 就是这一类,ktransformers 亦然)。而"专家级"这三个字,正是 11 token/s 和 0.3 token/s 的分水岭。
并发救不了你
很多人第一反应是:那就堆 batch,用并发摊薄搬运成本。可以摊,但摊得很有限。同一层内,B 个 token 各选 8 个专家,去重后的专家数期望是 256 × (1 - (1 - 8/256)^B):
| batch | 触碰的专家数 | 每 token 平均专家数 | 相对 B=1 的节省 |
|---|---|---|---|
| 1 | 8 | 8.0 | — |
| 4 | 30.5 | 7.6 | 5% |
| 8 | 57.4 | 7.2 | 10% |
| 16 | 102 | 6.4 | 21% |
| 32 | 163 | 5.1 | 36% |
B=32 才省 36% 的带宽,而单路速度已经掉到 0.5 token/s 量级。MoE 的 offload 吞吐上限约等于 带宽 ÷ 每 token 激活专家字节数,它几乎不随并发增长。 这就是"显存放下了,吞吐却没了"的数学表达 —— 不是配置没调好,是物理定律。
唯一的例外是时间局部性:同一批请求如果高度同质(同一份文档反复问答、同一类代码补全),专家命中会高度重复,LRU 专家缓存能显著抬高命中率。这也是为什么"24G 跑 36B"的 demo 视频看起来很美 —— 它们往往是单条、短、同质的 prompt。
prefill 是另一回事,而且更反直觉
8K token 的 prefill 会几乎触碰全部 256 个专家(8192 × top-8 足以覆盖整个专家池),搬一次就是 60 GiB ≈ 2.7 秒。这换来的是 8K token 的首 token 延迟,可以接受。
但如果你为了优化 ITL 把 --max-num-batched-tokens 从 8192 调到 2048(这是在线服务的常规做法),prefill 被切成 4 块,每一块都要近乎重新扫一遍专家池,专家流量直接 ×4。在 offload 场景下,"小 chunk 更平滑"这条经验是反的:chunk 越大,每个字节的专家权重摊到的 token 越多。 这是 offload 部署里最容易被忽略的一个调参反向操作。
四、三档预算下的可用方案
前面算清了账,下面按预算给结论。所有配置都基于仓库 README 里已验证的启动方式。
24G:不改精度只能"半身入土",改精度才是正解
路线 A(推荐):注意力在卡、专家在内存、专家做 W4
- GPU:注意力 2.86 GiB + Embedding/lm_head 1.89 GiB + 共享专家 0.27 GiB + 激活/graph ≈ 5.5~7 GiB
- 主机内存:W4 量化后的专家 ≈ 60 GiB ÷ 4 × 1.06(scale/zero point)≈ 16 GiB
- 剩余显存 ~16 GiB:够 256K 单序列(5 GiB KV)+ 2~3 路并发;开
--kv-cache-dtype fp8可到 5~6 路 - 期望吞吐:按上表 ~40 token/s 量级(需自测)
有一条纪律:只量化 MoE 的专家,linear_attn 和全注意力保持 BF16。 30 层线性注意力的 conv1d / A_log / dt_bias 是递归状态的一部分,量化误差会在 262144 长度的递归里被放大;而且新架构的量化 kernel 适配往往滞后,贸然全模型 W4 很容易得到一个"能跑但胡言乱语"的模型。
路线 B:全模型 W4 上卡
专家 W4 + 其余 BF16 ≈ 15 + 5.5 = 20.5 GiB,勉强塞进 24G,KV 只剩 2 GiB 左右(约 100K token 的聚合预算)。单路 256K 上下文直接放弃,--max-model-len 老实降到 65536。
路线 C:纯 offload,不改精度
就是前面那个 11 token/s 的配置。它适合验证模型能力、跑评测、写技术报告;不适合任何有并发概念的服务。如果你的目标是"能对外提供服务",请直接跳到路线 A。
一个必做的减法:--language-model-only。0.82 GiB 在 24G 上是 3.5% 的显存,够多放 40K token 的 KV。
48G:最大的错觉是"两张 24G 就够了"
先把结论放在最前面:BF16 权重 66.97 GiB,两张 24G(48 GiB)放不下;单张 48G 也放不下。 这不是差一点,是差 19 GiB。
| 形态 | BF16 每卡权重 | 是否可行 | 建议 |
|---|---|---|---|
| 单卡 48G | 66.97 GiB | ❌ | 必须 FP8 或 W4 |
| 2 × 24G,TP=2 | 33.5 GiB/卡 | ❌(>24 GiB) | 必须 FP8 或 W4 |
| 4 × 24G,TP=4 | 16.75 GiB/卡 | ✅ | 但 KV 头只有 2,见下 |
| 单卡 48G + FP8 | 33.5 GiB | ✅ | 余 ~12 GiB → 约 600K token KV |
| 单卡 48G + W4 | ~17 GiB | ✅ | 余 ~29 GiB,最宽裕 |
48G 单卡是最舒服的一档:FP8 权重 33.5 GiB,剩下 12 GiB 全部给 KV 和并发,没有任何 offload,吞吐回到正常水平。如果 FP8 kernel 对 linear_attn 的支持还没跟上,退一步用 W4 专家 + BF16 注意力,余量更大。
单机多卡:TP 只能到 2,真正的解是 EP
这里有个必须点破的架构约束:num_key_value_heads = 2。张量并行要求 KV 头能被 TP 度数整除,TP=4 意味着 KV 头要被复制 2 份,显存和带宽都白白浪费;线性注意力的 linear_num_key_heads = 16 / linear_num_value_heads = 32 稍微宽松,但也撑不住任意切分。
所以 4~8 卡的机器上:
- 优先
--tensor-parallel-size 2,把 KV 切干净; - 剩下的并行度交给 专家并行:
--enable-expert-parallel,256 个专家能被 8 / 16 整除,每个 rank 分到 32 / 16 个专家,卡上权重直接按专家数均分,注意力部分复制。对"90% 参数是专家"的模型来说,这才是对症下药。 - 再往上一层是 DP:模型副本各自独立跑请求,适合多用户吞吐型服务,代价是每份副本都要完整权重。
- 单机放不下时用 PP:按层切(40 层 / PP=2 → 20 层一 stage),KV 也跟着按层分片,通信量比 TP 小,代价是流水线气泡。
还有一个容易被忽略的信号:README 里 512K 上下文的 SGLang 示例把 --mem-fraction-static 从 0.8 提到 0.88。这不是"调大点更好",而是说明 0.8 时 KV 池不够 524288 token(512K × 20 KiB = 10 GiB),必须把静态区比例顶上去。任何"官方示例里这个数字不一样"的地方,背后都是一次具体的显存预算冲突。
五、把账算准:几个可复用的验收动作
- 用启动日志反推,而不是猜。 vLLM 启动时会打印
GPU KV cache size: N tokens。拿N × 20 KiB和你的--max-model-len一对比,就知道能开几路并发。差得很远就说明权重吃掉了本该给 KV 的空间。 --kv-cache-memory跳过 profiling。 显存边界已经摸清后,直接指定 KV 字节数可以跳过启动时的显存测量和 CUDA Graph 估算;但值只对同一张卡、同样的初始空闲显存有效,换机器必须去掉重测。--enforce-eager当诊断开关。 怀疑 OOM 来自 CUDA Graph 捕获而非权重时,先关图跑一次。能起来,就说明是图的锅,回去调--gpu-memory-utilization(0.9 → 0.85)或减少--max-num-seqs。- 对 offload 场景,
--max-num-batched-tokens要往大调。 这一点和在线服务的常规直觉相反,理由在第三节:chunk 越小,专家池被重复扫描的次数越多。 - 别把
--cpu-offload-gb当万能钥匙。 它是层/模块粒度;MoE 模型上请优先选择专家粒度的 offload 实现,或者干脆走"量化到能上卡"这条更直白的路。
最后回到那句总结:36B 塞进 24G,技术上是成立的,代价是把显存瓶颈换成了 PCIe 瓶颈。 显存是"容量问题",可以靠 offload 和量化骗过去;吞吐是"带宽问题",骗不过去。真正决定你能不能在 24G 上跑这个模型的,不是它有多少参数,而是每 token 需要搬多少字节的激活专家:这个数字是 2.01 GB,还是 0.53 GB,还是 66.97 GiB,直接决定了你拿到的是 11 token/s、41 token/s,还是 0.3 token/s。
算清这个数,再决定买哪张卡、开哪个开关。显存账可以糊弄,带宽账不行。