Upload alea/eval.py with huggingface_hub

alea/eval.py

@@ -1,245 +1,248 @@
-"""Evaluation: accuracy, ECE, known-q L2, permutation invariance, isolation."""
-import argparse
-import json
-import random
-
-import torch
-
-from .dataset import row_to_specs
-from .model import AleaModel, collate
-from .packing import QuestionSpec, pack_request
-
-
-def load_model(ckpt_path, model_name, device):
-    model = AleaModel(model_name).to(device)
-    ck = torch.load(ckpt_path, map_location="cpu", weights_only=False)
-    for name, m in zip(["choice", "score", "noul", "regress"],
-                       [model.choice_head, model.score_head, model.noul_head,
-                        model.regress_head]):
-        if name in ck.get("heads", {}):
-            m.load_state_dict(ck["heads"][name])
-    if ck.get("backbone"):
-        model.backbone.load_state_dict(ck["backbone"])
-    model.eval()
-    return model
-
-
-@torch.no_grad()
-def predict_all(model, tok, rows, device, max_len=4096):
-    """Return {row_id: {qid: {type, probs[list], keys}}}."""
-    res = {}
-    for row in rows:
-        state, qs, targets = row_to_specs(row)
-        pk = pack_request(tok, state, qs, max_len=max_len)
-        ids, mask, pos = collate([pk], tok.pad_token_id or tok.eos_token_id)
-        out = model(ids.to(device), mask.to(device).to(torch.bfloat16),
-                    pos.to(device), [pk])[0]
-        ans = {}
-        for r in out:
-            if r["qtype"] in ("choice", "score"):
-                p = torch.softmax(r["logits"], -1).tolist()
-                ans[r["qid"]] = {"type": r["qtype"], "probs": p}
-            elif r["qtype"] == "regress":
-                ans[r["qid"]] = {"type": "regress",
-                                 "quantiles": r["quantiles"].tolist()}
-            else:
-                ans[r["qid"]] = {"type": "noul", "p": r["p_yes"].item()}
-        res[row["id"]] = ans
-    return res
-
-
-def metrics(rows, preds):
-    """acc, ECE(10-bin on top-prob), known-q L2, noul Brier."""
-    import math
-    n_ch = correct = 0
-    ece_bins = [[] for _ in range(10)]
-    l2_sum, l2_n = 0.0, 0
-    noul_err, noul_n = 0.0, 0
-    regr_err, regr_n, regr_scale = 0.0, 0, 0.0
-    fam_err, fam_scale = {}, {}
-    fam_cor, fam_n = {}, {}
-    fam_brier, fam_bn = {}, {}
-    for row in rows:
-        _, qs, targets = row_to_specs(row)
-        ans = preds[row["id"]]
-        fam = row.get("family", "?")
-        for q in qs:
-            t = targets[q.qid]
-            a = ans[q.qid]
-            if q.qtype in ("choice", "score"):
-                p = a["probs"]
-                k = max(range(len(t)), key=lambda i: t[i])
-                ok = int(max(range(len(p)), key=lambda i: p[i]) == k)
-                correct += ok
-                n_ch += 1
-                fam_cor[fam] = fam_cor.get(fam, 0) + ok
-                fam_n[fam] = fam_n.get(fam, 0) + 1
-                pm = max(p)
-                ece_bins[min(9, int(pm * 10))].append((pm, k == p.index(pm)))
-                l2_sum += sum((pi - qi) ** 2 for pi, qi in zip(p, t))
-                l2_n += 1
-            elif q.qtype == "regress":
-                pq = a["quantiles"]
-                e = sum((x - y) ** 2 for x, y in zip(pq, t)) / len(t)
-                s = sum(y * y for y in t) / len(t)
-                regr_err += e
-                regr_scale += s
-                regr_n += 1
-                fam_err[fam] = fam_err.get(fam, 0.0) + e
-                fam_scale[fam] = fam_scale.get(fam, 0.0) + s
-            else:
-                noul_err += (a["p"] - t) ** 2
-                noul_n += 1
-                fam_brier[fam] = fam_brier.get(fam, 0.0) + (a["p"] - t) ** 2
-                fam_bn[fam] = fam_bn.get(fam, 0) + 1
-    ece = 0.0
-    for b in ece_bins:
-        if not b:
-            continue
-        conf = sum(x[0] for x in b) / len(b)
-        acc = sum(x[1] for x in b) / len(b)
-        ece += len(b) / n_ch * abs(conf - acc)
-    out = {"n_choice": n_ch, "acc": correct / max(1, n_ch),
-           "ece10": ece, "known_q_l2": l2_sum / max(1, l2_n),
-           "noul_brier": noul_err / max(1, noul_n)}
-    out["acc_byfam"] = {f: round(fam_cor[f] / fam_n[f], 3)
-                        for f in sorted(fam_cor) if fam_n[f] >= 8}
-    out["brier_byfam"] = {f: round(fam_brier[f] / fam_bn[f], 4)
-                          for f in sorted(fam_brier) if fam_bn[f] >= 8}
-    if regr_n:
-        # R^2-style: fraction of target variance explained by quantile preds
-        out["regress_r2"] = 1 - regr_err / max(1e-9, regr_scale)
-        out["n_regress"] = regr_n
-        # per-family normalized error: mean over families of err/scale —
-        # keeps large-scale targets from dominating the aggregate
-        fr = {f: round(1 - fam_err[f] / max(1e-9, fam_scale[f]), 4)
-              for f in sorted(fam_err)}
-        out["regress_r2_byfam"] = fr
-        out["regress_r2_fam_mean"] = round(sum(fr.values())
-                                           / max(1, len(fr)), 4)
-    return out
-
-
-def permutation_test(model, tok, rows, device, n_perm=8, max_len=4096):
-    """Shuffle each choice question's options; measure argmax flips + |dp|."""
-    flips, tot = 0, 0
-    dp_sum, dp_n = 0.0, 0
-    for row in rows:
-        state, qs, _ = row_to_specs(row)
-        ch = [q for q in qs if q.qtype == "choice"]
-        if not ch:
-            continue
-        base_pk = pack_request(tok, state, qs, max_len=max_len)
-        ids, mask, pos = collate([base_pk], tok.pad_token_id or tok.eos_token_id)
-        base_out = model(ids.to(device), mask.to(device).to(torch.bfloat16),
-                         pos.to(device), [base_pk])[0]
-        base = {r["qid"]: torch.softmax(r["logits"], -1).tolist()
-                for r in base_out if r["qtype"] == "choice"}
-        for _ in range(n_perm):
-            qs2 = []
-            perm_map = {}
-            for q in qs:
-                q2 = QuestionSpec(q.qid, q.qtype, q.instructions,
-                                  list(q.options), list(q.option_keys or []))
-                if q.qtype == "choice":
-                    order = list(range(len(q.options)))
-                    random.shuffle(order)
-                    q2.options = [q.options[j] for j in order]
-                    q2.option_keys = [q.option_keys[j] for j in order]
-                    perm_map[q.qid] = order
-                qs2.append(q2)
-            pk2 = pack_request(tok, state, qs2, max_len=max_len)
-            ids, mask, pos = collate([pk2], tok.pad_token_id or tok.eos_token_id)
-            out2 = model(ids.to(device), mask.to(device).to(torch.bfloat16),
-                         pos.to(device), [pk2])[0]
-            for r in out2:
-                if r["qtype"] != "choice":
-                    continue
-                order = perm_map[r["qid"]]
-                p2 = torch.softmax(r["logits"], -1).tolist()
-                # map permuted probs back to canonical order
-                canon = [0.0] * len(p2)
-                for new_i, orig_i in enumerate(order):
-                    canon[orig_i] = p2[new_i]
-                p1 = base[r["qid"]]
-                if max(range(len(canon)), key=lambda i: canon[i]) != \
-                        max(range(len(p1)), key=lambda i: p1[i]):
-                    flips += 1
-                tot += 1
-                dp_sum += max(abs(a - b) for a, b in zip(canon, p1))
-                dp_n += 1
-    return {"argmax_flip_rate": flips / max(1, tot),
-            "mean_max_dp": dp_sum / max(1, dp_n), "n": tot}
-
-
-def isolation_test(model, tok, rows, device, max_len=4096):
-    """Mutating question B's token ids in place (same length -> same kernel
-    shapes) must leave question A's output bitwise unchanged."""
-    n_test = n_same = 0
-    max_dp = 0.0
-    fill_id = tok.encode("zzzzz", add_special_tokens=False)[0]
-    for row in rows:
-        state, qs, _ = row_to_specs(row)
-        if len(qs) < 2:
-            continue
-        pk1 = pack_request(tok, state, qs, max_len=max_len)
-        ids, mask, pos = collate([pk1], tok.pad_token_id or tok.eos_token_id)
-        out1 = model(ids.to(device), mask.to(device).to(torch.bfloat16),
-                     pos.to(device), [pk1])[0]
-        ids2 = ids.clone()
-        qctx_lo, qctx_hi = pk1.qctx_spans[1]
-        ids2[0, qctx_lo:qctx_hi + 1] = fill_id
-        out2 = model(ids2.to(device), mask.to(device).to(torch.bfloat16),
-                     pos.to(device), [pk1])[0]
-        for r1, r2 in zip(out1, out2):
-            if r1["qid"] == qs[1].qid:
-                continue
-            if r1["qtype"] == "noul":
-                d = abs(r1["p_yes"].item() - r2["p_yes"].item())
-            elif r1["qtype"] == "regress":
-                d = max(abs(a - b) for a, b in
-                        zip(r1["quantiles"].tolist(), r2["quantiles"].tolist()))
-            else:
-                d = max(abs(a - b) for a, b in zip(
-                    torch.softmax(r1["logits"], -1).tolist(),
-                    torch.softmax(r2["logits"], -1).tolist()))
-            max_dp = max(max_dp, d)
-            n_same += int(d < 1e-4)
-            n_test += 1
-    return {"unchanged_rate": n_same / max(1, n_test),
-            "max_dp": max_dp, "n": n_test}
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--ckpt", required=True)
-    ap.add_argument("--data", default="data/test.jsonl")
-    ap.add_argument("--model", default="Qwen/Qwen3-0.6B")
-    ap.add_argument("--max-items", type=int, default=0)
-    ap.add_argument("--perm", type=int, default=8)
-    ap.add_argument("--skip-structural", action="store_true")
-    args = ap.parse_args()
-
-    from transformers import AutoTokenizer
-    dev = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    tok = AutoTokenizer.from_pretrained(args.model)
-    model = load_model(args.ckpt, args.model, dev)
-    rows = [json.loads(l) for l in open(args.data, encoding="utf-8")]
-    if args.max_items:
-        rows = rows[: args.max_items]
-
-    preds = predict_all(model, tok, rows, dev)
-    print(json.dumps(metrics(rows, preds), indent=2))
-
-    if not args.skip_structural:
-        perm_rows = [r for r in rows if any(
-            s["type"] == "choice" for s in r["questions"].values())][:64]
-        print("permutation:", json.dumps(
-            permutation_test(model, tok, perm_rows, dev, n_perm=args.perm),
-            indent=2))
-        print("isolation:", json.dumps(
-            isolation_test(model, tok, rows[:64], dev), indent=2))
-
-
-if __name__ == "__main__":
-    main()
+"""Evaluation: accuracy, ECE, known-q L2, permutation invariance, isolation."""
+import argparse
+import json
+import random
+
+import torch
+
+from .dataset import row_to_specs
+from .model import AleaModel, collate
+from .packing import QuestionSpec, pack_request
+from .train import load_into
+
+
+def load_model(ckpt_path, model_name, device):
+    ck = torch.load(ckpt_path, map_location="cpu", weights_only=False)
+    args = ck.get("args", {})
+    del ck
+    model = AleaModel(
+        model_name, attn_impl=args.get("attn", "sdpa"),
+        use_aux_embed=args.get("use_aux_embed", False),
+        use_ngram=args.get("use_ngram", False),
+        use_ngram2=args.get("use_ngram2", False),
+        use_ngram3=args.get("use_ngram3", False),
+    ).to(device)
+    load_into(model, ckpt_path)
+    model.eval()
+    return model
+
+
+@torch.no_grad()
+def predict_all(model, tok, rows, device, max_len=4096):
+    """Return {row_id: {qid: {type, probs[list], keys}}}."""
+    res = {}
+    for row in rows:
+        state, qs, targets = row_to_specs(row)
+        pk = pack_request(tok, state, qs, max_len=max_len)
+        ids, mask, pos = collate([pk], tok.pad_token_id or tok.eos_token_id)
+        out = model(ids.to(device), mask.to(device).to(torch.bfloat16),
+                    pos.to(device), [pk])[0]
+        ans = {}
+        for r in out:
+            if r["qtype"] in ("choice", "score"):
+                p = torch.softmax(r["logits"], -1).tolist()
+                ans[r["qid"]] = {"type": r["qtype"], "probs": p}
+            elif r["qtype"] == "regress":
+                ans[r["qid"]] = {"type": "regress",
+                                 "quantiles": r["quantiles"].tolist()}
+            else:
+                ans[r["qid"]] = {"type": "noul", "p": r["p_yes"].item()}
+        res[row["id"]] = ans
+    return res
+
+
+def metrics(rows, preds):
+    """acc, ECE(10-bin on top-prob), known-q L2, noul Brier."""
+    import math
+    n_ch = correct = 0
+    ece_bins = [[] for _ in range(10)]
+    l2_sum, l2_n = 0.0, 0
+    noul_err, noul_n = 0.0, 0
+    regr_err, regr_n, regr_scale = 0.0, 0, 0.0
+    fam_err, fam_scale = {}, {}
+    fam_cor, fam_n = {}, {}
+    fam_brier, fam_bn = {}, {}
+    for row in rows:
+        _, qs, targets = row_to_specs(row)
+        ans = preds[row["id"]]
+        fam = row.get("family", "?")
+        for q in qs:
+            t = targets[q.qid]
+            a = ans[q.qid]
+            if q.qtype in ("choice", "score"):
+                p = a["probs"]
+                k = max(range(len(t)), key=lambda i: t[i])
+                ok = int(max(range(len(p)), key=lambda i: p[i]) == k)
+                correct += ok
+                n_ch += 1
+                fam_cor[fam] = fam_cor.get(fam, 0) + ok
+                fam_n[fam] = fam_n.get(fam, 0) + 1
+                pm = max(p)
+                ece_bins[min(9, int(pm * 10))].append((pm, k == p.index(pm)))
+                l2_sum += sum((pi - qi) ** 2 for pi, qi in zip(p, t))
+                l2_n += 1
+            elif q.qtype == "regress":
+                pq = a["quantiles"]
+                e = sum((x - y) ** 2 for x, y in zip(pq, t)) / len(t)
+                s = sum(y * y for y in t) / len(t)
+                regr_err += e
+                regr_scale += s
+                regr_n += 1
+                fam_err[fam] = fam_err.get(fam, 0.0) + e
+                fam_scale[fam] = fam_scale.get(fam, 0.0) + s
+            else:
+                noul_err += (a["p"] - t) ** 2
+                noul_n += 1
+                fam_brier[fam] = fam_brier.get(fam, 0.0) + (a["p"] - t) ** 2
+                fam_bn[fam] = fam_bn.get(fam, 0) + 1
+    ece = 0.0
+    for b in ece_bins:
+        if not b:
+            continue
+        conf = sum(x[0] for x in b) / len(b)
+        acc = sum(x[1] for x in b) / len(b)
+        ece += len(b) / n_ch * abs(conf - acc)
+    out = {"n_choice": n_ch, "acc": correct / max(1, n_ch),
+           "ece10": ece, "known_q_l2": l2_sum / max(1, l2_n),
+           "noul_brier": noul_err / max(1, noul_n)}
+    out["acc_byfam"] = {f: round(fam_cor[f] / fam_n[f], 3)
+                        for f in sorted(fam_cor) if fam_n[f] >= 8}
+    out["brier_byfam"] = {f: round(fam_brier[f] / fam_bn[f], 4)
+                          for f in sorted(fam_brier) if fam_bn[f] >= 8}
+    if regr_n:
+        # R^2-style: fraction of target variance explained by quantile preds
+        out["regress_r2"] = 1 - regr_err / max(1e-9, regr_scale)
+        out["n_regress"] = regr_n
+        # per-family normalized error: mean over families of err/scale —
+        # keeps large-scale targets from dominating the aggregate
+        fr = {f: round(1 - fam_err[f] / max(1e-9, fam_scale[f]), 4)
+              for f in sorted(fam_err)}
+        out["regress_r2_byfam"] = fr
+        out["regress_r2_fam_mean"] = round(sum(fr.values())
+                                           / max(1, len(fr)), 4)
+    return out
+
+
+def permutation_test(model, tok, rows, device, n_perm=8, max_len=4096):
+    """Shuffle each choice question's options; measure argmax flips + |dp|."""
+    flips, tot = 0, 0
+    dp_sum, dp_n = 0.0, 0
+    for row in rows:
+        state, qs, _ = row_to_specs(row)
+        ch = [q for q in qs if q.qtype == "choice"]
+        if not ch:
+            continue
+        base_pk = pack_request(tok, state, qs, max_len=max_len)
+        ids, mask, pos = collate([base_pk], tok.pad_token_id or tok.eos_token_id)
+        base_out = model(ids.to(device), mask.to(device).to(torch.bfloat16),
+                         pos.to(device), [base_pk])[0]
+        base = {r["qid"]: torch.softmax(r["logits"], -1).tolist()
+                for r in base_out if r["qtype"] == "choice"}
+        for _ in range(n_perm):
+            qs2 = []
+            perm_map = {}
+            for q in qs:
+                q2 = QuestionSpec(q.qid, q.qtype, q.instructions,
+                                  list(q.options), list(q.option_keys or []))
+                if q.qtype == "choice":
+                    order = list(range(len(q.options)))
+                    random.shuffle(order)
+                    q2.options = [q.options[j] for j in order]
+                    q2.option_keys = [q.option_keys[j] for j in order]
+                    perm_map[q.qid] = order
+                qs2.append(q2)
+            pk2 = pack_request(tok, state, qs2, max_len=max_len)
+            ids, mask, pos = collate([pk2], tok.pad_token_id or tok.eos_token_id)
+            out2 = model(ids.to(device), mask.to(device).to(torch.bfloat16),
+                         pos.to(device), [pk2])[0]
+            for r in out2:
+                if r["qtype"] != "choice":
+                    continue
+                order = perm_map[r["qid"]]
+                p2 = torch.softmax(r["logits"], -1).tolist()
+                # map permuted probs back to canonical order
+                canon = [0.0] * len(p2)
+                for new_i, orig_i in enumerate(order):
+                    canon[orig_i] = p2[new_i]
+                p1 = base[r["qid"]]
+                if max(range(len(canon)), key=lambda i: canon[i]) != \
+                        max(range(len(p1)), key=lambda i: p1[i]):
+                    flips += 1
+                tot += 1
+                dp_sum += max(abs(a - b) for a, b in zip(canon, p1))
+                dp_n += 1
+    return {"argmax_flip_rate": flips / max(1, tot),
+            "mean_max_dp": dp_sum / max(1, dp_n), "n": tot}
+
+
+def isolation_test(model, tok, rows, device, max_len=4096):
+    """Mutating question B's token ids in place (same length -> same kernel
+    shapes) must leave question A's output bitwise unchanged."""
+    n_test = n_same = 0
+    max_dp = 0.0
+    fill_id = tok.encode("zzzzz", add_special_tokens=False)[0]
+    for row in rows:
+        state, qs, _ = row_to_specs(row)
+        if len(qs) < 2:
+            continue
+        pk1 = pack_request(tok, state, qs, max_len=max_len)
+        ids, mask, pos = collate([pk1], tok.pad_token_id or tok.eos_token_id)
+        out1 = model(ids.to(device), mask.to(device).to(torch.bfloat16),
+                     pos.to(device), [pk1])[0]
+        ids2 = ids.clone()
+        qctx_lo, qctx_hi = pk1.qctx_spans[1]
+        ids2[0, qctx_lo:qctx_hi + 1] = fill_id
+        out2 = model(ids2.to(device), mask.to(device).to(torch.bfloat16),
+                     pos.to(device), [pk1])[0]
+        for r1, r2 in zip(out1, out2):
+            if r1["qid"] == qs[1].qid:
+                continue
+            if r1["qtype"] == "noul":
+                d = abs(r1["p_yes"].item() - r2["p_yes"].item())
+            elif r1["qtype"] == "regress":
+                d = max(abs(a - b) for a, b in
+                        zip(r1["quantiles"].tolist(), r2["quantiles"].tolist()))
+            else:
+                d = max(abs(a - b) for a, b in zip(
+                    torch.softmax(r1["logits"], -1).tolist(),
+                    torch.softmax(r2["logits"], -1).tolist()))
+            max_dp = max(max_dp, d)
+            n_same += int(d < 1e-4)
+            n_test += 1
+    return {"unchanged_rate": n_same / max(1, n_test),
+            "max_dp": max_dp, "n": n_test}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--ckpt", required=True)
+    ap.add_argument("--data", default="data/test.jsonl")
+    ap.add_argument("--model", default="Qwen/Qwen3-0.6B")
+    ap.add_argument("--max-items", type=int, default=0)
+    ap.add_argument("--perm", type=int, default=8)
+    ap.add_argument("--skip-structural", action="store_true")
+    args = ap.parse_args()
+
+    from transformers import AutoTokenizer
+    dev = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    tok = AutoTokenizer.from_pretrained(args.model)
+    model = load_model(args.ckpt, args.model, dev)
+    rows = [json.loads(l) for l in open(args.data, encoding="utf-8")]
+    if args.max_items:
+        rows = rows[: args.max_items]
+
+    preds = predict_all(model, tok, rows, dev)
+    print(json.dumps(metrics(rows, preds), indent=2))
+
+    if not args.skip_structural:
+        perm_rows = [r for r in rows if any(
+            s["type"] == "choice" for s in r["questions"].values())][:64]
+        print("permutation:", json.dumps(
+            permutation_test(model, tok, perm_rows, dev, n_perm=args.perm),
+            indent=2))
+        print("isolation:", json.dumps(
+            isolation_test(model, tok, rows[:64], dev), indent=2))
+
+
+if __name__ == "__main__":
+    main()