| """Ask the teacher (Nemotron 3 Ultra on Nebius Token Factory) the 172 exam prompts again and score its answers the way the exam |
| scores the student: run its SQL and the stored SQL on the same database and compare the rows. |
| |
| This is the ceiling for the exam: how often the teacher, answering the exam prompt, returns the same rows as the label stored for |
| that question. The stored label was written together with the question, so this is not the same call twice. |
| |
| The key comes from the NEBIUS_API_KEY variable, is never printed or written, and the run stops when the estimated spend reaches |
| --max-usd. Writes teacher2.jsonl (the new answers) and teacher_selfcheck.json (the number).""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import importlib.util |
| import json |
| import os |
| import sys |
| import threading |
| import time |
| import urllib.request |
| from concurrent.futures import ThreadPoolExecutor |
| from pathlib import Path |
|
|
| BASE = os.environ.get("RATCHET_TEACHER_BASE", "https://api.tokenfactory.nebius.com/v1").rstrip("/") |
| MODEL = os.environ.get("RATCHET_TEACHER_MODEL", "nvidia/Nemotron-3-Ultra-550b-a55b") |
| PRICE_IN, PRICE_OUT = 1.0, 3.0 |
|
|
| HERE = Path(__file__).resolve().parent |
| spec = importlib.util.spec_from_file_location("m", HERE.parent / "measure_adapter.py") |
| m = importlib.util.module_from_spec(spec) |
| spec.loader.exec_module(m) |
|
|
|
|
| def main() -> None: |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--out", default=str(HERE.parent.parent / "evidence" / "text2sql-round1" / "data")) |
| ap.add_argument("--max-usd", type=float, default=0.10) |
| ap.add_argument("--workers", type=int, default=6) |
| a = ap.parse_args() |
| key = os.environ.get("NEBIUS_API_KEY", "") |
| if not key: |
| sys.exit("NEBIUS_API_KEY is not set") |
| out = Path(a.out) |
| gold = [json.loads(line) for line in open(out / "golden.jsonl", encoding="utf-8") if line.strip()] |
| dbs = json.load(open(out / "dbs.json", encoding="utf-8")) |
| spent = {"in": 0, "out": 0, "stop": False} |
| lock = threading.Lock() |
| |
| have: dict[int, str] = {} |
| prior = out / "teacher2.jsonl" |
| if prior.exists(): |
| for line in open(prior, encoding="utf-8"): |
| if line.strip(): |
| r0 = json.loads(line) |
| if r0.get("text") is not None: |
| have[r0["i"]] = r0["text"] |
| print(f"{len(have)} answers already saved; asking the other {len(gold) - len(have)}") |
|
|
| def ask(i: int) -> dict: |
| if i in have: |
| return {"i": i, "text": have[i], "error": None} |
| with lock: |
| usd = (spent["in"] * PRICE_IN + spent["out"] * PRICE_OUT) / 1e6 |
| if usd >= a.max_usd: |
| spent["stop"] = True |
| return {"i": i, "text": None, "error": "cap"} |
| body = json.dumps( |
| { |
| "model": MODEL, |
| "messages": gold[i]["prompt"], |
| "temperature": 0, |
| "max_tokens": 600, |
| "chat_template_kwargs": {"enable_thinking": False}, |
| } |
| ).encode() |
| req = urllib.request.Request( |
| f"{BASE}/chat/completions", body, {"Authorization": f"Bearer {key}", "Content-Type": "application/json"} |
| ) |
| for attempt in range(4): |
| try: |
| with urllib.request.urlopen(req, timeout=90) as r: |
| d = json.load(r) |
| u = d.get("usage") or {} |
| with lock: |
| spent["in"] += int(u.get("prompt_tokens", 0)) |
| spent["out"] += int(u.get("completion_tokens", 0)) |
| return {"i": i, "text": d["choices"][0]["message"]["content"], "error": None} |
| except Exception as e: |
| if attempt == 3: |
| return {"i": i, "text": None, "error": type(e).__name__} |
| time.sleep(2 * (attempt + 1)) |
| return {"i": i, "text": None, "error": "unreachable"} |
|
|
| t0 = time.time() |
| with ThreadPoolExecutor(a.workers) as ex: |
| answers = list(ex.map(ask, range(len(gold)))) |
| usd = (spent["in"] * PRICE_IN + spent["out"] * PRICE_OUT) / 1e6 |
| with open(out / "teacher2.jsonl", "w", encoding="utf-8") as f: |
| for r in answers: |
| f.write(json.dumps(r) + "\n") |
| got = [r for r in answers if r["text"] is not None] |
| print( |
| f"asked {len(gold)}, answered {len(got)}, errors {len(gold) - len(got)}, spend about ${usd:.4f}, {time.time() - t0:.0f}s" |
| ) |
| if len(got) < len(gold): |
| print("errors:", sorted({r["error"] for r in answers if r["error"]})) |
|
|
| |
| raw = [] |
| for r in answers: |
| t = r["text"] or "" |
| side = {"text": t, "mean_prob": 1.0, "min_prob": 1.0, "tokens_in": 0, "tokens_out": 0} |
| raw.append({"i": r["i"], "teacher": gold[r["i"]]["completion"][0]["content"], "base": side, "adapter": side}) |
| rows = m.annotate(raw, gold, dbs) |
| agree = sum(1 for r in rows if r["ok"]["adapter"]) |
| n = len(rows) |
| res = { |
| "what": "the teacher answering the exam prompt, scored against the stored label by running both on the same database", |
| "n": n, |
| "answered": len(got), |
| "agree": agree, |
| "rate": round(agree / n, 4), |
| "wilson95": m.wilson(agree, n), |
| "spend_usd_estimate": round(usd, 4), |
| "tokens": {"in": spent["in"], "out": spent["out"]}, |
| "model": MODEL, |
| } |
| (out / "teacher_selfcheck.json").write_text(json.dumps(res, indent=2), encoding="utf-8") |
| print(json.dumps(res, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
