| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import re |
| from collections import Counter |
| from pathlib import Path |
|
|
| from eval_answer_utils import extract_final_answer |
|
|
|
|
| RUNS = { |
| "qwen_full": "runs/20260408T070936Z_aime20_qwen4b_instruct_english/results.jsonl", |
| "qwen_repair": "runs/20260408T070936Z_aime20_qwen4b_instruct_english_repair/results.jsonl", |
| "qwen_cont": ( |
| "runs/20260408T070936Z_aime20_qwen4b_instruct_english_continuation_repaired/results.jsonl" |
| ), |
| "alt": "runs/20260408T070936Z_aime20_qwen4b_instruct_lfm25_alternating_repaired/results.jsonl", |
| "gemma": "runs/20260408T103238Z_aime20_gemma4e4b_thinking/results.jsonl", |
| "gemma_sr": "runs/20260409T125112Z_aime20_gemma4e4b_thinking_self_repair/results.jsonl", |
| } |
|
|
| PRIORITY = ["qwen_cont", "alt", "gemma", "gemma_sr", "qwen_full"] |
| REPAIR_BAD_MARKERS = ( |
| "known solution", |
| "known problem", |
| "known similar", |
| "given the time", |
| "not sure", |
| "guess", |
| "i think i will go", |
| "in the absence", |
| "typo", |
| ) |
| INTEGER_ANSWER_RE = re.compile(r"^0*\d{1,3}$") |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--out-dir", required=True) |
| return parser.parse_args() |
|
|
|
|
| def load_records(path: Path) -> list[dict[str, object]]: |
| return [json.loads(line) for line in path.read_text().splitlines() if line.strip()] |
|
|
|
|
| def answer_source(record: dict[str, object]) -> str: |
| return str( |
| record.get("raw_output") or record.get("final") or record.get("predicted_answer") or "" |
| ) |
|
|
|
|
| def integer_answer(record: dict[str, object]) -> str | None: |
| answer = extract_final_answer(answer_source(record)).strip().strip(" .") |
| if INTEGER_ANSWER_RE.fullmatch(answer) is None: |
| return None |
| return str(int(answer)) |
|
|
|
|
| def clean_repair(record: dict[str, object]) -> bool: |
| source = answer_source(record).lower() |
| return ( |
| integer_answer(record) is not None |
| and record.get("finish_reason") == "stop" |
| and not any(marker in source for marker in REPAIR_BAD_MARKERS) |
| ) |
|
|
|
|
| def majority_vote(votes: list[tuple[str, str]]) -> tuple[str | None, list[str]]: |
| if not votes: |
| return None, [] |
| counts = Counter(answer for answer, _ in votes) |
| answer = sorted( |
| counts, |
| key=lambda value: ( |
| -counts[value], |
| min(PRIORITY.index(name) for candidate, name in votes if candidate == value), |
| ), |
| )[0] |
| return answer, [name for candidate, name in votes if candidate == answer] |
|
|
|
|
| def select_answer(records: dict[str, dict[str, object]]) -> tuple[str | None, list[str], str]: |
| votes = [] |
| for name in PRIORITY: |
| if name in records: |
| answer = integer_answer(records[name]) |
| if answer is not None: |
| votes.append((answer, name)) |
|
|
| answer, sources = majority_vote(votes) |
| rationale = f"majority_{len(sources)}" if sources else "no_integer_vote" |
|
|
| repair = records.get("qwen_repair") |
| if repair is not None and clean_repair(repair) and len(sources) <= 2: |
| repair_answer = integer_answer(repair) |
| if repair_answer is None: |
| raise ValueError(f"clean repair without integer answer for {repair['id']}") |
| return repair_answer, ["qwen_repair"], "clean_qwen_repair_override" |
|
|
| return answer, sources, rationale |
|
|
|
|
| def evaluate(records_by_id: dict[str, dict[str, dict[str, object]]]) -> list[dict[str, object]]: |
| rows = [] |
| for problem_id in sorted(records_by_id): |
| records = records_by_id[problem_id] |
| gold = str(int(str(next(iter(records.values()))["gold_answer"]))) |
| answer, sources, rationale = select_answer(records) |
| votes = {} |
| for name, record in sorted(records.items()): |
| vote = integer_answer(record) |
| if vote is not None: |
| votes[name] = vote |
| rows.append( |
| { |
| "id": problem_id, |
| "gold_answer": gold, |
| "selected_answer": answer, |
| "correct": answer == gold, |
| "selected_sources": sources, |
| "rationale": rationale, |
| "integer_votes": votes, |
| "oracle_correct_in_selected_runs": any( |
| bool(record.get("correct")) for record in records.values() |
| ), |
| } |
| ) |
| return rows |
|
|
|
|
| def load_runs() -> dict[str, dict[str, dict[str, object]]]: |
| records_by_id: dict[str, dict[str, dict[str, object]]] = {} |
| for name, path_text in RUNS.items(): |
| path = Path(path_text) |
| if not path.exists(): |
| raise FileNotFoundError(path) |
| for record in load_records(path): |
| problem_id = str(record["id"]) |
| if problem_id.startswith("aime24_"): |
| records_by_id.setdefault(problem_id, {})[name] = record |
| return records_by_id |
|
|
|
|
| def summarize( |
| rows: list[dict[str, object]], |
| records_by_id: dict[str, dict[str, dict[str, object]]], |
| ) -> dict[str, object]: |
| total = len(rows) |
| correct = sum(bool(row["correct"]) for row in rows) |
| oracle_correct = sum(bool(row["oracle_correct_in_selected_runs"]) for row in rows) |
| single_run_scores = { |
| name: sum( |
| bool(records.get(name, {}).get("correct")) for records in records_by_id.values() |
| ) |
| for name in RUNS |
| } |
| return { |
| "correct": correct, |
| "total": total, |
| "accuracy": correct / total, |
| "oracle_correct_in_selected_runs": oracle_correct, |
| "best_single_run_correct": max(single_run_scores.values()), |
| "single_run_scores": single_run_scores, |
| "runs": RUNS, |
| } |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| records_by_id = load_runs() |
| rows = evaluate(records_by_id) |
| summary = summarize(rows, records_by_id) |
|
|
| out_dir = Path(args.out_dir) |
| out_dir.mkdir(parents=True, exist_ok=True) |
| with (out_dir / "results.jsonl").open("w") as handle: |
| for row in rows: |
| handle.write(json.dumps(row, ensure_ascii=False) + "\n") |
| (out_dir / "summary.json").write_text( |
| json.dumps(summary, indent=2, ensure_ascii=False) + "\n" |
| ) |
| print(json.dumps(summary, indent=2, ensure_ascii=False)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
