给每一焦耳上户口：LLM 推理能耗的四参数人口普查

算力的三笔账 · 第一笔：电费账
论文：The SIMPLE Law for Energy Cost of LLM Inference
arXiv: 2611.03330 | 2026-11-02 | University of Bologna + CINECA

🏷️ 一个 Token 不是一块钱

你家的电表很诚实。空调转一小时，台灯转一小时，电表走的字完全不同——它知道压缩机在干什么，也知道钨丝在干什么。你要是敢把空调和台灯按同样的"每小时单价"缴费，电力公司会以为你在开玩笑。

但大语言模型行业的"电表"就是这么干的：按 token 计费。一个 token 进来，走一个字；一个 token 出去，走一个字。就好像电力公司跟你说："我们不看你开了什么电器，只看电器开了几小时。"

这种计费方式已经酿成了实际的荒谬。论文开篇引用了一个令人瞠目的案例：选一个"每 token 标价更便宜"的模型，总成本反而可能是那个"单价贵"的模型的 28 倍。28 倍！不是 28%，是 2800% 的差距。为什么？因为 token 不是物理单位。它是一个工作量的观察值（observable），不是工作量本身。就像你不能用"小时"来度量不同电器的耗电量一样，你也不能用"token 数"来度量不同模型、不同架构、不同上下文长度下的真实计算开销。

想象你雇了一批翻译。有的翻译只需扫一眼原文就能下笔，因为原文简单、他的词汇量也刚好覆盖。有的翻译要把前面每一页都重新读一遍才能写下一句，因为原文晦涩、涉及大量指代和省略。你按"翻译了多少句"付钱——两种翻译收的单价一样，但第二种翻译实际干的活可能是第一种的好几倍。更麻烦的是，第二种翻译越往后翻，需要回头重读的页数就越多——每写一个新句子，都要把之前所有的内容重新过一遍。这就是 LLM 推理的核心机制。

这个"回头看"的动作，就是注意力机制（Attention）在解码（Decode）阶段干的事。模型每生成一个新 token，都要从 KV-cache（键值缓存）里把所有历史 token 的 Key 和 Value 都读出来，计算注意力权重，然后才能决定下一个词是什么。读一遍要耗能，读十遍要耗更多能。随着序列越来越长，KV-cache 越来越大，每个新 token 回头看的"距离"越来越远，搬运的数据量越来越惊人，能耗自然就非线性地上去了。

所以今天一个模型的推理能耗，不仅取决于你问它多少字，还取决于它要回答多少字、它的"记忆力仓库"（KV-cache）有多大、它的"脑回路设计"（注意力架构）长什么样、它有多少层、每层有多宽。整个行业在用一种无法计算生产成本的货币结账——这就是博洛尼亚大学团队要解决的荒谬。

🔌 电表为什么不走字：两个阶段的两种性格

要理解能耗为什么不能用 token 数线性度量，得先看懂 LLM 推理的两副面孔。它们的工作方式截然不同，就像水泵的"灌水"和"抽送"两个阶段。

第一副面孔叫 Prefill（预填充）。 你把一整段输入文本丢给模型——比如一篇 2000 字的文章、一段代码、一个复杂的问题描述。模型一口气处理完所有输入 token，为每个 token 计算出对应的 Key 和 Value 向量，把它们一股脑存进一个叫 KV-cache 的高速缓存里。这个阶段是高度并行的——所有 token 同时被处理，彼此之间的注意力关系一次性算清。像一排厨师同时切配所有食材，刀起刀落，瞬间完成。

Prefill 的能耗主要跟输入长度有关，但要注意：注意力的计算量跟输入长度呈二次关系。为什么？因为每个 token 都要跟所有其他 token 交互——第 1 个 token 要跟第 2 到第 N 个交互，第 2 个要跟第 1、3 到 N 个交互，以此类推，总共约 N²/2 次交互。输入从 100 token 涨到 1000 token，注意力计算量涨了 100 倍。这就是长输入场景的"阅读税"。

第二副面孔叫 Decode（解码）。 现在模型要开始生成回答了。它一个 token 一个 token 地往外蹦：生成第 t 个 token 时，要从 KV-cache 里读出前面所有 t-1 个 token 的 Key 和 Value，跟当前 token 的 Query 做注意力计算，然后经过前馈网络，才能输出下一个词的概率分布。这个阶段是严格串行的——没法并行，因为第 t+1 个 token 依赖第 t 个 token 的输出。像一个作家逐字写作，每写一个字都要把前面写的所有字重新读一遍。Production 效率跟 Prefill 完全不在一个量级。

Decode 的能耗有两个来源，性格迥异：

1. KV-cache 读取税：随着上下文变长，每生成一个 token 要读的数据越来越多。第 1 个输出 token 只要读输入的 KV-cache；第 100 个输出 token 要读输入加前面 99 个输出 token 的 KV-cache。这主要是内存带宽的瓶颈——不是 GPU 算不动，而是数据搬运太费劲。GPU 的算术单元可以每秒做万亿次浮点运算，但内存带宽只有每秒几 TB——每生成一个 token 都要把整个 KV-cache 从显存搬到计算单元，搬运的能耗远比计算的能耗高。

2. 每 token 固定计算费：前馈神经网络（FFN）和前向投影的计算。这部分每个 token 是固定的——不管上下文多长，每生成一个 token 都要做一次同样规模的矩阵乘法。这是模型的"基础代谢率"，像人体维持体温所需的最低热量。

所以总能耗的直觉图景是：**Prefill 是一次性投入，Decode 是持续运营；Prefill 的开销跟输入长度二次方增长，Decode 的开销跟上下文长度线性累积，再加上每 token 的固定成本。**输入越长，Prefill 越贵；输出越长，Decode 越贵；上下文越长，每个 token 的 KV-cache 读取税越重。

这还没完。现代 LLM 的注意力架构各不相同，而架构直接影响 KV-cache 的大小和读取量。**Multi-Head Attention（MHA）**是最经典的设计：每个注意力头都有自己独立的 Key-Value 对，query 头数等于 KV 头数，KV-cache 大小跟头数成正比。**Grouped-Query Attention（GQA）**是 2023 年后主流的效率优化：让多个 query 头共享同一组 Key-Value 对，比如 32 个 query 头共享 8 个 KV 头（R=1/4），KV-cache 直接缩小 4 倍。更激进的 GQA 可以做到 R=1/7 甚至更小。**Multi-Head Latent Attention（MLA）**则用低秩压缩把 Key 和 Value 压成一个潜在向量，需要时再还原，进一步压缩 KV-cache。

不同的 GQA 分组比例（R 值）意味着完全不同的 KV-cache 大小和内存带宽需求，能耗差好几倍。一个不考虑注意力架构的能耗模型，就像不看排量、不看混动还是燃油就收汽车税——同样跑 100 公里，能耗可能差 3 倍。

📐 前人的秤：从线性拟合到 SweetSpot

在 SIMPLE 之前，研究者们已经做了很多努力来预测 LLM 推理能耗。论文把这些工作分门别类，像陈列一批越来越精密的秤——每一代都比上一代准，但都有各自的盲区。

线性模型是最朴素的起点：总能耗 ≈ θ₀ + θ₁·输入长度 + θ₂·输出长度。意思是每个输入 token 标一个固定价钱 θ₁，每个输出 token 标一个固定价钱 θ₂，加起来就是总账。Vellaisamy 等人只关注 Decode 能耗，把 Prefill 成本吸收进常数项；Zhan 等人把输入长度作为显式项。问题是它们完全忽略了 token 之间的相互影响——第二个 token 和第二百个 token 的"回头看"成本被当成一样的，跟物理现实相去甚远。它们也不是从第一性原理推导的，纯粹是经验拟合，换一个新模型就得重新拟合一遍。

双线性模型加了一个交互项：θ₃·输入长度×输出长度。这下至少捕捉到了"输入越长、每个输出 token 越贵"这个直觉——因为输入越长，KV-cache 越大，每个 Decode step 要读的数据越多。Wilkins 等人用 ANOVA 统计方法证实输入和输出长度确实有显著的联合效应；Delavande 等人从 roofline 模型出发解析地推导出了同样的形式。但它们仍然没有引入任何架构参数——层数、隐藏维度、注意力配置全部缺席——所以同样无法跨模型泛化。

幂律模型走了一条不同的路。Oviedo 等人提出自底向上的框架：从节点功耗和 token 吞吐率出发，用 PUE（电能使用效率）校正数据中心开销，再用分段对数线性回归拟合吞吐率随序列长度的变化。因为吞吐率的对数是序列长度的线性函数，代入能耗公式就自然得到幂律关系。灵活，但仍然纯粹经验性，仍然无法解释，仍然无法跨模型泛化。

SweetSpot 是目前公认最精确的解析模型，也是 SIMPLE 最直接的对手。它从 Transformer 的计算内核出发——逐个矩阵乘法地推导 Prefill 和 Decode 的 FLOPs 和数据搬运量——特别是把 KV-cache 随输出增长的过程建模为等差数列求和，最终得到一个漂亮的闭式二次型表达式。在单个模型上，它把 MAPE（平均绝对百分比误差）从双线性基线的 30% 以上压到了惊人的 2% 以下。

但 SweetSpot 有一个致命的身份危机：它是拟合，不是定律。 它的六个系数 θ₀ 到 θ₅ 是在单个 LLM 上用大量实测数据拟合出来的，那个模型的层数 L、隐藏维度 d、注意力配置 R 全部被吸收进了这些系数里。你问它"θ₂ 代表什么物理意义"，它答不上来——它只是一个恰好在这个模型上表现很好的数字。你问它"一个我从没测过的新架构能耗多少"，它更答不上来——因为系数跟模型绑死了。它精确描述了一个已测量的区间，但没有解释那个区间为什么长这样，更无法预测区间之外的世界。

论文把现有模型按三个关键标准做了一张盘点表，像给每个模型发一张成绩单：第一，是不是解析推导的（从 Transformer 计算复杂度出发），还是纯粹经验拟合？第二，是不是 LLM 无关的（换个模型不用重新拟合系数）？第三，是不是注意力感知的（能区分 MHA 和 GQA，把架构参数写进公式）？把三个标准横向一拉——三个勾同时打上的，一个都没有。这就是 SIMPLE 要填的空白。

⚖️ SIMPLE 的诞生：四个参数，三层成本

SIMPLE 的名字是个精心设计的回文缩写：SIMPLE Inference Model to Predict LLMs Energy。拆开就是"用于预测 LLM 能耗的简易推理模型"——"简易"不是妥协，而是设计的核心追求：在精度和简洁之间找到那个甜点。

它的推导过程像一场从分子到原子的还原之旅。研究团队从 Transformer 的前向传播出发，逐个矩阵乘法地计算 Prefill 和 Decode 两阶段的 FLOPs（浮点运算次数）和 MemOPs（内存访问次数）。每一个投影矩阵——Query、Key、Value、Output——都有精确的 FLOPs 和 MemOPs 表达式。注意力分数矩阵的计算、FFN 的两次矩阵乘法、KV-cache 的读取，每一项都被拆开、量化、求和。

然后他们做了一件前人没做到的事：把建筑图纸上的参数——层数 L、隐藏维度 d、Query 头数 n_q、KV 头比 R——直接作为变量写进公式里。 不是拟合出来的系数，不是隐含在数字里的黑箱，而是明明白白出现在等式右边的物理量。

在经过系统的项消融（去掉统计显著性低的项）、低阶近似（丢弃贡献微小的项）、和分组策略优化之后，最终公式收敛到惊人的简洁——只有四项：

E_tok = θ₁·d²·L·(τ_in/τ_out) + θ₂·d·L·R·(τ_in + τ_out/2) + θ₀ + θ₃·d·L

（τ_in = 输入长度，τ_out = 输出长度，d = 隐藏维度，L = 层数，R = KV头比）

用大白话逐条翻译：

第一项 θ₁·d²·L·(τ_in/τ_out) 是"Prefill 摊销"。 它描述了处理输入 prompt 的固定成本如何摊到每个输出 token 上。注意它跟隐藏维度 d 的平方成正比——这是整个公式里最敏感的参数，d 翻一倍，这项翻四倍。它也跟层数 L 成正比——层数翻倍，每层都要做 Prefill 计算，总成本自然翻倍。τ_in 体现了输入越长 Prefill 越贵的直觉。但关键是它被 τ_out 除——输出越多，固定成本摊得越薄。这就像开工厂的固定投入：产量越大，单位成本越低。但工厂本身越大（d 越大），固定成本高得惊人——这是"胖模型"在长输入场景下的结构性劣势。

第二项 θ₂·d·L·R·(τ_in + τ_out/2) 是"KV-cache 税"。 它描述了每个 Decode step 中从 KV-cache 读取历史 token 数据的成本。τ_in + τ_out/2 来自等差数列求和：第 1 个输出 token 要读 τ_in 个 KV 对，第 2 个读 τ_in+1 个，……第 τ_out 个读 τ_in+τ_out-1 个，取平均就是 τ_in + τ_out/2。R（KV 头比）在这里扮演关键角色——GQA 的 R < 1（比如 R=1/4 意味着 4 个 query 头共享 1 个 KV 头），KV-cache 更小，这项就越低。这就是"注意力感知"的数学表达：公式里明明白白写着 R，换一个 GQA 配置，预测值立刻不同。

第三项 θ₀ 和第四项 θ₃·d·L 是"每 token 固定运营成本"。 θ₀ 是一个常数，可以理解为 GPU 待机、进程调度、CUDA 上下文管理的基础能耗——即使什么都不做也在"烧"的电。θ₃·d·L 是每生成一个 token 都要做的前向投影和 FFN 计算——跟上下文长度无关，就是模型的"基础代谢率"。d·L 的乘积正比于参数量（每层的参数量约等于 d² 的常数倍，乘以 L 层），所以这项本质上是在说：每生成一个 token，你都要把整个模型的所有参数从显存里搬一遍。

四个参数 θ₀ θ₁ θ₂ θ₃，三层成本结构，没有一个系数是凭空拍的。每个 θ 都对应一个可以物理解释的过程，每个建筑参数（d, L, R, n_q）都在公式里露了脸。这从"拟合"升格到了"定律"。

📊 十三罗汉的审判

理论再漂亮，也得过实验这关——而这关设置得相当严格。

团队在 NVIDIA H100 GPU 上测试了 13 个 dense LLM，来自 6 个家族：OPT、LLaMA、Gemma、Falcon、Qwen2、Granite。参数量从 1B 到 9B，注意力架构从标准 MHA（R=1）到各种 GQA 比例（R=1/2, 1/3, 1/4, 1/6, 1/7）都有覆盖。输入长度和输出长度各自独立地从 64 到 4096 token 扫描，2 的幂次递增，共 49 种组合，每种组合跑 1000 个请求。GPU 功耗每 500 毫秒采样一次，用平均功耗乘以总时间再除以请求数得到每请求能耗。

结果令人印象深刻。在留一交叉验证（LOOCV，每次留出一个模型的全部数据做测试）中，SIMPLE 拿到 R² = 0.944，MAPE = 13.25%。在全量数据拟合上，R² = 0.969，MAPE = 11.97%。

最关键的是 k-fold 交叉验证：SIMPLE 的 R² = 0.965 ± 0.015，MAPE = 12.89% ± 3.38%。这意味着它在没见过的新模型上也能准确预测能耗——因为它不是在背每个模型的电费单，而是在算每个模型的功率曲线。

跟此前 SOTA 的对比最有说服力。SweetSpot 需要逐模型拟合六系数才能达到高精度，SIMPLE 用一个跨模型共享的四参数拟合就做到了同级别的精度，误差反而低了 3.1–3.5 倍。其他 LLM 无关模型的表现则惨不忍睹：Zhan 等人的五系数线性模型 R² 只有 0.448，Vartziotis 等人的六系数模型 MAPE 高达 37.7%——它们的"LLM 无关"是以牺牲太多精度换来的。而 25 参数的 Fine-Grained 模型虽然 R² = 0.967 勉强追平了 SIMPLE，但参数多了 6 倍，每个参数都没有物理意义，完全丧失可解释性。

一个四参数的公式打败了 25 个参数的模型。这验证了奥卡姆剃刀在物理建模中的力量：正确的复杂度分组比暴力的精细拟合更有效。

💡 三个发现：胖在 d 上，省在 GQA 上，峰值在中间

SIMPLE 的价值不仅在于预测准——更在于它真的解释了为什么。定律和拟合的分水岭就在这里：拟合只能告诉你"是什么"，定律能告诉你"为什么"和"怎么办"。

发现一：隐藏维度 d 是能耗的头号敏感参数。

Prefill 能耗跟 d² 成正比。这意味着什么？意味着如果你把隐藏维度从 2048 提到 4096（翻倍），参数量大约翻 4 倍（因为参数量正比于 d²），Prefill 能耗也跟着翻 4 倍。但层数 L 翻倍，Prefill 能耗只翻 2 倍——因为 L 是以一次方的形式出现的。

换句话说，在参数量相同的前提下，"矮胖"架构（大 d、少层）比"瘦高"架构（小 d、多层）的 Prefill 能耗要高得多。论文建议：如果你的应用场景以长输入为主——比如文档分析、代码审查、长对话——选模型时应该优先选 d 较小但层数较多的瘦高架构。这个建议在以前只能靠实测 trial-and-error，现在可以在图纸阶段就用 SIMPLE 算出来。

发现二：GQA 分组比例是性价比最高的节能旋钮。

在参数量相近的模型之间比较，能效差距惊人。Qwen2 1.5B（GQA, R=1/7）达到了 49.06 tok/J（每焦耳产 49 个 token），而 OPT 1.3B（MHA, R=1）只有 20.66 tok/J——同样的电，Qwen2 多产了 2.4 倍的 token。Llama 3.2 1B（GQA, R=1/4）更是达到了 55.91 tok/J。最惨的是 Falcon-RW 7B（MHA, R=1），只有 5.12 tok/J——7B 的参数量，能效却只有 1B 模型的十分之一。

更激进的 KV 分组最多可以降低 3 倍的每 token 能耗。这背后的物理直觉很简单：R 越小，KV-cache 越小，每个 Decode step 要搬运的数据越少，内存带宽的瓶颈越轻。论文开头的观察在这里得到了定量验证：模型大小本身不足以表征推理能耗，注意力架构才是隐藏的主角。

发现三：Intelligence per Joule 存在一个中间峰值——想太多不仅慢，还费电。

这是最有战略意义的发现，直接关系到当前推理模型（Reasoning Model）的热潮。现在流行的做法是"让模型多想一会儿"——给模型更多推理 token budget，让它在回答之前先做充分的思考，换更高的准确率。这个 trade-off 看起来很划算：多花几个 token 的算力，换 5-10 个点的精度提升。

但 SIMPLE 定律揭示了一个被忽视的暗面。它可以解析地推导出每 token 能耗最小时的输出长度：太短了，Prefill 成本摊不下去，单位成本很高；太长了，KV-cache 税越积越重，单位成本也很高。中间存在一个甜点。

问题在于：增加推理 budget 会把输出长度推到甜点之外，进入超线性增长区间。虽然准确率确实在涨，但能耗涨得更快——所以 Intelligence per Joule（IPJ，每焦耳产出的智能量）在中等 budget 达到峰值。在一个 4 倍 budget 的扫描范围内，IPJ 最多可以跌落 3.14 倍。

翻译成人话：想太多不仅浪费时间，还浪费电——而且浪费的比例是加速上涨的。 存在一个最优的"思考长度"，过了那个点，每多换一分智能，要付出的电量代价是递增的。这对推理模型的部署策略有直接指导意义：不是给所有 query 都开最大思考预算，而是根据任务的难度动态分配——简单的问题少想，难的问题多想，把电力花在刀刃上。

🤖 Agentic 的电老虎：13 倍能耗炸弹

最后也是最扎心的发现，直接关系到 AI 行业最热的方向——Agentic AI（智能代理）。

Agentic 系统是那些不只做一次回答、而是会自己规划、自己调用工具、自己多轮对话、自己检查结果的系统。它们的工作模式天然导致超长的输入：每一轮对话都要带上之前的完整历史，每一次工具调用都要带上工具返回的结果，每一次规划都要引用之前的思考链。

数据是惊人的：Agentic 场景的中位输入长度已经从非 Agentic 的 750–1050 token 膨胀到了 68K token——膨胀了约 65 倍。根据 SIMPLE 定律，能耗增长来自两个方向同时恶化：Prefill 项随 τ_in 线性增长（但对 d² 敏感），KV-cache 项也随 τ_in 线性增长且在每个 Decode step 中持续累积。两者叠加，Agentic 请求的每请求能耗是普通请求的 13.0 倍。

Prefix caching（前缀缓存）是业界应对这个问题的标准手段：如果多个请求共享相同的长前缀——比如同一个系统 prompt、同一份文档背景——就只需要 Prefill 一次，后续请求直接复用缓存的 KV-cache，跳过重复计算。它能帮忙吗？

能，但只帮一半。数据显示 prefix caching 可以省掉 93% 的 Prefill 成本——听起来很不错。但看 SIMPLE 公式的第二项：KV-cache 税完全不受影响。Prefix caching 省掉的是蛋糕的奶油层，蛋糕本体——每个 Decode step 都要读的巨大 KV-cache——还在。结果：即使完全命中缓存，一个 Agentic 请求仍然比普通请求贵 4.8 倍。

这对正在规划 Agentic 基础设施的团队是一个直接的预警：光优化 Prefill 远远不够，KV-cache 的内存带宽才是真正的瓶颈。未来的优化方向——更激进的 GQA、MLA 压缩、KV-cache 量化、甚至把 KV-cache 搬到更快的存储介质上——比 prefix caching 的优先级应该更高。

🧭 从实测到推导：一把在图纸阶段的尺子

SIMPLE 的意义不在于又一个精度更高的能耗模型——虽然它确实更准、更简洁、更通用。意义在于它让"能效"从一个事后的排名表变成了一个事前的设计工具。

以前，你只能在模型部署完之后去测它的能耗效率，然后排名、颁奖、写报告、做 PPT。但那时候架构已经不是变量了——你测的只是你已经建好的东西，排名再高也不能让已经训练好的模型换一副骨架。这就像在房子建完之后测量保温性能——数据再精确，你也只能给房子打个分，不能把它拆了重建。

有了 SIMPLE，情况完全不同。你可以在训练之前就估算不同候选架构的能耗特征：瘦高还是矮胖？MHA 还是 GQA？R 取 1/4 还是 1/8？配合给定的典型工作负载（输入多长、输出多长），SIMPLE 可以给出量化的能耗预测。你可以回答"多少个推理 token 值得花"这个一直只能拍脑袋的问题——不是凭感觉，而是用 IPJ 曲线找峰值。你可以算出在什么上下文长度上 Agentic 服务的成本会失控，提前做好容量规划。

论文留下了一个互动实现（GitHub: ecs-lab/SIMPLE），输入架构参数和序列长度，输出预测的每 token 能耗。一个四参数的公式，给整个行业提供了一把在图纸阶段就能用的尺子。

当然，SIMPLE 也有边界。它目前只覆盖 dense 模型，MoE（混合专家）架构的能耗模式会更复杂——每个 token 只激活部分专家，能耗跟路由决策强相关，四个参数可能不够。它假设固定的 batch size，没有建模动态 batching 的影响——而实际 serving 中的 continuous batching 会显著改变能耗特征，多个请求共享计算资源时的能耗分配是个更复杂的课题。它也没有考虑量化——INT8 或 INT4 量化后的模型，内存带宽需求大幅下降，KV-cache 占用缩小，系数 θ 会发生质的变化，需要重新校准。推理阶段的硬件优化技术——FlashAttention、KV-cache 分页管理、推测解码（speculative decoding）——也都会改变能耗 profile。

但即便如此，SIMPLE 已经完成了它的核心使命。从分子级的矩阵乘法推导，到四个参数的宏观定律，再到跨 13 个模型、6 个家族的实验验证，它第一次让"一个 token 值多少电"这个问题有了解析答案。对正在做架构选择的团队来说，这意味着能耗不再是一个需要部署后才能测量的黑箱指标，而是一个可以在设计阶段就纳入决策的显式变量。对正在做容量规划的工程师来说，这意味着可以精确估算不同工作负载下的电力需求，而不是靠经验法则拍脑袋。对正在写 ESG 报告的企业来说，这意味着 AI 系统的碳足迹终于可以算清楚了——不是粗略的估算，而是基于物理定律的定量预测。每个 token 都有暗中的价钱，现在，这个价钱可以算出来了——在图纸阶段就能算。

参考文献

• Cavagna, H. P., Proia, A., Cesarini, D., Kiziltan, Z., & Bartolini, A. (2026). The SIMPLE Law for Energy Cost of LLM Inference. arXiv:2611.03330.
• SweetSpot: A Quadratic Closed-Form Model for LLM Inference Energy (2026). Prior SOTA baseline.
• Kaplan, J., et al. (2020). Scaling Laws for Neural Language Models.
• Aminabadi, R. Y., et al. (2022). DeepSpeed Inference: Enabling Efficient Inference of Transformer Models at Unprecedented Scale.
• Vaswani, A., et al. (2017). Attention Is All You Need.
• Ainslie, J., et al. (2023). GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints.

#LLM #能耗 #推理 #效率 #可持续AI #算力 #论文解读 #SIMPLELaw #费曼风格