---
tags: [nanochat, pretraining, gpt2]
阶段: 05-预训练Pretraining
难度: ★★☆
created: 2026-10-22
related: "[[CORE指标]], [[训练脚本与speedrun]], [[用--depth调参]], [[成本-延迟-质量权衡]]"
---

# 对比GPT-2核心指标

## 定义

**time-to-GPT-2**（time to GPT-2，到 GPT-2 的时间）是 nanochat 的主目标函数：在单个 8×H100 节点上，把模型训练到 CORE 分数超过 GPT-2 的 0.256525 所需的墙钟训练时间。

符号与术语定义如下。

- **GPT-2（1.6B）**：OpenAI 2019 年发布的 1.6B 参数模型，训练用 32 块 TPU v3、168 小时（7 天），当时 TPU v3 价格约 8 美元/小时/片，总成本约 43,000 美元（README 与 `dev/LEADERBOARD.md` 均记为约 \$43K）。
- **0.256525**：GPT-2 在 DCLM 的 CORE 协议下的分数，是 nanochat 的验收阈值。它是 DCLM 复现值，不是 OpenAI 在 2019 年报告的数字——CORE 指标 2024 年才提出。
- **time**：leaderboard 表中的时间，单位小时，取自 wandb 的 `total_training_time`（秒）。它只统计训练迭代本身，不含评测、采样与日志开销。
- **val_bpb**：同一次运行在验证集上的 bits per byte，作为辅助信号记录。
- **CORE**：模型中最后一步在 22 个 ICL 任务上的中心化准确率均值，定义见 [[CORE指标]]。
- **commit**：产生该次运行的 Git 提交短哈希，用于把成绩与代码状态绑定。
- **预算档**：以美元计的节点租用总额度；在固定单价下等价于可购买的小时数。

## 为什么重要

它把「模型能力」这个模糊目标压缩成一个可购买的量：能力阈值固定为 CORE 0.256525，于是优化目标退化为最小化训练时间，而训练时间乘以节点单价就是成本。没有这个换算，2019 年的 43,000 美元与 2026 年的几十美元无法放在同一张表上比较。

它是工程决策的判据。任何一个改动——换数据集、开 FP8、增大批、改架构——都要回答同一个问题：达到同一 CORE 阈值所需的时间是变短还是变长。leaderboard 的六次记录正是六次这样的判断，每次时间下降都对应一个可指认的机制变化。

它同时约束了「刷分」的边界。目标是一个阈值而非连续分数，因此存在「刚好压线」的过拟合风险：把 `--target-param-data-ratio` 从 12 降到 8，就是把 d24 从充分训练改为欠训练，用更少 token 压过阈值。为防止这种做法损害通用性，仓库要求改动必须在不同深度上都成立（miniseries），并且在报告 CORE 的同时报告 val bpb。

在三个维度中，本篇主要属于「懂工程」：它不讲新的模型机制，而是讲如何用公开数字判断一次训练是否值得。

## 原理与推导

### 1. 2019 年的成本如何得到

GPT-2 的训练配置在 `dev/LEADERBOARD.md` 中有明确记载：32 块 TPU v3、168 小时、8 美元/片/小时。相乘即得总成本：

$$
32\times 168\times 8=43{,}008\ \text{美元}.
$$

这个数字的含义是「当时的算力租赁价格下的训练开销」，不含数据、人力与推理。它作为参照点的价值在于：同样的能力在 2026 年可以用约 1.65 小时的 8×H100 达到，单价约 24 美元/小时，即约 40 美元，相差三个数量级。

### 2. 2026 年的成本如何得到

当前 speedrun 的配置写在 `runs/speedrun.sh` 中：`--depth=24 --target-param-data-ratio=8 --device-batch-size=16 --fp8`，8 卡。README 给出的换算基准是「当前约 3 美元/GPU/小时，8×H100 节点约 24 美元/小时」，于是：

| 口径 | 时间 | 单价 | 成本 |
|---|---|---|---|
| 2019 GPT-2 | 168 h | 32×8 美元/h | 约 43,000 美元 |
| 当前 speedrun（on-demand） | 1.65 h | 24 美元/h | 约 39.6 美元 |
| README 引用值（约 2 h） | 2 h | 24 美元/h | 约 48 美元 |
| spot 实例 | 未给出 | 未给出 | README 记为约 15 美元 |

最后一行不是精确算式：README 只说 spot 上总成本「closer to ~\$15」，未给出单价，因此只能引用结论，不能反推单价。

### 3. leaderboard 的读法

README 的主表有七行，第一行是 GPT-2 参照，其余六行是 nanochat 的六次记录。

| # | time (h) | val_bpb | CORE | 机制变化 | 日期 | commit |
|---|---|---|---|---|---|---|
| 0 | 168 | — | 0.2565 | OpenAI GPT-2 | 2019 | — |
| 1 | 3.04 | 0.74833 | 0.2585 | d24 基线，略微过训练 | 2026-01-29 | `348fbb3` |
| 2 | 2.91 | 0.74504 | 0.2578 | d26 略欠训练 + FP8 | 2026-02-02 | `a67eba3` |
| 3 | 2.76 | 0.74645 | 0.2602 | 总批从 0.5M 提到 1M | 2026-02-05 | `2c062aa` |
| 4 | 2.02 | 0.71854 | 0.2571 | 数据换为 NVIDIA ClimbMix | 2026-03-04 | `324e69c` |
| 5 | 1.80 | 0.71808 | 0.2690 | autoresearch 第一轮 | 2026-03-09 | `6ed7d1d` |
| 6 | 1.65 | 0.71800 | 0.2626 | autoresearch 第二轮 | 2026-03-14 | `a825e63` |

四列各有陷阱。`time` 不是墙钟：Run 1 的 `total_training_time` 为 10949 秒，折 3.04 小时，而端到端脚本还要跑分词器训练、下载数据、评测与采样。`val_bpb` 在 Run 4 之后不可与前三次比较，因为数据集从 FineWeb-EDU 换成了 ClimbMix，验证集分布随之改变；表内 Run 4 到 Run 6 的 0.71854、0.71808、0.71800 才是同一分布下的可比序列。`CORE` 单次值有约 0.005 的标准差，Run 4 的 0.2571 是 7 次运行的均值。`commit` 决定复现的代码状态，成绩必须与提交绑定才有意义。

### 4. 为什么跨模型比较用 CORE 而不是验证损失

验证损失与 bpb 都是「在当前数据分布上的平均预测质量」。一旦数据分布改变，数值整体平移：ClimbMix 与 FineWeb-EDU 的验证集不同，0.71854 与 0.74645 之间的差不能解释为模型能力提升。词表改变也会改变每个 token 覆盖的字节数，虽然 bpb 已按字节归一化，但分词边界变化仍会影响数值。

CORE 把评测对象固定为 22 个任务、固定提示模板、固定打分规则，因此可以在换数据、换架构、换深度之间比较。代价是方差：`dev/LOG.md` 记录同一配置（d24、ratio 9.5、ClimbMix）七次独立运行的 CORE 为 0.25373、0.2584、0.25489、0.2568、0.25732、0.26765、0.25119，均值 0.25714，样本标准差约 0.00523，标准误约 0.00198，极差 0.01646。阈值 0.256525 与该均值只差 0.0006，远小于标准误，因此单次运行压线不足以证明「超过 GPT-2」。

正确的做法是两条并用：CORE 作为验收约束，bpb 作为同分布内的平滑信号。Run 5 的决策正是这样做的：CORE 均值 0.2690 已大幅超过阈值，但仍把 ratio 保持在 8.7 而没有继续缩短训练，因为它的 val loss 0.71808 需要低于 Run 4 的 0.71854。

### 5. 三档预算对应的模型与能力

预算只能换算成「节点小时数」，再乘以吞吐换算成 token 数。README 的三个数字构成三档：

| 预算 | 可购买的 8×H100 时间 | 对应产物 | 能力 |
|---|---|---|---|
| 约 15 美元（spot） | 未给出（README 只给总价） | 完整 speedrun：分词器 + d24 预训练 + SFT + 评测 | base CORE 约 0.2626，chat 模型可对话（README 第 6 行与 speedrun 流程） |
| 约 48 美元 | 2 h | 同上，含少量余量 | 同上 |
| 100 美元 | 约 4.2 h（推算：100/24） | speedrun 全流程 + 若干次评测或一次 d26 短扫 | 未在仓库中给出确切配置与分数，只能标注为推算 |
| 1000 美元 | 约 41.7 h（推算：1000/24） | 整个 miniseries 扫描（d12–d26）与调参实验 | README 把「低于 1000 美元预算内可端到端工作」列为项目目标 |

第三、四行属于推算：仓库只给出单价与目标，没有给出「100 美元买到哪个深度的成绩」。任何更具体的说法都需要实测，不应凭 README 的宣传语推断。

### 6. 把 CORE 差距换算成训练时间与成本

设当前 CORE 为 $c_0$、阈值为 $c^{*}$，差距 $\Delta c=c^\*-c_0$。要把差距换算成时间，需要一个「CORE 对模型规模或 token 数的局部斜率」。

可用的一对实测点是同一数据管线下的 d18 与 d26（`dev/LOG.md` 2026-02-17 的基线）：d18 的 CORE 为 0.199，d26 为 0.2602。两者缩放参数分别为 324.4M 与 918.4M，于是

$$
\frac{\mathrm{d}\,\mathrm{CORE}}{\mathrm{d}\log_{10}N}
=\frac{0.2602-0.199}{\log_{10}(918.4/324.4)}
=\frac{0.0612}{0.4519}\approx 0.1354.
$$

再假设 token 数与参数数同比例变化（固定 `--target-param-data-ratio`），则

$$
\log_{10}\frac{D'}{D}=\frac{\Delta c}{0.1354}.
$$

取 $\Delta c=0.0045$（例如实测 0.2520、阈值 0.256525），得 $\log_{10}(D'/D)=0.0332$，即 token 增加 7.95%。以 d24、ratio 8 的 5.838B token 为基数，需增加约 0.464B token；按 `GPT.estimate_flops()` 的 4.7752e9 FLOP/token，约 $2.22\times10^{18}$ FLOPs；按 Run 1 实测的有效吞吐 $3.96\times10^{15}$ FLOP/s，约 560 秒，即 0.156 小时，按 24 美元/小时约 3.7 美元。

作为交叉校验，另一个更简单的问题「多加一个 ratio 要多少钱」：d24 每单位 ratio 增加 729.8M token，即 $3.49\times10^{18}$ FLOPs，约 880 秒、0.245 小时、约 5.9 美元。

这两个数都是估算，前提是斜率可从两个单点外推、且 CORE 随 token 单调。实际方差（标准误约 0.002）与两个单点的来源差异使结果只具量级意义。

### 7. 版本说明

仓库内有三处叙述不一致，写作与实验时必须区分。

第一处是「GPT-2 对应哪个深度」。README 第 6 行写「GPT-2 capability happens to be approximately depth 26」，而当前 `runs/speedrun.sh` 用 `--depth=24`。前者是较早的结论，后者是 ClimbMix 之后「更小的模型达到同等能力」的结果（`dev/LOG.md` 2026-03-04 记录 d26 改为 d24，速度从 2 小时 46 分降到 2 小时 1 分）。

第二处是「$100 与 d20」。README 的目录说明里仍留有一行 `runs/speedrun.sh # Train the ~$100 nanochat d20`，这是历史注释；当前 speedrun 是 d24，成本约 48 美元，d20 已不是 speedrun 的配置。

第三处是参数量口径。d24 的总参数为 1,384,122,122（含 `wte`、value embeddings、`lm_head`），缩放参数（`transformer_matrices + lm_head`）为 729,810,624。README 说 GPT-2 为 1.6B，改用总参数口径比较才成立；讨论训练时长与数据量时必须用缩放参数口径，两者不可混用。

### 8. 噪声与决策规则

CORE 的单次值不足以支撑「超过阈值」的结论，需要给出重复运行的统计量。Run 4 的七次独立运行是仓库中唯一公开的重复实验，其数值为

| 次序 | CORE | 与均值之差 |
|---|---|---|
| 1 | 0.25373 | $-0.00341$ |
| 2 | 0.25840 | $+0.00126$ |
| 3 | 0.25489 | $-0.00225$ |
| 4 | 0.25680 | $-0.00034$ |
| 5 | 0.25732 | $+0.00018$ |
| 6 | 0.26765 | $+0.01051$ |
| 7 | 0.25119 | $-0.00595$ |
| 均值 | 0.25714 | 标准差 0.00523 |

由此可推出三条决策规则。

第一，$k$ 次运行均值的标准误为 $0.00523/\sqrt{k}$。取 $k=5$，标准误约 0.00234，95% 置信半宽约 0.0046；取 $k=7$，半宽约 0.0039。因此 5 次运行只能分辨约 0.005 量级的能力差异。

第二，若要用单次或少数几次运行证明「超过 0.256525」，需要阈值的余量大于置信半宽。Run 4 的 7 次均值 0.25714 与阈值只差 0.0006，要以 95% 置信度排除「实际未超过」，所需运行次数约为 $(1.96\times0.00523/0.0006)^2\approx290$，不现实。这正是 `dev/LEADERBOARD.md` 要求同时报告 val bpb 的原因：bpb 的方差小得多，可以作为同向证据。

第三，比较两次改动时应比较均值而不是最好一次。Run 4 的最大值 0.26765 与 Run 5 的均值 0.2690 只差 0.0014，但前者是七次中的最大值、后者是五次均值，两者不可直接比较。

### 9. 一次实验的记录模板

要让结果能进入 leaderboard 式的比较，记录必须包含「配置、时间、两项指标、代码状态、成本」五组信息。

| 字段 | 示例 | 来源 |
|---|---|---|
| 日期 | 2026-03-14 | 运行当天 |
| commit | `a825e63` | `git log -1 --format="%h"` |
| 深度 / 数据参数比 | d24 / 8 | 命令行 |
| 单卡批 / 精度 | 16 / bf16 或 fp8 | 命令行 |
| 训练时间 | 1.65 h（5940 s） | `total_training_time` |
| val bpb | 0.71800 | `Minimum validation bpb` |
| CORE | 0.2626（5 次均值 0.262634） | `core_metric` |
| 运行次数 | 5 | 实验记录 |
| 成本 | 约 39.6 美元 | 时间 × 单价 |

缺任何一列都会导致结果不可复核：没有 commit 无法确定代码状态，没有运行次数无法判断 CORE 的可信度，没有 bpb 无法排除「只对 CORE 有效」的改动。

### 10. 阈值为什么是 0.256525

这个数不是设计出来的分界线，而是 GPT-2 在 DCLM 的 CORE 协议下测得的分数，作为「GPT-2 级能力」的操作化定义。它有四个后果。

第一，它继承 DCLM 评测协议的所有约定：22 个任务、固定的 few-shot 数、固定的续写分隔符、固定的随机基线。协议若变，阈值也要重测。

第二，它没有能力上的特殊性。0.256525 与 0.255 或 0.258 在能力上连续，只是历史上选定的参照点；因此「刚好超过」与「刚好没超过」不应被解释为质的差别。

第三，它把目标二值化，便于排序但不便于优化。实际优化时仍需连续信号（bpb 或多次运行的 CORE 均值），阈值只用于最终验收。

第四，它依赖 GPT-2 权重的可复现评测。`dev/LEADERBOARD.md` 注明 `base_eval.py` 曾支持 `--hf-path openai-community/gpt2-xl`，后为简化而移除（提交 `21a7774` 或更早）；若要自行复核该数值，需要回到那个提交。

### 在 nanochat 中的落地

第一处是 `runs/speedrun.sh`。它固定写死 `--depth=24 --target-param-data-ratio=8 --device-batch-size=16 --fp8`，这个组合就是 leaderboard 最后一行的复现入口；注释明确写出「从 compute optimal 的 10.5 降到 8，使 d24 略微欠训练」。

第二处是 `dev/LEADERBOARD.md` 的提交规范：跑完后取 `wandb` 的 `total_training_time` 作为成绩，取 `core_metric` 与 `Minimum validation bpb` 作为证据，再取 `git log -1 --format="%h"` 作为 commit 列。三个数字分别对应表的三列，缺一列就无法复核。

第三处是 `scripts/base_train.py` 的日志：训练结束时打印 `Total training time`、`Minimum validation bpb`，并在最后一步触发一次 CORE 评测（`--core-metric-every` 设为 999999 可保证只在最后评测）。这些输出正是填表所需。

## 关键直觉

> [!tip] 阈值固定时，优化「到阈值的时间」等价于在能力约束下最小化可购买的资源
> 目标函数可以写成 $\min T$ 使得 $\mathrm{CORE}(T)>0.256525$。这一定义把模型能力问题转成资源分配问题：深度决定单步成本，数据参数比决定步数，精度决定吞吐，三者共同决定 $T$。与严格定义的关系：直觉中的「可购买资源」就是定义里的 time 乘以节点单价；它解释了为什么 leaderboard 用时间而不是 CORE 做排序量——CORE 是约束，时间是目标。

## 例子与代码

### 1. 从一次运行提取填表所需的三项

```bash
# 训练结束后（或从 wandb 摘要中）取三项证据
git log -1 --format="%h"
# 例如：a825e63

# 训练日志末尾会打印（scripts/base_train.py）
# Total training time: 99.00m
# Minimum validation bpb: 0.718000
# Step 05568 | CORE metric: 0.2626
```

若用 wandb，对应字段是 `total_training_time`（秒）、`core_metric`、`val/bpb`。把秒换算成小时：$5940/3600=1.65$。

### 2. 把时间换算成成本与 token

```python
# 独立运行：给定 leaderboard 数据，计算每次记录的成本与每美元 token 数
rows = [  # (time_h, core, tokens_B)；token 数 = 该次运行的 param:data ratio × 该深度的缩放参数
    (3.04, 0.2585, 8.758),   # d24, ratio 12
    (2.91, 0.2578, 7.807),   # d26, ratio 8.5
    (2.76, 0.2602, 7.577),   # d26, ratio 8.25
    (2.02, 0.2571, 6.933),   # d24, ratio 9.5
    (1.80, 0.2690, 6.349),   # d24, ratio 8.7
    (1.65, 0.2626, 5.838),   # d24, ratio 8
]
PRICE_PER_HOUR = 24.0       # 8xH100 节点，README 给出的换算基准
for t, core, tokens_B in rows:
    cost = t * PRICE_PER_HOUR
    print(f"time {t:4.2f} h | cost ${cost:6.2f} | CORE {core:.4f} | {tokens_B / t:5.3f} B tok/h")
# 预期：time 1.65 h | cost $ 39.60 | CORE 0.2626 | 3.538 B tok/h
```

token 数由各次运行的 `--target-param-data-ratio` 乘以该深度的缩放参数得到（d24 为 729,810,624，d26 为 918,423,532），因此是推导值而非仓库逐次记录的原值；Run 1 的 8.758B 还可用 16704 步 × 524288 token 交叉验证。

### 3. CORE 差距换算的完整算例

```python
# 独立运行：把 CORE 差距换算成 token 增量与成本
LOG10_SLOPE = (0.2602 - 0.199) / __import__("math").log10(918.4 / 324.4)  # CORE 每十倍参数
gap = 0.0045                   # 实测 0.2520 与阈值 0.256525 之差
d_log10 = gap / LOG10_SLOPE
token_ratio = 10 ** d_log10
D = 5.838e9                     # d24 ratio 8 的训练 token 数
flops_per_token = 4.7752e9      # GPT.estimate_flops()，d24 当前架构
effective_flops = 3.96e15       # Run 1 实测：4.3308e19 FLOPs / 10949 s
extra_tokens = D * (token_ratio - 1)
extra_flops = extra_tokens * flops_per_token
hours = extra_flops / effective_flops / 3600
print(f"slope={LOG10_SLOPE:.4f} token_ratio={token_ratio:.4f}")
print(f"extra tokens={extra_tokens/1e9:.3f} B, time={hours:.3f} h, cost=${hours*24:.2f}")
# 预期：slope=0.1354 token_ratio=1.0795
# 预期：extra tokens=0.464 B, time=0.156 h, cost=$3.74
```

算例的敏感度：若有效吞吐不是 $3.96\times10^{15}$ FLOP/s（例如硬件不同或 MFU 不同），成本按比例缩放；若把斜率换成 0.09 或 0.18，token 增量分别在 0.71B 与 0.35B 附近。这说明该换算只适合做量级判断。

## 易错点

> [!warning] 六个可检验的错误
> 1. 把 leaderboard 的 time 当作端到端墙钟。它只含训练迭代，不含数据下载、分词器训练、评测与采样；端到端时间明显更长。
> 2. 跨数据集比较 val_bpb。Run 4 换成 ClimbMix 后 bpb 从 0.746 降到 0.718，这是分布变化而不是能力跃升，`dev/LEADERBOARD.md` 对此有明确说明。
> 3. 用 GPT-2 的 1.6B 与 d24 的 729.8M 缩放参数直接比较规模。d24 的总参数是 1.38B；两个口径分别适用于「与 GPT-2 比参数量」和「算训练 token 数」。
> 4. 把 0.256525 当作单次运行的硬门槛。单次 CORE 的标准差约 0.005，压线结果不可靠，应重复运行并同时报告 bpb。
> 5. 认为时间越短一定越好。目标是一个阈值，降到刚好压线会牺牲泛化；仓库用 miniseries（d12–d26 都要成立）与 bpb 双重约束防止这一点。
> 6. 用旧提交的 FLOPs 估算当前配置。Run 1 报告的 $4.33\times10^{19}$ 对应当时的架构与批大小，按当前 `estimate_flops()` 的 4.7752e9 FLOP/token 计算同样 token 数会得到 $4.18\times10^{19}$。

## 关联笔记

- 前置 [[CORE指标]]：0.256525 是如何在同一协议下算出来的。
- 前置 [[训练脚本与speedrun]]：speedrun 的参数组合与产物。
- 后续 [[用--depth调参]]：把「选深度」作为在 time-to-GPT-2 约束下的决策问题。
- 对照 [[如何解读指标]]：CORE、ChatCORE、bpb 的联合报告方式。
- 跨库 [[成本-延迟-质量权衡]]：通用原理见该篇，本篇只讲 nanochat 如何把质量阈值固定、把成本压到单一时间量。

## 达标检测

- [ ] 能复算 2019 年 GPT-2 的 43,000 美元与当前 speedrun 的约 40–48 美元，并说明单价与时间来源。
- [ ] 能读出 leaderboard 每一列的来源字段（wandb 名称或 git 命令），并指出哪一列跨行不可比。
- [ ] 能说明为什么跨数据集比较要用 CORE 而不是 val_bpb，并各给出一个仓库内的证据。
- [ ] 能给出 Run 4 七次运行的均值、样本标准差与极差，并判断 0.2571 是否足以证明超过 0.256525。
- [ ] 能写出 CORE 差距换算成 token 增量的两步公式，并手算 $\Delta c=0.0045$ 时的 token 增量。
- [ ] 能指出 README 中「depth 26」「d20」「\$100」三处叙述与当前代码的差异，并给出当前正确值。
- [ ] 能说明为什么 time-to-GPT-2 用时间排序而不是用 CORE 排序。

## 参考来源

- Karpathy, *nanochat* README（commit 92d63d4），Time-to-GPT-2 Leaderboard 与成本一段 —— 对应本篇第 1、2、3 节的数字。
- Karpathy, *nanochat* `dev/LEADERBOARD.md`（commit 92d63d4）—— 对应 168 小时 / 32 块 TPU v3 / 0.256525 与提交规范。
- Radford et al., *Language Models are Unsupervised Multitask Learners*（GPT-2 技术报告，2019）—— 对应 GPT-2 1.6B 的规模与训练设置。
- DCLM 团队, *DataComp-LM*（2406.11794）—— 对应 CORE 指标与 22 项评测的来源。
- Karpathy, *nanochat*（commit 92d63d4），`dev/LOG.md` 2026-02-17、2026-03-04 条目 —— 对应 d18/d26 的 CORE 实测点与换数据后的时间变化。
- Karpathy, *nanochat* discussion #481 *Beating GPT-2 for <<\$100: the nanochat journey* —— 对应「低于 100 美元达到 GPT-2」的完整叙述。
