| |
| """Merge DeepResearch evaluation shards and emit validated stratified metrics.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import statistics |
| from collections import Counter |
| from pathlib import Path |
| from typing import Any, Callable |
|
|
|
|
| def read_jsonl(path: Path) -> list[dict[str, Any]]: |
| with path.open(encoding="utf-8") as handle: |
| return [json.loads(line) for line in handle if line.strip()] |
|
|
|
|
| def sha256(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as handle: |
| for block in iter(lambda: handle.read(1024 * 1024), b""): |
| digest.update(block) |
| return digest.hexdigest() |
|
|
|
|
| def score_metrics(rows: list[dict[str, Any]], key: str) -> dict[str, Any]: |
| scores = [float(row[key]) for row in rows if row.get(key) is not None] |
| return { |
| "questions": len(rows), |
| "scored": len(scores), |
| "correct": sum(scores), |
| "accuracy": statistics.fmean(scores) if scores else None, |
| } |
|
|
|
|
| def grouped_metrics( |
| rows: list[dict[str, Any]], |
| key: str, |
| group: Callable[[dict[str, Any]], Any], |
| ) -> dict[str, Any]: |
| names = sorted({str(group(row)) for row in rows}) |
| return { |
| name: score_metrics([row for row in rows if str(group(row)) == name], key) |
| for name in names |
| } |
|
|
|
|
| def difficulty_teacher(row: dict[str, Any]) -> str: |
| return f"D{row.get('difficulty')}/teacher_{str(row.get('teacher_correct')).lower()}" |
|
|
|
|
| def benchmark_cell(row: dict[str, Any]) -> str: |
| bucket = (row.get("benchmark") or {}).get("selection_bucket") |
| return f"{difficulty_teacher(row)}/{bucket}" |
|
|
|
|
| def calibration_tier(row: dict[str, Any]) -> str: |
| return str((row.get("benchmark") or {}).get("calibration_tier") or "unspecified") |
|
|
|
|
| def tier_bucket(row: dict[str, Any]) -> str: |
| benchmark = row.get("benchmark") or {} |
| return f"{calibration_tier(row)}/{benchmark.get('selection_bucket')}" |
|
|
|
|
| def build_summary( |
| rows: list[dict[str, Any]], |
| *, |
| input_files: list[Path], |
| expected_data: Path | None, |
| model_label: str, |
| ) -> dict[str, Any]: |
| turns = [int(row["num_turns"]) for row in rows if row.get("num_turns") is not None] |
| active = [float(row["active_seconds"]) for row in rows if row.get("active_seconds") is not None] |
| result: dict[str, Any] = { |
| "questions": len(rows), |
| "model_label": model_label or None, |
| "input_files": [str(path) for path in input_files], |
| "expected_data": str(expected_data) if expected_data else None, |
| "expected_data_sha256": sha256(expected_data) if expected_data else None, |
| "agent_errors": sum(bool(row.get("error")) for row in rows), |
| "finish_rate": ( |
| sum(row.get("stop_reason") == "finish" for row in rows) / len(rows) |
| if rows |
| else None |
| ), |
| "mean_turns": statistics.fmean(turns) if turns else None, |
| "mean_active_seconds": statistics.fmean(active) if active else None, |
| "search_calls": sum(int((row.get("tool_stats") or {}).get("search", 0)) for row in rows), |
| "open_page_calls": sum( |
| int((row.get("tool_stats") or {}).get("open_page", 0)) for row in rows |
| ), |
| "stop_reasons": dict(sorted(Counter(row.get("stop_reason") or "missing" for row in rows).items())), |
| "local_em": score_metrics(rows, "local_em"), |
| } |
| for score_key in ("judge_score",): |
| if any(row.get(score_key) is not None for row in rows): |
| result[score_key] = score_metrics(rows, score_key) |
| result[f"{score_key}_by_difficulty"] = grouped_metrics( |
| rows, score_key, lambda row: row.get("difficulty") |
| ) |
| result[f"{score_key}_by_teacher_correct"] = grouped_metrics( |
| rows, score_key, lambda row: row.get("teacher_correct") |
| ) |
| result[f"{score_key}_by_difficulty_teacher"] = grouped_metrics( |
| rows, score_key, difficulty_teacher |
| ) |
| result[f"{score_key}_by_selection_bucket"] = grouped_metrics( |
| rows, |
| score_key, |
| lambda row: (row.get("benchmark") or {}).get("selection_bucket"), |
| ) |
| result[f"{score_key}_by_calibration_tier"] = grouped_metrics( |
| rows, score_key, calibration_tier |
| ) |
| result[f"{score_key}_by_calibration_tier_selection_bucket"] = grouped_metrics( |
| rows, score_key, tier_bucket |
| ) |
| result[f"{score_key}_by_cell"] = grouped_metrics( |
| rows, score_key, benchmark_cell |
| ) |
| result["local_em_by_difficulty"] = grouped_metrics( |
| rows, "local_em", lambda row: row.get("difficulty") |
| ) |
| result["local_em_by_teacher_correct"] = grouped_metrics( |
| rows, "local_em", lambda row: row.get("teacher_correct") |
| ) |
| result["local_em_by_difficulty_teacher"] = grouped_metrics( |
| rows, "local_em", difficulty_teacher |
| ) |
| result["local_em_by_selection_bucket"] = grouped_metrics( |
| rows, |
| "local_em", |
| lambda row: (row.get("benchmark") or {}).get("selection_bucket"), |
| ) |
| result["local_em_by_calibration_tier"] = grouped_metrics( |
| rows, "local_em", calibration_tier |
| ) |
| result["local_em_by_calibration_tier_selection_bucket"] = grouped_metrics( |
| rows, "local_em", tier_bucket |
| ) |
| result["local_em_by_cell"] = grouped_metrics(rows, "local_em", benchmark_cell) |
| result["judge_errors"] = sum(bool(row.get("judge_error")) for row in rows) |
| result["judge_remote_calls"] = sum(bool(row.get("judge_remote_called")) for row in rows) |
| return result |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--inputs", nargs="+", type=Path, required=True) |
| parser.add_argument("--out", type=Path, required=True) |
| parser.add_argument("--expected-data", type=Path) |
| parser.add_argument("--model-label", default="") |
| args = parser.parse_args() |
|
|
| rows = [row for path in args.inputs for row in read_jsonl(path)] |
| if not rows: |
| raise ValueError("no evaluation rows found") |
| indexes = [int(row["index"]) for row in rows] |
| duplicate_indexes = [index for index, count in Counter(indexes).items() if count > 1] |
| if duplicate_indexes: |
| raise ValueError(f"duplicate result indexes: {sorted(duplicate_indexes)}") |
| rows.sort(key=lambda row: int(row["index"])) |
|
|
| if args.expected_data: |
| expected = read_jsonl(args.expected_data) |
| expected_indexes = list(range(len(expected))) |
| if indexes := sorted(indexes): |
| if indexes != expected_indexes: |
| missing = sorted(set(expected_indexes) - set(indexes)) |
| extra = sorted(set(indexes) - set(expected_indexes)) |
| raise ValueError(f"result coverage mismatch: missing={missing} extra={extra}") |
| for index, (row, record) in enumerate(zip(rows, expected, strict=True)): |
| metadata = record.get("metadata") or {} |
| expected_qid = metadata.get("qid") or metadata.get("manifest_qid") |
| actual_qid = row.get("qid") or row.get("manifest_qid") |
| if actual_qid != expected_qid: |
| raise ValueError( |
| f"qid mismatch at index={index}: actual={actual_qid!r} expected={expected_qid!r}" |
| ) |
|
|
| args.out.parent.mkdir(parents=True, exist_ok=True) |
| with args.out.open("w", encoding="utf-8") as handle: |
| for row in rows: |
| handle.write(json.dumps(row, ensure_ascii=False) + "\n") |
| summary = build_summary( |
| rows, |
| input_files=args.inputs, |
| expected_data=args.expected_data, |
| model_label=args.model_label, |
| ) |
| summary["output"] = str(args.out) |
| summary["output_sha256"] = sha256(args.out) |
| summary_path = args.out.with_name(f"{args.out.stem}.summary.json") |
| summary_path.write_text( |
| json.dumps(summary, ensure_ascii=False, indent=2, sort_keys=True) + "\n", |
| encoding="utf-8", |
| ) |
| print("FINAL_AGGREGATE " + json.dumps(summary, sort_keys=True)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
