"""Evaluate a model on SplatBench through any OpenAI-compatible endpoint. Resumable: finished episodes are skipped. # OpenAI OPENAI_API_KEY=... uv run python scripts/run_eval.py --models gpt-6.1-sol --effort medium # OpenRouter (cost per response is read from the endpoint); label=endpoint_id keeps the leaderboard name OPENROUTER_API_KEY=... uv run python scripts/run_eval.py --base-url https://openrouter.ai/api/v1 \ --api-key-env OPENROUTER_API_KEY --models claude-opus-5.5=anthropic/claude-opus-5.5 \ --extra-body '{"reasoning": {"effort": "medium"}}' # an open model on a local vLLM or SGLang server uv run python scripts/run_eval.py --base-url http://localhost:8000/v1 --api-key-env NONE --models your-model The leaderboard protocol is every task twice (`--runs 2`). Episodes go to //run//; an episode that failed for infrastructure reasons (timeout, endpoint error) is moved aside and retried on the next invocation. At the end the script prints each model's SplatScore (mean over tasks of the mean over runs, with a 95% bootstrap interval over tasks), cost and time per episode, comparable with the leaderboard. """ import argparse import asyncio import glob import json import os import statistics as st import time from collections import defaultdict from pathlib import Path import numpy as np from splatbench.agent import Pricing, run_episode from splatbench.env import PROTOCOLS, load_task, task_variant ap = argparse.ArgumentParser() ap.add_argument("--models", nargs="+", required=True, help="endpoint model ids, or label=endpoint_model_id") ap.add_argument("--tasks", nargs="+", default=sorted(glob.glob("data/bench/tasks/*.json"))) ap.add_argument("--runs", type=int, default=2, help="runs per task (the leaderboard uses 2)") ap.add_argument("--out", default="runs") ap.add_argument("--base-url", default=None, help="OpenAI-compatible base URL (default: OpenAI)") ap.add_argument("--api-key-env", default="OPENAI_API_KEY", help="environment variable with the API key; NONE for none") ap.add_argument("--concurrency", type=int, default=3) ap.add_argument("--effort", default=None, help="reasoning_effort to send, e.g. medium (omitted if not given)") ap.add_argument("--extra-body", default=None, help='JSON merged into each request, e.g. \'{"reasoning": {"effort": "high"}}\'') ap.add_argument("--protocol", default="standard", choices=PROTOCOLS, help="standard | early_submit_refused (the first submit before call 20 is refused once) | " "one_shot (build tasks only: one call, no renders)") ap.add_argument("--timeout", type=float, default=2400, help="seconds per episode") ap.add_argument("--max-tokens", type=int, default=None) ap.add_argument("--price-in", type=float, default=None, help="USD per 1M input tokens") ap.add_argument("--price-out", type=float, default=None, help="USD per 1M output tokens") ap.add_argument("--price-cached", type=float, default=None, help="USD per 1M cached input tokens") ap.add_argument("--budget-usd", type=float, default=None, help="start no new episode beyond this total cost") ap.add_argument("--device", default=None, help="cuda or cpu (default: cuda if available)") a = ap.parse_args() def summarize(out_root: Path, labels: list[str]): print("\nmodel episodes SplatScore [95% CI] USD/episode min/episode") for label in labels: res = [json.loads(p.read_text()) for p in sorted((out_root / label).glob("run*/*/result.json"))] if not res: continue by_task = defaultdict(list) for r in res: by_task[r["task_id"]].append(r["final"]["score"]) tm = np.array([st.mean(v) for _, v in sorted(by_task.items())]) rng = np.random.default_rng(0) b = tm[rng.integers(0, len(tm), (10000, len(tm)))].mean(1) if len(tm) > 1 else tm costs = [r["usage"]["cost_usd"] for r in res if r["usage"]["cost_usd"] is not None] print(f"{label:24s}{len(res):8d} {tm.mean():6.1f} [{np.percentile(b, 2.5):6.1f}, {np.percentile(b, 97.5):6.1f}]" f" {('$%.3f' % st.mean(costs)) if costs else 'n/a':>10s} {st.mean(r['wall_s'] for r in res) / 60:10.1f}") async def main(): from openai import AsyncOpenAI key = "none" if a.api_key_env == "NONE" else os.environ[a.api_key_env] client = AsyncOpenAI(base_url=a.base_url, api_key=key, timeout=a.timeout, max_retries=4) pricing = Pricing(a.price_in, a.price_out, a.price_cached) extra = json.loads(a.extra_body) if a.extra_body else None sem = asyncio.Semaphore(a.concurrency) models = [tuple(m.split("=", 1)) if "=" in m else (m, m) for m in a.models] jobs = [] for run in range(1, a.runs + 1): for tp in a.tasks: # interleave models so that every model progresses at the same rate for label, mid in models: task = load_task(tp) if a.protocol == "one_shot" and task.kind != "sculpt": continue task = task_variant(task, a.protocol) od = Path(a.out) / label / f"run{run}" / task.task_id if (od / "result.json").exists(): continue jobs.append((label, mid, task, od)) spent = {"usd": 0.0} async def one(label, mid, task, od): async with sem: if a.budget_usd is not None and spent["usd"] > a.budget_usd: print(f"budget reached, skipping {label} {task.task_id}", flush=True) return t0 = time.time() try: r = await run_episode(client, mid, task, od, label=label, reasoning_effort=a.effort, extra_body=extra, pricing=pricing, timeout_s=a.timeout, max_tokens=a.max_tokens, device=a.device) except Exception as e: print(f"FAIL {label} {od.parent.name}/{task.task_id}: {type(e).__name__}: {e}", flush=True) return spent["usd"] += r["usage"]["cost_usd"] or 0.0 cost = r["usage"]["cost_usd"] print(f"done {label} {od.parent.name}/{task.task_id} score={r['final']['score']:.1f} calls={r['n_tool_calls']} " f"gaussians={r['final']['n_gaussians']} cost={'n/a' if cost is None else f'${cost:.3f}'} " f"t={time.time() - t0:.0f}s", flush=True) if r["failed"]: dst = od.parent / ".failed" / f"{task.task_id}_{int(time.time())}" dst.parent.mkdir(parents=True, exist_ok=True) od.rename(dst) print(f" {label} {task.task_id} failed ({r['status']}); moved to {dst}, will be retried", flush=True) print(f"{len(jobs)} episodes to run", flush=True) await asyncio.gather(*(one(*j) for j in jobs)) summarize(Path(a.out), [label for label, _ in models]) asyncio.run(main())