Upload significance.py with huggingface_hub

significance.py

@@ -0,0 +1,235 @@
+"""Exact paired significance tests for every entry in the portfolio.
+
+    python significance.py                 # every entry with verdicts on disk
+    python significance.py molperceive     # one entry
+    python significance.py --stage         # regenerate the verdict files first
+
+WHAT IS TESTED, AND WHY THIS TEST
+---------------------------------
+Every eval in this portfolio is a PAIRED design: the same held-out row is answered by the
+base and by the tuned model, in one process, under identical greedy decoding. Paired binary
+outcomes call for McNemar's test, and because some of our discordant counts are small (and
+because an exact test needs no large-sample assumption to defend), this uses the EXACT
+McNemar test rather than the chi-square approximation.
+
+Concordant rows carry no information about which model is better: a row both models get
+right, or both get wrong, is equally likely under either hypothesis. So the test conditions
+on the DISCORDANT rows, of which there are n = b + c:
+
+    b = base correct, tuned wrong        (evidence for the base)
+    c = base wrong,  tuned correct       (evidence for the tuned model)
+
+Under the null "the adapter is no better than the base", each discordant row is a fair coin,
+so c ~ Binomial(n, 0.5). The two-sided exact p-value is
+
+    p = min(1, 2 * P(X >= max(b, c)))        X ~ Binomial(n, 0.5)
+
+computed with exact integer binomial coefficients, no floating-point survival function and
+no normal approximation.
+
+AgriReason is the one entry that is not scored by exact match. It was judged blind and
+pairwise, so its verdicts are wins, losses and ties. Ties are DISCARDED rather than split,
+which is the standard sign test and the conservative choice: splitting ties would inflate
+the effective sample and flatter the result. The same binomial machinery then applies, with
+b = base wins and c = tuned wins.
+
+WHAT A SMALL p DOES AND DOES NOT MEAN
+-------------------------------------
+It means the measured difference is very unlikely to be sampling noise. It says nothing
+about whether the held-out slice is representative, whether the labels are right, or
+whether the task is worth doing. Those are argued elsewhere on each card and are not
+statistical questions. A p-value cannot rescue a bad slice, and this file does not pretend
+otherwise.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+GEN = ROOT / "docs" / "eval" / "gcp"
+EVAL = ROOT / "data" / "eval"
+VER = ROOT / "docs" / "eval" / "significance"
+PY = str(ROOT / ".venv" / "bin" / "python")
+
+# entry -> list of (label, verdict file, field carrying the headline boolean)
+# Verdict files carry one row per (row, column) pair with column in {base, tuned}.
+PAIRED = {
+    "molperceive": [
+        ("held-out, familiar scaffolds", "mp_v2__mp_held_seen.jsonl", "joint"),
+        ("held-out, novel scaffolds", "mp_v2__mp_held_novel.jsonl", "joint"),
+        ("real molecules, wwPDB CCD", "mp_v2__mp_real.jsonl", "joint"),
+        ("hard shard, 4 to 9 rings", "mp_v2__mp_hard.jsonl", "joint"),
+    ],
+    "flashfacts": [
+        ("ff_held", "ff_v1__ff_held.jsonl", "strict_match"),
+        ("ff_hard", "ff_v1__ff_hard.jsonl", "strict_match"),
+        ("ff_ood", "ff_v1__ff_ood.jsonl", "strict_match"),
+    ],
+    "chrono": [
+        ("headline held-out", "chrono_v1__chrono_held.jsonl", "strict"),
+        ("hard shard", "chrono_v1__chrono_held_hard.jsonl", "strict"),
+        ("enumerated calendar", "chrono_v1__chrono_enumerated.jsonl", "strict"),
+        ("range slice, 2031 to 2035", "chrono_v1__chrono_range.jsonl", "strict"),
+    ],
+    "cashsage": [
+        ("held-out", "cs_v2__cs_held.jsonl", "strict"),
+        ("hard", "cs_v2__cs_hard.jsonl", "strict"),
+        ("2026 rules", "cs_v2__cs_held_2026.jsonl", "strict"),
+    ],
+    "hr": [
+        ("held-out tool probes", "hr__hr_tool.jsonl", "overall"),
+        ("harder probe set", "hr__hr_tool_hard.jsonl", "overall"),
+    ],
+    "chart": [
+        ("held-out ChartForge", "chart__chart_held.jsonl", "ok"),
+    ],
+}
+
+
+def two_sided_exact_binomial(b: int, c: int) -> float:
+    """Exact two-sided binomial test at p=0.5 on b+c discordant pairs.
+
+    Integer arithmetic throughout: the tail is summed as an exact integer count of
+    outcomes and divided once at the end, so a p-value of 1e-150 is not an artifact of
+    accumulated float error. Returns 1.0 when there is nothing to test.
+    """
+    n = b + c
+    if n == 0:
+        return 1.0
+    k = max(b, c)
+    tail = sum(math.comb(n, i) for i in range(k, n + 1))
+    # 2 * tail / 2**n, computed as a ratio of exact integers before the float divide.
+    p = 2.0 * tail / (2 ** n) if n < 1000 else 2.0 * math.exp(
+        math.log(tail) - n * math.log(2))
+    return min(1.0, p)
+
+
+def fmt_p(p: float) -> str:
+    if p == 0.0:
+        return "< 1e-300"
+    if p < 1e-4:
+        return f"{p:.1e}".replace("e-0", "e-")
+    return f"{p:.4f}"
+
+
+def load_pairs(path: Path, field: str) -> tuple[list[bool], list[bool]]:
+    """Two verdict shapes exist in this repo and both are read here rather than normalised.
+
+      LONG : one row per (id, column), column in {base, tuned}, headline at top level.
+             molperceive, chrono, cashsage.
+      WIDE : one row per id carrying nested {"base": {...}, "tuned": {...}}.
+             flashfacts.
+
+    Rewriting either scorer to agree with the other would change a released file to suit a
+    convenience script, which is backwards. The shape is detected per file instead.
+    """
+    rows = [json.loads(l) for l in path.read_text().split("\n")
+            if l.strip() and not l.lstrip().startswith("#")]
+    if not rows:
+        return [], []
+    base: dict[str, bool] = {}
+    tuned: dict[str, bool] = {}
+
+    wide = isinstance(rows[0].get("base"), dict) and isinstance(rows[0].get("tuned"), dict)
+    for r in rows:
+        rid = str(r.get("id"))
+        if wide:
+            base[rid] = bool(r["base"].get(field))
+            tuned[rid] = bool(r["tuned"].get(field))
+        else:
+            col = r.get("column")
+            if col == "base":
+                base[rid] = bool(r.get(field))
+            elif col == "tuned":
+                tuned[rid] = bool(r.get(field))
+    ids = [i for i in tuned if i in base]
+    return [base[i] for i in ids], [tuned[i] for i in ids]
+
+
+def mcnemar(base: list[bool], tuned: list[bool]) -> dict:
+    b = sum(1 for x, y in zip(base, tuned) if x and not y)
+    c = sum(1 for x, y in zip(base, tuned) if y and not x)
+    return {"n": len(base), "b_base_only": b, "c_tuned_only": c,
+            "p": two_sided_exact_binomial(b, c)}
+
+
+def agri_sign_test() -> dict | None:
+    """AgriReason: blind pairwise verdicts, decoded through the side mapping."""
+    v = ROOT / "docs" / "eval" / "held_verdicts.jsonl"
+    m = ROOT / "docs" / "eval" / "held_mapping.json"
+    if not (v.exists() and m.exists()):
+        return None
+    verdicts = [json.loads(l) for l in v.read_text().split("\n") if l.strip()]
+    mapping = json.loads(m.read_text())
+    tuned = base = tie = 0
+    for row in verdicts:
+        w, a_arm = row["winner"], mapping[row["id"]]
+        if w == "tie":
+            tie += 1
+            continue
+        arm = a_arm if w == "A" else ("base" if a_arm == "tuned" else "tuned")
+        if arm == "tuned":
+            tuned += 1
+        else:
+            base += 1
+    return {"n": tuned + base + tie, "b_base_only": base, "c_tuned_only": tuned,
+            "ties_discarded": tie, "p": two_sided_exact_binomial(base, tuned)}
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("entries", nargs="*")
+    ap.add_argument("--out", default=str(ROOT / "docs" / "eval" / "significance.json"))
+    args = ap.parse_args()
+
+    wanted = args.entries or (list(PAIRED) + ["agri"])
+    out: dict[str, dict] = {}
+    missing: list[str] = []
+
+    for entry in wanted:
+        if entry == "agri":
+            r = agri_sign_test()
+            if r is None:
+                missing.append("agri")
+                continue
+            out["agri"] = {"test": "exact sign test on decisive pairs, ties discarded",
+                           "slices": {"held-out, blind pairwise": r}}
+            print(f"\n=== agri  (exact sign test, ties discarded)")
+            print(f"  {'held-out, blind pairwise':34} n={r['n']:4}  "
+                  f"tuned {r['c_tuned_only']:4}  base {r['b_base_only']:4}  "
+                  f"ties {r['ties_discarded']:3}  p {fmt_p(r['p'])}")
+            continue
+
+        if entry not in PAIRED:
+            print(f"unknown entry {entry}")
+            continue
+        print(f"\n=== {entry}  (exact McNemar on discordant pairs)")
+        slices: dict[str, dict] = {}
+        for label, fname, field in PAIRED[entry]:
+            p = VER / fname
+            if not p.exists():
+                print(f"  {label:34} NO VERDICT FILE ({fname})")
+                missing.append(f"{entry}:{fname}")
+                continue
+            base, tuned = load_pairs(p, field)
+            r = mcnemar(base, tuned)
+            slices[label] = r
+            print(f"  {label:34} n={r['n']:4}  tuned-only {r['c_tuned_only']:4}  "
+                  f"base-only {r['b_base_only']:4}  p {fmt_p(r['p'])}")
+        if slices:
+            out[entry] = {"test": "exact McNemar, two-sided, null p=0.5 on discordant pairs",
+                          "slices": slices}
+
+    Path(args.out).write_text(json.dumps(out, indent=1) + "\n")
+    print(f"\nwrote {args.out}")
+    if missing:
+        print(f"missing verdicts: {len(missing)} -> {missing[:6]}")
+
+
+if __name__ == "__main__":
+    main()