Upload jevbench_dump.py with huggingface_hub

jevbench_dump.py

@@ -0,0 +1,138 @@
+"""Run Alea on JevBench public datasets -> per-tier accuracy/ECE/Brier/latency.
+
+Maps JevBench tasks to Alea packing:
+  choice -> choice q, options=labels, descs=criteria[label]
+  noul   -> noul q, probs {yes,no}
+  score  -> choice q over level labels (native dist over exact label set)
+"""
+import json, sys, time
+sys.path.insert(0, "/root/alea")
+sys.path.insert(0, "/root/jevbench")
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+from alea.model import AleaModel, collate_segments, mask_from_segments
+from alea.packing import pack_request, QuestionSpec
+from alea.train import load_into
+from jevbench.tasks import load_jsonl
+from jevbench.scoring import score_task
+from jevbench.metrics import brier_score, ece_top_label, latency_summary, macro_accuracy
+
+CKPT = sys.argv[1] if len(sys.argv) > 1 else "/root/alea/checkpoints/alea_env_rl.pt"
+MAXLEN = 4096
+dev = torch.device("cuda")
+
+from transformers import AutoTokenizer
+tok = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")
+model = AleaModel("Qwen/Qwen3-0.6B", attn_impl="sdpa",
+                  use_aux_embed=True, use_ngram=True, use_ngram2=True, use_ngram3=True).to(dev)
+load_into(model, CKPT)
+model.eval()
+pad = tok.pad_token_id or tok.eos_token_id
+
+
+def task_to_spec(t):
+    qt = t.question["type"]
+    instr = t.question["instructions"]
+    crit = t.question.get("criteria")
+    keys = [str(l) for l in t.labels]
+    if qt == "noul":
+        return QuestionSpec(qid="decision", qtype="noul",
+                            instructions=instr, options=[], option_keys=["no", "yes"])
+    if isinstance(crit, dict):
+        opts = [str(crit.get(l, l)) for l in t.labels]
+    elif isinstance(crit, list):
+        opts = [str(x) for x in crit]
+    else:
+        opts = keys[:]
+    return QuestionSpec(qid="decision", qtype="choice", instructions=instr,
+                        options=opts, option_keys=keys)
+
+
+@torch.no_grad()
+def decide(t):
+    spec = task_to_spec(t)
+    st = t.state if isinstance(t.state, str) else json.dumps(t.state, indent=1)
+    pk = pack_request(tok, st, [spec], max_len=MAXLEN)
+    ids, pos, seg, qof, oof = collate_segments([pk], pad)
+    mask = mask_from_segments(seg.to(dev), qof.to(dev), oof.to(dev)).to(torch.bfloat16)
+    out = model(ids.to(dev), mask, pos.to(dev), [pk])
+    r = out[0][0]
+    if spec.qtype == "noul":
+        p = float(r["p_yes"].item())
+        return {"yes": p, "no": 1.0 - p}
+    probs = F.softmax(r["logits"][: len(t.labels)].float(), -1).tolist()
+    return {str(l): float(pr) for l, pr in zip(t.labels, probs)}
+
+
+all_recs = []
+for name in ["easy", "hard", "original"]:
+    tasks = load_jsonl(f"/root/jevbench/datasets/public/{name}.jsonl")
+    recs = []
+    for i, t in enumerate(tasks, 1):
+        t0 = time.perf_counter()
+        try:
+            probs = decide(t)
+            lat = time.perf_counter() - t0
+            s = score_task(probs, t)
+            recs.append({"task_id": t.id, "family": t.family, "split": name,
+                         "group": t.group, "ok": True, "probs": probs,
+                         "state": t.state[:3000],
+                         "instructions": t.question.get("instructions",""),
+                         "criteria": t.question.get("criteria"),
+                         "valid": s["valid"], "correct": s["correct"],
+                         "predicted": s.get("predicted"),
+                         "ordinal_ev": s.get("ordinal_ev"),
+                         "latency_s": lat,
+                         "expected": t.expected})
+        except Exception as e:
+            recs.append({"task_id": t.id, "family": t.family, "split": name,
+                         "ok": False, "error": f"{type(e).__name__}: {str(e)[:120]}",
+                         "correct": False, "valid": False, "latency_s": time.perf_counter() - t0})
+        if i % 25 == 0:
+            print("%s: %d/%d" % (name, i, len(tasks)), flush=True)
+    all_recs += recs
+    scorable = [r for r in recs if r["ok"] and r.get("expected") is not None]
+    n = len(scorable)
+    acc = sum(r["correct"] for r in scorable) / max(n, 1)
+    pairs = [(r["probs"], str(r["expected"]), [str(x) for x in
+             [t2.labels for t2 in tasks if t2.id == r["task_id"]][0]])
+             for r in scorable]
+    briers, ece_pairs = [], []
+    for r in scorable:
+        t2 = next(x for x in tasks if x.id == r["task_id"])
+        exp = str(t2.expected)
+        labs = [str(x) for x in t2.labels]
+        try:
+            briers.append(brier_score(r["probs"], exp, labs))
+        except Exception:
+            pass
+        conf = max(r["probs"].values()); pred = max(r["probs"], key=r["probs"].get)
+        ece_pairs.append((conf, float(pred == exp)))
+    ece = ece_top_label(ece_pairs)["ece"]
+    lat = latency_summary([r["latency_s"] for r in recs])
+    # chance-corrected intelligence (jevbench: (acc - chance)/(1 - chance))
+    chance = np.mean([1.0 / len(next(x for x in tasks if x.id == r["task_id"]).labels)
+                      for r in scorable])
+    cci = max(0.0, (acc - chance) / (1 - chance)) * 100 if n else 0.0
+    print()
+    print("== %s: n=%d acc=%.3f cci=%.1f brier=%.4f ece=%.4f p50=%.3fs p95=%.3fs"
+          % (name, n, acc, cci, np.mean(briers), ece,
+             lat["p50_s"], lat["p95_s"]))
+    # per-family
+    fams = {}
+    for r in scorable:
+        fams.setdefault(r["family"], []).append(r["correct"])
+    for f_, v in sorted(fams.items()):
+        print("   " + f_.ljust(22), "%d/%d = %.3f" % (sum(v), len(v), np.mean(v)))
+
+out = "/root/alea/jevbench_results.json"
+json.dump(all_recs, open(out, "w"), indent=1)
+print("wrote", out)
+
+import json as _j
+with open("/root/alea/jevbench_dump.jsonl","w") as fh:
+    for r in all_recs:
+        fh.write(_j.dumps(r)+chr(10))
+print("dumped", len(all_recs), "records")