| """Full-batch Euclidean GD on the squared loss from small initialisation. |
| |
| Reproduces Figures 2a/2b/2c of arXiv:2602.02431 and audits Theorem 4.1 (Claim 3) |
| and the two-phase trajectory decomposition of Section 4 (Claim 4). |
| |
| sigma(z) = min(z^2, M), M = 8, eta = 0.1 / M^2, delta = n/d = 10, |
| theta_0 ~ Unif(r0 * S^{d-1}), r0 in {d^-2 (paper figures), d^-15 (Theorem 4.1)}. |
| |
| All runs are float64 so that r0 = d^-15 (down to ~1e-54) does not underflow. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import json |
| import math |
| import os |
| import sys |
| import time |
|
|
| import torch |
|
|
| sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) |
| import sim |
|
|
|
|
| def main(): |
| p = argparse.ArgumentParser() |
| p.add_argument("--act", default="trunc", choices=["quad", "trunc", "smooth"]) |
| p.add_argument("--dims", default="64,128,256,512,1024,2048,4096") |
| p.add_argument("--seeds", default="8", help="int, or one value per dim") |
| p.add_argument("--M", type=float, default=8.0) |
| p.add_argument("--delta", type=float, default=10.0) |
| p.add_argument("--eta-c", type=float, default=0.1, help="eta = c / M^2") |
| p.add_argument("--r0-exp", type=float, default=2.0, help="r0 = d^-exp") |
| p.add_argument("--T", type=int, default=6000) |
| p.add_argument("--record-every", type=int, default=5) |
| p.add_argument("--stop-err", type=float, default=1e-13) |
| p.add_argument("--out-prefix", required=True) |
| args = p.parse_args() |
|
|
| dev = "cuda" if torch.cuda.is_available() else "cpu" |
| dims = [int(v) for v in args.dims.split(",")] |
| seed_list = [int(v) for v in args.seeds.split(",")] |
| if len(seed_list) == 1: |
| seed_list = seed_list * len(dims) |
| assert len(seed_list) == len(dims) |
| eta = args.eta_c / (args.M ** 2) |
| traj_rows, summ_rows = [], [] |
| t_start = time.time() |
| for d, nseeds in zip(dims, seed_list): |
| n = int(round(args.delta * d)) |
| r0 = float(d) ** (-args.r0_exp) |
| for s in range(nseeds): |
| seed = 90000 + 137 * d + s |
| t0 = time.time() |
| data = sim.make_data(d, n, seed, args.act, args.M, dev, torch.float64) |
| th0 = sim.rand_sphere(d, 800_000 + seed, dev, torch.float64) * r0 |
| rec = sim.squared_gd( |
| data, th0, args.act, args.M, eta, args.T, |
| record_every=args.record_every, stop_err=args.stop_err, |
| ) |
| for i in range(len(rec["step"])): |
| traj_rows.append(dict( |
| act=args.act, d=d, delta=args.delta, M=args.M, eta=eta, |
| r0_exp=args.r0_exp, seed=seed, step=rec["step"][i], |
| sq_overlap=rec["sq_overlap"][i], norm=rec["norm"][i], |
| dist2=rec["dist2"][i], loss=rec["loss"][i])) |
| summ_rows.append(dict( |
| act=args.act, d=d, n=n, delta=args.delta, M=args.M, eta=eta, |
| r0_exp=args.r0_exp, r0=r0, seed=seed, |
| steps_run=rec["step"][-1], final_sq_overlap=rec["sq_overlap"][-1], |
| final_norm=rec["norm"][-1], final_dist2=rec["dist2"][-1], |
| final_loss=rec["loss"][-1], secs=round(time.time() - t0, 2))) |
| del data |
| torch.cuda.empty_cache() if dev == "cuda" else None |
| fin = [r["final_dist2"] for r in summ_rows if r["d"] == d] |
| stp = [r["steps_run"] for r in summ_rows if r["d"] == d] |
| print(f"[{time.time()-t_start:7.1f}s] d={d:5d} n={n} r0={r0:.3e} " |
| f"median dist2={sorted(fin)[len(fin)//2]:.3e} median steps={sorted(stp)[len(stp)//2]}", |
| flush=True) |
|
|
| with open(args.out_prefix + "_traj.csv", "w", newline="") as f: |
| w = csv.DictWriter(f, fieldnames=list(traj_rows[0].keys())) |
| w.writeheader() |
| w.writerows(traj_rows) |
| with open(args.out_prefix + "_summary.csv", "w", newline="") as f: |
| w = csv.DictWriter(f, fieldnames=list(summ_rows[0].keys())) |
| w.writeheader() |
| w.writerows(summ_rows) |
| print(f"wrote {args.out_prefix}_{{traj,summary}}.csv " |
| f"({len(traj_rows)} traj rows, {time.time()-t_start:.1f}s)") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
