Upload alea/loop.py with huggingface_hub

alea/loop.py

@@ -0,0 +1,131 @@
+"""Iterative training loop: generate -> train -> eval -> repeat.
+
+Each round generates a FRESH corpus (new seed -> new instances), trains from
+the previous round's checkpoint, and evaluates on a FIXED test set so metrics
+are comparable across rounds. Appends to runs/loop_history.jsonl.
+
+Usage:
+  python -m alea.loop --rounds 4 --init runs\alea_v3\final.pt
+"""
+import argparse
+import json
+import os
+import subprocess
+import sys
+import time
+
+
+def run(cmd, **kw):
+    print("+", " ".join(cmd), flush=True)
+    return subprocess.run(cmd, **kw)
+
+
+def gen_corpus(round_idx, n, out_path, shares, seed_base):
+    from .gen_all import build
+    rows = build(n, seed=seed_base + round_idx, shares=shares)
+    from .genbase import write_jsonl
+    write_jsonl(rows, out_path)
+    return len(rows)
+
+
+def eval_metrics(ckpt, test_path, max_items=1500):
+    r = run([sys.executable, "-m", "alea.eval", "--ckpt", ckpt,
+             "--data", test_path, "--max-items", str(max_items),
+             "--skip-structural"], capture_output=True, text=True)
+    out = r.stdout
+    start = out.find("{")
+    end = out.rfind("}") + 1
+    if start < 0 or end <= start:
+        print(out[-2000:], r.stderr[-2000:])
+        return {}
+    try:
+        return json.loads(out[start:end])
+    except json.JSONDecodeError:
+        print(out[-2000:])
+        return {}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--rounds", type=int, default=4)
+    ap.add_argument("--init", required=True, help="starting checkpoint")
+    ap.add_argument("--n-per-round", type=int, default=60000)
+    ap.add_argument("--epochs-per-round", type=float, default=1.0)
+    ap.add_argument("--batch", type=int, default=16)
+    ap.add_argument("--accum", type=int, default=2)
+    ap.add_argument("--test", default="data/test_loop.jsonl")
+    ap.add_argument("--shares", default=None)
+    ap.add_argument("--lr-head", type=float, default=1e-4)
+    ap.add_argument("--lr-backbone", type=float, default=1e-5)
+    ap.add_argument("--eval-items", type=int, default=1500)
+    ap.add_argument("--history", default="runs/loop_history.jsonl")
+    args = ap.parse_args()
+
+    env = dict(os.environ)
+    env.setdefault("PYTHONIOENCODING", "utf-8")
+
+    shares = json.loads(args.shares) if args.shares else {
+        "gen_stoch": 0.9, "gen_enterprise": 1.0, "gen_structured": 0.8,
+        "gen_adversarial": 0.6, "gen_numeric": 0.7, "gen_long": 0.5,
+        "base": 0.4, "gen_kaggle_cls": 1.0, "gen_kaggle_reg": 0.7,
+        "gen_hf": 1.3}
+    # drop shares for modules that don't exist yet
+    from . import gen_all
+    avail = gen_all.sources()
+    shares = {k: w for k, w in shares.items() if k in avail}
+    print("active sources:", shares, flush=True)
+
+    # fixed test set for comparable metrics across rounds
+    if not os.path.exists(args.test):
+        print("generating fixed loop test set...", flush=True)
+        rows = gen_all.build(3000, seed=777, shares=shares)
+        from .genbase import write_jsonl
+        write_jsonl(rows, args.test)
+        print(f"  wrote {len(rows)} -> {args.test}", flush=True)
+
+    ckpt = args.init
+    prev_loop_ckpt = None
+    for r in range(args.rounds):
+        t0 = time.time()
+        print(f"\n===== ROUND {r} (init={ckpt}) =====", flush=True)
+        corpus = f"data/loop_train_r{r}.jsonl"
+        if not os.path.exists(corpus):
+            n = gen_corpus(r, args.n_per_round, corpus, shares,
+                           seed_base=1000)
+            print(f"corpus: {n} rows -> {corpus}", flush=True)
+        else:
+            print(f"corpus exists: {corpus}", flush=True)
+
+        outdir = f"runs/loop_r{r}"
+        run([sys.executable, "-m", "alea.train",
+             "--train", corpus, "--dev", args.test,
+             "--out", outdir, "--init-from", ckpt,
+             "--train-mode", "full",
+             "--epochs", str(args.epochs_per_round),
+             "--batch", str(args.batch), "--accum", str(args.accum),
+             "--lr-head", str(args.lr_head),
+             "--lr-backbone", str(args.lr_backbone),
+             "--attn", "sdpa", "--save-every", "100000",
+             "--max-len", "4096"], env=env)
+        ckpt = os.path.join(outdir, "final.pt")
+        if not os.path.exists(ckpt):
+            print(f"ROUND {r} TRAIN FAILED - stopping", flush=True)
+            break
+        # keep only the newest loop checkpoint (each ~1.3GB); the --init
+        # base is outside runs/loop_* and untouched
+        if prev_loop_ckpt and os.path.exists(prev_loop_ckpt):
+            os.remove(prev_loop_ckpt)
+        prev_loop_ckpt = ckpt
+
+        m = eval_metrics(ckpt, args.test, args.eval_items)
+        rec = {"round": r, "ckpt": ckpt, "minutes":
+               round((time.time() - t0) / 60, 1), **m}
+        with open(args.history, "a", encoding="utf-8") as fh:
+            fh.write(json.dumps(rec) + "\n")
+        print(f"ROUND {r} METRICS {json.dumps(m)}", flush=True)
+
+    print("\nloop done. history:", args.history)
+
+
+if __name__ == "__main__":
+    main()