File size: 6,285 Bytes
dcef129
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ae9e249
 
dcef129
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ae9e249
dcef129
 
 
 
 
 
ae9e249
dcef129
 
 
 
 
ae9e249
dcef129
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""Calibrate Five Desks v2 against Qwen3.8-27B (thinking off) with the arena's strict 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, as the arena does. 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  # noqa: E402

from calibrate import Model, system_prompt  # noqa: E402
from diligence.environment import TASK_IDS  # noqa: E402
from diligence.models import ToolAction  # noqa: E402
from proxy_eval.run import classify, unwrap  # noqa: E402
from wsclient import Session  # noqa: E402

FINISH = {"tool": "submit", "args": {}}


def play(url, model, schema, task_id, completion_budget, context_budget, extra=""):
    messages = [{"role": "system", "content": system_prompt(schema) + extra}]
    ep = {"task_id": task_id, "turns": [], "end": None, "reward": 0.0, "bad_args": 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:
                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 action.get("tool") in ("submit", "create_event") 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("--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("--out", required=True)
    args = ap.parse_args()
    tasks = [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) for t in jobs]:
            try:
                ep = fut.result()
            except Exception as exc:  # infrastructure errors are excluded, not scored
                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)}
    report = {"model": args.model, "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()