"""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()