FLOPs与训练成本估算
定义
FLOPs(floating point operations)是浮点运算次数,用作计算量的单位;FLOP/s 是算力单位。一次「乘加」记为 2 FLOPs(一次乘法、一次加法),这是深度学习中的通行约定。
训练一个稠密 Transformer 的每 token 计算量近似为
其中 是参与矩阵乘法的参数量, 是注意力头数, 是头维, 是第 层的有效注意力长度。这是 nanochat 的 GPT.estimate_flops 实现,也是 PaLM 论文(2204.02311)使用的估算方式。
符号与术语:
- :矩阵参数(matmul parameters)个数,即所有与 token 流做矩阵乘法的权重元素数;嵌入表不算,因为它是查表。
- :层数
n_layer;:n_head;:n_embd // n_head;:sequence_len。 - MFU(model FLOPs utilization):实际吞吐与硬件峰值的比值,。
- 峰值算力:
get_peak_flops返回的每卡 bf16 峰值,单位为 FLOP/s。 - :全局批大小(token);:训练总 token 数;:模型宽度
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 数( 缩放参数量)与批大小(Power Lines 的 规则)。没有 FLOPs 估算,就无法判断深度翻倍意味着多少 token、多少小时、多少成本。- 训练日志里的
train/mfu是判断「模型是否被数据或通信卡住」的第一指标:MFU 突然下降通常意味着输入形状变了、FA3 退化到 SDPA、或通信占比升高。 - 估算的精度的量级: 与 两项覆盖了绝大部分计算,误差在个位数百分比;相比之下,误把总参数量当 、或把查表算成矩阵乘法,会带来数倍的偏差。
- 在全书中的位置:前置是 矩阵与线性代数速查 的 与 、梯度下降与AdamW 的批大小缩放;后续是 05 阶段的缩放律与 09 阶段的推理成本。通用推理侧优化见 模型推理优化(跨库)。
原理与推导
1. 每个乘加 2 FLOPs
矩阵乘法 ,、,需要 次乘加,故
按 FLOP/s 而非「乘加/s」计价的原因:硬件规格与论文都以 FLOP/s 报告峰值,乘加数乘 2 才能与峰值对齐。约定本身不影响结论,但混用会让估算差一倍。
对单个 token(),一个 的权重消耗 FLOPs 前向。这就是 与计算量之间的桥:每个矩阵参数每个 token 恰好贡献 2 FLOPs 的前向计算。
2. 前向 2N,反向 4N
前向:每个矩阵参数被一次乘加使用一次,所以每 token 前向为
反向:设某层 ,、。反向需要两个梯度:
两个都是形状相同的矩阵乘法,各消耗 FLOPs/token。因此反向是前向的两倍:
合计 ,即 规则。
适用条件必须说清楚:稠密模型、每个参数都参与矩阵乘法、忽略 softmax 的指数与除法、忽略归一化与逐元素运算、忽略嵌入查表。Chinchilla 的公式把这些小项也算进去,差异约 1%(estimate_flops 的注释列出了两条:Chinchilla 计入嵌入层与 softmax 的超越函数,nanochat 不计)。这些项合计约为 的 1%,省略不影响成本判断。
若把 中的 误换成总参数量(含 wte、value_embeds),d24 会从 729,810,648 变成 1,384,122,122, 从 变成 ,结果偏大 90%。这是最容易犯的错。
3. 注意力项
只覆盖了「参数型」矩阵乘法,注意力的内积没有参数,必须单独加。对第 层、单个 token:
- 计算 :每个头与 个位置做内积,每个内积 次乘加,即 FLOPs; 个头共 。
- 计算加权求和 :每头 FLOPs, 个头共 。
前向合计 ,反向是前向的两倍,故
三个近似需要注意:
- 忽略因果掩码。 因果注意力下第 个位置只与 个位置做内积,平均是 ,精确值约为 。nanochat 沿用 ,对总计算量是高估,但注意力项只占 (见下),高估带来的总误差约 。
- 。 因为 ,有 ,注意力项可以只用宽度与序列长度表示。
- 不适用于 MoE。 见第 5 节。
4. sliding window 修正
nanochat 的 window_pattern="SSSL" 在层间平铺:S 是短窗口,L 是全上下文,最后一层强制为 L。窗口大小在 _compute_window_sizes 中计算:
long_window = config.sequence_len
short_window = -(-long_window // 4 // 128) * 128 # 向上取整到 128 的倍数
时 long_window = 2048,short_window = ceil(2048/4/128)*128 = 512。注意该行注释写作「2048 -> 768」,而表达式实算为 512( 已是 128 的倍数)。本篇以代码计算值为准。
estimate_flops 对每层取 effective_seq = min(window, t),再累加:
d24 的 24 层按 SSSL 平铺,得到 18 个 S 层()与 6 个 L 层(),最后一层落在 L 上不改变计数:
若 24 层全是全上下文,该项会是 ,即 sliding window 把注意力项压到 43.8%。这也解释了 window_pattern 在 05 阶段的吞吐讨论中为什么重要。
5. MoE 不适用
num_matmul_params 的统计口径是「所有 Linear 模块的权重元素之和」。若把 MLP 换成专家混合(MoE),每个 token 只经过 top- 个专家,但该函数仍会把全部专家算进去, 因此严重高估。同样,dev/LOG.md 记录过 3D 专家权重((num_experts, hidden, dim))与 Muon 的兼容性实验,说明未来可能引入 MoE;到那时 estimate_flops 必须改成按激活专家计数。当前 master 的 gpt.py 是稠密模型,不存在这个问题。
6. MFU 与成本
单卡峰值记为 (FLOP/s), 张卡的实测吞吐为 ,则
训练总 FLOPs (含注意力项时按本篇公式),则
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 的三步:
第二步的 是 --target-param-data-ratio,speedrun 取 8;第三步来自 Power Lines(2505.13738),即最优批大小随训练 token 数按 增长, 是 d12 的实测最优批大小, 是 d12 在相同 下的 token 数。d24 的具体取值:
,,,取最近的 2 的幂得 ,于是 num_iterations = D // B = 5568,实际训练 token。speedrun 的 --device-batch-size=16 乘 再乘 8 卡得每步 262,144 token,因此 grad_accum_steps=4。
在 nanochat 中的落地
estimate_flops(nanochat/gpt.py,以下为 GPT 类的方法体):
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
逐行说明:hq = n_embd,所以注意力项也可以写成 ;window 取 (left, right) 的左分量;window < 0 是 FA3 的「无限上下文」约定,在当前 _compute_window_sizes 下 L 层的左窗口是 sequence_len(正值),该分支不会触发,属于防御性代码;6 num_matmul_params() 即 。
num_matmul_params:
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:
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) 用 (只有前向)加 ;estimate_prefill_flops(num_tokens) 对因果注意力按 计斜坡与平台;kv_bytes_per_token() 与 kv_read_bytes() 给出每 token 的 KV 字节数与解码读取量。这些是 09 阶段 roofline 分析的输入,本篇只需知道它们与训练估算共用同一套 口径。
实际运行的一个锚点。 dev/LEADERBOARD.md 记录的一次 d24、ratio 12 的运行报告 total_training_flops = 4.3308e19、total_training_time = 10949 s。两者相除得 FLOP/s,除以 8 卡 bf16 峰值 得 MFU 。这是一次真实达到 50% MFU 的运行,可作为本篇成本表的校准点。
关键直觉
是「参数被读了几次」的账, 是「token 互相看了几次」的账
训练一步的计算量可以拆成两类:参数型矩阵乘法,每个参数每 token 被用一次(前向)+ 两次(反向),共 6 FLOPs;注意力内积没有参数,代价是每个 token 与 个 token 各做两次内积(前向 ,反向 )。前者随模型宽度线性增长,后者随宽度与序列长度都线性增长但总占比小。这个分解直接给出工程结论:加宽模型主要加 ,加长上下文主要加 ,而 sliding window 只压第二项。与严格定义的关系:两项都是精确的乘加计数,省略的是 softmax、归一化与查表,量级 。
例子与代码
例 1:纯标准库成本计算器
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 美元/小时):
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 的 FLOPs/token 拆解
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")
预期输出:
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( 个参数),而注意力内积只占 8.3%。 秒是 时的单步时间,与 5568 步相乘得 小时,与例 1 的 35% MFU 行一致。
三个预算档位的构成
| 档位 | 8×H100 机时 | 构成 | 对应计算量 |
|---|---|---|---|
| 48 美元 | 2.0 h | 当前 speedrun:d24、ratio 8、--fp8,5.84B token,MFU 约 50%(bf16 口径) | FLOPs |
| 100 美元 | 4.2 h | d24 不开 FP8、MFU 25%(3.92 h,94 美元),余量留给 SFT、RL 与评测 | FLOPs |
| 1000 美元 | 41.7 h | d32、ratio 20(25.4 h,609 美元)或 d24、ratio 80(19.6 h,470 美元),余量留给下游阶段与重跑 | 至 FLOPs |
三档的差别不在单价,而在「token 预算 模型规模」这一个乘积。48 美元档把 d24 训到 GPT-2 水平所需的最小 token 数;100 美元档承认预训练只是流水线的一环;1000 美元档把 token 数或深度提高一个量级,同时也把下游阶段的开销纳入预算。README 的原文表述是「well below 100 dollars」,并把整个项目定位在「< 1000 美元」的预算内。
易错点
具体、可检验的错误
- 用总参数量代替矩阵参数量。d24 的 13.84 亿包含 6.04 亿
value_embeds与 5033 万wte,它们不参与矩阵乘法;用总数会让 偏大 90%。- 只算 不加注意力项。d24 会少算 FLOPs/token,即总量的 8.3%;序列长度加到 8192 时这一项的比例会显著上升。
- 把因果注意力的 当成精确值。因果掩码下真实值约为一半,公式高估了注意力项;对总误差的影响取决于注意力占比。
- 以为
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 会看起来只有一半。- 认为 适用于 MoE。
num_matmul_params会把未激活的专家权重也算进去。
关联笔记
- 前置:矩阵与线性代数速查——、 与 d24 的矩阵形状表,是本篇两项公式的来源。
- 前置:梯度下降与AdamW——批大小缩放与
weight_decay_scaled的推导,与本篇的batch_lr_scale共用同一套缩放框架。 - 后续:05 阶段的缩放律笔记会用本篇的估算解释
--depth如何决定 token 数与成本。 - 对照:模型推理优化(跨库)——推理侧是访存受限,训练侧是计算受限,两者的 roofline 不同。
- 对照:分布式训练与部署(跨库)——多卡效率、通信占比与 MFU 的关系,本篇只给公式。
达标检测
- [ ] 从「每个乘加 2 FLOPs」推出前向 、反向 ,并列出省略了哪些项、量级多大。
- [ ] 手推 ,说明因子 12 中前向与反向各占多少,并解释因果掩码带来的偏差方向。
- [ ] 给定 、
window_pattern="SSL",写出每层的有效长度并算出注意力项。 - [ ] 用 与注意力项算出 d24 的 FLOPs/token,与
estimate_flops的 4,775,225,616 对照。 - [ ] 从总 FLOPs、8 卡峰值与 MFU 算出小时数与美元,并说明 48 美元档对应的 MFU。
- [ ] 解释为什么
S层窗口是 512 而不是注释里的 768,并说明这对估算的影响。 - [ ] 说明 在 MoE 下失效的两个原因(激活稀疏、
num_matmul_params的统计口径)。 - [ ] 说明用 FP8 训练时
train/mfu与真实硬件利用率的关系。
参考来源
- Chowdhery et al., PaLM: Scaling Language Modeling with Pathways(2204.02311)—— 对应 的估算方式;
estimate_flops的注释直接引用该编号。 - Hoffmann et al., Training Compute-Optimal Large Language Models(Chinchilla, 2203.15556)—— 对应 的精确形式与 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)—— 对应 的自动批大小规则。
- 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 的实测记录。