Add feed_forward_benchmark_nvs.py (feed-forward benchmark reference)

feed_forward_benchmark_nvs.py

@@ -0,0 +1,372 @@
+"""
+Feed-forward novel view synthesis (NVS) benchmark — reference implementation
+=============================================================================
+
+This script standardizes **per-scene** NVS evaluation for **feed-forward** 3DGS /
+Gaussian splatting style models that follow the AnySplat inference path used in
+``eval_nvs_full.py``.
+
+Dataset layout
+------------
+- ``--data_root``: directory whose **subfolders** are scene names.
+- Each scene folder contains unordered RGB frames (``.png`` / ``.jpg`` / ``.jpeg``).
+- Optional ``--scene_index``: JSON list of scene folder names to evaluate (subset).
+
+Train / hold-out split (LLFF-style)
+-----------------------------------
+Frames are sorted by filename, then indexed ``0..N-1``.
+- **Context** (conditioning): indices where ``idx % llffhold != 0`` (default ``llffhold=8``).
+- **Target** (novel views to render): indices where ``idx % llffhold == 0``.
+
+Metrics (on target views only)
+------------------------------
+- PSNR, SSIM, LPIPS between predicted and ground-truth target images in **[0, 1]**.
+
+Outputs
+-------
+- Per-scene folders under ``--output_root/<scene>/{gt,pred}/``.
+- Timestamped summary ``<cwd>/<summary_prefix>_<timestamp>.txt``.
+- Optional JSON of per-scene dicts with ``--save_json``.
+
+Dependencies (when vendoring outside this repository)
+-----------------------------------------------------
+You need the same model and utilities as the parent project: ``AnySplat``,
+``pose_encoding_to_extri_intri``, ``process_image``, and ``src.evaluation.metrics``.
+
+``BENCHMARK_VERSION`` documents the protocol; bump when the split or metrics change.
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime
+import json
+import os
+import sys
+from collections import defaultdict
+from pathlib import Path
+from typing import Any, TypedDict
+
+import torch
+
+# Repository root on sys.path (same pattern as legacy eval scripts).
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from src.evaluation.metrics import compute_lpips, compute_psnr, compute_ssim
+from src.misc.image_io import save_image
+from src.model.encoder.vggt.utils.pose_enc import pose_encoding_to_extri_intri
+from src.model.model.anysplat import AnySplat
+from src.utils.image import process_image
+
+BENCHMARK_VERSION = "1.0.0"
+BENCHMARK_NAME = "feed_forward_nvs_llffhold"
+
+
+class NVSSceneResult(TypedDict, total=False):
+    scene: str
+    ok: bool
+    psnr: float
+    ssim: float
+    lpips: float
+    error: str
+
+
+def build_argparser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=(
+            f"{BENCHMARK_NAME} v{BENCHMARK_VERSION}: full NVS evaluation "
+            "without video dumping (PSNR / SSIM / LPIPS)."
+        )
+    )
+    parser.add_argument(
+        "--data_root",
+        type=str,
+        required=True,
+        help="Root directory containing per-scene image folders.",
+    )
+    parser.add_argument(
+        "--scene_index",
+        type=str,
+        default="",
+        help="Optional JSON file listing scene folder names.",
+    )
+    parser.add_argument(
+        "--llffhold",
+        type=int,
+        default=8,
+        help="LLFF holdout step for context/target split.",
+    )
+    parser.add_argument(
+        "--device",
+        type=str,
+        default="cuda",
+        help='Device, e.g. "cuda" or "cpu".',
+    )
+    parser.add_argument(
+        "--summary_prefix",
+        type=str,
+        default="nvs_results",
+        help="Output summary filename prefix.",
+    )
+    parser.add_argument(
+        "--output_root",
+        type=str,
+        default="outputs/nvs_full_eval",
+        help="Root directory for per-scene artifacts (gt/pred).",
+    )
+    parser.add_argument(
+        "--category_split_token",
+        type=str,
+        default="__",
+        help="Token used to infer category from scene name suffix.",
+    )
+    parser.add_argument(
+        "--save_json",
+        action="store_true",
+        help="Also save per-scene raw metrics in JSON.",
+    )
+    parser.add_argument(
+        "--pretrained_id",
+        type=str,
+        default="lhjiang/anysplat",
+        help="Hugging Face model id for AnySplat.from_pretrained.",
+    )
+    return parser
+
+
+def load_scene_names(data_root: Path, scene_index: str) -> list[str]:
+    if scene_index:
+        with open(scene_index, "r", encoding="utf-8") as f:
+            names = json.load(f)
+        return [str(x) for x in names]
+    return sorted([p.name for p in data_root.iterdir() if p.is_dir()])
+
+
+def infer_category(scene_name: str, split_token: str) -> str:
+    if split_token and split_token in scene_name:
+        return scene_name.rsplit(split_token, 1)[-1]
+    return "uncategorized"
+
+
+@torch.no_grad()
+def evaluate_one_scene(
+    model: AnySplat,
+    scene_dir: Path,
+    llffhold: int,
+    device: torch.device,
+    output_root: Path,
+) -> dict[str, Any]:
+    image_names = sorted(
+        [
+            str(p)
+            for p in scene_dir.iterdir()
+            if p.suffix.lower() in {".png", ".jpg", ".jpeg"}
+        ]
+    )
+    if len(image_names) < 2:
+        return {"ok": False, "error": "not enough images"}
+
+    images = [process_image(p) for p in image_names]
+    ctx_indices = [idx for idx in range(len(image_names)) if idx % llffhold != 0]
+    tgt_indices = [idx for idx in range(len(image_names)) if idx % llffhold == 0]
+    if not ctx_indices or not tgt_indices:
+        return {"ok": False, "error": "invalid context/target split"}
+
+    ctx_images = torch.stack([images[i] for i in ctx_indices], dim=0).unsqueeze(0).to(device)
+    tgt_images = torch.stack([images[i] for i in tgt_indices], dim=0).unsqueeze(0).to(device)
+    ctx_images = (ctx_images + 1) * 0.5
+    tgt_images = (tgt_images + 1) * 0.5
+    b, v, _, h, w = tgt_images.shape
+
+    encoder_output = model.encoder(
+        ctx_images,
+        global_step=0,
+        visualization_dump={},
+    )
+    gaussians, pred_context_pose = encoder_output.gaussians, encoder_output.pred_context_pose
+
+    num_context_view = ctx_images.shape[1]
+    vggt_input_image = torch.cat((ctx_images, tgt_images), dim=1).to(torch.bfloat16)
+    with torch.cuda.amp.autocast(enabled=False, dtype=torch.bfloat16):
+        aggregated_tokens_list, _ = model.encoder.aggregator(
+            vggt_input_image,
+            intermediate_layer_idx=model.encoder.cfg.intermediate_layer_idx,
+        )
+    with torch.cuda.amp.autocast(enabled=False):
+        fp32_tokens = [token.float() for token in aggregated_tokens_list]
+        pred_all_pose_enc = model.encoder.camera_head(fp32_tokens)[-1]
+        pred_all_extrinsic, pred_all_intrinsic = pose_encoding_to_extri_intri(
+            pred_all_pose_enc, vggt_input_image.shape[-2:]
+        )
+
+    extrinsic_padding = (
+        torch.tensor([0, 0, 0, 1], device=pred_all_extrinsic.device, dtype=pred_all_extrinsic.dtype)
+        .view(1, 1, 1, 4)
+        .repeat(b, vggt_input_image.shape[1], 1, 1)
+    )
+    pred_all_extrinsic = torch.cat([pred_all_extrinsic, extrinsic_padding], dim=2).inverse()
+
+    pred_all_intrinsic[:, :, 0] = pred_all_intrinsic[:, :, 0] / w
+    pred_all_intrinsic[:, :, 1] = pred_all_intrinsic[:, :, 1] / h
+    pred_all_context_extrinsic = pred_all_extrinsic[:, :num_context_view]
+    pred_all_target_extrinsic = pred_all_extrinsic[:, num_context_view:]
+    pred_all_target_intrinsic = pred_all_intrinsic[:, num_context_view:]
+
+    scale_factor = (
+        pred_context_pose["extrinsic"][:, :, :3, 3].mean()
+        / pred_all_context_extrinsic[:, :, :3, 3].mean()
+    )
+    pred_all_target_extrinsic[..., :3, 3] = pred_all_target_extrinsic[..., :3, 3] * scale_factor
+
+    output = model.decoder.forward(
+        gaussians,
+        pred_all_target_extrinsic,
+        pred_all_target_intrinsic.float(),
+        torch.ones(1, v, device=device) * 0.01,
+        torch.ones(1, v, device=device) * 100,
+        (h, w),
+    )
+
+    psnr = compute_psnr(output.color[0], tgt_images[0]).mean().item()
+    ssim = compute_ssim(output.color[0], tgt_images[0]).mean().item()
+    lpips = compute_lpips(output.color[0], tgt_images[0]).mean().item()
+
+    scene_out = output_root / scene_dir.name
+    for idx, (gt_image, pred_image) in enumerate(zip(tgt_images[0], output.color[0])):
+        save_image(gt_image, scene_out / "gt" / f"{idx:0>6}.jpg")
+        save_image(pred_image, scene_out / "pred" / f"{idx:0>6}.jpg")
+
+    return {"ok": True, "psnr": psnr, "ssim": ssim, "lpips": lpips}
+
+
+def write_summary(
+    output_txt: Path,
+    results: list[dict[str, Any]],
+    category_split_token: str,
+) -> None:
+    per_category: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for r in results:
+        if r.get("ok"):
+            c = infer_category(r["scene"], category_split_token)
+            per_category[c].append(r)
+
+    with output_txt.open("w", encoding="utf-8") as f:
+        f.write(f"NVS Evaluation Results ({BENCHMARK_NAME} v{BENCHMARK_VERSION})\n")
+        f.write("=" * 50 + "\n\n")
+        f.write("Per-category results:\n")
+        f.write("-" * 50 + "\n")
+        for c in sorted(per_category.keys()):
+            vals = per_category[c]
+            f.write(f"{c:<22} PSNR: {sum(v['psnr'] for v in vals) / len(vals):.4f}\n")
+            f.write(f"{c:<22} SSIM: {sum(v['ssim'] for v in vals) / len(vals):.4f}\n")
+            f.write(f"{c:<22} LPIPS: {sum(v['lpips'] for v in vals) / len(vals):.4f}\n")
+            f.write("\n")
+
+        ok_vals = [r for r in results if r.get("ok")]
+        f.write("-" * 50 + "\n")
+        if ok_vals:
+            f.write(f"Mean PSNR: {sum(v['psnr'] for v in ok_vals) / len(ok_vals):.4f}\n")
+            f.write(f"Mean SSIM: {sum(v['ssim'] for v in ok_vals) / len(ok_vals):.4f}\n")
+            f.write(f"Mean LPIPS: {sum(v['lpips'] for v in ok_vals) / len(ok_vals):.4f}\n")
+            f.write(f"Num scenes (success): {len(ok_vals)}\n")
+
+        fail_vals = [r for r in results if not r.get("ok")]
+        if fail_vals:
+            f.write(f"Num scenes (failed): {len(fail_vals)}\n")
+        f.write("\n" + "=" * 50 + "\n")
+
+
+def run_feed_forward_nvs_benchmark(args: argparse.Namespace) -> list[dict[str, Any]]:
+    """
+    Run the full benchmark over ``args.data_root`` and return per-scene result dicts.
+
+    Side effects: writes ``--output_root`` scene folders, summary txt under cwd,
+    and optional JSON when ``args.save_json`` is True.
+    """
+    data_root = Path(args.data_root)
+    if not data_root.exists():
+        raise FileNotFoundError(f"Data root does not exist: {data_root}")
+
+    if args.device == "cuda" and not torch.cuda.is_available():
+        print("CUDA not available, fallback to CPU.", flush=True)
+        device = torch.device("cpu")
+    else:
+        device = torch.device(args.device)
+
+    print(
+        f"Loading AnySplat ({args.pretrained_id}) [{BENCHMARK_NAME} v{BENCHMARK_VERSION}]...",
+        flush=True,
+    )
+    model = AnySplat.from_pretrained(args.pretrained_id)
+    model.to(device)
+    model.eval()
+    for p in model.parameters():
+        p.requires_grad = False
+    print(f"Using device: {device}", flush=True)
+
+    scene_names = load_scene_names(data_root, args.scene_index)
+    print(f"Found {len(scene_names)} scenes to evaluate.", flush=True)
+    output_root = Path(args.output_root)
+    output_root.mkdir(parents=True, exist_ok=True)
+
+    results: list[dict[str, Any]] = []
+    for i, scene_name in enumerate(scene_names, start=1):
+        scene_dir = data_root / scene_name
+        if not scene_dir.is_dir():
+            results.append({"scene": scene_name, "ok": False, "error": "scene folder missing"})
+            print(f"[{i}/{len(scene_names)}] FAILED {scene_name}: folder missing", flush=True)
+            continue
+        try:
+            one = evaluate_one_scene(
+                model=model,
+                scene_dir=scene_dir,
+                llffhold=args.llffhold,
+                device=device,
+                output_root=output_root,
+            )
+            one["scene"] = scene_name
+            results.append(one)
+            if one.get("ok"):
+                print(
+                    f"[{i}/{len(scene_names)}] {scene_name} -> "
+                    f"PSNR {one['psnr']:.2f}, SSIM {one['ssim']:.3f}, LPIPS {one['lpips']:.3f}",
+                    flush=True,
+                )
+            else:
+                print(f"[{i}/{len(scene_names)}] FAILED {scene_name}: {one.get('error')}", flush=True)
+        except Exception as e:
+            results.append({"scene": scene_name, "ok": False, "error": str(e)})
+            print(f"[{i}/{len(scene_names)}] FAILED {scene_name}: {e}", flush=True)
+        finally:
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+
+    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    summary_path = Path.cwd() / f"{args.summary_prefix}_{timestamp}.txt"
+    write_summary(summary_path, results, args.category_split_token)
+    print(f"Summary saved to: {summary_path}", flush=True)
+
+    if args.save_json:
+        raw_path = Path.cwd() / f"{args.summary_prefix}_{timestamp}.json"
+        payload = {
+            "benchmark": BENCHMARK_NAME,
+            "version": BENCHMARK_VERSION,
+            "pretrained_id": args.pretrained_id,
+            "llffhold": args.llffhold,
+            "scenes": results,
+        }
+        with raw_path.open("w", encoding="utf-8") as f:
+            json.dump(payload, f, indent=2)
+        print(f"Raw scene metrics saved to: {raw_path}", flush=True)
+
+    return results
+
+
+def main() -> None:
+    parser = build_argparser()
+    args = parser.parse_args()
+    run_feed_forward_nvs_benchmark(args)
+
+
+if __name__ == "__main__":
+    main()