| """Play Qwen3.8-27B on any OpenEnv server under arena rules, optionally with extra system-prompt text. |
| |
| Used to check transfer: does a model that behaves the way Five Desks v2 rewards (imitated with a hint or with |
| demonstrations in the system prompt) do better on other people's environments? |
| |
| Rules follow the arena guide: arena-style system prompt with the server's action schema; reset observation |
| as the first user turn, later observations as JSON user turns; a reply that is not exactly one JSON object, |
| an action the server rejects, or an exhausted token budget ends the episode (scored 0 here, the same in every |
| arm); unseeded resets. |
| |
| Usage: HF_TOKEN_PATH=... .venv/bin/python scripts/transfer_eval.py --url http://localhost:8021 \ |
| --tasks a,b,c --samples 3 [--system-extra file] --out reports/transfer/far-x |
| """ |
|
|
| import argparse |
| import json |
| 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().parent)) |
| sys.path.insert(0, str(Path(__file__).resolve().parents[1])) |
|
|
| from calibrate import Model, system_prompt |
| from proxy_eval.run import classify, unwrap |
| from wsclient import Session |
|
|
| MAX_TURNS = 40 |
|
|
|
|
| def play(url, model, schema, task_id, extra, budgets, count, transcripts=None): |
| messages = [{"role": "system", "content": system_prompt(schema) + extra}] |
| ep = {"task_id": task_id, "turns": 0, "end": None, "reward": 0.0} |
| if transcripts is not None: |
| transcripts.append((ep, messages)) |
| completion, first = 0, True |
| with Session(url, timeout=120) as s: |
| data = s.reset(task_id=task_id) |
| for _ in range(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}) |
| if not first: |
| completion += count(obs) |
| first = False |
| if completion >= budgets[0] or sum(count(m["content"]) for m in messages) >= budgets[1]: |
| ep["end"] = "budget" |
| return ep |
| reply, used, finish_reason = model.chat(messages) |
| completion += used |
| messages.append({"role": "assistant", "content": reply}) |
| ep["turns"] += 1 |
| if finish_reason == "length": |
| ep["end"] = "truncated" |
| return ep |
| obj, kind = classify(reply) |
| if kind: |
| ep["end"] = kind |
| return ep |
| action = unwrap(obj) |
| if action.get("finish") is True: |
| ep["end"] = "finish" |
| return ep |
| try: |
| data = s.step(action) |
| except RuntimeError: |
| ep["end"] = "schema_invalid" |
| return ep |
| if data["done"]: |
| ep["end"], ep["reward"] = "done", float(data.get("reward") or 0.0) |
| return ep |
| ep["end"] = "max_turns" |
| return ep |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--url", required=True) |
| ap.add_argument("--tasks", required=True) |
| ap.add_argument("--samples", type=int, default=3) |
| ap.add_argument("--workers", type=int, default=8) |
| ap.add_argument("--system-extra", default="") |
| 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=8192) |
| ap.add_argument("--context-budget", type=int, default=16384) |
| ap.add_argument("--tokenizer", default="") |
| ap.add_argument("--out", required=True) |
| ap.add_argument("--save-transcripts", action="store_true", help="also write transcripts.jsonl (do not publish)") |
| args = ap.parse_args() |
|
|
| extra = "\n\n" + Path(args.system_extra).read_text().strip() if args.system_extra else "" |
| schema = json.load(urllib.request.urlopen(args.url.rstrip("/") + "/schema"))["action"] |
| if args.tokenizer: |
| from tokenizers import Tokenizer |
| tok = Tokenizer.from_file(args.tokenizer) |
| count = lambda text: len(tok.encode(text).ids) |
| else: |
| count = lambda text: len(text) // 3 |
| model = Model(args.model, args.max_tokens, 1.0) |
| tasks = args.tasks.split(",") |
| jobs = [t for t in tasks for _ in range(args.samples)] |
| out = Path(args.out) |
| out.mkdir(parents=True, exist_ok=True) |
| started, results = time.monotonic(), [] |
| transcripts = [] if args.save_transcripts else None |
| with ThreadPoolExecutor(args.workers) as pool, open(out / "episodes.jsonl", "w") as log: |
| futures = [pool.submit(play, args.url, model, schema, t, extra, (args.completion_budget, args.context_budget), |
| count, transcripts) for t in jobs] |
| for fut in futures: |
| try: |
| ep = fut.result() |
| except Exception as exc: |
| print("episode error:", repr(exc)[:300], file=sys.stderr) |
| continue |
| results.append(ep) |
| log.write(json.dumps(ep) + "\n") |
| log.flush() |
| per_task = {t: round(mean(e["reward"] for e in results if e["task_id"] == t), 3) |
| for t in tasks if any(e["task_id"] == t for e in results)} |
| ends = {} |
| for e in results: |
| ends[e["end"]] = ends.get(e["end"], 0) + 1 |
| report = {"url": args.url, "system_extra": args.system_extra, "episodes": len(results), |
| "mean_reward": round(mean(e["reward"] for e in results), 3), |
| "solved": sum(e["reward"] >= 0.999 for e in results), "ends": ends, "per_task": per_task, |
| "mean_turns": round(mean(e["turns"] for e in results), 1), "usage": model.usage, |
| "seconds": round(time.monotonic() - started)} |
| if transcripts is not None: |
| with open(out / "transcripts.jsonl", "w") as f: |
| for ep, messages in transcripts: |
| f.write(json.dumps({**ep, "messages": messages[1:]}) + "\n") |
| (out / "summary.json").write_text(json.dumps(report, indent=2) + "\n") |
| print(json.dumps({k: v for k, v in report.items() if k != "per_task"})) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
