图解 · 你问 ChatGPT 的那一瞬间

一趟一个字

你问 ChatGPT 一个问题,字一个一个地蹦出来。每蹦出一个字,机房里的 GPU 都得把整个模型从仓库搬上工作台,从头翻到尾。

这一页只用一个比喻:搬书。跟着一句问题,把这一路走一遍。

你

Explain the KV cache in one sentence.

用一句话解释 KV 缓存。
AI

KV 缓存把算好的“键”和“值”存起来,每写一个新字,就不用对整段提示重做一遍注意力计算。
完成 · 22 个 token先停一下,再一个一个冒出来。色块是切分的边界(示意)

读完这一页,你能回答这三个问题:

↓ 往下滑:文字一段一段推进,图跟着动。全程只看一句问题,模型用原文的例子 Llama 3 8B。

01 / 16你按下了发送

01

你按下了发送

这句话被装进一个加密的信封,寄到很远的机房。进门先查两样:钥匙对不对,额度够不够。

02

先切成小块

模型不认字,只认号码。整句话被切成一小块一小块,每块换一个号码。

这种小块叫 token。下面为了顺口,就叫它“字”。

连同系统提示,整个请求约 40 块

03

号码换成一长串数

每个号码去一本 128,256 行的“字典”里,翻到自己那一行,抄下 4,096 个数。只翻页,不计算。

04

认识一下这台机器

GPU 里有一个大仓库(显存)和一张工作台(计算核心)。模型就是仓库里一本 16 GB 的书,一共 32 章。

规矩只有一条:要算,就得把整本书搬上工作台,从第 1 章翻到第 32 章。这叫“搬一趟”。

05

读题:搬一趟,全读完

40 个字一起上桌,书只搬一趟。每翻一章,每个字都回头看看它前面的字。

同样是搬一趟,这回工作台有 40 个字要算,忙得很。顺手给每个字记一张小抄。

06

翻到最后,抽第一个字

模型给 128,256 个候选字各打一个分,再按分数抽签。这一次,抽中了 The。

07

写答案:一趟一个字

接下来每写一个字,书都得再搬一趟。工作台一眨眼就算完,大部分时间在等书。

原文:8B 模型在 A100 上,一趟约 5–10 毫秒

对一下账:16 GB ÷ 约 2 TB/s 的显存带宽 ≈ 8 毫秒。时间几乎全花在搬书上。推算

08

小抄:新字不用从头来

没有小抄,每写一个新字,前面所有字都得重算一遍。有了小抄,新字只算自己,旧字照着抄。

写 500 个字:没小抄是 500² 量级的活,有小抄是 500 步

09

小抄也占仓库

小抄和书挤在同一个仓库里。对话越长,小抄越厚。

2,000 个字 ≈ 250 MB · 10 万个字 ≈ 12.5 GB

10

写一个,送一个

每抽出一个字,马上推到你的屏幕上。所以你看到的是:先停一下(读题),然后嗒、嗒、嗒。

常见每秒 20–80 个字

11

推理模型:还有看不见的字

推理模型会先在后台“想”。想的每个字,也要搬一趟书。你看不见,但照样计费。

原文举例:200 个字的回答,可能要计费几千步

12

拼桌:一趟,多人受益

反正都要搬一趟书,不如顺手给别人也写一个字。服务 1 个人还是 32 个人,书一样重。

谁写完谁走,新人马上补位。

13

抢跑:让小徒弟先猜

小徒弟拿着一本薄书,飞快猜出后面 4 个字。大书只搬一趟,就能把 4 个一起检查:对的留下,第一个错的当场改掉。

好猜的内容(比如代码)常能快 3–4 倍,写出的字和一个个写的完全一样

14

书太大,一个仓库装不下

70B 的模型是一本 140 GB 的书,一张 H100 只有 80 GB。只好拆开,放进几张卡:

  • 按章拆:前半本、后半本各放一张卡,像流水线。
  • 每页撕开:几张卡各拿每页的一条,每翻完一章对一次答案。
  • 专家分住:书分成很多“专家”小册子,每个字只去找它选中的几位。

15

同样的开头,第二次便宜

开头的小抄还留在仓库里,下次直接用,不用再读一遍,API 也会给你打折。

前提是:你得被分到同一台机器。

16

回到你的屏幕

对你来说,只是一行字慢慢冒出来。对机房来说:先搬 1 趟读题,之后每多写一个字,就再搬一趟。

一趟,一个字。

三个问题

现在可以回答了

问题 1

为什么第一个字,总要等一下?

书得先搬一趟,把你整段话读完,才能抽第一个字。推理模型还要先在后台“想”一阵,想的字也要一趟一趟地搬。

第 05、11 段 ↑

问题 2

为什么很短的回答,账单也可能很长?

你看不见的“思考”,也是一个字一趟写出来的,照样按解码步计费。原文举例:200 个字的回答,可能计费几千步。

第 11 段 ↑

问题 3

为什么同样的开头,第二次问更便宜?

开头的小抄还留在仓库里,读题那部分可以省掉,API 把省下的钱以“缓存命中”打折还给你。前提是请求被分到了同一台机器。

第 15 段 ↑

折腾一大圈,只为写出一句解释 KV 缓存的话。而让这句话写得出来的,正是 KV 缓存本身。

动手试试

你来当一回 GPU

每按一下,就是把书搬一趟。先照常写完一句,再试试带上小徒弟、拉几个人拼桌,看看每趟能写出几个字。

搬了几趟
0
写出几个字(所有人)
0
平均每趟几个字
–
大约花了多久
0 毫秒

耗时按每趟约 8 毫秒推算。小徒弟每次猜中几个是按“代码类常能猜中 3–4 个”随机模拟的示意。新人坐下的第一趟要先读题。

给较真的人

比喻背后的正式说法

上面每一段都为了好懂省掉了细节。下面按段补上术语、数字和原文出处。

  1. 01请求。原文的例子是一个 HTTPS POST:模型 llama-3-8b-instruct,打开 stream(边写边发),一条系统提示 “You are a concise assistant.”,加上你的问题。ChatGPT、Claude、Cursor 发出的请求大同小异。
  2. 02分词(tokenize)。BPE(字节对编码)分词器和模型一起训练,上线后固定。Llama 3 的词表有 128,256 个;主流模型多在 10 万–20 万之间。同一句话换个模型,编号就不同:“Hello world” 在一个模型里是 [9906, 1917],在另一个里是 [15496, 995]。图里的编号取自原文插图,原文注明为示意。中文也会被切块:常用字多为一字一块,常用词可能合成一块,生僻字可能拆成几块。
  3. 03嵌入(embedding)。“字典”叫嵌入矩阵,是模型权重的一部分:128,256 行 × 4,096 列(d_model = 4,096)。40 块查完,得到一张 40 × 4,096 的表。
  4. 04书和章。Llama 3 8B 的权重用 FP16 存约 16 GB;32 章对应 32 个 Transformer 层。“搬一趟”指一次前向计算:权重要从显存读进计算核心。严格说,书没有离开仓库,读的是它的一份拷贝。
  5. 05读题(预填充,prefill)。一次前向计算处理全部已知 token,是大矩阵乘法;提示长到上千块时,吃的是算力(compute-bound),1,000 块也只要毫秒级。每层先做注意力 softmax(QKᵀ/√d)·V,再过前馈网络。Llama 这类模型每个字只看它前面的字(因果注意力);实际算子(FlashAttention-3、FlashInfer)分块计算,不摊开完整的 N×N 分数表;有些模型部分层只看附近一段(滑动窗口注意力)。Llama 3 8B 用分组查询注意力:32 个查询头共用 8 组键值头,小抄因此小 4 倍。
  6. 06抽签(采样,sampling)。最后一个位置的向量经过语言模型头(4,096 → 128,256 的线性层)得到分数,softmax 成概率再抽。图中前五名的概率取自原文插图。温度、top-p、top-k 会在抽之前重塑分布;常见默认是温度 1、top-p 不设限,0.9 属于手动改的;推理模型常用更低温度,有的 API 改成“思考预算”。本页把第一个字算在读题那一趟里;原文把首字时间写作“预填充 + 一步解码”,两种数法差一趟,不影响结论。
  7. 07写字(解码,decode)。每个新 token 一次前向计算,只有最后一个位置的结果有用,瓶颈在读显存(memory-bound)。原文:8B 模型在 A100 上一步约 5–10 毫秒。“对一下账”是本页推算:A100 的显存带宽约 2 TB/s(这个数不是原文的),读一遍 16 GB 约 8 毫秒,正好落在原文的范围里。
  8. 08小抄(KV 缓存)。保存每个 token 在每一层的键(K)和值(V)。没有它,生成第 N 个 token 要重算前面所有的 K、V;原文的例子:500 个 token 的回答,是 O(500²) 的注意力工作量,而不是 500 步。图里“69 次对 6 次”只画了 6 步,是示意。
  9. 09小抄有多大。KV 缓存 = 2 × 层数 × KV 头数 × 每头维度 × 长度 × 批大小 × 字节数。Llama 3 8B、2,000 块、FP16:2 × 32 × 8 × 128 × 2000 × 2 字节 ≈ 250 MB;10 万块约 12.5 GB;如果不分组(老式多头注意力),2,000 块约 1 GB。DeepSeek 用多头潜在注意力(MLA)把每层每个 token 压成 576 个数,61 层、FP16 约 70 KB/token,10 万块约 7 GB(常规存法要几百 GB)。图中“按比例画”以书 16 GB 为尺。
  10. 10送回(流式)。用 SSE 或 WebSocket 帧,出一个推一个;常见 20–80 token/秒,取决于模型大小和硬件。1 万块的系统提示如果没被缓存,停顿会很长。
  11. 11推理模型。可能几毫秒就读完题,却还在解码你看不见的思考 token,所以“第一个可见字出现的时间”不再能代表预填充。原文:200 个 token 的回答,可能计费几千个解码步。
  12. 12拼桌(批处理)。权重不管批大小是 1 还是 32 都要读一遍,多带请求就是摊薄这次读取。静态批要等最长的请求;连续批让写完的请求立刻让座,新请求的预填充随时插进来。PagedAttention 把 KV 缓存按固定大小的页存放,像虚拟内存。两种阶段抢同一张卡时,切块预填充(chunked prefill)把长提示切段夹在解码里做;预填充/解码分离(vLLM、SGLang、Mooncake、NVIDIA Dynamo)给两者各配一组 GPU,读完用 NVLink 或 RDMA 传 KV 缓存,传输有成本,规模大才划算。
  13. 13抢跑(投机解码)。草稿模型猜 N 个,大模型一次前向校验,接受与自己一致的前缀,从第一个不一致处重新采样;输出分布和逐个生成完全一样。代码、事实类文本常能保留 5 个里的 3–4 个(约 3–4 倍);开放式写作收益变小。生产上常用 EAGLE-3(在大模型隐藏状态上训练的轻量“猜测头”),DeepSeek-V3、GLM 这类 MoE 模型则内置多 token 预测(MTP)。图中例子取自原文插图。
  14. 14拆书(并行)。8B 用 FP16 约 16 GB,70B 约 140 GB;H100 80 GB、H200 141 GB、B200 180 GB。生产上多不用 FP16:原文说,用 FP8,以及在 Blackwell 上用 4-bit,70B 就能装下并给小抄留出地方。按章拆 = 流水线并行(不用层内同步,但请求要够多才不空转);每页撕开 = 张量并行(每层都要同步,只有 NVLink 这类高速互联才划算);专家分住 = 专家并行(MoE 专用)。DeepSeek-V3 共 6,710 亿参数,每个 token 只激活约 370 亿。
  15. 15同样的开头(前缀缓存)。同样的前缀算出完全相同的 K、V,可以直接复用。vLLM 的 automatic prefix caching、SGLang 的 RadixAttention 都维护一张“算过的 KV 块”查找表;API 以缓存命中折扣把省下的钱还给你。能不能命中,取决于请求有没有被路由到同一台服务器:这是路由的问题,不是缓存的问题。图中机器数和分配结果为示意。

比喻对照表

页面里的说法正式名称一句话
仓库显存(HBM)放模型权重和 KV 缓存;容量大,但读取有带宽上限
工作台计算核心做矩阵乘法的地方,快得多
书模型权重Llama 3 8B 用 FP16 约 16 GB
章Transformer 层Llama 3 8B 有 32 层
搬一趟一次前向计算把全部权重读一遍,算一轮
字、块token模型处理文字的最小单位
字典嵌入矩阵128,256 行 × 4,096 列
读题预填充(prefill)一次处理全部提示,吃算力
写字解码(decode)一次一个 token,等显存
抽签采样(sampling)按概率选下一个 token
小抄KV 缓存每个 token 每层的键和值
拼桌连续批处理一次前向同时服务多个请求
小徒弟投机解码的草稿模型先猜几个,大模型一次验收
按章拆 / 每页撕开 / 专家分住流水线并行 / 张量并行 / 专家并行一张卡放不下时的三种拆法
同样的开头前缀缓存复用相同提示前缀的 KV 缓存