| |
| """Export auditable per-clip results for both checkpoints and all three judges.""" |
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import json |
| import statistics |
| from collections import defaultdict |
| from pathlib import Path |
|
|
|
|
| RUNS = ("official_hf_origin_main", "trained_step4572") |
| JUDGES = ( |
| ("gemini", "gemini-3.1-pro-preview", "gemini_gpt55"), |
| ("gpt", "gpt-5.5", "gemini_gpt55"), |
| ("gpt", "gpt-6.1-sol", "gpt61"), |
| ) |
|
|
|
|
| def read_json(path: Path) -> dict: |
| return json.loads(path.read_text(encoding="utf-8")) |
|
|
|
|
| def write_csv(path: Path, rows: list[dict]) -> None: |
| with path.open("w", newline="", encoding="utf-8") as handle: |
| writer = csv.DictWriter(handle, fieldnames=list(rows[0])) |
| writer.writeheader() |
| writer.writerows(rows) |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--benchmark", type=Path, required=True) |
| args = parser.parse_args() |
| benchmark = args.benchmark.resolve() |
| selection = read_json(benchmark / "selection.json") |
| samples = selection["samples"] |
| if len(samples) != 200 or len({item["id"] for item in samples}) != 200: |
| raise ValueError("Expected exactly 200 unique test samples") |
|
|
| judgment_rows = [] |
| summary_rows = [] |
| class_rows = [] |
| for run_name in RUNS: |
| visual = read_json(benchmark / f"results_{run_name}_visual.json")["visual"]["per_sample"] |
| visual_by_id = {item["id"]: item for item in visual} |
| if len(visual) != 200 or len(visual_by_id) != 200: |
| raise ValueError(f"Expected 200 visual records for {run_name}") |
| judge_records = {} |
| for judge, expected_model, suffix in JUDGES: |
| result = read_json(benchmark / f"results_{run_name}_{suffix}.json")["mechanics_fidelity"][judge] |
| records = result["records"] |
| if result["n_runs"] != 3 or len(records) != 600: |
| raise ValueError(f"Expected 600 records for {run_name} {expected_model}") |
| grouped = defaultdict(list) |
| for record in records: |
| if record["model"] != expected_model: |
| raise ValueError(f"Unexpected judge model for {run_name}: {record['model']}") |
| grouped[(record["id"], int(record["run"]))].append(record) |
| judge_records[expected_model] = grouped |
|
|
| for sample in samples: |
| sample_id = sample["id"] |
| prediction = (benchmark / "generated" / run_name / sample["output_name"]).resolve() |
| if not prediction.is_file(): |
| raise FileNotFoundError(prediction) |
| source = sample["identity"] |
| base = { |
| "id": sample_id, |
| "source_id": sample["source_id"], |
| "model": run_name, |
| "ground_truth": sample["label"], |
| "definition_id": source.get("definition_id", ""), |
| "source_archive": source.get("source_archive", ""), |
| "source_reused": source.get("reused", ""), |
| "source_video": sample["source_video"], |
| "generated_video": str(prediction), |
| "source_video_sha256": source["video_sha256"], |
| } |
| visual_item = visual_by_id[sample_id] |
| summary = {**base, "ssim": visual_item["ssim"], "lpips": visual_item["lpips"]} |
| for _, expected_model, _ in JUDGES: |
| records = [] |
| for judge_run in (1, 2, 3): |
| key = (sample_id, judge_run) |
| grouped = judge_records[expected_model][key] |
| if len(grouped) != 1: |
| raise ValueError(f"Expected one record for {run_name} {expected_model} {key}") |
| record = grouped[0] |
| stat = prediction.stat() |
| if (Path(record["prediction"]).resolve() != prediction |
| or int(record["prediction_size"]) != stat.st_size |
| or int(record["prediction_mtime_ns"]) != stat.st_mtime_ns |
| or record["ground_truth"] != sample["label"]): |
| raise ValueError(f"Judge record is not tied to expected video: {run_name} {key}") |
| records.append(record) |
| judgment_rows.append({ |
| **base, |
| "judge_model": expected_model, |
| "transport": record["transport"], |
| "run": judge_run, |
| "predicted_state": record["predicted_state"], |
| "correct": bool(record["correct"]), |
| "confidence": record.get("confidence"), |
| "evidence": json.dumps(record.get("evidence"), ensure_ascii=False), |
| "reason": record.get("reason"), |
| "protocol_version": record["protocol_version"], |
| }) |
| summary[f"{expected_model}_correct_runs"] = sum(bool(item["correct"]) for item in records) |
| summary[f"{expected_model}_predictions"] = " | ".join(item["predicted_state"] for item in records) |
| summary_rows.append(summary) |
|
|
| for label, expected_count in selection["class_counts"].items(): |
| matching = [row for row in summary_rows if row["model"] == run_name and row["ground_truth"] == label] |
| if len(matching) != expected_count: |
| raise ValueError(f"Unexpected class count for {run_name} {label}") |
| row = { |
| "model": run_name, |
| "class": label, |
| "samples": expected_count, |
| "ssim_mean": statistics.fmean(item["ssim"] for item in matching), |
| "lpips_mean": statistics.fmean(item["lpips"] for item in matching), |
| } |
| for _, expected_model, _ in JUDGES: |
| for judge_run in (1, 2, 3): |
| matching_judge = [item for item in judgment_rows |
| if item["model"] == run_name and item["ground_truth"] == label |
| and item["judge_model"] == expected_model and item["run"] == judge_run] |
| if len(matching_judge) != expected_count: |
| raise ValueError(f"Incomplete {expected_model} class {label} run {judge_run}") |
| row[f"{expected_model}_run{judge_run}_correct"] = sum(item["correct"] for item in matching_judge) |
| class_rows.append(row) |
|
|
| if len(judgment_rows) != 3600 or len(summary_rows) != 400 or len(class_rows) != 10: |
| raise ValueError("Expected 3600 judgments, 400 clip summaries, and 10 class summaries") |
| write_csv(benchmark / "per_run_judgments.csv", judgment_rows) |
| write_csv(benchmark / "per_clip_summary.csv", summary_rows) |
| write_csv(benchmark / "per_class_summary.csv", class_rows) |
| with (benchmark / "per_run_judgments.jsonl").open("w", encoding="utf-8") as handle: |
| for row in judgment_rows: |
| handle.write(json.dumps(row, ensure_ascii=False) + "\n") |
| print("Exported 3600 judgments, 400 clip summaries, and 10 class summaries") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
