编者按:你有没有想过,为什么明明模型参数越来越大、算力越来越强,但大模型的响应速度却似乎始终跟不上我们的耐心消耗速度?
文章从底层机制出发,清晰地拆解了推理过程的两大阶段:Prefill阶段受限于计算吞吐量,负责并行处理输入提示词;Decode阶段则受限于内存带宽,逐个自回归地生成输出token。作者以一个7B模型在A100上的真实案例为锚点,通过四种典型场景(短提示词、中等长度、长上下文、超长上下文)的精确计算,揭示了令人反直觉的结论——当输入token达到约5000个时,系统会从“Decode主导”切换为“Prefill主导”,此时用户等待第一个token输出的时间将远超后续生成时间。文章进一步给出了针对性的优化路径:短提示词场景应聚焦投机解码与降低内核开销,长上下文场景则需提升Attention计算效率、采用FlashAttention及上下文压缩。
作者 | Abi Aryan
编译 | 岳扬
你就把这当成一篇博客随笔,或者深夜的牢骚吧。在 2025 年下半年,我为了写论文(目前还在推进中)一直在做分布式系统相关的研究。在梳理文献的过程中,我发现并行与分布式系统领域(尤其是计算机体系结构方向)的大量论文都出自纯学术界,而非工业界。这太离谱了(要知道 90 年代这个比例大概是 40%),这也恰恰说明,这个领域的信息生态已经变得多么割裂。
尽管 ISCA、MICRO、HPCA、ASPLOS 和 Hot Chips 这些顶会依然有工业界持续投稿,但 MLSys 和 NeurIPS 与当下推动 LLM Inferencing 瓶颈突破的那些工作之间,仍然显得有些脱节和割裂。
过去几个月里,在各种讨论中有一个观点越来越明确:LLM Inference 将是未来五年面临的一大危机。无论我们对 transformer 架构进行改进(比如引入 MoE 或 MLA),还是彻底抛弃 transformer 转向全新的方案,有一点始终不会变。那就是——
推理,将是可预见的未来里最亟待攻克的核心难题之一。
为什么呢?因为你终究得把结果输出给用户,如果系统不能针对实时响应做好优化,用户流失就是分分钟的事。现代人的注意力和耐心本就所剩无几,再过五年,大家的耐心估计连猫都不如。扯远了,这又是另一个话题了。但言归正传,核心结论是:我们再也回不到那个等模型吐出一个结果需要苦苦煎熬的时代了。我们想要的响应时间是微秒级,而不只是毫秒级。
我整理了一份包含十篇论文的清单,想推荐给所有对推理(Inferencing)感兴趣的人。但老实说,其中大部分论文不过是那些明星实验室发出的无病呻吟,他们哪怕只是说句“太阳打东边升起”,大家也会当成当天的头条新闻来听。最关键的是,除了用一些实验去证明那些显而易见的事实外,它们并没有带来什么实质性的贡献,顶多算是提供了一些通信层面的研究思路罢了。
更重要的是,推理优化绝不仅仅是一个研究课题,如果不解决这个问题,AI/ML 行业根本无法实现规模化扩展。我很反感夸大其词,但如果我说“它是下一个和氧气一样重要的东西”,那也不算撒谎。没错,问题就有这么严重。
为什么呢?有以下几个主要原因:
1)MoE 架构。它虽然不会大幅增加训练成本,但却通过拉大内存和通信开销让推理变得十分困难。
2)推理模型。并行探索(Parallel explorations)不仅会增加生成延迟,同时也会影响吞吐量。
3)多模态模型。与纯文本生成相比,多模态场景下,那些比纯文本“体量更大、结构更复杂”的输入数据形式需要消耗更多的算力和内存。
4)长上下文、RAG 和 KGs。这很明显,对吧?长上下文自然需要消耗更多的算力和内存。
还记得我 2 月 2 日在那场 Maven 闪电演讲[1]中提到过,为什么 Decode(解码阶段)是受内存限制的吗。提示一下:Decode 每次只生成一个 token,并且是自回归的。而且,生成每个 token 都需要读取两样东西 —— 1. 权重和 2. KV cache。因此:
Tokens Per Second (TPS) ≈ HBM Bandwidth / (Model Size + KV Cache Size per token).
每秒生成 token 数 (TPS) ≈ HBM 带宽 / (模型大小 + 每个 token 的 KV 缓存大小)
另外,输出越长,延迟就越高。除非我们用之前提到的一些技术同时对 prefill(预填充)和 decode 进行优化,否则这必然会拉高每个应用的端到端延迟。这些内容后续课程里也会涵盖。
但今天,我想教大家一个非常基础的东西 —— 如何理解 LLM 的延迟。
具体来说,Prefill(预填充)和 Decode(解码)阶段的瓶颈在于不同的硬件资源:Prefill 受限于计算吞吐量,而 Decode 受限于内存带宽。
因此,粗略地说,模型推理的成本可以总结为 = 输入长度 × 模型大小。这大家都知道,对吧?但在 decode 阶段,成本是随着输出长度增长的。所以,每个 token 的延迟可以总结为 ——
Total Latency ≈ Prefill(input_tokens) + Decode(output_tokens)
总延迟 ≈ 预填充阶段(输入token数) + 解码阶段(输出token数)
乍看可能简单得很,但落到实际运行里,这里面弯弯绕绕可不少。
对于短 prompt → decode 延迟会盖过一切。
但对于长 prompt → prefill 阶段的成本直接碾压 decode 阶段的开销。
让我试着用一个真实的案例来给你讲明白。
假设你现在有
模型:一个采用标准注意力机制和 KV cache 的 7B 稠密 Transformer
硬件:单张 A100 级别的 GPU,Batch Size = 1
并且没有排队或网络开销
且你的输入 token 长度 = 1,000(是 token 而不是单词)
接下来发生的事情是,模型会对这 1000 个 token 全部进行嵌入,并跑完所有的 Transformer 层。这也就意味着要为每个 token 计算 Q、K、V,对吧?
因此,注意力机制会在 1000 x 1000 的规模上运行,同时 KV Cache 会被存下来供后续解码使用。
这是一个高度并行的、单次前向传播的例子。根据经验数据,对于 7B 模型,Prefill 吞吐量 ≈ 5,000 tokens/sec
所以,你的 Prefill 延迟将会是:Prefill(input_tokens= 1,000) = 1,000 / 5,000 = 0.2 seconds = 200 ms
现在,一旦 prefill 完成,也就是生成阶段(也叫 Decode)就要开始了,
所以,对于每一个输出的 token,只有这一个 token 会经过模型。在这样的硬件上跑 7B 模型,在 1k 左右的上下文下 Decode 速度 ≈ 100 tokens/sec。这意味着,你的平均 Decode 时间 = 每个 token 约 10 ms。
那么,生成 100 个 token 时,Decode 延迟将会是 = 生成的 Tokens 数 x 平均 Decode 耗时 = 100 x 10 ms = 1,000 ms = 1s
是不是挺简单的?现在,让我们来看看这几种典型情况。
情况 1. 你的提示词很短
假设输入的 token 长度为 100。
那么,你的
Prefill 延迟 = 输入的 Token 长度 / Prefill 吞吐量 = 100 / 5,000 = 20 ms
&
Decode 延迟 = 输入的 Token 长度 x 平均 Decode 耗时 = 100 x 10 ms = 1000 ms
模型总延迟 = T_prefill(L_in) + T_decode(L_out) = 20 ms + 1000 ms = 1020 ms
这就意味着,
Prefill 时间占比 20x100/1020 ~ 2%,Decode 时间占比 1000X100/1020 ~ 98%
这说明你的模型是 Decode-dominant(解码阶段主导型)的。也就是说:
你在读取提示词上几乎没花什么时间,全在干等 token 一个个吐出来。
情况 2. 假设你有一个中等长度的提示词
对于这种情况,假设你输入的 token 长度是 1000。
那么,你的 Prefill 延迟 = 1,000 / 5,000 = 200 ms
而你的 Decode 延迟 = 100 X 10 ms = 1000 ms = 1 s
你可能会纳闷,难道不应该是 1000x10ms 吗?——其实不然,decode 延迟取决于输出的 token 数量,而不是输入 token 数。所以,输入长度影响的是 prefill,而你的输出长度是不变的,除非你手动去增加它。
这就意味着,由于 KV cache 的存在,每个 token 的 decode 时间大致上总是大致恒定的(摊销后)。因此,
Prefill = L_input / Prefill 吞吐量 & Decode = L_output x 平均 Decode 耗时 (per token)
模型总延迟 = T_prefill(L_in) + T_decode(L_out) = 200 ms + 1000 ms = 1200 ms
Prefill 时间占比 200x100/1200 ~ 17%,Decode 时间占比 1000X100/1200 ~ 83%
这说明你的模型仍然是 Decode-dominant(解码阶段主导型)的,但 prefill 的时间已经肉眼可见了。
现在,我们来看看
情况 3. 当你的 prefill 和 decode 时间大致相当时
即 T_prefill(L_in) ≈ T_decode = 1 s
当你输入的 token 长度在 5000 个左右时就会出现这种情况
所以,你的 Prefill 延迟 = 5,000 / 5,000 = 1 s
而你的 Decode 延迟 = 100 X 10 ms = 1000 ms = 1s
模型总延迟 = T_prefill(L_in) + T_decode(L_out) = 1s + 1s = 2s
这便是转折点,此时
Prefill 时间占比 1x100/2 ~ 50%,解码时间占比 1X100/2 ~ 50%
最后,
情况 4. 当你有一个超长提示词,也就是超长上下文窗口时
假设你输入的 token 长度是 10,000 个。
那么,Prefill 延迟 = 10,000 / 5,000 = 2.0 s
而你的 Decode 延迟 = 100 X 10 ms = 1000 ms = 1s
模型总延迟 = T_prefill(L_in) + T_decode(L_out) = 2s + 1s = 3s
Prefill 时间占比 2x100/3 ~ 67%,Decode 时间占比 1X100/3 ~ 33%
这说明你的模型变成了 Prefill-dominant(预填充阶段主导型)的。也就是说:
在第一个 token 冒出来之前,你绝大部分的时间都花在读取提示词上了。
TLDR;
你的 Decode 阶段耗时 = 10 ms × 100 tokens = 1 秒
在这个阶段,既没有并行计算,也无法用任何手段隐藏延迟。
在 1 秒的延迟下,用户能真切地“感受”到每一个 token 的生成。还记得咱们前面说的耐心吗?
这就是为什么短 prompt 依然让人觉得慢。所以你的优化方向是:
投机解码(Speculative decoding)(把需要逐个生成的 token 从 100 个砍到 30 个)
降低 Kernel 启动开销
提高时钟频率,换用更低延迟的内存
哪怕每个 token 只省下 2 ms:100 × (10 − 8) ms = 200 ms 的总节省
这种用户感知上的耗时减少会非常明显。
而到了长上下文窗口中,也就是 Prefill-dominant 模式下,你的瓶颈就来自 L_in / 5000,所以优化重点变成:
提升 Attention 机制的计算效率
采用 FlashAttention
上下文压缩
提高 FLOPs 利用率
在 10k tokens 的输入下,哪怕只优化掉 20% 的 prefill 时间:2.0 s → 1.6 s
这是在生成第一个 token 之前就能取得的巨大收益。
END
本期互动内容 🍻
❓等 AI 开始说话(Prefill)和听它一个字一个字往外蹦(Decode),哪种延迟更让你抓狂?在你们现在做的产品里,哪个才是真正的瓶颈?
文中链接
[1]https://maven.com/p/52b7f0/what-happens-when-you-make-an-llm-call
本文经原作者授权,由 Baihai IDP 编译。如需转载译文,请联系获取授权。
原文链接:
https://modelcraft.substack.com/p/the-real-reason-llms-feel-slow
AI 及大模型技术分享交流群

