| """Shared helpers for browsecomp-plus-mini: loading the run matrix, system weights, |
| weighted rank metrics, pair agreement by gap, and the select/validate/test protocol. |
| |
| Input (not redistributed here): a 0/1 matrix `matrix.csv` (rows = BrowseComp-Plus query_id, |
| columns = published runs, 1 = answer matched the gold answer under normalized exact match, |
| see grader.py), `runs.json` (one record per run: run, system, ...), and |
| `short_single_gold.json` ({query_id: bool}, true when the gold answer is a short single entity). |
| """ |
| import csv, json, collections |
| import numpy as np |
|
|
|
|
| def load(dirpath): |
| rows = list(csv.reader(open(f"{dirpath}/matrix.csv"))) |
| runs = rows[0][1:] |
| qids = [r[0] for r in rows[1:]] |
| X = np.array([[float(v) for v in r[1:]] for r in rows[1:]]).T |
| meta = {m["run"]: m for m in json.load(open(f"{dirpath}/runs.json"))} |
| systems = [meta[r]["system"] for r in runs] |
| k = collections.Counter(systems) |
| w = np.array([1.0 / k[s] for s in systems]) |
| short = json.load(open(f"{dirpath}/short_single_gold.json")) |
| pool = np.array([bool(short[q]) for q in qids]) |
| return dict(runs=runs, qids=qids, X=X, full=X.mean(1), systems=systems, w=w, pool=pool, meta=meta) |
|
|
|
|
| def rankdata(a): |
| order = np.argsort(a, kind="mergesort") |
| r = np.empty(len(a)); r[order] = np.arange(len(a)) |
| |
| vals, inv = np.unique(a, return_inverse=True) |
| sums = np.bincount(inv, r); cnts = np.bincount(inv) |
| return (sums / cnts)[inv] |
|
|
|
|
| def wpearson(a, b, w): |
| am = (w * a).sum() / w.sum(); bm = (w * b).sum() / w.sum() |
| da, db = a - am, b - bm |
| den = np.sqrt((w * da * da).sum() * (w * db * db).sum()) |
| return float((w * da * db).sum() / den) if den > 0 else 0.0 |
|
|
|
|
| def wspearman(a, b, w): |
| """weighted Spearman: weighted Pearson correlation of the (unweighted) ranks""" |
| return wpearson(rankdata(a), rankdata(b), w) |
|
|
|
|
| def wspearman_cols(S, f, w): |
| """weighted Spearman of each column of S (runs x candidates) against f""" |
| rf = rankdata(f) |
| R = np.apply_along_axis(rankdata, 0, S) |
| wn = w / w.sum() |
| Rc = R - (wn[:, None] * R).sum(0); fc = rf - (wn * rf).sum() |
| num = (wn[:, None] * Rc * fc[:, None]).sum(0) |
| den = np.sqrt((wn[:, None] * Rc ** 2).sum(0) * (wn * fc ** 2).sum()) |
| return np.where(den > 0, num / np.where(den > 0, den, 1), 0.0) |
|
|
|
|
| BANDS = [("more than 10 points", 0.10, 9.0), ("5 to 10 points", 0.05, 0.10), ("2 to 5 points", 0.02, 0.05), ("under 2 points", 0.0, 0.02)] |
|
|
|
|
| def pair_agreement(full, sub, w, idx, systems=None, cross_system_only=False): |
| """weighted share of run pairs ordered the same way by the subset, by size of the full-benchmark gap. |
| A tie on the subset counts as not agreeing.""" |
| out = [] |
| idx = list(idx) |
| for name, lo, hi in BANDS: |
| ok = tot = 0.0; n = 0 |
| for a_ in range(len(idx)): |
| for b_ in range(a_ + 1, len(idx)): |
| i, j = idx[a_], idx[b_] |
| if cross_system_only and systems[i] == systems[j]: |
| continue |
| g = abs(full[i] - full[j]) |
| if lo <= g < hi: |
| pw = w[i] * w[j]; n += 1; tot += pw |
| if (full[i] - full[j]) * (sub[i] - sub[j]) > 0: |
| ok += pw |
| out.append(dict(gap=name, n_pairs=n, agreement_pct=round(100 * ok / tot, 1) if tot else None)) |
| return out |
|
|
|
|
| def calibrated_mae(full, sub, w, fit_idx, eval_idx): |
| co = np.polyfit(sub[fit_idx], full[fit_idx], 1, w=np.sqrt(w[fit_idx])) |
| pred = np.polyval(co, sub[eval_idx]) |
| return float((w[eval_idx] * np.abs(pred - full[eval_idx])).sum() / w[eval_idx].sum()), co |
|
|
|
|
| def split_systems(systems, full, w, seed): |
| """three-way split of SYSTEMS, stratified by system accuracy: sort systems by mean full score, |
| take them in blocks of three and deal one to each split in random order.""" |
| rng = np.random.default_rng(seed) |
| sysacc = collections.defaultdict(list) |
| for s, f in zip(systems, full): |
| sysacc[s].append(f) |
| order = sorted(sysacc, key=lambda s: np.mean(sysacc[s])) |
| parts = ([], [], []) |
| for b in range(0, len(order), 3): |
| block = order[b:b + 3] |
| for p, s in zip(rng.permutation(3), block): |
| parts[p].append(s) |
| return parts |
|
|
|
|
| def run_idx(systems, sysset): |
| return np.array([i for i, s in enumerate(systems) if s in sysset]) |
|
|
|
|
| def objective(S, f, w, mae_pen=1.0): |
| rho = wspearman_cols(S, f, w) |
| mae = (w[:, None] * np.abs(S - f[:, None])).sum(0) / w.sum() |
| return rho - mae_pen * mae |
|
|
|
|
| def greedy(D, idx, n, cand_mask): |
| X, full, w = D["X"][idx], D["full"][idx], D["w"][idx] |
| p = (w[:, None] * X).sum(0) / w.sum() |
| var = p * (1 - p) |
| ok = cand_mask & (p > 0) & (p < 1) |
| pool = list(np.where(ok)[0]) |
| sub = sorted(pool, key=lambda t: -var[t])[:3] |
| pool = [t for t in pool if t not in sub] |
| while len(sub) < n: |
| base = X[:, sub].sum(1) |
| S = (base[:, None] + X[:, pool]) / (len(sub) + 1) |
| j = int(np.argmax(objective(S, full, w))) |
| sub.append(pool.pop(j)) |
| return sub |
|
|
|
|
| def climb(D, idx, start, cand_mask, rounds=6): |
| X, full, w = D["X"][idx], D["full"][idx], D["w"][idx] |
| p = (w[:, None] * X).sum(0) / w.sum() |
| allowed = np.where(cand_mask & (p > 0) & (p < 1))[0] |
| sub = list(start); n = len(sub) |
| cur = float(objective((X[:, sub].mean(1))[:, None], full, w)[0]) |
| for _ in range(rounds): |
| moved = False |
| for i in range(n): |
| rest = [t for t in allowed if t not in sub] |
| base = X[:, sub].sum(1) - X[:, sub[i]] |
| S = (base[:, None] + X[:, rest]) / n |
| sc = objective(S, full, w) |
| j = int(np.argmax(sc)) |
| if sc[j] > cur + 1e-9: |
| sub[i] = rest[j]; cur = float(sc[j]); moved = True |
| if not moved: |
| break |
| return sub |
|
|
|
|
| def candidates(D, sel_idx, n, cand_mask, seed, restarts=6): |
| rng = np.random.default_rng(seed) |
| allowed = np.where(cand_mask)[0] |
| c = [greedy(D, sel_idx, n, cand_mask)] |
| c.append(climb(D, sel_idx, c[0], cand_mask)) |
| X = D["X"][sel_idx] |
| p = X.mean(0) |
| allowed = [t for t in allowed if 0 < p[t] < 1] |
| for _ in range(restarts): |
| c.append(climb(D, sel_idx, list(rng.choice(allowed, n, replace=False)), cand_mask)) |
| return c |
|
|
|
|
| def rho_on(D, sub, idx): |
| return wspearman(D["X"][idx][:, sub].mean(1), D["full"][idx], D["w"][idx]) |
|
|
|
|
| def stratified(D, idx, n, cand_mask, nbins): |
| """difficulty-stratified pick: split candidate queries into `nbins` bands of solve rate and take the |
| most discriminating queries in each (discrimination = weighted point-biserial correlation between |
| solving the query and the run's full-benchmark score).""" |
| X, f, w = D["X"][idx], D["full"][idx], D["w"][idx] |
| p = (w[:, None] * X).sum(0) / w.sum() |
| fc = f - (w * f).sum() / w.sum(); Xc = X - p |
| disc = (w[:, None] * Xc * fc[:, None]).sum(0) / np.sqrt((w[:, None] * Xc ** 2).sum(0) * (w * fc ** 2).sum() + 1e-12) |
| ok = np.where(cand_mask & (p > 0.02) & (p < 0.98))[0] |
| qs = np.quantile(p[ok], np.linspace(0, 1, nbins + 1)) |
| per = [n // nbins + (1 if i < n % nbins else 0) for i in range(nbins)] |
| sel = [] |
| for b in range(nbins): |
| inb = ok[(p[ok] >= qs[b]) & ((p[ok] < qs[b + 1]) if b < nbins - 1 else (p[ok] <= qs[b + 1]))] |
| sel += [int(t) for t in inb[np.argsort(-disc[inb])][:per[b]] if t not in sel] |
| return sel |
|
|
|
|
| def methods(seed): |
| """candidate selection methods; each maps (D, run_idx, n, mask) -> list of query indices""" |
| m = {f"stratified_{b}": (lambda b: lambda D, i, n, c: stratified(D, i, n, c, b))(b) for b in (1, 2, 3, 4, 5)} |
| m["greedy"] = lambda D, i, n, c: greedy(D, i, n, c) |
| m["greedy_climb"] = lambda D, i, n, c: climb(D, i, greedy(D, i, n, c), c) |
| for r in range(3): |
| def f(D, i, n, c, r=r): |
| rng = np.random.default_rng(1000 * seed + r) |
| p = D["X"][i].mean(0) |
| allowed = [t for t in np.where(c)[0] if 0 < p[t] < 1] |
| return climb(D, i, list(rng.choice(allowed, n, replace=False)), c) |
| m[f"climb_restart_{r}"] = f |
| return m |
|
|
|
|
| def honest_pick(D, n, seed): |
| """SELECT fits every method; VALIDATE chooses the method; the chosen method is refit on SELECT+VALIDATE; |
| TEST is only used to score the result.""" |
| S, V, T = split_systems(D["systems"], D["full"], D["w"], seed) |
| si, vi, ti = run_idx(D["systems"], S), run_idx(D["systems"], V), run_idx(D["systems"], T) |
| M = methods(seed) |
| val = {k: rho_on(D, f(D, si, n, D["pool"]), vi) for k, f in M.items()} |
| best = max(val, key=val.get) |
| sub = M[best](D, np.concatenate([si, vi]), n, D["pool"]) |
| return dict(subset=sub, method=best, validate_rho=val, split=(S, V, T), idx=(si, vi, ti)) |
|
|
