---
tags: [nanochat, pretraining, scaling-law]
阶段: 05-预训练Pretraining
难度: ★★★
created: 2026-10-22
related: "[[FLOPs与训练成本估算]], [[用--depth调参]], [[对比GPT-2核心指标]], [[预训练-微调-对齐pipeline]]"
---

# 缩放定律与模型深度

## 定义

**缩放定律**（scaling law）是描述语言模型损失随参数量 $N$、训练 token 数 $D$、计算量 $C$ 变化的经验幂律；**计算最优**（compute-optimal）指在固定 $C$ 下使损失最小的 $(N,D)$ 分配。nanochat 把「模型形状」压缩成单一整数 `--depth`，其余量由缩放定律推导。

符号与术语定义如下。

- $N$：参数量。nanochat 区分两种口径：**总参数**（含 `wte`、value embeddings、`lm_head`、逐层标量）与**缩放参数**（`transformer_matrices + lm_head`，即 `num_scaling_params()` 的前两项之和）。缩放定律用后者。
- $D$：训练 token 数。nanochat 中 $D=\text{ratio}\times N_{\text{scaling}}$，ratio 由 `--target-param-data-ratio` 给出。
- $C$：训练计算量，单位 FLOPs，近似 $C\approx 6ND$。
- **深度**（depth）：Transformer 的层数 $L$，即 `--depth`。
- **宽度**（width）：残差流维度 $d$，即 `model_dim`、`n_embd`。nanochat 由深度推导：$d=\lceil L\cdot 64/128\rceil\cdot 128$。
- **头维度**（head dim）：每个注意力头的维度，固定为 128；头数 $H=d/128$；GQA 中 KV 头数等于查询头数。
- **参考模型**（reference model）：d12。批量大小、学习率、权重衰减的基准点都在 d12 上测得，再按幂律外推到其它深度（muP 式迁移）。
- $B$：全局批大小（每步 token 数）；$B_{\text{ref}}=2^{19}=524{,}288$ 是 d12 的最优批。
- $D_{\text{ref}}$：参考模型的训练 token 数，$D_{\text{ref}}=\text{ratio}\times N_{\text{scaling}}(\text{d12})$。
- **T_epoch**：训练轮次时间尺度，$T_{\text{epoch}}=B/(\eta\lambda D)$，其中 $\eta$ 为学习率、$\lambda$ 为权重衰减；T_epoch 框架要求它在不同规模下保持常数。
- **auto batch**：`--total-batch-size=-1` 时由公式推出的全局批大小，结果取最近的 2 的幂。

## 为什么重要

它解决了「给定预算，模型该多大、该训多少 token、批与学习率该取多少」这一组耦合问题。没有缩放定律，每换一个深度都要重新扫一遍批大小、学习率与权重衰减；nanochat 用 d12 作为参考点，把这些量写成深度的函数，于是「换模型」退化为「改一个整数」。

它是成本可控的前提。预训练时长正比于 $C=6ND$，而 $D$ 由 ratio 与 $N$ 决定，$N$ 由深度决定；这条链条让「$48 训一个 GPT-2 级模型」成为可计算的结论，而不是试出来的结果。

它也是实验方法论的约束：`runs/scaling_laws.sh` 在 1e18 到 1e19 FLOPs 的四个预算上扫 d10 到 d20，用来重新拟合「哪个 $(N,D)$ 在固定算力下最优」；`runs/miniseries.sh` 扫 d12 到 d26 的完整曲线，用来验证一个改动是否在所有深度上都成立。两者合起来保证超参数不是对着单一模型调出来的。

在三个维度中，本篇同时属于「懂原理」（幂律与分配指数）与「懂工程」（参数推导链与扫描脚本）。

## 原理与推导

### 1. Kaplan 与 Chinchilla 的分配结论

Kaplan 等（2001.08361）用幂律拟合损失：

$$
L(N,D)=\left(\frac{N_c}{N}\right)^{\alpha_N}+\left(\frac{D_c}{D}\right)^{\alpha_D}+L_\infty ,
$$

并在固定 $C$ 下最小化，得到「参数优先」的分配：$N_{\text{opt}}\propto C^{0.73}$、$D_{\text{opt}}\propto C^{0.27}$。含义是算力增加时，主要把钱花在更大的模型上，token 数增长很慢。

Chinchilla（2203.15556）重新做了实验，结论是两项应同比例增长：

$$
N_{\text{opt}}\propto C^{0.5},\qquad D_{\text{opt}}\propto C^{0.5},\qquad \frac{D_{\text{opt}}}{N_{\text{opt}}}\approx 20 .
$$

推导只需两步。把约束 $C=6ND$ 代入 $D=C/(6N)$，损失对 $N$ 求极小，两项幂律的指数决定 $N^{*}$ 的标度；当两项幂律的系数与指数接近时，极小点落在 $N\propto D$ 的对角线上，于是 0.5/0.5。第三式是代入系数后的经验比值：每 1 个参数配约 20 个训练 token。

$C\approx6ND$ 的来源是：前向每个参数每个 token 约 2 FLOPs（一次乘加），反向约为前向的 2 倍（对输入与对权重各一次），合计 6 FLOPs/参数/token。nanochat 的 `GPT.estimate_flops()` 在此之上加了注意力项：每层 $12hq\cdot\min(w,T)$，其中 $h$ 为头数、$q$ 为头维度、$w$ 为窗口长度。

### 2. nanochat 的深度单旋钮

`scripts/base_train.py` 的 `build_model_meta` 给出完整推导：

```python
def build_model_meta(depth):
    """Build a model on meta device for a given depth (shapes/dtypes only, no data)."""
    base_dim = depth * args.aspect_ratio                      # 默认 aspect_ratio = 64
    model_dim = ((base_dim + args.head_dim - 1) // args.head_dim) * args.head_dim
    num_heads = model_dim // args.head_dim                    # head_dim 默认 128
    config = GPTConfig(
        sequence_len=args.max_seq_len, vocab_size=vocab_size,
        n_layer=depth, n_head=num_heads, n_kv_head=num_heads, n_embd=model_dim,
        window_pattern=args.window_pattern,
    )
    with torch.device("meta"):
        model_meta = GPT(config)
    return model_meta
```

三个量由此确定：宽度是深度的线性函数并向上取整到 128 的倍数；头数等于宽度除以 128；KV 头数等于查询头数（不使用 GQA 压缩）。宽度与深度同比例增长，因此模型接近「等纵横比」，参数按 $N\approx 12Ld^2$ 增长；代入 $d\approx 64L$ 得 $N\propto L^3$。

计算量按 $C\propto N\cdot D$ 增长，而计算最优要求 $D\propto N$，于是 $C\propto N^2\propto L^6$。这条六次方关系是「深度是算力的对数刻度」的来源：在 d24 附近深度加 2，参数乘 1.26、算力乘 1.58；深度越小，同样的 +2 带来的相对增幅越大（d12 到 d14 约为 2.23 倍）。

### 3. 参数构成与两个口径

d24 的参数分组（`GPT.num_scaling_params()` 的返回值）：

| 组 | 元素数 | 说明 |
|---|---|---|
| `wte` | 50,331,648 | $32768\times1536$，bf16 存储 |
| `value_embeds` | 603,979,776 | 12 层各一个 $32768\times1536$ |
| `lm_head` | 50,331,648 | 与 `wte` 不共享 |
| `transformer_matrices` | 679,478,976 | 每层 $12d^2$，含 `ve_gate` |
| `scalars` | 74 | `resid_lambdas`、`x0_lambdas`、`smear`、`backout` |
| 总参数 | 1,384,122,122 | 上五项之和 |
| 缩放参数 | 729,810,624 | `transformer_matrices + lm_head` |

两个口径用途不同。与 GPT-2 的 1.6B 比较时用总参数；计算训练 token 数与 FLOPs 时用缩放参数。`dev/LOG.md` 2026-01-27 的拟合说明，用「transformer 矩阵 + `lm_head`」这一口径得到的缩放律最干净，因此 `base_train.py` 的 `get_scaling_params` 就取这两项。

### 4. 数据参数比的取舍

`--target-param-data-ratio` 直接决定训练 token 数：$D=\text{ratio}\times N_{\text{scaling}}$。当前默认值 12，speedrun 用 8，仓库文档另有一处写 10.5，Chinchilla 的经验值是 20。

比值的选择是「单模型质量」与「单位算力的可达能力」之间的取舍。在固定算力下，提高比值意味着缩小模型、延长训练：小模型每 token 更便宜，但容量有限；降低比值意味着放大模型、缩短训练：大模型每步更贵，但在较少 token 上就能达到同等能力。

nanochat 的目标函数是 time-to-GPT-2，即在固定能力阈值下最小化墙钟时间，因此它选择低于计算最优的比值：`runs/speedrun.sh` 用 8，`dev/LEADERBOARD.md` 的 Run 2 用 8.5、Run 3 用 8.25、Run 4 用 9.5、Run 5 用 8.7、Run 6 用 8。注释明确写出这是「slightly undertrained」，即用略微欠训练换取更短时间。反过来，如果目标是给定算力下的最低损失（而不是最快到达阈值），应当用计算最优比值。

### 5. 由 d12 参考点外推批大小

Power Lines（2505.13738）给出的结论是最优批大小随训练 token 数按 $B_{\text{opt}}\propto D^{0.383}$ 增长。nanochat 以 d12 的 $B_{\text{ref}}=2^{19}$ 为锚点：

$$
B=2^{\mathrm{round}\left(\log_2\left[B_{\text{ref}}\left(\frac{D}{D_{\text{ref}}}\right)^{0.383}\right]\right)},\qquad D_{\text{ref}}=\text{ratio}\times N_{\text{scaling}}(\text{d12}).
$$

因为 $D=\text{ratio}\times N$ 且 $D_{\text{ref}}=\text{ratio}\times N_{12}$，比值 $D/D_{\text{ref}}=N/N_{12}$ 与 ratio 无关：批大小只取决于模型本身，换 ratio 不会改变 auto batch。取整到 2 的幂是为通信与矩阵乘效率，代价是曲线呈阶梯状。

指数 0.383 很小：token 数增加到 10 倍，批大小只需增加到约 $10^{0.383}\approx2.4$ 倍。

### 6. 学习率与权重衰减的联动

批大小确定后，学习率按平方根缩放：$\eta\propto\sqrt{B/B_{\text{ref}}}$。这是 AdamW 的标准做法，nanochat 对 Muon 也沿用同一规则并在源码注释中标注「未仔细研究，属于假设」。此外 AdamW 组的学习率还要乘 $(d/768)^{-1/2}$，即按宽度的平方根反比缩放。

权重衰减由 T_epoch 框架推导。要求 $T_{\text{epoch}}=B/(\eta\lambda D)$ 为常数，代入 $\eta\propto\sqrt{B}$，得

$$
\lambda=\lambda_{\text{ref}}\cdot\sqrt{\frac{B}{B_{\text{ref}}}}\cdot\frac{D_{\text{ref}}}{D}.
$$

另有一条独立的经验律：在 d8、d12、d16、d20 上扫最优权重衰减，拟合得 $\lambda\propto1/\text{width}^{\alpha}$，$\alpha\approx1.97$（`dev/LOG.md` 2026-01-10）。两条规则量级一致：d12 上 0.28，外推到 d24 得 $0.28\times\sqrt{2}\times(110.1/729.8)\approx0.060$，而按 $1/\text{width}^2$ 得 $0.28\times(12/24)^2=0.070$。当前代码实现的是 T_epoch 版本，并在训练中按余弦曲线从该值衰减到 0。

### 7. 扫描脚本：scaling_laws 与 miniseries

`runs/scaling_laws.sh` 在四个算力预算上扫六个深度，用于重新拟合 $(N,D)$ 的最优点：

```bash
FLOPS_BUDGETS=(1e18 2.15e18 4.64e18 1e19)
DEPTHS=(10 12 14 16 18 20)
# 为聚焦核心循环只保留关键行；表头、run_exists 检查与日志提取见 runs/scaling_laws.sh 原文

torchrun --standalone --nproc_per_node=$NPROC_PER_NODE -m scripts.base_train -- \
    --depth=$d \
    --target-flops=$flops \
    --target-param-data-ratio=-1 \
    --core-metric-every=999999 \
    --core-metric-max-per-task=-1 \
    --sample-every=-1 \
    --save-every=-1 \
    $DEVICE_BATCH_SIZE_ARG
```

`--target-flops` 会把迭代数换算成 `round(target_flops / (flops_per_token * total_batch_size))`，因此每个 $(预算, 深度)$ 组合训练的 token 数不同，正好扫出「同等算力下不同规模的最优损失」。结果追加到 CSV，字段为 `flops_budget, depth, model_dim, params_wte, params_value_embeds, params_lm_head, params_transformer, params_scalars, params_total, num_iterations, tokens_trained, val_bpb, core_score, train_time_sec`。脚本用 `grep "^${flops},${depth},"` 跳过已完成的组合，因此中断后可续跑。

`runs/miniseries.sh` 固定 ratio、扫 d12 到 d26 的八个深度，CSV 字段为 `depth, model_dim, num_params, num_scaling_params, num_iterations, tokens_trained, param_data_ratio, val_bpb, core_score, train_time_sec`。它的意义与 scaling_laws 不同：scaling_laws 回答「同等算力下多大多小最优」，miniseries 回答「同一个改动是否在所有深度上都成立」。后者是 leaderboard 的准入条件——一个只在 d24 上有效的技巧不被接受，因为它无法支撑整条 miniseries。

### 8. 逐深度展开

下表按当前公式逐深度展开。缩放参数由 `num_scaling_params()` 的构成计算：$12Ld^2$ 加每个 value-embedding 层 `ve_gate` 的 $12\times(d/128)$ 个元素，再加 `lm_head` 的 $32768d$；d24 的 `ve_gate` 合计 1728 个。目标 token 按 LOG 表的 10.5 口径、当前默认的 12 与 speedrun 的 8 三列给出；auto batch 由第 5 节公式得到。

| depth | model_dim | n_head | 缩放参数 | 目标 token @10.5 | @12（默认） | @8（speedrun） | auto batch |
|---|---|---|---|---|---|---|---|
| d8 | 512 | 4 | 41,943,232 | 0.44B | 0.50B | 0.34B | $2^{18}=262{,}144$ |
| d12 | 768 | 6 | 110,100,912 | 1.16B | 1.32B | 0.88B | $2^{19}=524{,}288$ |
| d16 | 1024 | 8 | 234,881,792 | 2.47B | 2.82B | 1.88B | $2^{19}=524{,}288$ |
| d20 | 1280 | 10 | 435,160,240 | 4.57B | 5.22B | 3.48B | $2^{20}=1{,}048{,}576$ |
| d24 | 1536 | 12 | 729,810,624 | 7.66B | 8.76B | 5.84B | $2^{20}=1{,}048{,}576$ |
| d26 | 1664 | 13 | 918,423,532 | 9.64B | 11.02B | 7.35B | $2^{20}=1{,}048{,}576$ |
| d32 | 2048 | 16 | 1,677,724,672 | 17.62B | 20.13B | 13.42B | $2^{21}=2{,}097{,}152$ |

该表与 `dev/LOG.md` 2026-02-05 的区间表一致：d8 为 42M / 0.44B / $2^{18}$；d10–16 为 70M–235M / 0.7B–2.5B / $2^{19}$；d18–26 为 324M–918M / 3.4B–9.6B / $2^{20}$；d32–50 为 1.7B–6.2B / 17.6B–65.6B / $2^{21}$。LOG 的 token 列按 10.5 计算，因此与表中 @10.5 一列相同。

### 9. 由公式得到的 d24 实参

把第 5、6 节的公式代入 d24、ratio 8，可以得到每个参数组实际使用的学习率。中间量有两个：批缩放因子 $\sqrt{2^{20}/2^{19}}=\sqrt2\approx1.4142$，宽度缩放因子 $(1536/768)^{-1/2}=2^{-1/2}\approx0.7071$。

| 参数组 | 命令行值 | 传入优化器的值 | 最终学习率 |
|---|---|---|---|
| `wte`（AdamW） | `--embedding-lr=0.3` | $0.3\times\sqrt2=0.4243$ | $0.4243\times0.7071=0.300$ |
| value embeddings | 同上 | 同上 | $0.300\times0.5=0.150$ |
| `lm_head`（AdamW） | `--unembedding-lr=0.008` | $0.008\times\sqrt2=0.0113$ | $0.0113\times0.7071=0.008$ |
| `resid_lambdas` | `--scalar-lr=0.5` | $0.5\times\sqrt2=0.7071$ | $0.7071\times0.01=0.0071$ |
| `x0_lambdas` | 同上 | 同上 | $0.7071$ |
| `smear` 组 | 无 | 硬编码 0.2 | $0.2$（不随批与宽度缩放） |
| Muon $(1536,1536)$ | `--matrix-lr=0.02` | $0.02\times\sqrt2=0.0283$ | $0.0283\times1=0.0283$ |
| Muon $(6144,1536)$（`c_fc`） | 同上 | 同上 | $0.0283\times\sqrt{4}=0.0566$ |
| Muon $(1536,6144)$（`c_proj`） | 同上 | 同上 | $0.0283\times1=0.0283$ |

两处值得注意。第一，d24 上批缩放与宽度缩放恰好互为倒数（$\sqrt2\times2^{-1/2}=1$），因此 AdamW 组的最终学习率与命令行值相同；这解释了为什么 `--embedding-lr=0.3` 在 d12 与 d24 上都能直接用。第二，Muon 对「高瘦」矩阵乘了 $\sqrt{m/n}$，对「矮胖」矩阵不乘，因此同一次训练里 `c_fc` 与 `c_proj` 的有效学习率相差 2 倍；这不是笔误，而是按 `max(1.0, shape[-2]/shape[-1])**0.5` 计算的。

权重衰减起点为 0.0597（第 6 节），随后按余弦退火到 0；Muon 动量在前 400 步从 0.85 升到 0.97，warmdown 段降到 0.90。

### 在 nanochat 中的落地

第一处是 `scripts/base_train.py` 的「Scaling laws and muP extrapolations」段落。它按固定顺序推导：先用 `num_scaling_params()` 得到 $N$，再由 ratio 得 `target_tokens`；随后构造 d12 的 meta 模型得到 $D_{\text{ref}}$；再算批大小、学习率缩放因子与权重衰减；最后用 `total_batch_size // world_tokens_per_fwdbwd` 得梯度累积步数。顺序不可交换，因为每一步都依赖前一步。

第二处是 `GPT.setup_optimizer`。它按参数类型分组（6 个 AdamW 组 + 按形状分组的 Muon 组），并施加 $(d/768)^{-1/2}$ 的宽度缩放。分组决定优化器状态的分片边界，因此与分布式实现共享同一套形状假设。

第三处是三个调度器：`get_lr_multiplier`（40 步线性 warmup、恒定、按 `warmdown_ratio=0.65` 线性降到 `final_lr_frac=0.05`）、`get_muon_momentum`（400 步内从 0.85 升到 0.97，warmdown 段降到 0.90）、`get_weight_decay`（余弦退火到 0）。它们都以 `num_iterations` 为自变量，因此恢复训练时必须保持该值不变。

## 关键直觉

> [!tip] 深度是「算力预算」的一维刻度，宽度与 token 数都被它绑死
> 因为宽度是深度的线性函数、参数按深度三次方增长、计算最优下 token 与参数同比例，所以算力随深度六次方增长。这一个整数同时决定了模型多大、训多久、批多大、学习率与权重衰减取多少。与严格定义的关系：定义中的 $(N,D)$ 两维自由度被 ratio 与 depth 两条约束压成一维；若把 ratio 也当自由变量，模型就脱离计算最优曲线，深度不再是预算刻度。

## 例子与代码

### 1. 由深度复算宽度、参数与目标 token

```python
# 独立运行：复算本节的表；公式与 build_model_meta / get_scaling_params 一致
def model_dim(depth, aspect=64, head_dim=128):
    base = depth * aspect
    return ((base + head_dim - 1) // head_dim) * head_dim

VOCAB = 32768
def scaling_params(depth):
    d = model_dim(depth)
    L = depth
    # 每层 12 d^2；has_ve 的层各多一个 (n_kv_head x 12) 的 ve 门；再加大 vocab 的 lm_head
    n_ve = sum(1 for i in range(L) if i % 2 == (L - 1) % 2)
    ve_gate = 12 * (d // 128) * n_ve
    return 12 * L * d * d + ve_gate + VOCAB * d

for depth in (8, 12, 16, 20, 24, 26, 32):
    d = model_dim(depth)
    N = scaling_params(depth)
    print(f"d{depth:<2} dim={d:<4} heads={d//128:<2} N={N:>13,}  D@12={12*N/1e9:.2f}B")
# 预期：d24 dim=1536 heads=12 N=  729,810,624  D@12=8.76B
# 预期：d26 dim=1664 heads=13 N=  918,423,532  D@12=11.02B
```

注意 `ve_gate` 这一项：它让 d24 的矩阵参数比 $12Ld^2$ 多 1728 个元素（12 个 value-embedding 层各 144 个）。量级可忽略，但若用纯 $12Ld^2$ 去核对 `num_scaling_params()` 的输出，差额就来自这里。

### 2. 复算 auto batch

```python
import math
B_REF, D_RATIO = 2**19, 10.5
N12 = scaling_params(12)                     # 110,100,912
D_REF = D_RATIO * N12                        # 参考模型的训练 token 数
for depth in (8, 12, 16, 20, 24, 26, 32):
    N = scaling_params(depth)
    D = D_RATIO * N                           # 与训练脚本同一写法
    B = 2 ** round(math.log2(B_REF * (D / D_REF) ** 0.383))
    print(f"d{depth:<2} D/Dref={D/D_REF:5.2f}  B={B:>9,}  log2={math.log2(B):.2f}")
# 预期：d8  B=  262,144  log2=18.00
# 预期：d24 B=1,048,576  log2=20.00
# 预期：d32 B=2,097,152  log2=21.00
```

若把 `D_RATIO` 从 10.5 改成 12 或 8，输出不变：$D/D_{\text{ref}}$ 中的 ratio 上下抵消。这是第 5 节结论的数值验证。

### 3. 冒烟测试：算力随深度的六次方

```python
# 独立运行：验证 d24 -> d26 的算力增长约为 1.26^2
N24, N26 = scaling_params(24), scaling_params(26)
D = lambda N: 8 * N                       # ratio = 8
C = lambda N: 6 * N * D(N)
print(f"N ratio={N26/N24:.4f}  C ratio={C(N26)/C(N24):.4f}")
# 预期：N ratio=1.2584  C ratio=1.5836
```

在 d24 附近，深度加 2 使算力增加约 58%。leaderboard 上 d24 与 d26 的运行时间差（3.04 h 与 2.91 h 等）由批大小、精度与数据共同决定，不能直接用该比值外推。

### 4. 跑一次深度扫描

```bash
# 完整扫描：4 个算力预算 × 6 个深度 = 24 个组合，结果追加到同一个 CSV
bash runs/scaling_laws.sh

# 从某个组合的训练日志核对推导链（d20、1e19 FLOPs）
LOG="$NANOCHAT_BASE_DIR/scaling_laws_results_jan26/scaling_1e19_d20_train.log"
grep -E "Auto-computed optimal batch size|Calculated number of iterations" "$LOG"
# 预期输出：
# Auto-computed optimal batch size: 1,048,576 tokens
# Calculated number of iterations from target FLOPs: 3,304
```

迭代数可手算核对：d20 的 `FLOPs/token` 为 $2.8862\times10^{9}$，乘批 $2^{20}$ 得 $3.0265\times10^{15}$，$10^{19}/3.0265\times10^{15}=3304.2$，取整为 3304，对应训练 token 数 $3304\times1{,}048{,}576\approx3.46\times10^{9}$。`FLOPS_BUDGETS` 与 `DEPTHS` 是脚本内的硬编码数组，改变扫描范围需直接编辑文件。

## 易错点

> [!warning] 七个可检验的错误
> 1. 把 Kaplan 的分配指数写成 0.5/0.5。Kaplan 原文给的是 $N\propto C^{0.73}$、$D\propto C^{0.27}$；0.5/0.5 与 20 token/参数来自 Chinchilla。
> 2. 用总参数算 token horizon。`get_scaling_params` 只取 `transformer_matrices + lm_head`；用 1.38B 而不是 729.8M 会把 d24 的训练 token 数放大近一倍。
> 3. 认为 auto batch 随 ratio 变化。$D/D_{\text{ref}}$ 中的 ratio 上下抵消，批大小只由 $N/N_{12}$ 决定。
> 4. 认为批大小随深度连续变化。公式结果取整到最近的 2 的幂，因此 d12 与 d16 同为 $2^{19}$。
> 5. 用 $12Ld^2$ 精确核对参数。还差每个 value-embedding 层 `ve_gate` 的 $12\times(d/128)$ 与逐层标量；差额虽小，但断言相等会失败。
> 6. 把 T_epoch 公式与经验 $1/\text{width}^2$ 律当成同一个东西。前者由 $\eta\propto\sqrt{B}$ 与 $T_{\text{epoch}}$ 常数推出，后者是四档深度上的独立拟合；两者在 d24 上分别给出 0.060 与 0.070。
> 7. 认为 `D_REF` 是常数。它等于 ratio 乘 d12 的缩放参数，架构或词表改变时需要重算，否则后面所有推导都偏移。

## 关联笔记

- 前置 [[FLOPs与训练成本估算]]：$6N$ 与注意力项的通用推导。
- 前置 [[GPT模型类与config]]：`num_scaling_params()` 与 `estimate_flops()` 的实现。
- 后续 [[用--depth调参]]：把本篇的推导链用于实验设计。
- 对照 [[对比GPT-2核心指标]]：ratio 从 12 降到 8 正是为了缩短 time-to-GPT-2。
- 跨库 [[预训练-微调-对齐pipeline]]：通用原理见该篇，本篇只讲 nanochat 如何用单一深度参数推出全部超参数。

## 达标检测

- [ ] 能写出 $C\approx6ND$ 的两步推导，并说明 nanochat 的注意力项为何要单独加。
- [ ] 能区分 Kaplan 与 Chinchilla 的分配指数，并说明 20 token/参数属于哪一个。
- [ ] 能由 `--depth=24` 手算出 1536、12 头、729,810,624 缩放参数与 8.76B 目标 token。
- [ ] 能说明 auto batch 公式中 ratio 为何被消去，并验证 d16 与 d12 同为 $2^{19}$。
- [ ] 能写出 T_epoch 推导出的权重衰减公式，并与 $1/\text{width}^2$ 经验律比较 d24 上的数值。
- [ ] 能说出 `scaling_laws.sh` 与 `miniseries.sh` 在问题设定上的区别，以及各自 CSV 的关键列。
- [ ] 能解释为什么计算最优比值 10.5–12 与 speedrun 实际使用的 8 不同，代价是什么。

## 参考来源

- Kaplan et al., *Scaling Laws for Neural Language Models*（2001.08361）—— 对应第 1 节的幂律形式与 0.73/0.27 分配指数。
- Hoffmann et al., *Training Compute-Optimal Large Language Models*（2203.15556，Chinchilla）—— 对应 0.5/0.5 分配与 20 token/参数。
- Bergsma et al., *Power Laws for Batch Size, Model Size, and Training Horizon*（2505.13738，Power Lines）—— 对应 $B_{\text{opt}}\propto D^{0.383}$。
- Hägele et al., *Scaling Laws for the Learning Rate and Weight Decay*（2405.13698，T_epoch）—— 对应第 6 节的权重衰减推导。
- Karpathy, *nanochat*（commit 92d63d4），`scripts/base_train.py` 与 `dev/LOG.md` 2026-01-10、2026-02-05、2026-01-27 条目 —— 对应参考点、auto batch 表与权重衰减拟合。
- Karpathy, *nanochat*（commit 92d63d4），`runs/scaling_laws.sh` 与 `runs/miniseries.sh` —— 对应扫描设计与 CSV 字段。
