| """Calibrate Five Desks against Qwen3.8-27B (thinking off) under the arena's reply rules. |
| |
| A reply that is not exactly one JSON object, or an action that fails the schema, ends the episode through the |
| finish action. With --lenient, a reply with text around one JSON object is played instead: the v2 run showed the |
| arena accepts those (industrial trained at 0.80 against 0.31 measured strictly), and v1's lenient calibration |
| matched its arena run. The token is read in-process via HF_TOKEN_PATH and never printed. |
| |
| Usage: HF_TOKEN_PATH=... .venv/bin/python scripts/calibrate_v2.py --url http://localhost:8001 --episodes 8 --out reports/calibration-v2/run1 |
| """ |
|
|
| import argparse |
| import json |
| import random |
| import sys |
| import time |
| import urllib.request |
| from concurrent.futures import ThreadPoolExecutor |
| from pathlib import Path |
| from statistics import mean |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parents[1])) |
| sys.path.insert(0, str(Path(__file__).resolve().parent)) |
|
|
| from pydantic import ValidationError |
|
|
| from calibrate import Model, first_json_object, system_prompt |
| from diligence.environment import TASK_IDS |
| from diligence.models import ToolAction |
| from proxy_eval.run import classify, unwrap |
| from wsclient import Session |
|
|
| FINISH = {"tool": "submit", "args": {}} |
|
|
|
|
| def play(url, model, schema, task_id, completion_budget, context_budget, extra="", lenient=False): |
| messages = [{"role": "system", "content": system_prompt(schema) + extra}] |
| ep = {"task_id": task_id, "turns": [], "end": None, "reward": 0.0, "bad_args": 0, "rescued": 0} |
| used_total, first = 0, True |
| with Session(url, timeout=60) as s: |
| ep["seed"] = random.SystemRandom().randrange(2**48) |
| data = s.reset(task_id=task_id, seed=ep["seed"]) |
| while True: |
| obs = json.dumps({k: v for k, v in data["observation"].items() if k != "metadata" or v}) |
| messages.append({"role": "user", "content": obs}) |
| if not first: |
| used_total += len(obs) // 3 |
| first = False |
| if used_total >= completion_budget or sum(len(m["content"]) for m in messages) // 3 >= context_budget: |
| ep["end"], data = "budget", s.step(FINISH) |
| break |
| reply, used, finish_reason = model.chat(messages) |
| used_total += used |
| messages.append({"role": "assistant", "content": reply}) |
| ep["turns"].append({"obs": obs[:2500], "reply": reply[:2500]}) |
| if finish_reason == "length": |
| ep["end"], data = "truncated", s.step(FINISH) |
| break |
| obj, kind = classify(reply) |
| if kind and lenient and (rescued := first_json_object(reply)) is not None: |
| obj, kind = rescued, None |
| ep["rescued"] += 1 |
| if kind: |
| ep["end"], data = kind, s.step(FINISH) |
| break |
| action = unwrap(obj) |
| if action.get("finish") is True: |
| ep["end"], data = "finish", s.step(FINISH) |
| break |
| try: |
| ToolAction.model_validate(action) |
| except ValidationError: |
| ep["end"], data = "schema_invalid", s.step(FINISH) |
| break |
| data = s.step(action) |
| out = data["observation"].get("output", "") |
| if out.startswith(("Unknown tool", "Unknown argument", "Missing argument")) or "must be a" in out[:80]: |
| ep["bad_args"] += 1 |
| if data["done"]: |
| ep["end"] = "submitted" if out.startswith("Submitted") else "out_of_steps" |
| break |
| ep["reward"] = data.get("reward") or 0.0 |
| ep["n_turns"] = len(ep["turns"]) |
| return ep |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--url", default="http://localhost:8001") |
| ap.add_argument("--model", default="Qwen/Qwen3.8-27B:deepinfra") |
| ap.add_argument("--episodes", type=int, default=8) |
| ap.add_argument("--tasks", default="") |
| ap.add_argument("--task-ids", default="", help="explicit comma-separated task ids (for other servers)") |
| ap.add_argument("--workers", type=int, default=8) |
| ap.add_argument("--temperature", type=float, default=1.0) |
| ap.add_argument("--max-tokens", type=int, default=2048) |
| ap.add_argument("--completion-budget", type=int, default=8192) |
| ap.add_argument("--context-budget", type=int, default=16384) |
| ap.add_argument("--system-extra", default="", help="file appended to the system prompt") |
| ap.add_argument("--lenient", action="store_true", help="play the JSON object out of replies with extra text") |
| ap.add_argument("--out", required=True) |
| args = ap.parse_args() |
| tasks = args.task_ids.split(",") if args.task_ids else [ |
| t for t in TASK_IDS if not args.tasks or any(t.startswith(p) for p in args.tasks.split(","))] |
| with urllib.request.urlopen(f"{args.url}/schema", timeout=15) as r: |
| schema = json.load(r)["action"] |
| model = Model(args.model, args.max_tokens, args.temperature) |
| extra = "\n\n" + Path(args.system_extra).read_text().strip() if args.system_extra else "" |
| out = Path(args.out) |
| out.mkdir(parents=True, exist_ok=True) |
| started, results = time.monotonic(), [] |
| jobs = [t for t in tasks for _ in range(args.episodes)] |
| with ThreadPoolExecutor(args.workers) as pool, open(out / "episodes.jsonl", "w") as log: |
| for fut in [pool.submit(play, args.url, model, schema, t, args.completion_budget, args.context_budget, extra, args.lenient) for t in jobs]: |
| try: |
| ep = fut.result() |
| except Exception as exc: |
| print("episode error:", repr(exc)[:200], file=sys.stderr) |
| continue |
| results.append(ep) |
| log.write(json.dumps(ep) + "\n") |
| log.flush() |
| summary = {} |
| for t in tasks: |
| eps = [e for e in results if e["task_id"] == t] |
| if not eps: |
| continue |
| ends = {} |
| for e in eps: |
| ends[e["end"]] = ends.get(e["end"], 0) + 1 |
| summary[t] = {"n": len(eps), "mean": round(mean(e["reward"] for e in eps), 3), |
| "solved": sum(e["reward"] == 1.0 for e in eps), "rewards": [e["reward"] for e in eps], |
| "ends": ends, "turns": round(mean(e["n_turns"] for e in eps), 1), |
| "rescued_replies": sum(e.get("rescued", 0) for e in eps)} |
| report = {"model": args.model, "lenient": args.lenient, "episodes": len(results), "seconds": round(time.monotonic() - started), |
| "usage": model.usage, "tasks": summary} |
| (out / "summary.json").write_text(json.dumps(report, indent=2) + "\n") |
| print(f"{'task':24s} {'mean':>5s} solved ends") |
| for t, s in summary.items(): |
| print(f"{t:24s} {s['mean']:5.2f} {s['solved']:2d}/{s['n']:<2d} {s['ends']}") |
| print("usage:", model.usage, "seconds:", report["seconds"]) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
