同是14B,显存占用却差一倍:部署实测里的隐形变量

原创2026-11-19 10:20:2413 阅读
文章标签:人工智能深度学习媒体生成视频基础模型

同是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 长度和注意力计算量。

FastFrames 交互演示:左侧为官方实现,右侧为应用 FastFrames 优化后的同一模型,同一输入下的响应延迟差异

账本之外还有两块容易被漏掉的开销:一是激活值,论文在训练侧给出的对照很直白——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 倍差异至少在四个位置各出现了一次,而它们都不是模型本身的变化:

  1. 落盘精度:causal_teacher / dmd 是 FP32(57.15 GB),consistency 与部署版 dit 是 BF16(28.58 GB),张量数、层数、分片边界全部相同;
  2. KV cache 长度:满 cache 是 26.84 GB,接近第二份权重;分辨率提到 720p 后变成 61.93 GB;
  3. 切分方式:CP 只切 KV 与计算,权重仍按卡复制,8 卡省下的是 23.5 GB KV 而不是 30 GB 权重;
  4. 核算边界:激活值、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,显存差一倍”时,差的从来不是模型,而是那几个没被写进标题的变量。

登录后查看全文
FastFrames-L