Datasets:
Download code/analyze_mathvision_variance.py from Miiche/vpp-mathvision-seed-variance: direct link, hf CLI and curl.
- Browser
- Download file 6.06 kB
-
https://huggingface.co/datasets/Miiche/vpp-mathvision-seed-variance/resolve/main/code/analyze_mathvision_variance.py
- Command line
-
hf download hf://datasets/Miiche/vpp-mathvision-seed-variance/code/analyze_mathvision_variance.py
-
curl -L -o analyze_mathvision_variance.py https://huggingface.co/datasets/Miiche/vpp-mathvision-seed-variance/resolve/main/code/analyze_mathvision_variance.py
6.06 kB
| #!/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() | |