w wyl123ly 的博客
MD

FLOPs与训练成本估算

23 KB 2026.10.22 原文件

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, 个头共 。

前向合计 ,反向是前向的两倍,故

三个近似需要注意:

  1. 忽略因果掩码。 因果注意力下第 个位置只与 个位置做内积,平均是 ,精确值约为 。nanochat 沿用 ,对总计算量是高估,但注意力项只占 (见下),高估带来的总误差约 。
  2. 。 因为 ,有 ,注意力项可以只用宽度与序列长度表示。
  3. 不适用于 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 SXM989e12A100312e12
H100 NVL835e12L40S362e12
H100 PCIe756e12RTX 4090165.2e12
H200989e12B2002.25e15
H800 SXM756e12MI300X1.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 hd24 不开 FP8、MFU 25%(3.92 h,94 美元),余量留给 SFT、RL 与评测 FLOPs
1000 美元41.7 hd32、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 的实测记录。