| |
| """Shard eval_mlebench.py (or any repo command) across a GKE Indexed Job. |
| |
| # 20 comps x 3 arms x 10 repeats, one pod per (comp, 2-repeat chunk): |
| gke/.venv/bin/python gke/submit_eval.py submit --run r1 \ |
| --competitions-from-split both --arms all --repeats 10 --repeat-chunk 2 \ |
| --parallelism 50 |
| |
| # generic parallel command (rubric_gen experiments etc.); the shard sees |
| # SHARD_INDEX / SHARD_COUNT / MLEBENCH_DATA_DIR / WORK_DIR in its env: |
| gke/.venv/bin/python gke/submit_eval.py submit --run cf1 --mode cmd \ |
| --shards 40 --competitions-from-split both \ |
| --command 'cd rubric_gen && python counterfactual.py ... ' \ |
| --artifacts 'rubric_gen/results/*.json' |
| |
| gke/.venv/bin/python gke/submit_eval.py status --run r1 |
| gke/.venv/bin/python gke/submit_eval.py logs --run r1 --index 3 |
| gke/.venv/bin/python gke/submit_eval.py collect --run r1 |
| gke/.venv/bin/python gke/submit_eval.py cancel --run r1 |
| |
| The working tree ships as the code snapshot (git-tracked + untracked-unignored |
| files), so uncommitted changes run as-is. Each shard resumes from its own |
| previous rows on retry. Results merge locally into data/gke_runs/<run>.jsonl. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import sys |
| import time |
| from pathlib import Path |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parent)) |
| import k8s as K |
| import settings as S |
|
|
| REPO = Path(__file__).resolve().parents[1] |
| upload_code = K.upload_code |
|
|
|
|
| def job_name(run: str) -> str: |
| return f"eval-{run.lower().replace('_', '-')[:40].strip('-')}" |
|
|
|
|
| def build_shards(args) -> list[dict]: |
| comps: list[str] = [] |
| if args.competitions: |
| comps += [c.strip() for c in args.competitions.split(",") if c.strip()] |
| if args.competitions_from_split != "none": |
| sys.path.insert(0, str(REPO / "gke")) |
| from prep_datasets import split_sides |
|
|
| sides = split_sides() |
| comps += [c for c, s in sides.items() |
| if args.competitions_from_split in (s, "both")] |
|
|
| if args.mode == "cmd": |
| if not args.command: |
| raise SystemExit("--mode cmd needs --command") |
| n = args.shards or 1 |
| return [{"command": args.command, "shard_count": n, |
| "competitions": comps, |
| "artifacts": args.artifacts.split(",") if args.artifacts else []} |
| for _ in range(n)] |
|
|
| if not comps: |
| raise SystemExit("no competitions selected") |
| shards = [] |
| if args.repeats: |
| |
| |
| chunk = args.repeat_chunk or args.repeats |
| ranges = [(a + 1, min(a + chunk, args.repeats)) |
| for a in range(0, args.repeats, chunk)] |
| else: |
| ranges = [(None, None)] |
| for i in range(0, len(comps), args.group_size): |
| group = comps[i:i + args.group_size] |
| for start, end in ranges: |
| shard: dict = {"competitions": group} |
| if start is not None: |
| shard.update(repeats=args.repeats, repeat_start=start, |
| repeat_end=end) |
| shards.append(shard) |
| return shards |
|
|
|
|
| def cmd_submit(args) -> None: |
| shards = build_shards(args) |
| common = {"arms": args.arms, "run_cap": args.run_cap} |
| if args.db: |
| common["db"] = args.db |
| if args.eval_arg: |
| common["extra_args"] = args.eval_arg |
| manifest = {"run": args.run, "mode": args.mode, "common": common, |
| "shards": shards, "submitted_unix": int(time.time())} |
| S.bucket().blob(f"runs/{args.run}/manifest.json").upload_from_string( |
| json.dumps(manifest, indent=1)) |
| upload_code(args.run) |
|
|
| n = len(shards) |
| job = K.make_indexed_job( |
| name=job_name(args.run), run_id=args.run, mode=args.mode, |
| completions=n, parallelism=min(args.parallelism, n), |
| cpu=args.cpu, memory=args.memory, scratch_gi=args.scratch, |
| gpu=args.gpu or None, spot=args.spot, |
| ) |
| K.submit_job(job) |
| print(f"[ok] job {job.metadata.name}: {n} shards, parallelism " |
| f"{min(args.parallelism, n)}, cpu={args.cpu} mem={args.memory} " |
| f"scratch={args.scratch}Gi gpu={args.gpu or 'none'} spot={args.spot}") |
| print(f" shards preview: {json.dumps(shards[0])[:200]}") |
| print(f" status: gke/.venv/bin/python gke/submit_eval.py status --run {args.run}") |
|
|
|
|
| def cmd_status(args) -> None: |
| print(K.job_status(job_name(args.run))) |
| blobs = list(S.storage_client().list_blobs( |
| S.BUCKET, prefix=f"runs/{args.run}/shards/")) |
| done = sum(1 for b in blobs if b.name.endswith(".done")) |
| rows = 0 |
| for b in blobs: |
| if b.name.endswith(".jsonl") and not b.name.endswith(".gymlog.jsonl"): |
| rows += b.download_as_text().count("\n") |
| print(f"shards done: {done} | result rows so far: {rows}") |
|
|
|
|
| def cmd_logs(args) -> None: |
| print(K.pod_logs(job_name(args.run), index=args.index, tail=args.tail)) |
|
|
|
|
| def cmd_collect(args) -> None: |
| out_dir = REPO / "data" / "gke_runs" |
| out_dir.mkdir(parents=True, exist_ok=True) |
| out = out_dir / f"{args.run}.jsonl" |
| rows, shards = [], 0 |
| for b in S.storage_client().list_blobs(S.BUCKET, prefix=f"runs/{args.run}/shards/"): |
| if b.name.endswith(".jsonl") and not b.name.endswith(".gymlog.jsonl"): |
| rows += [l for l in b.download_as_text().splitlines() if l.strip()] |
| shards += 1 |
| out.write_text("\n".join(rows) + ("\n" if rows else "")) |
| print(f"[ok] {len(rows)} rows from {shards} shards -> {out}") |
|
|
|
|
| def cmd_cancel(args) -> None: |
| _, batch = S.kube_api() |
| batch.delete_namespaced_job( |
| name=job_name(args.run), namespace=S.NAMESPACE, |
| propagation_policy="Background") |
| print(f"[ok] deleted job {job_name(args.run)} (results in GCS are kept)") |
|
|
|
|
| def main() -> None: |
| ap = argparse.ArgumentParser() |
| sub = ap.add_subparsers(dest="cmd", required=True) |
| p = sub.add_parser("submit") |
| p.add_argument("--run", required=True) |
| p.add_argument("--mode", choices=("eval", "cmd"), default="eval") |
| p.add_argument("--competitions", default="") |
| p.add_argument("--competitions-from-split", |
| choices=("train", "eval", "both", "none"), default="none") |
| p.add_argument("--arms", default="all") |
| p.add_argument("--repeats", type=int, default=0) |
| p.add_argument("--repeat-chunk", type=int, default=0) |
| p.add_argument("--group-size", type=int, default=1, |
| help="Competitions per shard.") |
| p.add_argument("--run-cap", type=int, default=1800) |
| p.add_argument("--db", default="") |
| p.add_argument("--eval-arg", action="append", default=[], |
| help="Extra arg passed through to eval_mlebench.py (repeatable).") |
| p.add_argument("--command", default="") |
| p.add_argument("--shards", type=int, default=0, help="Shard count for --mode cmd.") |
| p.add_argument("--artifacts", default="", |
| help="Comma-separated globs uploaded after a cmd shard.") |
| p.add_argument("--parallelism", type=int, default=20) |
| p.add_argument("--cpu", default="4") |
| p.add_argument("--memory", default="16Gi") |
| p.add_argument("--scratch", type=int, default=100) |
| p.add_argument("--gpu", default="", help="e.g. nvidia-l4 or nvidia-tesla-t4") |
| p.add_argument("--spot", action="store_true") |
| for name in ("status", "logs", "collect", "cancel"): |
| q = sub.add_parser(name) |
| q.add_argument("--run", required=True) |
| q.add_argument("--index", type=int, default=None) |
| q.add_argument("--tail", type=int, default=100) |
| args = ap.parse_args() |
| {"submit": cmd_submit, "status": cmd_status, "logs": cmd_logs, |
| "collect": cmd_collect, "cancel": cmd_cancel}[args.cmd](args) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
