13.1 推理的成本结构:显存、算力、带宽谁先成为瓶颈

本页范围:第 13 章第 1 节 | 整理时间:2026-10-10

快速浏览

核心问题模型训练完交付使用,之后每产出一个 token 都要花真金白银的算力。同一个模型、同一张卡,为什么训练时 GPU 忙得不可开交,推理(decode)时算力却大片闲置?推理的成本到底由哪几本账决定,谁先顶到天花板?
本节主张推理成本可以拆成三本账:显存(装不装得下)、算力(算得快不快)、带宽(搬得动搬不动)。decode 阶段受自回归约束只能逐 token 串行,每生成一个 token 都要把全部权重从显存搬进计算单元一次,搬运量与参数量成正比、与峰值算力无关,于是带宽先成为瓶颈,算力大量空转。
一句话结论decode 的吞吐上限 ≈ 显存带宽 ÷ 权重字节数,公式里根本没有峰值算力;本章后续的优化技术(KV Cache、批处理、量化、蒸馏、投机采样)本质都是在这个公式和算术强度公式里动变量。
关键词
memory-bound算术强度roofline显存带宽FLOPsprefill / decode逐 token 串行KV Cache

  第 12 章解决的是模型侧的问题:一步解码怎么走、采样旋钮怎么调、什么时候停、怎么输出结构化结果。从本章起换一副眼镜,看系统侧:同一份权重,一个人本地跑和十万人同时用,成本与速度天差地别;云端每服务好一个请求,背后都是显存、算力、带宽三种资源的消耗。本章的任务是把同一个模型服务得更快、更便宜,而动手之前先得把账算清——「成本」这个笼统的词,拆开到底是哪几本账,各自怎么算,谁先顶到天花板。

  本节沿「先分清模式差异,再手算三本账,最后定位瓶颈」的主线展开,所有数字都用 minimind 的真实配置(约 63.9M 参数)手算一遍,读者可以跟着复算。路线图如下:

  1. 训练和推理不是一回事:批量并行 vs 逐 token 串行(13.1.1):同一个模型,两种完全不同的计算模式,利用率悬殊的根源在并行度;
  2. 一次解码的账:参数量、显存、FLOPs 怎么算(13.1.2):用 minimind 的真实数字把显存、算力两本账各算一遍,63.9M 参数逐组件对账;
  3. 带宽瓶颈:算术强度与 memory-bound(13.1.3):分解一步 decode 的时间,用 roofline 图解释带宽限制;
  4. 优化全景图:本章后续五节各动哪个变量(13.1.4):KV Cache、批处理、量化、蒸馏、投机采样各自攻哪本账,一张表收束全章。

  读完本节,应能手算模型在 FP16 下的权重显存与 decode 吞吐上限,说明 decode 为什么无法充分利用 GPU,并从成本公式理解本章后续各节的优化目标。训练侧章节到第 11 章结束,从这里开始进入推理与部署阶段。

13.1.1 训练和推理不是一回事:批量并行 vs 逐 token 串行

  表面上看,训练和推理都是把一批 token 喂进 Transformer 过一遍,似乎没理由一个忙得过来一个闲得发慌。差异的根源在数据可得性。训练时全部语料早已躺在硬盘里:第 6 章讲过,next-token 目标下一条长度为 \(n\) 的序列能同时提供 \(n\) 个位置的输入与监督,于是可以把成百上千条序列拼成一个大 batch,一次前向全部算完,矩阵乘法拉满。推理时序列是边算边长的:第 \(t\) 个 token 依赖前 \(t-1\) 个的输出,在算出第 \(t-1\) 个之前,谁也不知道第 \(t\) 个位置该放什么,只能按顺序一个一个生成。这个串行约束不是工程上的偷懒,是自回归的定义使然(第 12 章),早在 Transformer 原论文(Vaswani et al., 2017)的 decoder 推理设定里就是如此。

  严格说,一次完整生成分两个阶段:prefill(预填充)把用户的 prompt 一次性并行算完,计算模式与训练相同;之后才进入 decode(解码)阶段逐 token 的串行循环。本章谈的瓶颈与优化,绝大多数针对 decode 阶段——一次生成里 decode 步数往往占大头(生成 500 个 token 就要 500 步串行),而且它的计算模式恰好是硬件最不擅长的那种。图 1 把两种模式摆在一起对照。

原创示意图 · 非论文原图 训练:语料早已在手,一次前向全部并行 推理 decode:下一词依赖上一词,只能逐 token 串行 seq = 5 个位置 batch = 3 条序列 Transformer 前向 × 1 一次算出 3 × 5 = 15 个位置的预测 每个位置都配好监督信号(交叉熵) 同一秒内,上万 token 一起过模型,算力吃得满 瓶颈是算力:矩阵乘法越大越划算 第 1 步 你 好 今 第 2 步 你 好 今 天 第 3 步 你 好 今 天 。 输出接回输入 一次前向只产出 1 个新 token 生成 T 个 token 就要跑 T 次前向,一步不能少 前缀不重算的省法(KV Cache)见 13.2 节 单请求时一次前向只有 1 个 token:权重全搬一遍只换它一个 瓶颈是带宽:计算单元大半时间在等数据 同一个模型、同一张卡:训练是批发,一次吞吐一整批;decode 是零售,一次只出一件
图 1:训练与推理 decode 的计算模式对比。左:训练时全部语料在手,一批 3 × 5 个位置一次前向并行算完,每个位置都自带监督信号;右:decode 时第 \(t\) 个 token 依赖前 \(t-1\) 个的结果,一次前向只产出 1 个新 token(绿格),输出必须接回输入再算下一步,生成 T 个 token 就要 T 次前向。灰格是上一步刚生成的历史 token。并行度的悬殊,是两者硬件利用率天差地别的根源。

  图 1 右侧的串行循环使 decode 每步前向的规模很小(单请求时一次只算 1 个 token),却仍要读取模型的全部权重。因此,每一步的计算量与数据搬运量之间有固定的比例,这个比例正是 13.1.3 要讲的算术强度。先算出三本账的具体数字,再看它为什么成为瓶颈。

  同一个模型、同一张卡,训练是批发(一次吞吐一整批),decode 是零售(一次只出一件)。硬件利用率的悬殊不在模型、不在框架,在并行度:一次前向能同时服务多少个 token。

13.1.2 一次解码的账:参数量、显存、FLOPs 怎么算

  先对账参数量。minimind 全量约 63.9M 参数,这个数不是凭空来的:词表 6400、hidden 维度 768 的 embedding 约 4.9M;每层注意力约 1.77M(Q 投影 768×768,K、V 投影各 768×384,O 投影 768×768),FFN 三路投影约 5.60M(768×2432×3,SwiGLU 结构,第 5 章讲过),每层合计约 7.37M,8 层约 59.0M;加回 embedding 正好约 63.9M(lm_head 与 embedding 共享权重,不重复计数)。落成一张对账表:

组件形状参数量
embedding(与 lm_head 共享)\(6400 \times 768\)≈ 4.9 M
注意力(每层):Q / K / V / O 投影\(768{\times}768 + 2 \times (768{\times}384) + 768{\times}768\)≈ 1.77 M
FFN(每层,SwiGLU 三路投影)\(3 \times (768 \times 2432)\)≈ 5.60 M
8 层合计—≈ 59.0 M
全模型—≈ 63.9 M

  表里 K、V 投影的 384 来自 GQA:KV 头数 4 × head_dim 96(第 5 章)。RMSNorm 增益等零星参数仅万级,对账时忽略。

  第一本账是显存。推理不需要梯度,也不需要第 7 章讲的 Adam 优化器状态,权重本身就是大头:

\[ S_{\mathrm{weight}} = N \times b \tag{1} \]
公式 (1):权重显存占用——参数量乘以每个参数的字节数。符号说明:\(S_{\mathrm{weight}}\) 是权重占用的显存字节数;\(N\) 是参数量(minimind 为 63.9M);\(b\) 是每个参数的字节数,由数值精度决定:FP16 / BF16 为 2,INT8 为 1,INT4 为 0.5(第 13.4 节)。代入 FP16:\(63.9\,\mathrm{M} \times 2\,\mathrm{B} \approx 128\,\mathrm{MB}\)——消费级显卡随便装。

  注释:128 MB 只是权重。推理时显存里还有激活值与 KV Cache(缓存历史 token 的 K、V,避免每步重算,13.2 节细讲):短上下文、小模型下权重占大头;上下文一拉长,KV Cache 会反超权重成为显存大头,这笔账也在 13.2 节算。训练侧的显存构成(参数 + 梯度 + 优化器状态 + 激活)是另一本账,见第 7 章。

  第二本账是算力。第 7 章用过 Kaplan et al.(2020)的估算口径:一次前向里每个参数约贡献 2 次浮点运算(一次乘、一次加),训练每个 token 约 \(6N\)(前向 \(2N\) 加反向 \(4N\))。推理没有反向传播,每处理 1 个 token 的代价就是:

\[ F_{\mathrm{step}} \approx 2N \tag{2} \]
公式 (2):decode 一步(有 KV Cache、只处理 1 个新 token)的浮点运算量。符号说明:\(F_{\mathrm{step}}\) 是一步前向的 FLOPs;\(N\) 是参数量;系数 2 来自矩阵乘法中每个参数参与一次乘法和一次加法。适用条件:忽略了注意力分数的 \(n^2 d\) 项(\(n\) 为序列长度,短序列下占比很小),KV Cache 生效、每步只算新 token。代入 minimind:\(2 \times 63.9\,\mathrm{M} \approx 1.28\) 亿 FLOPs \(= 0.128\,\mathrm{GFLOP}\);生成 100 个 token 累计约 12.8 GFLOP——对每秒能算 312 万亿次 FP16 的 A100 来说,是九牛一毛。

  注意:\(2N\)/token 是工程估算口径,刻意忽略了注意力分数的 \(n^2 d\) 项、采样与调度等开销。上下文很短时它相当准;上下文拉长以后,注意力项会长大到不能忽略(即使有 KV Cache,注意力计算本身仍随长度线性增长),此时每步 FLOPs 高于公式 (2) 的估计。没有 KV Cache 时每步还要重算整段历史,代价随长度平方膨胀,那是 13.2 节要解决的灾难。

  前两本账都不像瓶颈:128 MB 显存单卡即可容纳,0.128 GFLOP 的算力需求也很小。decode 的速度限制来自第三本账。图 2 汇总三本账,右下角给出 13.1.3 要讨论的算术强度。

原创示意图 · 非论文原图 推理成本的三本账:谁先顶到天花板,谁就是瓶颈 推理的速度与成本 装得下 · 算得快 · 搬得动 显存容量(GB) 装不装得下权重与缓存 权重显存 = N × b 63.9M × 2B(FP16) ≈ 128 MB 算力(TFLOPS) 乘加运算有多快 每步 FLOPs ≈ 2N decode 一步仅 ≈ 0.13 GFLOP 显存带宽(GB/s) 数据搬运有多快 decode 每步要把 b·N 字节 全部权重原样搬一遍
图 2:推理成本的三本账汇总。显存决定装不装得下(权重 = \(N \times b\),minimind FP16 约 128 MB),算力决定算得快不快(decode 每步 FLOPs ≈ \(2N\) ≈ 0.13 GFLOP),带宽决定搬得动搬不动(decode 每步要把全部权重原样搬一遍)。本节结论:decode 阶段先顶到天花板的是右下角这本账(13.1.3 展开)。

13.1.3 带宽瓶颈:算术强度与 memory-bound

  关键在一个容易被忽略的事实:decode 每走一步,63.9M 个参数每个只参与约 2 次运算(一乘一加),但每一个都必须从显存搬进计算单元。权重能在片上缓存里留住吗?留不住——A100 的 L2 缓存只有 40 MB,装不下 128 MB 的权重;就算装得下,下一个 token 来了,每个权重还得重新参与一轮矩阵乘法。于是每生成 1 个 token,就有 128 MB 的搬运和 0.128 GFLOP 的计算。搬运躲不掉,它的时间按 A100 的公开规格(HBM 带宽约 2 TB/s、FP16 算力约 312 TFLOPS)拆出来,就是图 3。

原创示意图 · 非论文原图 decode 一步的时间花在哪:搬运 ≈ 64 µs,计算 ≈ 0.4 µs(minimind 权重 × A100 规格估算) 显存 HBM 全部权重 128 MB 63.9M 参数 × 2 B (FP16,63.9M 个权重) 显存带宽 ≈ 2 TB/s 每步搬运 128 MB ≈ 64 µs SM 计算单元 FP16 ≈ 312 TFLOPS 算完这批只要 ≈ 0.4 µs 产出 1 个 token 生成下一个 token:同一份 128 MB 原样再搬一趟 一步 decode 的时间构成(按 64.4 µs 总时长等比) 等待权重送达:≈ 64 µs(带宽决定) 紫色细条 ≈ 0.4 µs:实际计算时间,算力利用率不足 1% 生成 100 个 token:同一份权重搬 100 趟,累计搬运 12.8 GB 计算总量 12.8 GFLOP,与搬运 GB 数相同——正是算术强度 ≈ 1 FLOP/B 的体现
图 3:decode 一步的时间分解(minimind 128 MB 权重、A100 公开规格的估算,可复算)。每生成 1 个 token,全部权重从 HBM 搬入计算单元:128 MB ÷ 2 TB/s ≈ 64 µs;实际计算只需 0.128 GFLOP ÷ 312 TFLOPS ≈ 0.4 µs,在时间条上几乎看不见(紫条已按等比画出,细成一条线)。算力利用率不足 1%,而且下一个 token 来了原样再搬一趟。

  图 3 的时间条触目惊心:一步约 64 µs 里,63.6 µs 在等数据,真正计算只占 0.4 µs。搬运动作无法跳过,它给 decode 速度划了一条硬上限:

\[ \mathrm{tok/s} \;\leq\; \frac{B_{\mathrm{mem}}}{N \cdot b} \tag{3} \]
公式 (3):decode 吞吐的带宽上限——每生成 1 个 token 必须搬运 \(N \cdot b\) 字节(全部权重),带宽除以它就是每秒能走的步数。符号说明:\(B_{\mathrm{mem}}\) 是显存带宽(A100 约 2 TB/s);\(N\) 是参数量;\(b\) 是每参数字节数(FP16 为 2)。代入:\(2\,\mathrm{TB/s} \div 128\,\mathrm{MB} \approx 15600\) tok/s。这是理论天花板,实际还有 kernel 启动、采样、调度等开销,真实速度只达上限的一部分。注意公式里没有峰值算力:只要 decode 保持逐 token 串行,换一块算力翻倍的卡,tok/s 几乎原地不动。
算术强度 Arithmetic Intensity arithmetic intensity = 计算量 ÷ 数据搬运量,衡量每搬一个字节能「压榨」出多少次运算

定义 \(I = F / D\):\(F\) 是一次计算的浮点运算量(FLOPs),\(D\) 是这次计算必须从显存搬运的字节数。\(I\) 越高,数据复用越充分。每块硬件有自己的分水岭 \(I^* = \text{峰值算力} \div \text{带宽}\)(A100 ≈ 312 TFLOPS ÷ 2 TB/s ≈ 150 FLOP/B):程序的 \(I\) 低于拐点,就算力再强也只能等数据,叫 memory-bound(带宽瓶颈);高于拐点,数据供应跟得上,算力成为限制,叫 compute-bound(算力瓶颈)。decode 单请求的 \(I \approx 1\) FLOP/B,与拐点相差两个数量级,是深度 memory-bound。

像厨房出菜:带宽是传菜员的腿速,算力是厨师的手速。一次只点一道菜(decode),厨师大半时间干等传菜;一次订五百桌酒席(大 batch),传菜一趟管全场,厨师才真正忙起来。

  算术强度把「训练能跑满、decode 跑不满」统一到一个公式里。权重搬运一次可以摊给本次前向的所有 token,于是:

\[ I \;=\; \frac{F_{\mathrm{step}}}{D_{\mathrm{step}}} \;\approx\; \frac{2N \cdot M}{b \cdot N} \;=\; \frac{2M}{b} \tag{4} \]
公式 (4):算术强度与并行度的关系。符号说明:\(M\) 是一次前向并行处理的 token 数(decode 时等于 batch 大小,每个请求各贡献 1 个新 token;训练 / prefill 时等于 batch × 序列长度);\(D_{\mathrm{step}} \approx b \cdot N\) 是每步搬运的权重字节数,与 \(M\) 无关——这是全式的前提:权重只搬一遍,全员共享。约号忽略了 KV Cache 读写与激活(小模型、短上下文下占比小)。FP16(\(b = 2\))下 \(I \approx M\):decode 单请求 \(M = 1\)、\(I \approx 1\);训练时 \(M\) 轻松上万、\(I \approx 10^4\)。参数量 \(N\) 在分子分母中约掉,所以「decode 喂不饱 GPU」与模型大小无关,7B、70B 同病。

  把公式 (3)(4) 画到一张图上,就是系统领域常用的 roofline 模型(图 4):横轴是算术强度,纵轴是实际能吃到的性能,带宽和算力各画一条封顶线,谁低听谁的。

原创示意图 · 非论文原图 roofline 模型:算术强度决定性能天花板(双对数坐标,A100 量级示意) 0.1 1 10 100 1000 算术强度 I = 计算量 ÷ 搬运字节数(FLOP/B,对数) 0.1 1 10 100 1000 可达性能 P (TFLOPS,对数) I* ≈ 150 FLOP/B 带宽区 memory-bound:搬不及 算力区 compute-bound decode(batch = 1):I ≈ 1 只能吃到 ≈ 2 TFLOPS batch ≈ 512 后进入算力区 摸满 312 TFLOPS 读法(附录 A.7):斜线段上 I 每 ×10,可达 P 也 ×10;过拐点后 P 被算力封顶
图 4:roofline 模型(双对数坐标,按 A100 公开规格画的量级示意)。斜线段是带宽封顶(P = 带宽 × I),水平段是算力封顶(P = 峰值算力 312 TFLOPS),交点即拐点 \(I^* = \text{峰值算力} \div \text{带宽} \approx 150\) FLOP/B。decode 单请求(\(I \approx 1\))深在带宽区,只能吃到约 2 TFLOPS;把 batch 加到数百,\(I\) 越过拐点,才能摸满算力。向右平移的唯一旋钮是 \(M\)(公式 (4)),这正是 13.3 节连续批处理的全部动机。

  注释:同一次生成里,两个阶段各站一边。prefill 的 \(M\) 等于 prompt 长度(成百上千),落在算力区;decode 的 \(M\) 等于 batch 大小,单请求时落在带宽区深处。这解释了工程上「首 token 延迟」(time to first token,主要由 prefill 决定)与「后续逐 token 速度」(由 decode 决定)成因不同,也说明加大 batch 是把 decode 在图 4 里向右推的唯一旋钮:一次搬运,服务全场。

  decode 瓶颈的完整表述:吞吐上限 = 带宽 ÷(\(b \cdot N\)),与峰值算力无关;突围只有三个方向——提高算术强度(加大 \(M\))、缩小每参数字节(减小 \(b\))、缩小参数量(减小 \(N\))。第 13 章后续每一节,都是在这两个公式里动变量。

13.1.4 优化全景图:本章后续五节各动哪个变量

  把公式 (3)(4) 摆在桌面上,本章后续五节的布局就一目了然:每个变量对应一类技术,每类技术攻一本账。

技术动的变量一句话思路详解
KV Cache每步计算量(省重复)已算过的 K / V 存入显存,每步只算新 token,把注意力开销从随长度平方膨胀压回线性13.2
连续批处理 / PagedAttention\(M\) ↑多请求拼批、token 级调度,一次权重搬运服务更多 token,把算术强度推过拐点13.3
量化\(b\) ↓FP16 → INT8 / INT4,显存与搬运量同比例缩小,tok/s 上限同比提高13.4
蒸馏\(N\) ↓大模型教小模型,直接换一本更小的账13.5
投机采样串行步数 ↓小模型起草多个 token,大模型一次前向验收,把若干步并成一步13.6
推理时扩展主动加计算反向操作:decode 的算力本来就闲置,多花计算换更好答案反而划算13.6

  表里 KV Cache 一行需要多说一句:它省的是重复计算,权重搬运一趟不少,缓存本身还增加显存占用。它的价值在于保证公式 (2)(3) 的口径在长上下文下依然成立——没有它,decode 每步要重算整段历史,计算量随长度平方膨胀,带宽公式还没轮到出场,算力先被拖垮。所以全景表里它动的变量写的是每步计算量,与带宽主线互为补充。Pope et al.(MLSys 2023)对 decode 成本结构的系统分析也正是在这个框架下展开:权重搬运按 batch 摊销、KV Cache 读写随长度增长,两者共同决定大模型推理的真实成本。

  账本已经摊开,瓶颈已经定位。下一节先看最基础也最普遍的一项优化——KV Cache:它不直接改成本公式里的任何变量,却是所有现代推理引擎的标配,因为它把 decode 从每步重算整段历史的灾难里救了出来。

🧭本节要点回顾
为什么训练时 GPU 算力能吃满,decode 时却大量闲置?
并行度差异。训练时语料在手,batch × 序列长度个位置一次前向并行算完,算术强度轻松上万,越过硬件拐点(A100 ≈ 150 FLOP/B)进入算力区;decode 受自回归约束逐 token 串行,单请求一次前向只算 1 个 token,算术强度 ≈ 1 FLOP/B,深在带宽区——一步约 64 µs 里 99% 在等权重从显存搬过来,真正计算只占 0.4 µs。
用 minimind 把 decode 的三本账手算一遍?
显存:63.9M × 2 B ≈ 128 MB(FP16,组成可对账:embedding 4.9M + 每层 7.37M × 8)。算力:每步 FLOPs ≈ 2N ≈ 0.128 GFLOP。带宽:tok/s ≤ 2 TB/s ÷ 128 MB ≈ 15600(A100 理论上限,实际只达一部分)。瓶颈公式里没有峰值算力——decode 提速的钥匙是带宽、batch 与更小的 \(b \cdot N\)。
第 13 章后续的优化技术与成本公式是什么关系?
全在 tok/s ≤ \(B_{\mathrm{mem}} / (b \cdot N)\) 与 \(I \approx 2M/b\) 里动变量:量化减小 \(b\)、蒸馏减小 \(N\)、连续批处理加大 \(M\)、投机采样把多个串行步并成一步。KV Cache 例外:它省的是随长度膨胀的重复计算,保证上面两个公式在长上下文下依然成立。推理时扩展是反向操作——既然 decode 算力闲置,主动多花计算换更好答案。

参考来源

  • Pope et al., 2022. Efficiently Scaling Transformer Inference(arXiv:2211.05102,MLSys 2023):decode 阶段 memory-bound 的系统分析、权重搬运按 batch 摊销与 KV Cache 成本框架;本节「带宽决定 decode 吞吐」「加大 batch 提高硬件利用率」主线的直接依据。
  • Vaswani et al., 2017. Attention Is All You Need(arXiv:1706.03762):自回归增量解码的原始设定(逐位置生成、输出接回输入),13.1.1 串行约束的出处。本页正文所称「原论文」即此篇。
  • Kaplan et al., 2020. Scaling Laws for Neural Language Models(arXiv:2001.08361):前向每 token 约 \(2N\) FLOPs 的算力口径(训练每 token 约 \(6N\) = 前向 \(2N\) + 反向 \(4N\)),与第 7 章 \(C \approx 6ND\) 同出一源。
  • NVIDIA A100 Tensor Core GPU 官方规格:FP16 tensor core 算力约 312 TFLOPS、HBM 带宽约 2 TB/s(2039 GB/s)、L2 缓存 40 MB;用于图 3、图 4 与拐点 \(I^* \approx 150\) FLOP/B 的量级估算(均为可复算的比值,非实测)。
  • minimind(Apache 2.0):模型配置(hidden 768、8 层、词表 6400、8 头 / KV 头 4、head_dim 96、FFN 2432、约 63.9M 参数、embedding 与 lm_head 权重共享),见 minimind-master/model/model_minimind.py 及项目 README;13.1.2 的参数量对账以此为准。
  • 本手册第 6 章(next-token 目标的并行训练设定)、第 7 章(训练显存构成与 \(C \approx 6ND\))、第 12 章(解码机制);附录 A.7(对数坐标读法,图 4 的阅读基础)。