| |
| """Calibrated skill for one or more eval outputs, same metric as the official 49.59. |
| Usage: skill_eval.py BANK.jsonl eval1.jsonl[:name] eval2.jsonl[:name] ... |
| """ |
| import json, sys |
| from collections import defaultdict |
| import numpy as np |
|
|
| BANK = sys.argv[1] |
| REPS, CALIB = 120, 0.20 |
|
|
| def key_order(kind, keys): |
| if kind == "score": return sorted(keys, key=lambda k: int(k)) |
| if kind == "noul": return ["false", "true"] |
| return sorted(keys) |
|
|
| def metric(P, y, kind): |
| if kind == "score": |
| K = P.shape[1]; cp = np.cumsum(P, axis=1)[:, :-1]; cy = np.cumsum(np.eye(K)[y], axis=1)[:, :-1] |
| return ((cp - cy) ** 2).sum(-1) / (K - 1) |
| Y = np.zeros_like(P); Y[np.arange(len(y)), y] = 1.0 |
| return ((P - Y) ** 2).sum(-1) |
|
|
| def scale(z, T): |
| z = z / T; z = z - z.max(1, keepdims=True); e = np.exp(z); return e / e.sum(1, keepdims=True) |
|
|
| def fit(fams, calib): |
| cache = [(np.log(np.clip(fams[k][0][i], 1e-30, None)), fams[k][1][i], k[1]) for k, i in calib.items() if len(i)] |
| def loss(T): |
| tot = n = 0 |
| for lp, y, kind in cache: |
| tot += metric(scale(lp, T), y, kind).sum(); n += len(y) |
| return tot / n |
| g = np.geomspace(0.05, 20, 160) |
| return float(g[int(np.argmin([loss(t) for t in g]))]) |
|
|
| def skill(fams, ev, T): |
| cells = defaultdict(list) |
| for k, i in ev.items(): |
| if not len(i): continue |
| P, y = fams[k]; kind = k[1] |
| b = np.bincount(y, minlength=P.shape[1]).astype(float); b = (b + 1e-9) / (b.sum() + 1e-9 * P.shape[1]) |
| base = metric(np.repeat(b[None, :], len(y), 0), y, kind).mean() |
| if base <= 1e-12: continue |
| Q = scale(np.log(np.clip(P[i], 1e-30, None)), T) |
| cells[k[0]].append(1 - metric(Q, y[i], kind).mean() / base) |
| return float(np.mean([np.mean(v) for v in cells.values()])) |
|
|
| cases = {json.loads(l)["id"]: json.loads(l) for l in open(BANK) if l.strip()} |
| for spec in sys.argv[2:]: |
| path, _, name = spec.partition(":") |
| buckets = defaultdict(list) |
| for line in open(path): |
| if not line.strip(): continue |
| r = json.loads(line); c = cases[r["id"]] |
| kind = r["type"]; keys = key_order(kind, list(r["probabilities"])) |
| P = np.array([r["probabilities"][k] for k in keys], float); y = keys.index(str(r["label"])) |
| buckets[(c["family"], kind, len(keys))].append((P, y)) |
| fams = {k: (np.stack([a for a, _ in v]), np.array([b for _, b in v])) for k, v in buckets.items()} |
| ks = list(fams); sizes = {k: len(fams[k][1]) for k in ks} |
| rng = np.random.default_rng(5); vals = [] |
| for _ in range(REPS): |
| cal, ev = {}, {} |
| for k in ks: |
| m = sizes[k]; kk = max(1, int(round(m * CALIB))); perm = rng.permutation(m) |
| cal[k] = np.sort(perm[:kk]); ev[k] = np.sort(perm[kk:]) |
| vals.append(skill(fams, ev, fit(fams, cal))) |
| a = np.array(vals) |
| print(f"{name or path:24} skill={a.mean():.4f} sd={a.std(ddof=1):.4f} pts={100*a.mean():.2f}") |
|
|
