缩放定律与模型深度
定义
缩放定律(scaling law)是描述语言模型损失随参数量 、训练 token 数 、计算量 变化的经验幂律;计算最优(compute-optimal)指在固定 下使损失最小的 分配。nanochat 把「模型形状」压缩成单一整数 --depth,其余量由缩放定律推导。
符号与术语定义如下。
- :参数量。nanochat 区分两种口径:总参数(含
wte、value embeddings、lm_head、逐层标量)与缩放参数(transformer_matrices + lm_head,即num_scaling_params()的前两项之和)。缩放定律用后者。 - :训练 token 数。nanochat 中 ,ratio 由
--target-param-data-ratio给出。 - :训练计算量,单位 FLOPs,近似 。
- 深度(depth):Transformer 的层数 ,即
--depth。 - 宽度(width):残差流维度 ,即
model_dim、n_embd。nanochat 由深度推导:。 - 头维度(head dim):每个注意力头的维度,固定为 128;头数 ;GQA 中 KV 头数等于查询头数。
- 参考模型(reference model):d12。批量大小、学习率、权重衰减的基准点都在 d12 上测得,再按幂律外推到其它深度(muP 式迁移)。
- :全局批大小(每步 token 数); 是 d12 的最优批。
- :参考模型的训练 token 数,。
- T_epoch:训练轮次时间尺度,,其中 为学习率、 为权重衰减;T_epoch 框架要求它在不同规模下保持常数。
- auto batch:
--total-batch-size=-1时由公式推出的全局批大小,结果取最近的 2 的幂。
为什么重要
它解决了「给定预算,模型该多大、该训多少 token、批与学习率该取多少」这一组耦合问题。没有缩放定律,每换一个深度都要重新扫一遍批大小、学习率与权重衰减;nanochat 用 d12 作为参考点,把这些量写成深度的函数,于是「换模型」退化为「改一个整数」。
它是成本可控的前提。预训练时长正比于 ,而 由 ratio 与 决定, 由深度决定;这条链条让「$48 训一个 GPT-2 级模型」成为可计算的结论,而不是试出来的结果。
它也是实验方法论的约束:runs/scaling_laws.sh 在 1e18 到 1e19 FLOPs 的四个预算上扫 d10 到 d20,用来重新拟合「哪个 在固定算力下最优」;runs/miniseries.sh 扫 d12 到 d26 的完整曲线,用来验证一个改动是否在所有深度上都成立。两者合起来保证超参数不是对着单一模型调出来的。
在三个维度中,本篇同时属于「懂原理」(幂律与分配指数)与「懂工程」(参数推导链与扫描脚本)。
原理与推导
1. Kaplan 与 Chinchilla 的分配结论
Kaplan 等(2001.08361)用幂律拟合损失:
并在固定 下最小化,得到「参数优先」的分配:、。含义是算力增加时,主要把钱花在更大的模型上,token 数增长很慢。
Chinchilla(2203.15556)重新做了实验,结论是两项应同比例增长:
推导只需两步。把约束 代入 ,损失对 求极小,两项幂律的指数决定 的标度;当两项幂律的系数与指数接近时,极小点落在 的对角线上,于是 0.5/0.5。第三式是代入系数后的经验比值:每 1 个参数配约 20 个训练 token。
的来源是:前向每个参数每个 token 约 2 FLOPs(一次乘加),反向约为前向的 2 倍(对输入与对权重各一次),合计 6 FLOPs/参数/token。nanochat 的 GPT.estimate_flops() 在此之上加了注意力项:每层 ,其中 为头数、 为头维度、 为窗口长度。
2. nanochat 的深度单旋钮
scripts/base_train.py 的 build_model_meta 给出完整推导:
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 压缩)。宽度与深度同比例增长,因此模型接近「等纵横比」,参数按 增长;代入 得 。
计算量按 增长,而计算最优要求 ,于是 。这条六次方关系是「深度是算力的对数刻度」的来源:在 d24 附近深度加 2,参数乘 1.26、算力乘 1.58;深度越小,同样的 +2 带来的相对增幅越大(d12 到 d14 约为 2.23 倍)。
3. 参数构成与两个口径
d24 的参数分组(GPT.num_scaling_params() 的返回值):
| 组 | 元素数 | 说明 |
|---|---|---|
wte | 50,331,648 | ,bf16 存储 |
value_embeds | 603,979,776 | 12 层各一个 |
lm_head | 50,331,648 | 与 wte 不共享 |
transformer_matrices | 679,478,976 | 每层 ,含 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 数:。当前默认值 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 数按 增长。nanochat 以 d12 的 为锚点:
因为 且 ,比值 与 ratio 无关:批大小只取决于模型本身,换 ratio 不会改变 auto batch。取整到 2 的幂是为通信与矩阵乘效率,代价是曲线呈阶梯状。
指数 0.383 很小:token 数增加到 10 倍,批大小只需增加到约 倍。
6. 学习率与权重衰减的联动
批大小确定后,学习率按平方根缩放:。这是 AdamW 的标准做法,nanochat 对 Muon 也沿用同一规则并在源码注释中标注「未仔细研究,属于假设」。此外 AdamW 组的学习率还要乘 ,即按宽度的平方根反比缩放。
权重衰减由 T_epoch 框架推导。要求 为常数,代入 ,得
另有一条独立的经验律:在 d8、d12、d16、d20 上扫最优权重衰减,拟合得 ,(dev/LOG.md 2026-01-10)。两条规则量级一致:d12 上 0.28,外推到 d24 得 ,而按 得 。当前代码实现的是 T_epoch 版本,并在训练中按余弦曲线从该值衰减到 0。
7. 扫描脚本:scaling_laws 与 miniseries
runs/scaling_laws.sh 在四个算力预算上扫六个深度,用于重新拟合 的最优点:
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() 的构成计算: 加每个 value-embedding 层 ve_gate 的 个元素,再加 lm_head 的 ;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 | |
| d12 | 768 | 6 | 110,100,912 | 1.16B | 1.32B | 0.88B | |
| d16 | 1024 | 8 | 234,881,792 | 2.47B | 2.82B | 1.88B | |
| d20 | 1280 | 10 | 435,160,240 | 4.57B | 5.22B | 3.48B | |
| d24 | 1536 | 12 | 729,810,624 | 7.66B | 8.76B | 5.84B | |
| d26 | 1664 | 13 | 918,423,532 | 9.64B | 11.02B | 7.35B | |
| d32 | 2048 | 16 | 1,677,724,672 | 17.62B | 20.13B | 13.42B |
该表与 dev/LOG.md 2026-02-05 的区间表一致:d8 为 42M / 0.44B / ;d10–16 为 70M–235M / 0.7B–2.5B / ;d18–26 为 324M–918M / 3.4B–9.6B / ;d32–50 为 1.7B–6.2B / 17.6B–65.6B / 。LOG 的 token 列按 10.5 计算,因此与表中 @10.5 一列相同。
9. 由公式得到的 d24 实参
把第 5、6 节的公式代入 d24、ratio 8,可以得到每个参数组实际使用的学习率。中间量有两个:批缩放因子 ,宽度缩放因子 。
| 参数组 | 命令行值 | 传入优化器的值 | 最终学习率 |
|---|---|---|---|
wte(AdamW) | --embedding-lr=0.3 | ||
| value embeddings | 同上 | 同上 | |
lm_head(AdamW) | --unembedding-lr=0.008 | ||
resid_lambdas | --scalar-lr=0.5 | ||
x0_lambdas | 同上 | 同上 | |
smear 组 | 无 | 硬编码 0.2 | (不随批与宽度缩放) |
| Muon | --matrix-lr=0.02 | ||
Muon (c_fc) | 同上 | 同上 | |
Muon (c_proj) | 同上 | 同上 |
两处值得注意。第一,d24 上批缩放与宽度缩放恰好互为倒数(),因此 AdamW 组的最终学习率与命令行值相同;这解释了为什么 --embedding-lr=0.3 在 d12 与 d24 上都能直接用。第二,Muon 对「高瘦」矩阵乘了 ,对「矮胖」矩阵不乘,因此同一次训练里 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() 得到 ,再由 ratio 得 target_tokens;随后构造 d12 的 meta 模型得到 ;再算批大小、学习率缩放因子与权重衰减;最后用 total_batch_size // world_tokens_per_fwdbwd 得梯度累积步数。顺序不可交换,因为每一步都依赖前一步。
第二处是 GPT.setup_optimizer。它按参数类型分组(6 个 AdamW 组 + 按形状分组的 Muon 组),并施加 的宽度缩放。分组决定优化器状态的分片边界,因此与分布式实现共享同一套形状假设。
第三处是三个调度器: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 为自变量,因此恢复训练时必须保持该值不变。
关键直觉
深度是「算力预算」的一维刻度,宽度与 token 数都被它绑死
因为宽度是深度的线性函数、参数按深度三次方增长、计算最优下 token 与参数同比例,所以算力随深度六次方增长。这一个整数同时决定了模型多大、训多久、批多大、学习率与权重衰减取多少。与严格定义的关系:定义中的 两维自由度被 ratio 与 depth 两条约束压成一维;若把 ratio 也当自由变量,模型就脱离计算最优曲线,深度不再是预算刻度。
例子与代码
1. 由深度复算宽度、参数与目标 token
# 独立运行:复算本节的表;公式与 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 的矩阵参数比 多 1728 个元素(12 个 value-embedding 层各 144 个)。量级可忽略,但若用纯 去核对 num_scaling_params() 的输出,差额就来自这里。
2. 复算 auto batch
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,输出不变: 中的 ratio 上下抵消。这是第 5 节结论的数值验证。
3. 冒烟测试:算力随深度的六次方
# 独立运行:验证 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. 跑一次深度扫描
# 完整扫描: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 为 ,乘批 得 ,,取整为 3304,对应训练 token 数 。FLOPS_BUDGETS 与 DEPTHS 是脚本内的硬编码数组,改变扫描范围需直接编辑文件。
易错点
七个可检验的错误
1. 把 Kaplan 的分配指数写成 0.5/0.5。Kaplan 原文给的是 、;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 变化。 中的 ratio 上下抵消,批大小只由 决定。
4. 认为批大小随深度连续变化。公式结果取整到最近的 2 的幂,因此 d12 与 d16 同为 。
5. 用 精确核对参数。还差每个 value-embedding 层
ve_gate的 与逐层标量;差额虽小,但断言相等会失败。6. 把 T_epoch 公式与经验 律当成同一个东西。前者由 与 常数推出,后者是四档深度上的独立拟合;两者在 d24 上分别给出 0.060 与 0.070。
7. 认为
D_REF是常数。它等于 ratio 乘 d12 的缩放参数,架构或词表改变时需要重算,否则后面所有推导都偏移。
关联笔记
- 前置 FLOPs与训练成本估算: 与注意力项的通用推导。
- 前置 GPT模型类与config:
num_scaling_params()与estimate_flops()的实现。 - 后续 用--depth调参:把本篇的推导链用于实验设计。
- 对照 对比GPT-2核心指标:ratio 从 12 降到 8 正是为了缩短 time-to-GPT-2。
- 跨库 预训练-微调-对齐pipeline:通用原理见该篇,本篇只讲 nanochat 如何用单一深度参数推出全部超参数。
达标检测
- [ ] 能写出 的两步推导,并说明 nanochat 的注意力项为何要单独加。
- [ ] 能区分 Kaplan 与 Chinchilla 的分配指数,并说明 20 token/参数属于哪一个。
- [ ] 能由
--depth=24手算出 1536、12 头、729,810,624 缩放参数与 8.76B 目标 token。 - [ ] 能说明 auto batch 公式中 ratio 为何被消去,并验证 d16 与 d12 同为 。
- [ ] 能写出 T_epoch 推导出的权重衰减公式,并与 经验律比较 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)—— 对应 。
- 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.md2026-01-10、2026-02-05、2026-01-27 条目 —— 对应参考点、auto batch 表与权重衰减拟合。 - Karpathy, nanochat(commit 92d63d4),
runs/scaling_laws.sh与runs/miniseries.sh—— 对应扫描设计与 CSV 字段。