| |
| """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)) |
| 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} |
|
|
| |
| 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)") |
|
|
| |
| |
| |
| |
| 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}") |
|
|
| |
| 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() |
|
|
