| """Every number the pages show about the two text-to-SQL exams, computed from the saved answers. |
| |
| python scripts/text2sql/exam_numbers.py # write web/src/data/exams.json and docs-site/src/data/exams.json |
| python scripts/text2sql/exam_numbers.py --check # exit 1 if either file differs from what the answers give |
| |
| Strict scoring only (scripts/measure_adapter.py): an answer is right when running it returns the same rows as the reference query on |
| the same database. Standard library plus measure_adapter; no GPU and no network. |
| """ |
|
|
| |
| import argparse |
| import importlib.util |
| import json |
| import math |
| import sys |
| from pathlib import Path |
|
|
| ROOT = Path(__file__).resolve().parents[2] |
| _spec = importlib.util.spec_from_file_location("measure_adapter", ROOT / "scripts" / "measure_adapter.py") |
| m = importlib.util.module_from_spec(_spec) |
| sys.modules["measure_adapter"] = m |
| _spec.loader.exec_module(m) |
|
|
| R1 = ROOT / "evidence" / "text2sql-round1" |
| R2 = ROOT / "evidence" / "text2sql-round2" |
| X2 = ROOT / "evidence" / "text2sql-exam2" |
| OUTPUTS = [ROOT / "web" / "src" / "data" / "exams.json", ROOT / "docs-site" / "src" / "data" / "exams.json"] |
| DIFFICULTIES = ["simple", "join", "aggregate", "hard"] |
| MODELS = [ |
| {"id": "base", "label": "Base model, no training", "short": "Base model"}, |
| {"id": "teacher", "label": "Teacher (Nemotron 3 Ultra), same prompts", "short": "Teacher"}, |
| {"id": "r1", "label": "Adapter, round 1 (821 rows)", "short": "Adapter, round 1"}, |
| {"id": "r2", "label": "Adapter, round 2 (4,322 rows)", "short": "Adapter, round 2"}, |
| ] |
| EXAMS = [ |
| { |
| "id": "exam1", |
| "name": "Exam 1", |
| "rows": 172, |
| "built": "22 Oct 2026", |
| "writer": "Nemotron 3 Ultra, the teacher (open model, OpenMDW-1.1)", |
| "writer_note": "The same model that wrote the training labels, so it favours the teacher and anything trained to copy it.", |
| "industries": "14 industries; 57 of the 172 questions come from five industries that were never in training.", |
| "checked": "Every reference query was run in the sandbox and kept only if it was one read-only SELECT returning 1 to 100 rows.", |
| "fingerprint": "6b9c1db49bbe2aecf4157ed27845fe024d1b4fcb540f93d81b6987b982b22864", |
| "evidence": "evidence/text2sql-round1", |
| }, |
| { |
| "id": "exam2", |
| "name": "Exam 2", |
| "rows": 200, |
| "built": "23 Oct 2026", |
| "writer": "Claude Sonnet 5.5, a different lab's model, used for evaluation only", |
| "writer_note": "Written after training by a different author, so it does not depend on the teacher's style. No closed model's output is training data anywhere in this project.", |
| "industries": "10 industries in neither the training data nor exam 1: museum collections, veterinary clinic, wine distribution, film production, wind farm maintenance, court cases, recycling plant, podcast network, cinema chain, fishing fleet.", |
| "checked": "The same sandbox check, with the same mix as exam 1 (60 simple, 60 join, 40 aggregate, 40 hard). No row shares a question, a query or a set of table names with the training data.", |
| "fingerprint": "b7634971cf6b0d79e64e30e4c16d1253fad65ab9a501a06edc6c9f8e70d69058", |
| "evidence": "evidence/text2sql-exam2", |
| }, |
| ] |
|
|
|
|
| def load(path): |
| return m.load_jsonl(path) |
|
|
|
|
| def wilson(k, n): |
| lo, hi = m.wilson(k, n) |
| return round(lo, 4), round(hi, 4) |
|
|
|
|
| def score(gold, dbs, answers): |
| """Per-question right/wrong for each answers file; answers = {model: (rows, key or None)}.""" |
| conns = {} |
| out = {} |
| for model, (rows, key) in answers.items(): |
| flags = [False] * len(gold) |
| for r in rows: |
| g = gold[r["i"]] |
| db = g["meta"]["db"] |
| if db not in conns: |
| conns[db] = m.sql_connect(dbs[db]) |
| text = r[key]["text"] if key else r["text"] |
| flags[r["i"]] = bool(m.sql_same(conns[db], g["completion"][0]["content"], text)) |
| out[model] = flags |
| return out, conns |
|
|
|
|
| def shape(gold, rows, conns): |
| """How the teacher's misses look: same rows with another column count, same count other values, other row count.""" |
| c = {"exact": 0, "same_rows_other_columns": 0, "same_count_other_values": 0, "other_row_count": 0, "does_not_run": 0} |
| for r in rows: |
| g = gold[r["i"]] |
| conn = conns[g["meta"]["db"]] |
| ref, ans = m.sql_rows(conn, g["completion"][0]["content"]), m.sql_rows(conn, r["text"]) |
| if ans is None: |
| c["does_not_run"] += 1 |
| elif m.sql_same(conn, g["completion"][0]["content"], r["text"]): |
| c["exact"] += 1 |
| elif len(ref[0]) != len(ans[0]): |
| c["other_row_count"] += 1 |
| elif ref[0] and ans[0] and len(ref[0][0]) != len(ans[0][0]): |
| c["same_rows_other_columns"] += 1 |
| else: |
| c["same_count_other_values"] += 1 |
| return c |
|
|
|
|
| def exact_two_sided(up, down): |
| n, k = up + down, min(up, down) |
| return round(min(1.0, 2 * sum(math.comb(n, i) for i in range(k + 1)) / 2**n), 3) |
|
|
|
|
| def build() -> dict: |
| data = {"scores": {}, "difficulty": {}, "r1_to_r2": {}, "teacher_shape": {}} |
| |
| g1 = load(R1 / "data" / "golden.jsonl") |
| d1 = json.loads((R1 / "data" / "dbs.json").read_text(encoding="utf-8")) |
| r1_raw, r2_raw, t1 = ( |
| load(R1 / "answers" / "raw.jsonl"), |
| load(R2 / "answers" / "raw_r2.jsonl"), |
| load(R1 / "answers" / "teacher2.jsonl"), |
| ) |
| s1, c1 = score( |
| g1, d1, {"base": (r1_raw, "base"), "r1": (r1_raw, "adapter"), "r2": (r2_raw, "adapter"), "teacher": (t1, None)} |
| ) |
| g2 = load(X2 / "data" / "golden.jsonl") |
| d2 = json.loads((X2 / "data" / "dbs.json").read_text(encoding="utf-8")) |
| v1, v2, t2 = ( |
| load(X2 / "answers" / "raw_v1.jsonl"), |
| load(X2 / "answers" / "raw_v2.jsonl"), |
| load(X2 / "answers" / "teacher2.jsonl"), |
| ) |
| s2, c2 = score(g2, d2, {"base": (v1, "base"), "r1": (v1, "adapter"), "r2": (v2, "adapter"), "teacher": (t2, None)}) |
| for exam, gold, s, conns, teacher_rows in (("exam1", g1, s1, c1, t1), ("exam2", g2, s2, c2, t2)): |
| n = len(gold) |
| data["scores"][exam] = {} |
| for model in ("base", "teacher", "r1", "r2"): |
| k = sum(s[model]) |
| lo, hi = wilson(k, n) |
| data["scores"][exam][model] = {"agree": k, "n": n, "rate": round(k / n, 4), "lo": lo, "hi": hi} |
| diff = {} |
| for d in DIFFICULTIES: |
| idx = [i for i, g in enumerate(gold) if g["meta"]["difficulty"] == d] |
| diff[d] = {"n": len(idx), **{model: sum(s[model][i] for i in idx) for model in ("base", "teacher", "r1", "r2")}} |
| data["difficulty"][exam] = diff |
| up = sum(1 for a, b in zip(s["r1"], s["r2"], strict=True) if not a and b) |
| down = sum(1 for a, b in zip(s["r1"], s["r2"], strict=True) if a and not b) |
| both = sum(1 for a, b in zip(s["r1"], s["r2"], strict=True) if a and b) |
| data["r1_to_r2"][exam] = { |
| "wrong_to_right": up, |
| "right_to_wrong": down, |
| "both_right": both, |
| "both_wrong": n - up - down - both, |
| "p": exact_two_sided(up, down), |
| } |
| data["teacher_shape"][exam] = shape(gold, teacher_rows, conns) |
| return {"updated": "2026-10-24", "models": MODELS, "exams": EXAMS, **data} |
|
|
|
|
| def main() -> int: |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--check", action="store_true") |
| a = ap.parse_args() |
| text = json.dumps(build(), indent=1, ensure_ascii=False) + "\n" |
| bad = 0 |
| for path in OUTPUTS: |
| if a.check: |
| if not path.exists() or path.read_text(encoding="utf-8") != text: |
| print(f"STALE: {path.relative_to(ROOT)} differs from the saved answers; run scripts/text2sql/exam_numbers.py") |
| bad += 1 |
| else: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text(text, encoding="utf-8", newline="\n") |
| print("wrote", path.relative_to(ROOT)) |
| if a.check and not bad: |
| print("OK: both exams.json files match the saved answers") |
| return 1 if bad else 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
