---
tags: [nanochat, inference, cost, deployment]
阶段: 09-推理Engine与工具
难度: ★★★
created: 2026-10-22
related: "[[KV Cache原理]], [[自回归解码与prefill-decode]], [[CLI与WebUI]], [[成本-延迟-质量权衡]]"
---

# 部署与成本

## 定义

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

$$
\mathrm{MBU}=100\cdot\frac{(w+B\cdot K(T))/\mathrm{TPOT}}{\mathrm{BW}},
$$

其中 $w$ 是权重字节数，$B$ 是批大小，$K(T)$ 是单行在上下文 $T$ 下的缓存读取字节数，$\mathrm{TPOT}$ 是每输出 token 时间，$\mathrm{BW}$ 是峰值带宽。**MFU**（model FLOPs utilization）是实际浮点吞吐与峰值算力之比，在 prefill 阶段使用；它是训练侧 MFU 的推理对应物。

符号在全文保持一致。

| 符号 | 含义 | 单位 |
|---|---|---|
| $P$ | 参数量 | 个 |
| $w$ | 权重按存储 dtype 计的字节数 | 字节 |
| $K_{\text{tok}}$ | 每 token 的 KV 缓存字节数（全部层、单行） | 字节 |
| $K(T)$ | 上下文 $T$ 下单行 decode 读取的缓存字节数 | 字节 |
| $B$ | 批大小 | 条 |
| $T$ | 上下文长度（提示加已生成） | 个 |
| $\mathrm{BW}$ | 峰值显存带宽 | 字节/秒 |
| $F_{\text{peak}}$ | 峰值浮点算力 | FLOP/秒 |
| $p$ | GPU 每卡每小时价格 | 美元/卡·小时 |
| $\mathrm{TPOT}$ | 每输出 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 约 $24/小时、一次 speedrun 约 $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,248 | fp32 | 2,717,908,992 |
| `lm_head` | 50,331,648 | fp32 | 201,326,592 |
| `wte` | 50,331,648 | bf16 | 100,663,296 |
| value embeddings（12 层） | 603,979,776 | bf16 | 1,207,959,552 |
| 门控与标量 | 约 1,802 | fp32 | 约 7,208 |
| 合计 | 1,384,122,122 | 混合 | 4,227,865,640 |

$4{,}227{,}865{,}640$ 字节约 3.94 GiB。若按 $1.384\times10^{9}\times2$ 估算，只有 2.77 GB，低估 1.46 GB；这是 24 GB 卡上最常见的预算错误。

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

$$
K_{\text{tok}}=L\cdot2\cdot H_{kv}\cdot D\cdot s,
$$

d24 代入 $24\times2\times12\times128\times2=147{,}456$ 字节，即 144 KiB。2048 上下文单序列为 $147{,}456\times2048=301{,}989{,}888$ 字节，即 288 MiB。四种深度的容量账如下：权重为 bf16 推理口径，`KV@2048` 是存储口径（$K_{\text{tok}}\cdot2048$），最后一列是 `kv_read_bytes(2048)` 的读取口径，已按 `SSSL` 窗口截断。

| 模型 | 参数量 | 权重 | KV/token | KV@2048 | $K(2048)$ 读取 |
|---|---|---|---|---|---|
| d12 | 286,261,730 | 0.74 GiB | 36,864 B（36 KiB） | 72 MiB | 32 MiB |
| d20 | 896,533,746 | 2.48 GiB | 102,400 B（100 KiB） | 200 MiB | 88 MiB |
| d24 | 1,384,122,122 | 3.94 GiB | 147,456 B（144 KiB） | 288 MiB | 126 MiB |
| d26 | 1,681,786,938 | 4.84 GiB | 173,056 B（169 KiB） | 338 MiB | 153 MiB |

四种深度的 $\mathrm{KV@2048}$ 与读取量来自 `GPT.kv_bytes_per_token()` 与 `GPT.kv_read_bytes(2048)`：前者按存储口径给出全部层、全部位置，后者按 `SSSL` 窗口截断，只统计 decode 真正读取的部分。

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

$$
M_{\text{total}}\approx w+B\cdot K_{\text{tok}}\cdot T+M_{\text{act}}.
$$

容量上限的粗算公式是

$$
B_{\max}\approx\frac{\text{VRAM}-w-\text{reserve}}{K_{\text{tok}}\cdot T},
$$

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

| 模型 | 24 GB | 48 GB | 80 GB |
|---|---|---|---|
| d12 | 302 | 643 | 1098 |
| d20 | 99 | 222 | 386 |
| d24 | 64 | 149 | 263 |
| d26 | 51 | 124 | 221 |

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

### 2 吞吐与 batch：roofline 与 MBU

decode 的单步时间下界是

$$
t_{\text{step}}\ge\frac{w+B\cdot K(T)}{\mathrm{BW}},
$$

吞吐为 $B/t_{\text{step}}$。d24、2048 上下文、H100（$\mathrm{BW}=3.35\times10^{12}$ 字节/秒）、MBU 60% 下：

| $B$ | 单步字节 | TPOT | tok/s | \$/百万 token（$3/卡·小时） |
|---|---|---|---|---|
| 1 | 4.06 GiB | 2.17 ms | 461 | 1.808 |
| 8 | 4.92 GiB | 2.63 ms | 3,043 | 0.274 |
| 32 | 7.88 GiB | 4.21 ms | 7,607 | 0.110 |
| 128 | 19.69 GiB | 10.52 ms | 12,171 | 0.068 |

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

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

$$
\mathrm{MBU}=100\cdot\frac{(w+B K(T))/\mathrm{TPOT}}{\mathrm{BW}}.
$$

`infer_bench` 用 `bytes_per_step = w_bytes + batch_size * kv_read` 与中位 TPOT 计算它；同一段代码还用 $B\cdot F_{\text{decode}}/\mathrm{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`，提示会被夹到 $2048-256=1792$，并打印一条 `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 成本为

$$
\text{\$/token}=\frac{p}{\text{tok/s}\times3600},\qquad
\text{\$/百万 token}=\frac{p}{\text{tok/s}\times3600}\times10^{6}.
$$

README 给出的基准是「约 \$3/GPU·小时，8×H100 约 \$24/小时，2 小时约 \$48；spot 约 \$15」。按 \$3/卡·小时与上表：batch=1 时每百万 token \$1.81，batch=8 时 \$0.27，batch=32 时 \$0.11。把这组数乘以请求量，可以得到量级判断：100 万次请求、每次 256 个输出 token（2.56 亿 token），在 batch=8 下约 \$70；在 batch=1 下约 \$463。预填充的成本另算：1792 token 的 prefill 在 40% MFU 下约 6.98 ms，即每请求 \$5.8×10^{-6}，100 万请求约 \$5.8，相对解码成本很小。

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

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

README 的口径是：2019 年训练 GPT-2 约 \$43,000；当前 8×H100 约 \$24/小时，speedrun 约 1.5 至 2 小时，成本约 \$48，spot 约 \$15；leaderboard 最快 1.65 小时，按 \$3/卡·小时计约 \$40。训练是一次性支出，推理是按请求持续支出，两者不能直接比较绝对值，但可以比较「一次训练的钱能买多少推理」。

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

### 6 部署形态

| 形态 | 并发 | 批处理 | 延迟目标 | 适用场景 |
|---|---|---|---|---|
| 单机 CLI | 1 | `num_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 两列给出；容量按 $T=2048$、`reserve=2 GiB`）。

| GPU | 显存 | 峰值带宽 | d24 可驻留序列 | B=32 上界（100%） | B=32（60% MBU） |
|---|---|---|---|---|---|
| RTX 4090 | 24 GB | 1.01 TB/s | 64 | 3,822 tok/s | 2,293 tok/s |
| L40S | 48 GB | 864 GB/s | 149 | 3,270 tok/s | 1,962 tok/s |
| A100-80G | 80 GB | 2.0 TB/s | 263 | 7,569 tok/s | 4,541 tok/s |
| H100-80G | 80 GB | 3.35 TB/s | 263 | 12,679 tok/s | 7,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 以上，但超过 $B^{*}\approx32$ 后 KV 读取成为主项，吞吐增益递减。若把上下文降到 512，单序列 KV 降到 72 MiB，容量约提高 4 倍；但模型是在 2048 上下文上训练的，短上下文只适合短提示，长文档任务仍应按 2048 预算。

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

| 硬件 | 可跑模型 | 上下文 | 推荐 batch | 依据 |
|---|---|---|---|---|
| RTX 4090 24 GB | d20 宽裕，d24 仅小 batch | 2048 | 8 至 16 | d24 容量上界 64 条，需留激活 |
| L40S 48 GB | d24、d26 | 2048 | 16 至 32 | 容量上界 149/124 条 |
| A100-80G | d24、d26 | 2048 | 32 至 64 | 容量上界 263/221 条，带宽 2.0 TB/s |
| H100-80G | d24、d26 | 2048 | 32 至 64 | 容量上界 263/221 条，带宽 3.35 TB/s |
| CPU / MPS | d12（fp32） | 512 至 2048 | 1 | 无带宽优势，仅用于验证 |

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

### 在 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_bandwidth` | MBU 的分母 | 未知 GPU 返回 `inf`，MBU 显示为 0% |
| `README.md` 的 Time-to-GPT-2 一节 | 价格基准 | 约 \$3/卡·小时、8 卡约 \$24/小时、speedrun 约 \$48、spot 约 \$15 |

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

## 关键直觉

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

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

## 例子与代码

### 例 1：运行 `infer_bench`

```bash
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），一张表头为

```text
 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：成本与容量计算脚本

```python
# 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 上下文序列")
```

预期输出：

```text
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` 化简为 `4*L*D`；`KV_READ` 是 `GPT.kv_read_bytes(2048)` 的返回值，已按 `SSSL` 窗口截断（18 层短窗口 512、6 层全窗口 2048），不是 `KV_TOKEN*2048`。把两者混用会高估 decode 的读取量，从而低估 tok/s。

### 例 3：一次请求的成本拆分

```python
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: $76`。这里 decode 成本按 8 行均摊，即每个请求承担 1/8 的 255 步解码时间；若 batch=1，同一请求的 decode 成本约为 \$4.6×10^{-4}，100 万请求约 \$463。预填充只占约 8%，与「decode 是主要成本」的判断一致。

## 易错点

> [!warning] 常见错误
> 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 卡节点约 \$24/小时当成常数。README 的价格是约 \$3/卡·小时的近似，spot 与不同供应商差别很大；成本表应把单价作为参数，而不是写死结论。

## 关联笔记

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

## 达标检测

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

## 参考来源

- Karpathy, *nanochat* README（commit 92d63d4），Time-to-GPT-2 Leaderboard 一节及开头的成本段 —— \$24/8 卡·小时、\$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 读取量的影响，对应 $K(T)$ 的推导。
- Ainslie et al., *GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints*, arXiv:2305.13245 —— KV 头数对缓存与容量的影响，对应 d24 的 $H_{kv}=H$ 与容量表。
- PyTorch 文档, *torch.cuda*（`max_memory_allocated`、`reset_peak_memory_stats`）—— 对应 `infer_bench` 的峰值显存测量。
