同是14B,显存占用却差一倍:部署实测里的隐形变量
同是14B,显存占用却差一倍:部署实测里的隐形变量
Apple 开源的 FastFrames 在 14B 档位上给出了 45 ms/帧(8×B200)的成绩,但真正值得研究的不是这个数字本身,而是仓库里一个容易被跳过的现象:同一个 14.3B 的 DiT,在同一份代码仓库里同时以 28.58 GB 和 57.15 GB 两种体积存在,比值精确到 2.0。
如果你只按“参数量 × 精度”的粗算去准备显存,或者只按“8 卡就能跑”的经验去申请机器,几乎一定会在这两个数字之间踩坑。这篇文章把 FastFrames-L 的权重账本、KV cache 开销和并行切分代价逐项拆开,给出一份可复核的显存与延迟预算表——所有数字都能用仓库里的文件复算。
一、先把账本摊开:仓库里躺着两组“同架构”权重
fastframes-l-intermediate/ 下有三个中间检查点,对应论文描述的蒸馏管线:causal teacher → consistency distillation → DMD。直觉上它们应该随训练逐步变小或保持稳定,实际情况是:
| 检查点 | 分片数 | metadata.total_size(字节) |
张量数 | 每参数字节 | 等价精度 |
|---|---|---|---|---|---|
causal_teacher |
3 | 57,153,966,336 | 1095 | 4.000 | FP32 |
consistency |
2 | 28,576,983,168 | 1095 | 2.000 | BF16 |
dmd |
3 | 57,153,966,336 | 1095 | 4.000 | FP32 |
三者的网络结构完全一致:40 个 blocks.*,加上 patch_embedding、text_embedding、time_embedding、time_projection、head 共 15 个非 block 张量,总计 1095 个 key。三个 index.json 的 key 集合逐个比对完全相同。
关键证据不在“大小”,而在分片边界的对齐方式:
causal_teacher: 382 + 382 + 331 = 1095
consistency: 764 + 331 = 1095 (764 = 382 + 382)
consistency 只是把前两个分片合并成了一片,尾部那个 331 张量的分片原封不动。这说明切分策略只按张量顺序走,唯一的变量就是每个张量的字宽。更有意思的是 SHA256SUMS 里 causal_teacher 与 dmd 的 model.safetensors.index.json 哈希完全相同(3b3d1858…),即两个检查点的布局描述逐字节一致。
再看部署包:
| 文件 | 字节 | 折合参数(BF16) | 说明 |
|---|---|---|---|
| dit.safetensors | 28,577,096,680 | 14.29 B | 与论文表格 14.3B 吻合 |
| kv_refiner.safetensors | 1,780,342,784 | 890 M | 40 层逐层修复头 |
| pixel_decoder.safetensors | 286,952,688 | 143 M(若 BF16)/71.7 M(若 FP32) | 见下节 |
| 合计 | 30,644,392,152 | — | 30.64 GB(28.54 GiB) |
用 14.29B 参数做标尺反推,部署版 DiT 的 bytes/param 恰好是 2.000,causal_teacher 与 dmd 恰好是 4.000。没有猜测空间:2 倍体积差就是 FP32 与 BF16 的差。
顺带一个工程细节:这些文件在本地是 Git LFS 指针,cat 出来只有 130 多字节。但指针里已经写明了真实 size,因此不拉权重也能完成上面所有核算:
for f in fastframes-l/*.safetensors fastframes-l-intermediate/*/*.safetensors; do
awk '/^size /{printf "%14d %s\n", $2, FILENAME}' "$f"
done
二、精度档位:2 倍不是“差不多”,是恰好 2.000
把 total_size 除以标定出的参数量 14,288,491,584,可以一次性判定所有检查点的落盘精度:
python3 - <<'EOF'
import json
N = 14_288_491_584 # 由部署版 dit 的 size/2 标定
for d in ("causal_teacher", "consistency", "dmd"):
j = json.load(open(f"fastframes-l-intermediate/{d}/model.safetensors.index.json"))
ts = j["metadata"]["total_size"]
print(f"{d:15s} {ts:>14,d} tensors={len(j['weight_map'])} bytes/param={ts/N:.3f}")
EOF
# causal_teacher 57,153,966,336 tensors=1095 bytes/param=4.000
# consistency 28,576,983,168 tensors=1095 bytes/param=2.000
# dmd 57,153,966,336 tensors=1095 bytes/param=4.000
这个结果带来三条部署结论:
第一,纯权重侧就已经跨过了 80 GB 卡的临界线的一半。 BF16 是 30.64 GB,FP32 是 59.22 GB(DiT 翻倍、kv_refiner 与 pixel_decoder 按原精度计)。同一张卡上,前者能和 KV cache 共存,后者不能——后文会算这笔账。
第二,dmd 发布成 FP32 是一个真实的显存陷阱。 想用 DMD 阶段检查点做二次蒸馏或微调的人,下载下来会发现比最终部署包大一倍,且这个差异在文件列表里完全看不出来——ls -lh 只会告诉你“两个 57 GB 的 safetensors”。
第三,文件大小并不总能唯一确定精度。 pixel_decoder.safetensors 是 286,952,688 字节,按 BF16 读是 143.5M 参数,按 FP32 读是 71.7M;论文给的 pixel decoder 规模是 63.87M(1.3B 版),14B 版特征宽度更大,71.7M 更接近合理区间,但这只是推断。唯一可靠的判定是读 safetensors header 里的 dtype 字段,而这一步在 8 字节偏移处就能完成,不需要真正加载张量:
python3 - <<'EOF'
import json, struct
f = "fastframes-l/pixel_decoder.safetensors"
with open(f, "rb") as fh:
n = struct.unpack("<Q", fh.read(8))[0] # header 长度
h = json.loads(fh.read(n))
h.pop("__metadata__", None)
print(len(h), "tensors;", {v["dtype"] for v in h.values()})
EOF
同一段代码对 kv_refiner.safetensors 跑一遍,就能确认 890M 这个数字是否成立。“先看 header,再谈显存”应该成为部署前的固定动作。
三、显存不等于权重:KV cache 是第二个“14B”
FastFrames-L 是自回归模型,每生成一帧都要 attend 全部历史帧,KV cache 是常驻开销而非临时缓冲。用论文给出的稳定态配置复算:
- 每帧 latent token 数:30 × 52 = 1,560
- 21 个 latent 帧 → 32,760 token(论文中 “full KV cache of length 32,760”)
- 40 层,hidden dim 5,120,K 与 V 各存一份,BF16
2 × 40 × 32,760 × 5,120 × 2 B = 26.84 GB (每层 640 MiB)
26.84 GB 的 KV cache,已经接近一份 14.3B 权重的 28.58 GB。 把这两块加到一张卡上:
| 配置(832×480) | 权重 | KV cache | 每卡合计 | 80 GB 卡 | 实测延迟 |
|---|---|---|---|---|---|
| BF16 × 1 卡 | 30.64 | 26.84 | 57.48 | 可以 | 158 ms |
| FP32 × 1 卡 | 59.22 | 26.84 | 86.06 | 放不下 | — |
| BF16 × 1 卡 @720p | 30.64 | 61.93 | 92.58 | 放不下 | — |
| BF16 × 8 卡 CP | 30.64(每卡复制) | 3.35 | 34.00 | 可以 | 45 ms |
| BF16 × 8 卡 CP @720p | 30.64 | 7.74 | 38.39 | 可以 | 116 ms |
这张表解释了标题里的悖论:“同是 14B”这个说法只在参数量维度成立,在显存维度它至少是 57.48 GB 与 86.06 GB 两种东西。 前者能在单张 80 GB 卡上跑出 158 ms,后者连加载都过不去——中间没有调参空间,只有精度选择。
720p 那一行同样值得警惕:token 数从 32,760 涨到 75,600(2.31 倍),KV cache 直接涨到 61.93 GB。论文附录也印证了这一点——720p 下单卡方案不可行,FastFrames-L 在 8 卡上是 116 ms,比 480p 的 45 ms 明显变差。分辨率是比参数量更陡的显存变量,因为它同时放大 KV 长度和注意力计算量。
账本之外还有两块容易被漏掉的开销:一是激活值,论文在训练侧给出的对照很直白——81 帧 832×480、BF16 加 activation checkpointing 时,VAE decoder 单次更新峰值约 68 GB,而替换成 pixel decoder 后约 5 GB;二是文本编码器等第三方权重,Wan2.1 系列的 umT5-XXL 按 BF16 计约 11 GB 量级,需按 README 的 checkpoint 指引单独下载,不在本仓库的核算范围内。把权重、KV、激活、文本编码器四者混在一起谈“14B 要多少显存”,是这类对比最常见的失真来源。
四、并行切分怎么选:只有一种方案真的省钱
论文明确列出了一轮筛选:tensor parallelism、attention-head parallelism、KV sharding、joint query–KV partitioning、context parallelism(CP)全部试过,只有 CP 的通信开销能被计算收益覆盖。原因不难理解——14B 的瓶颈是 DiT 前向本身,而每帧只有 1,560 个 query token,切分权重意味着每层都要做 all-reduce,通信量远超节省的计算。
CP 的做法是把 query token 切到各卡,注意力和 FFN 一起分摊,每层只交换一次算好的 K/V,并用 CUDA graph 兼容的 NVLink symmetric-memory gather 完成交换。效果是 DiT 单次前向从 75.6 ms 降到 20.3 ms。
这里有一个与直觉相反的结论,也是选型时最容易算错的地方:
| 模型 | 单卡 DiT | 8 卡 CP DiT | 加速比 | 并行效率 |
|---|---|---|---|---|
| FastFrames-S(1.3B) | 16.4 ms | 5.8 ms | 2.83× | 35.3% |
| FastFrames-L(14B) | 75.6 ms | 20.3 ms | 3.72× | 46.6% |
14B 的 8 卡扩展效率反而高于 1.3B。 小模型在单卡上就已经被 kernel launch 与调度开销主导,切到 8 卡后固定开销不变、可分摊的计算又少,收益自然被吃掉;14B 是实打实的计算受限,CP 才有空间。所以“小模型多卡更容易扩展”是错的,至少在低延迟、单帧、小 batch 的自回归场景里是错的。
同时必须看清 CP 的内存语义:它切的是 KV 序列,不是权重。 8 卡配置下每张卡仍然持有完整的 30.64 GB 权重,只是 KV 从 26.84 GB 降到 3.35 GB。这正好解释了上面的表——8 卡方案的收益主要在算力和 KV,不在模型体积。如果你的目标只是“让 FP32 权重塞进一张卡”,CP 帮不上忙,只能降精度或改用权重重切分方案并接受通信代价。
五、实测记录与可复现条件
FastFrames-L 的两个关键数字(158 ms 单卡、45 ms 8 卡)可以用一个极简的延迟模型完整复现:两次 DiT 前向 + 一次 KV 修复 + 一次像素解码。
| 组件 | 1×B200 @480p | 8×B200 CP @480p |
|---|---|---|
| DiT 去噪(2 步) | 2 × 75.6 = 151.2 ms | 2 × 20.3 = 40.6 ms |
KV refinement(kv_refiner) |
6 ms | 3 ms |
Pixel decoder(pixel_decoder) |
1 ms | 1 ms |
| 合计 | 158.2 ms | 44.6 ms |
| 论文/README | 158 ms | 45 ms |
误差在 1 ms 以内,说明这条关键路径没有隐藏项。同样的方法可以校验 README 里 FastFrames-S 的分项表:16.1 + 16.2 + 2.2 + 0.9 = 35.4 ms,与 36 ms 的对外口径一致。
反过来,这个模型也给出了硬性预算:50 ms 的交互目标下,两次 DiT 前向必须压进 40 ms 左右,即单次 DiT 前向不能超过 20 ms。8 卡 CP 的 20.3 ms 正好卡在线上——这也解释了为什么 14B 单卡 158 ms 无论如何优化调度都进不了交互区间,它差的不是几个百分点,而是 3.7 倍的算力。
要复现上述数字,这些条件缺一不可,也决定了任何跨来源对比是否有意义:
- batch size = 1,单帧自回归步,不做批内摊销;
- 稳定态、满 KV cache(32,760 token)。这一条最关键:部分工作把整段序列的总时间除以帧数,早期帧因 cache 为空而更快,得到的均值系统性偏低,不能与稳定态数字并列;
- 输出 832×480、81 帧(21 个 latent 帧,按 Wan VAE 约定丢弃前 3 帧);
- BF16 权重、cuDNN attention backend、
torch.compile、CUDA graph; - 硬件为 B200;换到 H100 会整体慢 25%–50%,且各组件比例不完全等比。
仓库里的入口就是 README 给出的两条命令,--gpus 的取值直接对应上表的两种配置:
uv run python evaluation/latency/benchmark.py ff-s
uv run python evaluation/latency/benchmark.py ff-l --gpus 8
这也是本文反复强调的一点:RPS 与 FPS 不可互换。 一个生成单元无论产出几帧都只计一次响应,FastFrames 每步产出 1 个 latent 帧,而 LingBot 每步 4 帧、RealWonder 每步 3 帧,两者的单帧成本与显存曲线形状都不同,横向比较必须先对齐“一个响应”的定义。
六、把隐形变量显式化:一份部署前的检查清单
回到标题里的“差一倍”。在这份仓库里,2 倍差异至少在四个位置各出现了一次,而它们都不是模型本身的变化:
- 落盘精度:
causal_teacher/dmd是 FP32(57.15 GB),consistency与部署版dit是 BF16(28.58 GB),张量数、层数、分片边界全部相同; - KV cache 长度:满 cache 是 26.84 GB,接近第二份权重;分辨率提到 720p 后变成 61.93 GB;
- 切分方式:CP 只切 KV 与计算,权重仍按卡复制,8 卡省下的是 23.5 GB KV 而不是 30 GB 权重;
- 核算边界:激活值、VAE/像素解码器、文本编码器是否计入,能让同一句“14B 需要多少显存”得出相差数十 GB 的答案。
所以一份可执行的部署前检查,顺序应该是固定的:
# 1) 体积:不拉权重,先读 LFS 指针里的真实 size
awk '/^size /{printf "%14d %s\n", $2, FILENAME}' fastframes-l/*.safetensors
# 2) 精度:读 safetensors header 的 dtype,不靠文件大小猜
python3 -c "
import json,struct,sys
f=sys.argv[1]
fh=open(f,'rb'); n=struct.unpack('<Q',fh.read(8))[0]; h=json.loads(fh.read(n))
h.pop('__metadata__',None); print(f, len(h), {v['dtype'] for v in h.values()})
" fastframes-l/dit.safetensors
# 3) 结构:确认张量数与分片布局与预期一致
python3 -c "
import json,collections,sys
j=json.load(open(sys.argv[1]))
print(j['metadata']['total_size'], len(j['weight_map']))
print(collections.Counter(j['weight_map'].values()).most_common())
" fastframes-l-intermediate/dmd/model.safetensors.index.json
三步做完,你会得到一个明确的数字:权重是多少 GB、KV 是多少 GB、这张卡上还剩多少余量。而这些数字里,没有一个能从“14B”这三个字推出来。
FastFrames-L 真正值得借鉴的地方也在这里:它把延迟拆成 KV 更新、去噪、像素渲染三段,逐段替换并公布分项耗时,才让 45 ms 这个结果变得可复算。显存同样应该被这样对待——当有人说“同是 14B,显存差一倍”时,差的从来不是模型,而是那几个没被写进标题的变量。
