| |
| """Batch runner for the baseline RealSR agent. |
| |
| Runs `run_baseline.py` across many tasks/models/modes, writes incremental |
| summaries, and optionally dispatches the parallel structure judge after |
| simulator submissions finish. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import concurrent.futures |
| import csv |
| import json |
| import os |
| import subprocess |
| import sys |
| import threading |
| import time |
| from collections import Counter, defaultdict |
| from datetime import datetime, timezone |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| REPO = Path(__file__).resolve().parent.parent |
| BASELINE_DIR = Path(__file__).resolve().parent |
| RUN_BASELINE = BASELINE_DIR / "run_baseline.py" |
| HARNESS_DIR = REPO / "harness" |
|
|
| sys.path.insert(0, str(REPO)) |
| sys.path.insert(0, str(BASELINE_DIR)) |
| sys.path.insert(0, str(HARNESS_DIR)) |
|
|
| from call_llm_api import resolve_model_and_source |
| import evaluate_numeric as _ev |
| import eval_formula as _ef |
|
|
|
|
| FIELDNAMES = [ |
| "run_id", |
| "model", |
| "mode", |
| "type", |
| "task", |
| "task_dir", |
| "max_turns", |
| "include_test_range", |
| "returncode", |
| "status", |
| "submitted", |
| "qualified_submission", |
| "numeric_score", |
| "raw_numeric_score", |
| "numeric_score_std", |
| "metric", |
| "score_status", |
| "contract_ok", |
| "rounds", |
| "total_tokens", |
| "n_experiments", |
| "n_python_calls", |
| "active_rows", |
| "elapsed_seconds", |
| "submission_path", |
| "trajectory_path", |
| "numeric_path", |
| "log_path", |
| "error", |
| ] |
|
|
|
|
| def _utc_stamp() -> str: |
| return datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S") |
|
|
|
|
| def _json_default(obj: Any) -> Any: |
| try: |
| import numpy as np |
|
|
| if isinstance(obj, np.generic): |
| return obj.item() |
| if isinstance(obj, np.ndarray): |
| return obj.tolist() |
| except Exception: |
| pass |
| if isinstance(obj, Path): |
| return str(obj) |
| return str(obj) |
|
|
|
|
| def _write_json(path: Path, payload: Any) -> None: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| tmp = path.with_suffix(path.suffix + ".tmp") |
| tmp.write_text(json.dumps(payload, indent=2, sort_keys=True, default=_json_default) + "\n") |
| os.replace(tmp, path) |
|
|
|
|
| def _read_json(path: Path) -> dict[str, Any]: |
| try: |
| return json.loads(path.read_text(encoding="utf-8")) |
| except Exception: |
| return {} |
|
|
|
|
| def _tasks(tasks_dir: Path, task_types: list[str]) -> list[dict[str, Any]]: |
| out: list[dict[str, Any]] = [] |
| for task_type in task_types: |
| for meta in sorted((tasks_dir / task_type).glob("*/metadata.yaml")): |
| task_dir = meta.parent |
| out.append({ |
| "type": task_type, |
| "task": task_dir.name, |
| "task_dir": task_dir, |
| }) |
| return out |
|
|
|
|
| def _read_summary_rows(summary_tsv: Path) -> list[dict[str, Any]]: |
| if not summary_tsv.exists(): |
| return [] |
| with summary_tsv.open(newline="", encoding="utf-8") as fh: |
| return list(csv.DictReader(fh, delimiter="\t")) |
|
|
|
|
| def _row_key(row: dict[str, Any]) -> tuple[str, str, str, str]: |
| return ( |
| row.get("model", ""), |
| row.get("mode", ""), |
| row.get("type", ""), |
| row.get("task", ""), |
| ) |
|
|
|
|
| def _float_or_blank(value: Any) -> str: |
| if value is None or value == "": |
| return "" |
| try: |
| return str(float(value)) |
| except Exception: |
| return "" |
|
|
|
|
| def _json_from_mixed_output(text: str) -> dict[str, Any]: |
| """Extract the first JSON object from scorer output. |
| |
| Some numeric submissions trigger low-level BLAS/LAPACK warnings that write |
| directly to stdout around the JSON emitted by evaluate_numeric.py. The |
| scorer result is still valid; parse the JSON prefix and ignore trailing |
| warning text. |
| """ |
| decoder = json.JSONDecoder() |
| start = text.find("{") |
| if start < 0: |
| raise ValueError("no JSON object found in scorer output") |
| obj, _ = decoder.raw_decode(text[start:]) |
| if not isinstance(obj, dict): |
| raise ValueError("scorer output JSON is not an object") |
| return obj |
|
|
|
|
| def _score_typeii_submission_subprocess(task_dir: Path, submission_path: Path) -> dict[str, Any]: |
| """Run Type II numeric scoring in a child process. |
| |
| Type II scoring uses signal.alarm() for per-cluster fit timeouts. Python |
| only allows signal handlers in the main thread, while run_batch scores |
| jobs from ThreadPoolExecutor workers. Running the official scorer in a |
| child process keeps that signal logic in the child's main thread. |
| """ |
| cmd = [ |
| sys.executable, |
| str(HARNESS_DIR / "evaluate_numeric.py"), |
| "score", |
| str(task_dir), |
| str(submission_path), |
| ] |
| proc = subprocess.run( |
| cmd, |
| cwd=REPO, |
| text=True, |
| stdout=subprocess.PIPE, |
| stderr=subprocess.PIPE, |
| ) |
| try: |
| result = _json_from_mixed_output(proc.stdout) |
| except Exception as exc: |
| return { |
| "status": "score_error", |
| "contract_ok": False, |
| "numeric_score": 0.0, |
| "raw_numeric_score": None, |
| "numeric_score_std": 0.0, |
| "error": ( |
| f"numeric scorer subprocess failed to produce parseable JSON " |
| f"(returncode={proc.returncode}): {type(exc).__name__}: {exc}" |
| ), |
| "stdout_tail": proc.stdout[-2000:], |
| "stderr_tail": proc.stderr[-2000:], |
| } |
| if proc.returncode != 0: |
| result.setdefault("status", "score_error") |
| result.setdefault("contract_ok", False) |
| result.setdefault("numeric_score", 0.0) |
| result.setdefault("raw_numeric_score", None) |
| result["subprocess_returncode"] = proc.returncode |
| result["stderr_tail"] = proc.stderr[-2000:] |
| return result |
|
|
|
|
| def _score_real_submission(task_dir: Path, submission_path: Path, |
| include_test_range: bool, numeric_path: Path) -> dict[str, Any]: |
| del include_test_range |
| if not submission_path.exists(): |
| return { |
| "numeric_score": "", |
| "raw_numeric_score": "", |
| "numeric_score_std": "", |
| "metric": "", |
| "score_status": "missing_submission", |
| "contract_ok": "", |
| } |
| try: |
| meta = _ev.load_task(task_dir) |
| task_type = meta.get("type", "typeII") |
| ref_path = _ev.reference_metrics_path(task_dir) |
| if not ref_path.exists(): |
| result = { |
| "status": "no_reference", |
| "contract_ok": None, |
| "numeric_score": 0.0, |
| "raw_numeric_score": None, |
| "numeric_score_std": 0.0, |
| "numeric_score_per_seed": ( |
| [0.0] if task_type == "typeI" else [0.0] * _ev.N_SEEDS |
| ), |
| "error": f"{ref_path} missing", |
| } |
| elif task_type == "typeII": |
| result = _score_typeii_submission_subprocess(task_dir, submission_path.resolve()) |
| else: |
| ref_metrics = json.loads(ref_path.read_text(encoding="utf-8")) |
| data = _ef.load_flat(task_dir) |
| mod = _ev.load_submission(submission_path.resolve()) |
| result = _ev.score_one( |
| mod, submission_path.name, data, ref_metrics, meta, {} |
| ) |
| _write_json(numeric_path, result) |
| score_obj = result.get("score") if isinstance(result.get("score"), dict) else {} |
| return { |
| "numeric_score": _float_or_blank(result.get("numeric_score")), |
| "raw_numeric_score": _float_or_blank(result.get("raw_numeric_score")), |
| "numeric_score_std": _float_or_blank(result.get("numeric_score_std")), |
| "metric": result.get("metric") or score_obj.get("metric") or "", |
| "score_status": result.get("status") or "", |
| "contract_ok": str(bool(result.get("contract_ok"))).lower(), |
| } |
| except Exception as exc: |
| payload = { |
| "status": "score_error", |
| "contract_ok": False, |
| "numeric_score": 0.0, |
| "raw_numeric_score": None, |
| "error": f"{type(exc).__name__}: {exc}", |
| } |
| _write_json(numeric_path, payload) |
| return { |
| "numeric_score": "0.0", |
| "raw_numeric_score": "", |
| "numeric_score_std": "0.0", |
| "metric": "", |
| "score_status": "score_error", |
| "contract_ok": "false", |
| } |
|
|
|
|
| def _score_info_from_numeric(numeric_path: Path) -> dict[str, Any] | None: |
| result = _read_json(numeric_path) |
| if not result: |
| return None |
| score_obj = result.get("score") if isinstance(result.get("score"), dict) else {} |
| return { |
| "numeric_score": _float_or_blank(result.get("numeric_score")), |
| "raw_numeric_score": _float_or_blank(result.get("raw_numeric_score")), |
| "numeric_score_std": _float_or_blank(result.get("numeric_score_std")), |
| "metric": result.get("metric") or score_obj.get("metric") or "", |
| "score_status": result.get("status") or "", |
| "contract_ok": str(bool(result.get("contract_ok"))).lower(), |
| } |
|
|
|
|
| def _row_from_traj(traj_path: Path) -> dict[str, Any]: |
| payload = _read_json(traj_path) |
| trial = payload.get("trial") or {} |
| experiment_log = trial.get("experiment_log") or [] |
| active_rows = "" |
| if trial.get("train_rows_current") is not None and experiment_log is not None: |
| active_rows = str(trial.get("train_rows_current")) |
| return { |
| "status": trial.get("status") or "", |
| "rounds": trial.get("rounds") or "", |
| "total_tokens": trial.get("total_tokens") or "", |
| "n_experiments": trial.get("n_experiments") or 0, |
| "n_python_calls": trial.get("n_python_calls") or 0, |
| "active_rows": active_rows, |
| } |
|
|
|
|
| def _job_paths(job: dict[str, Any], args: argparse.Namespace) -> dict[str, Path]: |
| model = job["model"] |
| mode = job["mode"] |
| task_type = job["type"] |
| task_name = job["task"] |
|
|
| sub_dir = args.run_dir / mode / "submissions" / model / task_type |
| traj_dir = args.run_dir / mode / "trajectories" / model / task_type |
| log_dir = args.run_dir / mode / "logs" / model / task_type |
| numeric_dir = args.run_dir / mode / "numeric" / model / task_type |
| for path in (sub_dir, traj_dir, log_dir, numeric_dir): |
| path.mkdir(parents=True, exist_ok=True) |
|
|
| submission_path = sub_dir / f"{task_name}.py" |
| traj_path = traj_dir / f"{task_name}.traj.json" |
| log_path = log_dir / f"{task_name}.log" |
| numeric_path = numeric_dir / f"{task_name}.json" |
| return { |
| "sub_dir": sub_dir, |
| "traj_dir": traj_dir, |
| "log_dir": log_dir, |
| "numeric_dir": numeric_dir, |
| "submission_path": submission_path, |
| "traj_path": traj_path, |
| "log_path": log_path, |
| "numeric_path": numeric_path, |
| } |
|
|
|
|
| def _submission_nonempty(submission_path: Path) -> bool: |
| return ( |
| submission_path.exists() |
| and submission_path.read_text(encoding="utf-8", errors="replace").strip() != "" |
| ) |
|
|
|
|
| def _is_qualified(mode: str, submitted: bool, score_info: dict[str, Any]) -> bool: |
| if mode == "real": |
| return ( |
| submitted |
| and score_info.get("contract_ok") == "true" |
| and score_info.get("score_status") not in {"contract_fail", "exec_error", "score_error"} |
| ) |
| return submitted |
|
|
|
|
| def _existing_row(job: dict[str, Any], args: argparse.Namespace) -> dict[str, Any] | None: |
| model = job["model"] |
| mode = job["mode"] |
| task_type = job["type"] |
| task_name = job["task"] |
| task_dir = Path(job["task_dir"]) |
| include_range = bool(args.include_range and mode == "real") |
| paths = _job_paths(job, args) |
| submission_path = paths["submission_path"] |
| traj_path = paths["traj_path"] |
| log_path = paths["log_path"] |
| numeric_path = paths["numeric_path"] |
|
|
| submitted = _submission_nonempty(submission_path) |
| if not submitted: |
| return None |
|
|
| score_info = { |
| "numeric_score": "", |
| "raw_numeric_score": "", |
| "numeric_score_std": "", |
| "metric": "", |
| "score_status": "", |
| "contract_ok": "", |
| } |
| if mode == "real": |
| score_info = ( |
| _score_info_from_numeric(numeric_path) |
| or _score_real_submission(task_dir, submission_path, include_range, numeric_path) |
| ) |
|
|
| qualified = _is_qualified(mode, submitted, score_info) |
| if not qualified: |
| return None |
|
|
| traj_info = _row_from_traj(traj_path) |
| row = { |
| "run_id": args.run_id, |
| "model": model, |
| "mode": mode, |
| "type": task_type, |
| "task": task_name, |
| "task_dir": str(task_dir), |
| "max_turns": args.max_turns, |
| "include_test_range": str(include_range).lower(), |
| "returncode": 0, |
| "status": traj_info.get("status") or "completed_existing", |
| "submitted": "1", |
| "qualified_submission": "1", |
| "rounds": traj_info.get("rounds", ""), |
| "total_tokens": traj_info.get("total_tokens", ""), |
| "n_experiments": traj_info.get("n_experiments", ""), |
| "n_python_calls": traj_info.get("n_python_calls", ""), |
| "active_rows": traj_info.get("active_rows", ""), |
| "elapsed_seconds": "0.000", |
| "submission_path": str(submission_path), |
| "trajectory_path": str(traj_path), |
| "numeric_path": str(numeric_path) if mode == "real" else "", |
| "log_path": str(log_path), |
| "error": "", |
| } |
| row.update(score_info) |
| return row |
|
|
|
|
| def _upsert_row(rows: list[dict[str, Any]], row: dict[str, Any]) -> None: |
| key = _row_key(row) |
| for pos, old_row in enumerate(rows): |
| if _row_key(old_row) == key: |
| rows[pos] = row |
| return |
| rows.append(row) |
|
|
|
|
| def _run_one(job: dict[str, Any], args: argparse.Namespace) -> dict[str, Any]: |
| model = job["model"] |
| mode = job["mode"] |
| task_type = job["type"] |
| task_name = job["task"] |
| task_dir = Path(job["task_dir"]) |
| include_range = bool(args.include_range and mode == "real") |
| paths = _job_paths(job, args) |
| sub_dir = paths["sub_dir"] |
| traj_dir = paths["traj_dir"] |
| submission_path = paths["submission_path"] |
| traj_path = paths["traj_path"] |
| log_path = paths["log_path"] |
| numeric_path = paths["numeric_path"] |
|
|
| cmd = [ |
| sys.executable, |
| str(RUN_BASELINE), |
| str(task_dir), |
| model, |
| "--max-turns", |
| str(args.max_turns), |
| "--out", |
| str(sub_dir), |
| "--traj-out", |
| str(traj_dir), |
| ] |
| if mode == "parallel": |
| cmd.append("--simulator") |
| elif include_range: |
| cmd.append("--include-test-range") |
| else: |
| cmd.append("--no-include-test-range") |
|
|
| env = os.environ.copy() |
| if args.reasoning_effort: |
| env["OPENAI_REASONING_EFFORT"] = args.reasoning_effort |
| env["REASONING_EFFORT"] = args.reasoning_effort |
| if args.llm_timeout_seconds: |
| env["LLM_TIMEOUT_SECONDS"] = str(args.llm_timeout_seconds) |
|
|
| start = time.time() |
| error = "" |
| with log_path.open("w", encoding="utf-8") as log: |
| log.write("$ " + " ".join(cmd) + "\n\n") |
| log.flush() |
| try: |
| proc = subprocess.run( |
| cmd, |
| cwd=REPO, |
| stdout=log, |
| stderr=subprocess.STDOUT, |
| text=True, |
| env=env, |
| timeout=args.task_timeout_seconds or None, |
| ) |
| returncode = proc.returncode |
| except subprocess.TimeoutExpired as exc: |
| returncode = 124 |
| error = f"TimeoutExpired: {exc}" |
| log.write("\nBATCH_TIMEOUT: " + error + "\n") |
| except Exception as exc: |
| returncode = 125 |
| error = f"{type(exc).__name__}: {exc}" |
| log.write("\nBATCH_ERROR: " + error + "\n") |
|
|
| elapsed = time.time() - start |
| submitted = _submission_nonempty(submission_path) |
| traj_info = _row_from_traj(traj_path) |
|
|
| score_info = { |
| "numeric_score": "", |
| "raw_numeric_score": "", |
| "numeric_score_std": "", |
| "metric": "", |
| "score_status": "", |
| "contract_ok": "", |
| } |
| if mode == "real": |
| score_info = _score_real_submission( |
| task_dir, submission_path, include_range, numeric_path) |
|
|
| qualified = _is_qualified(mode, submitted, score_info) |
|
|
| row = { |
| "run_id": args.run_id, |
| "model": model, |
| "mode": mode, |
| "type": task_type, |
| "task": task_name, |
| "task_dir": str(task_dir), |
| "max_turns": args.max_turns, |
| "include_test_range": str(include_range).lower(), |
| "returncode": returncode, |
| "status": traj_info.get("status") or ("ok" if returncode == 0 else "run_error"), |
| "submitted": "1" if submitted else "0", |
| "qualified_submission": "1" if qualified else "0", |
| "rounds": traj_info.get("rounds", ""), |
| "total_tokens": traj_info.get("total_tokens", ""), |
| "n_experiments": traj_info.get("n_experiments", ""), |
| "n_python_calls": traj_info.get("n_python_calls", ""), |
| "active_rows": traj_info.get("active_rows", ""), |
| "elapsed_seconds": f"{elapsed:.3f}", |
| "submission_path": str(submission_path), |
| "trajectory_path": str(traj_path), |
| "numeric_path": str(numeric_path) if mode == "real" else "", |
| "log_path": str(log_path), |
| "error": error, |
| } |
| row.update(score_info) |
| return row |
|
|
|
|
| def _summary(rows: list[dict[str, Any]]) -> dict[str, Any]: |
| groups: dict[tuple[str, str, str], list[dict[str, Any]]] = defaultdict(list) |
| for row in rows: |
| groups[(row["model"], row["mode"], row["type"])].append(row) |
| groups[(row["model"], row["mode"], "ALL")].append(row) |
| out: list[dict[str, Any]] = [] |
| for (model, mode, task_type), items in sorted(groups.items()): |
| scores = [] |
| for row in items: |
| try: |
| if row.get("numeric_score") != "": |
| scores.append(float(row["numeric_score"])) |
| except Exception: |
| pass |
| status_counts = Counter(row.get("status") or "" for row in items) |
| out.append({ |
| "model": model, |
| "mode": mode, |
| "type": task_type, |
| "n": len(items), |
| "submitted": sum(row.get("submitted") == "1" for row in items), |
| "qualified": sum(row.get("qualified_submission") == "1" for row in items), |
| "completion_rate": ( |
| sum(row.get("qualified_submission") == "1" for row in items) / len(items) |
| if items else None |
| ), |
| "numeric_scored": len(scores), |
| "numeric_mean_scored": (sum(scores) / len(scores) if scores else None), |
| "numeric_strict_mean": ( |
| sum(float(row["numeric_score"]) if row.get("numeric_score") not in ("", None) else 0.0 |
| for row in items) / len(items) |
| if items else None |
| ), |
| "status_counts": dict(status_counts), |
| }) |
| return { |
| "rows": len(rows), |
| "by_model_mode_type": out, |
| } |
|
|
|
|
| def _write_summary(summary_tsv: Path, summary_json: Path, |
| rows: list[dict[str, Any]]) -> None: |
| summary_tsv.parent.mkdir(parents=True, exist_ok=True) |
| tmp = summary_tsv.with_suffix(summary_tsv.suffix + ".tmp") |
| with tmp.open("w", newline="", encoding="utf-8") as fh: |
| writer = csv.DictWriter(fh, fieldnames=FIELDNAMES, delimiter="\t") |
| writer.writeheader() |
| for row in rows: |
| writer.writerow({key: row.get(key, "") for key in FIELDNAMES}) |
| os.replace(tmp, summary_tsv) |
| _write_json(summary_json, _summary(rows)) |
|
|
|
|
| def _score_parallel(args: argparse.Namespace, models: list[str]) -> None: |
| results = {} |
| for model in models: |
| submissions = args.run_dir / "parallel" / "submissions" / model |
| if not submissions.exists(): |
| continue |
| stage_dir = args.run_dir / "parallel_stage" / model |
| output_dir = args.run_dir / "parallel_out" / model |
| cmd = [ |
| sys.executable, |
| str(REPO / "harness" / "evaluate_parallel.py"), |
| "--repo-root", |
| str(REPO), |
| "--tasks-dir", |
| "tasks", |
| "--submissions", |
| str(submissions), |
| "--stage-dir", |
| str(stage_dir), |
| "--output-dir", |
| str(output_dir), |
| "--method-name", |
| model, |
| "--chunk-size", |
| str(args.parallel_chunk_size), |
| "--dispatch", |
| "codex", |
| "--max-workers", |
| str(args.parallel_judge_workers), |
| "--overwrite", |
| ] |
| if args.codex_model: |
| cmd.extend(["--codex-model", args.codex_model]) |
| log_path = args.run_dir / "parallel_out" / f"{model}.evaluate_parallel.log" |
| log_path.parent.mkdir(parents=True, exist_ok=True) |
| with log_path.open("w", encoding="utf-8") as log: |
| log.write("$ " + " ".join(cmd) + "\n\n") |
| log.flush() |
| proc = subprocess.run(cmd, cwd=REPO, stdout=log, stderr=subprocess.STDOUT, text=True) |
| summary_path = output_dir / "parallel_summary.json" |
| results[model] = { |
| "returncode": proc.returncode, |
| "log_path": str(log_path), |
| "summary_json": str(summary_path), |
| "summary": _read_json(summary_path), |
| } |
| _write_json(args.run_dir / "parallel_score_summary.json", results) |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--models", nargs="+", required=True) |
| parser.add_argument("--modes", nargs="+", choices=("real", "parallel"), |
| default=["real", "parallel"]) |
| parser.add_argument("--tasks-dir", type=Path, default=REPO / "tasks") |
| parser.add_argument("--task-types", nargs="+", choices=("typeI", "typeII"), |
| default=["typeI", "typeII"]) |
| parser.add_argument("--tasks", nargs="+", default=[], |
| help="Optional task directory names to run.") |
| parser.add_argument("--max-turns", type=int, default=30) |
| parser.add_argument("--run-id", default=None) |
| parser.add_argument("--run-dir", type=Path, default=None) |
| parser.add_argument("--workers", type=int, default=4) |
| parser.add_argument("--limit", type=int, default=0) |
| parser.add_argument("--include-range", action="store_true", default=True) |
| parser.add_argument("--no-include-range", dest="include_range", action="store_false") |
| parser.add_argument("--reasoning-effort", default="") |
| parser.add_argument("--llm-timeout-seconds", type=float, default=0.0) |
| parser.add_argument("--task-timeout-seconds", type=float, default=0.0) |
| parser.add_argument("--score-parallel", action="store_true") |
| parser.add_argument("--parallel-judge-workers", type=int, default=4) |
| parser.add_argument("--parallel-chunk-size", type=int, default=3) |
| parser.add_argument("--codex-model", default="") |
| parser.add_argument("--merge-existing-summary", action="store_true", |
| help="Load existing summary.tsv and replace rows for rerun jobs.") |
| parser.add_argument("--skip-existing", action="store_true", |
| help=("Reuse existing qualified submissions/numeric results in " |
| "the run dir and run only missing or unqualified jobs.")) |
| args = parser.parse_args() |
|
|
| args.run_id = args.run_id or f"batch_{_utc_stamp()}" |
| args.run_dir = (args.run_dir or (BASELINE_DIR / "batch_runs" / args.run_id)).resolve() |
| args.tasks_dir = args.tasks_dir.resolve() |
| args.run_dir.mkdir(parents=True, exist_ok=True) |
|
|
| for model in args.models: |
| resolve_model_and_source(model) |
|
|
| tasks = _tasks(args.tasks_dir, args.task_types) |
| if args.tasks: |
| wanted = set(args.tasks) |
| tasks = [task for task in tasks if task["task"] in wanted] |
| missing = sorted(wanted - {task["task"] for task in tasks}) |
| if missing: |
| raise SystemExit(f"unknown tasks for selected --task-types: {missing}") |
| if args.limit: |
| tasks = tasks[:args.limit] |
| jobs = [] |
| for mode in args.modes: |
| for task in tasks: |
| for model in args.models: |
| jobs.append({**task, "model": model, "mode": mode}) |
|
|
| metadata = { |
| "run_id": args.run_id, |
| "run_dir": str(args.run_dir), |
| "models": args.models, |
| "modes": args.modes, |
| "task_types": args.task_types, |
| "max_turns": args.max_turns, |
| "include_range": args.include_range, |
| "reasoning_effort": args.reasoning_effort, |
| "workers": args.workers, |
| "job_order": "mode_task_model", |
| "skip_existing": args.skip_existing, |
| "n_jobs": len(jobs), |
| "created_at_unix": time.time(), |
| } |
| _write_json(args.run_dir / "run_meta.json", metadata) |
|
|
| summary_tsv = args.run_dir / "summary.tsv" |
| summary_json = args.run_dir / "summary.json" |
| rows: list[dict[str, Any]] = ( |
| _read_summary_rows(summary_tsv) if args.merge_existing_summary else [] |
| ) |
| if rows: |
| _write_summary(summary_tsv, summary_json, rows) |
| lock = threading.Lock() |
|
|
| run_jobs = jobs |
| skipped_existing = 0 |
| if args.skip_existing: |
| run_jobs = [] |
| for job in jobs: |
| existing = _existing_row(job, args) |
| if existing is None: |
| run_jobs.append(job) |
| else: |
| _upsert_row(rows, existing) |
| skipped_existing += 1 |
| if skipped_existing: |
| _write_summary(summary_tsv, summary_json, rows) |
|
|
| print(f"RUN_DIR: {args.run_dir}", flush=True) |
| print( |
| f"JOBS: {len(jobs)} run={len(run_jobs)} " |
| f"skip_existing={skipped_existing} workers={args.workers}", |
| flush=True, |
| ) |
| with concurrent.futures.ThreadPoolExecutor(max_workers=max(1, args.workers)) as pool: |
| futs = [pool.submit(_run_one, job, args) for job in run_jobs] |
| for idx, fut in enumerate(concurrent.futures.as_completed(futs), start=1): |
| try: |
| row = fut.result() |
| except Exception as exc: |
| row = { |
| "run_id": args.run_id, |
| "model": "", |
| "mode": "", |
| "type": "", |
| "task": "", |
| "returncode": 126, |
| "status": "batch_error", |
| "submitted": "0", |
| "qualified_submission": "0", |
| "error": f"{type(exc).__name__}: {exc}", |
| } |
| with lock: |
| _upsert_row(rows, row) |
| _write_summary(summary_tsv, summary_json, rows) |
| print( |
| f"[{idx}/{len(run_jobs)}] {row.get('model')} {row.get('mode')} " |
| f"{row.get('type')}/{row.get('task')} status={row.get('status')} " |
| f"submitted={row.get('submitted')} score={row.get('numeric_score')}", |
| flush=True, |
| ) |
|
|
| if args.score_parallel and "parallel" in args.modes: |
| _score_parallel(args, args.models) |
|
|
| print(f"SUMMARY_TSV: {summary_tsv}", flush=True) |
| print(f"SUMMARY_JSON: {summary_json}", flush=True) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
