| """Paired comparison of ablation runs (vbe/ablate.py) against the baseline. |
| |
| python -m vbe.ablate_report results/ablate results/phase3_qbase_full_hybrid_lr1e-5 [out.json] |
| |
| For every (variant, budget, benchmark): accuracy, the difference to the baseline on the |
| same questions with a 95% interval from resampling videos (2,000 draws), the same on the |
| questions the variant actually changed (``reused: false``) and on the long-video subset |
| (Video-MME long, LongVideoBench >= 3 min, all of MLVU), plus MLVU M-Avg. |
| """ |
| import glob |
| import json |
| import os |
| import re |
| import sys |
| from collections import defaultdict |
|
|
| import numpy as np |
|
|
| LONG = {"videomme": lambda m: m["duration"] == "long", |
| "longvideobench": lambda m: str(m["duration_group"]) in ("600", "3600"), |
| "mlvu": lambda m: True} |
|
|
|
|
| def load(run_dir, bench): |
| recs = {} |
| for f in sorted(glob.glob(os.path.join(run_dir, bench, "*.jsonl"))): |
| for line in open(f): |
| if line.strip(): |
| r = json.loads(line) |
| recs[r["qid"]] = r |
| return recs |
|
|
|
|
| def paired(var, base, qids, draws=2000, seed=0): |
| """(variant acc, baseline acc, delta, lo, hi, n) on ``qids``; interval over videos.""" |
| if not qids: |
| return None |
| by_vid = defaultdict(lambda: [0.0, 0]) |
| a = b = 0 |
| for q in qids: |
| ca, cb = var[q]["pred"] == var[q]["answer"], base[q]["pred"] == base[q]["answer"] |
| a += ca; b += cb |
| v = by_vid[base[q]["video"]] |
| v[0] += ca - cb; v[1] += 1 |
| d = np.array([x[0] for x in by_vid.values()]); n = np.array([x[1] for x in by_vid.values()]) |
| rng = np.random.default_rng(seed) |
| idx = rng.integers(0, len(d), (draws, len(d))) |
| boot = 100 * d[idx].sum(1) / n[idx].sum(1) |
| k = len(qids) |
| return dict(acc=100 * a / k, base=100 * b / k, delta=100 * (a - b) / k, |
| lo=float(np.percentile(boot, 2.5)), hi=float(np.percentile(boot, 97.5)), n=k) |
|
|
|
|
| def m_avg(recs, qids): |
| by = defaultdict(list) |
| for q in qids: |
| by[recs[q]["meta"]["task_type"]].append(recs[q]["pred"] == recs[q]["answer"]) |
| return 100 * float(np.mean([np.mean(v) for v in by.values()])) |
|
|
|
|
| def main(): |
| root, base_prefix = sys.argv[1], sys.argv[2] |
| out = {} |
| for run in sorted(glob.glob(os.path.join(root, "*_b*"))): |
| m = re.match(r"(.+)_b(\d+)$", os.path.basename(run)) |
| if not m: |
| continue |
| variant, budget = m.group(1), int(m.group(2)) |
| for bench in ("videomme", "mlvu", "longvideobench"): |
| var = load(run, bench) |
| if not var: |
| continue |
| base = load(f"{base_prefix}_b{budget}", bench) |
| qids = sorted(q for q in var if q in base) |
| row = dict(n_total=len(base), complete=len(qids) == len(base), |
| all=paired(var, base, qids), |
| changed=paired(var, base, [q for q in qids if not var[q].get("reused")]), |
| long=paired(var, base, [q for q in qids if LONG[bench](base[q]["meta"])])) |
| if bench == "mlvu" and row["complete"]: |
| row["m_avg"], row["m_avg_base"] = m_avg(var, qids), m_avg(base, qids) |
| modes = defaultdict(int) |
| for q in qids: |
| if not var[q].get("reused"): |
| modes[var[q].get("mode", "error")] += 1 |
| row["changed_modes"] = dict(modes) |
| out.setdefault(variant, {}).setdefault(str(budget), {})[bench] = row |
|
|
| def fmt(p): |
| if p is None: |
| return "—" |
| star = "*" if p["lo"] > 0 or p["hi"] < 0 else " " |
| return f"{p['acc']:5.1f} ({p['delta']:+5.1f}{star} n={p['n']})" |
|
|
| for variant in sorted(out): |
| for budget in sorted(out[variant], key=int): |
| for bench, r in out[variant][budget].items(): |
| flag = "" if r["complete"] else " [INCOMPLETE]" |
| extra = f" M-Avg {r['m_avg']:.1f} ({r['m_avg'] - r['m_avg_base']:+.1f})" if "m_avg" in r else "" |
| print(f"{variant:11s} {budget:>5} {bench:15s} all {fmt(r['all'])} changed {fmt(r['changed'])} " |
| f"long {fmt(r['long'])}{extra}{flag}") |
| if len(sys.argv) > 3: |
| with open(sys.argv[3], "w") as f: |
| json.dump(out, f, indent=1) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
