---
tags: [nanochat, math, flops]
阶段: 02-数学与工程基础
难度: ★★★
created: 2026-10-22
related: "[[矩阵与线性代数速查]], [[梯度下降与AdamW]], [[模型推理优化]]"
---

# FLOPs与训练成本估算

## 定义

**FLOPs**（floating point operations）是浮点运算次数，用作计算量的单位；**FLOP/s** 是算力单位。一次「乘加」记为 2 FLOPs（一次乘法、一次加法），这是深度学习中的通行约定。

训练一个稠密 Transformer 的每 token 计算量近似为

$$
\text{FLOPs/token}=6N+\sum_{\ell=1}^{L}12\,h\,q\,T_{\text{eff}}^{(\ell)},
$$

其中 $N$ 是参与矩阵乘法的参数量，$h$ 是注意力头数，$q$ 是头维，$T_{\text{eff}}^{(\ell)}$ 是第 $\ell$ 层的有效注意力长度。这是 nanochat 的 `GPT.estimate_flops` 实现，也是 PaLM 论文（2204.02311）使用的估算方式。

符号与术语：

- $N$：**矩阵参数**（matmul parameters）个数，即所有与 token 流做矩阵乘法的权重元素数；嵌入表不算，因为它是查表。
- $L$：层数 `n_layer`；$h$：`n_head`；$q$：`n_embd // n_head`；$T$：`sequence_len`。
- **MFU**（model FLOPs utilization）：实际吞吐与硬件峰值的比值，$\text{MFU}=\dfrac{\text{FLOP/s 实测}}{\text{FLOP/s 峰值}}$。
- **峰值算力**：`get_peak_flops` 返回的每卡 bf16 峰值，单位为 FLOP/s。
- $B$：全局批大小（token）；$D$：训练总 token 数；$C$：模型宽度 `n_embd`。
- **param:data 比例**：训练 token 数与缩放参数量的比值，nanochat 由 `--target-param-data-ratio` 控制。

## 为什么重要

- 成本是这个项目的一等公民。README 给出的核心卖点是「2019 年约 43,000 美元的 GPT-2，现在在 8×H100 上约 48 美元」。这个数字只能通过 FLOPs 与单价算出来：训练总 FLOPs 已知，8 卡的峰值算力已知，实测 MFU 已知，三者相除就是小时数，再乘电价就是美元。
- `--depth` 是唯一的复杂度旋钮，其余超参数都由它推出，其中包括训练 token 数（$8\times$ 缩放参数量）与批大小（Power Lines 的 $D^{0.383}$ 规则）。没有 FLOPs 估算，就无法判断深度翻倍意味着多少 token、多少小时、多少成本。
- 训练日志里的 `train/mfu` 是判断「模型是否被数据或通信卡住」的第一指标：MFU 突然下降通常意味着输入形状变了、FA3 退化到 SDPA、或通信占比升高。
- 估算的精度的量级：$6N$ 与 $12hqT$ 两项覆盖了绝大部分计算，误差在个位数百分比；相比之下，误把总参数量当 $N$、或把查表算成矩阵乘法，会带来数倍的偏差。
- 在全书中的位置：前置是 [[矩阵与线性代数速查]] 的 $2mn$ 与 $O(mnk)$、[[梯度下降与AdamW]] 的批大小缩放；后续是 05 阶段的缩放律与 09 阶段的推理成本。通用推理侧优化见 [[模型推理优化]]（跨库）。

## 原理与推导

### 1. 每个乘加 2 FLOPs

矩阵乘法 $\mathbf{C}=\mathbf{A}\mathbf{B}$，$\mathbf{A}\in\mathbb{R}^{m\times k}$、$\mathbf{B}\in\mathbb{R}^{k\times n}$，需要 $mnk$ 次乘加，故

$$
\text{FLOPs}(\mathbf{A}\mathbf{B})=2mnk=O(mnk).
$$

按 FLOP/s 而非「乘加/s」计价的原因：硬件规格与论文都以 FLOP/s 报告峰值，乘加数乘 2 才能与峰值对齐。约定本身不影响结论，但混用会让估算差一倍。

对单个 token（$m=1$），一个 $(C_{\text{out}},C_{\text{in}})$ 的权重消耗 $2C_{\text{out}}C_{\text{in}}$ FLOPs 前向。这就是 $N$ 与计算量之间的桥：**每个矩阵参数每个 token 恰好贡献 2 FLOPs 的前向计算。**

### 2. 前向 2N，反向 4N

**前向**：每个矩阵参数被一次乘加使用一次，所以每 token 前向为

$$
\text{FLOPs}_{\text{fwd}}=2N .
$$

**反向**：设某层 $\mathbf{Y}=\mathbf{X}\mathbf{W}^{\top}$，$\mathbf{X}\in\mathbb{R}^{T\times C_{\text{in}}}$、$\mathbf{W}\in\mathbb{R}^{C_{\text{out}}\times C_{\text{in}}}$。反向需要两个梯度：

$$
\frac{\partial\mathcal{L}}{\partial\mathbf{X}}=\frac{\partial\mathcal{L}}{\partial\mathbf{Y}}\mathbf{W},\qquad
\frac{\partial\mathcal{L}}{\partial\mathbf{W}}=\Big(\frac{\partial\mathcal{L}}{\partial\mathbf{Y}}\Big)^{\top}\mathbf{X}.
$$

两个都是形状相同的矩阵乘法，各消耗 $2N$ FLOPs/token。因此反向是前向的两倍：

$$
\text{FLOPs}_{\text{bwd}}=4N .
$$

合计 $\text{FLOPs}_{\text{fwd+bwd}}=6N$，即 **$6N$ 规则**。

适用条件必须说清楚：稠密模型、每个参数都参与矩阵乘法、忽略 softmax 的指数与除法、忽略归一化与逐元素运算、忽略嵌入查表。Chinchilla 的公式把这些小项也算进去，差异约 1%（`estimate_flops` 的注释列出了两条：Chinchilla 计入嵌入层与 softmax 的超越函数，nanochat 不计）。这些项合计约为 $6N$ 的 1%，省略不影响成本判断。

若把 $6N$ 中的 $N$ 误换成总参数量（含 `wte`、`value_embeds`），d24 会从 729,810,648 变成 1,384,122,122，$6N$ 从 $4.38\times10^{9}$ 变成 $8.30\times10^{9}$，结果偏大 90%。这是最容易犯的错。

### 3. 注意力项 $12hqT$

$6N$ 只覆盖了「参数型」矩阵乘法，注意力的内积没有参数，必须单独加。对第 $\ell$ 层、单个 token：

- 计算 $\mathbf{q}_i\mathbf{k}_j^{\top}$：每个头与 $T$ 个位置做内积，每个内积 $q$ 次乘加，即 $2qT$ FLOPs；$h$ 个头共 $2hqT$。
- 计算加权求和 $\sum_j a_{ij}\mathbf{v}_j$：每头 $2Tq$ FLOPs，$h$ 个头共 $2hqT$。

前向合计 $4hqT$，反向是前向的两倍，故

$$
\text{FLOPs}_{\text{attn}}^{(\ell)}=4hqT+8hqT=12hqT .
$$

三个近似需要注意：

1. **忽略因果掩码。** 因果注意力下第 $i$ 个位置只与 $i$ 个位置做内积，平均是 $T/2$，精确值约为 $6hqT$。nanochat 沿用 $12hqT$，对总计算量是高估，但注意力项只占 $8.3\%$（见下），高估带来的总误差约 $4\%$。
2. **$h\cdot q=C$。** 因为 $q=C/h$，有 $12hqT=12CT$，注意力项可以只用宽度与序列长度表示。
3. **不适用于 MoE。** 见第 5 节。

### 4. sliding window 修正

nanochat 的 `window_pattern="SSSL"` 在层间平铺：`S` 是短窗口，`L` 是全上下文，最后一层强制为 `L`。窗口大小在 `_compute_window_sizes` 中计算：

```text
long_window = config.sequence_len
short_window = -(-long_window // 4 // 128) * 128   # 向上取整到 128 的倍数
```

$T=2048$ 时 `long_window = 2048`，`short_window = ceil(2048/4/128)*128 = 512`。注意该行注释写作「2048 -> 768」，而表达式实算为 512（$2048/4=512$ 已是 128 的倍数）。本篇以代码计算值为准。

`estimate_flops` 对每层取 `effective_seq = min(window, t)`，再累加：

$$
\text{FLOPs}_{\text{attn}}=\sum_{\ell}12\,h\,q\,\min\big(W_\ell,T\big).
$$

d24 的 24 层按 `SSSL` 平铺，得到 18 个 `S` 层（$W=512$）与 6 个 `L` 层（$W=2048$），最后一层落在 `L` 上不改变计数：

$$
\text{FLOPs}_{\text{attn}}=12\cdot1536\cdot\big(18\cdot512+6\cdot2048\big)=12\cdot1536\cdot21504=396{,}361{,}728 .
$$

若 24 层全是全上下文，该项会是 $12\cdot1536\cdot24\cdot2048=905{,}969{,}664$，即 sliding window 把注意力项压到 43.8%。这也解释了 `window_pattern` 在 05 阶段的吞吐讨论中为什么重要。

### 5. MoE 不适用

`num_matmul_params` 的统计口径是「所有 `Linear` 模块的权重元素之和」。若把 MLP 换成专家混合（MoE），每个 token 只经过 top-$k$ 个专家，但该函数仍会把全部专家算进去，$6N$ 因此严重高估。同样，`dev/LOG.md` 记录过 3D 专家权重（`(num_experts, hidden, dim)`）与 Muon 的兼容性实验，说明未来可能引入 MoE；到那时 `estimate_flops` 必须改成按激活专家计数。当前 master 的 `gpt.py` 是稠密模型，不存在这个问题。

### 6. MFU 与成本

单卡峰值记为 $P_{\text{peak}}$（FLOP/s），$G$ 张卡的实测吞吐为 $\text{FLOP/s}_{\text{actual}}$，则

$$
\text{MFU}=\frac{\text{FLOP/s}_{\text{actual}}}{G\cdot P_{\text{peak}}} .
$$

训练总 FLOPs $F=6N\cdot D$（含注意力项时按本篇公式），则

$$
\text{小时数}=\frac{F}{G\cdot P_{\text{peak}}\cdot\text{MFU}\cdot3600},\qquad
\text{美元}=\text{小时数}\times G\times \text{每小时每卡价格}.
$$

`get_peak_flops` 的查表值（节选）：

| GPU | 峰值（FLOP/s） | GPU | 峰值（FLOP/s） |
|---|---|---|---|
| H100 SXM | 989e12 | A100 | 312e12 |
| H100 NVL | 835e12 | L40S | 362e12 |
| H100 PCIe | 756e12 | RTX 4090 | 165.2e12 |
| H200 | 989e12 | B200 | 2.25e15 |
| H800 SXM | 756e12 | MI300X | 1.3074e15 |

一个必须知道的口径问题：NVIDIA 数据表里 H100 SXM 的 989 TFLOPs 是 bf16 张量核的稠密峰值（含稀疏为 1979 TFLOPs）。`get_peak_flops` 使用 989e12，因此日志里的 MFU 是相对稠密峰值的比例；跨仓库比较 MFU 前必须先确认峰值口径（稀疏、稠密、是否含 sparsity），否则会系统性相差两倍。

### 7. 参数量、token 数与批大小

训练时长还取决于训练多少 token，而 token 数由缩放律给定。`base_train.py` 的三步：

$$
N_{\text{scaling}}=N_{\text{transformer\_matrices}}+N_{\text{lm\_head}},\qquad
D=r\cdot N_{\text{scaling}},\qquad
B=2^{\text{round}(\log_2(B_{\text{ref}}(D/D_{\text{ref}})^{0.383}))}.
$$

第二步的 $r$ 是 `--target-param-data-ratio`，speedrun 取 8；第三步来自 Power Lines（2505.13738），即最优批大小随训练 token 数按 $D^{0.383}$ 增长，$B_{\text{ref}}=2^{19}=524{,}288$ 是 d12 的实测最优批大小，$D_{\text{ref}}$ 是 d12 在相同 $r$ 下的 token 数。d24 的具体取值：

$$
N_{\text{scaling}}=679{,}478{,}976+50{,}331{,}648=729{,}810{,}624,\qquad
D=8\times729{,}810{,}624=5{,}838{,}484{,}992 .
$$

$D/D_{\text{ref}}=6.6286$，$6.6286^{0.383}\approx2.063$，$B_{\text{ref}}\times2.063\approx1.082\times10^{6}$，取最近的 2 的幂得 $B=2^{20}=1{,}048{,}576$，于是 `num_iterations = D // B = 5568`，实际训练 $5{,}838{,}471{,}168$ token。speedrun 的 `--device-batch-size=16` 乘 $T=2048$ 再乘 8 卡得每步 262,144 token，因此 `grad_accum_steps=4`。

### 在 nanochat 中的落地

**`estimate_flops`**（`nanochat/gpt.py`，以下为 `GPT` 类的方法体）：

```text
h, q, t = self.config.n_head, self.config.n_embd // self.config.n_head, self.config.sequence_len
attn_flops = 0
for window_size in self.window_sizes:
    window = window_size[0]
    effective_seq = t if window < 0 else min(window, t)
    attn_flops += 12 * h * q * effective_seq
num_flops_per_token = 6 * self.num_matmul_params() + attn_flops
return num_flops_per_token
```

逐行说明：`h*q = n_embd`，所以注意力项也可以写成 $12CT$；`window` 取 `(left, right)` 的左分量；`window < 0` 是 FA3 的「无限上下文」约定，在当前 `_compute_window_sizes` 下 `L` 层的左窗口是 `sequence_len`（正值），该分支不会触发，属于防御性代码；`6 * num_matmul_params()` 即 $6N$。

**`num_matmul_params`**：

```text
matmul_params = sum(m.weight.numel() for m in self.modules() if isinstance(m, Linear))
```

遍历所有 `Linear` 累加。`wte` 与 `value_embeds` 是 `nn.Embedding`，不计入；`smear_gate` 是 `Linear(24,1)`，计入 24 个参数。d24 得到 729,810,648，其中 24 个来自 `smear_gate`。

**`base_train.py` 的记录与 MFU**：

```text
num_flops_per_token = model.estimate_flops()
flops_so_far = num_flops_per_token * total_batch_size * step          # 累计 FLOPs
flops_per_sec = num_flops_per_token * total_batch_size / dt           # 单步吞吐
mfu = 100 * flops_per_sec / (gpu_peak_flops * ddp_world_size)         # 百分比
```

`dt` 是单步墙钟时间（含 4 次梯度累积的前向与反向，不含评测）。`total_batch_size` 是 token 数而非样本数，这一点容易看错。

**推理侧的三个估计函数。** `estimate_decode_flops(context_len)` 用 $2N$（只有前向）加 $\sum 4hq\min(\text{ctx},W)$；`estimate_prefill_flops(num_tokens)` 对因果注意力按 $\frac{w(w+1)}{2}+(n-w)w$ 计斜坡与平台；`kv_bytes_per_token()` 与 `kv_read_bytes()` 给出每 token 的 KV 字节数与解码读取量。这些是 09 阶段 roofline 分析的输入，本篇只需知道它们与训练估算共用同一套 $2N$ 口径。

**实际运行的一个锚点。** `dev/LEADERBOARD.md` 记录的一次 d24、ratio 12 的运行报告 `total_training_flops = 4.3308e19`、`total_training_time = 10949 s`。两者相除得 $3.955\times10^{15}$ FLOP/s，除以 8 卡 bf16 峰值 $7.912\times10^{15}$ 得 MFU $=50.0\%$。这是一次真实达到 50% MFU 的运行，可作为本篇成本表的校准点。

## 关键直觉

> [!tip] $6N$ 是「参数被读了几次」的账，$12hqT$ 是「token 互相看了几次」的账
> 训练一步的计算量可以拆成两类：参数型矩阵乘法，每个参数每 token 被用一次（前向）+ 两次（反向），共 6 FLOPs；注意力内积没有参数，代价是每个 token 与 $T$ 个 token 各做两次内积（前向 $4hqT$，反向 $8hqT$）。前者随模型宽度线性增长，后者随宽度与序列长度都线性增长但总占比小。这个分解直接给出工程结论：加宽模型主要加 $6N$，加长上下文主要加 $12hqT$，而 sliding window 只压第二项。与严格定义的关系：两项都是精确的乘加计数，省略的是 softmax、归一化与查表，量级 $10^{-3}$。

## 例子与代码

### 例 1：纯标准库成本计算器

```python
import math

VOCAB, SEQ, ASPECT, HEAD_DIM = 32768, 2048, 64, 128
B_REF, RATIO_REF = 2 ** 19, 8


def dims(depth):
    n_embd = -(-depth * ASPECT // HEAD_DIM) * HEAD_DIM
    return n_embd, n_embd // HEAD_DIM


def params(depth):
    """按 gpt.py 的结构计数：QKVO 与 MLP 走 Linear，wte/value_embeds 是查表。"""
    C, H = dims(depth)
    n_ve = sum(1 for i in range(depth) if i % 2 == (depth - 1) % 2)
    blocks = depth * (12 * C * C) + n_ve * 12 * H      # 4C^2 + 8C^2，另加 ve_gate
    return {"wte": C * VOCAB, "blocks": blocks, "lm_head": C * VOCAB,
            "value_embeds": n_ve * C * VOCAB, "scalars": 2 * depth + 26,
            "matmul": blocks + C * VOCAB + 24, "C": C, "H": H}


def flops_per_token(depth):
    p = params(depth)
    short = -(-SEQ // 4 // 128) * 128
    win = [short if "SSSL"[i % 4] == "S" else SEQ for i in range(depth)]
    win[-1] = SEQ
    attn = 12 * p["C"] * sum(win)                       # h * q == n_embd
    return 6 * p["matmul"] + attn, attn


def train_cost(depth, ratio, mfu, peak, gpus=8, price=3.0):
    p = params(depth)
    tokens = ratio * (p["blocks"] + p["lm_head"])        # get_scaling_params 的口径
    d_ref = RATIO_REF * (params(12)["blocks"] + params(12)["lm_head"])
    batch = 2 ** round(math.log2(B_REF * (tokens / d_ref) ** 0.383))
    iters = tokens // batch
    total_tokens = batch * iters
    fpt, attn = flops_per_token(depth)
    flops = fpt * total_tokens
    hours = flops / (gpus * peak * mfu) / 3600
    return dict(tokens=total_tokens, batch=batch, iters=iters, fpt=fpt, attn=attn,
                flops=flops, hours=hours, usd=hours * gpus * price)


if __name__ == "__main__":
    print(f"{'config':30s}{'batch':>8s}{'tokens':>11s}{'PFLOPs':>9s}{'hours':>7s}{'USD':>6s}")
    for depth, ratio, mfu, peak in [
        (24, 8, 0.35, 989e12), (24, 8, 0.40, 989e12), (24, 8, 0.45, 989e12),
        (24, 8, 0.25, 1979e12), (32, 8, 0.25, 1979e12), (32, 20, 0.25, 1979e12),
        (24, 80, 0.25, 1979e12),
    ]:
        tag = "bf16" if peak < 1.5e15 else "fp8"
        r = train_cost(depth, ratio, mfu, peak)
        name = f"d{depth} ratio={ratio} {tag} mfu={mfu:.0%}"
        print(f"{name:30s}{r['batch']//1024:>7d}k{r['tokens']/1e9:>10.2f}B"
              f"{r['flops']/1e15:>9.0f}{r['hours']:>7.2f}{r['usd']:>6.0f}")
    r = train_cost(24, 8, 0.25, 1979e12)
    print("d24: flops/token", f"{r['fpt']:,}", "| attn part", f"{r['attn']:,}",
          "| iters", r["iters"])
```

预期输出（`price=3.0` 美元/卡·小时，即 8 卡约 24 美元/小时）：

```text
config                           batch     tokens   PFLOPs  hours   USD
d24 ratio=8 bf16 mfu=35%         1024k      5.84B    27880   2.80    67
d24 ratio=8 bf16 mfu=40%         1024k      5.84B    27880   2.45    59
d24 ratio=8 bf16 mfu=45%         1024k      5.84B    27880   2.18    52
d24 ratio=8 fp8 mfu=25%          1024k      5.84B    27880   1.96    47
d32 ratio=8 fp8 mfu=25%          2048k     13.42B   144566  10.15   243
d32 ratio=20 fp8 mfu=25%         2048k     33.55B   361414  25.36   609
d24 ratio=80 fp8 mfu=25%         2048k     58.38B   278800  19.57   470
d24: flops/token 4,775,225,616 | attn part 396,361,728 | iters 5568
```

示例中 `1979e12` 是 H100 的 FP8 峰值（约为 bf16 的两倍），用来表示 `--fp8` 路径。**当 MFU 按 bf16 峰值计量时，FP8 下的 25% 与 bf16 下的 50% 给出同样的墙钟时间**；这正是 speedrun 用 `--fp8` 后仍能报出约 50% `bf16_mfu` 的原因。

### 例 2：d24 的 $4.775\times10^{9}$ FLOPs/token 拆解

```python
C, H, D = 1536, 12, 128
attn_proj = 6 * 24 * (4 * C * C)          # 24 层，每层 4 个 (C,C) 方阵
mlp       = 6 * 24 * (8 * C * C)          # c_fc 与 c_proj 共 8C^2 个参数
lm        = 6 * C * 32768                 # lm_head
tiny      = 6 * (12 * 12 * H + 24)        # 12 个 ve_gate + smear_gate
attn_in   = 12 * H * D * (18 * 512 + 6 * 2048)   # 18 个 S 层与 6 个 L 层
total     = attn_proj + mlp + lm + tiny + attn_in
for name, v in [("attn_proj", attn_proj), ("mlp", mlp), ("lm_head", lm),
                ("attn_inner", attn_in), ("tiny", tiny)]:
    print(f"{name:>10s} {v:>14,} {100 * v / total:6.2f}%")
print(f"{'total':>10s} {total:>14,}")
print("step time @ MFU 35%:", round(1048576 / (8 * 989e12 * 0.35 / total), 3), "s")
```

预期输出：

```text
 attn_proj  1,358,954,496  28.46%
       mlp  2,717,908,992  56.92%
   lm_head    301,989,888   6.32%
attn_inner    396,361,728   8.30%
      tiny         10,512   0.00%
     total  4,775,225,616
step time @ MFU 35%: 1.808 s
```

这张表说明加宽或加密层数时增长最快的是 MLP（$8C^2$ 个参数），而注意力内积只占 8.3%。$1.808$ 秒是 $B=2^{20}$ 时的单步时间，与 5568 步相乘得 $2.80$ 小时，与例 1 的 35% MFU 行一致。

### 三个预算档位的构成

| 档位 | 8×H100 机时 | 构成 | 对应计算量 |
|---|---|---|---|
| 48 美元 | 2.0 h | 当前 speedrun：d24、ratio 8、`--fp8`，5.84B token，MFU 约 50%（bf16 口径） | $2.79\times10^{19}$ FLOPs |
| 100 美元 | 4.2 h | d24 不开 FP8、MFU 25%（3.92 h，94 美元），余量留给 SFT、RL 与评测 | $2.79\times10^{19}$ FLOPs |
| 1000 美元 | 41.7 h | d32、ratio 20（25.4 h，609 美元）或 d24、ratio 80（19.6 h，470 美元），余量留给下游阶段与重跑 | $3.6\times10^{20}$ 至 $5.4\times10^{20}$ FLOPs |

三档的差别不在单价，而在「token 预算 $\times$ 模型规模」这一个乘积。48 美元档把 d24 训到 GPT-2 水平所需的最小 token 数；100 美元档承认预训练只是流水线的一环；1000 美元档把 token 数或深度提高一个量级，同时也把下游阶段的开销纳入预算。README 的原文表述是「well below 100 dollars」，并把整个项目定位在「< 1000 美元」的预算内。

## 易错点

> [!warning] 具体、可检验的错误
> - 用总参数量代替矩阵参数量。d24 的 13.84 亿包含 6.04 亿 `value_embeds` 与 5033 万 `wte`，它们不参与矩阵乘法；用总数会让 $6N$ 偏大 90%。
> - 只算 $6N$ 不加注意力项。d24 会少算 $3.96\times10^{8}$ FLOPs/token，即总量的 8.3%；序列长度加到 8192 时这一项的比例会显著上升。
> - 把因果注意力的 $12hqT$ 当成精确值。因果掩码下真实值约为一半，公式高估了注意力项；对总误差的影响取决于注意力占比。
> - 以为 `S` 层的窗口是 768。代码表达式 `-(-2048 // 4 // 128) * 128` 的结果是 512，注释里的 768 与计算不符，以代码为准。
> - 把 `total_batch_size` 当成样本数。它是 token 数；`tokens_per_fwdbwd = device_batch_size * max_seq_len` 才是每 rank 每 micro-batch 的 token 数。
> - 用 bf16 峰值算 FP8 训练的时间。FP8 峰值约为 bf16 的两倍，用 bf16 峰值会得到约两倍的小时数（或把 MFU 算成一半）。
> - 跨仓库比较 MFU 而不核对峰值口径。`get_peak_flops` 的 H100 取值 989 TFLOPs 是 bf16 稠密峰值（含稀疏为 1979 TFLOPs）；若对方用稀疏口径，同一实现的 MFU 会看起来只有一半。
> - 认为 $6N$ 适用于 MoE。`num_matmul_params` 会把未激活的专家权重也算进去。

## 关联笔记

- 前置：[[矩阵与线性代数速查]]——$2mn$、$O(mnk)$ 与 d24 的矩阵形状表，是本篇两项公式的来源。
- 前置：[[梯度下降与AdamW]]——批大小缩放与 `weight_decay_scaled` 的推导，与本篇的 `batch_lr_scale` 共用同一套缩放框架。
- 后续：05 阶段的缩放律笔记会用本篇的估算解释 `--depth` 如何决定 token 数与成本。
- 对照：[[模型推理优化]]（跨库）——推理侧是访存受限，训练侧是计算受限，两者的 roofline 不同。
- 对照：[[分布式训练与部署]]（跨库）——多卡效率、通信占比与 MFU 的关系，本篇只给公式。

## 达标检测

- [ ] 从「每个乘加 2 FLOPs」推出前向 $2N$、反向 $4N$，并列出省略了哪些项、量级多大。
- [ ] 手推 $12hqT$，说明因子 12 中前向与反向各占多少，并解释因果掩码带来的偏差方向。
- [ ] 给定 $T=4096$、`window_pattern="SSL"`，写出每层的有效长度并算出注意力项。
- [ ] 用 $6N$ 与注意力项算出 d24 的 FLOPs/token，与 `estimate_flops` 的 4,775,225,616 对照。
- [ ] 从总 FLOPs、8 卡峰值与 MFU 算出小时数与美元，并说明 48 美元档对应的 MFU。
- [ ] 解释为什么 `S` 层窗口是 512 而不是注释里的 768，并说明这对估算的影响。
- [ ] 说明 $6N$ 在 MoE 下失效的两个原因（激活稀疏、`num_matmul_params` 的统计口径）。
- [ ] 说明用 FP8 训练时 `train/mfu` 与真实硬件利用率的关系。

## 参考来源

- Chowdhery et al., *PaLM: Scaling Language Modeling with Pathways*（2204.02311）—— 对应 $6N+12hqT$ 的估算方式；`estimate_flops` 的注释直接引用该编号。
- Hoffmann et al., *Training Compute-Optimal Large Language Models*（Chinchilla, 2203.15556）—— 对应 $6N$ 的精确形式与 nanochat 估算的差异来源。
- Kaplan et al., *Scaling Laws for Neural Language Models*（2001.08361）—— 对应参数量、数据量与计算量之间的幂律关系。
- Hägele et al., *Power Lines: Scaling Laws for the Optimal Batch Size*（2505.13738）—— 对应 $B\propto D^{0.383}$ 的自动批大小规则。
- Karpathy, *nanochat* `nanochat/gpt.py`、`nanochat/common.py`、`scripts/base_train.py`（commit 92d63d4）—— 对应 `estimate_flops`、`num_matmul_params`、`get_peak_flops` 与 MFU 计算。
- Karpathy, *nanochat* README 与 `dev/LEADERBOARD.md`—— 对应 43,000 美元的历史成本、约 24 美元/小时与约 48 美元的当前报价、以及 4.3308e19 FLOPs / 10949 s 的实测记录。
