File size: 8,781 Bytes
89f52aa | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 | #!/usr/bin/env python
"""Fit the joint pretraining-RL scaling law from the T2/T2b sweep results.
Replicates arXiv:2607.16097 App. G at reduced scale on the 20M family:
1. Per RL run: OLS fit of pass@1 vs (log10 C_RL - log10 C_ref), C_ref = 1e20
(Eq. 7), giving per-run (R_ref, B).
2. Claim 4a: R_ref vs pretraining validation loss L_pt — Spearman rho and an
exponential fit f(L) = gamma + alpha*exp(-beta*L) (Eq. 8).
3. Claim 4b: local RL slope B vs log10 pretraining tokens T — Pearson r
(paper: +0.84 on B3-B4) and linear fit.
Two evaluation subsets are fit separately:
b3b4 = the paper's fitting bins (results/t2/); at our reduced measurement
scale these floor at zero (reported as a scale limitation).
b1b2 = the focused high-power sweep (results/t2b/), used because at our
scale nothing saturates and B1+B2 sits above the resolution floor.
C_RL estimation: C = 10 * N * T_rollout, T_rollout = 256 prompts x group 8 x
(L_prompt + L_resp) per step (paper App. D); a step-only sensitivity variant
is also reported since a constant multiplier affects R_ref levels but not
slopes.
"""
import argparse
import json
import os
import re
import numpy as np
from huggingface_hub import HfApi, hf_hub_download
from scipy import stats
from scipy.optimize import curve_fit
RESULTS_REPO = "ML-Intern-lab/pre2post-chess-replication"
C_REF = 1e20
N_PARAMS_20M = 20.5e6
PROMPTS_PER_STEP = 256
GROUP = 8
def load_results():
api = HfApi()
files = [f for f in api.list_repo_files(RESULTS_REPO, repo_type="dataset")
if f.startswith(("results/t2/", "results/t2b/")) and f.endswith(".json")]
runs = {}
for f in files:
p = hf_hub_download(RESULTS_REPO, f, repo_type="dataset")
d = json.load(open(p))
tag = os.path.basename(f)[:-5]
subset = "b1b2" if tag.startswith("t2b_") else "b3b4"
m = re.match(r"(?:t2b_|rl_)20m_([\dp]+)B_s(\d+)", tag)
if not m:
continue
tok_b = float(m.group(1).replace("p", "."))
step = int(m.group(2))
runs.setdefault((subset, tok_b), {})[step] = d["summary"]["pass1_mean_overall"]
return runs
def load_losses():
api = HfApi()
files = [f for f in api.list_repo_files(RESULTS_REPO, repo_type="dataset")
if f.startswith("results/loss/loss_model_20m_") and f.endswith(".json")]
losses = {}
for f in files:
p = hf_hub_download(RESULTS_REPO, f, repo_type="dataset")
d = json.load(open(p))
tok_b = d.get("pretrain_tokens", 0) / 1e9
losses[round(tok_b, 2)] = d["val_loss"]
return losses
def fit_exp(L, alpha, beta, gamma):
return gamma + alpha * np.exp(-beta * np.asarray(L))
def analyze(runs, losses, args, label):
per_run = []
for tok_b, curve in sorted(runs.items()):
steps = sorted(curve)
if len(steps) < 3:
print(f"[{label}] [skip] T={tok_b}B has {len(steps)} points")
continue
L = losses.get(round(tok_b, 2))
T_rollout_step = PROMPTS_PER_STEP * GROUP * (args.prompt_len + args.resp_len)
c_per_step = 10 * N_PARAMS_20M * T_rollout_step
x = np.array([np.log10(step * c_per_step) - np.log10(C_REF) for step in steps])
y = np.array([curve[s] for s in steps])
xs = np.log10(np.array(steps, dtype=float)) # step-only sensitivity fit
if float(y.max() - y.min()) < 1e-9:
B, R_ref, Bs, Rs = 0.0, float(y.mean()), 0.0, float(y.mean())
else:
A = np.vstack([np.ones_like(x), x]).T
(R_ref, B), *_ = np.linalg.lstsq(A, y, rcond=None)
As = np.vstack([np.ones_like(xs), xs]).T
(Rs, Bs), *_ = np.linalg.lstsq(As, y, rcond=None)
per_run.append({
"tokens": tok_b, "log10_tokens": float(np.log10(tok_b * 1e9)),
"loss": L, "steps": steps, "pass1": [float(v) for v in y],
"R_ref": float(R_ref), "B": float(B),
"R_ref_step": float(Rs), "B_step": float(Bs),
"pass1_last": float(y[-1]),
})
print(f"[{label}] T={tok_b:5.1f}B L={('%.3f' % L) if L else ' ? '} "
f"pass1={[round(float(v), 4) for v in y]} "
f"-> R_ref={R_ref:.4f} B={B:.5f}")
done = [r for r in per_run if r["loss"] is not None]
out = {"per_run": per_run}
# ---- claim 4a: R_ref vs pretraining loss --------------------------------
if len(done) >= 4:
Ls = np.array([r["loss"] for r in done])
Rs = np.array([r["R_ref"] for r in done])
rho, rho_p = stats.spearmanr(Ls, Rs)
popt = None
try:
popt, _ = curve_fit(fit_exp, Ls, Rs, p0=[100.0, 12.0, 0.03], maxfev=20000)
pred = fit_exp(Ls, *popt)
ss_res = float(((Rs - pred) ** 2).sum())
ss_tot = float(((Rs - Rs.mean()) ** 2).sum())
r2 = 1 - ss_res / ss_tot if ss_tot > 0 else float("nan")
except Exception as e:
r2 = float("nan")
print(f"[{label}] exp fit failed: {e}")
out["claim_R_ref_vs_loss"] = {
"spearman_rho": float(rho), "spearman_p": float(rho_p),
"exp_fit": {"alpha": float(popt[0]), "beta": float(popt[1]),
"gamma": float(popt[2]), "R2": r2} if popt is not None else None,
"paper": {"rho_range": "[-0.99, -0.93]",
"alpha_f": 129.85, "beta_f": 12.85, "gamma_f": 0.0314,
"R2_f": 0.980},
}
print(f"[{label}] Claim 4a (R_ref vs L): Spearman rho={rho:.3f} "
f"(paper -0.93..-0.99)")
# ---- claim 4a (no-extrapolation variant): pass@1 at fixed RL compute ----
# At our reduced scale the R_ref extrapolation to C_ref=1e20 is noise-
# dominated, so also correlate the MEASURED pass@1 at the last (and highest
# common) RL step with L. This is the same claim read without extrapolation.
if len(done) >= 4:
last = {}
for r in done:
last[r["tokens"]] = (r["loss"], r["pass1"][-1], r["steps"][-1])
Ls2 = np.array([v[0] for v in last.values()])
Rs2 = np.array([v[1] for v in last.values()])
rho2, rho2_p = stats.spearmanr(Ls2, Rs2)
r2_lin, r2_p = stats.pearsonr(Ls2, Rs2)
out["claim_R_ref_vs_loss_measured"] = {
"note": "pass@1 at the measured (non-extrapolated) final RL step vs L",
"points": {f"{t}B": {"loss": v[0], "pass1_last": v[1], "step": v[2]}
for t, v in last.items()},
"spearman_rho": float(rho2), "spearman_p": float(rho2_p),
"pearson_r": float(r2_lin), "pearson_p": float(r2_p),
"paper": {"rho_range": "[-0.99, -0.93]"},
}
print(f"[{label}] Claim 4a measured (pass1@last vs L): Spearman "
f"rho={rho2:.3f}, Pearson r={r2_lin:.3f}")
# ---- claim 4b: slope B vs log10 tokens ----------------------------------
if len(done) >= 4:
Ts = np.array([r["log10_tokens"] for r in done])
Bs = np.array([r["B"] for r in done])
r, r_p = stats.pearsonr(Ts, Bs)
rho_b, _ = stats.spearmanr(Ts, Bs)
slope, intercept = np.polyfit(Ts, Bs, 1)
pred = intercept + slope * Ts
ss_tot = float(((Bs - Bs.mean()) ** 2).sum())
r2 = 1 - float(((Bs - pred) ** 2).sum()) / ss_tot if ss_tot > 0 else float("nan")
out["claim_B_vs_logT"] = {
"pearson_r": float(r), "p": float(r_p), "spearman_rho": float(rho_b),
"linear_fit": {"slope_per_decade_tokens": float(slope),
"intercept": float(intercept), "R2": r2},
"paper": {"pearson_r": 0.84},
}
print(f"[{label}] Claim 4b (B vs log T): Pearson r={r:.3f} (paper +0.84), "
f"slope={slope:.5f}/decade, R2={r2:.3f}")
return out
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--resp-len", type=float, default=1400.0,
help="assumed mean RL response tokens per rollout")
ap.add_argument("--prompt-len", type=float, default=300.0)
ap.add_argument("--out", default="fit_results.json")
args = ap.parse_args()
runs = load_results()
losses = load_losses()
print(f"RL runs: {sorted(runs)}")
print(f"losses: {sorted(losses)}")
out = {"config": vars(args), "subsets": {}}
for subset in ("b1b2", "b3b4"):
sub = {t: curve for (s, t), curve in runs.items() if s == subset}
if not sub:
print(f"[skip] no data for subset {subset}")
continue
out["subsets"][subset] = analyze(sub, losses, args, subset)
with open(args.out, "w") as f:
json.dump(out, f, indent=2, default=float)
print(f"\nwrote {args.out}")
if __name__ == "__main__":
main()
|