Datasets:
File size: 6,062 Bytes
65b8e03 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 | #!/usr/bin/env python3
"""Seed variance on the MathVision sample: per-seed accuracy, item-level
agreement, pass@k / majority vote, and breakdowns by level, subject and
question type. Reads runs/<tag>/<model>/seed-*/outputs.jsonl.
Usage: analyze_mathvision_variance.py <repo_dir> [--tag main] [--output report.json]
"""
from __future__ import annotations
import argparse
import itertools
import json
import statistics
from collections import Counter, defaultdict
from pathlib import Path
from video_position_probing.jsonl import read_jsonl
FILE = "outputs.jsonl"
def load(model_dir: Path) -> dict[int, dict[str, dict]]:
runs = {}
for path in sorted(model_dir.glob(f"seed-*/{FILE}")):
seed = int(path.parent.name.split("-")[1])
runs[seed] = {r["item_id"]: r for r in read_jsonl(path) if r.get("status") == "ok"}
return runs
def model_report(runs: dict[int, dict[str, dict]]) -> dict:
seeds = sorted(runs)
items = sorted(set.intersection(*(set(r) for r in runs.values())))
acc = {s: sum(runs[s][i]["correct"] for i in items) / len(items) for s in seeds}
n_correct = {i: sum(runs[s][i]["correct"] for s in seeds) for i in items}
k = len(seeds)
majority = []
for i in items:
votes = Counter(str(runs[s][i]["prediction"]).strip() for s in seeds)
top = votes.most_common(1)[0][0]
majority.append(next(runs[s][i]["correct"] for s in seeds if str(runs[s][i]["prediction"]).strip() == top))
pairs = list(itertools.combinations(seeds, 2))
correctness_flip = statistics.mean(
sum(runs[a][i]["correct"] != runs[b][i]["correct"] for i in items) / len(items) for a, b in pairs)
def group(key):
out = defaultdict(list)
for i in items:
out[key(runs[seeds[0]][i])].append(i)
return {g: {"n": len(v), "mean_acc": statistics.mean(n_correct[i] / k for i in v),
"always": sum(n_correct[i] == k for i in v) / len(v),
"never": sum(n_correct[i] == 0 for i in v) / len(v)} for g, v in sorted(out.items())}
ct = [runs[s][i]["usage"]["completion_tokens"] for s in seeds for i in items]
return {
"seeds": seeds, "items": len(items),
"accuracy_per_seed": acc,
"accuracy_mean": statistics.mean(acc.values()), "accuracy_std": statistics.pstdev(acc.values()),
"accuracy_range": [min(acc.values()), max(acc.values())],
"correct_count_histogram": dict(sorted(Counter(n_correct.values()).items())),
"always_correct": sum(v == k for v in n_correct.values()) / len(items),
"never_correct": sum(v == 0 for v in n_correct.values()) / len(items),
"unstable": sum(0 < v < k for v in n_correct.values()) / len(items),
"pass_at_k": sum(v > 0 for v in n_correct.values()) / len(items),
"majority_vote_accuracy": sum(majority) / len(items),
"pairwise_correctness_flip_rate": correctness_flip,
"length_capped": sum(runs[s][i]["finish_reason"] == "length" for s in seeds for i in items),
"no_answer": sum(runs[s][i]["prediction"] is None for s in seeds for i in items),
"completion_tokens": {"mean": statistics.mean(ct), "median": statistics.median(ct), "max": max(ct)},
"mean_tokens_correct_vs_wrong": [
statistics.mean([runs[s][i]["usage"]["completion_tokens"] for s in seeds for i in items if runs[s][i]["correct"]] or [0]),
statistics.mean([runs[s][i]["usage"]["completion_tokens"] for s in seeds for i in items if not runs[s][i]["correct"]] or [0])],
"by_level": group(lambda r: r["level"]),
"by_type": group(lambda r: "multiple_choice" if r["options"] else "free_form"),
"by_subject": group(lambda r: r["subject"]),
"per_item_correct_count": n_correct,
}
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("repo_dir", type=Path)
parser.add_argument("--tag", default="main")
parser.add_argument("--output", type=Path)
parser.add_argument("--file", default="outputs.jsonl", help="e.g. outputs_rescored.jsonl")
args = parser.parse_args()
global FILE
FILE = args.file
report = {}
for model_dir in sorted((args.repo_dir / "runs" / args.tag).iterdir()):
runs = load(model_dir)
if runs:
report[model_dir.name] = model_report(runs)
models = list(report)
if len(models) == 2: # cross-model agreement on per-item correct counts
a, b = (report[m]["per_item_correct_count"] for m in models)
common = a.keys() & b.keys()
report["cross_model"] = {"items": len(common),
"both_always": sum(a[i] == b[i] == len(report[models[0]]["seeds"]) for i in common),
"both_never": sum(a[i] == b[i] == 0 for i in common)}
if args.output:
args.output.write_text(json.dumps(report, indent=2) + "\n")
for m in models:
r = report[m]
print(f"## {m}: {r['items']} items x {len(r['seeds'])} seeds")
print(" per seed:", {s: f"{100 * v:.1f}" for s, v in r["accuracy_per_seed"].items()},
f"mean {100 * r['accuracy_mean']:.1f} ± {100 * r['accuracy_std']:.1f}")
print(f" always {100 * r['always_correct']:.1f} never {100 * r['never_correct']:.1f} unstable {100 * r['unstable']:.1f}"
f" pass@{len(r['seeds'])} {100 * r['pass_at_k']:.1f} majority {100 * r['majority_vote_accuracy']:.1f}"
f" pairwise flip {100 * r['pairwise_correctness_flip_rate']:.1f}")
print(" correct-count histogram:", r["correct_count_histogram"],
"| length-capped", r["length_capped"], "no-answer", r["no_answer"], "| tokens", r["completion_tokens"])
print(" by level:", {g: f"{100 * v['mean_acc']:.0f}% (n={v['n']}, unstable {100 * (1 - v['always'] - v['never']):.0f}%)"
for g, v in r["by_level"].items()})
print(" by type:", {g: f"{100 * v['mean_acc']:.1f}%" for g, v in r["by_type"].items()})
if __name__ == "__main__":
main()
|