整合自对话记录与 GPT3.md 文件，涵盖 GPT-3 架构参数、完整前向传播数值演示、各层矩阵运算规模，以及 FLOPs 与电能消耗的关系。
| 参数 | 数值 |
|---|---|
| 模型名称 | GPT-3 |
| 发布机构 | OpenAI |
| 发布日期 | 2020-06-11 |
| 训练 token 数 | 3000 亿（$3 \times 10^{11}$） |
| 词表大小 $|V|$ | 50,527 |
| 总参数量 | 1750 亿（$1.75 \times 10^{11}$） |
| 层数 | 96 |
| 模型维度 $d_{model}$ | 12,288 |
| 注意力头数 | 96 |
| 每头维度 | 128（= 12288 ÷ 96） |
| FFN 中间维度 | 49,152（= 12288 × 4） |
| Batch size | 3,200,000 tokens |
| 学习率 | 6e-05 |
| 训练硬件 | V100 GPU |
$$3,200,000 \text{ (tokens)} \times 12,288 \text{ (dims)} \approx 3.93 \times 10^{10} \text{ (elements)}$$
这个乘积体现在三个方面：
1. 显存压力
使用 FP16（每个数占 2 字节），仅存储一层的激活值就需要：
$$3.2 \times 10^6 \times 12288 \times 2 \text{ 字节} \approx \textbf{78.6 GB}$$
一张 H100（80GB 显存）几乎被一层的中间结果撑满。这直接决定了模型必须使用张量并行或数据并行，将 320 万个 token 分散到成百上千块显卡上。
2. 矩阵乘法的规模
每一层的核心运算 $Y = XW$：
3. 梯度下降的平滑度
320 万个 token 的梯度平均，统计信息足够丰富，支撑模型使用较大学习率（6e-05）而不崩溃。
先追踪 1 个 token，感受形状；最后乘以 batch size 感受总规模。
$$E \text{ 的形状} = [50527,\ 12288] \quad \text{参数量} = 50527 \times 12288 = \textbf{6.2 亿}$$
取出第 42 行，得到初始向量：$x_0 \text{ 的形状} = [1,\ 12288]$
加位置编码（形状不变）：
$$x_0 = \text{Embedding} + \text{PositionalEncoding} \quad [1,\ 12288]$$
形状不变：$[1,\ 12288] \rightarrow [1,\ 12288]$
这里的 Layer Norm 不是矩阵乘法，而是对当前 token 的 12288 维隐藏向量做归一化。假设当前 token 的向量是 $x = [x_1, x_2, \dots, x_{12288}]$。
先计算平均值：
$$\mu = \frac{1}{d}\sum_{i=1}^{d} x_i$$
再计算方差：
$$\sigma^2 = \frac{1}{d}\sum_{i=1}^{d}(x_i-\mu)^2$$
然后标准化：
$$\hat{x}_i = \frac{x_i-\mu}{\sqrt{\sigma^2+\epsilon}}$$
最后乘上可训练的缩放参数 $\gamma_i$，加上平移参数 $\beta_i$：
$$y_i = \gamma_i \hat{x}_i + \beta_i$$
其中 $d=12288$，$\epsilon$ 防止除以 0，$\gamma$ 和 $\beta$ 的形状都是 $[12288]$。
生成 Q、K、V（各一次）：
$$Q = x \cdot W_Q \quad [1,\ 12288] \times [12288,\ 12288] \rightarrow [1,\ 12288]$$
$W_Q,\ W_K,\ W_V$ 各有参数量：$12288^2 = \textbf{1.51 亿}$
切分为 96 个头，每头 128 维：
$$[1,\ 12288] \rightarrow \text{96 个头，每头} [1,\ 128]$$
小知识点：为什么是 96 个头？
GPT-3 175B 的隐藏维度是 $d_{\text{model}}=12288$，注意力头数是 $n_{\text{heads}}=96$，所以每个头的维度是：
$$d_{\text{head}}=\frac{d_{\text{model}}}{n_{\text{heads}}}=\frac{12288}{96}=128$$
这里的 96 不是严格数学推导出来的最优值，更像是经验、实验和硬件效率共同作用后的设计选择。实际设计大模型时，常见做法是让每个 head 保持一个比较合适的维度，例如 64 或 128，然后根据总隐藏维度反推头数。
一句话：GPT-3 的 96 个头不是公式证明出的最优解，而是在 $12288$ hidden size 下选择 $128$ head dimension 后得到的工程经验平衡点。
每头计算注意力得分：
$$\text{score} = Q_{head}K_{head}^T = [1,128] \times [128,1] = \text{一个标量}$$
Softmax 后加权求和，每头输出 $[1,\ 128]$，96 头拼接回 $[1,\ 12288]$。
以下展开多头注意力的完整计算细节。
小注解：$q_3$ 里的 3 是什么？
在例子"黑猫睡"里：$x_1=\text{黑},\quad x_2=\text{猫},\quad x_3=\text{睡}$
所以 $q_3$ 表示第 3 个 token，也就是"睡"这个位置生成的 query 向量。这里的下标 3 是位置序号，不是第 3 维，也不是第 3 个 attention head。计算"睡"的注意力输出时，会用 $q_3$ 分别和 $k_1,k_2,k_3$ 做相似度计算。因为 GPT 是因果模型，所以第 3 个 token 只能看位置 1、2、3，不能看未来的位置 4、5、...。
教科书公式 8.10～8.14（单头模板）：
$$\begin{aligned} q_i &= x_i W^Q \\ k_j &= x_j W^K \\ v_j &= x_j W^V \end{aligned} \tag{8.10}$$
$$\text{score}(x_i, x_j) = \frac{q_i k_j^T}{\sqrt{d_k}} \tag{8.11}$$
小知识点：为什么原书写 $q_i \cdot k_j$，工程里常写 $q_i k_j^T$？
原书里的 $q_i \cdot k_j$ 是向量点积写法，数学上没有问题。点积符号 $\cdot$ 本身就表示两个向量逐维相乘后求和：
$$q_i \cdot k_j = \sum_{m=1}^{d_k} q_{i,m} k_{j,m}$$
如果把 $q_i$ 和 $k_j$ 都看成行向量（形状 $[1,d_k]$），要得到一个标量就需要转置：
$$q_i k_j^T:[1,d_k]\times[d_k,1]\rightarrow[1,1]$$
所以 $q_i \cdot k_j \equiv q_i k_j^T$，区别只是视角不同——前者是数学内积写法，后者是工程矩阵乘法写法，更容易和代码里的 $QK^T$ 对上。
$$\alpha_{ij} = \text{softmax}(\text{score}(x_i, x_j)) \tag{8.12}$$
其中 $j \leq i$（因果掩码：只对当前及之前的位置计算注意力权重，$j > i$ 时 $\alpha_{ij} = 0$）。
$$\text{head}_i = \sum_{j \leq i} \alpha_{ij} v_j \tag{8.13}$$
$$a_i = \text{head}_i W^O \tag{8.14}$$
正确理解 8.10～8.14：这是一套完整的单头注意力公式
首先澄清一个容易犯的错误：8.10～8.14 本身量纲完全自洽，不存在任何问题。
单头注意力的含义是：用 token 的全部 $d_{\text{model}}$ 维度跑一套 QKV 计算，整个 $d_{\text{model}}$ 就是唯一的一个头在处理。此时：
$$W^Q, W^K, W^V \in \mathbb{R}^{d_{\text{model}} \times d_{\text{model}}}$$
$$q_i,\ k_j,\ v_j \in \mathbb{R}^{1 \times d_{\text{model}}}$$
$$\text{head}_i = \sum_{j \le i} \alpha_{ij} v_j \in \mathbb{R}^{1 \times d_{\text{model}}}$$
$$a_i = \text{head}_i \cdot W^O : [1,\ d_{\text{model}}] \times [d_{\text{model}},\ d_{\text{model}}] \rightarrow [1,\ d_{\text{model}}] \quad \checkmark$$
量纲完全闭合，不需要任何额外步骤。
$\text{head}_i$ 里的 $i$ 是 token 位置（$j \le i$ 这个因果掩码就是证据），"head" 只是这个单头输出的名字——作者用 head 命名，是为了和多头场景的语义保持一致（多头里每个头也叫 head）。
单头 vs 多头的直觉区别：
| 单头注意力 | 多头注意力（GPT-3） | |
|---|---|---|
| 头数 | 1 | 96 |
| 每个头处理的维度 | 全部 $d_{\text{model}}=12288$ 维 | 切分后每头 $d_{\text{head}}=128$ 维 |
| $W^Q$ 形状 | $[12288, 12288]$ | 每头 $[12288, 128]$ |
| $\text{head}_i$ 维度 | $12288$ | 每头 $128$，拼接后 $12288$ |
$128 \ne 12288$ 的冲突从哪里来？ 只在把这套公式套用到多头场景（每头 $W^Q$ 已切成 $[12288, 128]$）却不加拼接步时才会出现。这是应用时遗漏了拼接步骤的问题，不是公式 8.10～8.14 本身的错误。
为什么还要补一套修正公式（8.10′～8.15′）？
原版 8.10～8.14 是自洽的单头模板，但它没有显式体现多头——头编号不出现在任何符号里，读者无法直接看出如何扩展到多头。修正版的目的是把头编号 $(c)$ 和位置下标 $i,j$ 彻底分开写清楚，同时把缺失的拼接步骤（8.14′）和输出投影（8.15′）显式列出，让多头计算流程在符号层面完整可见。
约定：头数 $h=96$，$d_{\text{model}}=12288$，每头维度 $d_{\text{head}}=d_{\text{model}}/h=128$。上标 $(c)\in\{1,\dots,h\}$ 表示第 $c$ 个头；下标 $i$ 为 query 位置、$j$ 为 key/value 位置。两个维度各占一个符号位，全篇不复用。
说明：头编号用上标 $(c)$ 是为了和位置下标 $i,j$ 在视觉上分到上/下两层而做的消歧选择，并非业界标准记号。最经典的 Vaswani(2017) 反而用下标 $\text{head}_i$ 表示第 $i$ 个头——这也正是原文 $\text{head}_i$ 把「头」和「位置」记号撞车的根源。字母可随意，关键是「头维度与位置维度永不复用」并在开头声明。
三条简化前提（GPT-3 特例 / 教学抽象，需显式标明）：
| 声明 | 内容 | 影响 |
|---|---|---|
| 维度合一 | 一般注意力允许 $d_k\ne d_v$、缩放只用 key 维 $d_k$；本文代入 GPT-3 恰有 $d_k=d_v=d_{\text{head}}=128$，故统一写 128。 | 缩放因子、value 维、单头输出维 |
| 缩放用 key 维 | (8.11′) 的缩放是 $\sqrt{d_k}=\sqrt{128}$，不是 $\sqrt{d_{\text{model}}}$。 | (8.11′)、矩阵形式 |
| 省略 bias | 投影写成 $xW$ 是教学抽象（bias 为 $O(d)$ 量级，参数量统计中可忽略）；GPT-3 实际实现为 $xW+b$。 | 全部投影、$W^O$ |
(8.10′) 每头各自投影（输出 128 维；完整实现为 $x_iW^{Q,(c)}+b^{Q,(c)}$，此处略去 bias）：
$$\begin{aligned} q_i^{(c)} &= x_i\,W^{Q,(c)} \\ k_j^{(c)} &= x_j\,W^{K,(c)} \\ v_j^{(c)} &= x_j\,W^{V,(c)} \end{aligned} \tag{8.10'}$$
$$W^{Q,(c)},W^{K,(c)},W^{V,(c)}\in\mathbb{R}^{12288\times128} \;\Rightarrow\; q_i^{(c)},k_j^{(c)},v_j^{(c)}\in\mathbb{R}^{1\times 128}$$
(8.11′) 该头内得分（缩放因子为 key 维 $\sqrt{d_k}=\sqrt{128}$）：
$$\text{score}^{(c)}(x_i,x_j)=\frac{q_i^{(c)}\,\big(k_j^{(c)}\big)^{\!\top}}{\sqrt{d_k}} \tag{8.11'}$$
矩阵形状：$[1,128]\times[128,1]\to[1,1]$（结果为标量）
(8.12′) 因果 softmax（分母显式对 $j'\le i$ 求和，故无歧义）：
$$\alpha_{ij}^{(c)}=\frac{\exp\!\big(\text{score}^{(c)}(x_i,x_j)\big)}{\displaystyle\sum_{j'\le i}\exp\!\big(\text{score}^{(c)}(x_i,x_{j'})\big)} \tag{8.12'}$$
其中 $j \leq i$（因果掩码）；$j > i$ 时 $\alpha_{ij}^{(c)} = 0$。
(8.13′) 单头输出（128 维，下标 $i$=位置，上标 $(c)$=头）：
$$\text{head}_i^{(c)}=\sum_{j\le i}\alpha_{ij}^{(c)}\,v_j^{(c)} \tag{8.13'}$$
输出维度：$\text{head}_i^{(c)}\in\mathbb{R}^{1\times 128}$（下标 $i$=位置，上标 $(c)$=头）。
(8.14′) 跨头拼接（原文缺失、修正核心：头上标在此被收掉，结果只剩位置下标）：
$$o_i=\operatorname{Concat}\!\big(\text{head}_i^{(1)},\dots,\text{head}_i^{(h)}\big) \tag{8.14'}$$
输出维度：$o_i\in\mathbb{R}^{1\times 12288}$（$h$ 个 128 维向量拼接）。
(8.15′) 输出投影（$W^O$ 作用在拼接后的 12288 维上，量纲自洽；完整实现含 $+b^O$）：
$$a_i = o_i\,W^O \tag{8.15'}$$
其中 $W^O\in\mathbb{R}^{12288\times12288}$，结果 $a_i\in\mathbb{R}^{1\times 12288}$。
对照原文：$a_i=\text{head}_i W^O$ 之所以算不通，正是因为 $\text{head}_i$ 是 128 维而 $W^O$ 要求 12288 维输入。拆出 (8.14′) 拼接步、并用 $o_i$ 与 $\text{head}_i^{(c)}$ 两个符号，缺口即补上。
矩阵·整序列形式（$X\in\mathbb{R}^{n\times d_{\text{model}}}$，$n$ 个 token 一起算）：
$$Q^{(c)}=XW^{Q,(c)},\quad K^{(c)}=XW^{K,(c)},\quad V^{(c)}=XW^{V,(c)}\;\in\mathbb{R}^{n\times 128}$$
$$A^{(c)}=\operatorname{softmax}_{\text{row}}\!\left(\frac{Q^{(c)}\big(K^{(c)}\big)^{\!\top}}{\sqrt{d_k}}+M\right)\in\mathbb{R}^{n\times n},\qquad M_{ij}=\begin{cases}0,& j\le i\\[2pt]-\infty,& j>i\end{cases}$$
其中 $\operatorname{softmax}_{\text{row}}$ 表示逐行归一化：对 $[n,n]$ 分数矩阵的每一行（固定 query 位置 $i$、沿所有 key 位置 $j$）做 softmax，每行之和为 1。这与 (8.12′) 分母 $\sum_{j'\le i}$ 是同一件事的矩阵写法。
$$H^{(c)}=A^{(c)}V^{(c)}\in\mathbb{R}^{n\times 128},\qquad \operatorname{MultiHead}(X)=\operatorname{Concat}\!\big(H^{(1)},\dots,H^{(h)}\big)\,W^O\in\mathbb{R}^{n\times 12288}$$
逐位置形式的 $a_i$ 即 $\operatorname{MultiHead}(X)$ 的第 $i$ 行；掩码 $M$ 是 (8.12′) 中 $\forall j\le i$ 的矩阵写法。
与「大矩阵切块」视角对接：原文说的 $W^Q[12288,12288]$ 切成每头 $[12288,128]$，就是把 $h$ 个头的投影矩阵横向拼接——
$$W^Q=\big[\,W^{Q,(1)}\ \big|\ \cdots\ \big|\ W^{Q,(h)}\,\big]\in\mathbb{R}^{12288\times12288}$$
「一次大乘法 $XW^Q$ 再切 96 段」与「跑 96 次 $XW^{Q,(c)}$」数值完全等价：前者是工程并行写法，后者是 (8.10′) 的数学定义。
量纲自检：
| 检查项 | 结果 |
|---|---|
| 单头投影参数量 | $96\times(12288\times128)=12288^2=1.51$ 亿 ✓ |
| 拼接维度 | $96\times128=12288=d_{\text{model}}$ ✓ |
| 输出投影 | $o_i[1,12288]\times W^O[12288,12288]\to[1,12288]$ ✓ |
| 缩放因子 | $\sqrt{d_k}=\sqrt{128}\approx11.3$，与原文 Step 2 一致 ✓ |
| $W^O$ 参数量 | $12288^2=1.51$ 亿 ✓ |
四处全部闭合，不再出现 $128\ne12288$ 的冲突。
Step 1：生成 Q、K、V
每个头的 $W^Q$ 是从完整 $[12288,\ 12288]$ 矩阵里切出的 $[12288,\ 128]$ 部分：
$$q_3 = x_3 \cdot W^Q \quad [1,\ 128] \leftarrow [1,\ 12288] \times [12288,\ 128]$$
$$q_3 = [0.5,\ 0.2,\ -0.1,\ \ldots] \quad \text{（128个数）}$$
$$k_1 = [0.4,\ 0.7,\ 0.1,\ \ldots] \quad v_1 = [0.3,\ -0.1,\ 0.5,\ \ldots] \quad \text{（"黑"）}$$
$$k_2 = [0.6,\ 0.3,\ -0.2,\ \ldots] \quad v_2 = [0.1,\ 0.8,\ 0.2,\ \ldots] \quad \text{（"猫"）}$$
$$k_3 = [0.2,\ 0.5,\ 0.4,\ \ldots] \quad v_3 = [0.6,\ 0.2,\ -0.3,\ \ldots] \quad \text{（"睡"自己）}$$
Step 2：计算得分（除以 $\sqrt{128} \approx 11.3$ 防止梯度消失）
$$\text{score}(x_3, x_1) = \frac{0.33}{11.3} \approx 0.029$$
$$\text{score}(x_3, x_2) = \frac{0.52}{11.3} \approx 0.046$$
$$\text{score}(x_3, x_3) = \frac{0.71}{11.3} \approx 0.063$$
Step 3：Softmax 归一化
$$[\alpha_{31},\ \alpha_{32},\ \alpha_{33}] = \text{softmax}([0.029,\ 0.046,\ 0.063]) \approx [0.319,\ 0.328,\ 0.353]$$
| 词 | 注意力权重 | 解读 |
|---|---|---|
| "黑" | 31.9% | "睡"对"黑"的关注程度 |
| "猫" | 32.8% | "睡"对"猫"的关注程度 |
| "睡"自己 | 35.3% | "睡"对自身的关注程度 |
Step 4：加权求和，得到单头输出
$$\text{head}_3 = 0.319 \times v_1 + 0.328 \times v_2 + 0.353 \times v_3$$
$$\text{head}_3 = [0.341,\ 0.301,\ \ldots] \quad \text{（128个数，第1头的输出）}$$
Step 5：96个头拼接
第1头： [0.341, 0.301, ..., ] → 128个数
第2头： [0.112, -0.205, ..., ] → 128个数
...
第96头： [0.223, 0.671, ..., ] → 128个数$$96 \times 128 = 12288 \quad \Rightarrow \quad \text{concat} = [0.341,\ 0.301,\ \ldots,\ 0.223,\ 0.671,\ \ldots] \quad \text{（12288个数）}$$
多头注意力完整流程图：
x₃（"睡"）[1, 12288]
│
┌───┴──────────── 96个头并行 ──────────────┐
│ │
头1 × W^Q[12288,128] 头2 ... 头96
→ q₃[1,128]
├── × W^K → k₁,k₂,k₃ [1,128]
├── × W^V → v₁,v₂,v₃ [1,128]
├── score = q₃·kⱼ / √128
├── softmax → α₃₁,α₃₂,α₃₃
└── Σαⱼ·vⱼ → head₁ [1,128]
│ │
└──────── 拼接 concat ─────────────────────┘
[1, 12288]（= 96 × 128）O 投影（第 4 次矩阵乘法）：
$$[1,\ 12288] \cdot W_O[12288,\ 12288] \rightarrow [1,\ 12288]$$
$W_O$ 参数量也是 1.51 亿。
O 投影的作用：96 个头拼接后只是简单堆叠，$W_O$ 对来自不同头的信息进行"融合"，让不同角度的语义信息真正混合在一起。
Attention 层共 4 次矩阵乘法，参数量：
$$4 \times 12288^2 = \textbf{6.04 亿}$$
$$x_1 = x_0 + \text{attn\_out} \quad [1,\ 12288]$$
$$[1,\ 12288] \cdot W_1[12288,\ 49152] \rightarrow [1,\ 49152]$$
$$W_1 \text{ 参数量} = 12288 \times 49152 = \textbf{6.04 亿}$$
激活函数 GELU（形状不变）：$[1,\ 49152] \rightarrow [1,\ 49152]$
$$[1,\ 49152] \cdot W_2[49152,\ 12288] \rightarrow [1,\ 12288]$$
$$W_2 \text{ 参数量} = 49152 \times 12288 = \textbf{6.04 亿}$$
FFN 相当于 8 个 $[12288 \times 12288]$ 的大小——贡献了模型约 2/3 的参数量和计算量。
| 组件 | 参数量 |
|---|---|
| $W_Q$ | 1.51 亿 |
| $W_K$ | 1.51 亿 |
| $W_V$ | 1.51 亿 |
| $W_O$ | 1.51 亿 |
| $W_1$（FFN 升维） | 6.04 亿 |
| $W_2$（FFN 降维） | 6.04 亿 |
| 一层合计 | 18.1 亿 |
$$96 \times 18.1\text{亿} = \textbf{1,738 亿}$$
加上 Embedding 矩阵 6.2 亿，合计约 1750 亿参数。✓ 与 GPT-3 标称一致。
$$h_{\text{final}} [1,\ 12288] \cdot U[12288,\ 50527] \rightarrow [1,\ 50527]$$
Softmax 后得到 50,527 个词的概率分布，取最大值得到预测的下一个词。
1个token（id=42）
↓ Embedding [50527, 12288]
x₀: [1, 12288]
↓ × 96层，每层：
│
├─ Layer Norm → [1, 12288]
├─ × W_Q [12288,12288] → Q: [1,12288] → 96头，每头[1,128]
├─ × W_K [12288,12288] → K: [1,12288] → 96头，每头[1,128]
├─ × W_V [12288,12288] → V: [1,12288] → 96头，每头[1,128]
├─ 注意力得分+加权求和 → 每头[1,128] → 拼接[1,12288]
├─ × W_O [12288,12288] → [1,12288]
├─ ⊕ 残差连接 → [1,12288]
├─ Layer Norm → [1,12288]
├─ × W₁ [12288,49152] → [1,49152]
├─ GELU → [1,49152]
├─ × W₂ [49152,12288] → [1,12288]
└─ ⊕ 残差连接 → [1,12288]
↓ 96层后
h_final: [1, 12288]
↓ × U [12288, 50527]
logits: [1, 50527]
↓ Softmax
概率分布：50,527个词各自的概率训练时 320 万个 token 同时处理，每次大矩阵乘法的实际形状：
| 矩阵乘法 | 形状 |
|---|---|
| $X \cdot W_Q$ | $[3200000,\ 12288] \times [12288,\ 12288]$ |
| $X \cdot W_1$ | $[3200000,\ 12288] \times [12288,\ 49152]$ |
| $X \cdot W_2$ | $[3200000,\ 49152] \times [49152,\ 12288]$ |
$$2 \times 3,200,000 \times 12,288 \times 12,288 \approx \textbf{966 万亿次} \quad \text{（一次 }W_Q\text{ 乘法的 FLOPs）}$$
$$6 \times 966\text{万亿} \approx \textbf{5,800 万亿次} \quad \text{（一层 Block 共 6 次大矩阵乘法）}$$
$$96 \times 5800\text{万亿} \approx 5.57 \times 10^{17} \text{ 次} \quad \text{（96 层前向传播）}$$
加上反向传播（约为前向的 2 倍），一个 step 总计：
$$\approx 1.67 \times 10^{18} \text{ 次浮点运算}$$
核心指标是能效比：
$$\text{能效} = \frac{\text{FLOP/s}}{\text{Watt}}$$
根据 Epoch AI 研究，GPU/TPU 能效历史上每两年翻一倍。以 FP16 格式，NVIDIA H100 达到每瓦 $1.4 \times 10^{12}$ FLOP/s，Meta MTIA 达到 $2.1 \times 10^{12}$ FLOP/s。
$$\text{电能（焦耳）} = \frac{\text{总 FLOPs}}{\text{FLOP/s per Watt}}$$
$$\text{电度数（kWh）} = \frac{\text{电能（焦耳）}}{3,600,000}$$
训练用 V100 GPU，能效约 $4.7 \times 10^{11}$ FLOP/s per Watt（功耗 300W，吞吐 $1.4 \times 10^{14}$ FLOP/s）。
$$\text{总 steps} = \frac{3 \times 10^{11}}{3.2 \times 10^6} \approx 93,750$$
$$\text{单 step 耗时} = \frac{1.67 \times 10^{18}}{1024 \times 1.4 \times 10^{14}} \approx 11.6 \text{ 秒}$$
$$1024 \times 300W \times 11.6s \approx 0.99 \text{ kWh/step}$$
$$93,750 \times 0.99 \approx \textbf{93 MWh（理论下限）}$$
| 数值 | |
|---|---|
| 理论下限（纯计算） | 93 MWh |
| 实测消耗 | 1,287 MWh |
| 差距倍数 | 约 14 倍 |
差距来源：
| 额外开销 | 说明 |
|---|---|
| PUE（数据中心能效系数） | 散热、照明、网络等，通常使总用电乘以 1.2～1.5 倍 |
| GPU 利用率不足 | 等待通信和 IO 的时间也在耗电 |
| 梯度检查点、重算 | 为节省显存，部分激活值需重新计算 |
| 网络通信开销 | 数千张 GPU 之间同步梯度 |
| 训练不稳定、重启 | 训练中途崩溃重启浪费电力 |
训练 GPT-3 实际消耗约 1,287 MWh 电力，排放超过 550 公吨 CO₂e，以及超过 700 千升水用于冷却（相当于三分之二个奥运标准泳池）。训练 GPT-4 的用电量是 GPT-3 的约 16.5 倍。
推理可能占模型整个生命周期能源使用的 90%。
总 FLOPs（计算量）
÷ 硬件能效（FLOP/s per Watt）
= 理论最低电能（焦耳）
÷ 3,600,000
= 理论最低电度数（kWh）
× PUE（数据中心效率系数，通常 1.2～1.5）
× 实际 GPU 利用率修正（通常除以 0.3～0.5）
= 实际用电量（kWh）
× 当地电网碳强度（kg CO₂/kWh）
= 碳排放量GPU 的每瓦 FLOP/s 从 2010 年到 2024 年以每年约 1.28 倍的速度提升。如果延续，到 2030 年代末训练效率将提升 4 倍。
GPT-3 拥有 1750 亿参数，每个训练 step 约需 $1.67 \times 10^{18}$ 次浮点运算，一层激活值就需要 78GB 显存——这是为什么它需要数百张 GPU、数个月才能训练完成的根本原因。FLOPs 和电能之间的桥梁是硬件能效（FLOP/s per Watt）。GPT-3 训练理论用电 93 MWh，实际因散热、通信、利用率损失等开销，真实用电达 1,287 MWh——是理论值的 14 倍。推理虽然单次用电少，但因持续大规模运行，生命周期内占总用电的 90%。