| |
| """Score model outputs on the AudioSpan release. |
| |
| Two modes (both stdlib-only, no external dependencies): |
| accuracy — multiple choice on native audio, per-layer breakdown. |
| chain — first-error truncation over P->U->R chains on anchor audio. |
| |
| For rubric scoring (which requires a judge model), use score_rubric.py. |
| |
| The answer file carries only what the model produced, one record per |
| question: {"qa_id": ..., "answer": "..."}. For multiple choice the scorer |
| extracts the option letter from the answer text. Correct answers and |
| question profiles are joined in from metadata/<mode>/{S,M,L}.jsonl; |
| questions with no answer count as wrong. |
| |
| Usage: |
| python score.py --mode accuracy --input results/<model>/accuracy.jsonl |
| python score.py --mode chain --input results/<model>/chain.jsonl |
| """ |
|
|
| import argparse |
| import json |
| import logging |
| import re |
| import sys |
| from collections import defaultdict |
| from pathlib import Path |
|
|
| logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s") |
| logger = logging.getLogger(__name__) |
|
|
| RELEASE_ROOT = Path(__file__).resolve().parent.parent |
| TIERS = ("S", "M", "L") |
| LAYER_ORDER = ["perception", "understanding", "reasoning"] |
| LAYER_BY_CODE = {"P": "perception", "U": "understanding", "R": "reasoning"} |
|
|
|
|
| def load_questions(mode: str, data_root: Path) -> list[dict]: |
| questions = [] |
| for tier in TIERS: |
| path = data_root / "metadata" / mode / f"{tier}.jsonl" |
| if not path.is_file(): |
| sys.exit(f"ERROR: metadata not found: {path}") |
| with open(path, encoding="utf-8") as fh: |
| questions.extend(json.loads(line) for line in fh if line.strip()) |
| return questions |
|
|
|
|
| def extract_option(answer) -> str | None: |
| """Normalize a model answer to an option letter (A-D), or None.""" |
| if answer is None: |
| return None |
| if not isinstance(answer, str): |
| answer = str(answer) |
| text = answer.strip() |
| if re.fullmatch(r"[A-Da-d]", text): |
| return text.upper() |
| m = re.search(r"\b(?:answer|option|choice)\s*(?:is|:)?\s*[\(（]?([A-Da-d])[\)）]?\b", |
| text, re.IGNORECASE) |
| if m: |
| return m.group(1).upper() |
| m = re.search(r"[\(（]([A-Da-d])[\)）]", text) |
| if m: |
| return m.group(1).upper() |
| m = re.fullmatch(r"([A-Da-d])[\.\)、:：].*", text, re.DOTALL) |
| if m: |
| return m.group(1).upper() |
| return None |
|
|
|
|
| def load_answers(path: str) -> dict[str, str]: |
| """Map qa_id -> raw answer; later duplicates win.""" |
| preds: dict[str, str] = {} |
| with open(path, encoding="utf-8", errors="replace") as fh: |
| for lineno, line in enumerate(fh, 1): |
| line = line.strip() |
| if not line: |
| continue |
| try: |
| rec = json.loads(line) |
| except json.JSONDecodeError as e: |
| logger.warning("Skipping bad line %d: %s", lineno, e) |
| continue |
| qa_id = rec.get("qa_id") |
| if not qa_id: |
| logger.warning("Skipping line %d: missing qa_id", lineno) |
| continue |
| preds[qa_id] = rec.get("answer") |
| return preds |
|
|
|
|
| def score_accuracy(questions: list[dict], preds: dict[str, str]) -> dict: |
| scored = [] |
| layer_stats: dict[str, dict[str, int]] = defaultdict(lambda: {"correct": 0, "total": 0}) |
|
|
| for q in questions: |
| predicted = extract_option(preds.get(q["qa_id"])) |
| is_correct = predicted is not None and predicted == q["correct_option"] |
| layer = (q.get("question_profile") or {}).get("level", "unknown") |
| layer_stats[layer]["total"] += 1 |
| if is_correct: |
| layer_stats[layer]["correct"] += 1 |
| scored.append({"qa_id": q["qa_id"], "predicted": predicted, "correct": is_correct}) |
|
|
| total = len(scored) |
| correct = sum(1 for s in scored if s["correct"]) |
| per_layer = { |
| layer: { |
| "accuracy": round(s["correct"] / s["total"] * 100, 2) if s["total"] else 0, |
| "correct": s["correct"], "total": s["total"], |
| } |
| for layer, s in sorted(layer_stats.items()) |
| } |
| return { |
| "mode": "accuracy", "total": total, "correct": correct, |
| "accuracy": round(correct / total * 100, 2) if total else 0, |
| "per_layer": per_layer, "scored_records": scored, |
| } |
|
|
|
|
| def score_chain(questions: list[dict], preds: dict[str, str]) -> dict: |
| layer_correct: dict[str, int] = defaultdict(int) |
| layer_total: dict[str, int] = defaultdict(int) |
| chains: dict[str, dict[str, bool | None]] = defaultdict(lambda: {l: None for l in LAYER_ORDER}) |
|
|
| for q in questions: |
| chain_key, layer_code = q["qa_id"].rsplit("_", 1) |
| layer = LAYER_BY_CODE.get(layer_code) |
| if layer not in LAYER_ORDER: |
| continue |
| predicted = extract_option(preds.get(q["qa_id"])) |
| is_correct = predicted is not None and predicted == q["correct_option"] |
| chains[chain_key][layer] = is_correct |
| layer_total[layer] += 1 |
| if is_correct: |
| layer_correct[layer] += 1 |
|
|
| complete = {cid: layers for cid, layers in chains.items() |
| if all(v is not None for v in layers.values())} |
| k = len(LAYER_ORDER) |
|
|
| n_dist = defaultdict(int) |
| scored = [] |
| group_scores = [] |
| for cid, layers in complete.items(): |
| n = 0 |
| for layer in LAYER_ORDER: |
| if layers[layer]: |
| n += 1 |
| else: |
| break |
| n_dist[n] += 1 |
| group_scores.append(n / k) |
| scored.append({ |
| "chain_id": cid, |
| "per_layer": {l: bool(layers[l]) for l in LAYER_ORDER}, |
| "n_correct": n, |
| "correct": n == k, |
| "chain_score": round(n / k * 100, 2), |
| }) |
|
|
| chain_score = sum(group_scores) / len(group_scores) * 100 if group_scores else 0 |
| per_layer = { |
| layer: { |
| "accuracy": round(layer_correct[layer] / layer_total[layer] * 100, 2) if layer_total[layer] else 0, |
| "correct": layer_correct[layer], "total": layer_total[layer], |
| } |
| for layer in LAYER_ORDER |
| } |
| return { |
| "mode": "chain", "total_chains": len(complete), |
| "chain_score": round(chain_score, 2), |
| "per_layer": per_layer, |
| "n_distribution": {str(n): cnt for n, cnt in sorted(n_dist.items())}, |
| "scored_records": scored, |
| } |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description="Score AudioSpan model outputs (accuracy/chain)") |
| parser.add_argument("--input", required=True, |
| help="Prediction JSONL: {\"qa_id\": ..., \"answer\": \"...\"} per line") |
| parser.add_argument("--mode", required=True, choices=["accuracy", "chain"]) |
| parser.add_argument("--data-root", type=Path, default=RELEASE_ROOT, |
| help="release root holding metadata/ (default: parent of evaluate/)") |
| parser.add_argument("--output", help="Scored output path (default: <input>_scored.jsonl)") |
| args = parser.parse_args() |
|
|
| preds = load_answers(args.input) |
| if not preds: |
| print(f"ERROR: no valid answers in {args.input}", file=sys.stderr) |
| sys.exit(1) |
|
|
| questions = load_questions(args.mode, args.data_root.resolve()) |
| known = {q["qa_id"] for q in questions} |
| unknown = sorted(set(preds) - known) |
| if unknown: |
| logger.warning("Ignoring %d unknown qa_id(s), e.g. %s", len(unknown), unknown[0]) |
| covered = sum(1 for q in questions if q["qa_id"] in preds) |
| logger.info("Answers cover %d/%d questions (missing count as wrong)", covered, len(questions)) |
|
|
| summary = score_accuracy(questions, preds) if args.mode == "accuracy" else score_chain(questions, preds) |
|
|
| out_path = args.output or args.input.replace(".jsonl", "_scored.jsonl") |
| with open(out_path, "w", encoding="utf-8") as fh: |
| for s in summary.get("scored_records", []): |
| fh.write(json.dumps(s, ensure_ascii=False) + "\n") |
| logger.info("Scored records: %s", out_path) |
|
|
| print(json.dumps({k: v for k, v in summary.items() if k != "scored_records"}, |
| indent=2, ensure_ascii=False)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
