现代 AI 加速器 GPU / TPU 系统课程 / 主线 / 专题六 / 推理 🌐 English

推理

训练一步算一大批,推理一步只出一个字。
decode 每一步都要把权重和 KV 搬一趟。推理的每一招,要么让这一趟分给更多人,要么干脆少搬。
前置 专题三(KV cache)专题五(并行) 口径 截至 2026-10 ⏱ 讲约 90 分钟 📖 想深挖:完整版(L300)

课程作者 Chris Yang·Google Cloud AI Infra 架构师

第 零 节

推理为什么贵?这几年又是怎么一步步变便宜的?

🎯 开场热身:五种并行,各自要用哪几种集合通信? —— 回顾专题五,课上一起点开(课前勿点)。不做也不影响这一讲

每一行勾上这种并行训练一步里要用到的通信,可以勾不止一个。五行都勾完再点「对答案」。

并行方式AllReduceAllGatherReduceScatterAllToAll一对一收发
DP 数据并行每张卡一份完整模型,各吃一份数据
FSDP(ZeRO-3)权重、梯度、优化器状态全切开
TP 张量并行一层里的矩阵切给几张卡
PP 流水线并行按层切成几段 stage
EP 专家并行MoE 的专家分到不同卡

训练一步算一大批,推理得一个字一个字往外吐。 贵就贵在:每吐一个字,都要把整车货从显存里搬一趟。

用户只等两个数:第一个字,之后每个字

一个请求的一生 —— 一大块 prefill,接一长串一步一字的 decode 示意时间线,格子长短不按比例。上:在做什么、何时出字;中:显存里的 KV 有多长;下:decode 每一步要从显存读什么 prefill:整段 prompt 一次算完 decode:一步出一个字 权重 KV cache 从进门到结束 在做什么 何时出字 排队 prefill 整段 prompt 一次算完 第 1 步 第 2 步 第 3 步 第 4 步 第 5 步 第 6 步 第 7 步 第 8 步 字 1 字 2 字 3 字 4 字 5 字 6 字 7 字 8 结束 请求进门 TTFT:进门到第一个字(含排队) TPOT:平均每字间隔 显存里的 KV 有多长 prefill 一次写满整段 prompt 的 KV decode 每出一个字,KV 长一格 每一步 从显存读什么 权重:每步读一遍 KV:每步全部 两段的账正好相反 prefill 读一遍权重,分给整段 prompt 的几千个 token 一起算:卡在算力上。 decode 读一遍权重和全部 KV,只出一个字:卡在显存带宽上,而且字越往后 KV 越长、这一趟越重。
先指红点,再看一串绿格:每格出一个字、权重读一遍,紫色阶梯每步都在长。
示意时间线,长短不按比例。
出处与口径

⚠️ 示意时间线:格子长短不按比例,prompt 画成 6 格 KV、decode 画 8 步,都是为了看得清。

📌 TTFT、TPOT 的定义按 vLLM 的 benchmark_serving:TTFT 从请求发出算到第一个输出 token,TPOT 是除第一个 token 外平均每个输出 token 的时间。第二节会细讲它们的口径(含不含排队、平均还是 p99)。

⚠️ 「第一个字由 prefill 产出」是标准实现:prefill 的最后一个位置直接给出第一个输出 token 的分布。

贵在哪:每出一个字,整车货搬一趟

全课一句话 decode 每一步都要把权重和 KV 搬一趟。推理的每一招,要么让这一趟分给更多人,要么干脆少搬。
还有一类不碰这一趟:把两种活拆开,各放合适的机器。

四年怎么变便宜:每一招补一个洞,又留下一个

问题链 —— 十三招各是哪年冒出来的 点落在首次公开的那一年(⑫⑬ 思路更早,落在进入主流大模型那年),年内只排先后;「→」是一直做到哪年;圈里是环号 系统侧 空心:模型侧 外力:上下文变长 外力:输出变长 2022 2023 2024 2025 2026 上下文变长 128K 1M 输出变长 o1 R1 2022 Orca 连续批 ① 2022 →2026 GPTQ 量化 ② 2022 →2025 投机解码 ③ 2023 →2025 GQA 压薄 KV ④ 2023 PagedAttention ⑤ 2023 分块 prefill ⑥ 2023 →2025 PD 分离 ⑦ 2023 RadixAttention ⑧ 2024 →2025 KV 分层下放 ⑨ 2024 →2025 切序列 CP ⑩ 2024 →2025 MoE 大 EP ⑪ 2025 →2026 线性注意力混合 ⑫ 2026 循环模型 ⑬
每一环讲什么,看下表。
每招省了多少、对谁比,见完整版第零节。
出处与口径

首次公开:Orca OSDI'22;GPTQ arXiv 2210.17323;投机解码 Leviathan 等 arXiv 2211.17192;GQA arXiv 2305.13245;PagedAttention 博客 2023-06-20;Splitwise arXiv 2311.18677;RadixAttention arXiv 2312.07104;SARATHI arXiv 2308.16369;Mooncake arXiv 2407.00079;Meta 上下文并行 arXiv 2411.01783;SGLang v0.4 博客 2024-12-04(DP attention)、DeepSeek-V3 arXiv 2412.19437;⑫ Qwen3-Next 博客 2025-09-10(更早:H3 arXiv 2212.14052、Jamba 2403.19887);⑬ Koi-4B arXiv 2610.12582、NVIDIA-Nemotron-Labs-Dory1.0-4B 2026-10-16(更早:Universal Transformers arXiv 1807.03819)。末年:DeepSeek-V3.2-Exp 技术报告(DSA,2025-09);SGLang HiCache 博客 2025-09-10;NVIDIA Dynamo 新闻稿 2025-03-18;SGLang 大 EP 博客 2025-05-05;vLLM v0.10.2 release(DCP,2025-09);EAGLE-3 arXiv 2503.01840;Inferact TPU megakernel 博客 2026-09、vLLM DeepSeek-V4.1-Flash 博客 2026-10-07(FP4 KV)。外力:OpenAI DevDay 2023-11-06、Google 2024-02-15;OpenAI 2024-09-12、DeepSeek-R1 arXiv 2501.12948。年内等距排,只表先后。

首次公开卡在哪怎么解又留下什么节
2022整批人陪最慢的写完连续批:每步都能上下车座位归 KV 管,KV 按最长预留二
2023–2024KV 白占显存、每行太厚分页;GQA、MLA 压薄;相同开头不重算上下文越来越长三
2024–2025MoE 把人拆散到几百个专家DEP + 大 EP:专家铺满上百张卡每卡自备状态,长上下文 KV 被复制四
2024–2025长上下文 KV 放不下、首字慢DCP/PCP:按序列切只在长上下文划算五
2023–2025长 prompt 卡住正在出字的人PD 分离:两种活分开放每个请求多搬一趟 KV六
2022–2025思考模型一题几千字,一趟一个字投机解码:一趟验好几个字人多时缩水七
2022–2026能省的只剩字节FP8、FP4 量化,合并 kernel掉不掉点要实测八
先猜一个数 同一套 GB300、同一个 DeepSeek-V4-Pro、每个用户出字一样快,光改软件,每卡吞吐是首发日的几倍?答案在第九节。
市面降价更多,主要归给更强的小模型(斯坦福 AI Index 2025);这题只算软件。
第 一 节

为什么几千字的 prompt 一趟读完,吐字却一趟只出一个?

同一颗芯片,读 prompt 时忙得不行,往外吐字时大半在发呆。 差别只在一件事:一趟喂进去几行。

一趟喂几行,决定卡在算还是卡在搬

一次喂几行,决定卡在哪 —— decode 在屋脊点下面,prefill 在上面 一个 7168×7168 的 bf16 矩阵乘:横轴是一次喂进去的行数 M(token 数),纵轴是每搬 1 字节做几次运算。两轴都是对数 decode:M = 同时解码的人数 prefill:M = prompt 长度 v7 屋脊点 运算强度 = 运算次数 ÷ 搬的字节 1 4 16 64 256 1,024 4,096 16,384 M:一次喂进去的行数(token 数) 1 10 100 1,000 运算/字节 v7 屋脊点:每字节要算 313 次才不用等显存(bf16) ↑ 这一侧卡在算力 ↓ 这一侧卡在显存带宽 一次喂到约 343 行才过屋脊点 decode 1 人:每字节算 1 次 decode 64 人:每字节算 63 次 decode 256 人:每字节算 239 次 prefill 一段 4K prompt:远在线上 decode 再多拼人也难过线,prefill 一段 prompt 就远远过线 decode 一步每人只喂 1 行,256 个人拼一起也才每字节算 239 次;prefill 一段 4K prompt 一次就是 4,096 行。 所以同一块芯片,prefill 时算力是瓶颈,decode 时显存带宽是瓶颈。
红线是 313:绿点(decode)全在线下,橙点(prefill)在线上。
横轴是一趟喂几行;本课推导。
出处与口径

📌 7168 = DeepSeek-V3 config.json 的 hidden_size。屋脊点 313 = v7 每芯片 bf16 2,307 TFLOP/s ÷ HBM 7.37 TB/s(Google Cloud 公开规格;bf16 是 FP8 4,614 的一半,本课推导;专题二同一个数)。

📌 本课推导:运算 2·M·H²,字节 2·(H² + 2·M·H)(权重读一遍、输入读一遍、输出写一遍,bf16 每数 2 字节),强度 = M·H ÷ (H + 2M)。令它等于 313 解出 M ≈ 343。

⚠️ 只算权重时强度就是 M,过线点正好是 313(专题五 fig5-decode-ai 的口径);这里把输入输出也算上,过线点往右挪到 343。

⚠️ 刻意没画:注意力(它读的是 KV,强度不随人数涨,第五节讲)和 MoE 专家层(见本节专家行数那张图)。

一个人出一个字:5 毫秒在搬,0.016 毫秒在算

看蓝条一格格爬满、橙条几乎不动;再看第 3 步喂到 313 行,橙条才追上来。 (27 秒,Manim 渲染;默认连续播放;取消勾选「连续播放」、点「⟲ 重来」,再点「开始」一步一步看。只算权重的理想下限;「313 行时算和搬一样长」是本课按同一组规格推的。)

37 GB ÷ 7.37 TB/s ≈ 5 毫秒,算力只用上 0.32%(理想下限)。换更快的计算单元没用,下限是带宽定的。

还是那辆公交车 开一趟油钱固定:prefill 是满载的车,decode 一趟只拉一个人;313 人以内,多上来的人白搭车。

多拉几个人:权重能摊,KV 摊不了

每出一个字搬多少:权重能分摊,KV 每人一份 DeepSeek-V3,FP8 权重,bf16 的 MLA KV。每根条 = 一步读的权重 ÷ 人数 + 这个人自己的 KV。同一把尺 分到每个字的权重 这个人自己的 KV 每个字的字节(GB) 1 人同时解码 整份 37 GB 只给一个人 4K KV 0.8% 32K KV 6% 128K KV 20% 64 人同时解码 每人摊到 9.14 GB(87% 专家被碰到) 4K KV 3% 32K KV 20% 128K KV 50% 256 人同时解码 每人摊到 2.62 GB 4K KV 10% 32K KV 47% 128K KV 78% 0 8 16 24 32 40 48 GB/字 人越多、上下文越长,这一趟里 KV 越重 权重一次读完分给所有人;KV 是每人自己的历史,128K 时每个字要读 9.21 GB,拼多少人都不变。 256 人、128K 时 KV 已占 78%:再往后,省的就得是 KV 本身。
蓝段随人数缩短,紫段只随上下文变长。
均匀路由、上下文等长;不含激活值与通信。本课推导。
出处与口径

📌 本课推导:KV = 70,272 字节/token(MLA 每层存 512 + 64 个数,bf16,61 层,config.json)× 上下文。128K 时 9.21 GB = 8.58 GiB,与专题五同一个数。

📌 本课推导:b 人一步读的权重 = 不经路由的部分 + 653.9B 路由专家 × [1 − (1 − 8/256)^b](FP8,每参数 1 字节)。b=1 时恰好 37 GB,b 很大时趋近 670.5 GB,对上 671B。

⚠️ 64 人时每人摊到 9.14 GB 而不是 37 ÷ 64:每人挑的专家不同,一步里 87% 的专家都被碰到、都要读。

⚠️ 假设路由均匀、所有人上下文一样长;没算激活和通信字节。KV 改存 FP8 时紫段减半。

MoE 又把凑好的人拆散

MoE 把一批人拆散:256 人进来,每个专家只分到 8 行 同一批 256 人解码一步。方块是 v7 的 MXU(一边 256),填色的是这一步真正喂进去的行 这一步喂进 MXU 的行(decode 的 token) 稠密层 vs 一个专家 稠密层:256 人共用一块权重 MXU 256 × 256 256 行,填满一边 运算强度 ≈ 239 屋脊点 313 MoE 层:一个专家 MXU 256 × 256 平均 8 行,占一边的 1/32 运算强度 ≈ 8 屋脊点 313 256 × 8 ÷ 256 = 8 仍在线下,但差得不多 拼来的 256 人,到了专家这里又被拆成 256 份 每人只挑 8 个专家,一个专家平均只分到 8 行,强度约 8;稠密层约 239,差 30 倍。 要让专家吃饱,得把很多卡上的人收到一起:这就是大 EP 要做的事。
左边填满一边,右边只剩一条细线:像每站换乘 256 条支线,每人只坐 8 条,每条平均只上 8 人。
8 是均匀路由下的平均数;共享专家不受影响。
出处与口径

📌 256 个路由专家、每 token 挑 8 个:DeepSeek-V3 config.json(n_routed_experts、num_experts_per_tok)。MXU 一边 256:JAX 公开源码 jax/_src/pallas/mosaic/tpu_info.py,TPU 7 的 mxu_column_size=256。

📌 本课推导:专家矩阵 7168×2048,M=8 时强度 = 2·8·7168·2048 ÷ [2·(7168·2048 + 8·(7168 + 2048))] ≈ 8。稠密层 239 来自本节第一张图。

⚠️ 8 是平均数,路由不均时有的专家几十行、有的零行。共享专家每个 token 都过,不受影响。

过线只对整块矩阵乘成立;要每个专家都喂饱,一步得凑 9 千多个 token(完整版第三节按 H100 推导)。

这一节带走 prefill 卡算力,decode 卡搬运。要让这一趟值回油钱,就得多拉人: 先让车一直坐满(第二节),再给 KV 腾座位(第三节),最后把被 MoE 拆散的人收回来(第四节)。
三列对比表、强度推导,翻完整版第一节。
第 二 节

那多拉几个人不就行了?batch 能开多大?

要多拉人,可人不是一起上车、一起下车的:有人问一句就走,有人要写三千字。 车怎么排,决定一趟能坐满几个人;座位有多少,决定最多坐几个;坐得越满,每个人越慢。

老办法:凑满一车,等最慢的那个

每站都停:每一步都重新排一次

比两组的灰格:上面越走越多,下面一格没有。 (18 秒无声循环。请求长度是示意,每步按等长算。)

Orca(OSDI 2022)第一招:每走一步就停下来看一眼。 后来叫连续批(continuous batching),vLLM、SGLang 都这样排。

还是那辆公交车 静态批像包车,凑满一车一起到站;连续批才是公交:每站都停,到站的下,等车的上。

座位就是 KV:多给座位,不一定多出字

KV 池装得下几个人,就有几个座位。一笔账:每卡吞吐 ≈ 车上人数 ÷ 两字间隔,座位一满,吞吐就到顶。

那多给座位呢?两字间隔不会原地不动:

座位多给一成多 —— 吞吐几乎没动,多出来的人换成了每一步更慢 GB300 · DeepSeek-V4-Pro · 只多给 KV 池显存;条长=比调整前变了百分之几 人数 两字间隔 推算上限 实测 调整后比调整前多了多少 车上人数 886 → 999 +13% 两字间隔 77.7 → 85.3 ms 每个人都慢了 吞吐上限 人数 ÷ 间隔推算 约 +3%(本课推导) 实测吞吐 端到端 +0.8% 0
先比最上和最下两根:人多了一成多,吞吐几乎没动。
同一组实测,只调了 KV 池的显存。
出处与口径

实测:GB300、DeepSeek-V4-Pro、SGLang,mem-fraction-static 0.85 → 0.88;每 rank 请求 886 → 999,TPOT 77.7 → 85.3 ms,端到端吞吐 10,614 → 10,704(SGLANG-V4PRO-RUNBOOK.md:849-858、885-894)。

本课推导:0.8% = 10,704 ÷ 10,614 − 1;上限 = 999/886 × 77.7/85.3 − 1 ≈ 2.7%,假设新座位全坐满、两字间隔按实测。

权重早已摊薄,新上车的人带来的全是 KV,每一步就长了。

所以 batch 开多大,要先问「每人要多快」

吞吐和交互性是一条曲线 —— 先定档,再比吞吐 GB300 · DeepSeek-V4-Pro · 8K 进 1K 出 · 纵轴只数输出 token、只除以 decode 卡(11,200 官方没写怎么数) InferenceX:Dynamo + vLLM(同一条曲线) PyTorch 博客:SGLang 本仓库实测:SGLang dep8 每张 GPU 的吞吐 vs 每个用户的速度 0 50 100 150 200 0 3,000 6,000 9,000 12,000 每个用户每秒拿到的字(tok/s/user)→ 越右越跟手 每张 GPU 每秒出的字 ↑ 先定档:每用户 50 tok/s 9,759 @ 68 3,816 @ 121 895 @ 173 11,200(2026-06,开 MTP) 2,200(首发,无 MTP) 9,168 @ ≈ 17 (TPOT 约 60 ms) 同一档上:11,200 对 2,200,几倍? 每卡约 224 个用户同时在线(11,200 ÷ 50) 单报一个每卡吞吐,等于没报 同一条 vLLM 曲线上,每用户从 68 提到 173,每卡吞吐从 9,759 掉到 895。报吞吐必须连同交互档一起报。 本仓库的 9,168 落在每用户约 17 的低档,跟 50 档上的 11,200 不能直接比高低。
沿着绿线往左走,每卡吞吐往上涨,每个人拿到的字变慢。
只有绿色三点是同一条曲线;其余点分属不同框架和配置。
出处与口径

InferenceX 三点:gpu-tpu-pedia gpu/inference/a4x-max/deepseek-v4/VLLM-V4PRO-RUNBOOK.md:683-695(GB300 Dynamo + vLLM,V4-Pro FP4,8K/1K,output ÷ decode GPU)。

PyTorch 博客 2026-06-23「Serving DeepSeek-V4 on GB300 with SGLang: 5x Higher Throughput at the Same Interactivity Since Day-0」:~11,200 tok/s/GPU at roughly 50 tok/s/user,Day-0 无 MTP 曲线约 2,200。

⚠️ 11,200 用的是 output ÷ decode GPU 还是 (in+out) ÷ 全部 GPU,公开材料没钉死(SGLANG-V4PRO-RUNBOOK.md:745)。本图按前者画,若是后者,这个点要往下挪。

本仓库实测 9,168:SGLANG-V4PRO-RUNBOOK.md:596(conc600,TPOT 59–61 ms)、723-725。横坐标 1000 ÷ 60 ≈ 17 是本课推导。

goodput:DistServe(arXiv 2401.09670)。

这一节带走 连续批让座位不空着;座位数由 KV 定;人越多,每人越慢。 这一步进步多少:Orca 论文里,同样每字 190 毫秒的延迟,GPT-3 175B 每秒能服务的请求是 FasterTransformer 静态批的 36.9 倍。
座位既然是 KV,下一节就问:每人那块 KV 到底多大,能不能小一点?
想深挖:完整版第三节。
第 三 节

KV cache 到底占多少,怎么省?

座位就是 KV:每人一本笔记,说过的每个字记一行。 座位数 = KV 池 ÷ 每人那本笔记有多厚。想多坐人分三步:先把每行写薄,再让纸别浪费,最后算过的不再算。

第一步,一行多厚:同样的模型形状,能差五十多倍

写薄了掉不掉分?GQA 原论文把 T5-XXL 改成 8 组:解码快约 5.4 倍(本课推导),平均分 47.1 对原版 47.2;只是 T5-XXL 在 TPU v4 上的数。

写薄了还不够:笔记越长,车上坐的人越少

上下文长到 8 倍,纯注意力只装得下 1/8,线性混合还剩 1/4 以上 —— KV 的记账方式决定 batch 上限 一个 v7 device,V3 权重铺 8 颗芯片 = 16 个 device 后剩下的空间全给 KV。横轴上下文长度,纵轴能同时装下几条序列(对数,向下取整) MLA · DeepSeek-V3 线性+全注意力 · Qwen3.5 形状 GQA · Llama-3.1-70B MHA · V3 形状(假想) 一个 device 可用的 94.75 GiB(一颗芯片 = 两个 device) V3 权重的 1/16(FP8):39.1 GiB 留 10% 9.5 GiB KV 池:46.2 GiB 能同时装几条序列 1 10 100 1000 1K 2K 4K 8K 16K 32K 64K 128K 上下文长度(对数,每格翻倍;1K = 1024 token) 条 172 21 5 条 MLA 70,272 B/token 157 41 11 条 线性+全注意力 30,720 B/token + 180 MiB/条 36 4 1 条 GQA 327,680 B/token MHA:16K 起一条都装不下 12 3 装得下几条序列,每趟搬运就分给几个人 MLA 在 4K 装 172 条,32K 只剩 21 条。线性层每条序列先交 180 MiB 固定状态: 4K 时反而比 MLA 少装(157 < 172),128K 时是 MLA 的两倍多(11 > 5)。
往右每走一格,上下文翻倍,绿、蓝、红三条线的人数就减半。
一个 v7 device(半颗芯片,94.75 GiB)、KV 按 bf16;权重按全切粗算。紫线是线性注意力混合模型,本节不展开。本课推导。
出处与口径

出处:每 token KV:V3 (512+64)×61×2 B = 70,272(config.json);Llama-3.1-70B 2×8×128×80×2 = 327,680(HF config.json);Qwen3.5 全注意力 15 层 × 2 头 × 256 维 × K、V × 2 B = 30,720,线性层状态 45×64×128×128×4 B = 180 MiB(HF config.json,mamba_ssm_dtype float32)。

口径:MHA 一行是 V3 形状的假想(128 头 × 128 维,专题三第一题):3,997,696 B/token。

本课推导:v7 一颗芯片对软件是两个 device,各管自己的显存,按 device 记账;V3 权重全按 FP8 1 B/参数算 671 GB ÷ 16 个 device = 41.9 GB = 39.1 GiB;每 device 实测可用 94.75 GiB(tpu-inference R1 FP4 README),再留 10% 给激活(本课假设);KV 池 = 94.75 GiB × 0.9 − 39.1 GiB = 46.2 GiB,先按权重全切粗算,DP attention 下非专家权重每个 device 各一份,实际更少。假设 attention 走数据并行(每个 device 只存自己那几条序列);若 attention 走 TP,MLA 的 KV 每个 device 复制一份(专题五)。

口径:没算激活与通信缓冲(归入那 10%)、线性层卷积状态、引擎实际的状态 dtype(可能不是 fp32)。

人少,这一趟又分给几个人;每人每步要读的 KV 也更多。长上下文贵就贵在这两头。

第二步,纸别浪费:领一页用一页

看请求 2 一走,它的两块马上被请求 4 住进去。 (18 秒无声循环。块大小、块数、请求长度都是示意。)

第三步,算过的不再算:开头一样,就接着往后写

命中的前缀不用重算 —— 首字从 13 s 降到 0.5 s DeepSeek 线上服务,把算好的 KV 存在磁盘上。上:一条 128K 高复用 prompt 的首字延迟(线性,0–14 s);下:一天的输入里有多少命中 不命中:prefill 重算整段前缀 命中:从磁盘读回 KV 128K prompt 的首字延迟 0 s 2 s 4 s 6 s 8 s 10 s 12 s 14 s 不命中 命中 重算 128K 前缀 13 s 0.5 s 首字(含读盘) ≈ 1/26(本课推导:13 ÷ 0.5) 24 小时的输入 token(另一份统计,2025-02) 6,080 亿 56.3% 命中磁盘上的 KV 43.7% 不命中(本课推导:100 − 56.3) 0% 100%
上栏:一条请求命中能省多少;下栏:一天里有多少输入能这样省。
DeepSeek 线上数;首字延迟与命中比例出自两份不同时期的公开材料。
出处与口径

出处:首字 13 s → 0.5 s 取自 DeepSeek API 文档的磁盘缓存公告(api-docs.deepseek.com/news/news0802,2024-08,原文 128K prompt with high reference)。

出处:6,080 亿输入 token、56.3% 命中取自 DeepSeek open-infra-index 202502OpenSourceWeek day_6(统计窗口 2025-02-27 12:00 到 02-28 12:00 UTC+8,608B 里 342B 命中,V3 与 R1 合计)。

本课推导:13 ÷ 0.5 = 26;100% − 56.3% = 43.7%。两个数来自两份文档、两个时间点,不是同一次测量。价格不画。

这一节带走 写薄(MLA/GQA)省每本的厚度,分页省空着的纸,前缀复用省重算的时间:同样的显存里多坐人、少重算。
这一步进步多少:vLLM 论文(SOSP 2023)里,对手有一套已经会连续批(作者复现的 Orca),同样延迟下吞吐还是对手的 2–4 倍;比的是整套系统,不是单开分页。
到这里都是一张卡的账。要多张卡一起跑时,下一节问:每人那本笔记是只存一份,还是每张卡各复印一份?
想深挖:完整版第四节。
第 四 节

多卡跑:TEP 还是 DEP?

V3 这么大的模型,一张卡装不下,得几张卡一起跑。专家那一半大家都按 EP 分,分歧在注意力:几张卡合算一批人,还是各带各的人? 这一选,决定每人那本笔记被复印了几份。

名字拆开读 TEP = T + EP,DEP = D + EP。EP 是专家那一半,两种一样;首字母说的是注意力那一半怎么切:T 是 TP(按头切),D 是 DP(各卡带自己那批人)。dep8 就是 8 路 DEP。
下一节 DCP/PCP 的首字母却是阶段,不是同一维度;也别和 Megatron 的 ETP/EDP 混。

谁把笔记复印了几份

TEP 和 DEP:注意力那一半怎么切 —— 一起算同一批,还是各算各的一批 同样 4 张卡、同样 4 批请求(颜色 = 哪一批);专家那一半两边一样:8 个专家铺在 4 张卡上,每卡 2 个 请求 1 请求 2 请求 3 请求 4 TEP4:注意力用 TP,四张卡一起算同一批 请求 注意力 KV 笔记 专家 卡 0 1/4 的头 全部 KV(整份) 专0 专1 卡 1 1/4 的头 全部 KV(整份) 专2 专3 卡 2 1/4 的头 全部 KV(整份) 专4 专5 卡 3 1/4 的头 全部 KV(整份) 专6 专7 注意力出口 AllReduce:四份部分结果加起来 专家那一步 token 本来人人都有,各算本卡专家,再 AllReduce 好处 每个请求四张卡一起算,单个请求更快 坑 KV 切不开,每张卡存一整份:TEP4 白存 3 份 DEP4:注意力用数据并行,各算各的一批 请求 注意力 KV 笔记 专家 卡 0 全部的头 只存自己的 专0 专1 卡 1 全部的头 只存自己的 专2 专3 卡 2 全部的头 只存自己的 专4 专5 卡 3 全部的头 只存自己的 专6 专7 注意力 各算各的,不用通信 专家那一步 AllToAll 派发到专家所在的卡,算完合并回来 好处 KV 不重复,装得下更多请求,吞吐大 坑 各卡请求长短不一、忙闲不均;没请求的卡也得陪跑 差别全在注意力那一半:一起算同一批,还是各算各的一批 TEP:同一批请求四张卡一起算,单个请求快;可 MLA 这类只有一个 KV 头的模型,KV 在每张卡上都得存一整份。 DEP:每张卡只管自己那批请求,KV 不重复、batch 能开大;代价是专家那一步换成 AllToAll,还要防各卡忙闲不均。
只看注意力那一半:左边四张卡合算一批人,右边四张卡各带各的人。
专家那一行两边一样,都按 EP 分。
出处与口径

📌 TensorRT-LLM 定义:TEP<N> shards both attention (TP) and experts (EP) across N ranks;DEP<N> keeps attention data-parallel (ADP) while distributing experts across N ranks。

⚠️ 专家那一步的通信按常见实现画:attention 用 TP 时各卡 token 相同,专家输出用 AllReduce 合并;attention 用数据并行时各卡 token 不同,走 AllToAll。示意 4 张卡、8 个专家。

代进去:MLA、V4-Pro 1 个 KV 头,TEP8 复印 8 份;Qwen3.5-397B 32 个查询头共用 2 个,复印 4 份;8 个 KV 头的 GQA 不复印,DEP 不占便宜。

容量和速度分开看:座位有人坐才值钱

V4-Pro 1 个 KV 头。我们自己在 GB300 上用 SGLang 搭的一套部署,读题和写字拆在两批机器上(为什么这么拆,第六节讲),两头都用 DEP:14 台 prefill 各跑 dep4,decode 跑 dep8,每张 decode 卡端到端 10,704 tok/s,是官方目标(PyTorch 博客报的每卡约 11,200,分母官方没写明,本课按 decode 卡读)的 95.6%。

TEP 换 DEP:容量和速度分开看 —— SGLang 两头都用 DEP,座位坐满就换来吞吐 上半张容量轴(示意,每卡 KV 池装满);下半张 SGLang 实测(14 台 prefill 各 dep4 → decode dep8) 一批不同请求的 KV 同一批 KV 的副本 ① 容量轴:KV 池装满时,存的是几批不同的请求(示意) TEP4 4 张卡合算一批 卡 0 批 A 卡 1 批 A 的副本 卡 2 批 A 的副本 卡 3 批 A 的副本 4 张卡只放 1 批 1 个 KV 头切不开, 每张卡各存一整份 DEP8 各算各的 卡 0 批 1 卡 1 批 2 卡 2 批 3 卡 3 批 4 卡 4 批 5 卡 5 批 6 卡 6 批 7 卡 7 批 8 8 张卡放 8 批:每卡上限 4 倍 4 = TP 路数 4 ÷ KV 头数 1 这是天花板:同时在跑的请求多到坐满 TEP4 的池子,多出的座位才换得来吞吐;光是上下文长没用。 ② SGLang 实测:14 台 prefill 各 dep4 → decode dep8,输入 4096,座位多少换多少吞吐 prefill × 14 台,每台 dep4(注意力 DP4 + EP4) decode dep8(跨 2 台,DP8 + EP8) 16 台 GB300,同一 NVL72 域 每卡同时在跑 两个 KV 池占用 端到端每张 decode 卡 出字间隔 池子划错(ratio 0.20) 727 0.93 / 0.63 6,887 58.0 ms 划平(ratio 0.15) 886 0.92 / 0.89 10,614 77.7 ms 再多 13% 显存 999 0.92 / 0.67 10,704 85.3 ms +54% → +0.8% 座位换吞吐要两个前提:有人来坐,每一步别跟着拖长 727 → 886:池子划平、座位多了,有 14 台 prefill 喂着,座位坐得满,端到端涨 54%。 886 → 999:再多 13% 座位,只涨 0.8%:一步从 77.7 拖到 85.3 ms,多坐的人被抵掉。
上半张是容量上限(示意),三份是复印;下半张是 SGLang 实测:座位坐满,吞吐才跟着涨。
GB300、两头 DEP、输入 4096;上半张是示意,不是实测占用。
出处与口径

SGLang 部署:gpu/inference/a4x-max/deepseek-v4/SGLANG-V4PRO-RUNBOOK.md:33-34(14 prefill 各 dep4 + dep8 decode、16 节点同一 NVL72 域)、scripts/prefill-dep4.sh、decode-dep8.sh(--enable-dp-attention,EP 4/8);三行实测 :851-858(ISL 4096,14 路 × 并发 1050,#1/#3/#7)。

旁证:VLLM-V4PRO-RUNBOOK.md:298-302(num_key_value_heads 1)、:464-465、:476(并发 512:TP4 decode 输出 4,220、出字间隔 46.8 ms;dep8 为 11,031、11.8 ms;GPU 16 与 20)。

本课推导:容量上限倍数 = TP ÷ min(TP, KV 头数),上半张是示意,条长不按实测请求数画;+54% = 10,614 ÷ 6,887,+0.8% = 10,704 ÷ 10,614;2.09 倍 = (55,153 ÷ 20) ÷ (21,100 ÷ 16),55,153、21,100 是同表的总吞吐(输入+输出,4K 进 1K 出,所以约是输出的 5 倍),1.31 倍 = (11,031 ÷ 8) ÷ (4,220 ÷ 4)。

DEP 的代价:每张卡自备一份家当

大 EP:把第一节拆散的人收回来

第一节的洞:每个专家平均只剩 8 行。解法是把专家铺开:出了一台 8 卡机还在分,就是大 EP(TensorRT-LLM 的线是 EP 超过 8);注意力各管各的人,所以它是放大版的 DEP。

上下两条泳道比同一列:每份专家分到的人越多,每张卡读得越少。 (24 秒,Manim 渲染;默认连续播放;取消勾选「连续播放」、点「⟲ 重来」,再点「开始」一步一步看。专家大小、层数照 V3 配置;每卡 32 个请求、负载均匀是示意。)

DeepSeek 线上 decode 用 EP144:18 台机器,256 个专家加 32 份冗余共 288 份,每卡 2 个路由专家加 1 个共享专家。

为什么做得成:难在等,不在量

大 EP 吃网络:卡越多,每趟越慢 左:DeepEP 低延迟 kernel 实测(H800,每卡一张 400 Gb InfiniBand 网卡;每批 128 个 token)。右:三种互连域 分发:token 送到专家所在的卡 汇回:专家算完送回来 每趟传送多久(微秒) 0 100 200 300 400 EP8 EP16 EP32 EP64 EP128 EP256 77 118 155 173 192 194 114 195 273 314 369 360 卡数 ×32:分发 77 → 194(×2.5),汇回 114 → 360(×3.2) 按 EP256:每层一去一回 × 58 个 MoE 层 ≈ 32 毫秒,不藏起来就全露在每一步里 (本课推导;线上把它藏进计算,靠的是双微批) 三种互连域 8 卡机器 + InfiniBand 机内 NVLink 约 160 GB/s,机间每卡约 50 GB/s DeepSeek 的 EP144 就跑在这上面:跨 18 台 GB200 NVL72 72 张卡在同一个 NVLink 域里 SGLang:延迟低到可以关掉双微批 TPU Ironwood 64 颗一组,ICI 直连成 3D 环面,每颗连 6 个邻居 光交换连到 9,216 颗,再往外走数据中心网络 不是非 NVL72 不可 普通 8 卡机器,只要每张卡一张 RDMA 网卡、全互连、GPU 能直接发起传送,就跑得起;域越大,每趟越快,越不用藏。
看左图横轴:卡数涨 32 倍,延迟只涨两到三倍,但每层都要付一次。
左图是 H800、每卡一张 400 Gb 网卡的实测;右边三种互连的规格来自各家公开资料。
出处与口径

左:DeepEP v1.2.1 README 低延迟 kernel 表(H800 NVLink 约 160 GB/s;CX7 400 Gb/s IB 约 50 GB/s;128 token/批、hidden 7168、top-8、FP8 分发、BF16 汇回)。右:DeepSeek-V3 技术报告 §3.4;LMSYS 2025-06-16「GB200 NVL72 Part I」(pure-NVLink … allows two-batch overlap to be disabled);Google Cloud「Inside the Ironwood TPU codesigned AI stack」(64-chip cube、3D torus、9,216 颗、DCN)。

本课推导:(194 + 360) µs × 58 层 ≈ 32 ms,是不重叠时的上限;V3 61 层中前 3 层稠密,MoE 58 层(config.json first_k_dense_replace 3)。NVL72、ICI 的带宽没写数字。

还有一笔账:批小了凑不满车,传的开销照付。

所以 NVL72 这类大域,对推理特别合适

整柜一个 NVLink 域跑大 EP —— 每卡是 H100 大 EP 部署的 2.7 到 4.8 倍 SGLang · GB200 NVL72 · DeepSeek V3/R1 · 2K 输入 · PD 分离、decode 48 张卡;H100 记作 1 H100 大 EP 第一篇:原精度 第二篇:FP8 注意力+NVFP4 专家 每卡吞吐,对 H100 上的大 EP 部署 H100 大 EP 基线 1× NVL72 · 原精度 decode,每卡 7,583 tok/s 2.7× NVL72 · 压低精度 prefill 3.8× NVL72 · 压低精度 decode 4.8× 别全记在大 EP 头上 倍数里混着显存、精度、kernel 和 PD 分离。 decode 先压慢、攒满请求再放开测;H100 基线有一组开了模拟 MTP,GB200 没开。
先看虚线:H100 那根只到这里,最下面一根将近五个它长。
两篇都是每卡对每卡,对照的是 H100 上的大 EP 部署。
出处与口径

LMSYS 2025-06-16「GB200 NVL72 Part I」:decode 每卡 7,583 tok/s,对 H100 每卡 2.7×(2,000 token 输入;H100 柱含模拟 MTP;decode 用 slow-down 接口攒满再放开)。

LMSYS 2025-09-25「Part II」:FP8 注意力 + NVFP4 专家,prefill 26,156、decode 13,386 tok/s 每卡,对 H100 3.8× 和 4.8×;decode 48 卡(「For decode, we use 48 ranks」)。

H100 基线是两篇各自引用的 H100 PD + 大 EP 部署;倍数为原文所报,未做同精度拆分。

这一节带走 DEP 不复印笔记,每一步变短;大 EP 把专家那趟车坐满,还腾出显存装笔记。
这一步进步多少:SGLang 两头 DEP 做到官方目标的 95.6%;vLLM 换 dep8,按全部卡算每卡吞吐 2.09 倍。
可 DEP 要每卡自备状态,有的模型只能退回 TP,笔记又被复印;上下文一长,复印件吃光显存。下一节问:DCP 和 PCP 有啥区别?
想深挖:完整版第六节。
第 五 节

长上下文:DCP 和 PCP 有啥区别?

上一节的洞:K3 这类模型 DEP 起不来,退回 TP,笔记被复印好几份,上下文一长先把显存吃光。第二个麻烦:prompt 一长,首字要等很久。 两招都沿序列切,名字只差一个字母。

名字别按字母记 DCP、PCP 是框架里的叫法,按最常用的阶段起名:D 是 decode,P 是 prefill。CP 是 context parallel,一条长序列分给几张卡。
可机制不绑阶段:Meta 按谁在搬起名,叫 pass-KV 和 pass-Q,缓存命中高、新输入很短的 prefill 也传 Q。本课只记谁搬家:PCP 传笔记,DCP 传提问。

谁搬家

注意力是一张表:行是新 token 的提问(Q),列是前面 token 的笔记(K、V),只看前面,所以是三角。切开它,总有一方得搬家。

先看 PCP 里蓝色笔记段绕着环走、提问一动不动;再看 DCP 里反过来,黄色提问飞进每张卡、答案在终点拼。 (34 秒,Manim 渲染;默认连续播放;取消勾选「连续播放」、点「⟲ 重来」,再点「开始」一步一步看。4 张卡、4 段是示意;没画 Ring 的负载均衡排布。)

切法一样:都按 token 把序列切成几段,每张卡管一段、存自己那段的 KV。不同只在传什么。

为什么反过来:谁小搬谁

答案怎么拼:先别除。注意力是加权平均:每张卡交出分子和分母,加总后只除一次。

想看算术:两张卡各交一个平均分,怎么合才对?
分块算注意力,合并时先别除 —— 分子加分子,分母加分母,最后只除一次 注意力 = 按分数加权平均。三个 token:分数取指数后是 2、1、1,值是 10、4、20。卡 0 拿前两个,卡 1 拿第三个 卡 0 卡 1 错 对 两张卡各自算自己那份笔记 卡 0:2×10 + 1×4 分子 24 分母 3 卡 1:1×20 分子 20 分母 1 分子 = Σ 权重×值,分母 = Σ 权重 (分母取个对数,就是常说的 LSE) 各除各的,再平均 卡 0:24 ÷ 3 = 8 卡 1:20 ÷ 1 = 20 平均:(8 + 20) ÷ 2 = 14 ✗ 卡 1 只有一个 token,却占了一半的票 先别除:最后只除一次 分子:24 + 20 = 44 分母:3 + 1 = 4 44 ÷ 4 = 11 ✓ 跟三个 token 放在一张卡上算的一样 所以每张卡除了结果,还得交出自己的分母 跟合并两个班的平均分一样:得带上各班人数,不能把两个平均数再平均。 Ring 在路上一段一段这样合并,DCP 在终点这样合并,是同一招。
三个 token 的小算例:中间打叉,右边打勾。
像合并两个班的平均分,要带上各班人数。
出处与口径

📌 讲法:Ring Attention(Liu 等,arXiv 2310.01889)附录实现按分子、分母分别累加;分块 softmax 的数值稳定写法见 FlashAttention(arXiv 2205.14135)。

⚠️ 本课示例:数字是随手取的,按定义现算并断言。

所以呢:同样切八份,买到的不一样

推理时切序列:KV cache 被 TP 复制了几份 —— DCP 把复制变回容量 DeepSeek-V3,一个 128K 上下文的请求。每 token 的 KV = (512 + 64) × 61 层 × 2 字节 = 70,272 字节 重复存的那几份 真正需要的那一份 8 张卡上,这一个请求的 KV 各占多少 TP 8 路 卡 0 卡 1 卡 2 卡 3 卡 4 卡 5 卡 6 卡 7 每卡 8.58 GiB 合计 68.6 GiB(8 份一样的) TP 8 + DCP 8 卡 0 卡 1 卡 2 卡 3 卡 4 卡 5 卡 6 卡 7 每卡 1.07 GiB 合计 8.58 GiB(刚好一份) TP 超过 KV 头数,多出来的全是复制 MLA 的 KV 只有一个头。TP 8 路时每张卡都存完整的一份,7 份是白存的。 DCP 让 KV 按 token 轮流落到 8 张卡上,每卡只剩 1/8;它不增加卡,直接复用 TP 那几张。
上排八块一样高(一绿七红),下排八块矮条拼成一份。
MLA 每层只有一个 KV 头,TP 切不开它。
出处与口径

📌 vLLM context parallel 部署文档:KV cache 会被复制 tp_size / H 次;DeepSeek-R1 在 MLA 下只有 1 个 KV 头,-tp 8 就是 8 倍复制,可加 -dcp 8。KV 尺寸取自 V3 config.json,本脚本现算。

DCP 什么时候赚,什么时候亏

DCP 只在长上下文赚 —— 128K、8 并发:365 对 108,+237% Kimi K3 · GB300 · SGLang · TP8 跨 2 节点,输出 1K。纵轴:DCP8 ÷ TP8 的输出吞吐(对数刻度),一条线一个并发 并发 8 并发 1 并发 32 并发 64 输入长度 → DCP8 相对 TP8 0.6× 0.8× 1× 1.5× 2× 3× 4× DCP 赚 DCP 亏 4K 8K 32K 128K 输入长度(token) 4K:四档并发全亏 并发 64:−7% 并发 8:−9% 并发 32:−11% 并发 1:−26% 并发 32:+24% −11% −17% 并发 1:+12% 并发 1 的 8K、32K 没测,虚线只连两端 +237% 365 vs 108 tok/s
先找突出画的并发 8 那条在 128K 处翻到多高,再看最左边 4K 那四个点都落在 1× 线以下。
纵轴是两者输出吞吐之比,对数刻度;TP8 取调过参的最好一档。
出处与口径

gpu/inference/a4x-max/kimi-k3/SGLANG-K3-RUNBOOK.md §11.0.3(:1010-1023,八个工作点)、§11.0.0 宽表(:921-938,4K c8/c32 本脚本取 symm-mem 开着时 TP8 最好的一档现算)、:721-723(逻辑 KV 1.5M → 12.2M token)、:1024-1026(−26% = 关 symm-mem 的损失)、:962(symm-mem 在 DCP 下用不了)。

各点比值:4K c1 −26%、c8 −9%、c32 −11%、c64 −7%;8K c8 −11%、c32 +24%;32K c8 −17%、c32 +7%;128K c1 +12%、c8 +237%。

吞吐是输出 tok/s,热轮;32K c32 按 §11.0.3 取 TP8 408.2(宽表 ratio 0.4 那行是 420,比值变 1.04,不改结论)。K3 的 MLA 层只有一个 KV 头,它的 69 层 KDA 状态池 DCP 不切(同文件 :725-726)。横轴没换成「KV 总量」:原表只给输入长度和并发,没有实测的 KV 占用。

开之前要知道:DCP 叠不到 DEP 上

DCP 只管注意力那一半:不添卡,叠在注意力的 TP 上,把复印件改成分册。专家那一半用 EP 还是 TP 都不碍事,所以常见写法是 TEP + DCP(我们 K3 那组是 TP8 + DCP8,专家没开 EP)。按现在的做法,它的路数从注意力 TP 那组卡里借(最多「TP 路数 ÷ KV 头数」份);DEP 注意力那边每组只有一张卡,没得借。不是不能配 EP,是不能配 DEP。它救的正是 DEP 起不来、注意力退回 TP 的那批模型。

这一节带走 谁小搬谁。PCP 搬笔记,读题卡在算,切开买首字;DCP 搬提问,写字卡在搬,切开买容量,扣掉每层通信,长上下文才净赚。
这一步进步多少:K3、GB300、SGLang、TP8 跨两台机器、128K 输入 1K 输出、并发 8,DCP8 对调过参的 TP8,输出吞吐 108 → 365 tok/s,多出 237%。短输入时它是亏的。
可 prefill 和 decode 还挤在同一批卡上,人越多,一个长 prompt 进门耽误的人越多。下一节:PD 分离多搬一趟 KV,凭什么接的人更多?
想深挖:完整版第七节。
第 六 节

PD 分离:多搬一趟 KV,凭什么接的人更多?

上一节的洞:prefill 和 decode 还挤在同一批卡上,每卡装的人越多,一个长 prompt 进门耽误的人越多。 PD 分离把两种活拆到两批机器上,代价是每个请求多搬一趟 KV。多搬一趟,凭什么接的人反而更多?

两种活互相拖

先看上组的红框,再看下组那支紫箭头:一个是整批人在等,一个是多搬一趟。 (22 秒无声循环,Manim 渲染。时间格只表相对长短,不是实测毫秒;传 KV 画得比 prefill 短,量级见下文。)
一个厨房:备菜和出菜 毛病不在一趟搬多少,在两种活抢同一个灶台。prefill 是备菜,整段 prompt 一次备完;decode 是出菜,一盘一盘往外端,一次多端几盘才划算。突然来一桌大单、一大堆菜要备,出菜全停。
拆开就是两个灶台,备好的料(KV)递过去一趟。

凭什么接的人更多:各按各的上限

拆开以后,3 张卡顶混着做的 7 张 —— 各干各的,谁也不拖谁 同一套延迟要求下,一张卡每秒接得住几个请求(DistServe 论文的例子,13B 模型、单张 A100) 两样都做 只做 prefill 只做 decode 每张卡每秒接得住几个请求 混着做 两样都做 1.6 个/秒 两样都做 1.6 个/秒 两样都做 1.6 个/秒 两样都做 1.6 个/秒 两样都做 1.6 个/秒 两样都做 1.6 个/秒 两样都做 1.6 个/秒 7 张 ≈ 11.2 个/秒 拆开 prefill 5.6 个/秒 prefill 5.6 个/秒 decode 10 个/秒 3 张 = min(2 × 5.6, 10) = 10 个/秒 每张卡接的请求翻了一倍多,配比就是这么算出来的 两边各有各的上限:prefill 一张接 5.6 个,decode 一张接 10 个,所以配 2 比 1,两边差不多同时忙满。 长 prompt 的业务 prefill 更累,就多配 prefill;长回答的业务多配 decode。
上排七张卡都「两样都做」,下排三张卡各干一样。
专题五原图;请求率取自论文里的例子。
出处与口径

📌 DistServe(Zhong 等,arXiv 2401.09670)sec. 1 与图 1 的例子(13B 模型、单张 A100,90% 请求达标):同一 SLO 下单卡 goodput 1.6/5.6/10 rps,2P1D 每卡 3.3 rps、2.1 倍;作者博客「Throughput is Not All You Need」用同一组数讲了一遍。

⚠️ 本课推导:2P1D 每秒 min(2 × 5.6, 10) = 10 个,每卡约 3.3 个;混着做接 10 个要 ⌈10 ÷ 1.6⌉ = 7 张卡。

DistServe 报告每卡请求率最多是不拆的 7.4 倍(九成以上请求守住延迟)。Mooncake 做进 Kimi 线上,NVIDIA Dynamo 2026 年 3 月出 1.0 版,PD 分离成了标准件。

多搬的那一趟有多贵

一趟 KV 传输,只占一次 prefill 的 5–10% —— 网络不是瓶颈 我们在 TPU v7x 上的 1P1D(Qwen3-Coder-480B),8K token 的 prompt。KV 传输是按带宽估算,不是计时实测 prefill(1–2 秒) ① ② ③ 同一把时间尺:0 到 2 秒 0 500 ms 1000 ms 1500 ms 2000 ms 一次 prefill 1–2 秒 一趟 KV 传输 10 + 83 + 10 ≈ 100 ms 放大 10 倍: 10 ms ① 显存 → 本机内存(PCIe) 83 ms ② 本机 → 对方(数据中心网络 100 Gb/s) 10 ms ③ 对方内存 → 显存(PCIe) 敢走慢线,是因为一个请求只传这一次 这个模型 KV 头少(8 个)又用 FP8 存,8K prompt 的 KV 约 1.04 GB;换一个 KV 大得多的模型、换网络,要重算。 对比 TP:它每一层都要通信,只能待在最快那一圈;这里一个请求就一趟,跨机器也藏得住。
先看上面那根一到两秒的长条,再看下面那根三色细条。
KV 用时按带宽估算,不是计时。
出处与口径

📌 我们的 TPU v7x 1P1D 记录(wiki qwen3-coder-480b-pd-disagg-tpuv7x-20260425):三段按带宽估算约 10 / 80 / 10 ms、合计约 100 ms、占 prefill 5–10%(prefill 1–2 s 由此反推)。

⚠️ 本课推导:KV = 2 × 62 层 × 8 个 KV 头 × 128 × 8,192 × 1 字节 ≈ 1.04 GB;100 Gb/s = 12.5 GB/s → 约 83 ms。

KV 变薄,PD 才敢跨数据中心 —— 混合模型要送的字节降到全注意力的 1/4 到 1/13 PrFaaS 论文 Table 3:32K 输入,一台 8×H200(SGLang v0.5.9)做 prefill 时每秒要外送的 KV,单位 Gb/s 全注意力 混合(线性或滑窗 + 少量全注意力) 每台 prefill 每秒要外送的 KV(Gb/s,32K 输入) 0 20 40 60 80 100 案例:整个 prefill 集群平均出口 13 Gb/s = 专线的 13% Qwen3-235B 全注意力 33.35 够并 2 台 Qwen3.5-397B 每 4 层里 3 层线性 8.25 够并 12 台 MiniMax-M2.5 全注意力 59.93 够并 1 台 MiMo-V2-Flash 每 6 层里 5 层只看近处 4.66 够并 21 台 整条跨集群专线约 100 Gb/s(集群共用)
先看两根橙柱只够并 1–2 台,再看两根绿柱能并 12–21 台。
32K 输入,一台 8×H200 每秒外送的 KV;「够并几台」是 100 Gb/s 除以每台外送,本课推导。
出处与口径

📌 PrFaaS,arXiv 2604.15039(Moonshot AI + 清华):Table 3 的 Φ_kv;案例吞吐 +54%、P90 TTFT −64%、同成本约 +15%、比不调度的朴素异构 +32%;长度阈值 19.4K,约一半请求外送;平均出口 13 Gb/s,占整条以太网的 13%(§4.3.1,故专线约 100 Gb/s)。「够并几台」= ⌊100 ÷ 每台外送⌋,本课推导。

📌 案例:内部 1T 混合模型,32 张 H200 做 prefill + 64 张 H20 做本地 PD,对比 96 张 H20 同构 PD。「每 4 层里 3 层线性」即论文的混合 3:1;「每 6 层里 5 层只看近处」即 5:1 滑窗注意力(SWA)。

⚠️ 那 4 倍、13 倍是论文拿规模相近的模型两两对比(原话 dense models of similar size),不是同一参数量下的严格对照。

拆开之后:各怎么切、配几台、什么时候别拆

两边各怎么切:prefill 窄而多份,decode 宽而一份 我们自己在 GB300 上用 SGLang 搭的 V4-Pro,16 台机器,两头都是 DEP(注意力各卡带自己那批人,专家按 EP 分),差在宽度和份数:
  • prefill:14 份 dep4。一台机器 4 张卡一组,组和组互不说话。prefill 卡在算,一个长 prompt 自己就喂饱算力,不用凑人;组小,跨机通信少;要接更多,多开几份。
  • decode:1 份 dep8。横跨两台机器 8 张卡。decode 卡在搬,得凑大批,专家权重读一遍才划算;EP 开宽,每个专家攒到的人更多;注意力走 DP,V4-Pro 只有 1 个 KV 头,每人的 KV 只存一份不复印。
  • 宽了要有人喂。decode 宽到 dep16,prefill 只剩 12 台、喂不饱,每张 decode 卡输出反掉四成(第四节)。
  • 不只我们这么配。SGLang 在 GB200 NVL72 上的公开实测也是这个形状:decode 48 卡一个实例(DP 注意力+EP48),prefill 每实例 2–4 卡(完整版 8.5)。
  • 换模型,组合会变。DEP 起不来的,decode 退回 TEP 再叠 DCP(K3,第五节);首字太慢的,prefill 可以加 PCP。这两条是按前两节推的配法,我们这套部署没用到。
多一台 prefill,买的是首字快,不是吞吐 —— 每张卡反而少了三成 DeepSeek-V3,B200(每台 8 卡),SGLang + NIXL;1P1D(16 卡)→ 2P1D(24 卡);输入 3,000–4,000、输出 400–600,并发 128 1P1D 2P1D 按机器看:花的卡换来多少字 总输出(tok/s) 1,118.8 1,159.0 +3.6% 每张卡输出(tok/s) 69.9 48.3 −31% 按用户看:等第一个字等多久 平均 TTFT(s) 2.40 1.73 −28% P99 TTFT(s) 12.07 6.23 −48% 加 prefill 前先问:缺的是首字速度,还是每秒出的字 这台 prefill 让排队的请求更快开始,总输出几乎没动。拿每卡吞吐评估 2P1D 一定吃亏,该拿 TTFT 的 SLO 来评。
左边总输出几乎没动、每卡少了三成;右边两组首字都在降。
每卡 = 总输出 ÷ 全部卡数;首字是客户端测的,含排队。
出处与口径

📌 gpu/inference/a4/deepseek-v3/REPORT-2P1D-DeepSeek-V3.md:表在 :69、:85,对比在 :100–142(每卡 = 总输出 ÷ 卡数,报告原算法,脚本复算)。c256:1,798.1 → 1,775.6。

⚠️ TTFT 是客户端测的,含排队。两边都开了 --disable-cuda-graph(REPORT-1P1D :129),所以没画 TPOT。

这一节带走 PD 分离不让 decode 少搬,只让它不被打断;两边各按上限开批。多递的那趟 KV 一个请求只传一次,单趟很便宜;拆开后两边还能各挑切法。
这一步进步多少:Mooncake 的 FAST'25 正式版报告,比此前系统多接 115%(A800)、107%(H800)请求。
可拆不拆,decode 还是一步只出一个字。下一节:能不能一趟出好几个字?
想深挖:完整版第八、九节。
第 七 节

投机解码:怎么一趟出好几个字?

上一节的洞:拆不拆 PD,decode 都一步一字、每字搬一趟。要每个字都快的档 batch 开不大,推理模型又一答几千字。能不能搬一趟,出好几个字?

先猜后验:猜对白赚,猜错只亏一点

看第 1 步的红字「似」:错的位置换成大模型自己的字,后面的全扔;再看第 2 步白送的那一个。 (23 秒,Manim 渲染;默认连续播放;取消勾选「连续播放」、点「⟲ 重来」,再点「开始」一步一步看。示意,按温度 0 贪心比对。)
徒弟打草稿,师傅一次批 小模型(徒弟)一口气写几个字;大模型(师傅)把它们当一段输入,搬一趟权重一次批完。
对上的收;第一个不对的换成师傅的字,后面全扔。最差出一个字,跟不开一样。
多验证几个 token 贵不贵 —— 稠密部分白送,MoE 专家不白送 左:V3 验证一步要读的权重(本课推导,FP8)。右:Kimi K3 实测,搬一趟变慢了,但一趟带回的字多得多 每个 token 都经过的部分 路由专家(各挑各的) 开投机后的一趟 V3 验证 n 个 token,一步读多少 GB 0 60 120 180 GB 1 37.5 2 3 4 5 6 7 8 163.8 一步验证的 token 数 n 验证 8 个 = 验证 1 个的 4.4 倍 浅蓝 17.1 GB 不随 n 变 Kimi K3 实测:搬一趟,带回几个字 不开投机 搬一趟 11.1 ms 带回 1 个字 开投机 搬一趟 16.1 ms 平均带回 6.96 个字 用时 1.45×,对不开 摊到每个字 11.1 ms → 2.31 ms,降到 1/4.81 一趟慢一点不要紧,带回的字多得多
左边深蓝那段越验越高:专家越验读得越多;右边一趟慢了一截,带回的字多得多。
左为 V3、FP8、均匀路由的推导,偏高;右为 K3 在 GB300 上一个人用的实测。
出处与口径

V3 结构取自 HF deepseek-ai/DeepSeek-V3 config.json:hidden 7,168、moe_intermediate 2,048、61 层中前 3 层稠密、256 个路由专家挑 8 个。每个专家 3 × 7,168 × 2,048 ≈ 4,404 万参数。

⚠️ 本课推导:其余部分 = 671B − 256 × 58 × 专家大小 ≈ 17.1B;由此推出每 token 激活 ≈ 37.5B,与技术报告的 37B 差 2% 以内(外部锚点)。

⚠️ 本课推导:n 个 token 独立、均匀地挑专家时,一层平均碰到 256 × (1 − (1 − 8/256)^n) 个;实际路由不均匀、相邻 token 常挑同一批专家,所以深蓝那段是偏高的估计。

K3:gpu/inference/a4x-max/kimi-k3/SGLANG-K3-RUNBOOK.md:1089(GB300 TP8 跨两节点,ISL 4096/OSL 1024,temperature 0,bs=1,TPOT 11.1 → 2.31 ms)、:979(accept len 6.96,block 7)。

⚠️ 本课推导:开投机后一趟耗时 = 2.31 ms × 6.96 ≈ 16.1 ms;每字间隔降到 1/4.81(11.1 ÷ 2.31 ≈ 4.81)。runbook 报的端到端 4.22× 含首字时间,所以比 4.81 小。右图第 7 个方块代表平均值里的 0.96 个,示意。

注:K3 是 8 张卡跑 bs=1,一步里除了读权重还有通信和 kernel 之间的空转,所以「用时 1.45×」不能全归给多读的专家。

Kimi K3 在 GB300 上一个人用:一趟从 11.1 ms 慢到约 16 ms(本课反推),平均带回 6.96 个字,每字快到 4.81 倍。这是温度 0、随机 prompt 测的,偏乐观:官方按温度 1.0 给的接受长度低一截,代码类约 4.73、创作类约 2.61(引擎不同,别直接相除)。

人一多就不灵

投机解码的收益会缩 —— 人一多、上下文一长,白送的那部分就变少 Kimi K3 · GB300 · SGLang TP8。柱高 = 开投机后的输出吞吐 ÷ 不开;虚线 = 1,不赚不赔 4K 上下文,并发 1 → 64 32K 上下文,并发 1 开投机后的吞吐是不开的几倍 1× 4.22× 并发 1 2.86× 并发 8 1.89× 并发 32 1.74× 并发 64 1.32× 32K · 并发 1 同样并发 1, 上下文 4K → 32K: 4.22× → 1.32×
从左往右看柱子一路变矮:人越多,投机多送的越少。
K3 在 GB300 上的输出吞吐,对同条件不开投机;最右那根是同样一个人、上下文拉到 32K。
出处与口径

K3:gpu/inference/a4x-max/kimi-k3/SGLANG-K3-RUNBOOK.md:1089-1092(GB300,TP8 跨两节点,ISL 4096/OSL 1024,random,temperature 0,开环,只报热轮;输出 tok/s 总量)、:1057-1058(32K,只测了并发 1;8/32 没测,集群已删)。

注:K3 并发 64 时开投机的 TPOT 仍只有不开的 40%,这一档吞吐和延迟同时变好。

另两组相关实测的出处 —— B200:gpu/inference/a4/deepseek-v4/README.vllm.md:265-277(DeepSeek-V4-Flash,8× B200,vLLM v0.20.0,EP+DP=8,MTP num_speculative_tokens=2;接受率约 54%;十档并发 −3% 到 −37%)。

V4-Pro:gpu/inference/a4x-max/deepseek-v4/SGLANG-V4PRO-RUNBOOK.md:900-911(steps 1/draft 2 → steps 2/draft 3;接受长度 1.88 → 2.36(+26%),反推单步耗时 115.3 → 162.5 ms(+41%);decode 峰值 −13%、端到端 +28%)。B200 那套是 EP+DP 高吞吐配置,结论不能搬到 TP-only 低延迟配置。

所以呢:低并发、要跟手的档先开;为大 batch 配的部署先实测再开。

草稿从哪来:离大模型越来越近

草稿从哪来 —— 一步步长进大模型身上,或者干脆不要模型 横轴是首次公开的时间:论文按 arXiv 首版,Prompt Lookup 没有论文,按 GitHub 仓库。每张卡只写草稿从哪来 主线:要训练的草稿(小模型/头/层) 侧枝:不用草稿模型 草稿越来越贴着大模型自己长 2022-11 投机解码 另放一个独立小模型 打草稿 2024-01 Medusa 大模型头上 加几个解码头 2024-01 EAGLE 小模型读大模型的 隐状态来猜 2024-12 MTP · DeepSeek-V3 预训练时就多带一层, 共享输出头 2025-03 EAGLE-3 把大模型几层的隐状态 拼在一起来猜 2026-07 DSpark 半自回归一次出一小段, 按置信度定验几个 2022 2023 2024 2025 2026 2023-11 Prompt Lookup 不用草稿模型: 直接从 prompt 里抄
沿时间轴从左往右:草稿从独立小模型,一步步长到大模型身上。
图上故意不画倍数:各家在自己的模型上测,不能横比。
出处与口径

时间取 arXiv 首版(2026-10-15 逐个核过摘要页):投机解码 Leviathan 等 2211.17192;Chen 等 2302.01318;Medusa 2401.10774;EAGLE 2401.15077、EAGLE-2 2406.16858;MTP · DeepSeek-V3 2412.19437;EAGLE-3 2503.01840;DSpark 2607.05147。Prompt Lookup 没有论文,年份按 GitHub 仓库 apoorvumang/prompt-lookup-decoding 的创建时间(2023-11,GitHub API 核过;已集成进 vLLM 与 transformers)。Medusa 与 EAGLE 都是 2024-01,轴上两点挨着。

没画进图的:SpecInfer 2305.09781 把草稿排成树;SuffixDecoding 2411.04975 从历史输出里抄;扩散草稿 DiffuSpec 2510.02358、DFlash 2602.06036;Lookahead 2402.02057。P-EAGLE、PARD、LayerSkip 等也没画。

注:各家倍数都是原作者在自己的模型和负载上测的,口径不同,不横比,所以图上不画。

各家倍数口径不同,比的对象、用的模型都不一样,不能横比,完整版第十一节逐条列了。

DSpark 怎么补的:两刀。一趟出整块的草稿开头准、往后掉得快;闲聊又天生比解题难猜(论文实测在下面折叠里)。两刀各补一头。

论文实测数据:一个个猜和一趟出整块,各在哪一位准?
DSpark 论文实测:开头靠深度,往后靠前后照应 左:每一位单看准不准;右:一轮平均收下几个字 EAGLE-3(一个个猜) DFlash(一趟出整块) DSpark ① 逐位接受率:第 1 位 → 块里往后 Qwen3-4B 0.5 0.6 0.7 0.8 0.9 1.0 闲聊 EAGLE-3 0.53 0.74 闲聊 DFlash 0.72 0.63 代码 DFlash 0.87 0.78 数学 只看第 1 位 EAGLE-3 0.81 DFlash 0.88 DSpark 0.93 箭头从第 1 位指向块里往后。一个个猜的越往后越稳, 一趟出整块的越往后越掉;第 1 位反而是浅草稿最弱。 ② 每轮平均收下几个字 Qwen3-8B,含大模型补的 1 个 0 1 2 3 4 5 6 4.66 4.77 5.65 数学 4.15 4.46 5.28 代码 2.58 2.97 3.50 闲聊 同一个草稿,闲聊比数学少收约两个字: 每次验几个,该看内容,也该看机器忙不忙。 开头靠草稿够深,往后靠前后照应;DSpark 两头都要 一趟出整块的草稿能叠得更深,第 1 位更准;DSpark 再用顺序小头把往后的下滑补回来。闲聊收得少,就是第二刀按把握定验几个的理由。
左边看箭头往哪指,右边看闲聊那组有多矮。
全部是 DSpark 论文实测;右图每类取三个基准的平均。
出处与口径

DSpark:arXiv 2607.05147。左:§4.3.1 正文给出的数(Figure 2 全曲线未逐点公开,图上只画正文写明的;右端是正文说的「块里更靠后」处,没写明是第几位)。右:表 1 Qwen3-8B,数学=GSM8K/MATH500/AIME25、代码=MBPP/HumanEval/LiveCodeBench、闲聊=MT-Bench/Alpaca/Arena-Hard,每类取三个基准的平均(本课计算)。

核对:九个基准的平均算出来 DSpark 比 EAGLE-3 高 26.7%、比 DFlash 高 18.4%,与论文正文一致。温度 1.0、块长 7、草稿 5 层(EAGLE-3 为 1 层)。

看第 2 格的分数条:同一个骨干,加了小头之后跟着第 1 格变。 (24 秒,Manim 渲染;默认连续播放;取消勾选「连续播放」、点「⟲ 重来」,再点「开始」一步一步看。分数是示意;0.2–1.3% 与 16–18% 是论文实测。)
看同一批草稿,闲时放进 14 个、忙时只放 7 个。 (26 秒,Manim 渲染;默认连续播放;取消勾选「连续播放」、点「⟲ 重来」,再点「开始」一步一步看。把握和吞吐表是示意,排队和停止规则照论文 Algorithm 1。)

EAGLE 和 MTP:长得一样,差在谁训

EAGLE 和 MTP 长什么样 —— 头尾借大模型,只训中间一小块 方框里橙色是要训的,蓝色是直接借大模型、不训的 要训 借大模型,冻住不训 数据怎么拼 EAGLE(2024-01):大模型冻住,草稿是外挂的一小块 大模型出字前那层的向量 大模型本来就算出来了 抽中的字 已定下的下一个 嵌入层 借 拼起来 2 倍宽 FC 压回 1 倍 一层 decoder 猜下一位的向量 LM head 借:向量变成字 草稿字 猜出的向量 + 刚抽中的字,再喂回去猜下一个:猜几个跑几趟 为什么要喂抽中的字: 光看向量,不知道 上一步按概率抽中了谁 70B 配的这块: 可训 0.99B 参数, A100 服务器 1–2 天 EAGLE-3(2025-03):改两处 改动一:三层拼起来,直接猜字 浅层向量 中层向量 深层向量 拼起来 3 倍宽 FC 压回 1 倍 不再猜向量,decoder 出来直接借 LM head 出字 改动二:第 2 个字起,拿草稿自己的输出顶替 第 1 步 大模型给的 how 大模型给的 can + 字 I do 第 2 步 大模型给的 how 大模型给的 can 草稿自己的 I + 字 do it I 大模型还没验,拿不到它的向量,只能用草稿上一步的输出顶上。 所以训练时就让草稿把自己的输出喂回来练:training-time test。 MTP(DeepSeek-V3 起):骨架几乎一样,差在谁训 DeepSeek-V3 的 MTP 模块 主干向量 + 下一个字的嵌入 归一化、投影 transformer block 输出头 与主模型共用 什么时候训 大模型动不动 EAGLE 模型发布以后,谁都能外挂上去训 冻住 MTP 厂家预训练时一起训,随模型发布 一起训 带 MTP 的还有 Qwen3-Next、GLM-4.5、小米 MiMo;Step 3.5 Flash 挂 3 个模块(MTP-3) 一层 MTP 连猜:输出喂回自己再跑一趟 MiMo-7B,第 1/2/3 个草稿字的接受率 70% 81% 第 1 个 10% 56% 第 2 个 2% 36% 第 3 个 原样连猜(只练过往前一步) 按连猜微调后(FastMTP) 长相差不多,差在谁训、练没练过连猜 EAGLE 不是免训练,只是训得少;MTP 能多猜几步,但草稿得按连猜练过,改个参数不够。
先看颜色:橙色要训,蓝色借大模型。三块的橙色都只有中间一小段;右下灰柱和绿柱比的是连猜练没练过。
结构按论文正文;how/can/I/do/it 是 EAGLE-3 论文的例子。
出处与口径

EAGLE:arXiv 2401.15077 v3 §3(Figure 6 说明:嵌入层、LM head 用目标模型参数不训;FC+一层 decoder;特征与提前一位的 token 嵌入拼 2 倍宽)、§4 Training(70B 可训 0.99B,A100 40G 服务器 1–2 天)。EAGLE-3:arXiv 2503.01840 v3 §3.1–3.2(低/中/高特征拼 3k 经 FC 压回 k;第 2 步起用草稿输出 a 顶替;training-time test);how/can/I/do/it 是论文 Figure 5 的例子。

MTP:DeepSeek-V3 技术报告 MTP 一节;各家采用见 sebastianraschka.com 架构图鉴 MTP 页、FastMTP 引言。接受率:FastMTP arXiv 2509.18362(MiMo-7B 单层 MTP,冻结主模型、自蒸馏数据微调 MTP 头;原样第 2 位约 10%,第 3 位约 2%)。

这一节带走 搬一趟权重换回好几个字:猜对几个出几个,最差出一个。人少时赚得最多,人一多就缩。
这一步进步多少:K3 在 GB300 上一个人用,每字间隔快到 4.81 倍;算上不受加速的首字,端到端吞吐是不开的 4.22 倍;64 个人一起用剩 1.74 倍。
人一多投机就帮得少了,每一趟还是那么重。下一节换一根杠杆:把货变轻。
想深挖:完整版第十一节。
第 八 节

量化:少搬字节,掉不掉点?

上一节的洞:人一多投机帮得少了,每一趟还是那么重。前面大多走「一趟多坐人」,这一节换另一条:车不变,货变轻,权重和 KV 少用几位存。 省多少?掉不掉点?

位数减半,搬运下限减半

位数减半,一步的搬运下限就减半 —— FP4 只要 BF16 的四分之一多一点 DeepSeek-V3 · 8 颗 TPU v7 · batch 1 · 只算权重(本课推导) BF16 FP8 MXFP4 NVFP4 每 token 要读的权重(37B 激活参数) BF16 16 bit 74.00 GB → 至少 1.26 ms FP8 8 bit 37.00 GB → 至少 0.63 ms MXFP4 4.25 bit 19.66 GB → 至少 0.33 ms NVFP4 4.5 bit 20.81 GB → 至少 0.35 ms 整个模型放得下吗(671B,按 HBM 裸容量) BF16 1,342 GB FP8 671 GB MXFP4 356 GB NVFP4 377 GB 8 颗合计 1,649 GB
先看左边四根条一根比一根短:位数减半,一步至少要花的时间也减半。
本课推导的理想值:带宽跑满,不含 KV 与通信,实际一步更慢。
出处与口径

V3:技术报告 arXiv 2412.19437 摘要,总参数 671B、每 token 激活 37B。TPU v7:Google Cloud 公开规格,每芯片 HBM 192 GiB、带宽 7.37 TB/s。右图统一用十进制 GB:8 × 192 GiB = 1,536 GiB ≈ 1,649 GB(本课推导)。

MXFP4:OCP Microscaling Formats (MX) Specification v1.0。NVFP4:NVIDIA 技术博客「Introducing NVFP4 for Efficient and Accurate Low-Precision Inference」。

⚠️ 本课推导:下限 = 激活参数 × 每参数位数 ÷ 8 ÷ (8 × 7.37 TB/s)。假设权重均匀摊开、带宽跑满;不含 KV、激活值和通信,实际一步更慢。

注:真实部署很少整模型都降到 FP4:DeepSeek-V4 只把专家放 FP4、其余多为 FP8(HF 模型卡)。

同一车货,换个装法 车还是那辆,每件货从 16 位装成 8 位、4 位。
人少时一步几乎全花在读权重上,字节减半,下限也减半。

专家压到 4 bit,注意力最多 8 bit

gpt-oss-120b 的模型卡分开列:专家 114.71B,注意力 0.96B,嵌入和输出层 1.16B。专家约占 98%,注意力不到 1%(本课推导)。OpenAI 只把专家压成 MXFP4,整个模型装进一张 80 GB 的卡。

我们在 TPU v7 上:图的是装进一台机器 R1、GLM-5.1 都从官方 FP8 出发,只压专家:每个输出通道定一把尺子,四舍五入到 FP4,不用校准数据,离线转一次存盘复用。
头一件好处是放得下:R1 专家 FP8 每个 device 约 101.8 GB(R1 FP4 部署 README 的记录),可用的 94.75 GiB 只合约 101.7 GB,激活和 KV 没地方放;FP4 约 60.9 GB,四颗芯片一台机器就跑起来。精度跑出来没塌(R1 的 GSM8K 约 95%),但没有同机 FP8 对照,说不出掉了多少。
只压专家 —— 整步字节约减半,不是减到四分之一 gpt-oss-120b · batch 1 · 每生成一个字读多少权重(GB,本课推导,不含 KV 和激活) 专家(选中的 4 个 × 36 层) 注意力 BF16 输出层 BF16 三根条只换专家的格式 专家 BF16 7.2 1.9 1.2 合计 10.2 专家占 70% 专家 FP8 3.6 1.9 1.2 合计 6.7 专家占 54% 专家 MXFP4 1.9 1.9 1.2 合计 5.0 专家占 38% BF16 → MXFP4:整步约 2.06 倍,FP8 → MXFP4 约 1.34 倍 不动的那两段(蓝、灰)三根条一样长;上下文一长,还要再加一段 KV。
从上往下看:橙色的专家一根比一根短,蓝、灰两段一动不动。
gpt-oss-120b 每出一个字读多少权重,按 config 推算,一个人用,不含 KV。
出处与口径

gpt-oss-120b config.json(hidden 2880、intermediate 2880、128 专家选 4、36 层、64 头、8 个 KV 头、head_dim 64、词表 201,088);模型卡 Table 1(注意力 0.96B、激活 5.13B)作核对锚点;MXFP4 每参数 4.25 bit(模型卡)。

按 config 算的注意力 0.955B、激活 5.12B(另加路由约 0.01B)对上模型卡;字节、占比、倍数为本课推导,未计 KV、激活和缩放外的开销。

所以呢:专家压到四分之一,整步只省一半左右:压完后注意力占每步字节约 38%(本课推导),上下文一长还要再加 KV。

掉不掉点:误差过四道关,掉多少看怎么压

误差过四道关。不是 softmax 把误差补回来了;跟着一个四舍五入误差从权重走到出字(出处见完整版第十二节):

掉多少,看怎么压。同是 4 bit,直接四舍五入和挑过缩放差一截:

同样压到 4 bit —— 挑缩放的方法决定掉多少 AWQ 那组测试 · Llama-2-7B · WikiText-2 困惑度(越往右越差) 16 位 AWQ 直接取整 困惑度刻度尺 5.40 5.45 5.50 5.55 5.60 5.65 5.70 5.75 5.80 16 位 5.47 不压 AWQ 4 bit 5.60 挑过缩放 四舍五入 4 bit 5.73 直接取整 比 16 位多掉的
红点离灰点远,绿点往回挪了一半:同是 4 bit,差在缩放怎么挑。
困惑度越低越好;只这一组模型和数据集。
出处与口径

AWQ:arXiv 2306.00978v5,Llama-2-7B、WikiText-2 困惑度 FP16 5.47、RTN 5.73、AWQ 5.60(INT4,每 128 个数一组缩放)。只这一组模型和数据集。

KV 也能压

KV 少存一半位数 —— 这两例都省不满一半 条长=每条 KV 的字节,压之前记作 1;红虚线=正好减半该到的位置;左右两个模型,不横比 压之前 压之后 DeepSeek-V3.2:BF16 → FP8 BF16 FP8 同显存约装 1.63 倍的人(本课推导) 正好一半 多出来的:没压的位置编码、新加的缩放、本来就是 FP8 的索引键 DeepSeek-V4.1-Flash:FP8 → FP4 FP8 FP4 小 45% 正好一半 没缩满一半的那截是缩放:每 16 个数一个,缩放字节反比 FP8 多一倍
两根绿条都停在红虚线右边。
左右是两个模型、两种压法,只看各自省了几成。
出处与口径

V3.2:FlashMLA README(2026-09-30 提交 2e5429f 之前版本「FP8 with scale」)每 token 每层 512 个 FP8 + 4 个 FP32 缩放 + 64 维 BF16 RoPE = 656 B,另加 132 B 的 FP8 indexer key;BF16 = (512 + 64) × 2 + 132 = 1,284 B。本课推导:1,284 ÷ 788 ≈ 1.63,没算权重和激活。

V4.1-Flash:2026-09 模型卡称主 KV 存 FP4(每 16 个数一个缩放),FlashMLA 同时放出读它的 kernel;但 README 写这个格式只能用于 extra_k_cache,k_cache 那份仍是 FP8。每 token FP4 256 B 数据 + 32 B 缩放 = 288 B,FP8 512 B 数据 + 16 B 缩放 = 528 B,小 45%(本课推导)。

这一节带走 省:位数减半,下限减半;专家压到 4 bit、注意力最多 8 bit,整步省一半左右。掉:误差大多半路被消化,softmax 会把误差放大,所以护着注意力;掉多少要实测。
这一步进步多少:vLLM 在 2 张 H100 上给 Llama 3 70B 换 FP8 权重,每字间隔最多降到一半;gpt-oss-120b 只压专家,装进一张 80 GB 的卡。
招都讲完了。最后一节回到那一趟:拿到一个模型、一批卡,从哪下手。
想深挖:完整版第十二节。
第 九 节

第一天上手,先问哪几个问题?

招齐了。回到第零节那一趟:拿到一个模型、一批卡,第一天先问哪几件事? 八问:前四问在纸上算账,后四问才去拨开关。

第一天的八问 —— 先定尺子和账,再挑招数 还是第零节那一趟:每一问钉在它问的那个部件上 校准尺子 / 上线 分给更多 token 少搬 拆开放对地方 八个图钉 吞 prompt KV 仓库 = 显存 权重 KV 权重 工位 = 算力 1 2 3 4 5 6 7a 8 7b 算账 1 负载长什么样? 2 用哪把尺子? 3 一步至少搬多少字节? 4 放得下几条序列? 挑招数 5 attention 怎么切? 6 拆不拆 PD,配几台? 7a 量化、 7b 投机开不开? 8 上线前跑通了吗?
先看车上:3、4、7 号钉在货和座位上,8 号钉在车头,问的都是那一趟。
颜色对着两条路:蓝=分给更多 token,绿=少搬;橙=拆开放;灰=尺子和上线。
出处与口径

⚠️ 本课归纳:顺序按「先校准、再算账、后调招数」排,各问拿什么回答、判据见正文和对应的节。

先对尺子,再量这一趟

卡在哪,用哪招(⑤–⑦)

顺序别反:还是第四节那套 vLLM 实测,先换 DEP 每卡 2.09 倍,只调并发(256 → 512)才涨 28%(见完整版第十节)。

⭐ 八问是一个问题:这一趟卡在哪;招要么让更多人分,要么让它变轻。

开场那道题:光改软件,几倍?

第零节的题:同一套 GB300、同一个 DeepSeek-V4-Pro、每个用户出字一样快,光改软件,每卡吞吐是首发日的几倍?

卡没换、模型没换、出字一样快 —— 只换软件,每卡 5.1 倍 左:GB300 · DeepSeek-V4-Pro · SGLang;右:另一组模型和卡,只看 MTP 的量级 首发日 六月(开 MTP) MTP 层数 每卡每秒 token(同一交互档) 约 2,200 首发日 2026-04 · 不开 MTP 约 11,200 六月 2026-06 · 开 MTP ×5.1 本课推导 另一组:8 张 B200 · R1 · 单用户 111 不开 198 1 层 253 3 层 239 5 层 反而降了 每个字的成本约降到五分之一(本课推导:按全部卡算、卡价不变) 每卡除的是 decode 卡还是全部卡,博客没写;两个数出自同一张图,比值不受影响。 5.1 倍是整个软件栈改进的合计,MTP 占多少博客没拆;右边只当量级参考。
左边两根柱子之间,卡、模型、交互档都没换。
右边换了模型和卡,只当 MTP 的量级参考。
出处与口径

左:PyTorch 博客 2026-06-23「Serving DeepSeek-V4 on GB300 with SGLang: 5x Higher Throughput at the Same Interactivity Since Day-0」(「the June 2026 MTP curve delivers ~11,200 tok/s/GPU … versus ~2,200 tok/s/GPU for the Day-0 (April 2026) no-MTP curve」)。

本课推导:11,200 ÷ 2,200 ≈ 5.1;成本 2,200 ÷ 11,200 ≈ 0.196。

右:TensorRT-LLM 技术博客「Pushing Latency Boundaries: Optimizing DeepSeek-R1 Performance on NVIDIA B200 GPUs」,8 × B200、输入 1k 输出 2k,不开 MTP 111 TPS/user,MTP1 198、MTP3 253、MTP5 239;模型和卡都与左边不同。

别把各节的倍数乘起来 Orca 比的是 FasterTransformer,分页比的已经有 Orca。后一个的基线就是前一个,乘起来就把 Orca 重复算了。同口径的总账只有这一笔。
这一节带走 八问是一个问题:这一趟卡在哪。先对尺子、量清楚,答案自己指向某一招。
这一步进步多少:同一套 GB300、同一个 V4-Pro、同一个交互档,光改软件,每卡是首发日的 5.1 倍(本课推导)。
下一个洞:线性注意力层只揣一张随写随改的便条(第四节),截不出前缀那一份;tpu-inference 上跑 Qwen3.5,前缀缓存至今还得关。
谁再报一个倍数,先问三句:比的是谁,哪一档,分母几张卡。
想深挖:完整版第十五节。

← 回 课程总纲 · 上一讲 专题五 · 并行策略 · 想深挖 专题六完整版(L300)
本页由 Courses/tools/topic06-build-L200.py 拼装,正文在 topic06_L200_s*.py。