Blame for debug/debug_pusht_rollout.py

#!/usr/bin/env python3
"""Measure PushT latent rollout drift under ground-truth action replay.

The script freezes a trained HyperbolicJEPA checkpoint, samples real PushT
trajectory windows, and compares autoregressive latent predictions against
encoded future frames. Teacher-forced one-step errors are reported alongside
autoregressive errors to separate local model error from compounding drift.
"""

from __future__ import annotations

import argparse
import csv
import json
import sys
from pathlib import Path
from types import SimpleNamespace
from typing import Any

import h5py
import numpy as np
import torch
import torch.nn.functional as F

ROOT_DIR = Path(__file__).resolve().parents[1]
if str(ROOT_DIR) not in sys.path:
    sys.path.insert(0, str(ROOT_DIR))

import stable_worldmodel as swm
from omegaconf import OmegaConf

from eval_hyperbolic import _load_hyperbolic_policy_model
from utils import resolve_runtime_device


IMAGENET_MEAN = torch.tensor([0.485, 0.456, 0.406], dtype=torch.float32).view(1, 3, 1, 1)
IMAGENET_STD = torch.tensor([0.229, 0.224, 0.225], dtype=torch.float32).view(1, 3, 1, 1)


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--policy", required=True, help="Hyperbolic checkpoint prefix or file.")
    parser.add_argument(
        "--dataset",
        default="pusht/pusht_expert_train",
        help="PushT H5 path or stable-worldmodel cache-relative dataset name.",
    )
    parser.add_argument("--cache-dir", default="", help="Override the stable-worldmodel cache directory.")
    parser.add_argument("--output-dir", default="", help="Output directory below cache when relative.")
    parser.add_argument("--device", default="auto", help="Runtime device: auto, cuda, npu, or cpu.")
    parser.add_argument("--num-sequences", type=int, default=512)
    parser.add_argument("--context-blocks", type=int, default=3)
    parser.add_argument("--max-blocks", type=int, default=5)
    parser.add_argument("--frameskip", type=int, default=5)
    parser.add_argument("--encode-batch-size", type=int, default=128)
    parser.add_argument("--seed", type=int, default=42)
    return parser.parse_args()


def resolve_cache_dir(cache_dir: str) -> Path:
    return Path(cache_dir).expanduser() if cache_dir else Path(swm.data.utils.get_cache_dir())


def resolve_h5_path(dataset_name: str, cache_dir: Path) -> Path:
    raw = Path(dataset_name).expanduser()
    candidates = [raw]
    if not raw.is_absolute():
        candidates.extend([cache_dir / raw, cache_dir / "pusht" / raw])

    expanded = []
    for candidate in candidates:
        expanded.append(candidate)
        if candidate.suffix.lower() != ".h5":
            expanded.append(Path(f"{candidate}.h5"))

    seen = set()
    for candidate in expanded:
        candidate = candidate.resolve()
        if candidate in seen:
            continue
        seen.add(candidate)
        if candidate.is_file():
            return candidate
    tried = ", ".join(str(path) for path in expanded)
    raise FileNotFoundError(f"Could not resolve PushT H5 dataset. Tried: {tried}")


def resolve_output_dir(args: argparse.Namespace, cache_dir: Path) -> Path:
    if args.output_dir:
        output_dir = Path(args.output_dir).expanduser()
        return output_dir if output_dir.is_absolute() else cache_dir / output_dir
    policy_stem = Path(str(args.policy).rstrip("/")).stem
    return cache_dir / "debug" / "pusht_rollout" / policy_stem


def preprocess_pixels(pixels: np.ndarray, *, image_size: int, device: str) -> torch.Tensor:
    tensor = torch.as_tensor(pixels)
    if tensor.ndim != 4:
        raise ValueError(f"Expected pixels with four dimensions, got shape={tuple(tensor.shape)}.")
    if tensor.shape[-1] in {1, 3, 4}:
        tensor = tensor.permute(0, 3, 1, 2)
    elif tensor.shape[1] not in {1, 3, 4}:
        raise ValueError(f"Could not infer pixel channel axis from shape={tuple(tensor.shape)}.")
    if tensor.shape[1] == 4:
        tensor = tensor[:, :3]
    if tensor.shape[1] == 1:
        tensor = tensor.expand(-1, 3, -1, -1)

    tensor = tensor.to(device=device, dtype=torch.float32)
    if pixels.dtype == np.uint8 or float(tensor.detach().amax().cpu()) > 1.5:
        tensor = tensor / 255.0
    if tuple(tensor.shape[-2:]) != (image_size, image_size):
        tensor = F.interpolate(
            tensor,
            size=(image_size, image_size),
            mode="bilinear",
            align_corners=False,
            antialias=True,
        )
    return (tensor - IMAGENET_MEAN.to(device)) / IMAGENET_STD.to(device)


def load_metadata(h5_file: h5py.File) -> tuple[np.ndarray, np.ndarray]:
    episode_key = "episode_idx" if "episode_idx" in h5_file else "ep_idx"
    if episode_key not in h5_file:
        raise KeyError("Dataset must contain episode_idx or ep_idx.")
    episode_idx = np.asarray(h5_file[episode_key], dtype=np.int64).reshape(-1)

    if "step_idx" in h5_file:
        step_idx = np.asarray(h5_file["step_idx"], dtype=np.int64).reshape(-1)
    else:
        step_idx = np.empty(len(episode_idx), dtype=np.int64)
        for episode_id in np.unique(episode_idx):
            rows = np.flatnonzero(episode_idx == episode_id)
            step_idx[rows] = np.arange(len(rows), dtype=np.int64)
    return episode_idx, step_idx


def build_episode_rows(episode_idx: np.ndarray, step_idx: np.ndarray) -> list[np.ndarray]:
    episodes = []
    for episode_id in np.unique(episode_idx):
        rows = np.flatnonzero(episode_idx == episode_id)
        rows = rows[np.argsort(step_idx[rows])]
        if len(rows) > 1 and not np.all(np.diff(step_idx[rows]) == 1):
            print(f"[debug-pusht] skipping episode={int(episode_id)} with non-contiguous step_idx", flush=True)
            continue
        episodes.append(rows)
    return episodes


def sample_windows(
    episodes: list[np.ndarray],
    *,
    count: int,
    required_raw_steps: int,
    rng: np.random.Generator,
) -> np.ndarray:
    eligible = [rows for rows in episodes if len(rows) >= required_raw_steps]
    if not eligible:
        raise ValueError(
            f"No episode contains the required {required_raw_steps} raw steps."
        )
    valid_counts = np.asarray([len(rows) - required_raw_steps + 1 for rows in eligible], dtype=np.int64)
    cumulative = np.cumsum(valid_counts)
    total = int(cumulative[-1])
    if count > total:
        print(
            f"[debug-pusht] requested {count} windows but only {total} are available; using all.",
            flush=True,
        )
        sampled = np.arange(total, dtype=np.int64)
    else:
        sampled = rng.choice(total, size=count, replace=False)

    window_rows = []
    for flat_index in sampled.tolist():
        episode_pos = int(np.searchsorted(cumulative, flat_index, side="right"))
        previous = int(cumulative[episode_pos - 1]) if episode_pos > 0 else 0
        start = int(flat_index - previous)
        window_rows.append(eligible[episode_pos][start : start + required_raw_steps])
    return np.stack(window_rows)


def normalize_and_chunk_actions(
    raw_actions: np.ndarray,
    window_rows: np.ndarray,
    *,
    num_blocks: int,
    frameskip: int,
) -> tuple[torch.Tensor, dict[str, Any]]:
    actions = torch.from_numpy(np.asarray(raw_actions, dtype=np.float32).reshape(len(raw_actions), -1))
    valid_actions = actions[~torch.isnan(actions).any(dim=1)]
    action_mean = valid_actions.mean(dim=0, keepdim=True)
    action_std = valid_actions.std(dim=0, keepdim=True).clamp_min(1e-6)
    actions = torch.nan_to_num((actions - action_mean) / action_std, 0.0)

    block_rows = []
    for block_index in range(num_blocks):
        start = block_index * frameskip
        block_rows.append(window_rows[:, start : start + frameskip])
    block_rows = np.stack(block_rows, axis=1)
    chunks = actions[torch.from_numpy(block_rows)].reshape(len(window_rows), num_blocks, -1)
    stats = {
        "raw_action_dim": int(actions.shape[-1]),
        "chunked_action_dim": int(chunks.shape[-1]),
        "action_mean": action_mean.squeeze(0).tolist(),
        "action_std": action_std.squeeze(0).tolist(),
    }
    return chunks, stats


def image_size_from_model(model) -> int:
    value = getattr(model.encoder.config, "image_size", 224)
    return int(value[0] if isinstance(value, (list, tuple)) else value)


@torch.inference_mode()
def encode_rows(
    model,
    h5_file: h5py.File,
    rows: np.ndarray,
    *,
    image_size: int,
    batch_size: int,
    device: str,
) -> dict[str, torch.Tensor]:
    unique_rows = np.unique(rows.reshape(-1))
    encoded_chunks: dict[str, list[torch.Tensor]] = {
        "emb": [],
        "hyp_tangent": [],
        "hyp_emb": [],
    }
    for start in range(0, len(unique_rows), batch_size):
        end = min(start + batch_size, len(unique_rows))
        selected_rows = unique_rows[start:end]
        pixels = np.asarray(h5_file["pixels"][selected_rows])
        pixel_tensor = preprocess_pixels(pixels, image_size=image_size, device=device)
        encoded = model.encode({"pixels": pixel_tensor.unsqueeze(1)})
        for key in encoded_chunks:
            encoded_chunks[key].append(encoded[key][:, 0].float().cpu())
        print(f"[debug-pusht] encoded rows {end}/{len(unique_rows)}", end="\r", flush=True)
    print("", flush=True)

    positions = np.searchsorted(unique_rows, rows)
    positions = torch.from_numpy(positions)
    return {
        key: torch.cat(chunks, dim=0)[positions]
        for key, chunks in encoded_chunks.items()
    }


def summarize(values: torch.Tensor) -> dict[str, float]:
    values = values.detach().float().cpu()
    return {
        "mean": float(values.mean()),
        "std": float(values.std(unbiased=False)),
        "median": float(values.median()),
        "p90": float(torch.quantile(values, 0.90)),
    }


def metric_row(
    *,
    block: int,
    frameskip: int,
    mode: str,
    euclidean_mse: torch.Tensor,
    tangent_mse: torch.Tensor,
    lorentz_dist: torch.Tensor,
    predicted_euclidean_norm: torch.Tensor,
    target_euclidean_norm: torch.Tensor,
    predicted_tangent_norm: torch.Tensor,
    target_tangent_norm: torch.Tensor,
) -> dict[str, Any]:
    return {
        "block": int(block),
        "raw_action_steps": int(block * frameskip),
        "mode": mode,
        "euclidean_mse": summarize(euclidean_mse),
        "tangent_mse": summarize(tangent_mse),
        "lorentz_dist": summarize(lorentz_dist),
        "predicted_euclidean_norm": summarize(predicted_euclidean_norm),
        "target_euclidean_norm": summarize(target_euclidean_norm),
        "predicted_tangent_norm": summarize(predicted_tangent_norm),
        "target_tangent_norm": summarize(target_tangent_norm),
    }


def flatten_summary_row(row: dict[str, Any], *, frameskip: int) -> dict[str, Any]:
    flattened = {
        "block": row["block"],
        "raw_action_steps": int(row["block"]) * int(frameskip),
        "mode": row["mode"],
    }
    for metric_name, stats in row.items():
        if not isinstance(stats, dict):
            continue
        for stat_name, value in stats.items():
            flattened[f"{metric_name}_{stat_name}"] = value
    return flattened


@torch.inference_mode()
def measure_rollout_drift(
    model,
    true_latents: dict[str, torch.Tensor],
    action_chunks: torch.Tensor,
    *,
    context_blocks: int,
    max_blocks: int,
    frameskip: int,
    device: str,
) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
    true_emb = true_latents["emb"].to(device)
    true_tangent = true_latents["hyp_tangent"].to(device)
    true_hyp = true_latents["hyp_emb"].to(device)
    action_chunks = action_chunks.to(device)
    action_embeddings = model.action_encoder(action_chunks)

    autoregressive_context = true_emb[:, :context_blocks].clone()
    summary_rows = []
    sequence_rows = []

    for step_index in range(max_blocks):
        block = step_index + 1
        act_context = action_embeddings[:, step_index : step_index + context_blocks]
        target_index = context_blocks + step_index
        target_emb = true_emb[:, target_index]
        target_tangent = true_tangent[:, target_index]
        target_hyp = true_hyp[:, target_index]

        autoregressive_pred = model.predict(
            autoregressive_context[:, -context_blocks:],
            act_context,
        )[:, -1]
        autoregressive_context = torch.cat(
            [autoregressive_context, autoregressive_pred.unsqueeze(1)],
            dim=1,
        )

        teacher_context = true_emb[:, step_index : step_index + context_blocks]
        teacher_pred = model.predict(teacher_context, act_context)[:, -1]

        for mode, predicted_emb in (
            ("autoregressive", autoregressive_pred),
            ("teacher_forced", teacher_pred),
        ):
            predicted_tangent, predicted_hyp = model.to_hyperbolic(predicted_emb.unsqueeze(1))
            predicted_tangent = predicted_tangent[:, 0]
            predicted_hyp = predicted_hyp[:, 0]
            euclidean_mse = (predicted_emb - target_emb).square().mean(dim=-1)
            tangent_mse = (predicted_tangent - target_tangent).square().mean(dim=-1)
            lorentz_dist = model.manifold.dist(predicted_hyp, target_hyp)
            predicted_euclidean_norm = predicted_emb.norm(dim=-1)
            target_euclidean_norm = target_emb.norm(dim=-1)
            predicted_tangent_norm = predicted_tangent.norm(dim=-1)
            target_tangent_norm = target_tangent.norm(dim=-1)
            summary_rows.append(
                metric_row(
                    block=block,
                    frameskip=frameskip,
                    mode=mode,
                    euclidean_mse=euclidean_mse,
                    tangent_mse=tangent_mse,
                    lorentz_dist=lorentz_dist,
                    predicted_euclidean_norm=predicted_euclidean_norm,
                    target_euclidean_norm=target_euclidean_norm,
                    predicted_tangent_norm=predicted_tangent_norm,
                    target_tangent_norm=target_tangent_norm,
                )
            )
            for sequence_index in range(len(euclidean_mse)):
                sequence_rows.append(
                    {
                        "sequence": int(sequence_index),
                        "block": int(block),
                        "raw_action_steps": int(block * frameskip),
                        "mode": mode,
                        "euclidean_mse": float(euclidean_mse[sequence_index]),
                        "tangent_mse": float(tangent_mse[sequence_index]),
                        "lorentz_dist": float(lorentz_dist[sequence_index]),
                        "predicted_euclidean_norm": float(predicted_euclidean_norm[sequence_index]),
                        "target_euclidean_norm": float(target_euclidean_norm[sequence_index]),
                        "predicted_tangent_norm": float(predicted_tangent_norm[sequence_index]),
                        "target_tangent_norm": float(target_tangent_norm[sequence_index]),
                    }
                )
    return summary_rows, sequence_rows


def write_csv(path: Path, rows: list[dict[str, Any]]) -> None:
    if not rows:
        return
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0]))
        writer.writeheader()
        writer.writerows(rows)


def save_plot(path: Path, summary_rows: list[dict[str, Any]], *, frameskip: int) -> None:
    import matplotlib

    matplotlib.use("Agg")
    import matplotlib.pyplot as plt

    metrics = (
        ("euclidean_mse", "Euclidean latent MSE"),
        ("tangent_mse", "Tangent latent MSE"),
        ("lorentz_dist", "Lorentz distance"),
    )
    colors = {
        "autoregressive": "#d1495b",
        "teacher_forced": "#00798c",
    }
    fig, axes = plt.subplots(1, 3, figsize=(13.2, 4.1), constrained_layout=True)
    for axis, (metric_key, title) in zip(axes, metrics):
        for mode in ("autoregressive", "teacher_forced"):
            selected = [row for row in summary_rows if row["mode"] == mode]
            x = [int(row["block"]) * int(frameskip) for row in selected]
            y = [row[metric_key]["mean"] for row in selected]
            yerr = [row[metric_key]["std"] for row in selected]
            axis.plot(x, y, marker="o", linewidth=2, color=colors[mode], label=mode.replace("_", " "))
            axis.fill_between(
                x,
                np.asarray(y) - np.asarray(yerr),
                np.asarray(y) + np.asarray(yerr),
                color=colors[mode],
                alpha=0.14,
            )
        axis.set_title(title)
        axis.set_xlabel("oracle action replay steps")
        axis.grid(alpha=0.25)
    axes[0].set_ylabel("error")
    axes[-1].legend(frameon=False)
    fig.savefig(path, dpi=180)
    plt.close(fig)


def json_ready(value: Any) -> Any:
    if isinstance(value, dict):
        return {str(key): json_ready(item) for key, item in value.items()}
    if isinstance(value, (list, tuple)):
        return [json_ready(item) for item in value]
    if isinstance(value, np.ndarray):
        return value.tolist()
    if isinstance(value, np.generic):
        return value.item()
    return value


def load_model(
    *,
    policy: str,
    cache_dir: Path,
    action_dim: int,
    device: str,
):
    cfg = OmegaConf.create(
        {
            "cache_dir": str(cache_dir),
            "policy": policy,
            "checkpoint": {
                "force_rebuild": True,
                "strict": True,
            },
        }
    )
    dataset_stub = SimpleNamespace(get_dim=lambda key: action_dim)
    return _load_hyperbolic_policy_model(cfg, dataset_stub, device)


def main() -> None:
    args = parse_args()
    if args.context_blocks < 1 or args.max_blocks < 1 or args.frameskip < 1:
        raise ValueError("context-blocks, max-blocks, and frameskip must be positive.")
    cache_dir = resolve_cache_dir(args.cache_dir)
    h5_path = resolve_h5_path(args.dataset, cache_dir)
    output_dir = resolve_output_dir(args, cache_dir)
    output_dir.mkdir(parents=True, exist_ok=True)
    runtime_device = resolve_runtime_device(args.device)
    rng = np.random.default_rng(args.seed)

    print(f"[debug-pusht] device={runtime_device}", flush=True)
    print(f"[debug-pusht] dataset={h5_path}", flush=True)
    print(f"[debug-pusht] policy={args.policy}", flush=True)

    with h5py.File(h5_path, "r") as h5_file:
        if "pixels" not in h5_file or "action" not in h5_file:
            raise KeyError("Dataset must contain pixels and action.")
        episode_idx, step_idx = load_metadata(h5_file)
        episodes = build_episode_rows(episode_idx, step_idx)
        raw_actions = np.asarray(h5_file["action"], dtype=np.float32)
        action_dim = int(raw_actions.reshape(len(raw_actions), -1).shape[-1])

        model = load_model(
            policy=args.policy,
            cache_dir=cache_dir,
            action_dim=action_dim,
            device=runtime_device,
        )
        image_size = image_size_from_model(model)
        required_raw_steps = (args.context_blocks + args.max_blocks - 1) * args.frameskip + 1
        window_rows = sample_windows(
            episodes,
            count=args.num_sequences,
            required_raw_steps=required_raw_steps,
            rng=rng,
        )
        observation_rows = window_rows[
            :,
            np.arange(args.context_blocks + args.max_blocks) * args.frameskip,
        ]
        true_latents = encode_rows(
            model,
            h5_file,
            observation_rows,
            image_size=image_size,
            batch_size=args.encode_batch_size,
            device=runtime_device,
        )

    action_chunks, action_stats = normalize_and_chunk_actions(
        raw_actions,
        window_rows,
        num_blocks=args.context_blocks + args.max_blocks - 1,
        frameskip=args.frameskip,
    )
    expected_action_dim = int(model.action_encoder.patch_embed.in_channels)
    if int(action_chunks.shape[-1]) != expected_action_dim:
        raise ValueError(
            f"Chunked action dim={int(action_chunks.shape[-1])}, but model expects "
            f"{expected_action_dim}. Check --frameskip and the dataset action protocol."
        )

    summary_rows, sequence_rows = measure_rollout_drift(
        model,
        true_latents,
        action_chunks,
        context_blocks=args.context_blocks,
        max_blocks=args.max_blocks,
        frameskip=args.frameskip,
        device=runtime_device,
    )
    flattened_summary = [
        flatten_summary_row(row, frameskip=args.frameskip)
        for row in summary_rows
    ]
    summary = {
        "policy": args.policy,
        "dataset": str(h5_path),
        "device": runtime_device,
        "num_sequences": int(len(window_rows)),
        "context_blocks": int(args.context_blocks),
        "max_blocks": int(args.max_blocks),
        "frameskip": int(args.frameskip),
        "raw_steps_per_max_rollout": int(args.max_blocks * args.frameskip),
        "required_raw_steps_per_window": int(required_raw_steps),
        "image_size": int(image_size),
        "action": action_stats,
        "sampled_start_rows": window_rows[:, 0].tolist(),
        "metrics": summary_rows,
    }

    summary_path = output_dir / "rollout_drift_summary.json"
    summary_csv_path = output_dir / "rollout_drift_summary.csv"
    sequence_csv_path = output_dir / "rollout_drift_per_sequence.csv"
    plot_path = output_dir / "rollout_drift.png"
    summary_path.write_text(json.dumps(json_ready(summary), indent=2), encoding="utf-8")
    write_csv(summary_csv_path, flattened_summary)
    write_csv(sequence_csv_path, sequence_rows)
    save_plot(plot_path, summary_rows, frameskip=args.frameskip)

    print(f"[debug-pusht] wrote {summary_path}", flush=True)
    print(f"[debug-pusht] wrote {summary_csv_path}", flush=True)
    print(f"[debug-pusht] wrote {sequence_csv_path}", flush=True)
    print(f"[debug-pusht] wrote {plot_path}", flush=True)
    for row in flattened_summary:
        print(
            f"[debug-pusht] mode={row['mode']:<14} block={row['block']} "
            f"raw_steps={row['raw_action_steps']:>2} "
            f"euc_mse={row['euclidean_mse_mean']:.6f} "
            f"tan_mse={row['tangent_mse_mean']:.6f} "
            f"lorentz={row['lorentz_dist_mean']:.6f}",
            flush=True,
        )


if __name__ == "__main__":
    main()