| """Why does the untrained model fail? Play Qwen3.8-27B on other entrants' environments and record how each episode ends. |
| |
| Arena rules (strict): a reply that is not exactly one JSON object ends the episode. To see what that rule costs, |
| this runner keeps playing when a reply has text around a valid JSON action (lenient continuation) but records every |
| reply's format, so each episode yields both outcomes: |
| strict_reward = the reward if the episode had ended at the first non-strict reply (scored as 0 here) |
| lenient_reward = the reward with the format problem forgiven |
| Transcripts are written locally only (they contain other entrants' task text) and are never published. |
| |
| Usage: HF_TOKEN_PATH=... .venv/bin/python scripts/failure_study.py --env NAME=URL --tasks a,b --samples 2 --out DIR |
| """ |
|
|
| import argparse |
| import json |
| import random |
| import sys |
| import time |
| import urllib.request |
| from concurrent.futures import ThreadPoolExecutor |
| from pathlib import Path |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parent)) |
| sys.path.insert(0, str(Path(__file__).resolve().parents[1])) |
|
|
| from calibrate import Model, first_json_object, system_prompt |
| from proxy_eval.run import classify, unwrap |
| from wsclient import Session |
|
|
| MAX_TURNS = 40 |
|
|
|
|
| def play(url, model, schema, task_id, budgets, extra=""): |
| messages = [{"role": "system", "content": system_prompt(schema) + extra}] |
| ep = {"task_id": task_id, "turns": 0, "end": None, "reward": 0.0, "formats": [], "first_bad_turn": None, |
| "reply_tokens": 0, "obs_chars": 0} |
| completion, first = 0, True |
| with Session(url, timeout=180) as s: |
| data = s.reset(task_id=task_id) |
| while ep["turns"] < MAX_TURNS: |
| obs = json.dumps({k: v for k, v in data["observation"].items() if k != "metadata" or v}) |
| messages.append({"role": "user", "content": obs}) |
| ep["obs_chars"] += len(obs) |
| if not first: |
| completion += len(obs) // 3 |
| first = False |
| if completion >= budgets[0] or sum(len(m["content"]) for m in messages) // 3 >= budgets[1]: |
| ep["end"] = "budget" |
| break |
| reply, used, finish_reason = model.chat(messages) |
| completion += used |
| ep["reply_tokens"] += used |
| messages.append({"role": "assistant", "content": reply}) |
| ep["turns"] += 1 |
| if finish_reason == "length": |
| ep["formats"].append("truncated") |
| ep["end"] = "truncated" |
| break |
| obj, kind = classify(reply) |
| fmt = kind or "clean" |
| if kind and (rescued := first_json_object(reply)) is not None: |
| obj = rescued |
| elif kind: |
| ep["formats"].append(fmt) |
| ep["end"] = fmt |
| break |
| ep["formats"].append(fmt) |
| if fmt != "clean" and ep["first_bad_turn"] is None: |
| ep["first_bad_turn"] = ep["turns"] |
| action = unwrap(obj) |
| if action.get("finish") is True: |
| ep["end"] = "finish" |
| break |
| try: |
| data = s.step(action) |
| except RuntimeError as exc: |
| ep["end"] = "schema_invalid" |
| ep["error"] = str(exc)[:200] |
| break |
| if data["done"]: |
| ep["end"], ep["reward"] = "done", float(data.get("reward") or 0.0) |
| break |
| else: |
| ep["end"] = "max_turns" |
| ep["lenient_reward"] = ep["reward"] |
| ep["strict_reward"] = ep["reward"] if ep["first_bad_turn"] is None and ep["end"] == "done" else 0.0 |
| return ep, messages[1:] |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--env", required=True, help="NAME=URL") |
| ap.add_argument("--tasks", required=True) |
| ap.add_argument("--samples", type=int, default=2) |
| ap.add_argument("--workers", type=int, default=8) |
| ap.add_argument("--model", default="Qwen/Qwen3.8-27B:deepinfra") |
| ap.add_argument("--max-tokens", type=int, default=2048) |
| ap.add_argument("--completion-budget", type=int, default=16384) |
| ap.add_argument("--context-budget", type=int, default=32768) |
| ap.add_argument("--system-extra", default="", help="file appended to the system prompt") |
| ap.add_argument("--out", required=True) |
| args = ap.parse_args() |
| extra = "\n\n" + Path(args.system_extra).read_text().strip() if args.system_extra else "" |
| name, url = args.env.split("=", 1) |
| schema = json.load(urllib.request.urlopen(url.rstrip("/") + "/schema"))["action"] |
| model = Model(args.model, args.max_tokens, 1.0) |
| jobs = [t for t in args.tasks.split(",") for _ in range(args.samples)] |
| random.Random(0).shuffle(jobs) |
| out = Path(args.out) |
| out.mkdir(parents=True, exist_ok=True) |
| started, results = time.monotonic(), [] |
| with ThreadPoolExecutor(args.workers) as pool, open(out / "episodes.jsonl", "w") as log, \ |
| open(out / "transcripts.jsonl", "w") as tr: |
| futures = [pool.submit(play, url, model, schema, t, (args.completion_budget, args.context_budget), extra) |
| for t in jobs] |
| for fut in futures: |
| try: |
| ep, messages = fut.result() |
| except Exception as exc: |
| print("episode error:", repr(exc)[:300], file=sys.stderr) |
| continue |
| ep["env"] = name |
| results.append(ep) |
| log.write(json.dumps(ep) + "\n") |
| log.flush() |
| tr.write(json.dumps({**ep, "messages": messages}) + "\n") |
| n = max(1, len(results)) |
| ends = {} |
| for e in results: |
| ends[e["end"]] = ends.get(e["end"], 0) + 1 |
| report = {"env": name, "episodes": len(results), "seconds": round(time.monotonic() - started), "usage": model.usage, |
| "lenient_mean": round(sum(e["lenient_reward"] for e in results) / n, 3), |
| "strict_mean": round(sum(e["strict_reward"] for e in results) / n, 3), |
| "episodes_with_text_around_json": sum(e["first_bad_turn"] is not None for e in results), "ends": ends} |
| (out / "summary.json").write_text(json.dumps(report, indent=2) + "\n") |
| print(json.dumps(report)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
