| """Measure a trained adapter against the teacher on held-out rows, and let anyone recompute the numbers. |
| |
| Two steps, so a judge can check the result without a GPU: |
| |
| generate (GPU) answer every held-out prompt with the base model and with base + adapter; write raw.jsonl |
| report (CPU) read raw.jsonl and compute agreement, coverage, precision and savings; write results.json |
| verify (CPU) recompute the report from raw.jsonl and fail if results.json differs |
| |
| python scripts/measure_adapter.py generate --golden golden.jsonl --adapter ./adapter --out raw.jsonl |
| python scripts/measure_adapter.py report --raw raw.jsonl --golden golden.jsonl --adapter ./adapter --out results.json |
| python scripts/measure_adapter.py verify --raw raw.jsonl --results results.json |
| |
| golden.jsonl rows: {"prompt": [messages], "completion": [{"role": "assistant", "content": <teacher answer>}]}, the |
| rows `dataset.write_training` writes for held-out (golden) examples. Calibration and measurement use different rows |
| (even rows set the confidence threshold, odd rows measure it), as in ratchet/nightschool/evaluate.py (invariant 6). |
| Every number is computed here from raw.jsonl; none is typed in. Prices are inputs and are written into results.json. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import platform |
| import re |
| import sys |
| import time |
| from pathlib import Path |
| from typing import Any |
|
|
| FIELDS = ( |
| "category", |
| "priority", |
| ) |
|
|
|
|
| def sha256_file(path: str | Path) -> str: |
| h = hashlib.sha256() |
| with open(path, "rb") as f: |
| for chunk in iter(lambda: f.read(1 << 20), b""): |
| h.update(chunk) |
| return h.hexdigest() |
|
|
|
|
| def adapter_hash(path: str | Path) -> str | None: |
| p = Path(path) |
| f = p / "adapter_model.safetensors" if p.is_dir() else p |
| return sha256_file(f) if f.exists() else None |
|
|
|
|
| def load_jsonl(path: str | Path) -> list[dict[str, Any]]: |
| return [json.loads(line) for line in Path(path).read_text(encoding="utf-8").splitlines() if line.strip()] |
|
|
|
|
| def parse_answer(text: str) -> dict[str, Any] | None: |
| m = re.search(r"\{.*\}", text, re.DOTALL) |
| if not m: |
| return None |
| try: |
| obj = json.loads(m.group(0)) |
| except ValueError: |
| return None |
| return obj if isinstance(obj, dict) else None |
|
|
|
|
| def key_of(text: str) -> tuple | str: |
| """What counts as 'the same answer': the compared JSON fields, or the whitespace-normalised text.""" |
| obj = parse_answer(text) |
| if obj is not None and any(k in obj for k in FIELDS): |
| return tuple(str(obj.get(k, "")).strip().lower() for k in FIELDS) |
| return " ".join(text.lower().split()) |
|
|
|
|
| |
|
|
|
|
| def _norm(v: Any) -> Any: |
| if isinstance(v, float): |
| return round(v, 6) |
| return v.hex() if isinstance(v, bytes) else v |
|
|
|
|
| def sql_connect(script: str): |
| import sqlite3 |
|
|
| conn = sqlite3.connect(":memory:") |
| conn.executescript(script) |
| conn.set_authorizer(lambda action, *_: sqlite3.SQLITE_OK if action in (20, 21, 31, 33) else sqlite3.SQLITE_DENY) |
| return conn |
|
|
|
|
| def sql_extract(text: str) -> str: |
| m = re.search(r"```(?:sql|sqlite)?\s*(.*?)```", text, re.DOTALL | re.IGNORECASE) |
| return (m.group(1) if m else text).strip().rstrip(";").strip() |
|
|
|
|
| def sql_rows(conn, text: str): |
| """(rows, ordered) for one read-only SELECT that runs within 2 s, else None. Never raises.""" |
| import sqlite3 |
|
|
| q = sql_extract(text) |
| if not re.match(r"(?is)^(select|with)\b", q): |
| return None |
| deadline = time.monotonic() + 2.0 |
| conn.set_progress_handler(lambda: 1 if time.monotonic() > deadline else 0, 2000) |
| try: |
| rows = conn.execute(q).fetchmany(1001) |
| except (sqlite3.Error, ValueError): |
| return None |
| finally: |
| conn.set_progress_handler(None, 0) |
| return [tuple(_norm(v) for v in r) for r in rows], bool(re.search(r"(?i)\border\s+by\b", q)) |
|
|
|
|
| def sql_same(conn, teacher_text: str, answer_text: str) -> bool: |
| """Do the two queries return the same rows (column names ignored; order only if the teacher's query orders)?""" |
| t, a = sql_rows(conn, teacher_text), sql_rows(conn, answer_text) |
| if t is None or a is None: |
| return False |
| if t[1]: |
| return t[0] == a[0] |
| return sorted(map(repr, t[0])) == sorted(map(repr, a[0])) |
|
|
|
|
| def annotate( |
| raw: list[dict[str, Any]], |
| golden: list[dict[str, Any]] | None, |
| dbs: dict[str, str] | None, |
| ) -> list[dict[str, Any]]: |
| """Add r["ok"] = {"base": bool, "adapter": bool}: did each answer match the teacher's? JSON mode compares fields; |
| SQL mode executes both queries on the row's database.""" |
| conns: dict[str, Any] = {} |
| out = [] |
| for r in raw: |
| r = dict(r) |
| if dbs is not None and golden is not None: |
| db = golden[r["i"]]["meta"]["db"] |
| if db not in conns: |
| conns[db] = sql_connect(dbs[db]) |
| r["ok"] = {w: sql_same(conns[db], r["teacher"], r[w]["text"]) for w in ("base", "adapter")} |
| r["meta"] = golden[r["i"]]["meta"] |
| else: |
| r["ok"] = {w: key_of(r[w]["text"]) == key_of(r["teacher"]) for w in ("base", "adapter")} |
| out.append(r) |
| return out |
|
|
|
|
| |
|
|
|
|
| def generate(a: argparse.Namespace) -> None: |
| import torch |
| from peft import PeftModel |
| from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig |
|
|
| rows = load_jsonl(a.golden) |
| tok = AutoTokenizer.from_pretrained(a.base, trust_remote_code=True) |
| quant = None |
| if not a.bf16: |
| quant = BitsAndBytesConfig( |
| load_in_4bit=True, |
| bnb_4bit_quant_type="nf4", |
| bnb_4bit_compute_dtype=torch.float16, |
| bnb_4bit_use_double_quant=True, |
| llm_int8_skip_modules=["in_proj", "out_proj", "lm_head"], |
| ) |
| base = AutoModelForCausalLM.from_pretrained( |
| a.base, |
| trust_remote_code=True, |
| quantization_config=quant, |
| device_map="auto", |
| dtype=torch.bfloat16 if a.bf16 else torch.float16, |
| ) |
| |
| |
| _cls = type(base) |
| _orig_prepare = _cls.prepare_inputs_for_generation |
|
|
| def _prepare(self, input_ids, past_key_values=None, **kwargs): |
| cp = kwargs.pop("cache_position", None) |
| if cp is None and past_key_values is not None: |
| try: |
| seen = int(past_key_values.get_seq_length()) |
| except Exception: |
| seen = input_ids.shape[1] - 1 |
| cp = torch.arange(seen, input_ids.shape[1], device=input_ids.device) |
| return _orig_prepare(self, input_ids, past_key_values=past_key_values, cache_position=cp, **kwargs) |
|
|
| _cls.prepare_inputs_for_generation = _prepare |
| model = PeftModel.from_pretrained(base, a.adapter) |
| model.eval() |
| kw = {"enable_thinking": False} |
|
|
| def _safe_generate(fn, **kw): |
| """Decode with the cache; if the model's cache code fails on this transformers version, decode without it (slower).""" |
| try: |
| return fn(**kw) |
| except (TypeError, AttributeError, IndexError, RuntimeError) as e: |
| print(f"generate fell back to use_cache=False after {type(e).__name__}: {str(e)[:120]}", flush=True) |
| return fn(use_cache=False, **kw) |
|
|
| def run(prompt: list[dict[str, str]], with_adapter: bool) -> dict[str, Any]: |
| ids = tok.apply_chat_template( |
| prompt, |
| add_generation_prompt=True, |
| return_tensors="pt", |
| return_dict=True, |
| **kw, |
| ).to("cuda") |
| n_in = ids["input_ids"].shape[1] |
| with torch.no_grad(): |
| if with_adapter: |
| out = _safe_generate( |
| model.generate, |
| **ids, |
| max_new_tokens=a.max_new, |
| do_sample=False, |
| output_scores=True, |
| return_dict_in_generate=True, |
| ) |
| else: |
| with model.disable_adapter(): |
| out = _safe_generate( |
| model.generate, |
| **ids, |
| max_new_tokens=a.max_new, |
| do_sample=False, |
| output_scores=True, |
| return_dict_in_generate=True, |
| ) |
| gen = out.sequences[0][n_in:] |
| probs = [torch.softmax(s[0].float(), -1)[t].item() for s, t in zip(out.scores, gen, strict=True)] |
| return { |
| "text": tok.decode(gen, skip_special_tokens=True), |
| "mean_prob": sum(probs) / max(len(probs), 1), |
| "min_prob": min(probs) if probs else 0.0, |
| "tokens_in": int(n_in), |
| "tokens_out": len(gen), |
| } |
|
|
| t0 = time.time() |
| with open(a.out, "w", encoding="utf-8") as f: |
| for i, r in enumerate(rows): |
| rec = { |
| "i": i, |
| "teacher": r["completion"][0]["content"], |
| "base": run(r["prompt"], False), |
| "adapter": run(r["prompt"], True), |
| } |
| f.write(json.dumps(rec) + "\n") |
| if i % 10 == 0: |
| print(f"{i + 1}/{len(rows)} rows, {time.time() - t0:.0f}s", flush=True) |
|
|
|
|
| |
|
|
|
|
| def wilson(k: int, n: int, z: float = 1.96) -> tuple[float, float]: |
| if n == 0: |
| return (0.0, 1.0) |
| p = k / n |
| d = 1 + z * z / n |
| c = (p + z * z / (2 * n)) / d |
| h = z * ((p * (1 - p) / n + z * z / (4 * n * n)) ** 0.5) / d |
| return (round(max(0.0, c - h), 4), round(min(1.0, c + h), 4)) |
|
|
|
|
| def agreement(rows: list[dict[str, Any]], who: str) -> dict[str, Any]: |
| ok = sum(1 for r in rows if r["ok"][who]) |
| return { |
| "n": len(rows), |
| "agree": ok, |
| "rate": round(ok / len(rows), 4) if rows else None, |
| "wilson95": wilson(ok, len(rows)), |
| } |
|
|
|
|
| def calibrate(rows: list[dict[str, Any]], target: float) -> float: |
| """Lowest confidence threshold whose answered rows agree with the teacher at least `target` of the time.""" |
| best = 1.01 |
| for thr in sorted({r["adapter"]["mean_prob"] for r in rows}, reverse=True): |
| sel = [r for r in rows if r["adapter"]["mean_prob"] >= thr] |
| if sel and sum(r["ok"]["adapter"] for r in sel) / len(sel) >= target: |
| best = thr |
| return best |
|
|
|
|
| def build_report(raw: list[dict[str, Any]], a: argparse.Namespace, golden=None, dbs=None) -> dict[str, Any]: |
| raw = annotate(raw, golden, dbs) |
| cal, test = ( |
| raw[0::2], |
| raw[1::2], |
| ) |
| thr = calibrate(cal, a.target_precision) |
| answered = [r for r in test if r["adapter"]["mean_prob"] >= thr] |
| ok = sum(r["ok"]["adapter"] for r in answered) |
| tin = sum(r["adapter"]["tokens_in"] for r in test) |
| tout = sum(r["adapter"]["tokens_out"] for r in test) |
| teacher_all = (tin * a.teacher_in_per_m + tout * a.teacher_out_per_m) / 1e6 |
| |
| esc = [r for r in test if r["adapter"]["mean_prob"] < thr] |
| cost = ( |
| sum(r["adapter"]["tokens_in"] for r in esc) * a.teacher_in_per_m |
| + sum(r["adapter"]["tokens_out"] for r in esc) * a.teacher_out_per_m |
| ) / 1e6 + ((sum(r["adapter"]["tokens_in"] + r["adapter"]["tokens_out"] for r in answered)) * a.student_per_m) / 1e6 |
| groups: dict[str, dict[str, Any]] = {} |
| if dbs is not None: |
| for field, label in (("difficulty", "difficulty"), ("domain_seen", "domain")): |
| for val in sorted({str(r["meta"][field]) for r in test}): |
| sub = [r for r in test if str(r["meta"][field]) == val] |
| name = f"{label}={('seen' if val == 'True' else 'unseen') if field == 'domain_seen' else val}" |
| groups[name] = { |
| "base": agreement(sub, "base"), |
| "adapter": agreement(sub, "adapter"), |
| } |
| return { |
| "mode": "sql" if dbs is not None else "json", |
| "breakdown_answering_every_row": groups, |
| "rows": {"total": len(raw), "calibration": len(cal), "measured": len(test)}, |
| "base_model_agreement": agreement(test, "base"), |
| "adapter_agreement": agreement(test, "adapter"), |
| "confidence_threshold": round(thr, 4), |
| "target_precision": a.target_precision, |
| "coverage": { |
| "answered": len(answered), |
| "of": len(test), |
| "rate": round(len(answered) / len(test), 4) if test else None, |
| }, |
| "precision_when_answered": { |
| "n": len(answered), |
| "agree": ok, |
| "rate": round(ok / len(answered), 4) if answered else None, |
| "wilson95": wilson(ok, len(answered)), |
| }, |
| "cost_usd_on_measured_rows": { |
| "all_teacher": round(teacher_all, 6), |
| "with_student": round(cost, 6), |
| "saved_pct": round(100 * (1 - cost / teacher_all), 2) if teacher_all else None, |
| "prices_per_million_tokens": { |
| "teacher_in": a.teacher_in_per_m, |
| "teacher_out": a.teacher_out_per_m, |
| "student": a.student_per_m, |
| }, |
| }, |
| "label": "estimate: token counts are measured, prices are inputs (see prices_per_million_tokens)", |
| } |
|
|
|
|
| def report(a: argparse.Namespace) -> None: |
| raw = load_jsonl(a.raw) |
| golden = load_jsonl(a.golden) if a.dbs else None |
| dbs = json.loads(Path(a.dbs).read_text(encoding="utf-8")) if a.dbs else None |
| res = build_report(raw, a, golden, dbs) |
| res["provenance"] = { |
| "raw_sha256": sha256_file(a.raw), |
| "golden_sha256": sha256_file(a.golden) if a.golden else None, |
| "dbs_sha256": sha256_file(a.dbs) if a.dbs else None, |
| "adapter_sha256": adapter_hash(a.adapter) if a.adapter else None, |
| "base_model": a.base, |
| "python": sys.version.split()[0], |
| "platform": platform.platform(), |
| "gpu": a.gpu or None, |
| "run_note": a.note or None, |
| "args": { |
| k: getattr(a, k) |
| for k in ( |
| "target_precision", |
| "teacher_in_per_m", |
| "teacher_out_per_m", |
| "student_per_m", |
| ) |
| }, |
| } |
| Path(a.out).write_text(json.dumps(res, indent=2), encoding="utf-8") |
| print( |
| json.dumps( |
| { |
| k: res[k] |
| for k in ( |
| "adapter_agreement", |
| "coverage", |
| "precision_when_answered", |
| "cost_usd_on_measured_rows", |
| ) |
| }, |
| indent=2, |
| ) |
| ) |
|
|
|
|
| def verify(a: argparse.Namespace) -> None: |
| saved = json.loads(Path(a.results).read_text(encoding="utf-8")) |
| p = saved["provenance"] |
| if sha256_file(a.raw) != p["raw_sha256"]: |
| sys.exit("FAIL: raw.jsonl is not the file the results were computed from") |
| ns = argparse.Namespace(**p["args"]) |
| golden = dbs = None |
| if p.get("dbs_sha256"): |
| if not (a.golden and a.dbs): |
| sys.exit("FAIL: this is a SQL result; pass --golden and --dbs too") |
| if sha256_file(a.golden) != p["golden_sha256"] or sha256_file(a.dbs) != p["dbs_sha256"]: |
| sys.exit("FAIL: golden.jsonl or dbs.json is not the file the results were computed from") |
| golden = load_jsonl(a.golden) |
| dbs = json.loads(Path(a.dbs).read_text(encoding="utf-8")) |
| |
| again = json.loads(json.dumps(build_report(load_jsonl(a.raw), ns, golden, dbs))) |
| bad = [k for k in again if again[k] != saved.get(k)] |
| if bad: |
| sys.exit(f"FAIL: recomputed numbers differ in {bad}") |
| print("OK: every number in results.json was recomputed from raw.jsonl and matches") |
|
|
|
|
| def main(argv: list[str] | None = None) -> None: |
| ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| sub = ap.add_subparsers(dest="cmd", required=True) |
| g = sub.add_parser("generate") |
| g.add_argument("--golden", required=True) |
| g.add_argument("--adapter", required=True) |
| g.add_argument("--base", default="nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16") |
| g.add_argument("--out", required=True) |
| g.add_argument("--max-new", type=int, default=160, help="use 256 for SQL") |
| g.add_argument( |
| "--bf16", |
| action="store_true", |
| help="load in bf16 instead of 4-bit (needs an L4 or better)", |
| ) |
| g.set_defaults(fn=generate) |
| r = sub.add_parser("report") |
| r.add_argument("--raw", required=True) |
| r.add_argument("--golden") |
| r.add_argument( |
| "--dbs", |
| help="dbs.json: score by RUNNING each answer's SQL on the row's database (needs --golden)", |
| ) |
| r.add_argument("--adapter") |
| r.add_argument("--base", default="nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16") |
| r.add_argument("--out", required=True) |
| r.add_argument("--target-precision", type=float, default=0.95) |
| r.add_argument( |
| "--teacher-in-per-m", |
| type=float, |
| default=1.0, |
| help="USD per 1M input tokens (Nemotron 3 Ultra on Token Factory)", |
| ) |
| r.add_argument("--teacher-out-per-m", type=float, default=3.0) |
| r.add_argument( |
| "--student-per-m", |
| type=float, |
| default=0.06, |
| help="USD per 1M tokens for the student; an estimate, set it from your serving cost", |
| ) |
| r.add_argument("--gpu", default="") |
| r.add_argument("--note", default="") |
| r.set_defaults(fn=report) |
| v = sub.add_parser("verify") |
| v.add_argument("--raw", required=True) |
| v.add_argument("--results", required=True) |
| v.add_argument("--golden") |
| v.add_argument("--dbs") |
| v.set_defaults(fn=verify) |
| a = ap.parse_args(argv) |
| a.fn(a) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
