File size: 7,855 Bytes
a2b0c04 | 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 148 149 150 151 152 153 154 155 156 157 158 159 | """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 # noqa: E402
from shortlist.policies import Beam, Null, Random, Small, SmallPlain, action_tool, random_supported # noqa: E402
from shortlist.rollout import run_episode # noqa: E402
from shortlist.serve import ROOT, serve # noqa: E402
from contextlib import nullcontext # noqa: E402
from shortlist.suite import SUITES, Suite, community, openspiel, reasoning_gym # noqa: E402
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(): # resume: skip episodes already recorded
from shortlist.checks import harness_error
for line in path.read_text().splitlines():
r = json.loads(line)
if not harness_error(r): # our own failures are played again
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: # noqa: BLE001
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()
|