| """Shape checks on the final scenes of the leaderboard episodes (medium effort), from held-out silhouettes. |
| |
| uv run python scripts/shape_checks.py -> results/shape_checks.json |
| |
| * Mirror test (build tasks): silhouette IoU of the final scene on the 8 held-out views, as built and after mirroring |
| the Gaussian centers front to back (y -> -y), plus three other axis changes. A build that follows the object's real |
| layout loses overlap when mirrored; a rough blob fits the mirrored object about as well as the real one, and no |
| model gains from an axis change (no systematic axis error). |
| * Size (all tasks): area ratio = rendered pixels with alpha > 0.5 over true silhouette pixels, summed over the |
| held-out views. 1 = right size, below 1 = too small or too transparent. |
| """ |
| import argparse |
| import json |
| import statistics as st |
| from collections import defaultdict |
| from pathlib import Path |
|
|
| import pyarrow.parquet as pq |
| import torch |
|
|
| from splatbench.render import render |
| from splatbench.scene import Scene |
|
|
| ap = argparse.ArgumentParser() |
| ap.add_argument("--data", default="data") |
| ap.add_argument("--out", default="results/shape_checks.json") |
| ap.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu") |
| a = ap.parse_args() |
| dev = a.device |
|
|
| TRANSFORMS = {"as_built": torch.eye(3), "mirror_x": torch.diag(torch.tensor([-1.0, 1, 1])), |
| "mirror_y": torch.diag(torch.tensor([1.0, -1, 1])), "rotate_180_z": torch.diag(torch.tensor([-1.0, -1, 1])), |
| "swap_xy": torch.tensor([[0.0, 1, 0], [1, 0, 0], [0, 0, 1]])} |
| rows = pq.read_table(Path(a.data) / "episodes" / "medium_effort.parquet", |
| columns=["episode_id", "model", "model_name", "task_id", "kind", "final_gaussians"]).to_pylist() |
| scenes = {} |
| iou, area = defaultdict(lambda: defaultdict(list)), defaultdict(list) |
| for e in rows: |
| G = e["final_gaussians"] |
| scene = e["task_id"].split("__")[0] |
| if scene not in scenes: |
| scenes[scene] = Scene.load(Path(a.data) / "bench" / "scenes" / scene) |
| if not G: |
| continue |
| cams, _, masks = scenes[scene].torch_views("test", dev) |
| f = lambda k: torch.tensor([g[k] for g in G], dtype=torch.float32, device=dev) |
| gs = dict(means=f("pos"), scales=f("scale"), quats=f("quat"), colors=f("color"), opacities=f("opacity")) |
| mine = truth = 0.0 |
| for cam, m in zip(cams, masks): |
| with torch.no_grad(): |
| al = render(gs, cam)["alpha"] |
| mine += float((al > 0.5).sum()) |
| truth += float((m > 0.5).sum()) |
| area[e["model"]].append(mine / max(truth, 1.0)) |
| if e["kind"] != "build": |
| continue |
| for name, M in TRANSFORMS.items(): |
| g2 = dict(gs, means=gs["means"] @ M.to(dev).T) |
| inter = union = 0.0 |
| for cam, m in zip(cams, masks): |
| with torch.no_grad(): |
| al = render(g2, cam)["alpha"] > 0.5 |
| b = m > 0.5 |
| inter += float((al & b).sum()) |
| union += float((al | b).sum()) |
| iou[e["model"]][name].append(inter / max(union, 1.0)) |
|
|
| names = {e["model"]: e["model_name"] for e in rows} |
| out = {} |
| for m in sorted(iou, key=lambda m: -st.mean(iou[m]["as_built"])): |
| r = area[m] |
| out[m] = dict( |
| heldout_iou={k: round(st.mean(v), 3) for k, v in iou[m].items()}, |
| mirror_drop_points=round(100 * (st.mean(iou[m]["as_built"]) - st.mean(iou[m]["mirror_y"])), 1), |
| median_area_ratio=round(st.median(r), 2), share_too_small=round(sum(x < 0.7 for x in r) / len(r), 2), |
| share_too_big=round(sum(x > 1.3 for x in r) / len(r), 2)) |
| o = out[m] |
| print(f"{names[m]:18s} IoU as built {o['heldout_iou']['as_built']:.3f}, mirrored {o['heldout_iou']['mirror_y']:.3f} " |
| f"(drop {o['mirror_drop_points']:.1f} points) | median area ratio {o['median_area_ratio']:.2f}, " |
| f"too small {o['share_too_small']:.0%}") |
| Path(a.out).parent.mkdir(parents=True, exist_ok=True) |
| Path(a.out).write_text(json.dumps(out, indent=1)) |
|
|
