第 20 关 · 原理 · 在浏览器里运行
English

推理成本:显存与速度

模型每写一个 token,要花多少显存和时间?

第 16 关到第 19 关搭出了一个能给出正确答案的模型。这一关问的是:运行它要花多少代价。模型写东西时,有两样东西限制它。 一样是它在 GPU 上需要的显存,另一样是每个新 token 要花的时间。两者都只取决于模型的几个数,完全不需要训练。 下面的每个数你都可以手算验证。

1. KV 缓存:模型写东西时要留着什么

模型写东西时,每个新 token 都要关注它之前的每个 token,所以需要它们的 K 和 V。 这些一旦算出来就不会再变,因为一个 token 永远看不到它后面的东西。所以模型把它们留在 GPU 显存里。 对每个新 token,它只算这一个 token 的 q、k 和 v:

交给模型的 token(从 0 开始数)现在计算从 KV 缓存里读
token 3token 3 的 q、k、vtoken 0–2 的 k、v
token 4token 4 的 q、k、vtoken 0–3 的 k、v

这就是第 18 关第 7 节里的那个缓存。现在来数它有多大。在每一层、每个注意力头里,每个 token 都留着一个 k 向量和一个 v 向量, 各有 dkd_k 个数。模型用 16 位存每个数,也就是 2 字节。显存用 KiB(1 KiB = 1,024 字节)和 GiB(1 GiB = 1,024 × 1,024 KiB)来计:

bytes per token=2×heads×dk×layers×2\text{bytes per token} = 2 \times \text{heads} \times d_k \times \text{layers} \times 2

第一个 2 是 k 和 v 两份;最后一个 2 是每个数的字节数。举个小例子:1 个头、dk=4d_k = 4、2 层, 每个 token 就是 2 × 1 × 4 × 2 × 2 = 32 字节。

数字 一个模型有 32 层、32 个注意力头,dₖ = 128,每个头都有自己的 K 和 V。每个数占 2 字节。一个 token 需要多少 KiB 的 KV 缓存?(1 KiB = 1,024 字节)
我卡在这里了 为什么缓存随对话变大,而不只随模型变大?

到目前为止写出的每个 token 都在每一层留着自己的 k 和 v。回答里的第 100 个 token 要关注它前面的 99 个 token(还有整个提示词)。所以它们都要留在显存里,直到对话结束。 对话长一倍,缓存就大一倍。相比之下,不管对话是 10 个 token 还是 10,000 个,权重的大小都一样。

2. 分组查询注意力:共用 K 和 V

这个缓存随每个 token、每一层、每个 K/V 头增长。一块 GPU 能服务多少用户,常常就卡在它上面。 分组查询注意力(grouped-query attention)让它变小:几个查询头共用一个 K/V 头。

分组查询注意力:查询头共用 K/V 头,缓存就变小了

选择 K/V 头的个数。指向或点一下某个 K/V 头,看看哪些查询头读它。

8 个 K/V 头,每个查询头一个

8 个查询头Q0Q1Q2Q3Q4Q5Q6Q7KV0KV1KV2KV3KV4KV5KV6KV78 个 K/V 头:缓存存的东西
每个 token 的 K/V 缓存 8,192 字节

为了让图看得清,这里用一个小模型:8 个查询头,dₖ = 64,4 层。题目里用的是 32 个查询头和 32 层,但共用的方式一样。

K/V 头
每个 token 存的 K 和 V = 2 × 8 个头 × 64 × 4 层 × 2 字节 = 8,192 字节 (8 个头时大小的 100.0%)
你选的组:一个 K/V 头和读它的查询头 其他组

K/V 头变少以后,几个查询头用同一份键和值。每个查询头仍然有自己的 q,所以每个头仍然可以找不同的东西。 但它们都在同一份键里找。

数字 一个模型有 32 个查询头和 8 个 K/V 头,都从 0 开始编号;相邻的查询头共用一个 K/V 头。查询头 13 用的是哪个 K/V 头?
先猜一猜先猜一猜:把 K/V 头从 32 个减到 1 个(32 个查询头共用一份 K 和一份 V),KV 缓存缩小到 1/32。质量会怎样?
动手试试

在实验台里,把 K/V 头从 8 个调到 1 个。每个 token 的显存降到 12.5%。再试试 4 和 2。 如果占满 GPU 的是缓存而不是权重,你会选哪个?查询头又会失去什么?

数字 一块 GPU 有 24 GiB 显存,模型的权重占了其中 16 GiB。剩下的放 KV 缓存。模型用分组查询注意力,有 4 个 K/V 头,dₖ = 128,32 层,每个数存成 2 字节。能放下多少个 token 的 KV 缓存?(1 KiB = 1,024 字节,1 GiB = 1,024 × 1,024 KiB)

这些都只是写东西时的显存。训练时每个权重需要多得多的显存,还要把前向传播的值留给反向传播。 支线 U6 会数这部分显存。

3. FLOPs:一个 token 要花多少算术

计算量用 FLOPs 来计:浮点运算次数,每次是一个乘法或一个加法。矩阵乘积 (1, a) @ (a, b) 得到 b 个数。每个数需要 a 次乘法和大约 a 次加法。 所以这个乘积要花 2 × a × b 个 FLOPs。对 (1, 3) @ (3, 4) 来说就是 24。

一个 token 经过模型的每个权重矩阵一次,每个权重做一次乘法和一次加法。 所以有 N 个权重的模型,前向传播大约每个 token 花 2N 个 FLOPs。在嵌入表里查一个 token 的那一行不是乘法, 所以严格地说,N 只算矩阵乘积里用到的权重。

这一关的数都很大,所以写成 10 的幂。10 的幂相除,就把指数相减:10¹⁴ / 10¹⁰ = 10⁴。 数学页里有更多例子。

数字 一个模型有 70 亿个权重。一块 GPU 每秒做 10¹⁴ 个 FLOPs(100 万亿)。用前向传播的 2N 规则,只算算术的话,它每秒最多能产生多少个 token?

2N 里还少了一部分:注意力本身。在一个块里,向量大小为 dd(模型宽度)的新 token 要做下面这些步骤。 它关注 L 个 token,所有头加起来每个 token 用 dd 个数。

步骤乘积每个 token 的 FLOPs
q、k、v 和输出:四个 (d,d)(d, d) 矩阵(每个查询头一个 K/V 头)(1,d) @ (d,d)(1, d)\,@\,(d, d),四次2×4d22 \times 4d^2
FFN:先 (d,dff)(d, d_{ff}),再 (dff,d)(d_{ff}, d)先 (1,d) @ (d,dff)(1, d)\,@\,(d, d_{ff}),再 (1,dff) @ (dff,d)(1, d_{ff})\,@\,(d_{ff}, d)2×2 d dff2 \times 2\,d\,d_{ff}
分数:q 和 L 个 token 的 k(1,d) @ (d,L)(1, d)\,@\,(d, L)?
L 个值向量的加权和(1,L) @ (L,d)(1, L)\,@\,(L, d)?

前两行就是块里权重的 2N 规则。用分组查询注意力时,k 和 v 矩阵比 (d,d)(d, d) 小,2N 仍然能正确地数出它们的权重。 后两行完全不用权重。对它们的形状用 2 × a × b 规则。

数字 一个块的模型宽度 d = 64,FFN 宽度 256。一个新 token 关注 L = 128 个 token。它的注意力需要两个乘积:分数 (1, 64) @ (64, 128),和加权和 (1, 128) @ (128, 64)。这个 token 在整个块里花多少 FLOPs,权重和注意力合起来?

每个注意力乘积花 2Ld 个 FLOPs,所以注意力部分是 4Ld。它随 L 增长,L 是新 token 要关注的 token 数。 权重部分保持不变。

数字 一个块的模型宽度 64,FFN 宽度 256,所以它的权重部分是每个 token 98,304 个 FLOPs。它的注意力部分是 4 × L × 64 个 FLOPs。上下文长度 L 是多少时,两部分相等?
深入一点 训练每个 token 大约花 6N

训练要跑前向传播(2N)和反向传播,后者大约是前者的两倍。对每个权重, 反向传播既要算这个权重的梯度,也要算它的输入(上一层的输出)的梯度。所以训练大约 每个 token 花 6N 个 FLOPs。第 21 关的参考 GPT 有 N = 102,415 个权重:前向传播每个 token 大约 0.2 百万个 FLOPs。 它的两张嵌入表大约占权重的 2%,所以把它们算进去,估计几乎不变。 一轮是 8,500 道题,每道 10 个 token。所以一轮大约花 6 × 102,415 × 85,000 ≈ 5.2 × 10¹⁰ 个 FLOPs。 笔记本电脑几秒钟就能做完这些算术。真实的训练会更久,因为有 Python 的开销,而且矩阵很小。 第 21 关的上下文只有 10 个 token,所以那里的注意力部分很小。

4. 解码:每一步一个 token

GPU 把权重存在它的显存里,运算单元必须从那里把它们读出来。读的速度就是 显存带宽,单位是字节每秒。带宽用十进制单位给出,所以这一关接下来 1 GB = 10⁹ 字节。 (1 GiB 是 1,024³ 字节,大约 1.07 GB。)

一次一个 token 地写出答案叫作解码(decode)。每一步解码产生一个新 token。

先猜一猜算之前先猜:一块 GPU 每秒算 10¹⁴ 个 FLOPs,每秒从显存读 10¹² 字节。它用一个 70 亿权重的模型给一个用户写回答。是什么限制了速度?

每一步解码都要把每个权重读一遍。下一个 token 要用这一个作为输入。所以这一个没写完,下一个就不能开始, 权重也要再读一遍。

对一个用户来说,这给出一个简单的上限:

tokens per second≤bandwidthweight bytes\text{tokens per second} \le \frac{\text{bandwidth}}{\text{weight bytes}}
数字 一个模型有 70 亿个权重,每个 2 字节。GPU 每秒从显存读 10¹² 字节,每个新 token 都必须把每个权重读一遍。对一个用户,它每秒最多能写多少个 token?(保留 1 位小数)

服务器不会一次只给一个用户写。它在一步里把权重读一遍,再用它们一起写 B 个用户的下一个 token: 读一次的代价,换来 B 个 token。但算术仍然随 B 增长。所以 B 足够大时,限制就变成算术,而不是读取。 一步的时间取两者中较长的那个。

数字 一个模型有 70 亿个权重,每个 2 字节。一步解码以每秒 10¹² 字节的速度读 1.4 × 10¹⁰ 字节的权重。每个用户的 token 花 1.4 × 10¹⁰ 个 FLOPs,速度是每秒 10¹⁴ 个 FLOPs。一步同时服务 B 个用户,只读一遍权重。B 是多少时,算术和读取花的时间一样长?

两个时间相等时的 B 叫作交叉点(crossover)。低于它,读权重是瓶颈;高于它,算术是瓶颈。

每一步还要读每个用户的 KV 缓存。假设有 8 个用户,每人 4,000 个 token,每个 token 128 KiB。 他们的缓存共 4,096,000 KiB。乘以 1,024,大约是 4.2 × 10⁹ 字节,也就是 4.2 GB。所以一步要读 14 + 4.2 ≈ 18.2 GB,花 18.2 ms, 而不是 14 ms。每个用户现在每秒大约得到 55 个 token,而不是 71 个。

缓存还必须和权重一起放进 GPU 的显存。第 2 节用 GiB 计显存。这里和带宽一样,1 GB = 10⁹ 字节。

数字 一块 GPU 有 80 GB 显存。里面放着那个 70 亿权重模型的 14 GB 权重,以及每个用户的 KV 缓存。每个用户有 4,000 个 token 的缓存,每个 token 128 KiB。最多能放下多少个用户?(1 GB = 10⁹ 字节,1 KiB = 1,024 字节)

B 个用户的一步解码:读取时间和算术时间

拖动滑块增加用户。再给每个用户更长的对话。

020406050100150200250一步里的用户数 B每步时间(ms)读取:权重算术:B × 2NB = 100 时相等
每个用户的 token 数
B = 8:读取 14.00 ms,算术 1.12 ms,所以一步要花 14.00 ms。 每个用户每秒 71.4 个 token, 总共每秒 571 个。
显存: 14 GB 权重 + 0.0 GB 缓存 = 14.0 GB,共 80 GB。
你的 B 交叉点:B = 100 时两个时间相等
我卡在这里了 既然多一个用户几乎不花代价,为什么不同时服务 1,000 个?

有两个原因。B 超过 100 以后,每多一个用户,每一步都要多一份算术,所以每个用户拿到 token 的速度都变慢。 有 256 个用户时,一步要花 256 × 0.14 ms ≈ 36 ms,而不是 14 ms。另外,每个用户都带着一份 KV 缓存, 它必须和权重一起放进显存。每个用户 4,000 个 token 时,一块 80 GB 的 GPU 只放得下 125 个用户。 所以一块 GPU 能服务多少用户,常常是由 KV 缓存决定的,而不是算术。

权重只为所有 B 个用户读一次。相比之下,每个用户的缓存只为这个用户自己读,所以这部分读取没法在用户之间共享。 对话很长时,多一个用户就不再是几乎不花代价了。在实验台里,给每个用户 4,000 个 token:两条线永远不会相交。 K/V 头更少,缓存就更小,既省显存,也省时间。

另一种少读一些的办法,是用更少的字节存每个权重。

数字 把 70 亿个权重每个存成 1 字节,而不是 2 字节。GPU 仍然每秒读 10¹² 字节,每个用户的 token 仍然花 1.4 × 10¹⁰ 个 FLOPs,速度是每秒 10¹⁴ 个 FLOPs。现在 B 是多少时,算术和读取花的时间一样长?

5. 预填充:用一次前向传播读完提示词

解码开始之前,模型必须先读提示词。提示词的所有 token 一开始就都知道了。所以它们用一次前向传播穿过模型, 就像训练时整个序列那样(第 17 关第 4 节)。 这一次前向传播叫作预填充(prefill)。它还会把每个提示词 token 的 k 和 v 填进 KV 缓存。

预填充时,权重为全部 L 个提示词 token 只读一次。这和一批 L 个用户是同一个道理。

数字 一个模型有 70 亿个权重,每个 2 字节。GPU 每秒读 10¹² 字节,每秒做 10¹⁴ 个 FLOPs。它用一次前向传播读一个 2,000 个 token 的提示词。权重读一遍(14 ms),每个 token 花 1.4 × 10¹⁰ 个 FLOPs。这一次前向传播要多少 ms?
数字 同样的模型和 GPU:70 亿个权重,每个 2 字节,每秒读 10¹² 字节,每秒 10¹⁴ 个 FLOPs。现在提示词只有 50 个 token。预填充这一次要多少 ms?

所以一次聊天回答分成两部分,受的限制不同。第一个新 token 要等预填充。提示词超过大约 100 个 token 时 (就是第 4 节的 B = 100),预填充受算术限制。更短的提示词仍然在等读权重。 第一个 token 之后的每个 token 都来自解码,而解码受显存限制。

现在把整个解码步骤写成一个函数。它就是你在运行任何模型之前都能做的那个估计。

代码写出一步解码的 serve。B 个用户每人有一份 KV 缓存,长度是给定的 token 数。这一步把权重读一遍,再读每个用户的缓存。它还为每个用户的 token 做 2N 个 FLOPs。bytes_per 是每个存储的数的字节数:权重和 KV 缓存都用它。这一步花的是读取和算术中较长的那个。返回一步的时间(ms)、每个用户每秒的 token 数,以及每秒的 token 总数。

Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行

第 21 关把各部分拼起来:你会写出并训练你自己的 GPT。它的上下文只有 10 个 token,所以它的注意力部分和 KV 缓存都很小。

小结

通关后的总结

通关后,这里会显示关键公式和常见错误。

你现在会了

  • 算出一个模型的 KV 缓存有多大,并看出分组查询注意力怎样让它变小。
  • 数出一个 token 的 FLOPs:权重部分是 2N,再加上一个随上下文增长的注意力部分。
  • 算出 B 个用户一步解码要多久,并分清预填充(提示词很长时受算术限制)和解码(受显存限制)。

要记住

  • ;一个块:
  • 预填充用一次前向传播读完整个提示词。提示词超过大约 100 个 token 时,它等的是算术。解码每一步写一个 token,等的是显存。

常见错误

  • 算 KV 缓存大小时,漏掉 K 和 V 的那个 2,或者每个数 2 字节的那个 2。
  • 每个权重只算了一次 FLOP,而不是两次(一次乘法和一次加法)。

按 ? 查看快捷键

阅读模式 · 实验台数值全部显示,不计星