CS336 · 第 11 课

Scaling Laws：深入拟合、外推与决策

第 9 课建立了 scaling law 的宏观图景；这一课深入实际工程问题：如何从噪声数据中稳健拟合幂律？如何量化外推的不确定性？如何用 scaling law 在真实约束下做最优决策？

本讲问题：第 9 课给出了 scaling law 的结论；本讲进一步处理真正困难的部分：有限、带噪声的实验怎样支持对更大训练规模的外推和决策。

run design → observations → fit parameters
                         ├→ held-out residuals
                         ├→ bootstrap / uncertainty
                         └→ regime-shift checks
                                  ↓
candidate extrapolation → sensitivity analysis → decision

point estimate ≠ confidence interval ≠ guarantee

从第 9 课说起

第 9 课的核心结论：

• 总 FLOPs ≈ 6ND（前向 2ND + 反向 4ND）
• Chinchilla 最优比例：D ≈ 20 × N
• Isoflop 曲线：固定算力下，存在最优的 (N, D) 组合

回顾：幂律形式

# 参数 vs 损失（固定数据量）
L(N) = (N_c / N)^α_N

# 数据 vs 损失（固定参数量）
L(D) = (D_c / D)^α_D

# 联合形式（Chinchilla 论文）
L(N, D) = E + (N_c / N)^α + (D_c / D)^β
# 其中 E 是不可约损失（irreducible loss）

如何拟合 Scaling Law

方法 1：对数线性回归（简单但不稳健）

对幂律 L = (N_c / N)^α 取对数，得到：

log L = α log N_c − α log N
      = a − α × log N     （关于 log N 的线性函数）

# 算法：
# 1. 训练多个不同大小的模型（固定其他超参）
# 2. 记录 (log N, log L)
# 3. 做线性回归
# 4. 斜率 = −α，截距 = α log N_c

方法 2：非线性最小二乘（NLLS）

直接拟合原始幂律形式，避免 log 变换的偏差：

import numpy as np
from scipy.optimize import curve_fit

def scaling_law(N, N_c, alpha, L_inf):
    """带不可约损失的幂律"""
    return (N_c / N) ** alpha + L_inf

# 数据：多个模型的参数量和验证 loss
N_values = np.array([1e6, 3e6, 1e7, 3e7, 1e8, 3e8, 1e9])
losses = np.array([4.2, 3.8, 3.5, 3.2, 2.9, 2.7, 2.5])

# 拟合
popt, pcov = curve_fit(scaling_law, N_values, losses,
                       p0=[1e5, 0.1, 2.0],
                       bounds=([0, 0, 0], [np.inf, 1, np.inf]))
N_c, alpha, L_inf = popt

print(f"α = {alpha:.3f}")
print(f"N_c = {N_c:.2e}")
print(f"L_∞ = {L_inf:.3f}")

方法 3：考虑数据量的联合拟合（Chinchilla 方法）

Chinchilla 论文使用的是同时变化 N 和 D 的联合拟合：

def chinchilla_law(N, D, E, alpha, beta, N_c, D_c):
    """
    Chinchilla 论文的参数化形式
    L(N, D) = E + A/N^α + B/D^β
    其中 A = N_c^α, B = D_c^β
    """
    return E + (N_c / N) ** alpha + (D_c / D) ** beta

# 实验设计：
# - 变化 N: 70M, 160M, 400M, 1B, 14B 等
# - 变化 D: 对应每个 N 训练不同步数
# - 总数据点：几百个 (N, D, L) 三元组

方法 4：Isoflop 曲线拟合（Hoffmann 2022）

Chinchilla 论文采用的更精细策略：

1. 选择几个固定的算力预算 C（如 1e18, 1e19, 1e20 FLOPs）
2. 对每个 C，训练多个 (N, D) 组合（满足 6ND = C）
3. 画出 Isoflop 曲线：x 轴 = N，y 轴 = L
4. 找到每条曲线的最优点 N_opt(C)
5. 拟合 N_opt(C) 和 D_opt(C) 与 C 的关系

超参数的影响

Scaling law 的拟合结果依赖于训练超参数：

噪声、方差与置信区间

损失的随机性来源

同一个 (N, D) 配置，多次训练可能得到不同的 loss：

• 数据顺序：不同的数据 shuffle 顺序
• 权重初始化：随机种子影响收敛路径
• Dropout：如果使用了 dropout
• 采样噪声：batch 采样的随机性

# 估计噪声水平的实验：
# 固定 N=1B, D=20B，训练 5 次

seeds = [42, 123, 456, 789, 1024]
losses = []
for seed in seeds:
    model = train(N=1e9, D=20e9, seed=seed)
    losses.append(evaluate(model, val_set))

# 例: losses = [2.81, 2.79, 2.83, 2.80, 2.82]
# 均值 = 2.81, 标准差 = 0.015
# 这个噪声虽然小，但在拟合时不可忽略

Bootstrap 置信区间

给定拟合结果，如何量化不确定性？

from scipy.optimize import curve_fit
import numpy as np

def bootstrap_ci(N_data, loss_data, n_bootstrap=1000, alpha=0.05):
    """用 bootstrap 估计拟合参数的置信区间"""
    params_list = []
    n = len(N_data)

    for _ in range(n_bootstrap):
        # 有放回抽样
        indices = np.random.choice(n, size=n, replace=True)
        N_boot = N_data[indices]
        loss_boot = loss_data[indices]

        try:
            popt, _ = curve_fit(scaling_law, N_boot, loss_boot,
                                p0=[1e5, 0.1, 2.0])
            params_list.append(popt)
        except RuntimeError:
            continue  # 拟合失败则跳过

    params_array = np.array(params_list)
    # 计算每个参数的置信区间
    lower = np.percentile(params_array, 100 * alpha/2, axis=0)
    upper = np.percentile(params_array, 100 * (1 - alpha/2), axis=0)

    return lower, upper

外推的不确定性

外推（预测未训练过的尺度）的不确定性会指数增长：

幂律弯曲（Bend in the power law）

幂律假设 L ∝ N^{-α} 在所有尺度成立。但实际上：

• 小模型区域（< 1M）：模型太小，无法有效学习，loss 可能偏离幂律
• 中等模型（1M - 10B）：幂律通常在此区域成立
• 大模型区域（> 100B）：可能看到"饱和"效应——额外参数收益递减

# 检测幂律弯曲的方法：
# 1. 拟合后看残差（residuals）
# 2. 如果残差有系统性模式 → 幂律不完全成立

predicted = scaling_law(N_values, *popt)
residuals = losses - predicted

# 如果残差在某个 N 范围内系统性为正或负
# 说明该区域的实际 α 与拟合值不同

外推挑战

为什么要外推？

训练 70B 模型需要数百万美元。我们不可能训练 100 个不同大小的 70B 模型来找最优配置。所以必须：

1. 训练小模型（1M - 1B 范围，便宜）
2. 拟合 scaling law
3. 外推预测大模型（70B - 1T）的最优配置

外推的风险

降低外推风险的策略

策略 1：覆盖足够宽的尺度范围

策略 2：保守预测 + 区间估计

不要只给一个点估计，给出置信区间：

策略 3：中间验证

在拟合范围和外推目标之间，训练一个中等规模模型验证：

用 Scaling Law 做决策

场景 1：固定算力预算，最大化模型性能

这是 Chinchilla 论文解决的问题：

场景 2：考虑推理成本

Chinchilla 只优化了训练 loss，但实际部署时推理成本也很重要：

场景 3：固定时间，选择模型大小

实际约束往往是时间 + 硬件，而非 FLOPs：

场景 4：多目标权衡

实际决策需要同时考虑多个目标：

Beyond Chinchilla：数据质量与 Overtraining

Chinchilla 的核心假设

Chinchilla 假设所有 token 等价——每个 token 对降低 loss 的贡献相同。但这个假设在现实中不成立：

数据质量的影响

DCLM (DataComp-LM) 等研究表明，经过严格质量过滤的数据上训练，可以用更少的 token 达到相同 loss：

Overtraining 的合理性

有时故意 overtrain（D > 20N）也有好处：

• 更好的指令跟随：模型见过更多模式，泛化更好
• 更稳定的 RLHF：overtrained 模型对 reward model 更"听话"
• 记忆与泛化的平衡：某些任务（如代码）需要记忆 API
• DeepSeek-V3：使用了适度的 overtraining，D/N ≈ 25-30

Overtraining 的风险

Overtrain 过多也有代价：

• 训练成本增加：更多 GPU 小时
• 过拟合风险：验证 loss 开始上升
• 泛化下降：模型记住训练数据而非学习模式
• 评估污染：如果测试数据在训练集中，评估无效

实际的数据策略

拟合实战：完整流程

Step 1：实验设计

# 确定要变化的范围
# - N: 至少 10 个值，覆盖 2-3 个数量级
# - D: 每个 N 至少 3 个值（不同训练步数）
# - 其他超参：全部固定

model_sizes = [1e6, 3e6, 1e7, 3e7, 1e8, 3e8, 1e9, 3e9]
tokens_per_size = {
    1e6: [2e7, 5e7, 1e8],
    1e7: [2e8, 5e8, 1e9],
    # ... 每个 N 对应多个 D
}

# 总实验数: 8 × 3 = 24 个模型
# 如果每个模型训练成本 100 美元 → 总成本 2400 美元
# 这比训练一个 70B 模型便宜得多

Step 2：训练与记录

import json

results = []
for N in model_sizes:
    for D in tokens_per_size[N]:
        # 训练模型
        model = train_model(N=N, D=D, seed=42)

        # 记录结果
        results.append({
            "N": N,
            "D": D,
            "val_loss": evaluate(model, val_set),
            "train_loss": evaluate(model, train_set),
            "training_time": get_training_time(),
        })

# 保存结果
with open("scaling_results.json", "w") as f:
    json.dump(results, f, indent=2)

Step 3：拟合与验证

# 加载数据
results = json.load(open("scaling_results.json"))
N_data = np.array([r["N"] for r in results])
D_data = np.array([r["D"] for r in results])
loss_data = np.array([r["val_loss"] for r in results])

# 拟合联合模型
def joint_law(N, D, E, alpha, beta, A, B):
    return E + A * N ** (-alpha) + B * D ** (-beta)

popt, pcov = curve_fit(
    lambda x, E, alpha, beta, A, B: joint_law(x[0], x[1], E, alpha, beta, A, B),
    (N_data, D_data),
    loss_data,
    p0=[2.0, 0.1, 0.1, 10.0, 10.0]
)

# 检查拟合质量
predicted = joint_law(N_data, D_data, *popt)
r_squared = 1 - np.sum((loss_data - predicted)**2) / np.sum((loss_data - loss_data.mean())**2)
print(f"R² = {r_squared:.4f}")  # 希望 > 0.99

Step 4：预测最优配置

from scipy.optimize import minimize

C_target = 6 * 70e9 * 1.4e12  # 目标: 70B 模型, Chinchilla 推荐 1.4T tokens

def loss_at_optimal_D(N):
    """给定 N，计算最优 D 和对应 loss"""
    D_opt = C_target / (6 * N)  # 满足算力约束
    return joint_law(N, D_opt, *popt)

# 在合理范围内搜索最优 N
result = minimize(loss_at_optimal_D, x0=[70e9], bounds=[(1e9, 200e9)])
N_optimal = result.x[0]
D_optimal = C_target / (6 * N_optimal)

print(f"最优配置: N = {N_optimal:.2e}, D = {D_optimal:.2e}")
print(f"预测 loss: {result.fun:.4f}")

Scaling Laws 的深层局限

1. 只捕捉训练 loss，不捕捉能力

验证 loss 是连续、平滑的，但下游能力可能是"涌现"的——在某个尺度突然变得可用。Scaling law 无法预测这种相变。

2. 假设架构不变

拟合的 α 和 N_c 是针对特定架构的。如果改变 attention 类型（如 GQA）、使用 MoE、或改变激活函数，整个 scaling law 会变化。

3. 忽略推理效率

Chinchilla 的 70B 模型训练成本低于 GPT-3 175B，但推理成本更高（更多 tokens 需要处理）。对于推理密集型应用，Chinchilla 配置可能不是最优。

4. 数据质量不可控

Scaling law 假设我们可以获得任意多的高质量数据。但现实中高质量数据有限，低质量数据可能引入噪声或偏见。

5. 评估指标单一

只优化验证 loss，但实际关心的是下游任务表现（MMLU、HumanEval 等）。Loss 和下游任务之间有关联但不是完美相关。

知识检查

如果只能记住 5 件事

延伸阅读