| |
| """Sample K candidates per eval problem from an OpenAI-compatible endpoint. |
| Protocol = arm B / SFT_DESIGN §7: temp 1.0, top_p 0.95, configurable |
| completion cap (legacy default 16384), reasoning medium, per-sample seed = |
| base_seed + k, reasoning_content preserved. |
| Shard-native: --shard i/N (deterministic by sorted id) or --ids file. |
| Resumable: existing (id,k) rows in --out are skipped. |
| |
| python3 eval_sample.py --testset testset.jsonl --model <name> \ |
| --base-url http://localhost:8000/v1 --k 16 --shard 0/4 --out samples_s0.jsonl |
| """ |
| import argparse, asyncio, json, os |
|
|
| async def main(a): |
| from openai import AsyncOpenAI |
| rows = [json.loads(l) for l in open(a.testset)] |
| rows.sort(key=lambda r: r["id"]) |
| if a.ids: |
| want = {l.strip() for l in open(a.ids) if l.strip()} |
| rows = [r for r in rows if r["id"] in want] |
| if a.shard: |
| i, n = map(int, a.shard.split("/")) |
| rows = rows[i::n] |
| done = set() |
| if os.path.exists(a.out): |
| for l in open(a.out): |
| try: |
| r = json.loads(l) |
| done.add((r["id"], r["k"])) |
| except Exception: |
| pass |
| todo = [(r, k) for r in rows for k in range(a.k) if (r["id"], k) not in done] |
| print(f"{len(rows)} problems x k={a.k}; {len(done)} done, {len(todo)} to sample", flush=True) |
| client = AsyncOpenAI(base_url=a.base_url, api_key=a.api_key, timeout=a.timeout) |
| sem = asyncio.Semaphore(a.concurrency) |
| outf = open(a.out, "a") |
| lock = asyncio.Lock() |
|
|
| async def one(r, k): |
| async with sem: |
| for attempt in range(5): |
| try: |
| resp = await client.chat.completions.create( |
| model=a.model, |
| messages=[{"role": "user", "content": r["question"]}], |
| temperature=1.0, top_p=0.95, |
| max_completion_tokens=a.max_completion_tokens, |
| reasoning_effort="medium", |
| seed=a.base_seed + k, timeout=a.timeout) |
| ch = resp.choices[0] |
| u = resp.usage |
| rec = {"id": r["id"], "k": k, "seed": a.base_seed + k, |
| "text": ch.message.content or "", |
| "rt": getattr(ch.message, "reasoning_content", None), |
| "finish": ch.finish_reason, |
| "pt": u.prompt_tokens if u else None, |
| "ct": u.completion_tokens if u else None, |
| "max_completion_tokens": a.max_completion_tokens} |
| async with lock: |
| outf.write(json.dumps(rec) + "\n"); outf.flush() |
| return |
| except Exception as e: |
| if attempt == 4: |
| print(f"GIVEUP {r['id']} k={k}: {type(e).__name__}", flush=True) |
| return |
| await asyncio.sleep(min(60, 2 ** attempt * 5)) |
|
|
| CH = 2000 |
| for i in range(0, len(todo), CH): |
| await asyncio.gather(*(one(r, k) for r, k in todo[i:i + CH])) |
| print(f"{min(i + CH, len(todo))}/{len(todo)}", flush=True) |
| outf.close() |
| print("SAMPLING DONE", flush=True) |
|
|
| if __name__ == "__main__": |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--testset", required=True) |
| ap.add_argument("--model", required=True) |
| ap.add_argument("--base-url", default="http://localhost:8000/v1") |
| ap.add_argument("--api-key", default="EMPTY") |
| ap.add_argument("--k", type=int, default=16) |
| ap.add_argument("--max-completion-tokens", type=int, default=16384) |
| ap.add_argument("--shard", default=None, help="i/N over sorted problem ids") |
| ap.add_argument("--ids", default=None, help="file of ids (one per line)") |
| ap.add_argument("--out", required=True) |
| ap.add_argument("--base-seed", type=int, default=1234) |
| ap.add_argument("--concurrency", type=int, default=128) |
| ap.add_argument("--timeout", type=float, default=1800) |
| args = ap.parse_args() |
| asyncio.run(main(args)) |
|
|
