Upload evaluate_matrix_game_sc.py

evaluate_matrix_game_sc.py

@@ -0,0 +1,360 @@
+#!/usr/bin/env python3
+"""Reproduce Matrix-Game 2.0 self-consistency metrics from released videos."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import math
+import re
+import sys
+from collections import defaultdict
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Sequence
+
+import cv2
+import numpy as np
+
+
+EXPECTED_COUNTS = {"inverse": 448, "loop": 445, "equivalence": 239}
+PAPER_RESULTS = {
+    "inverse": {"lpips": 0.71, "psnr": 10.45},
+    "loop": {"lpips": 0.72, "psnr": 10.62},
+    "equivalence": {"lpips": 0.59, "psnr": 12.57},
+}
+EQUIVALENCE_RE = re.compile(
+    r"(?P<run>run_\d+_\d+)__pair_(?P<pair>\d+)_(?P<branch>[AB])_traj_\d+\.mp4$",
+    re.IGNORECASE,
+)
+
+
+@dataclass(frozen=True)
+class EvaluationUnit:
+    relation: str
+    unit: str
+    video_a: Path
+    video_b: Path | None = None
+
+
+@dataclass(frozen=True)
+class MetricRow:
+    relation: str
+    unit: str
+    video_a: str
+    video_b: str
+    frame_a: int
+    frame_b: int
+    width: int
+    height: int
+    psnr: float
+    lpips: float | None
+    psnr_exact_match: bool
+
+
+def is_downloaded_video(path: Path) -> bool:
+    if not path.is_file() or path.stat().st_size <= 200:
+        return False
+    with path.open("rb") as handle:
+        return not handle.read(64).startswith(b"version https://git-lfs.github.com/spec/v1")
+
+
+def discover_units(root: Path, strict_counts: bool = True) -> list[EvaluationUnit]:
+    units: list[EvaluationUnit] = []
+    for relation in ("inverse", "loop"):
+        for difficulty in ("easy", "hard"):
+            folder = root / f"{relation}_{difficulty}"
+            if not folder.is_dir():
+                raise FileNotFoundError(f"missing dataset folder: {folder}")
+            for path in sorted(folder.glob("*.mp4")):
+                if not is_downloaded_video(path):
+                    raise RuntimeError(f"missing Git LFS video object: {path}")
+                units.append(EvaluationUnit(relation, path.stem, path))
+
+    equivalence_folder = root / "equivalence"
+    if not equivalence_folder.is_dir():
+        raise FileNotFoundError(f"missing dataset folder: {equivalence_folder}")
+    pairs: dict[str, dict[str, Path]] = defaultdict(dict)
+    for path in sorted(equivalence_folder.glob("*.mp4")):
+        if not is_downloaded_video(path):
+            raise RuntimeError(f"missing Git LFS video object: {path}")
+        match = EQUIVALENCE_RE.fullmatch(path.name)
+        if not match:
+            raise ValueError(f"unrecognized Equivalence filename: {path.name}")
+        unit = f"{match.group('run')}__pair_{match.group('pair')}"
+        branch = match.group("branch").upper()
+        if branch in pairs[unit]:
+            raise ValueError(f"duplicate Equivalence branch {branch}: {unit}")
+        pairs[unit][branch] = path
+    for unit, branches in sorted(pairs.items()):
+        if set(branches) != {"A", "B"}:
+            raise ValueError(f"incomplete Equivalence pair {unit}: {sorted(branches)}")
+        units.append(EvaluationUnit("equivalence", unit, branches["A"], branches["B"]))
+
+    counts = {relation: sum(unit.relation == relation for unit in units) for relation in EXPECTED_COUNTS}
+    if strict_counts and counts != EXPECTED_COUNTS:
+        raise RuntimeError(f"unexpected graph counts: found {counts}, expected {EXPECTED_COUNTS}")
+    return units
+
+
+def read_endpoint(path: Path, endpoint: str) -> tuple[np.ndarray, int]:
+    capture = cv2.VideoCapture(str(path))
+    if not capture.isOpened():
+        raise RuntimeError(f"failed to open video: {path}")
+    frame_count = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))
+    if frame_count < 2:
+        capture.release()
+        raise RuntimeError(f"video has fewer than two frames: {path}")
+    frame_index = 0 if endpoint == "first" else frame_count - 1
+    capture.set(cv2.CAP_PROP_POS_FRAMES, frame_index)
+    ok, frame = capture.read()
+    capture.release()
+    if not ok:
+        raise RuntimeError(f"failed to decode {endpoint} frame: {path}")
+    return cv2.cvtColor(frame, cv2.COLOR_BGR2RGB), frame_index
+
+
+def psnr(reference: np.ndarray, prediction: np.ndarray) -> float:
+    if reference.shape != prediction.shape:
+        raise ValueError(f"frame shape mismatch: {reference.shape} versus {prediction.shape}")
+    mse = np.mean((reference.astype(np.float64) - prediction.astype(np.float64)) ** 2)
+    if mse == 0:
+        return float("inf")
+    return 10.0 * math.log10((255.0**2) / mse)
+
+
+class LPIPSMetric:
+    def __init__(self, device: str) -> None:
+        try:
+            import lpips
+            import torch
+        except ImportError as exc:
+            raise RuntimeError("install the Python dependencies listed in README.md before using --lpips") from exc
+        if device == "auto":
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.torch = torch
+        self.device = torch.device(device)
+        self.model = lpips.LPIPS(net="alex").to(self.device).eval()
+
+    def __call__(self, reference: np.ndarray, prediction: np.ndarray) -> float:
+        if reference.shape != prediction.shape:
+            raise ValueError(f"frame shape mismatch: {reference.shape} versus {prediction.shape}")
+        tensors = []
+        for image in (reference, prediction):
+            tensor = self.torch.from_numpy(np.ascontiguousarray(image)).permute(2, 0, 1).float()
+            tensors.append(tensor.div(127.5).sub(1.0).unsqueeze(0).to(self.device))
+        with self.torch.inference_mode():
+            value = self.model(tensors[0], tensors[1], normalize=False)
+        return float(value.item())
+
+
+def evaluate(units: Sequence[EvaluationUnit], lpips_metric: LPIPSMetric | None) -> list[MetricRow]:
+    rows: list[MetricRow] = []
+    for index, unit in enumerate(units, start=1):
+        if unit.relation in {"inverse", "loop"}:
+            frame_a, index_a = read_endpoint(unit.video_a, "first")
+            frame_b, index_b = read_endpoint(unit.video_a, "last")
+            video_b = unit.video_a
+        else:
+            if unit.video_b is None:
+                raise AssertionError("Equivalence unit is missing branch B")
+            frame_a, index_a = read_endpoint(unit.video_a, "last")
+            frame_b, index_b = read_endpoint(unit.video_b, "last")
+            video_b = unit.video_b
+        value_psnr = psnr(frame_a, frame_b)
+        value_lpips = lpips_metric(frame_a, frame_b) if lpips_metric else None
+        rows.append(
+            MetricRow(
+                relation=unit.relation,
+                unit=unit.unit,
+                video_a=str(unit.video_a),
+                video_b=str(video_b),
+                frame_a=index_a,
+                frame_b=index_b,
+                width=int(frame_a.shape[1]),
+                height=int(frame_a.shape[0]),
+                psnr=value_psnr,
+                lpips=value_lpips,
+                psnr_exact_match=math.isinf(value_psnr),
+            )
+        )
+        if index % 100 == 0 or index == len(units):
+            print(f"evaluated {index}/{len(units)} graph units", flush=True)
+    return rows
+
+
+def bootstrap_ci(values: Sequence[float], seed: int, repetitions: int) -> tuple[float, float]:
+    array = np.asarray(values, dtype=np.float64)
+    if len(array) < 2:
+        return float("nan"), float("nan")
+    rng = np.random.default_rng(seed)
+    means = np.empty(repetitions, dtype=np.float64)
+    for start in range(0, repetitions, 500):
+        count = min(500, repetitions - start)
+        indices = rng.integers(0, len(array), size=(count, len(array)))
+        means[start : start + count] = array[indices].mean(axis=1)
+    low, high = np.quantile(means, [0.025, 0.975])
+    return float(low), float(high)
+
+
+def summarize(rows: Sequence[MetricRow], seed: int, repetitions: int) -> list[dict[str, object]]:
+    output: list[dict[str, object]] = []
+    for relation in ("inverse", "loop", "equivalence"):
+        group = [row for row in rows if row.relation == relation]
+        summary: dict[str, object] = {
+            "relation": relation,
+            "n_graphs": len(group),
+            "psnr_finite_n": sum(math.isfinite(row.psnr) for row in group),
+            "psnr_exact_match_n": sum(row.psnr_exact_match for row in group),
+        }
+        for metric in ("psnr", "lpips"):
+            values = [
+                float(value)
+                for row in group
+                if (value := getattr(row, metric)) is not None and math.isfinite(float(value))
+            ]
+            if not values:
+                continue
+            low, high = bootstrap_ci(values, seed, repetitions)
+            summary.update(
+                {
+                    metric: float(np.mean(values)),
+                    f"{metric}_std": float(np.std(values, ddof=1)) if len(values) > 1 else 0.0,
+                    f"{metric}_ci95_low": low,
+                    f"{metric}_ci95_high": high,
+                }
+            )
+        output.append(summary)
+    return output
+
+
+def write_csv(path: Path, rows: Sequence[dict[str, object]]) -> None:
+    if not rows:
+        return
+    columns: list[str] = []
+    for row in rows:
+        for key in row:
+            if key not in columns:
+                columns.append(key)
+    with path.open("w", newline="", encoding="utf-8") as handle:
+        writer = csv.DictWriter(handle, fieldnames=columns)
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def paper_check(summaries: Sequence[dict[str, object]]) -> tuple[bool, list[dict[str, object]]]:
+    checks: list[dict[str, object]] = []
+    passed = True
+    for summary in summaries:
+        relation = str(summary["relation"])
+        for metric in ("lpips", "psnr"):
+            value = summary.get(metric)
+            expected = PAPER_RESULTS[relation][metric]
+            metric_passed = value is not None and round(float(value), 2) == expected
+            checks.append(
+                {
+                    "relation": relation,
+                    "metric": metric,
+                    "computed": value,
+                    "paper_rounded": expected,
+                    "pass_at_2_decimals": metric_passed,
+                }
+            )
+            passed = passed and metric_passed
+    return passed, checks
+
+
+def report(summaries: Sequence[dict[str, object]], check_passed: bool | None) -> str:
+    lines = [
+        "# Matrix-Game 2.0 SC Reproduction",
+        "",
+        "| Relation | Graph N | LPIPS (95% CI) | PSNR dB (95% CI) | Exact PSNR pairs |",
+        "| --- | ---: | ---: | ---: | ---: |",
+    ]
+    for row in summaries:
+        lpips_text = "not computed"
+        if "lpips" in row:
+            lpips_text = (
+                f"{row['lpips']:.4f} [{row['lpips_ci95_low']:.4f}, "
+                f"{row['lpips_ci95_high']:.4f}]"
+            )
+        psnr_text = f"{row['psnr']:.4f} [{row['psnr_ci95_low']:.4f}, {row['psnr_ci95_high']:.4f}]"
+        lines.append(
+            f"| {str(row['relation']).title()} | {row['n_graphs']} | {lpips_text} | "
+            f"{psnr_text} | {row['psnr_exact_match_n']} |"
+        )
+    if check_passed is not None:
+        lines.extend(["", f"Paper rounded-value check: **{'PASS' if check_passed else 'FAIL'}**."])
+    lines.extend(
+        [
+            "",
+            "Inverse/Loop compare the generated first and final frames. Equivalence compares",
+            "the generated final frames of paired A/B rollouts. Confidence intervals use",
+            "10,000 graph-level bootstrap resamples by default.",
+            "",
+        ]
+    )
+    return "\n".join(lines)
+
+
+def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--data", type=Path, default=Path("data/Nips_WM_Eval_qzf"))
+    parser.add_argument("--output", type=Path, default=Path("results/matrix_game_sc"))
+    parser.add_argument("--lpips", action="store_true", help="compute LPIPS 0.1.4 with AlexNet")
+    parser.add_argument("--device", default="auto", help="auto, cpu, cuda, or cuda:<index>")
+    parser.add_argument("--seed", type=int, default=2026)
+    parser.add_argument("--bootstrap-repetitions", type=int, default=10_000)
+    parser.add_argument("--allow-partial", action="store_true", help="disable published-count checks")
+    parser.add_argument("--check-paper", action="store_true", help="check values at paper precision")
+    return parser.parse_args(argv)
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = parse_args(argv)
+    if not args.data.is_dir():
+        raise SystemExit(f"dataset directory does not exist: {args.data}")
+    if args.check_paper and not args.lpips:
+        raise SystemExit("--check-paper requires --lpips")
+    args.output.mkdir(parents=True, exist_ok=True)
+
+    units = discover_units(args.data, strict_counts=not args.allow_partial)
+    metric = LPIPSMetric(args.device) if args.lpips else None
+    rows = evaluate(units, metric)
+    summaries = summarize(rows, args.seed, args.bootstrap_repetitions)
+    check_passed: bool | None = None
+    checks: list[dict[str, object]] = []
+    if args.check_paper:
+        check_passed, checks = paper_check(summaries)
+
+    write_csv(args.output / "per_graph.csv", [asdict(row) for row in rows])
+    write_csv(args.output / "summary.csv", summaries)
+    if checks:
+        write_csv(args.output / "paper_check.csv", checks)
+    audit = {
+        "data": str(args.data.resolve()),
+        "definitions": {
+            "inverse": "generated first frame versus generated final frame",
+            "loop": "generated first frame versus generated final frame",
+            "equivalence": "generated branch-A final frame versus generated branch-B final frame",
+        },
+        "expected_counts": EXPECTED_COUNTS,
+        "observed_counts": {row["relation"]: row["n_graphs"] for row in summaries},
+        "lpips": "lpips==0.1.4, AlexNet, RGB in [-1,1]" if args.lpips else "not computed",
+        "psnr": "RGB uint8, MAX=255; exact matches excluded from finite PSNR mean and counted separately",
+        "bootstrap_seed": args.seed,
+        "bootstrap_repetitions": args.bootstrap_repetitions,
+        "paper_check_passed": check_passed,
+    }
+    (args.output / "audit.json").write_text(
+        json.dumps(audit, indent=2, ensure_ascii=True) + "\n", encoding="utf-8"
+    )
+    (args.output / "report.md").write_text(report(summaries, check_passed), encoding="utf-8")
+    print(report(summaries, check_passed))
+    print(f"Outputs: {args.output.resolve()}")
+    return 0 if check_passed is not False else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())