| """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, |
| "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 = 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"])) |
| |
| 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) |
|
|
