把 36B 塞进 24G 显存的血泪账:显存放下了,吞吐却没了

原创2026-10-25 13:50:031,667 阅读
文章标签:大模型基础模型多模态AI Agent科研

把 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 —— 和上表完全对得上。

这个结构决定了三件事:

  1. 每 token 真正需要的计算只有约 3B 参数(8/256 的专家 + 全部注意力 + 共享专家),所以算力不是瓶颈;
  2. 权重容量是瓶颈,而且是 90% 的"死重";
  3. 正因为死重不在计算路径上,你才有 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),必须把静态区比例顶上去。任何"官方示例里这个数字不一样"的地方,背后都是一次具体的显存预算冲突。

五、把账算准:几个可复用的验收动作

  1. 用启动日志反推,而不是猜。 vLLM 启动时会打印 GPU KV cache size: N tokens。拿 N × 20 KiB 和你的 --max-model-len 一对比,就知道能开几路并发。差得很远就说明权重吃掉了本该给 KV 的空间。
  2. --kv-cache-memory 跳过 profiling。 显存边界已经摸清后,直接指定 KV 字节数可以跳过启动时的显存测量和 CUDA Graph 估算;但值只对同一张卡、同样的初始空闲显存有效,换机器必须去掉重测。
  3. --enforce-eager 当诊断开关。 怀疑 OOM 来自 CUDA Graph 捕获而非权重时,先关图跑一次。能起来,就说明是图的锅,回去调 --gpu-memory-utilization(0.9 → 0.85)或减少 --max-num-seqs。
  4. 对 offload 场景,--max-num-batched-tokens 要往大调。 这一点和在线服务的常规直觉相反,理由在第三节:chunk 越小,专家池被重复扫描的次数越多。
  5. 别把 --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。

算清这个数,再决定买哪张卡、开哪个开关。显存账可以糊弄,带宽账不行。

登录后查看全文
Sage-A1.5