Upload common/scoring.py with huggingface_hub

common/scoring.py

@@ -0,0 +1,201 @@
+"""Scoring harness shared by every entry's scorer.
+
+Reads the generation files gcp_eval.py writes and handles the two modes uniformly:
+
+    {"id","category","prompt","reference","tuned","base"}   adapter run
+    {"id","category","prompt","reference","output"}         Day-0 base-only run
+
+Conventions carried over from the three scorers that won the finished entries:
+
+- A per-row metric returns True, False, or **None meaning not applicable**, and None is
+  excluded from that metric's denominator rather than counted wrong.
+- A metric that is a strict conjunction gets no partial credit, because partial credit
+  hides the failure that matters: a confidently wrong answer that looks well-formed.
+- If nothing was scoreable, say so loudly. A silent 0.0% reads like a model result when
+  it is really a harness failure, and that has cost this project real time.
+- Print the DELTA in both points and relative percent, because the competition scores
+  relative improvement over the base.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Callable, Sequence
+
+LABELS = {"tuned": "TUNED", "base": "BASE", "output": "BASE (day-0)"}
+
+
+def load(path: str | Path) -> list[dict]:
+    rows = [json.loads(l) for l in Path(path).read_text().splitlines() if l.strip()]
+    if not rows:
+        raise SystemExit(f"{path}: no rows")
+    return rows
+
+
+def columns(rows: Sequence[dict]) -> list[str]:
+    """Which prediction columns this file carries."""
+    return ["tuned", "base"] if "tuned" in rows[0] else ["output"]
+
+
+def score_file(rows: Sequence[dict],
+               metrics: dict[str, Callable[[str, dict], bool | None]]) -> dict:
+    """Apply each metric to each row for each column.
+
+    metrics maps a metric name to fn(prediction_text, row) -> True | False | None.
+    Returns {column: {metric: {"pct","n_true","n_scored","n_skipped"}}}.
+    """
+    out: dict[str, dict] = {}
+    for col in columns(rows):
+        per: dict[str, dict] = {}
+        for name, fn in metrics.items():
+            t = s = k = 0
+            for r in rows:
+                v = fn(r.get(col) or "", r)
+                if v is None:
+                    k += 1
+                    continue
+                s += 1
+                t += bool(v)
+            per[name] = {"pct": round(100.0 * t / s, 1) if s else 0.0,
+                         "n_true": t, "n_scored": s, "n_skipped": k}
+        out[col] = per
+    return out
+
+
+def report(result: dict, title: str, headline: str | None = None) -> None:
+    """Print the metric table, the harness warning, and the DELTA block."""
+    cols = list(result)
+    names = list(next(iter(result.values()))) if result else []
+
+    print("=" * 72)
+    print(title)
+    print("=" * 72)
+    w = max([len(n) for n in names] + [22])
+    print(f"{'metric':<{w}}  " + "  ".join(f"{LABELS.get(c, c):>14}" for c in cols))
+    for n in names:
+        cells = []
+        for c in cols:
+            m = result[c][n]
+            cells.append(f"{m['pct']:>8.1f}%  ({m['n_true']}/{m['n_scored']})".rjust(14))
+        print(f"{n:<{w}}  " + "  ".join(cells))
+
+    for c in cols:
+        for n in names:
+            if result[c][n]["n_scored"] == 0:
+                print(f"\nWARNING: 0 of the rows were scoreable for {n!r} on column {c!r}.")
+                print("  This is a HARNESS failure, not a model result. Check that the")
+                print("  generation file matches the slice and that ids/references parse.")
+
+    if headline and len(cols) == 2 and headline in names:
+        b = result["base"][headline]["pct"]
+        t = result["tuned"][headline]["pct"]
+        rel = f"{(t - b) / b * 100:+.0f}%" if b else "n/a (base is 0)"
+        print(f"\nDELTA {headline}: {b:.1f}% to {t:.1f}%  "
+              f"= {t - b:+.1f} points, relative {rel}")
+
+
+def length_report(rows: Sequence[dict]) -> dict:
+    """Median output length per column, and the terseness ratio.
+
+    First-class on purpose. Collapsing to terse output raised accuracy and destroyed the
+    win rate twice in this project, and both times it was invisible in the accuracy
+    numbers.
+
+    THE DENOMINATOR IS GOLD, NOT BASE, and that correction was bought with a false
+    positive. On MolPerceive the tuned median was 406 characters against a base of 1,609,
+    a ratio of 0.25 that tripped the old rule and failed a run that was fine. The gold
+    median was also 406: the tuned model matched the target format exactly, and the base
+    was long only because it rambles through chemistry it gets wrong. Measuring terseness
+    against a verbose, incorrect base inverts the rule precisely when the base is worst.
+
+    So the gate is `tuned / gold`, which is what "did the model get terser than it should
+    be" actually means. The base ratio is still reported, as context only, because a large
+    gap between the two is informative about the base rather than about us.
+
+    A guard that cries wolf is worse than no guard, because it trains you to skip it.
+    """
+    def med(xs: list[int]) -> int:
+        return sorted(xs)[len(xs) // 2] if xs else 0
+
+    cols = columns(rows)
+    out = {c: med([len(r.get(c) or "") for r in rows]) for c in cols}
+
+    # The reference column is the gold completion; scorers name it "reference".
+    gold = med([len(r.get("reference") or "") for r in rows])
+    if gold:
+        out["gold"] = gold
+    if "tuned" in out and "base" in out and out["base"]:
+        out["ratio_tuned_over_base"] = round(out["tuned"] / out["base"], 2)
+    if "tuned" in out and gold:
+        ratio = out["tuned"] / gold
+        out["ratio_tuned_over_gold"] = round(ratio, 2)
+        out["terseness_flag"] = ratio < 0.6
+        out["terseness_basis"] = "gold"
+    elif "tuned" in out and "base" in out and out["base"]:
+        # No gold available (Day-0 probe files carry no reference). Fall back to base and
+        # SAY SO, so a flag raised on the weaker basis is never mistaken for the real gate.
+        out["terseness_flag"] = out["ratio_tuned_over_base"] < 0.6
+        out["terseness_basis"] = "base (no gold column present, weaker signal)"
+    return out
+
+
+def _selftest() -> None:
+    rows = [
+        {"id": "1", "prompt": "p", "reference": "42", "tuned": "42", "base": "41"},
+        {"id": "2", "prompt": "p", "reference": "7", "tuned": "7", "base": "7"},
+        {"id": "3", "prompt": "p", "reference": "9", "tuned": "9", "base": ""},
+    ]
+    exact = lambda pred, row: pred.strip() == row["reference"]
+    res = score_file(rows, {"exact": exact})
+    assert res["tuned"]["exact"]["pct"] == 100.0, res
+    assert res["base"]["exact"]["pct"] == 33.3, res
+    ok = 2
+
+    # None must leave the denominator, not count as wrong.
+    half = lambda pred, row: None if row["id"] == "3" else pred.strip() == row["reference"]
+    res2 = score_file(rows, {"h": half})
+    assert res2["tuned"]["h"]["n_scored"] == 2 and res2["tuned"]["h"]["n_skipped"] == 1
+    assert res2["tuned"]["h"]["pct"] == 100.0
+    ok += 2
+
+    # The terseness gate, PROVEN able to both pass and fail on its new basis. It is
+    # measured against gold, and the case that motivated the change is the first one: a
+    # verbose wrong base must not fail a tuned model that matches the target format.
+    verbose_base = [
+        {"id": "1", "prompt": "p", "reference": "x" * 400, "tuned": "y" * 400,
+         "base": "z" * 1600},
+    ]
+    lr = length_report(verbose_base)
+    assert lr["terseness_flag"] is False, lr        # 1.00x gold, despite 0.25x base
+    assert lr["ratio_tuned_over_gold"] == 1.0, lr
+    assert lr["ratio_tuned_over_base"] == 0.25, lr  # still reported, as context
+    assert lr["terseness_basis"] == "gold", lr
+    ok += 1
+
+    # And it MUST fire when the tuned model really did collapse against gold.
+    collapsed = [
+        {"id": "1", "prompt": "p", "reference": "x" * 400, "tuned": "y" * 100,
+         "base": "z" * 400},
+    ]
+    lr2 = length_report(collapsed)
+    assert lr2["terseness_flag"] is True, lr2       # 0.25x gold
+    ok += 1
+
+    # Day-0 single-column files.
+    d0 = [{"id": "1", "prompt": "p", "reference": "42", "output": "42"}]
+    assert columns(d0) == ["output"]
+    assert score_file(d0, {"exact": exact})["output"]["exact"]["pct"] == 100.0
+    ok += 2
+
+    # Terseness canary fires when tuned collapses.
+    terse = [{"id": "1", "prompt": "p", "reference": "", "tuned": "x", "base": "x" * 100}]
+    assert length_report(terse)["terseness_flag"] is True
+    fine = [{"id": "1", "prompt": "p", "reference": "", "tuned": "x" * 90, "base": "x" * 100}]
+    assert length_report(fine)["terseness_flag"] is False
+    ok += 2
+
+    print(f"scoring selftest: {ok} assertions OK")
+
+
+if __name__ == "__main__":
+    _selftest()