File size: 9,052 Bytes
eeaa10a | 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 | """Evaluate one actor on many cases: run_case.py per case (up to --jobs at once), then the environment check of
every run, then one table.
python scripts/run_batch.py --cases cases/02*/case.yaml --n-runs 1 \
--actor-agent codex --actor-model deepseek-chat \
--env-model claude-sonnet-5-5 --judge-model claude-opus-5-5 \
--actor-timeout-s 10800 --checkpoints case --jobs 2 --out runs --env-check-scratch /tmp/twinlab_env_check
Output: the usual run dirs under <out>/<case_id>/, plus <out>/batches/<timestamp>/ with one log per case and
attempt and batch_summary.json. Invalid runs are rerun up to MAX_ATTEMPTS times; see run_one.
"""
import argparse
import json
import subprocess
import sys
import time
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT)) # run from a checkout without installing
from twinlab.actors import AGENTS # noqa: E402
from twinlab.case import CHECKPOINT_MODES, Case # noqa: E402
from twinlab.env_check import check_env # noqa: E402
from twinlab.scale import round1 # noqa: E402
ACTOR_EFFORTS = ["low", "medium", "high", "xhigh", "max"] # same list as run_case.py (claude --effort levels)
ROOT_LINE = "[run_case] " # run_case.py prints its output dir on this line (after the [case] line)
MAX_ATTEMPTS = 3 # run_case.py calls per case while runs are judged invalid; then the missing runs score 0
def run_attempt(case: Case, a, n_runs: int, log: Path) -> dict:
"""One run_case.py call with n_runs runs, then the environment check of each run."""
cmd = [sys.executable, "-u", str(ROOT / "scripts/run_case.py"), "--case", str(case.path),
"--n-runs", str(n_runs), "--actor-agent", a.actor_agent, "--actor-model", a.actor_model,
"--env-model", a.env_model, "--judge-model", a.judge_model, "--actor-timeout-s", str(a.actor_timeout_s),
"--checkpoints", a.checkpoints, "--out", str(a.out),
*(["--actor-effort", a.actor_effort] if a.actor_effort is not None else [])]
print(f"[batch] start {case.id} (log {log})", flush=True)
with open(log, "w") as f:
rc = subprocess.run(cmd, stdout=f, stderr=subprocess.STDOUT, cwd=ROOT).returncode
roots = [line[len(ROOT_LINE):] for line in log.read_text().splitlines() if line.startswith(ROOT_LINE)]
assert len(roots) <= 1, f"{log}: several output dirs {roots}"
root = Path(roots[0]) if roots else None
att = {"rc": rc, "root": str(root), "log": str(log)}
if root is None:
print(f"[batch] {case.id} FAILED before any run (rc={rc}); see {log}", flush=True)
return att
checks = {}
for run_dir in sorted(root.glob("run_*")):
if (run_dir / "env_session.jsonl").is_file():
rep = check_env(run_dir, a.env_check_scratch / case.id / root.name / run_dir.name,
run_dir / "env_session.jsonl")
checks[run_dir.name] = {"problems": len(rep["problems"]), "to_read": len(rep["to_read"])}
summary = json.loads((root / "summary.json").read_text()) if (root / "summary.json").is_file() else {}
att.update(unfinished=summary.get("unfinished"), env_check=checks,
results=[json.loads(p.read_text()) for p in sorted(root.glob("run_*/result.json"))])
return att
def run_one(case: Case, a, logs: Path) -> dict:
"""a.n_runs valid runs of a case. Runs judged invalid (environment flag or contamination) are rerun, up to
MAX_ATTEMPTS run_case.py calls in all; a slot still without a valid run after that scores 0 (derived_100 0,
pass false) and keeps its place in the mean (user 2026-11-18). A stopped run (rc != 0 or unfinished) ends the
attempts: it is resumed by hand, never rerun."""
valid, invalid, attempts = [], [], []
for k in range(1, MAX_ATTEMPTS + 1):
missing = a.n_runs - len(valid)
log = logs / (f"{case.id}.log" if k == 1 else f"{case.id}.attempt{k}.log")
att = run_attempt(case, a, missing, log)
attempts.append({x: att.get(x) for x in ("rc", "root", "log", "unfinished", "env_check")})
for r in att.get("results", []):
(valid if r["valid"] else invalid).append({"root": att["root"], "run": r["run"], "score": r["score"]})
if att["rc"] != 0 or att.get("unfinished") or att["root"] == "None":
break
if len(valid) == a.n_runs:
break
print(f"[batch] {case.id}: attempt {k} left {a.n_runs - len(valid)} of {a.n_runs} runs without a valid "
f"result" + ("; rerunning" if k < MAX_ATTEMPTS else f"; {MAX_ATTEMPTS} attempts used, scored 0"),
flush=True)
last = attempts[-1]
stopped = last["rc"] != 0 or bool(last["unfinished"]) or last["root"] == "None"
row = {"case": case.id, "rc": last["rc"], "root": last["root"], "log": last["log"], "unfinished": last["unfinished"],
"attempts": attempts, "n_runs": a.n_runs, "n_valid": len(valid),
"n_invalid_runs": len(invalid), "invalid_runs": [f"{x['root']}/{x['run']}" for x in invalid]}
if stopped: # not final: the stopped run is resumed by hand
row.update({"n_scored_0": None, "pass@1": None, "mean_score": None, "mean_cost_used": None})
else:
n0 = a.n_runs - len(valid)
row.update({"n_scored_0": n0,
"pass@1": sum(v["score"]["pass"] for v in valid) / a.n_runs,
"mean_score": round1(sum(v["score"]["derived_100"] for v in valid) / a.n_runs),
"mean_cost_used": (sum(v["score"]["cost_used"] for v in valid) / len(valid)) if valid else None})
print(f"[batch] done {case.id}: attempts={len(attempts)} pass@1={row['pass@1']} mean_score={row['mean_score']} "
f"valid={len(valid)}/{a.n_runs} invalid_runs={len(invalid)} scored_0={row['n_scored_0']}", flush=True)
return row
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--cases", required=True, nargs="+", type=Path, help="case.yaml paths (shell globs are fine)")
ap.add_argument("--n-runs", required=True, type=int)
ap.add_argument("--actor-agent", required=True, choices=sorted(AGENTS))
ap.add_argument("--actor-model", required=True)
ap.add_argument("--actor-effort", choices=ACTOR_EFFORTS,
help="omit for the CLI default of this model (machine.yaml actor_default_effort)")
ap.add_argument("--env-model", required=True)
ap.add_argument("--judge-model", required=True)
ap.add_argument("--actor-timeout-s", required=True, type=int)
ap.add_argument("--checkpoints", required=True, choices=CHECKPOINT_MODES)
ap.add_argument("--jobs", required=True, type=int, help="cases evaluated at the same time")
ap.add_argument("--out", required=True, type=Path)
ap.add_argument("--env-check-scratch", required=True, type=Path, help="dir outside runs/ and cases/")
a = ap.parse_args()
a.out = a.out.resolve()
cases = [Case(p, a.checkpoints) for p in a.cases] # every case must load before anything runs
batch = a.out / "batches" / time.strftime("%Y%m%d-%H%M%S")
(batch / "logs").mkdir(parents=True)
(batch / "batch_config.json").write_text(json.dumps({**vars(a), "cases": [str(c.path) for c in cases]},
indent=1, default=str))
print(f"[batch] {len(cases)} cases, {a.jobs} at a time -> {batch}", flush=True)
with ThreadPoolExecutor(max_workers=a.jobs) as pool:
rows = list(pool.map(lambda c: run_one(c, a, batch / "logs"), cases))
(batch / "batch_summary.json").write_text(json.dumps(rows, indent=1))
print(f"\n{'case':40s} {'rc':>3s} {'valid':>7s} {'tries':>5s} {'pass@1':>7s} {'score':>7s} {'cost':>7s}")
for r in rows:
print(f"{r['case']:40s} {r['rc']:3d} {str(r['n_valid']) + '/' + str(r['n_runs']):>7s} "
f"{len(r['attempts']):5d} {str(r['pass@1']):>7s} {str(r['mean_score']):>7s} "
f"{str(r['mean_cost_used']):>7s}")
done = [r for r in rows if r["mean_score"] is not None]
if len(done) == len(rows): # every case final: invalid-after-retries slots are in as 0, the divisor is all cases
print(f"[batch] mean score over {len(rows)} cases: {round1(sum(r['mean_score'] for r in rows) / len(rows))}")
print(f"[batch] summary: {batch / 'batch_summary.json'}")
# a stopped run (gateway outage, harness assert, timeout) is reported and the batch exits non-zero, so the caller
# sees it (stop on errors with the log, resume by hand; no automatic resume)
stopped = [r for r in rows if r["rc"] != 0 or r.get("unfinished")]
if stopped:
print(f"\n[batch] {len(stopped)} case(s) did not finish:", flush=True)
for r in stopped:
print(f" {r['case']}: rc={r['rc']} unfinished={r.get('unfinished')} log={r['log']} root={r['root']}")
print(f" resume: python scripts/resume_run.py --run-dir {r['root']}/<run>")
sys.exit(1)
if __name__ == "__main__":
main()
|