| """Play the capability ladder on environments and save every episode. |
| |
| dotenvx run -- python scripts/ladder.py --suites maze_env,rg:leg_counting --tiers null,random,beam-low |
| python scripts/ladder.py --suites maze_env --tiers null,random # no key needed |
| |
| Writes runs/<run>/<suite>.jsonl (one episode per line) and prints a line per episode. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import sys |
| import threading |
| import time |
| from concurrent.futures import ThreadPoolExecutor |
| from datetime import datetime, timezone |
| from pathlib import Path |
|
|
| import requests |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parent.parent)) |
| from shortlist import beam |
| from shortlist.policies import Beam, Null, Random, Small, SmallPlain, action_tool, random_supported |
| from shortlist.rollout import run_episode |
| from shortlist.serve import ROOT, serve |
| from contextlib import nullcontext |
|
|
| from shortlist.suite import SUITES, Suite, community, openspiel, reasoning_gym |
|
|
| ATTEMPTS = {"null": 1, "random": 3, "small": 3, "beam-low": 3, "beam-medium": 2, "beam-high": 2, "beam-xhigh": 1, "beam-max": 1} |
|
|
|
|
| def resolve(name: str) -> tuple[str, Suite]: |
| if name.startswith("rg:"): |
| family = name[3:] |
| return f"rg-{family}", reasoning_gym(family) |
| if name.startswith("os:"): |
| return f"os-{name[3:]}", openspiel(name[3:]) |
| if name.startswith("hub:"): |
| space = name[4:] |
| return "hub-" + space.replace("/", "__"), community(space) |
| return name, SUITES[name] |
|
|
|
|
| def env_docs(env: str, limit: int = 6000, space: str | None = None) -> str: |
| """The environment's own README (front matter removed): what a person would read before playing.""" |
| if space: |
| r = requests.get(f"https://huggingface.co/spaces/{space}/raw/main/README.md", timeout=30) |
| text = r.text if r.ok else "" |
| else: |
| path = ROOT / "vendor" / "OpenEnv" / "envs" / env / "README.md" |
| if not path.exists(): |
| return "" |
| text = path.read_text() |
| if text.startswith("---"): |
| text = text.split("---", 2)[-1] |
| text = text.strip() |
| return text[:limit] + (" …(truncated)" if len(text) > limit else "") |
|
|
|
|
| def make_policy(tier: str, suite: Suite, seed: int, docs: str = ""): |
| if tier == "null": |
| return Null() |
| if tier == "random": |
| return Random(seed) |
| extra_small = "\n\n".join(x for x in (f"Environment documentation (its README):\n{docs}" if docs else "", suite.beam_hint) if x) |
| if tier == "small": |
| return SmallPlain(*suite.plain_question) if suite.plain_question else Small(extra_small) |
| extra = "\n\n".join(x for x in (f"Environment documentation (its README):\n{docs}" if docs else "", suite.beam_hint) if x) |
| return Beam(tier.split("-", 1)[1], extra) |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--suites", required=True) |
| parser.add_argument("--tiers", default="null,random,beam-low") |
| parser.add_argument("--run", default=datetime.now(timezone.utc).strftime("%Y%m%d-%H%M")) |
| parser.add_argument("--parallel", type=int, default=4) |
| parser.add_argument("--attempts", default="", help="override, e.g. beam-low=2,beam-high=1") |
| parser.add_argument("--suite-parallel", type=int, default=3, help="environments played at the same time") |
| parser.add_argument("--envs-dir", default=None, help="folder with patched environment copies (searched first)") |
| args = parser.parse_args() |
| attempts = dict(ATTEMPTS) |
| for part in filter(None, args.attempts.split(",")): |
| k, v = part.split("=") |
| attempts[k] = int(v) |
| out_dir = ROOT / "runs" / args.run |
| out_dir.mkdir(parents=True, exist_ok=True) |
| tiers = args.tiers.split(",") |
|
|
| stop = threading.Event() |
|
|
| def run_suite(name: str) -> None: |
| if stop.is_set(): |
| return |
| suite_id, suite = resolve(name) |
| path = out_dir / f"{suite_id}.jsonl" |
| done_keys = set() |
| if path.exists(): |
| from shortlist.checks import harness_error |
| for line in path.read_text().splitlines(): |
| r = json.loads(line) |
| if not harness_error(r): |
| done_keys.add((r["policy"], r["task"], r["attempt"])) |
| lock = threading.Lock() |
| try: |
| envs_dir = args.envs_dir or suite.envs_dir |
| if suite.space: |
| from openenv.core.utils import hf_space_subdomain |
| server = nullcontext(suite.remote_url or f"https://{hf_space_subdomain(suite.space)}.hf.space") |
| else: |
| server = serve(suite.env, extra_env=suite.server_env or None, envs_dir=(ROOT / envs_dir).resolve() if envs_dir else None) |
| with server as url: |
| schema = requests.get(f"{url}/schema", timeout=30).json() |
| tool = action_tool(schema["action"]) |
| docs = env_docs(suite.env, space=suite.space) |
| if "random" in tiers: |
| from openenv.core.generic_client import GenericEnvClient |
| with GenericEnvClient(base_url=url).sync() as probe_env: |
| first = probe_env.reset(**suite.tasks[0]).observation or {} |
| if not random_supported(tool, first): |
| print(f" {suite_id:26s} random play skipped: no legal-move list or bounded action fields") |
| done_keys.update(("random", t, a) for t in range(len(suite.tasks)) for a in range(attempts["random"])) |
| jobs = [(tier, t, a) for tier in tiers for t in range(len(suite.tasks)) for a in range(attempts[tier]) |
| if (make_policy(tier, suite, 0).name, t, a) not in done_keys] |
|
|
| def work(job): |
| tier, t, a = job |
| policy = make_policy(tier, suite, seed=t * 100 + a, docs=docs) |
| record = run_episode(url, tool, policy, suite.tasks[t], suite.max_steps) |
| record.update({"suite": suite_id, "env": suite.env, "task": t, "attempt": a, |
| "score_mode": suite.score, "solved_at": suite.solved_at, "notes": suite.notes, **suite.extra}) |
| with lock: |
| with path.open("a") as f: |
| f.write(json.dumps(record, default=str) + "\n") |
| score = record["return"] if suite.score == "return" else record["mean_step_reward"] |
| flag = "ERR " if record["error"] else " " |
| print(f"{flag}{suite_id:26s} {record['policy']:12s} task {t} try {a} score {score:8.3f} steps {record['n_steps']:3d} " |
| f"out-tokens {record['tokens']['completion']:6d} {record['seconds']:6.1f}s {(record['error'] or '')[:90]}", flush=True) |
|
|
| with ThreadPoolExecutor(max_workers=min(args.parallel, suite.parallel)) as pool: |
| list(pool.map(work, jobs)) |
| except beam.DailyLimitReached: |
| stop.set() |
| print("Daily Beam allowance used up; resume after 00:00 UTC with the same --run.") |
| except Exception as error: |
| print(f"SUITE FAILED {suite_id}: {type(error).__name__}: {error}") |
| with path.with_suffix(".failed.txt").open("w") as f: |
| f.write(f"{type(error).__name__}: {error}\n") |
| with ThreadPoolExecutor(max_workers=args.suite_parallel) as suites_pool: |
| list(suites_pool.map(run_suite, args.suites.split(","))) |
| print(json.dumps({"beam_usage": beam.USAGE.summary()})) |
| (out_dir / f"usage-{int(time.time())}.json").write_text(json.dumps(beam.USAGE.summary())) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
