feed_forward_benchmark_pose_co3d.py

"""
Feed-forward camera pose benchmark on CO3D (multi-backend) — reference implementation
======================================================================================

This script standardizes **relative pose error** evaluation on the **Common Objects
in 3D (CO3D)** test annotations, following the protocol in ``eval_pose_vggt.py``.

Supported backends (``--backends``)
-----------------------------------
- ``anysplat_baseline``: ``AnySplat.from_pretrained`` (feed-forward encoder + pose head path used in ``src.eval_pose.process_sequence``).
- ``vggt``: ``VGGT.from_pretrained`` with ``pose_enc`` decoded via ``pose_encoding_to_extri_intri``.
- ``anysplat_finetune``: optional; requires ``--finetune_ckpt``.

Sampling & reproducibility
--------------------------
- By default, each category builds a **fixed sampling plan**: ``num_frames`` indices per
  sequence, gated by ``min_num_images`` and max image size ``>= 448`` (same gates as the
  legacy script). The plan is written to ``<output>/co3d_sampling_plan.json``.
- Pass ``--sampling_plan_path`` to reuse a saved plan (recommended for paper numbers).

Metrics
-------
- Per-frame relative rotation / translation errors vs. GT extrinsics, then **AUC**
  curves at thresholds **5°, 10°, 20°, 30°** (``calculate_auc_np``), aggregated per
  category and mean over categories.

Pose alignment (``--pose_postprocess``)
---------------------------------------
- ``legacy``: align GT to the first camera only (AnySplat path flag ``gt_only``; VGGT ``gt_only``).
- ``align_both``: align **both** predictions and GT to the first camera before error.

Outputs
-------
- ``co3d_pose_metrics.json``, ``co3d_pose_summary.txt`` under ``--output_dir/<run_tag>/``.

Dependencies when vendoring
---------------------------
Requires CO3D images + ``*_test.jgz`` annotations, VGGT / AnySplat code paths under
``src.model``, ``src.utils.pose``, and ``src.eval_pose.process_sequence``.

``BENCHMARK_VERSION`` documents the protocol; bump when sampling, AUC definition, or
alignment semantics change.
"""

from __future__ import annotations

import os
import sys
import json
import gzip
import argparse
import datetime
import gc
from pathlib import Path
from typing import Any, Callable, Dict, List, Optional, Tuple

import numpy as np
from PIL import Image

import torch

sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from src.model.encoder.vggt.models.vggt import VGGT
from src.model.encoder.vggt.utils.pose_enc import pose_encoding_to_extri_intri
from src.model.encoder.vggt.utils.load_fn import load_and_preprocess_images
from src.model.model.anysplat import AnySplat
from src.utils.pose import (
    align_to_first_camera,
    calculate_auc_np,
    convert_pt3d_RT_to_opencv,
    se3_to_relative_pose_error,
)
from src.eval_pose import process_sequence as process_sequence_anysplat

BENCHMARK_VERSION = "1.0.0"
BENCHMARK_NAME = "feed_forward_pose_co3d_multi_backend"


def setup_args():
    parser = argparse.ArgumentParser(
        description=(
            f"{BENCHMARK_NAME} v{BENCHMARK_VERSION}: CO3D pose eval for feed-forward models "
            "(AnySplat baseline, VGGT, optional finetune; fixed frame ids via sampling plan; "
            "pose postprocess options)."
        )
    )
    parser.add_argument("--debug", action="store_true", help="Enable debug mode (only test on specific category)")
    parser.add_argument("--use_ba", action="store_true", default=False, help="Bundle adjustment (AnySplat backends only)")
    parser.add_argument("--fast_eval", action="store_true", default=False, help="Only evaluate 10 sequences per category")
    parser.add_argument("--min_num_images", type=int, default=50, help="Minimum number of images for a sequence")
    parser.add_argument("--num_frames", type=int, default=10, help="Number of frames to use for testing")
    parser.add_argument("--co3d_dir", type=str, required=True, help="Path to CO3D dataset")
    parser.add_argument("--co3d_anno_dir", type=str, required=True, help="Path to CO3D annotations")
    parser.add_argument(
        "--categories",
        type=str,
        default="auto",
        help='Comma-separated categories, or "auto" to detect from *_test.jgz',
    )
    parser.add_argument("--seed", type=int, default=0, help="Random seed for sampling (scan phase only)")
    parser.add_argument(
        "--vggt_repo_id",
        type=str,
        default="facebook/VGGT-1B",
        help='HuggingFace repo id for VGGT weights (default: "facebook/VGGT-1B")',
    )
    parser.add_argument(
        "--anysplat_pretrained_id",
        type=str,
        default="lhjiang/anysplat",
        help="HuggingFace id for baseline AnySplat",
    )
    parser.add_argument(
        "--finetune_ckpt",
        type=str,
        default=None,
        help="Finetuned weights: .ckpt, run dir with checkpoints/, or HF-style AnySplat folder.",
    )
    parser.add_argument(
        "--output_dir",
        type=str,
        default="output/exp_output2_bench_finetune_singlegpu_gt",
        help="Root directory for this evaluation run.",
    )
    parser.add_argument(
        "--run_tag",
        type=str,
        default=None,
        help='Subfolder under output_dir (default: timestamp "%%Y-%%m-%%d_%%H-%%M-%%S").',
    )
    parser.add_argument(
        "--sampling_plan_path",
        type=str,
        default=None,
        help="If set, load co3d_sampling_plan.json from this path and skip the scan phase (must match categories / annotations).",
    )
    parser.add_argument(
        "--pose_postprocess",
        type=str,
        choices=["legacy", "align_both"],
        default="legacy",
        help="legacy: align GT to first camera only (previous behavior). align_both: align pred and GT to first camera on all backends.",
    )
    parser.add_argument(
        "--backends",
        type=str,
        default="all",
        help='Which models to run, comma-separated: anysplat_baseline, vggt, anysplat_finetune. '
        'Use "all" to run baseline + VGGT and also anysplat_finetune when --finetune_ckpt is set.',
    )
    return parser.parse_args()


def parse_backends_selection(backends: str, finetune_ckpt: Optional[str]) -> List[str]:
    raw = backends.strip().lower()
    allowed = frozenset({"anysplat_baseline", "vggt", "anysplat_finetune"})
    if raw == "all":
        out = ["anysplat_baseline", "vggt"]
        if finetune_ckpt:
            out.append("anysplat_finetune")
        else:
            print("[info] --backends all: omitting anysplat_finetune (pass --finetune_ckpt to include it)")
        return out
    names = [x.strip().lower() for x in backends.split(",") if x.strip()]
    if not names:
        raise SystemExit("--backends is empty; use e.g. anysplat_finetune or all")
    seen = set()
    deduped: List[str] = []
    for n in names:
        if n in seen:
            continue
        seen.add(n)
        deduped.append(n)
    names = deduped
    for n in names:
        if n not in allowed:
            raise SystemExit(f"Unknown backend {n!r}. Allowed: {sorted(allowed)}")
    if "anysplat_finetune" in names and not finetune_ckpt:
        raise SystemExit("Including anysplat_finetune requires --finetune_ckpt")
    return names


def build_backends_for_eval(
    selected: List[str],
    args: argparse.Namespace,
    device: torch.device,
) -> List[Tuple[str, Callable[[], torch.nn.Module], str]]:
    """Return list of (name, loader, kind) in the same order as ``selected``."""
    out: List[Tuple[str, Callable[[], torch.nn.Module], str]] = []
    for name in selected:
        if name == "anysplat_baseline":
            hf = args.anysplat_pretrained_id
            out.append((name, lambda hf=hf: AnySplat.from_pretrained(hf), "anysplat"))
        elif name == "vggt":
            rid = args.vggt_repo_id
            out.append((name, lambda rid=rid: VGGT.from_pretrained(rid), "vggt"))
        elif name == "anysplat_finetune":
            ck = args.finetune_ckpt
            bid = args.anysplat_pretrained_id
            out.append((name, lambda ck=ck, bid=bid: load_finetune_anysplat(ck, device, bid), "anysplat"))
        else:
            raise RuntimeError(f"Unhandled backend: {name}")
    return out


def _anysplat_pose_align_flag(pose_postprocess: str) -> str:
    return "both" if pose_postprocess == "align_both" else "gt_only"


def _vggt_align_mode(pose_postprocess: str) -> str:
    return "both" if pose_postprocess == "align_both" else "gt_only"


def prepare_co3d_views(
    seq_data: list,
    co3d_dir: str,
    min_num_images: int,
    num_frames: int,
    rng: np.random.Generator,
) -> Optional[Dict[str, Any]]:
    """
    Same gate + RNG semantics as the original per-sequence eval:
    rng.choice is executed only after a valid metadata list is built; if max_size < 448 after that, returns None but RNG was already consumed.
    """
    if len(seq_data) < min_num_images:
        return None

    metadata = []
    for data in seq_data:
        if data["T"][0] + data["T"][1] + data["T"][2] > 1e5:
            return None
        extri_opencv = convert_pt3d_RT_to_opencv(data["R"], data["T"])
        metadata.append({"filepath": data["filepath"], "extri": extri_opencv})

    ids = rng.choice(len(metadata), num_frames, replace=False)
    frame_filepaths = [metadata[int(i)]["filepath"] for i in ids]
    image_names = [os.path.join(co3d_dir, fp) for fp in frame_filepaths]
    gt_extri = np.stack([np.array(metadata[int(i)]["extri"]) for i in ids], axis=0)

    max_size = max(Image.open(image_names[0]).size)
    if max_size < 448:
        return None

    return {
        "ids": ids.astype(np.int64),
        "frame_filepaths": frame_filepaths,
        "gt_extri": gt_extri,
    }


def plan_entry_to_json(entry: Dict[str, Any]) -> dict:
    return {
        "seq_name": entry["seq_name"],
        "ids": [int(x) for x in entry["ids"]],
        "frame_filepaths": list(entry["frame_filepaths"]),
        "gt_extri": np.asarray(entry["gt_extri"], dtype=np.float64).tolist(),
    }


def plan_entry_from_json(obj: dict, co3d_dir: str) -> Dict[str, Any]:
    ids = np.asarray(obj["ids"], dtype=np.int64)
    fps = list(obj["frame_filepaths"])
    image_names = [os.path.join(co3d_dir, fp) for fp in fps]
    gt_extri = np.asarray(obj["gt_extri"], dtype=np.float64)
    return {
        "seq_name": obj["seq_name"],
        "ids": ids,
        "frame_filepaths": fps,
        "image_names": image_names,
        "gt_extri": gt_extri,
    }


def build_sampling_plan(
    args: argparse.Namespace,
    categories: List[str],
) -> Dict[str, List[dict]]:
    rng = np.random.default_rng(args.seed)
    plan: Dict[str, List[dict]] = {c: [] for c in categories}

    for category in categories:
        annotation_file = os.path.join(args.co3d_anno_dir, f"{category}_test.jgz")
        try:
            with gzip.open(annotation_file, "r") as fin:
                annotation = json.loads(fin.read())
        except FileNotFoundError:
            print(f"Annotation file not found for {category}, skipping plan")
            continue

        n_success = 0
        for seq_name, seq_data in annotation.items():
            if args.debug and not os.path.exists(os.path.join(args.co3d_dir, category, seq_name)):
                continue

            prep = prepare_co3d_views(
                seq_data,
                args.co3d_dir,
                args.min_num_images,
                args.num_frames,
                rng,
            )
            if prep is None:
                continue

            entry = {"seq_name": seq_name, **prep}
            plan[category].append(plan_entry_to_json(entry))
            n_success += 1

            if args.fast_eval and n_success >= 10:
                break

    return plan


def save_sampling_plan(path: Path, plan: Dict[str, List[dict]], meta: dict) -> None:
    payload = {"version": 1, "meta": meta, "plan": plan}
    path.parent.mkdir(parents=True, exist_ok=True)
    with open(path, "w") as f:
        json.dump(payload, f, indent=2)
    print(f"Saved sampling plan to {path}")


def load_sampling_plan(path: Path, co3d_dir: str) -> Dict[str, List[Dict[str, Any]]]:
    with open(path, "r") as f:
        payload = json.load(f)
    raw_plan = payload.get("plan", payload)
    out: Dict[str, List[Dict[str, Any]]] = {}
    for cat, entries in raw_plan.items():
        out[cat] = [plan_entry_from_json(e, co3d_dir) for e in entries]
    print(f"Loaded sampling plan from {path} ({sum(len(v) for v in out.values())} entries)")
    return out


def _relative_pose_errors_from_extrinsics(
    pred_extrinsic: torch.Tensor,
    gt_extri_np: np.ndarray,
    num_frames: int,
    device: torch.device,
    align_mode: str,
) -> Tuple[np.ndarray, np.ndarray]:
    gt_extrinsic = torch.from_numpy(gt_extri_np).to(device)
    add_row = torch.tensor([0, 0, 0, 1], device=device).expand(pred_extrinsic.size(0), 1, 4)
    pred_se3 = torch.cat((pred_extrinsic, add_row), dim=1)
    gt_se3 = torch.cat((gt_extrinsic, add_row), dim=1)

    if align_mode == "gt_only":
        gt_se3 = align_to_first_camera(gt_se3)
    elif align_mode == "both":
        pred_se3 = align_to_first_camera(pred_se3)
        gt_se3 = align_to_first_camera(gt_se3)
    else:
        raise ValueError(f"Unknown align_mode: {align_mode}")

    rel_rangle_deg, rel_tangle_deg = se3_to_relative_pose_error(pred_se3, gt_se3, num_frames)
    return rel_rangle_deg.cpu().numpy(), rel_tangle_deg.cpu().numpy()


def infer_vggt_on_plan_entry(
    model,
    prepared: Dict[str, Any],
    category: str,
    seq_name: str,
    num_frames: int,
    device: torch.device,
    dtype: torch.dtype,
    align_mode: str,
) -> Tuple[np.ndarray, np.ndarray]:
    image_names = prepared["image_names"]
    gt_extri = prepared["gt_extri"]
    images = load_and_preprocess_images(image_names)[None].to(device)

    with torch.no_grad(), torch.cuda.amp.autocast(dtype=dtype):
        pred = model(images)
        pred_all_pose_enc = pred["pose_enc"]

    with torch.cuda.amp.autocast(dtype=torch.float32):
        pred_all_extrinsic, _ = pose_encoding_to_extri_intri(pred_all_pose_enc, images.shape[-2:])
        pred_extrinsic = pred_all_extrinsic[0]

    rel_r, rel_t = _relative_pose_errors_from_extrinsics(
        pred_extrinsic, gt_extri, num_frames, device, align_mode
    )
    print(f"{category} sequence {seq_name} Rot Error: {rel_r.mean():.4f}")
    print(f"{category} sequence {seq_name} Trans Error: {rel_t.mean():.4f}")
    return rel_r, rel_t


def _resolve_checkpoint_file(path: Path) -> Path:
    path = path.expanduser().resolve()
    if path.is_file():
        return path
    if path.is_dir():
        ckpt_dir = path / "checkpoints"
        if ckpt_dir.is_dir():
            ckpts = list(ckpt_dir.glob("*.ckpt"))
            if ckpts:
                ckpts.sort(key=lambda p: p.stat().st_mtime)
                return ckpts[-1]
        ckpts = sorted(path.glob("**/*.ckpt"), key=lambda p: p.stat().st_mtime)
        if ckpts:
            return ckpts[-1]
        if (path / "config.json").exists():
            return path
    raise FileNotFoundError(f"No checkpoint or AnySplat bundle found at: {path}")


def load_finetune_anysplat(ckpt: str, device: torch.device, base_hf_id: str = "lhjiang/anysplat") -> AnySplat:
    resolved = _resolve_checkpoint_file(Path(ckpt))
    if resolved.is_dir():
        model = AnySplat.from_pretrained(str(resolved))
        model.to(device)
        model.eval()
        for p in model.parameters():
            p.requires_grad = False
        return model

    model = AnySplat.from_pretrained(base_hf_id)
    try:
        blob = torch.load(resolved, map_location="cpu", weights_only=False)
    except TypeError:
        blob = torch.load(resolved, map_location="cpu")
    state = blob["state_dict"] if isinstance(blob, dict) and "state_dict" in blob else blob
    if not isinstance(state, dict):
        raise ValueError(f"Unexpected checkpoint format in {resolved}")

    stripped: Dict[str, Any] = {}
    for k, v in state.items():
        nk = k
        if nk.startswith("module."):
            nk = nk[len("module.") :]
        if nk.startswith("model."):
            nk = nk[len("model.") :]
        stripped[nk] = v

    model_keys = set(model.state_dict().keys())
    stripped_keys = set(stripped.keys())
    overlap = len(model_keys & stripped_keys)
    print(
        f"[finetune] ckpt keys={len(stripped)} overlap_with_AnySplat={overlap} / {len(model_keys)} "
        f"(resolved file: {resolved})"
    )

    missing, unexpected = model.load_state_dict(stripped, strict=False)
    print(f"[finetune] load_state_dict strict=False: missing={len(missing)}, unexpected={len(unexpected)}")
    if missing:
        print(f"[finetune] missing (first 8): {missing[:8]}")
    if unexpected:
        print(f"[finetune] unexpected (first 8): {unexpected[:8]}")
    if overlap < 50 or len(missing) > len(model_keys) * 0.25:
        print(
            "[finetune][warn] Few keys matched the Hub AnySplat — weights may be mostly baseline or load is wrong; "
            "pose metrics can be misleading."
        )
    model.to(device)
    model.eval()
    for p in model.parameters():
        p.requires_grad = False
    return model


def _finalize_category(r_error_list: List[float], t_error_list: List[float]) -> Optional[Dict[str, Any]]:
    if not r_error_list:
        return None
    r_error = np.array(r_error_list)
    t_error = np.array(t_error_list)
    thresholds = [5, 10, 20, 30]
    aucs = {}
    for th in thresholds:
        auc, _ = calculate_auc_np(r_error, t_error, max_threshold=th)
        aucs[th] = auc
    return {
        "rError": r_error,
        "tError": t_error,
        "Auc_5": aucs[5],
        "Auc_10": aucs[10],
        "Auc_20": aucs[20],
        "Auc_30": aucs[30],
    }


def _run_one_backend_on_plan(
    backend_name: str,
    model: torch.nn.Module,
    backend_kind: str,
    plan: Dict[str, List[Dict[str, Any]]],
    args: argparse.Namespace,
    categories: List[str],
    device: torch.device,
    dtype: torch.dtype,
    pose_align_anysplat: str,
    vggt_align_mode: str,
) -> Dict[str, Any]:
    per_category: Dict[str, Any] = {}
    _unused_rng = np.random.default_rng(0)

    for category in categories:
        entries = plan.get(category) or []
        if not entries:
            print(f"[{backend_name}] No cached entries for {category}, skipping")
            continue

        annotation_file = os.path.join(args.co3d_anno_dir, f"{category}_test.jgz")
        try:
            with gzip.open(annotation_file, "r") as fin:
                annotation = json.loads(fin.read())
        except FileNotFoundError:
            print(f"Annotation file not found for {category}, skipping")
            continue

        print(f"[{backend_name}] Evaluating {len(entries)} cached sequences for {category}")
        r_err: List[float] = []
        t_err: List[float] = []

        for prepared in entries:
            seq_name = prepared["seq_name"]
            print("-" * 50)
            print(f"[{backend_name}] {category} / {seq_name}")

            if args.debug and not os.path.exists(os.path.join(args.co3d_dir, category, seq_name)):
                print(f"Skipping {seq_name} (not found)")
                continue

            seq_data = annotation.get(seq_name)
            if seq_data is None:
                print(f"No annotation for {seq_name}, skipping")
                continue

            if backend_kind == "vggt":
                seq_r, seq_t = infer_vggt_on_plan_entry(
                    model,
                    prepared,
                    category,
                    seq_name,
                    args.num_frames,
                    device,
                    dtype,
                    vggt_align_mode,
                )
            elif backend_kind == "anysplat":
                seq_r, seq_t = process_sequence_anysplat(
                    model,
                    seq_name,
                    seq_data,
                    category,
                    args.co3d_dir,
                    args.min_num_images,
                    args.num_frames,
                    args.use_ba,
                    device,
                    dtype,
                    _unused_rng,
                    frame_ids=prepared["ids"],
                    pose_align=pose_align_anysplat,
                )
            else:
                raise ValueError(f"Unknown backend_kind: {backend_kind}")

            print("-" * 50)
            if seq_r is not None and seq_t is not None:
                r_err.extend(np.asarray(seq_r).reshape(-1).tolist())
                t_err.extend(np.asarray(seq_t).reshape(-1).tolist())

        fin = _finalize_category(r_err, t_err)
        if fin is None:
            print(f"No valid results for {category} ({backend_name}), skipping")
            continue

        print("=" * 80)
        print(f"[{backend_name}] AUC of {category} test set: {fin['Auc_30']:.4f}")
        print("=" * 80)
        per_category[category] = fin

    return per_category


def _print_and_collect_means(per_category: Dict[str, Any]) -> Dict[str, float]:
    means = {}
    if not per_category:
        return means
    for key in ["Auc_5", "Auc_10", "Auc_20", "Auc_30"]:
        means[key] = float(np.mean([per_category[c][key] for c in per_category]))
    print("\nSummary of AUC results:")
    print("-" * 50)
    for category in sorted(per_category.keys()):
        print(f"{category:<15} AUC_5: {per_category[category]['Auc_5']:.4f}")
        print(f"{category:<15} AUC_30: {per_category[category]['Auc_30']:.4f}")
        print(f"{category:<15} AUC_20: {per_category[category]['Auc_20']:.4f}")
        print(f"{category:<15} AUC_10: {per_category[category]['Auc_10']:.4f}")
    print("-" * 50)
    print(f"Mean AUC_5: {means['Auc_5']:.4f}")
    print(f"Mean AUC_30: {means['Auc_30']:.4f}")
    print(f"Mean AUC_20: {means['Auc_20']:.4f}")
    print(f"Mean AUC_10: {means['Auc_10']:.4f}")
    return means


def _save_results(
    out_root: Path,
    args: argparse.Namespace,
    all_backends: Dict[str, Dict[str, Any]],
    all_means: Dict[str, Dict[str, float]],
):
    out_root.mkdir(parents=True, exist_ok=True)

    serializable = {}
    for bname, per_cat in all_backends.items():
        serializable[bname] = {}
        for cat, d in per_cat.items():
            serializable[bname][cat] = {
                "Auc_5": float(d["Auc_5"]),
                "Auc_10": float(d["Auc_10"]),
                "Auc_20": float(d["Auc_20"]),
                "Auc_30": float(d["Auc_30"]),
            }

    payload = {
        "benchmark": BENCHMARK_NAME,
        "version": BENCHMARK_VERSION,
        "args": vars(args),
        "per_category_auc": serializable,
        "mean_auc": {k: v for k, v in all_means.items()},
    }
    with open(out_root / "co3d_pose_metrics.json", "w") as f:
        json.dump(payload, f, indent=2)

    lines = [
        f"CO3D pose evaluation — {BENCHMARK_NAME} v{BENCHMARK_VERSION} (AnySplat / VGGT / finetune)",
        "=" * 60,
        json.dumps(vars(args), indent=2),
        "",
    ]
    for bname in sorted(all_backends.keys()):
        lines.append(f"### {bname}")
        lines.append("-" * 40)
        pc = all_backends[bname]
        for cat in sorted(pc.keys()):
            lines.append(
                f"{cat:<15} AUC_5/10/20/30: {pc[cat]['Auc_5']:.4f} / {pc[cat]['Auc_10']:.4f} / "
                f"{pc[cat]['Auc_20']:.4f} / {pc[cat]['Auc_30']:.4f}"
            )
        if bname in all_means and all_means[bname]:
            m = all_means[bname]
            lines.append(
                f"MEAN            AUC_5/10/20/30: {m['Auc_5']:.4f} / {m['Auc_10']:.4f} / "
                f"{m['Auc_20']:.4f} / {m['Auc_30']:.4f}"
            )
        lines.append("")

    with open(out_root / "co3d_pose_summary.txt", "w") as f:
        f.write("\n".join(lines))

    print(f"Wrote {out_root / 'co3d_pose_metrics.json'} and {out_root / 'co3d_pose_summary.txt'}")


def run_feed_forward_co3d_pose_benchmark(args: argparse.Namespace) -> None:
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    dtype = torch.bfloat16

    if args.categories.strip().lower() == "auto":
        anno_dir = Path(args.co3d_anno_dir)
        categories = sorted(p.name[:-9] for p in anno_dir.glob("*_test.jgz") if p.name.endswith("_test.jgz"))
    else:
        categories = [c.strip() for c in args.categories.split(",") if c.strip()]

    if not categories:
        raise RuntimeError(f"No categories found to evaluate in {args.co3d_anno_dir}")

    if args.debug:
        categories = categories[:1]
        print(f"Debug mode on, only evaluating category: {categories[0]}")

    tag = args.run_tag or datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
    out_root = Path(args.output_dir).expanduser().resolve() / tag
    out_root.mkdir(parents=True, exist_ok=True)
    print(f"Results directory: {out_root}")

    pose_align_anysplat = _anysplat_pose_align_flag(args.pose_postprocess)
    vggt_align = _vggt_align_mode(args.pose_postprocess)

    if args.sampling_plan_path:
        plan_path = Path(args.sampling_plan_path).expanduser().resolve()
        hydrated_full = load_sampling_plan(plan_path, args.co3d_dir)
        hydrated = {c: hydrated_full.get(c, []) for c in categories}
        unknown = [c for c in categories if c not in hydrated_full]
        if unknown:
            print(f"[warn] No entries in loaded plan for categories (empty lists): {unknown}")
    else:
        raw_plan = build_sampling_plan(args, categories)
        plan_serializable = {cat: list(raw_plan.get(cat, [])) for cat in categories}
        meta = {
            "benchmark": BENCHMARK_NAME,
            "version": BENCHMARK_VERSION,
            "seed": args.seed,
            "co3d_dir": os.path.abspath(args.co3d_dir),
            "co3d_anno_dir": os.path.abspath(args.co3d_anno_dir),
            "num_frames": args.num_frames,
            "min_num_images": args.min_num_images,
            "fast_eval": args.fast_eval,
            "categories": categories,
        }
        save_sampling_plan(out_root / "co3d_sampling_plan.json", plan_serializable, meta)
        hydrated = {cat: [plan_entry_from_json(e, args.co3d_dir) for e in plan_serializable[cat]] for cat in categories}

    total_entries = sum(len(hydrated.get(c, [])) for c in categories)
    if total_entries == 0:
        raise RuntimeError("Sampling plan is empty — no valid sequences. Check CO3D paths and filters.")

    selected = parse_backends_selection(args.backends, args.finetune_ckpt)
    print(f"Backends to evaluate (in order): {selected}")
    backends = build_backends_for_eval(selected, args, device)

    all_backends: Dict[str, Dict[str, Any]] = {}
    all_means: Dict[str, Dict[str, float]] = {}

    for backend_name, loader, kind in backends:
        print("\n" + "#" * 80)
        print(f"Loading backend: {backend_name}")
        print("#" * 80)
        model = loader()
        model.to(device)
        model.eval()
        for p in model.parameters():
            p.requires_grad = False

        per_cat = _run_one_backend_on_plan(
            backend_name,
            model,
            kind,
            hydrated,
            args,
            categories,
            device,
            dtype,
            pose_align_anysplat,
            vggt_align,
        )
        all_backends[backend_name] = per_cat
        all_means[backend_name] = _print_and_collect_means(per_cat)

        del model
        gc.collect()
        if torch.cuda.is_available():
            torch.cuda.empty_cache()

    _save_results(out_root, args, all_backends, all_means)


def main() -> None:
    args = setup_args()
    run_feed_forward_co3d_pose_benchmark(args)


# Backward-compatible name for callers that imported ``evaluate`` from ``eval_pose_vggt``.
evaluate = run_feed_forward_co3d_pose_benchmark


if __name__ == "__main__":
    main()