| """Play Qwen3.8-27B (thinking off) on the proxy tasks with arena-style prompts. |
| |
| Each episode is scored twice from one conversation: |
| - strict: the arena's rule. A reply that is not exactly one JSON object, or an action that fails the task's |
| schema, ends the episode and the task scores its finish_action. |
| - lenient: the conversation continues (first JSON object in the reply is used; schema errors are reported back |
| to the model), to show what the model would reach without format failures. |
| |
| Usage: HF_TOKEN_PATH=... .venv/bin/python -m proxy_eval.run --samples 2 --out reports/proxy/run1 |
| """ |
|
|
| import argparse |
| import copy |
| import json |
| import sys |
| import time |
| from concurrent.futures import ThreadPoolExecutor |
| from pathlib import Path |
| from statistics import mean |
|
|
| from pydantic import ValidationError |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts")) |
|
|
| from calibrate import Model, first_json_object, system_prompt |
|
|
| from .tasks import FAMILIES |
|
|
|
|
| def classify(reply: str): |
| s = reply.strip() |
| if not s: |
| return None, "empty" |
| try: |
| obj = json.loads(s) |
| return (obj, None) if isinstance(obj, dict) else (None, "not_object") |
| except json.JSONDecodeError: |
| pass |
| if s.startswith("```"): |
| return None, "code_fence" |
| if first_json_object(s) is not None: |
| return None, "json_plus_text" |
| return None, "no_json" |
|
|
|
|
| def unwrap(action): |
| if isinstance(action, dict) and set(action) == {"action"} and isinstance(action["action"], dict): |
| return action["action"] |
| return action |
|
|
|
|
| def finish_score(task): |
| """Reward the arena would record if the episode were ended now through finish_action.""" |
| if task.done: |
| return None |
| try: |
| clone = copy.deepcopy(task) |
| except TypeError: |
| return 0.0 |
| return clone.step(clone.Action.model_validate(task.finish_action)).reward |
|
|
|
|
| def play(task, model, completion_budget, context_budget, system_extra=""): |
| schema = task.Action.model_json_schema() |
| messages = [{"role": "system", "content": system_prompt(schema) + system_extra}] |
| obs = task.reset() |
| ep = {"task_id": task.task_id, "family": task.family, "domain": task.domain, "turns": [], |
| "strict": None, "lenient": None, "strict_end": None, "lenient_end": None, "schema_errors": 0} |
| completion_used = 0 |
| first = True |
|
|
| def strict_fail(kind): |
| if ep["strict"] is None: |
| ep["strict"], ep["strict_end"] = finish_score(task) or 0.0, kind |
|
|
| while True: |
| obs_text = json.dumps(obs) |
| messages.append({"role": "user", "content": obs_text}) |
| if not first: |
| completion_used += len(obs_text) // 3 |
| first = False |
| if completion_used >= completion_budget or sum(len(m["content"]) for m in messages) // 3 >= context_budget: |
| strict_fail("budget") |
| ep["lenient"], ep["lenient_end"] = finish_score(task) or 0.0, "budget" |
| break |
| reply, used, finish_reason = model.chat(messages) |
| completion_used += used |
| messages.append({"role": "assistant", "content": reply}) |
| ep["turns"].append({"obs": obs_text[:1500], "reply": reply[:1500], "tokens": used}) |
| if finish_reason == "length": |
| strict_fail("truncated") |
| ep["lenient"], ep["lenient_end"] = finish_score(task) or 0.0, "truncated" |
| break |
| strict_obj, kind = classify(reply) |
| if kind: |
| strict_fail(kind) |
| action = unwrap(strict_obj if strict_obj is not None else first_json_object(reply)) |
| if action is None: |
| ep["lenient"], ep["lenient_end"] = finish_score(task) or 0.0, kind |
| break |
| if action.get("finish") is True: |
| score = finish_score(task) or 0.0 |
| strict_fail("finish") |
| ep["lenient"], ep["lenient_end"] = score, "finish" |
| break |
| try: |
| parsed = task.Action.model_validate(action) |
| except ValidationError as exc: |
| ep["schema_errors"] += 1 |
| strict_fail("schema_invalid") |
| errors = "; ".join(f"{'.'.join(map(str, e['loc']))}: {e['msg']}" for e in exc.errors()[:3]) |
| obs = {"error": f"Invalid action: {errors}"} |
| if task.steps + ep["schema_errors"] > task.max_steps + 3: |
| ep["lenient"], ep["lenient_end"] = finish_score(task) or 0.0, "schema_invalid" |
| break |
| continue |
| step = task.step(parsed) |
| obs = step.observation |
| if step.done: |
| if ep["strict"] is None: |
| ep["strict"], ep["strict_end"] = step.reward, "done" |
| ep["lenient"], ep["lenient_end"] = step.reward, "done" |
| break |
| ep["n_turns"] = len(ep["turns"]) |
| return ep |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--model", default="Qwen/Qwen3.8-27B:deepinfra") |
| parser.add_argument("--families", default="", help="comma-separated family prefixes (default: all)") |
| parser.add_argument("--seeds", default="0-4") |
| parser.add_argument("--samples", type=int, default=2) |
| parser.add_argument("--workers", type=int, default=8) |
| parser.add_argument("--temperature", type=float, default=1.0) |
| parser.add_argument("--max-tokens", type=int, default=2048) |
| parser.add_argument("--completion-budget", type=int, default=8192) |
| parser.add_argument("--context-budget", type=int, default=16384) |
| parser.add_argument("--thinking", action="store_true", help="enable the model's thinking mode") |
| parser.add_argument("--system-extra", default="", help="file whose text is appended to the system prompt " |
| "(to imitate a model that has learned a habit)") |
| parser.add_argument("--out", required=True) |
| args = parser.parse_args() |
| extra = "\n\n" + Path(args.system_extra).read_text().strip() if args.system_extra else "" |
|
|
| lo, hi = map(int, args.seeds.split("-")) |
| fams = [f for f in FAMILIES if not args.families or any(f.startswith(p) for p in args.families.split(","))] |
| jobs = [(f, s) for f in fams for s in range(lo, hi + 1) for _ in range(args.samples)] |
| model = Model(args.model, args.max_tokens, args.temperature, args.thinking) |
| out = Path(args.out) |
| out.mkdir(parents=True, exist_ok=True) |
| started, results = time.monotonic(), [] |
|
|
| def run(job): |
| fam, seed = job |
| return play(FAMILIES[fam](seed), model, args.completion_budget, args.context_budget, extra) |
|
|
| with ThreadPoolExecutor(args.workers) as pool, open(out / "episodes.jsonl", "w") as log: |
| for fut in [pool.submit(run, j) for j in jobs]: |
| 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() |
|
|
| summary = {} |
| for fam in fams: |
| eps = [e for e in results if e["family"] == fam] |
| if not eps: |
| continue |
| ends = {} |
| for e in eps: |
| ends[e["strict_end"]] = ends.get(e["strict_end"], 0) + 1 |
| summary[fam] = {"n": len(eps), "strict": round(mean(e["strict"] for e in eps), 3), |
| "lenient": round(mean(e["lenient"] for e in eps), 3), "strict_ends": ends, |
| "turns": round(mean(e["n_turns"] for e in eps), 1)} |
| report = {"model": args.model, "system_extra": args.system_extra, "temperature": args.temperature, "thinking": args.thinking, "episodes": len(results), |
| "seconds": round(time.monotonic() - started), "usage": model.usage, "families": summary, |
| "overall": {"strict": round(mean(e["strict"] for e in results), 3), |
| "lenient": round(mean(e["lenient"] for e in results), 3)}} |
| (out / "summary.json").write_text(json.dumps(report, indent=2) + "\n") |
| print(f"{'family':24s} {'n':>3s} {'strict':>6s} {'lenient':>7s} strict ends") |
| for fam, s in summary.items(): |
| print(f"{fam:24s} {s['n']:3d} {s['strict']:6.2f} {s['lenient']:7.2f} {s['strict_ends']}") |
| print("overall", report["overall"], "usage", model.usage, "seconds", report["seconds"]) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
