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()