Add the calibration config (11,018 validation/dev rows, 32 benchmarks); evaluate.py: Skill Index = Brier skill at a temperature fitted on it

README.md

@@ -184,6 +184,10 @@ configs:
   data_files:
   - split: test
     path: crossingguard/test.parquet
+- config_name: calibration
+  data_files:
+  - split: validation
+    path: calibration/validation.parquet
 ---
 
 # OpenNLI eval sets
@@ -207,6 +211,8 @@ Labels are mapped from the model's `id2label`, or use `--label-order` (e.g. `ent
 - accuracy per dataset
 - category score = mean over datasets
 - overall = mean of the 4 category scores.
+- Skill Index (the leaderboard headline) = Brier skill vs a uniform guess, per dataset (floored at −100), averaged the same
+  way, at each model's fitted temperature (see Calibration).
 
 >[!Note]
 > For license information, refer to the original dataset's license.
@@ -215,6 +221,13 @@ Labels are mapped from the model's `id2label`, or use `--label-order` (e.g. `ent
 > DocNLI (1,000) and VitaminC (10,000) are fixed random samples of their test splits.
 
 
+## Calibration
+
+The `calibration` config (split `validation`, 11,018 rows) is used only to fit each model's temperature: one number that
+rescales the model's confidence before the Skill Index is computed. It's drawn from the validation / dev splits of 32
+benchmarks (never a test split), up to 400 rows each, labelled like the test sets, with no text overlapping any test set.
+Models may calibrate on it however they like; it never scores anything.
+
 | Config | Dataset | Category | Rows | Labels |
 | --- | --- | --- | ---: | --- |
 | `mnli` | MNLI-m | NLI | 9,815 | 3way |

calibration/validation.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:55d02d454c4205438b93ea280737a0b77a0efc1fa277e9be2ea29f000832a724
+size 9678332

evaluate.py

@@ -10,8 +10,22 @@ Scoring (same as the leaderboard):
   - a row with label 0/1/2 is correct when the prediction matches; a 2-way row (label 3 = not_entailment) is correct when
     the prediction is neutral or contradiction;
   - dataset score = accuracy; category score = mean over its datasets; overall = mean of the category scores (macro);
-  - skill (the leaderboard's default view) = max(0, (accuracy - chance) / (1 - chance)) per dataset, chance = 1/3 for 3-way
-    and 1/2 for 2-way datasets (mixed sets: weighted by their share of 2-way rows), aggregated the same way.
+  - Skill Index (the leaderboard's headline, 2026-10-30) = Brier skill score per dataset, aggregated the same way:
+      skill = 1 - sum(Brier) / sum(Brier of a uniform guess), from the model's probabilities. 3-way rows: Brier summed over
+      the 3 classes, uniform guess 1/3 each (Brier 2/3). Rows of a 2-way dataset (and label-3 rows of a mixed one): the
+      entailment decision, Brier = 2 (P(entailment) - y)^2, uniform guess 1/2 (Brier 1/2). 0 = no better than guessing,
+      100 = always right with full confidence; negative = confidently wrong often enough to do worse than guessing,
+      floored at -100 per dataset (twice the guess's error), so one pathological dataset cannot swamp a category.
+      Brier is a proper scoring rule: it is the expected cost of acting on the probabilities over all cost trade-offs, so
+      it rewards both being right and being calibrated, and cannot be improved by misreporting confidence.
+      A model that only returns labels can be scored with one-hot probabilities.
+      Scored at a fitted temperature (2026-10-30): the logits are divided by one temperature per model, fitted to
+      maximise the Brier skill on the `calibration` config (11k rows from the validation / dev splits of 32 benchmarks,
+      never a test split), then applied to every test set. So the index measures the model once its confidence is
+      calibrated on held-out data, as a production user would; `temperature` reports how far off it was (1 = already
+      calibrated, > 1 = overconfident) and `skill_raw` is the score as shipped (T = 1).
+  - acc_skill = max(0, (accuracy - chance) / (1 - chance)) per dataset (chance 1/3 for 3-way, 1/2 for 2-way; mixed sets
+    weighted by their share of 2-way rows); auroc = AUROC of P(entailment) for entailment vs not; both aggregated the same way.
 Calibration (on by default): per-row probabilities are saved (--preds-dir) and expected calibration error is reported
 per dataset (15 equal-width confidence bins), averaged the same way as accuracy. 3-way rows: confidence = the top class
 probability; 2-way rows: the binary decision P(entailment) vs 1 - P(entailment).
@@ -49,6 +63,54 @@ def chance_level(df: pd.DataFrame) -> float:
     return share / 2 + (1 - share) / 3
 
 
+def brier_skill(p: np.ndarray, label: np.ndarray, label_space: str, floor: float = -1.0) -> float:
+    """Brier skill vs a uniform guess (see the module docstring). p: (n, 3) probabilities in entailment/neutral/contradiction order."""
+    p = p / p.sum(1, keepdims=True)
+    y = np.asarray(label)
+    two = np.full(len(y), label_space == "2way") | (y == NOT_ENT)
+    ye = (y == 0).astype(float)
+    b3 = ((p - np.eye(4)[y][:, :3]) ** 2).sum(1)
+    b2 = 2 * (p[:, 0] - ye) ** 2
+    return float(max(floor, 1 - np.where(two, b2, b3).sum() / np.where(two, 0.5, 2 / 3).sum()))
+
+
+def softmax_t(lg: np.ndarray, t: float) -> np.ndarray:
+    z = lg / t
+    z = np.exp(z - z.max(1, keepdims=True))
+    return z / z.sum(1, keepdims=True)
+
+
+def fit_temperature(items: list[tuple[str, np.ndarray, np.ndarray, str]]) -> float:
+    """The single temperature (logits / T) that maximises the macro-average Brier skill over the given (category, logits,
+    label, label_space) sets (unfloored, categories weighted equally); T in [0.25, 20], searched on log T."""
+    from scipy.optimize import minimize_scalar
+
+    def neg(logt: float) -> float:
+        cat: dict[str, list[float]] = {}
+        for c, lg, y, sp in items:
+            cat.setdefault(c, []).append(brier_skill(softmax_t(lg, np.exp(logt)), y, sp, floor=-np.inf))
+        return -float(np.mean([np.mean(v) for v in cat.values()]))
+
+    return float(np.exp(minimize_scalar(neg, bounds=(np.log(0.25), np.log(20)), method="bounded", options={"xatol": 1e-3}).x))
+
+
+def calibration_items(df: pd.DataFrame, lg: np.ndarray) -> list[tuple[str, np.ndarray, np.ndarray, str]]:
+    """The calibration config's rows grouped by source dataset, as fit_temperature input."""
+    return [(g.category.iat[0], lg[g.index.to_numpy()], g.label.to_numpy(), g.label_space.iat[0]) for _, g in df.groupby("dataset")]
+
+
+def auroc(p: np.ndarray, label: np.ndarray) -> float:
+    """AUROC of P(entailment), entailment vs not (ties count half)."""
+    from scipy.stats import rankdata
+
+    pos = np.asarray(label) == 0
+    n1, n0 = int(pos.sum()), int((~pos).sum())
+    if not n1 or not n0:
+        return float("nan")
+    r = rankdata(p[:, 0])
+    return float((r[pos].sum() - n1 * (n1 + 1) / 2) / (n1 * n0))
+
+
 def calibration(p: np.ndarray, label: np.ndarray) -> dict:
     """ECE over rows: 3-way rows use the top-class confidence, 2-way rows (label 3) the entailment-vs-not decision."""
     two = label == NOT_ENT
@@ -119,6 +181,7 @@ def main():
     ap.add_argument("--max-batch", type=int, default=512, help="max pairs per batch (lower it on a shared GPU)")
     ap.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
     ap.add_argument("--limit", type=int, default=0, help="first N rows per set (smoke test; not leaderboard numbers)")
+    ap.add_argument("--calibration-only", action="store_true", help="score only the calibration config (temperature + its predictions)")
     ap.add_argument("--out", default="results.json")
     ap.add_argument("--preds-dir", help="per-set predictions (id, label, pred, probabilities); default preds/<model>")
     ap.add_argument("--no-preds", action="store_true", help="do not save per-row predictions")
@@ -133,7 +196,22 @@ def main():
     cols = label_columns(cfg, a.label_order)
     print(f"{a.model}: context {model.max_length}, logit columns (ent, neu, con) = {cols}, device {a.device}", flush=True)
 
-    sets = a.sets or get_dataset_config_names(a.dataset)
+    sets = [s for s in (a.sets or get_dataset_config_names(a.dataset)) if s != "calibration"]
+    # temperature first: fitted on the calibration config only
+    cdf = load_dataset(a.dataset, "calibration", split="validation").to_pandas()
+    if a.limit:
+        cdf = cdf.groupby("dataset", group_keys=False).head(a.limit).reset_index(drop=True)
+    clg = logits(model, cdf.premise.tolist(), cdf.hypothesis.tolist(), cols, a.batch_tokens, a.max_batch)
+    temp = fit_temperature(calibration_items(cdf, clg))
+    print(f"temperature {temp:.3f} (fitted on the calibration config, {len(cdf):,} rows)", flush=True)
+    if not a.no_preds:
+        pdir = Path(a.preds_dir or Path("preds") / a.model.replace("/", "__"))
+        pdir.mkdir(parents=True, exist_ok=True)
+        pd.DataFrame({"id": cdf.id, "dataset": cdf.dataset, "label": cdf.label, "logit_ent": clg[:, 0], "logit_neu": clg[:, 1],
+                      "logit_con": clg[:, 2]}).to_parquet(pdir / "calibration.parquet", index=False)  # fmt: skip
+    if a.calibration_only:
+        Path(a.out).write_text(json.dumps({"model": a.model, "dataset": a.dataset, "temperature": temp, "calibration_rows": len(cdf)}, indent=1))
+        return
     results, cats, n_total, t_total = {}, {}, 0, 0.0
     for name in sets:
         df = load_dataset(a.dataset, name, split="test").to_pandas()
@@ -152,12 +230,14 @@ def main():
         prob = torch.softmax(torch.from_numpy(lg), -1).numpy()
         cal = calibration(prob, label)
         ch = chance_level(df)
-        results[name] = {"category": cat, "n": len(df), "accuracy": float(ok.mean()), "chance": ch, "skill": max(0.0, (float(ok.mean()) - ch) / (1 - ch)),
-                         "ece": cal["ece"], "mean_conf": cal["mean_conf"],
+        results[name] = {"category": cat, "n": len(df), "accuracy": float(ok.mean()), "chance": ch,
+                         "skill_raw": brier_skill(prob, label, df.label_space.iat[0]), "acc_skill": max(0.0, (float(ok.mean()) - ch) / (1 - ch)),
+                         "auroc": auroc(prob, label), "ece": cal["ece"], "mean_conf": cal["mean_conf"],
                          "calibration_bins": cal["bins"], "seconds": round(dt, 2)}  # fmt: skip
         cats.setdefault(cat, []).append(float(ok.mean()))
         n_total, t_total = n_total + len(df), t_total + dt
-        print(f"{name:18s} {cat:10s} n={len(df):6d} acc={ok.mean():.4f} ece={cal['ece']:.4f} ({len(df) / dt:.0f} pairs/s)", flush=True)
+        print(f"{name:18s} {cat:10s} n={len(df):6d} acc={ok.mean():.4f} skill(T=1)={results[name]['skill_raw']:+.4f} ece={cal['ece']:.4f} ({len(df) / dt:.0f} pairs/s)", flush=True)
+        results[name]["skill"] = brier_skill(softmax_t(lg, temp), label, df.label_space.iat[0])
         if not a.no_preds:
             pdir = Path(a.preds_dir or Path("preds") / a.model.replace("/", "__"))
             pdir.mkdir(parents=True, exist_ok=True)
@@ -166,16 +246,19 @@ def main():
 
     cat_scores = {c: float(np.mean(v)) for c, v in cats.items()}
     cat_ece = {c: float(np.mean([r["ece"] for r in results.values() if r["category"] == c])) for c in cats}
-    cat_skill = {c: float(np.mean([r["skill"] for r in results.values() if r["category"] == c])) for c in cats}
+    cat_mean = lambda key: {c: float(np.nanmean([r[key] for r in results.values() if r["category"] == c])) for c in cats}  # noqa: E731
+    cat_skill, cat_skill_raw, cat_acc_skill, cat_auroc = cat_mean("skill"), cat_mean("skill_raw"), cat_mean("acc_skill"), cat_mean("auroc")
     summary = {"model": a.model, "dataset": a.dataset, "context": model.max_length, "device": a.device, "limit": a.limit or None,
                "overall": float(np.mean(list(cat_scores.values()))), "categories": cat_scores,
                "skill_overall": float(np.mean(list(cat_skill.values()))), "skill_categories": cat_skill,
+               "temperature": temp, "skill_raw_overall": float(np.mean(list(cat_skill_raw.values()))),
+               "acc_skill_overall": float(np.mean(list(cat_acc_skill.values()))), "auroc_overall": float(np.mean(list(cat_auroc.values()))),
                "ece_overall": float(np.mean(list(cat_ece.values()))), "ece_categories": cat_ece,
                "dataset_mean": float(np.mean([r["accuracy"] for r in results.values()])),
                "throughput_pairs_per_s": round(n_total / t_total, 1) if t_total else None, "sets": results}  # fmt: skip
     Path(a.out).write_text(json.dumps(summary, indent=1))
     print("\n" + "  ".join(f"{c}={v * 100:.1f}" for c, v in cat_scores.items()) + f"  overall={summary['overall'] * 100:.1f}"
-          + f"  skill={summary['skill_overall'] * 100:.1f}  ECE={summary['ece_overall'] * 100:.1f}  -> {a.out}")
+          + f"  skill={summary['skill_overall'] * 100:.1f} (T={temp:.2f}; as shipped {summary['skill_raw_overall'] * 100:.1f})  ECE={summary['ece_overall'] * 100:.1f}  -> {a.out}")
 
 
 if __name__ == "__main__":