w wyl123ly 的博客
MD

部署与成本

25 KB 2026.10.22 原文件

部署与成本

定义

部署(deployment)是把训练好的检查点放进可执行环境、按请求或按批产出 token,并对显存、延迟与失败率负责的工程过程。推理成本(inference cost)是在给定硬件价格、批大小与上下文长度下,产出单位数量 token 所需的货币量;nanochat 的常用口径是每百万输出 token 的美元数。权重显存(weight memory)是参数按其存储 dtype 占用的显存;KV 显存(KV cache memory)是解码时为每条并发序列保存的键值缓存;MBU(model bandwidth utilization)是解码阶段实际达到的显存带宽与 GPU 峰值带宽之比,定义为

其中 是权重字节数, 是批大小, 是单行在上下文 下的缓存读取字节数, 是每输出 token 时间, 是峰值带宽。MFU(model FLOPs utilization)是实际浮点吞吐与峰值算力之比,在 prefill 阶段使用;它是训练侧 MFU 的推理对应物。

符号在全文保持一致。

符号含义单位
参数量个
权重按存储 dtype 计的字节数字节
每 token 的 KV 缓存字节数(全部层、单行)字节
上下文 下单行 decode 读取的缓存字节数字节
批大小条
上下文长度(提示加已生成)个
峰值显存带宽字节/秒
峰值浮点算力FLOP/秒
GPU 每卡每小时价格美元/卡·小时
每输出 token 时间秒

为什么重要

部署决策只有三个输入:显存能否装下、带宽能跑多快、卡时单价是多少。三者分别对应权重与 KV 的容量账、roofline 的吞吐账与租赁市场的价格账。nanochat 的模型很小,d24 只有 1.38B 参数,权重约 3.94 GiB,单张 24 GB 卡就能装下;但装得下不等于跑得快,也不等于服务得起。若不做容量与吞吐估算,会出现三类具体错误:按「参数乘 2 字节」估权重,低估约 35%,在 24 GB 卡上预留不足而 OOM;按最大 batch 配置并发,忽略预填充临时缓存与激活,实际只能跑一半;按单卡峰值带宽报吞吐,忽略 MBU 只有 50% 至 70%,对外承诺的 tok/s 无法兑现。

scripts/infer_bench.py 把推理代价本身作为评测:它测量 TTFT、TPOT、tok/s、MBU、MFU 与峰值显存,并把架构选择(GQA、sliding window、深度)的影响直接显示在这些数字上。README 给出的成本基准是 8×H100 约 48、spot 约 $15;这些数字只有结合 batch、上下文与利用率才有意义。

在「懂原理、能复现、懂工程」三项中,本篇属于第三项:它把前两篇的生成协议与缓存公式换算成显存、吞吐与美元。通用推理优化手段见 模型推理优化,成本与延迟、质量的权衡方法见 成本-延迟-质量权衡,本篇只算 nanochat 的账。

原理与推导

1 显存账:权重、KV 与激活

权重字节数不等于参数量乘 2。nanochat 的 master 权重以 fp32 保存,Linear.forward 在前向时把权重临时转换为激活 dtype;在 bf16 路径下,embedding 与 value embedding 在初始化时被转换为 COMPUTE_DTYPE 以节省显存。因此 d24 的实际构成是

参数组参数量存储 dtype字节数
Transformer 矩阵(24 层)679,477,248fp322,717,908,992
lm_head50,331,648fp32201,326,592
wte50,331,648bf16100,663,296
value embeddings(12 层)603,979,776bf161,207,959,552
门控与标量约 1,802fp32约 7,208
合计1,384,122,122混合4,227,865,640

字节约 3.94 GiB。若按 估算,只有 2.77 GB,低估 1.46 GB;这是 24 GB 卡上最常见的预算错误。

KV 缓存按 COMPUTE_DTYPE 分配,H100 上为 bf16,每 token 每行的字节数为

d24 代入 字节,即 144 KiB。2048 上下文单序列为 字节,即 288 MiB。四种深度的容量账如下:权重为 bf16 推理口径,KV@2048 是存储口径(),最后一列是 kv_read_bytes(2048) 的读取口径,已按 SSSL 窗口截断。

模型参数量权重KV/tokenKV@2048 读取
d12286,261,7300.74 GiB36,864 B(36 KiB)72 MiB32 MiB
d20896,533,7462.48 GiB102,400 B(100 KiB)200 MiB88 MiB
d241,384,122,1223.94 GiB147,456 B(144 KiB)288 MiB126 MiB
d261,681,786,9384.84 GiB173,056 B(169 KiB)338 MiB153 MiB

四种深度的 与读取量来自 GPT.kv_bytes_per_token() 与 GPT.kv_read_bytes(2048):前者按存储口径给出全部层、全部位置,后者按 SSSL 窗口截断,只统计 decode 真正读取的部分。

除权重与 KV 外,激活也占显存。prefill 的 GPT.forward 会生成形状 的 logits 并转为 fp32,d24、、 时约 MB;decode 每步只生成 , 时约 1 MiB。其余是注意力工作区与 MLP 临时缓冲,通常按 1 至 2 GiB 预留,已包含在下面的 reserve 中。把这三项相加才是单卡可用的显存预算:

容量上限的粗算公式是

其中 reserve 覆盖激活、CUDA 上下文、cuBLAS 工作区与碎片。取 reserve=2 GiB、:

模型24 GB48 GB80 GB
d123026431098
d2099222386
d2464149263
d2651124221

infer_bench 的 max_rows 用 (total_vram - w_bytes) / (kv_store * sequence_len),对 d24、80 GB 得到约 270 行;它没有扣 reserve,因此是上界而非可用值。实际部署应把表中数字再打七折左右,并把预填充阶段那份长度为提示的临时缓存计入瞬时峰值。

2 吞吐与 batch:roofline 与 MBU

decode 的单步时间下界是

吞吐为 。d24、2048 上下文、H100( 字节/秒)、MBU 60% 下:

单步字节TPOTtok/s\3/卡·小时)
14.06 GiB2.17 ms4611.808
84.92 GiB2.63 ms3,0430.274
327.88 GiB4.21 ms7,6070.110
12819.69 GiB10.52 ms12,1710.068

这张表说明三件事。第一,batch 从 1 增到 8,吞吐提高 6.6 倍,而 TPOT 只从 2.17 ms 升到 2.63 ms;权重读取被摊薄,延迟代价很小。第二,batch 超过 后,新增读取主要来自 KV 缓存,吞吐增益递减;表中 32 到 128 吞吐只提高 1.6 倍,TPOT 却翻了 2.5 倍。第三,每百万 token 成本随 batch 单调下降,但下降速度在 之后变缓;部署的合理工作点在延迟约束允许的最大 batch 附近,而不是表中最右列。

MBU 的定义把「实际带宽」与「峰值带宽」放在同一量纲上:

infer_bench 用 bytes_per_step = w_bytes + batch_size * kv_read 与中位 TPOT 计算它;同一段代码还用 计算 decode MFU。小 batch 时 MBU 是主指标(带宽受限);batch 增大时 MFU 随之上升,但 d24 在 128 以内仍以带宽为主,尚未真正进入算力受限区。若 GPU 型号不在 get_peak_bandwidth 的表中,函数返回 inf,MBU 显示为 0%,这不是性能为 0,而是缺少峰值参数。

3 infer_bench.py 的指标与实现

scripts/infer_bench.py 的流程分四段。

静态卡:读取模型配置,计算 weight_bytes、kv_bytes_per_token、kv_read_bytes(context_mid)、batch=1 的 tok/s 上界 peak_bw/(w+kv_read),以及能放进显存的全上下文行数 max_rows。这些数在测量之前打印,用于判断实测值离物理上界有多远。

prefill 测量:用 bench_generate(engine, prompt_tokens, 1, 2, temperature) 先热身一次,再测一次;ttft 是第一次 next() 的耗时(含预填充、缓存复制与首次采样),prefill_tok_per_sec = prompt_len / prefill_time,prefill_mfu = 100 * estimate_prefill_flops(prompt_len) / prefill_time / peak_flops。

batch 扫描:对每个 batch size 先热身,再计时。bench_generate 把第一次 next() 记为 TTFT,后续每次 next() 记为一步;tpot 取 sorted(step_times)[num_steps // 2],即中位数;tok_per_sec = batch_size * num_steps / sum(step_times);mbu 与 mfu 按上一节的公式;peak_vram 来自 torch.cuda.max_memory_allocated。num_steps 等于 decode_tokens - 1 是正常的:第一个 token 已经被计入 TTFT。

机读输出:所有人类可读的卡片与表格之后,最后一行是单行 JSON,字段包括 model_config、weight_bytes、kv_bytes_per_token、kv_read_bytes_per_step、decode_flops_per_token、ceiling_bs1_tok_per_sec、max_full_context_rows、prefill、sweep。脚本消费方式是取 stdout 最后一行做 json.loads。

默认参数是 --prompt-tokens=2048、--decode-tokens=256、--batch-sizes=1,8,32,128、-t 0。由于 sequence_len=2048,提示会被夹到 ,并打印一条 note: clamping prompt to 1792 tokens so prompt+decode fits sequence_len=2048;因此默认运行的 TTFT 是 1792 token 的 prefill,不是 2048。infer_bench 还断言设备为 CUDA 且 ddp_world_size == 1,它是单卡基准,不是多卡吞吐测试。

4 成本模型

GPU 按小时计费,单位 token 成本为

README 给出的基准是「约 \24/小时,2 小时约 \15」。按 \1.81,batch=8 时 \0.11。把这组数乘以请求量,可以得到量级判断:100 万次请求、每次 256 个输出 token(2.56 亿 token),在 batch=8 下约 \463。预填充的成本另算:1792 token 的 prefill 在 40% MFU 下约 6.98 ms,即每请求 \5.8,相对解码成本很小。

上式的分母是「有效吞吐」,它同时包含 batch、MBU 与利用率。低负载时 GPU 空转,实际成本按小时照付,单位 token 成本会远高于表值;因此「每百万 token 成本」必须附带 batch 与利用率假设,否则不可比。spot 价格波动、出口流量、存储与评测脚本的 CPU 开销都不在上式中。

5 训练成本与推理成本的量级

README 的口径是:2019 年训练 GPT-2 约 \24/小时,speedrun 约 1.5 至 2 小时,成本约 \15;leaderboard 最快 1.65 小时,按 \40。训练是一次性支出,推理是按请求持续支出,两者不能直接比较绝对值,但可以比较「一次训练的钱能买多少推理」。

按 batch=8 的 \48 约等于 1.75 亿输出 token;按 batch=32 的 \4\times10^{19}2.56\times10^{8}\times1.59\times10^{9}\approx4.1\times10^{17}$ FLOPs,前者约为后者的 100 倍。算力差 100 倍而成本只差不到 1 倍,原因有两个:训练用 8 张卡并接近算力上界,推理用 1 张卡且受带宽限制;训练只跑一次,推理按请求重复。把这两个量混为一谈,会得出「训练比推理贵 100 倍」或「推理比训练贵」这类互相矛盾的结论。

6 部署形态

形态并发批处理延迟目标适用场景
单机 CLI1num_samples=1交互式,TTFT 与 TPOT 直接可见本地验证、演示、调试
API 服务多会话每请求独立 batch=1,无连续批处理TTFT 与 TPOT 受排队影响小规模内部服务、原型
批处理评测1 至多卡generate_batch,同一提示多采样无延迟目标,追求吞吐HumanEval、GSM8K、pass@k
训练节点8 卡训练 batch不适用speedrun、SFT、RL

nanochat 当前没有请求级调度器:Engine.generate 接受一个提示与 num_samples,把同一提示复制成多行;不同提示不能合并成一批。没有连续批处理、没有 KV 分页、没有抢占。这意味着 API 服务只能靠限流与队列控制并发,无法像 vLLM 一类系统那样把多个会话的 decode 步拼成一批。批量评测则相反,generate_batch 的同一提示多采样正好匹配 pass@k 的需求,是仓库里吞吐最高的用法。

7 硬件与模型可行性

d24 在四种常见卡上的容量与 batch=32 的 decode 上界如下(上界按 100% 带宽与 60% MBU 两列给出;容量按 、reserve=2 GiB)。

GPU显存峰值带宽d24 可驻留序列B=32 上界(100%)B=32(60% MBU)
RTX 409024 GB1.01 TB/s643,822 tok/s2,293 tok/s
L40S48 GB864 GB/s1493,270 tok/s1,962 tok/s
A100-80G80 GB2.0 TB/s2637,569 tok/s4,541 tok/s
H100-80G80 GB3.35 TB/s26312,679 tok/s7,607 tok/s

容量一列是「只放权重与 KV」的上界,实际还要放激活与预填充缓存。24 GB 卡跑 d24、2048 上下文时,64 条序列已经把 18 GiB 的缓存加 3.94 GiB 权重推到 22 GiB,剩余空间很小;更现实的工作点是 batch 8 至 16。48 GB 与 80 GB 卡可以把 batch 推到 32 以上,但超过 后 KV 读取成为主项,吞吐增益递减。若把上下文降到 512,单序列 KV 降到 72 MiB,容量约提高 4 倍;但模型是在 2048 上下文上训练的,短上下文只适合短提示,长文档任务仍应按 2048 预算。

把硬件、可跑模型、上下文与 batch 合并成一张可行性表:

硬件可跑模型上下文推荐 batch依据
RTX 4090 24 GBd20 宽裕,d24 仅小 batch20488 至 16d24 容量上界 64 条,需留激活
L40S 48 GBd24、d26204816 至 32容量上界 149/124 条
A100-80Gd24、d26204832 至 64容量上界 263/221 条,带宽 2.0 TB/s
H100-80Gd24、d26204832 至 64容量上界 263/221 条,带宽 3.35 TB/s
CPU / MPSd12(fp32)512 至 20481无带宽优势,仅用于验证

推荐 batch 不是容量上界,而是「在延迟约束内接近 」的工程取值;表中 H100 与 A100 的 64 已经超过 ,继续增大只对离线吞吐有利。

在 nanochat 中的落地

位置作用关键细节
scripts/infer_bench.py 的 bench_generate测 TTFT、TPOT 与峰值显存第一次 next() 计 TTFT,后续 next() 计步时
同文件的静态卡容量与理论上界weight_bytes、kv_bytes_per_token、max_rows、ceiling_bs1
nanochat/gpt.py 的 estimate__flops、kv__bytes架构成本函数按窗口逐层累加,区分存储与读取口径
nanochat/common.py 的 get_peak_bandwidthMBU 的分母未知 GPU 返回 inf,MBU 显示为 0%
README.md 的 Time-to-GPT-2 一节价格基准约 \24/小时、speedrun 约 \15

部署时唯一需要改动的仓库文件通常不是模型代码,而是启动方式与并发配置:chat_cli 单卡单会话,infer_bench 单卡基准,chat_eval 可多卡但面向离线任务;当前没有请求级服务入口。因此「部署」在本仓库中意味着自建服务层,并复用 Engine、KVCache 与 GPT 的成本函数做容量规划。

关键直觉

机制性直觉

部署成本由三个乘数决定:权重与 KV 决定「一张卡能装多少条」,带宽与 MBU 决定「一条卡每秒能出多少 token」,卡时单价决定「这些 token 值多少钱」。前两个乘数由架构与实现决定,第三个由市场决定;在 d24 这个规模上,权重只有 3.94 GiB,容量通常不是第一约束,带宽与 batch 才是。因此「换更贵的卡」不如「把 batch 提到 附近」有效,除非瓶颈已经转到算力或显存容量。

这一直觉与严格定义的关系:$/百万 token 的定义分母是有效吞吐,而有效吞吐包含利用率;表中的数字都假设 GPU 满载且 MBU 为 60%。真实服务的利用率由请求到达率决定,低负载时按小时计费的成本摊到少量 token 上,单位成本会高于任何表值。

例子与代码

例 1:运行 infer_bench

python -m scripts.infer_bench -i sft -g d24 \
    --prompt-tokens 2048 --decode-tokens 256 --batch-sizes 1,8,32,128 -t 0

预期输出的结构是:一段静态卡(模型、GPU、参数量、权重字节、KV/token、理论 batch=1 上界、max_rows),一行 prefill 结果(tok/s 与 MFU),一张表头为

 batch  TTFT ms  TPOT ms      tok/s   MBU %   MFU %  VRAM GiB  steps

的扫描表,最后一行是单行 JSON。steps 通常等于 255(decode_tokens - 1),若所有行都提前结束则小于 255 并带 (early stop @ N) 备注。TTFT 列在默认参数下对应 1792 token 的提示,脚本会先打印一条 note: clamping prompt to 1792 tokens so prompt+decode fits sequence_len=2048。

例 2:成本与容量计算脚本

# d24、bf16、H100 的容量与成本估算;常量与 repo 的 GPT 配置一致
V, L, D, H = 32768, 24, 1536, 12
KV_TOKEN = L * 2 * H * (D // H) * 2          # 147,456 字节/token
W_BYTES = 4_227_865_640                      # 权重按存储 dtype
KV_READ = 132_120_576                        # 2048 上下文单行读取
BW, PEAK = 3.35e12, 989e12
PRICE, MBU, MFU, CTX = 3.0, 0.6, 0.4, 2048

print(f"KV/token {KV_TOKEN:,} B; 2048 ctx {KV_TOKEN*CTX/2**20:.0f} MiB")
for B in (1, 8, 32, 128):
    bytes_step = W_BYTES + B * KV_READ
    tpot = bytes_step / (MBU * BW)
    tps = B / tpot
    print(f"B={B:3d} TPOT={tpot*1e3:5.2f} ms tok/s={tps:8,.0f} $/M={PRICE/(tps*3600)*1e6:6.3f}")

rows_80 = int((80 - W_BYTES / 2**30 - 2) / (KV_TOKEN * CTX / 2**30))
print(f"80 GB 可驻留约 {rows_80} 条 2048 上下文序列")

预期输出:

KV/token 147,456 B; 2048 ctx 288 MiB
B=  1 TPOT= 2.17 ms tok/s=     461 $/M= 1.808
B=  8 TPOT= 2.63 ms tok/s=   3,043 $/M= 0.274
B= 32 TPOT= 4.21 ms tok/s=   7,607 $/M= 0.110
B=128 TPOT=10.52 ms tok/s=  12,171 $/M= 0.068
80 GB 可驻留约 263 条 2048 上下文序列

脚本里的 KV_TOKEN 用 L 2 H (D // H) 2 化简为 4LD;KV_READ 是 GPT.kv_read_bytes(2048) 的返回值,已按 SSSL 窗口截断(18 层短窗口 512、6 层全窗口 2048),不是 KV_TOKEN*2048。把两者混用会高估 decode 的读取量,从而低估 tok/s。

例 3:一次请求的成本拆分

price = 3.0
ttft = 6.98 / 1000                       # 1792 token prefill,40% MFU
decode_b8 = 255 * (4_227_865_640 + 8 * 132_120_576) / (0.6 * 3.35e12) / 8
print(f"prefill ${ttft/3600*price:.2e}; decode ${decode_b8/3600*price:.2e}")
print(f"1M requests: ${(ttft+decode_b8)/3600*price*1e6:,.0f}")

预期输出为 prefill $5.82e-06; decode $6.98e-05 与 `1M requests: 4.6×10^{-4},100 万请求约 \$463。预填充只占约 8%,与「decode 是主要成本」的判断一致。

易错点

常见错误

1. 用「参数量 × 2 字节」估权重。d24 的矩阵与 lm_head 是 fp32,只有 embedding 与 value embedding 是 bf16;按 2 字节/参数得到 2.77 GB,比实际 4.23 GB 少 35%,24 GB 卡上会因预留不足而 OOM。

2. 假设 KV 缓存总是 bf16。缓存按 COMPUTE_DTYPE 分配;CPU 与 MPS 默认 fp32,每 token 字节数翻倍。用 bf16 的数去估 CPU 部署会低估一倍。

3. 把 max_rows 当成可用并发。infer_bench 的公式没有扣激活、CUDA 上下文与预填充临时缓存;它算出的 270 行是上界,实际应按七折估算,并在压测中验证。

4. 拿不同 dtype 的 MBU 互比,或忽略默认参数的提示夹取。MBU 的分子是「按存储 dtype 计的权重字节」,fp32 部署的 MBU 天然更高;infer_bench 默认 --prompt-tokens=2048 会被夹到 1792,TTFT 与 prefill tok/s 都按 1792 计算,与另一次 2048 提示的测量并列会得到不可比的 MFU。

5. 用平均 step time 代替 TPOT,或把 tok/s 当成有效输出吞吐。脚本取中位数,平均值会被个别抢占、同步或早停的步拉高;某些行提前遇到终止 token 后仍占用 batch 槽位,tok/s 统计的是槽位吞吐,不是「用户实际拿到的 token」。

6. 把 8 卡节点约 \3/卡·小时的近似,spot 与不同供应商差别很大;成本表应把单价作为参数,而不是写死结论。

关联笔记

  • 前置:KV Cache原理 —— 缓存字节公式、kv_bytes_per_token 与 kv_read_bytes 的差异在本篇直接用于容量与成本表。
  • 前置:自回归解码与prefill-decode —— TTFT、TPOT、roofline 与 的定义在本篇换成美元与显存。
  • 对照:CLI与WebUI —— 部署形态与并发上限决定 Web 服务的限流参数;当前 Engine 没有请求级调度器。
  • 后续:跑通speedrun脚本 —— 训练侧的成本与产物是推理侧的前置;speedrun 的 \/百万 token 在本篇对照。
  • 跨库:成本-延迟-质量权衡 —— 用 SLO 反推 batch 与模型规模的通用方法见该篇,本篇只给 nanochat 的数值;分布式训练与部署 讨论多卡与部署的通用形态。

达标检测

  • [ ] 能写出权重、KV、激活三部分显存公式,算出 d24 在 2048 上下文下的 KV/token、单序列 KV 与 80 GB 卡的可驻留序列数,并解释为什么 d24 的权重不是 2.77 GB。
  • [ ] 能写出 MBU 与 MFU 的定义,并用 infer_bench 的公式说明两者分别在哪一阶段使用。
  • [ ] 能解释 的含义,并说明为什么 batch 超过它后吞吐增益递减。
  • [ ] 能由 tok/s 与每卡小时价格算出每百万 token 成本,并说明该数字依赖哪些假设。
  • [ ] 能复述 speedrun 的 \3/卡·小时)与 spot 约 \$15 的来源。
  • [ ] 能比较一次训练与一批推理的算力与成本量级,说明为什么算力差 100 倍而成本差不到 1 倍。
  • [ ] 能指出 infer_bench 的四段输出与 steps=255 的原因,并说明提示被夹取对 TTFT 的影响。
  • [ ] 能给出至少三种部署形态与各自的并发、批处理与延迟特征,指出当前 Engine 缺少请求级调度。

参考来源

  • Karpathy, nanochat README(commit 92d63d4),Time-to-GPT-2 Leaderboard 一节及开头的成本段 —— \48、spot 约 \$15、1.65 小时与 d24 配置的事实来源。
  • Karpathy, nanochat(commit 92d63d4),scripts/infer_bench.py、nanochat/gpt.py 的 estimate_decode_flops、kv_bytes_per_token、kv_read_bytes、nanochat/common.py 的 get_peak_bandwidth —— 本篇全部指标定义、默认参数与硬件表的来源。
  • Dao et al., FlashAttention-3: Fast and Accurate Attention with Asynchrony and Low-precision, arXiv:2407.08608 —— 窗口注意力与缓存原地更新对 decode 读取量的影响,对应 的推导。
  • Ainslie et al., GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints, arXiv:2305.13245 —— KV 头数对缓存与容量的影响,对应 d24 的 与容量表。
  • PyTorch 文档, torch.cuda(max_memory_allocated、reset_peak_memory_stats)—— 对应 infer_bench 的峰值显存测量。