Upload 7 files

debug/README.md

@@ -0,0 +1,50 @@
+# Debug Tools
+
+## Puzzle Eval-Stack Oracle Replay
+
+The previous root-level `debug_puzzle.py` now lives in this directory. Run it
+from the repository root:
+
+```bash
+MUJOCO_GL=egl python debug/debug_puzzle.py --config-name=puzzle
+```
+
+## PushT Multi-Step Latent Rollout Drift
+
+`debug_pusht_rollout.py` freezes a trained HyperbolicJEPA checkpoint and replays
+ground-truth PushT actions from the offline dataset. It compares each predicted
+latent against the encoded real future frame for blocks `1...5`.
+
+The script writes:
+
+- `rollout_drift.png`: Euclidean, tangent-space, and Lorentz error curves.
+- `rollout_drift_summary.json`: run metadata and aggregated metrics.
+- `rollout_drift_summary.csv`: aggregated metrics for plotting or tables.
+- `rollout_drift_per_sequence.csv`: per-window metrics for deeper analysis.
+
+Each curve contains two modes:
+
+- `autoregressive`: append each predicted latent and continue rollout.
+- `teacher_forced`: restart each one-step prediction from real encoded frames.
+
+Interpretation:
+
+- Low teacher-forced error with rapidly rising autoregressive error indicates
+  compounding rollout drift.
+- High error from block 1 indicates a one-step dynamics or action-protocol
+  issue.
+- Similar low curves with poor planning SR point toward candidate sampling or
+  goal-cost alignment instead of dynamics quality.
+
+Example:
+
+```bash
+MUJOCO_GL=egl python debug/debug_pusht_rollout.py \
+  --policy /data_nvme/user/zliu681/le-wm-main/lewm_cache/pusht/hyperbolic_pusht/lewm_hyperbolic_pusht_epoch_10 \
+  --dataset pusht/pusht_expert_train \
+  --device auto \
+  --num-sequences 512 \
+  --context-blocks 3 \
+  --max-blocks 5 \
+  --frameskip 5
+```

debug/__init__.py

@@ -0,0 +1 @@
+"""Standalone diagnostic tools for LeWM experiments."""

debug/debug_pusht_rollout.py

@@ -0,0 +1,589 @@
+#!/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()

debug/debug_puzzle.py

@@ -0,0 +1,414 @@
+#!/usr/bin/env python3
+"""Eval-stack oracle replay for OGBench Puzzle.
+
+This script runs the same stable_worldmodel.World evaluation stack used by
+eval_puzzle.py, including dataset goal construction, static goal-info
+injection, callables, video writing, and success accounting. The only
+difference is the policy: instead of a world model planner, it replays the
+ground-truth dataset action at each environment step.
+"""
+
+from __future__ import annotations
+
+import faulthandler
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+os.environ.setdefault("MUJOCO_GL", "egl")
+
+ROOT_DIR = Path(__file__).resolve().parents[1]
+if str(ROOT_DIR) not in sys.path:
+    sys.path.insert(0, str(ROOT_DIR))
+
+import hydra
+import numpy as np
+import stable_worldmodel as swm
+import torch
+from omegaconf import DictConfig, ListConfig, OmegaConf, open_dict
+
+from eval import (
+    _resolve_safe_row_limit,
+    _resolve_world_env_name,
+    evaluate_from_dataset_with_progress,
+    get_dataset,
+    get_episodes_length,
+)
+
+
+class DatasetActionReplayPolicy:
+    """Policy that returns preloaded dataset actions one eval step at a time."""
+
+    def __init__(self, actions: np.ndarray):
+        actions = np.asarray(actions, dtype=np.float32)
+        if actions.ndim != 3:
+            raise ValueError(f"actions must have shape (num_envs, steps, action_dim), got {actions.shape}")
+        self.actions = actions
+        self.step_idx = 0
+
+    def reset(self) -> None:
+        self.step_idx = 0
+
+    def get_action(self, infos: dict[str, Any]):
+        action_idx = min(self.step_idx, self.actions.shape[1] - 1)
+        actions = self.actions[:, action_idx]
+        self.step_idx += 1
+        return actions
+
+
+def _to_numpy(value: Any) -> np.ndarray:
+    if torch.is_tensor(value):
+        return value.detach().cpu().numpy()
+    return np.asarray(value)
+
+
+def _jsonify(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {str(k): _jsonify(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_jsonify(v) for v in value]
+    if isinstance(value, np.ndarray):
+        return value.tolist()
+    if isinstance(value, np.generic):
+        return value.item()
+    if torch.is_tensor(value):
+        return value.detach().cpu().tolist()
+    return value
+
+
+def _debug_node(cfg: DictConfig):
+    node = cfg.get("debug", {})
+    return {} if node is None else node
+
+
+def _debug_get(cfg: DictConfig, key: str, default: Any) -> Any:
+    node = _debug_node(cfg)
+    if isinstance(node, DictConfig):
+        return node.get(key, default)
+    if isinstance(node, dict):
+        return node.get(key, default)
+    return default
+
+
+def _parse_row_indices(value: Any) -> list[int]:
+    if value is None:
+        return []
+    if isinstance(value, (list, tuple, ListConfig)):
+        return [int(v) for v in value]
+
+    text = str(value).strip()
+    if not text:
+        return []
+    if text.startswith("[") and text.endswith("]"):
+        text = text[1:-1]
+    return [int(part.strip()) for part in text.split(",") if part.strip()]
+
+
+def _as_bool(value: Any, default: bool) -> bool:
+    if value is None:
+        return default
+    if isinstance(value, bool):
+        return value
+    text = str(value).strip().lower()
+    if text in {"1", "true", "yes", "y", "on"}:
+        return True
+    if text in {"0", "false", "no", "n", "off"}:
+        return False
+    return default
+
+
+def _dataset_columns(dataset) -> tuple[str, np.ndarray, np.ndarray]:
+    ep_key = "episode_idx" if "episode_idx" in dataset.column_names else "ep_idx"
+    episode_idx = _to_numpy(dataset.get_col_data(ep_key)).reshape(-1)
+    step_idx = _to_numpy(dataset.get_col_data("step_idx")).reshape(-1)
+    if len(episode_idx) != len(step_idx):
+        raise ValueError(f"len({ep_key})={len(episode_idx)} but len(step_idx)={len(step_idx)}")
+    return ep_key, episode_idx, step_idx
+
+
+def _select_rows(dataset, cfg: DictConfig) -> tuple[np.ndarray, np.ndarray, np.ndarray, dict[str, Any]]:
+    ep_key, episode_idx_col, step_idx_col = _dataset_columns(dataset)
+    safe_row_limit, row_counts = _resolve_safe_row_limit(dataset, [ep_key, "step_idx"])
+    episode_idx_col = episode_idx_col[:safe_row_limit]
+    step_idx_col = step_idx_col[:safe_row_limit]
+
+    ep_indices, _ = np.unique(episode_idx_col, return_index=True)
+    episode_len = get_episodes_length(dataset, ep_indices)
+    max_start_idx_dict = {
+        int(ep_id): int(episode_len[i] - int(cfg.eval.goal_offset_steps) - 1)
+        for i, ep_id in enumerate(ep_indices)
+    }
+
+    require_budget_actions = _as_bool(_debug_get(cfg, "require_eval_budget_actions", True), True)
+    if require_budget_actions:
+        budget_max_start = {
+            int(ep_id): int(episode_len[i] - int(cfg.eval.eval_budget) - 1)
+            for i, ep_id in enumerate(ep_indices)
+        }
+        max_start_idx_dict = {
+            ep_id: min(max_start_idx_dict[ep_id], budget_max_start[ep_id])
+            for ep_id in max_start_idx_dict
+        }
+
+    max_start_per_row = np.array(
+        [max_start_idx_dict.get(int(ep_id), -1) for ep_id in episode_idx_col],
+        dtype=np.int64,
+    )
+    valid_mask = step_idx_col <= max_start_per_row
+    valid_indices = np.nonzero(valid_mask)[0].astype(np.int64)
+
+    explicit_rows = _parse_row_indices(_debug_get(cfg, "start_indices", ""))
+    preferred_candidate_groups: list[np.ndarray] | None = None
+    if explicit_rows:
+        candidate_indices = np.asarray(explicit_rows, dtype=np.int64)
+        bad = candidate_indices[(candidate_indices < 0) | (candidate_indices >= safe_row_limit)]
+        if len(bad):
+            raise ValueError(f"Explicit debug.start_indices outside dataset bounds: {bad.tolist()}")
+        not_valid = candidate_indices[~valid_mask[candidate_indices]]
+        if len(not_valid):
+            raise ValueError(
+                "Explicit debug.start_indices do not have enough future context "
+                f"(goal_offset/eval_budget): {not_valid.tolist()}"
+            )
+        num_eval = len(candidate_indices)
+    else:
+        num_eval = int(cfg.eval.num_eval)
+        candidate_indices = valid_indices
+
+        prefer_button_change = _as_bool(_debug_get(cfg, "prefer_button_change", True), True)
+        button_key = str(_debug_get(cfg, "button_key", "button_states"))
+        if prefer_button_change and button_key in dataset.column_names:
+            buttons = _to_numpy(dataset.get_col_data(button_key))[:safe_row_limit]
+            buttons = buttons.reshape(buttons.shape[0], -1)
+            goal_rows = candidate_indices + int(cfg.eval.goal_offset_steps)
+            in_bounds = goal_rows < len(buttons)
+            candidate_indices = candidate_indices[in_bounds]
+            goal_rows = goal_rows[in_bounds]
+            changed_mask = np.any(buttons[goal_rows] != buttons[candidate_indices], axis=1)
+            changed = candidate_indices[changed_mask]
+            unchanged = candidate_indices[~changed_mask]
+            candidate_indices = np.concatenate([changed, unchanged])
+            if len(changed):
+                preferred_candidate_groups = [changed, unchanged]
+
+    if len(candidate_indices) < num_eval:
+        raise ValueError(f"Not enough valid oracle starts: requested {num_eval}, found {len(candidate_indices)}")
+
+    rng = np.random.default_rng(int(cfg.seed))
+    if explicit_rows:
+        ordered_candidates = candidate_indices
+    elif preferred_candidate_groups is not None:
+        ordered_candidates = np.concatenate(
+            [rng.permutation(group) for group in preferred_candidate_groups if len(group)]
+        )
+    else:
+        ordered_candidates = rng.permutation(candidate_indices)
+
+    selected_rows = ordered_candidates[:num_eval].astype(np.int64, copy=False)
+    eval_episodes = episode_idx_col[selected_rows].astype(np.int64)
+    eval_start_idx = step_idx_col[selected_rows].astype(np.int64)
+
+    info = {
+        "safe_row_limit": int(safe_row_limit),
+        "row_counts": {str(k): int(v) for k, v in row_counts.items()},
+        "valid_start_count": int(len(valid_indices)),
+        "explicit_start_indices": [int(v) for v in explicit_rows],
+        "require_eval_budget_actions": bool(require_budget_actions),
+    }
+    return selected_rows, eval_episodes, eval_start_idx, info
+
+
+def _resolve_action_row(
+    episode_idx_col: np.ndarray,
+    step_idx_col: np.ndarray,
+    ep_id: int,
+    step: int,
+    expected_row: int,
+    lookup: dict[tuple[int, int], int] | None,
+) -> tuple[int, dict[tuple[int, int], int] | None]:
+    if (
+        0 <= expected_row < len(episode_idx_col)
+        and int(episode_idx_col[expected_row]) == ep_id
+        and int(step_idx_col[expected_row]) == step
+    ):
+        return int(expected_row), lookup
+
+    if lookup is None:
+        lookup = {}
+        for row, (row_ep, row_step) in enumerate(zip(episode_idx_col, step_idx_col)):
+            lookup.setdefault((int(row_ep), int(row_step)), int(row))
+
+    key = (int(ep_id), int(step))
+    if key not in lookup:
+        raise KeyError(f"Could not find dataset row for episode={ep_id}, step={step}")
+    return int(lookup[key]), lookup
+
+
+def _build_oracle_actions(
+    dataset,
+    selected_rows: np.ndarray,
+    eval_episodes: np.ndarray,
+    eval_start_idx: np.ndarray,
+    eval_budget: int,
+    action_key: str,
+) -> tuple[np.ndarray, np.ndarray]:
+    _, episode_idx_col, step_idx_col = _dataset_columns(dataset)
+    actions_col = _to_numpy(dataset.get_col_data(action_key))
+    if actions_col.ndim == 1:
+        actions_col = actions_col.reshape(-1, 1)
+
+    action_dim = int(actions_col.shape[-1])
+    actions = np.empty((len(selected_rows), eval_budget, action_dim), dtype=np.float32)
+    action_rows = np.empty((len(selected_rows), eval_budget), dtype=np.int64)
+
+    lookup = None
+    for env_idx, row in enumerate(selected_rows.tolist()):
+        ep_id = int(eval_episodes[env_idx])
+        start_step = int(eval_start_idx[env_idx])
+        for t in range(eval_budget):
+            action_row, lookup = _resolve_action_row(
+                episode_idx_col=episode_idx_col,
+                step_idx_col=step_idx_col,
+                ep_id=ep_id,
+                step=start_step + t,
+                expected_row=int(row) + t,
+                lookup=lookup,
+            )
+            actions[env_idx, t] = actions_col[action_row].astype(np.float32, copy=False)
+            action_rows[env_idx, t] = action_row
+
+    return actions, action_rows
+
+
+def _button_summary(dataset, selected_rows: np.ndarray, cfg: DictConfig) -> dict[str, Any]:
+    button_key = str(_debug_get(cfg, "button_key", "button_states"))
+    if button_key not in dataset.column_names:
+        return {"has_button_states": False}
+
+    buttons = _to_numpy(dataset.get_col_data(button_key))
+    buttons = buttons.reshape(buttons.shape[0], -1)
+    goal_rows = selected_rows + int(cfg.eval.goal_offset_steps)
+    valid = goal_rows < len(buttons)
+    if not np.all(valid):
+        goal_rows = goal_rows[valid]
+        selected_rows = selected_rows[valid]
+    start_buttons = buttons[selected_rows]
+    goal_buttons = buttons[goal_rows]
+    changed = np.any(start_buttons != goal_buttons, axis=1)
+    return {
+        "has_button_states": True,
+        "button_key": button_key,
+        "button_changed_to_goal_count": int(np.count_nonzero(changed)),
+        "button_changed_to_goal_fraction": float(np.mean(changed)) if len(changed) else 0.0,
+        "button_start": start_buttons.tolist(),
+        "button_goal": goal_buttons.tolist(),
+    }
+
+
+def _default_out_dir(cfg: DictConfig) -> Path:
+    debug_out = _debug_get(cfg, "out_dir", "")
+    if debug_out:
+        return Path(os.path.expandvars(str(debug_out))).expanduser()
+    cache_dir = Path(str(cfg.get("cache_dir", "") or swm.data.utils.get_cache_dir()))
+    return cache_dir / "debug_puzzle_eval_stack"
+
+
+@hydra.main(version_base=None, config_path="../config/eval", config_name="puzzle")
+def main(cfg: DictConfig):
+    faulthandler.enable(all_threads=True)
+
+    with open_dict(cfg):
+        if "cache_dir" not in cfg:
+            cfg.cache_dir = ""
+        cfg.world.env_name = _resolve_world_env_name(str(cfg.world.env_name))
+        cfg.world.max_episode_steps = 2 * int(cfg.eval.eval_budget)
+
+    dataset = get_dataset(cfg, cfg.eval.dataset_name)
+    selected_rows, eval_episodes, eval_start_idx, selection_info = _select_rows(dataset, cfg)
+
+    with open_dict(cfg):
+        cfg.eval.num_eval = int(len(selected_rows))
+        cfg.world.num_envs = int(len(selected_rows))
+
+    action_key = str(_debug_get(cfg, "action_key", "action"))
+    if action_key not in dataset.column_names:
+        raise KeyError(f"Action key '{action_key}' not found. Available columns: {dataset.column_names}")
+    oracle_actions, action_rows = _build_oracle_actions(
+        dataset=dataset,
+        selected_rows=selected_rows,
+        eval_episodes=eval_episodes,
+        eval_start_idx=eval_start_idx,
+        eval_budget=int(cfg.eval.eval_budget),
+        action_key=action_key,
+    )
+
+    world_image_shape = (
+        int(cfg.world.get("height", cfg.eval.img_size)),
+        int(cfg.world.get("width", cfg.eval.img_size)),
+    )
+    world = swm.World(**cfg.world, image_shape=world_image_shape)
+    policy = DatasetActionReplayPolicy(oracle_actions)
+    world.set_policy(policy)
+
+    out_dir = _default_out_dir(cfg)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    print(f"[debug-puzzle] mode=eval-stack-oracle", flush=True)
+    print(f"[debug-puzzle] dataset={cfg.eval.dataset_name}", flush=True)
+    print(f"[debug-puzzle] env={cfg.world.env_name}", flush=True)
+    print(f"[debug-puzzle] selected_rows={selected_rows.tolist()}", flush=True)
+    print(f"[debug-puzzle] episodes={eval_episodes.tolist()}", flush=True)
+    print(f"[debug-puzzle] start_steps={eval_start_idx.tolist()}", flush=True)
+    print(f"[debug-puzzle] oracle_actions_shape={list(oracle_actions.shape)}", flush=True)
+
+    policy.reset()
+    metrics = evaluate_from_dataset_with_progress(
+        world=world,
+        dataset=dataset,
+        episodes_idx=eval_episodes.tolist(),
+        start_steps=eval_start_idx.tolist(),
+        goal_offset_steps=int(cfg.eval.goal_offset_steps),
+        eval_budget=int(cfg.eval.eval_budget),
+        callables=OmegaConf.to_container(cfg.eval.get("callables"), resolve=True),
+        save_video=bool(cfg.eval.get("save_video", True)),
+        video_path=out_dir,
+    )
+
+    summary = {
+        "mode": "eval-stack-oracle",
+        "dataset_name": str(cfg.eval.dataset_name),
+        "env_name": str(cfg.world.env_name),
+        "num_eval": int(len(selected_rows)),
+        "goal_offset_steps": int(cfg.eval.goal_offset_steps),
+        "eval_budget": int(cfg.eval.eval_budget),
+        "selected_rows": selected_rows.tolist(),
+        "episodes": eval_episodes.tolist(),
+        "start_steps": eval_start_idx.tolist(),
+        "selection": selection_info,
+        "oracle_policy": {
+            "action_key": action_key,
+            "actions_shape": list(oracle_actions.shape),
+            "steps_consumed": int(policy.step_idx),
+            "first_action_rows": action_rows[:, : min(5, action_rows.shape[1])].tolist(),
+            "last_action_rows": action_rows[:, max(0, action_rows.shape[1] - 5) :].tolist(),
+        },
+        "button_summary": _button_summary(dataset, selected_rows, cfg),
+        "metrics": _jsonify(metrics),
+        "video_dir": str(out_dir),
+    }
+
+    summary_path = out_dir / "eval_stack_oracle_summary.json"
+    summary_path.write_text(json.dumps(summary, indent=2))
+
+    print("[debug-puzzle] metrics:", json.dumps(_jsonify(metrics), indent=2), flush=True)
+    print(f"[debug-puzzle] wrote {summary_path}", flush=True)
+
+    close_fn = getattr(world.envs, "close", None)
+    if callable(close_fn):
+        close_fn()
+
+
+if __name__ == "__main__":
+    main()

debug/extract_rollout_figure_frames.py

@@ -0,0 +1,288 @@
+#!/usr/bin/env python3
+"""Extract context and prediction panels from a four-grid rollout mp4.
+
+The eval videos produced by eval.py/eval_hyperbolic.py use this layout:
+
+    top-left:     model-controlled rollout frame
+    bottom-left:  dataset/reference real trajectory frame
+    top-right:    goal frame
+    bottom-right: goal frame
+
+This script crops the left panels and saves them with explicit context vs.
+open-loop-prediction names so paper figures do not mix the two groups.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+
+def parse_steps(value: str) -> list[int]:
+    steps = []
+    for item in str(value).split(","):
+        item = item.strip()
+        if not item:
+            continue
+        steps.append(int(item))
+    if not steps:
+        raise argparse.ArgumentTypeError("Expected at least one comma-separated step.")
+    return steps
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--video", required=True, type=Path, help="Path to rollout_*.mp4.")
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=None,
+        help="Default: <video_parent>/<video_stem>_figure_frames",
+    )
+    parser.add_argument("--context-steps", type=parse_steps, default=parse_steps("0,5,10"))
+    parser.add_argument(
+        "--prediction-steps",
+        type=parse_steps,
+        default=parse_steps("15,20,25,30,35"),
+    )
+    parser.add_argument(
+        "--imagined-label",
+        default="imagined",
+        help="Name used for the model rollout row. Use 'rollout' if you want stricter wording.",
+    )
+    parser.add_argument(
+        "--save-composite",
+        action=argparse.BooleanOptionalAction,
+        default=False,
+        help="Also save a paper-style composite grid.",
+    )
+    parser.add_argument("--composite-name", default="context_vs_prediction_grid.png")
+    parser.add_argument("--dpi", type=int, default=220)
+    return parser.parse_args()
+
+
+def read_frame(reader, index: int) -> np.ndarray:
+    import numpy as np
+
+    try:
+        frame = reader.get_data(index)
+    except IndexError as exc:
+        raise IndexError(f"Video does not contain frame index {index}.") from exc
+    frame = np.asarray(frame)
+    if frame.ndim != 3 or frame.shape[-1] < 3:
+        raise ValueError(f"Unexpected video frame shape at index {index}: {frame.shape}")
+    return frame[..., :3].astype(np.uint8, copy=False)
+
+
+def crop_left_panels(frame: np.ndarray) -> dict[str, np.ndarray]:
+    height, width = frame.shape[:2]
+    if height < 2 or width < 2:
+        raise ValueError(f"Frame is too small to crop: {frame.shape}")
+    mid_h = height // 2
+    mid_w = width // 2
+    return {
+        "rollout": frame[:mid_h, :mid_w],
+        "real": frame[mid_h : 2 * mid_h, :mid_w],
+    }
+
+
+def save_png(path: Path, frame: np.ndarray) -> None:
+    from PIL import Image
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    Image.fromarray(frame).save(path)
+
+
+def extract_frames(args: argparse.Namespace) -> tuple[Path, dict]:
+    video_path = args.video.expanduser().resolve()
+    if not video_path.is_file():
+        raise FileNotFoundError(f"Video not found: {video_path}")
+
+    output_dir = (
+        args.output_dir.expanduser().resolve()
+        if args.output_dir is not None
+        else video_path.parent / f"{video_path.stem}_figure_frames"
+    )
+    context_dir = output_dir / "context_input"
+    prediction_dir = output_dir / "open_loop_prediction"
+
+    manifest = {
+        "video": str(video_path),
+        "layout": {
+            "source": "four-grid eval mp4",
+            "real_panel": "bottom-left",
+            "imagined_panel": "top-left",
+        },
+        "context_steps": list(args.context_steps),
+        "prediction_steps": list(args.prediction_steps),
+        "frames": [],
+    }
+
+    import imageio
+
+    reader = imageio.get_reader(video_path)
+    try:
+        groups = [
+            ("context_input", context_dir, args.context_steps),
+            ("open_loop_prediction", prediction_dir, args.prediction_steps),
+        ]
+        for group_name, group_dir, steps in groups:
+            for local_index, step in enumerate(steps, start=1):
+                frame = read_frame(reader, int(step))
+                panels = crop_left_panels(frame)
+                entries = [
+                    ("real", panels["real"]),
+                    (str(args.imagined_label), panels["rollout"]),
+                ]
+                for row_name, panel in entries:
+                    filename = f"{group_name}_{local_index:02d}_{row_name}_t{int(step):03d}.png"
+                    out_path = group_dir / row_name / filename
+                    save_png(out_path, panel)
+                    manifest["frames"].append(
+                        {
+                            "group": group_name,
+                            "index": int(local_index),
+                            "row": row_name,
+                            "step": int(step),
+                            "path": str(out_path),
+                        }
+                    )
+    finally:
+        reader.close()
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    with (output_dir / "manifest.json").open("w") as handle:
+        json.dump(manifest, handle, indent=2)
+
+    return output_dir, manifest
+
+
+def _load_manifest_image(frame_entry: dict) -> np.ndarray:
+    import numpy as np
+    from PIL import Image
+
+    return np.asarray(Image.open(frame_entry["path"]).convert("RGB"))
+
+
+def save_composite(output_dir: Path, manifest: dict, composite_name: str, dpi: int) -> Path:
+    import matplotlib.pyplot as plt
+
+    context_steps = list(manifest["context_steps"])
+    prediction_steps = list(manifest["prediction_steps"])
+    all_steps = context_steps + prediction_steps
+    n_context = len(context_steps)
+    n_prediction = len(prediction_steps)
+    n_total = len(all_steps)
+    gap_units = 0.45
+
+    by_key = {
+        (entry["group"], entry["row"], int(entry["index"])): entry
+        for entry in manifest["frames"]
+    }
+    imagined_rows = sorted(
+        {
+            entry["row"]
+            for entry in manifest["frames"]
+            if entry["row"] != "real"
+        }
+    )
+    imagined_row = imagined_rows[0] if imagined_rows else "imagined"
+
+    sample = _load_manifest_image(manifest["frames"][0])
+    aspect = sample.shape[1] / sample.shape[0]
+    tile_h = 1.0
+    tile_w = aspect
+    fig_w = max(8.0, n_total * 1.35 * aspect + 2.2)
+    fig_h = 3.8
+
+    fig = plt.figure(figsize=(fig_w, fig_h))
+    left_margin = 0.10
+    right_margin = 0.02
+    top_margin = 0.20
+    bottom_margin = 0.18
+    row_gap = 0.055
+    available_w = 1.0 - left_margin - right_margin
+    available_h = 1.0 - top_margin - bottom_margin
+    unit_w = available_w / (n_total + gap_units)
+    axis_w = unit_w
+    axis_h = (available_h - row_gap) / 2.0
+
+    def x_for_column(column: int) -> float:
+        extra_gap = gap_units if column >= n_context else 0.0
+        return left_margin + (column + extra_gap) * unit_w
+
+    row_y = {
+        "real": bottom_margin + axis_h + row_gap,
+        imagined_row: bottom_margin,
+    }
+
+    context_entries = [("context_input", i + 1, step) for i, step in enumerate(context_steps)]
+    prediction_entries = [
+        ("open_loop_prediction", i + 1, step)
+        for i, step in enumerate(prediction_steps)
+    ]
+    column_entries = context_entries + prediction_entries
+
+    for col, (group_name, local_index, step) in enumerate(column_entries):
+        for row_name in ("real", imagined_row):
+            entry = by_key[(group_name, row_name, local_index)]
+            ax = fig.add_axes([x_for_column(col), row_y[row_name], axis_w, axis_h])
+            ax.imshow(_load_manifest_image(entry))
+            ax.set_xticks([])
+            ax.set_yticks([])
+            for spine in ax.spines.values():
+                spine.set_linewidth(1.2)
+                spine.set_color("black")
+            if row_name == imagined_row:
+                label = f"T = {step}" if col == 0 else f"{step}"
+                ax.set_xlabel(label, fontsize=15, labelpad=6)
+
+    context_center = (
+        x_for_column(0) + x_for_column(n_context - 1) + axis_w
+    ) / 2.0
+    prediction_center = (
+        x_for_column(n_context) + x_for_column(n_total - 1) + axis_w
+    ) / 2.0
+    fig.text(context_center, 0.95, "Context Input", ha="center", va="top", fontsize=19)
+    fig.text(
+        prediction_center,
+        0.95,
+        "Open Loop Prediction",
+        ha="center",
+        va="top",
+        fontsize=19,
+    )
+    fig.text(0.045, row_y["real"] + axis_h / 2, "Real", rotation=90, ha="center", va="center", fontsize=17)
+    fig.text(
+        0.045,
+        row_y[imagined_row] + axis_h / 2,
+        imagined_row.capitalize(),
+        rotation=90,
+        ha="center",
+        va="center",
+        fontsize=17,
+    )
+
+    composite_path = output_dir / composite_name
+    fig.savefig(composite_path, dpi=dpi, bbox_inches="tight", pad_inches=0.06)
+    plt.close(fig)
+    return composite_path
+
+
+def main() -> None:
+    args = parse_args()
+    output_dir, manifest = extract_frames(args)
+    print(f"[extract] wrote frames to {output_dir}", flush=True)
+    if args.save_composite:
+        composite_path = save_composite(
+            output_dir,
+            manifest,
+            args.composite_name,
+            int(args.dpi),
+        )
+        print(f"[extract] wrote composite figure to {composite_path}", flush=True)
+
+
+if __name__ == "__main__":
+    main()

debug/visualize_pusht_poincare_hierarchy.py

@@ -0,0 +1,933 @@
+#!/usr/bin/env python
+"""Visualize PushT progress hierarchy in the Poincare ball.
+
+Example:
+    python debug/visualize_pusht_poincare_hierarchy.py \
+      --policy /data_nvme/user/zliu681/le-wm-main/lewm_cache/pusht/hyperbolic_pusht_stable_trial2/lewm_hyperbolic_pusht_stable_epoch_10_state.ckpt \
+      --num-trajectories 8 \
+      --window 80
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import h5py
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import torch.nn.functional as F
+from omegaconf import OmegaConf, open_dict
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+
+import stable_worldmodel as swm  # noqa: E402
+from train_hyperbolic import (  # noqa: E402
+    build_hyperbolic_world_model,
+    ensure_hyperbolic_defaults,
+)
+from utils import get_img_preprocessor  # noqa: E402
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Draw goal-conditioned PushT Poincare progress hierarchy.",
+    )
+    parser.add_argument(
+        "--policy",
+        required=True,
+        help="Path to a hyperbolic *_state.ckpt, *_weights.ckpt, *_object.ckpt, or run directory.",
+    )
+    parser.add_argument(
+        "--config",
+        default=None,
+        help="Optional config.yaml path. By default, use config.yaml beside the checkpoint.",
+    )
+    parser.add_argument(
+        "--dataset",
+        default=None,
+        help="Optional h5 dataset path. By default, resolve cfg.data.dataset.name under lewm_cache.",
+    )
+    parser.add_argument("--pixel-key", default="pixels")
+    parser.add_argument("--num-trajectories", type=int, default=8)
+    parser.add_argument(
+        "--candidate-episodes",
+        type=int,
+        default=48,
+        help="Number of episodes to scan before selecting representative windows.",
+    )
+    parser.add_argument(
+        "--windows-per-episode",
+        type=int,
+        default=4,
+        help="Only used with --window-mode scan.",
+    )
+    parser.add_argument("--window", type=int, default=80)
+    parser.add_argument("--stride", type=int, default=2)
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument(
+        "--window-mode",
+        choices=("scan", "tail", "random"),
+        default="scan",
+        help=(
+            "scan searches several subwindows per episode; tail uses the final window; "
+            "random samples one window inside each episode."
+        ),
+    )
+    parser.add_argument(
+        "--selection",
+        choices=("radius_corr", "radius_gain", "random"),
+        default="radius_corr",
+        help="How to select final displayed windows from candidates.",
+    )
+    parser.add_argument(
+        "--projection",
+        choices=("goal_aligned", "global_goal_pca"),
+        default="goal_aligned",
+        help=(
+            "goal_aligned maps each hindsight goal to +x independently; "
+            "global_goal_pca uses the first goal direction and one global orthogonal PCA axis."
+        ),
+    )
+    parser.add_argument("--device", default="auto")
+    parser.add_argument(
+        "--output-dir",
+        default=None,
+        help="Default: lewm_cache/debug/pusht_poincare_hierarchy/<checkpoint_stem>",
+    )
+    parser.add_argument("--dpi", type=int, default=220)
+    parser.add_argument("--plot-3d", action="store_true")
+    return parser.parse_args()
+
+
+def resolve_device(device: str) -> torch.device:
+    if device == "auto":
+        return torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    return torch.device(device)
+
+
+def resolve_policy_path(policy: str) -> Path:
+    path = Path(policy)
+    if path.is_dir():
+        candidates = sorted(path.glob("*_state.ckpt"))
+        candidates += sorted(path.glob("*_weights.ckpt"))
+        candidates += sorted(path.glob("*.ckpt"))
+        if not candidates:
+            raise FileNotFoundError(f"No checkpoint found under policy directory: {path}")
+        return candidates[-1]
+
+    if path.name.endswith("_object.ckpt"):
+        state_path = path.with_name(path.name.replace("_object.ckpt", "_state.ckpt"))
+        if state_path.exists():
+            return state_path
+        weights_path = path.with_name(path.name.replace("_object.ckpt", "_weights.ckpt"))
+        if weights_path.exists():
+            return weights_path
+
+    return path
+
+
+def resolve_config_path(policy_path: Path, config_arg: str | None) -> Path:
+    if config_arg is not None:
+        config_path = Path(config_arg)
+    else:
+        config_path = policy_path.parent / "config.yaml"
+    if not config_path.exists():
+        raise FileNotFoundError(
+            f"Could not find config.yaml at {config_path}. Pass --config explicitly."
+        )
+    return config_path
+
+
+def resolve_dataset_path(cfg, dataset_arg: str | None) -> Path:
+    if dataset_arg:
+        dataset_path = Path(dataset_arg)
+        if dataset_path.exists():
+            return dataset_path
+        raise FileNotFoundError(f"Dataset path does not exist: {dataset_path}")
+
+    dataset_name = str(cfg.data.dataset.name).replace("\\", "/")
+    cache_dir = Path(swm.data.utils.get_cache_dir())
+    candidates = [
+        cache_dir / f"{dataset_name}.h5",
+        cache_dir / dataset_name,
+    ]
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    raise FileNotFoundError(
+        "Could not resolve dataset from cfg.data.dataset.name="
+        f"{dataset_name!r}. Tried: {', '.join(str(c) for c in candidates)}"
+    )
+
+
+def resolve_output_dir(policy_path: Path, output_dir: str | None) -> Path:
+    if output_dir:
+        return Path(output_dir)
+    cache_dir = Path(swm.data.utils.get_cache_dir())
+    return cache_dir / "debug" / "pusht_poincare_hierarchy" / policy_path.stem
+
+
+def infer_action_dim(h5_file: h5py.File) -> int:
+    if "action" not in h5_file:
+        raise KeyError("Expected action key in dataset to infer action_dim.")
+    action_shape = h5_file["action"].shape
+    if len(action_shape) < 2:
+        raise ValueError(f"Unexpected action shape: {action_shape}")
+    return int(action_shape[-1])
+
+
+def load_model(policy_path: Path, cfg, action_dim: int, device: torch.device):
+    ensure_hyperbolic_defaults(cfg)
+    with open_dict(cfg):
+        cfg.wm.action_dim = int(action_dim)
+
+    model = build_hyperbolic_world_model(cfg, action_dim=int(action_dim))
+    checkpoint = torch.load(policy_path, map_location="cpu", weights_only=False)
+
+    if hasattr(checkpoint, "state_dict"):
+        state = checkpoint.state_dict()
+    elif isinstance(checkpoint, dict) and "model_state_dict" in checkpoint:
+        state = checkpoint["model_state_dict"]
+    elif isinstance(checkpoint, dict) and "state_dict" in checkpoint:
+        state = checkpoint["state_dict"]
+    elif isinstance(checkpoint, dict) and all(torch.is_tensor(v) for v in checkpoint.values()):
+        state = checkpoint
+    else:
+        raise TypeError(
+            "Unsupported checkpoint format. Prefer a portable *_state.ckpt checkpoint."
+        )
+
+    stripped = {}
+    for key, value in state.items():
+        if key.startswith("model."):
+            stripped[key[len("model.") :]] = value
+        else:
+            stripped[key] = value
+
+    missing, unexpected = model.load_state_dict(stripped, strict=False)
+    print(
+        f"[poincare] loaded {policy_path} | "
+        f"missing={len(missing)} unexpected={len(unexpected)}",
+        flush=True,
+    )
+    if missing:
+        print(f"[poincare] first missing keys: {missing[:8]}", flush=True)
+    if unexpected:
+        print(f"[poincare] first unexpected keys: {unexpected[:8]}", flush=True)
+
+    return model.to(device).eval()
+
+
+def dataset_length(h5_file: h5py.File, pixel_key: str) -> int:
+    if pixel_key in h5_file:
+        return int(h5_file[pixel_key].shape[0])
+    for key in h5_file.keys():
+        value = h5_file[key]
+        if isinstance(value, h5py.Dataset) and len(value.shape) > 0:
+            return int(value.shape[0])
+    raise ValueError("Could not infer dataset length.")
+
+
+def episode_bounds(h5_file: h5py.File, pixel_key: str) -> list[tuple[int, int]]:
+    total = dataset_length(h5_file, pixel_key)
+
+    if "ep_offset" in h5_file and "ep_len" in h5_file:
+        starts = np.asarray(h5_file["ep_offset"][:], dtype=np.int64).reshape(-1)
+        lengths = np.asarray(h5_file["ep_len"][:], dtype=np.int64).reshape(-1)
+        if starts.shape == lengths.shape:
+            ends = starts + lengths
+            bounds = [
+                (int(start), int(end))
+                for start, end in zip(starts, ends)
+                if 0 <= int(start) < int(end) <= total
+            ]
+            if bounds:
+                return bounds
+
+    for key in ("episode_ends", "episode_end", "ends"):
+        if key in h5_file:
+            ends = np.asarray(h5_file[key][:], dtype=np.int64)
+            starts = np.concatenate([[0], ends[:-1]])
+            return [(int(s), int(e)) for s, e in zip(starts, ends) if int(e) > int(s)]
+
+    if "episode_idx" in h5_file:
+        episode_idx = np.asarray(h5_file["episode_idx"][:], dtype=np.int64).reshape(-1)
+        if episode_idx.shape[0] == total:
+            change_points = np.flatnonzero(episode_idx[1:] != episode_idx[:-1]) + 1
+            ends = np.concatenate([change_points, [total]]).astype(np.int64)
+            starts = np.concatenate([[0], ends[:-1]])
+            bounds = [
+                (int(start), int(end))
+                for start, end in zip(starts, ends)
+                if int(end) > int(start)
+            ]
+            if bounds:
+                return bounds
+
+    if "step_idx" in h5_file:
+        step_idx = np.asarray(h5_file["step_idx"][:], dtype=np.int64).reshape(-1)
+        if step_idx.shape[0] == total:
+            starts = np.flatnonzero(step_idx == 0).astype(np.int64)
+            if starts.size:
+                ends = np.concatenate([starts[1:], [total]]).astype(np.int64)
+                bounds = [
+                    (int(start), int(end))
+                    for start, end in zip(starts, ends)
+                    if int(end) > int(start)
+                ]
+                if bounds:
+                    return bounds
+
+    done = np.zeros(total, dtype=bool)
+    found_done = False
+    for key in ("terminals", "terminal", "timeouts", "timeout", "dones", "done"):
+        if key in h5_file:
+            value = np.asarray(h5_file[key][:], dtype=bool).reshape(-1)
+            if value.shape[0] == total:
+                done |= value
+                found_done = True
+
+    if found_done:
+        ends = (np.flatnonzero(done) + 1).astype(np.int64)
+        if len(ends) == 0 or int(ends[-1]) != total:
+            ends = np.concatenate([ends, [total]])
+        starts = np.concatenate([[0], ends[:-1]])
+        return [(int(s), int(e)) for s, e in zip(starts, ends) if int(e) > int(s)]
+
+    return [(0, total)]
+
+
+def choose_candidate_windows(
+    bounds: list[tuple[int, int]],
+    *,
+    num_trajectories: int,
+    candidate_episodes: int,
+    windows_per_episode: int,
+    window: int,
+    stride: int,
+    mode: str,
+    rng: np.random.Generator,
+) -> list[tuple[int, int, int, int]]:
+    min_len = max(2, int(window))
+    valid = [(s, e) for s, e in bounds if e - s >= min_len]
+    if not valid:
+        raise ValueError(
+            f"No episode is long enough for window={window}. "
+            f"Longest episode length={max((e - s for s, e in bounds), default=0)}"
+        )
+
+    sample_count = num_trajectories if mode != "scan" else max(num_trajectories, candidate_episodes)
+    order = rng.permutation(len(valid))[: min(sample_count, len(valid))]
+    windows = []
+    for local_idx in order:
+        ep_start, ep_end = valid[int(local_idx)]
+        max_start = ep_end - window
+        if mode == "scan":
+            if windows_per_episode <= 1:
+                starts = [max_start]
+            else:
+                starts = np.linspace(
+                    ep_start,
+                    max_start,
+                    num=max(1, int(windows_per_episode)),
+                ).round().astype(np.int64)
+                starts = list(dict.fromkeys(int(s) for s in starts))
+        elif mode == "tail":
+            starts = [max_start]
+        else:
+            starts = [int(rng.integers(ep_start, max_start + 1))]
+
+        for start in starts:
+            start = int(max(ep_start, min(start, max_start)))
+            end = start + window
+            rows = np.arange(start, end, max(1, int(stride)), dtype=np.int64)
+            if rows[-1] != end - 1:
+                rows = np.concatenate([rows, [end - 1]])
+            windows.append((ep_start, ep_end, int(rows[0]), int(rows[-1])))
+
+    unique = []
+    seen = set()
+    for item in windows:
+        if item not in seen:
+            seen.add(item)
+            unique.append(item)
+    return unique
+
+
+def score_poincare_window(poincare: np.ndarray) -> dict[str, float]:
+    progress = np.linspace(0.0, 1.0, poincare.shape[0], dtype=np.float64)
+    radius = np.linalg.norm(poincare, axis=1)
+    if radius.size < 2 or np.std(radius) < 1e-8:
+        corr = float("nan")
+    else:
+        corr = float(np.corrcoef(progress, radius)[0, 1])
+
+    early = radius[progress <= 0.25]
+    late = radius[progress >= 0.75]
+    early_mean = float(np.mean(early)) if early.size else float("nan")
+    late_mean = float(np.mean(late)) if late.size else float("nan")
+    return {
+        "radius_corr": corr,
+        "radius_gain": late_mean - early_mean,
+        "early_radius": early_mean,
+        "late_radius": late_mean,
+        "radius_min": float(np.min(radius)),
+        "radius_max": float(np.max(radius)),
+        "radius_spread": float(np.max(radius) - np.min(radius)),
+        "goal_radius": float(np.linalg.norm(poincare[-1])),
+    }
+
+
+def select_candidate_indices(
+    candidate_scores: list[dict[str, float]],
+    *,
+    selection: str,
+    num_trajectories: int,
+    rng: np.random.Generator,
+) -> list[int]:
+    if selection == "random":
+        order = rng.permutation(len(candidate_scores))
+        return [int(i) for i in order[:num_trajectories]]
+
+    def finite(value: float, fallback: float = -1e9) -> float:
+        return float(value) if np.isfinite(value) else fallback
+
+    if selection == "radius_gain":
+        key = lambda i: (
+            finite(candidate_scores[i]["radius_gain"]),
+            finite(candidate_scores[i]["radius_corr"]),
+            finite(candidate_scores[i]["radius_spread"]),
+        )
+    else:
+        key = lambda i: (
+            finite(candidate_scores[i]["radius_corr"]),
+            finite(candidate_scores[i]["radius_gain"]),
+            finite(candidate_scores[i]["radius_spread"]),
+        )
+
+    ranked = sorted(range(len(candidate_scores)), key=key, reverse=True)
+    return [int(i) for i in ranked[:num_trajectories]]
+
+
+def write_candidate_summary(path: Path, rows: list[dict]) -> None:
+    fields = [
+        "candidate",
+        "selected",
+        "traj",
+        "episode_start",
+        "episode_end",
+        "first_row",
+        "last_row",
+        "radius_corr",
+        "radius_gain",
+        "early_radius",
+        "late_radius",
+        "radius_min",
+        "radius_max",
+        "radius_spread",
+        "goal_radius",
+    ]
+    with path.open("w", newline="") as handle:
+        handle.write(",".join(fields) + "\n")
+        for row in rows:
+            handle.write(",".join(str(row.get(field, "")) for field in fields) + "\n")
+
+
+def pixel_tensor(raw: np.ndarray) -> torch.Tensor:
+    x = torch.from_numpy(np.asarray(raw))
+    if x.ndim != 4:
+        raise ValueError(f"Expected pixels with 4 dims, got shape={tuple(x.shape)}")
+    if x.shape[-1] in (1, 3):
+        x = x.permute(0, 3, 1, 2)
+    return x.contiguous()
+
+
+def preprocess_pixels(raw_pixels: np.ndarray, cfg, pixel_key: str) -> torch.Tensor:
+    pixels = pixel_tensor(raw_pixels)
+    transform = get_img_preprocessor(
+        source=pixel_key,
+        target="pixels",
+        img_size=int(cfg.img_size),
+        resize=True,
+    )
+    try:
+        return transform({pixel_key: pixels})["pixels"]
+    except Exception as exc:
+        print(
+            "[poincare] get_img_preprocessor failed; using simple float resize fallback. "
+            f"Reason: {exc}",
+            flush=True,
+        )
+        pixels = pixels.float()
+        if pixels.max() > 1.5:
+            pixels = pixels / 255.0
+        return F.interpolate(
+            pixels,
+            size=(int(cfg.img_size), int(cfg.img_size)),
+            mode="bilinear",
+            align_corners=False,
+        )
+
+
+def encoder_features(model, pixels: torch.Tensor) -> torch.Tensor:
+    output = model.encoder(pixels)
+    if torch.is_tensor(output):
+        return output
+    if hasattr(output, "last_hidden_state"):
+        hidden = output.last_hidden_state
+        if hidden.ndim == 3:
+            return hidden[:, 0]
+        return hidden
+    if hasattr(output, "pooler_output") and output.pooler_output is not None:
+        return output.pooler_output
+    if isinstance(output, (tuple, list)) and output:
+        first = output[0]
+        if torch.is_tensor(first) and first.ndim == 3:
+            return first[:, 0]
+        return first
+    raise TypeError(f"Unsupported encoder output type: {type(output)!r}")
+
+
+@torch.no_grad()
+def encode_poincare(
+    model,
+    raw_pixels: np.ndarray,
+    cfg,
+    pixel_key: str,
+    device: torch.device,
+    chunk_size: int = 32,
+) -> np.ndarray:
+    pixels = preprocess_pixels(raw_pixels, cfg, pixel_key)
+    poincare_chunks = []
+    for start in range(0, pixels.size(0), chunk_size):
+        batch = pixels[start : start + chunk_size].to(device)
+        features = encoder_features(model, batch)
+        emb = model.projector(features)
+        hyperbolic = model.to_hyperbolic(emb)
+        if isinstance(hyperbolic, tuple):
+            hyp = hyperbolic[-1]
+        else:
+            hyp = hyperbolic
+        poincare = model.manifold.to_poincare(hyp)
+        poincare_chunks.append(poincare.detach().cpu().float().numpy())
+    return np.concatenate(poincare_chunks, axis=0)
+
+
+def unit(v: np.ndarray, eps: float = 1e-8) -> np.ndarray:
+    norm = float(np.linalg.norm(v))
+    if norm < eps:
+        out = np.zeros_like(v)
+        out[0] = 1.0
+        return out
+    return v / norm
+
+
+def first_principal_axis(x: np.ndarray, fallback: np.ndarray) -> np.ndarray:
+    if x.shape[0] < 2 or np.allclose(x, 0.0):
+        return fallback
+    centered = x - x.mean(axis=0, keepdims=True)
+    try:
+        _, _, vh = np.linalg.svd(centered, full_matrices=False)
+        return unit(vh[0])
+    except np.linalg.LinAlgError:
+        return fallback
+
+
+def project_goal_aligned(p: np.ndarray) -> tuple[np.ndarray, float]:
+    goal = p[-1]
+    x_axis = unit(goal)
+    x = p @ x_axis
+    residual = p - x[:, None] * x_axis[None, :]
+    fallback = np.zeros_like(x_axis)
+    fallback[0] = 1.0
+    if abs(float(np.dot(fallback, x_axis))) > 0.9 and fallback.size > 1:
+        fallback = np.zeros_like(x_axis)
+        fallback[1] = 1.0
+    fallback = unit(fallback - np.dot(fallback, x_axis) * x_axis)
+    y_axis = first_principal_axis(residual, fallback)
+    y_axis = unit(y_axis - np.dot(y_axis, x_axis) * x_axis)
+    y = p @ y_axis
+    if y[-1] < 0:
+        y = -y
+    return np.stack([x, y], axis=1), float(np.linalg.norm(goal))
+
+
+def project_global_goal_pca(all_p: list[np.ndarray]) -> tuple[list[np.ndarray], list[float]]:
+    goals = np.stack([p[-1] for p in all_p], axis=0)
+    x_axis = unit(goals.mean(axis=0))
+    residuals = []
+    for p in all_p:
+        x = p @ x_axis
+        residuals.append(p - x[:, None] * x_axis[None, :])
+    y_axis = first_principal_axis(np.concatenate(residuals, axis=0), np.roll(x_axis, 1))
+    y_axis = unit(y_axis - np.dot(y_axis, x_axis) * x_axis)
+
+    coords = []
+    goal_radii = []
+    for p in all_p:
+        coords.append(np.stack([p @ x_axis, p @ y_axis], axis=1))
+        goal_radii.append(float(np.linalg.norm(p[-1])))
+    return coords, goal_radii
+
+
+def radius_metrics(records: list[dict]) -> dict:
+    progress = np.asarray([row["progress"] for row in records], dtype=np.float64)
+    radius = np.asarray([row["radius"] for row in records], dtype=np.float64)
+    if progress.size < 2 or np.std(radius) < 1e-8:
+        corr = float("nan")
+    else:
+        corr = float(np.corrcoef(progress, radius)[0, 1])
+
+    early = radius[progress <= 0.25]
+    mid = radius[(progress > 0.25) & (progress < 0.75)]
+    late = radius[progress >= 0.75]
+    return {
+        "radius_progress_pearson": corr,
+        "early_radius_mean": float(np.mean(early)) if early.size else float("nan"),
+        "mid_radius_mean": float(np.mean(mid)) if mid.size else float("nan"),
+        "late_radius_mean": float(np.mean(late)) if late.size else float("nan"),
+        "num_points": int(progress.size),
+    }
+
+
+def write_csv(path: Path, records: list[dict]) -> None:
+    fields = [
+        "traj",
+        "episode_start",
+        "episode_end",
+        "row",
+        "local_t",
+        "progress",
+        "radius",
+        "x",
+        "y",
+    ]
+    with path.open("w", newline="") as handle:
+        handle.write(",".join(fields) + "\n")
+        for row in records:
+            handle.write(",".join(str(row[field]) for field in fields) + "\n")
+
+
+def plot_disk(ax, records_by_traj: list[list[dict]], goal_radii: list[float]) -> None:
+    theta = np.linspace(0, 2 * np.pi, 400)
+    ax.plot(np.cos(theta), np.sin(theta), color="0.25", lw=1.1)
+    ax.axhline(0, color="0.85", lw=0.8)
+    ax.axvline(0, color="0.85", lw=0.8)
+
+    cmap = plt.get_cmap("viridis")
+    for rows in records_by_traj:
+        xy = np.asarray([[row["x"], row["y"]] for row in rows], dtype=np.float64)
+        prog = np.asarray([row["progress"] for row in rows], dtype=np.float64)
+        colors = cmap(prog)
+        for i in range(len(xy) - 1):
+            ax.plot(
+                xy[i : i + 2, 0],
+                xy[i : i + 2, 1],
+                color=colors[i],
+                alpha=0.55,
+                lw=1.5,
+            )
+        ax.scatter(xy[:, 0], xy[:, 1], c=prog, cmap="viridis", s=14, alpha=0.85)
+        if len(xy) > 3:
+            for idx in np.linspace(1, len(xy) - 2, 3).astype(int):
+                ax.annotate(
+                    "",
+                    xy=xy[idx + 1],
+                    xytext=xy[idx],
+                    arrowprops={
+                        "arrowstyle": "->",
+                        "color": colors[idx],
+                        "lw": 1.0,
+                        "alpha": 0.85,
+                    },
+                )
+
+    goal_radius = float(np.mean(goal_radii)) if goal_radii else 0.0
+    ax.scatter(
+        [goal_radius],
+        [0.0],
+        marker="*",
+        s=260,
+        c="#ffd33d",
+        edgecolors="black",
+        linewidths=1.2,
+        zorder=10,
+        label="hindsight goal",
+    )
+    ax.set_aspect("equal")
+    ax.set_xlim(-1.03, 1.03)
+    ax.set_ylim(-1.03, 1.03)
+    ax.set_xlabel("goal direction")
+    ax.set_ylabel("orthogonal progress direction")
+    ax.set_title("Goal-aligned Poincare disk")
+    ax.legend(loc="lower right", frameon=False, fontsize=8)
+
+
+def plot_radius(ax, records_by_traj: list[list[dict]]) -> None:
+    all_progress = []
+    all_radius = []
+    for rows in records_by_traj:
+        progress = np.asarray([row["progress"] for row in rows], dtype=np.float64)
+        radius = np.asarray([row["radius"] for row in rows], dtype=np.float64)
+        all_progress.append(progress)
+        all_radius.append(radius)
+        ax.plot(progress, radius, color="0.65", alpha=0.55, lw=1.0)
+
+    grid = np.linspace(0.0, 1.0, 100)
+    interp = []
+    for progress, radius in zip(all_progress, all_radius):
+        interp.append(np.interp(grid, progress, radius))
+    if interp:
+        stack = np.stack(interp, axis=0)
+        mean = stack.mean(axis=0)
+        std = stack.std(axis=0)
+        ax.plot(grid, mean, color="#d9485f", lw=2.2, label="mean")
+        ax.fill_between(grid, mean - std, mean + std, color="#d9485f", alpha=0.16)
+
+    ax.set_xlabel("normalized trajectory progress")
+    ax.set_ylabel("full Poincare radius")
+    ax.set_title("Radius should increase with progress")
+    ax.set_ylim(0.0, 1.03)
+    ax.grid(True, alpha=0.25)
+    ax.legend(frameon=False, fontsize=8)
+
+
+def plot_stage_boxes(ax, records: list[dict]) -> None:
+    stages = [[], [], []]
+    for row in records:
+        progress = float(row["progress"])
+        if progress <= 0.25:
+            stages[0].append(float(row["radius"]))
+        elif progress < 0.75:
+            stages[1].append(float(row["radius"]))
+        else:
+            stages[2].append(float(row["radius"]))
+    ax.boxplot(
+        stages,
+        labels=["early", "middle", "late"],
+        patch_artist=True,
+        boxprops={"facecolor": "#d6eef7", "edgecolor": "0.35"},
+        medianprops={"color": "#d9485f", "linewidth": 1.6},
+    )
+    ax.set_ylabel("full Poincare radius")
+    ax.set_title("Radial hierarchy by stage")
+    ax.set_ylim(0.0, 1.03)
+    ax.grid(axis="y", alpha=0.25)
+
+
+def plot_3d_ball(path: Path, records_by_traj: list[list[dict]], dpi: int) -> None:
+    from mpl_toolkits.mplot3d import Axes3D  # noqa: F401
+
+    fig = plt.figure(figsize=(6.5, 6.0))
+    ax = fig.add_subplot(111, projection="3d")
+    u = np.linspace(0, 2 * np.pi, 50)
+    v = np.linspace(0, np.pi, 25)
+    x = np.outer(np.cos(u), np.sin(v))
+    y = np.outer(np.sin(u), np.sin(v))
+    z = np.outer(np.ones_like(u), np.cos(v))
+    ax.plot_wireframe(x, y, z, color="0.85", linewidth=0.4, alpha=0.45)
+
+    cmap = plt.get_cmap("viridis")
+    for rows in records_by_traj:
+        xy = np.asarray([[row["x"], row["y"]] for row in rows], dtype=np.float64)
+        radius = np.asarray([row["radius"] for row in rows], dtype=np.float64)
+        progress = np.asarray([row["progress"] for row in rows], dtype=np.float64)
+        z_coord = np.sqrt(np.maximum(radius**2 - np.sum(xy**2, axis=1), 0.0))
+        ax.plot(xy[:, 0], xy[:, 1], z_coord, color="0.2", alpha=0.35, lw=1.0)
+        ax.scatter(xy[:, 0], xy[:, 1], z_coord, c=progress, cmap="viridis", s=14)
+
+    ax.set_xlim(-1.0, 1.0)
+    ax.set_ylim(-1.0, 1.0)
+    ax.set_zlim(0.0, 1.0)
+    ax.set_xlabel("goal direction")
+    ax.set_ylabel("orthogonal direction")
+    ax.set_zlabel("remaining radius")
+    ax.set_title("Poincare ball view")
+    fig.tight_layout()
+    fig.savefig(path, dpi=dpi)
+    plt.close(fig)
+
+
+def main() -> None:
+    args = parse_args()
+    rng = np.random.default_rng(args.seed)
+    device = resolve_device(args.device)
+
+    policy_path = resolve_policy_path(args.policy)
+    config_path = resolve_config_path(policy_path, args.config)
+    cfg = OmegaConf.load(config_path)
+    dataset_path = resolve_dataset_path(cfg, args.dataset)
+    output_dir = resolve_output_dir(policy_path, args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    with h5py.File(dataset_path, "r") as h5_file:
+        pixel_key = args.pixel_key
+        if pixel_key not in h5_file:
+            pixel_candidates = [key for key in h5_file.keys() if str(key).startswith("pixels")]
+            if not pixel_candidates:
+                raise KeyError(f"Pixel key {pixel_key!r} not found and no pixels* key exists.")
+            pixel_key = pixel_candidates[0]
+            print(f"[poincare] using pixel key {pixel_key!r}", flush=True)
+
+        action_dim = infer_action_dim(h5_file)
+        model = load_model(policy_path, cfg, action_dim=action_dim, device=device)
+
+        bounds = episode_bounds(h5_file, pixel_key)
+        candidate_windows = choose_candidate_windows(
+            bounds,
+            num_trajectories=int(args.num_trajectories),
+            candidate_episodes=int(args.candidate_episodes),
+            windows_per_episode=int(args.windows_per_episode),
+            window=int(args.window),
+            stride=int(args.stride),
+            mode=str(args.window_mode),
+            rng=rng,
+        )
+
+        candidate_poincare = []
+        candidate_rows = []
+        candidate_meta = []
+        candidate_scores = []
+        for candidate_idx, (ep_start, ep_end, first_row, last_row) in enumerate(candidate_windows):
+            rows = np.arange(first_row, last_row + 1, max(1, int(args.stride)), dtype=np.int64)
+            if rows[-1] != last_row:
+                rows = np.concatenate([rows, [last_row]])
+            raw_pixels = h5_file[pixel_key][rows]
+            poincare = encode_poincare(model, raw_pixels, cfg, pixel_key, device)
+            score = score_poincare_window(poincare)
+            candidate_poincare.append(poincare)
+            candidate_rows.append(rows)
+            candidate_meta.append((candidate_idx, ep_start, ep_end))
+            candidate_scores.append(score)
+            print(
+                f"[poincare] encoded candidate={candidate_idx} episode=({ep_start},{ep_end}) "
+                f"rows=({int(rows[0])},{int(rows[-1])}) points={len(rows)} "
+                f"corr={score['radius_corr']:.3f} gain={score['radius_gain']:.3f}",
+                flush=True,
+            )
+
+    selected_indices = select_candidate_indices(
+        candidate_scores,
+        selection=str(args.selection),
+        num_trajectories=min(int(args.num_trajectories), len(candidate_scores)),
+        rng=rng,
+    )
+    selected_set = set(selected_indices)
+    candidate_summary_rows = []
+    selected_rank = {candidate_idx: rank for rank, candidate_idx in enumerate(selected_indices)}
+    for candidate_idx, ((_, ep_start, ep_end), rows, score) in enumerate(
+        zip(candidate_meta, candidate_rows, candidate_scores)
+    ):
+        candidate_summary_rows.append(
+            {
+                "candidate": int(candidate_idx),
+                "selected": int(candidate_idx in selected_set),
+                "traj": selected_rank.get(candidate_idx, ""),
+                "episode_start": int(ep_start),
+                "episode_end": int(ep_end),
+                "first_row": int(rows[0]),
+                "last_row": int(rows[-1]),
+                **score,
+            }
+        )
+    write_candidate_summary(output_dir / "candidate_window_scores.csv", candidate_summary_rows)
+
+    all_poincare = [candidate_poincare[i] for i in selected_indices]
+    row_arrays = [candidate_rows[i] for i in selected_indices]
+    meta = [
+        (display_idx, candidate_meta[candidate_idx][1], candidate_meta[candidate_idx][2])
+        for display_idx, candidate_idx in enumerate(selected_indices)
+    ]
+    print(
+        "[poincare] selected candidates: "
+        + ", ".join(
+            f"{idx}(corr={candidate_scores[idx]['radius_corr']:.3f}, "
+            f"gain={candidate_scores[idx]['radius_gain']:.3f})"
+            for idx in selected_indices
+        ),
+        flush=True,
+    )
+
+    if args.projection == "goal_aligned":
+        coords = []
+        goal_radii = []
+        for poincare in all_poincare:
+            projected, goal_radius = project_goal_aligned(poincare)
+            coords.append(projected)
+            goal_radii.append(goal_radius)
+    else:
+        coords, goal_radii = project_global_goal_pca(all_poincare)
+
+    records = []
+    records_by_traj = []
+    for (traj_idx, ep_start, ep_end), rows, poincare, xy in zip(
+        meta, row_arrays, all_poincare, coords
+    ):
+        progress = np.linspace(0.0, 1.0, len(rows), dtype=np.float64)
+        radius = np.linalg.norm(poincare, axis=1)
+        traj_records = []
+        for local_t, (row, prog, rad, point) in enumerate(zip(rows, progress, radius, xy)):
+            record = {
+                "traj": int(traj_idx),
+                "episode_start": int(ep_start),
+                "episode_end": int(ep_end),
+                "row": int(row),
+                "local_t": int(local_t),
+                "progress": float(prog),
+                "radius": float(rad),
+                "x": float(point[0]),
+                "y": float(point[1]),
+            }
+            traj_records.append(record)
+            records.append(record)
+        records_by_traj.append(traj_records)
+
+    metrics = radius_metrics(records)
+    metrics.update(
+        {
+            "policy": str(policy_path),
+            "config": str(config_path),
+            "dataset": str(dataset_path),
+            "pixel_key": str(args.pixel_key),
+            "projection": str(args.projection),
+            "selection": str(args.selection),
+            "window_mode": str(args.window_mode),
+            "num_candidates": int(len(candidate_scores)),
+            "num_trajectories": len(records_by_traj),
+            "window": int(args.window),
+            "stride": int(args.stride),
+            "goal_radius_mean": float(np.mean(goal_radii)) if goal_radii else float("nan"),
+            "goal_radius_std": float(np.std(goal_radii)) if goal_radii else float("nan"),
+        }
+    )
+
+    write_csv(output_dir / "poincare_progress_points.csv", records)
+    with (output_dir / "poincare_progress_metrics.json").open("w") as handle:
+        json.dump(metrics, handle, indent=2)
+
+    fig, axes = plt.subplots(1, 3, figsize=(15.2, 4.8), constrained_layout=True)
+    plot_disk(axes[0], records_by_traj, goal_radii)
+    plot_radius(axes[1], records_by_traj)
+    plot_stage_boxes(axes[2], records)
+    fig.suptitle("PushT goal-conditioned progress hierarchy in the Poincare ball")
+
+    figure_path = output_dir / "pusht_poincare_progress_hierarchy.png"
+    fig.savefig(figure_path, dpi=int(args.dpi))
+    fig.savefig(output_dir / "pusht_poincare_progress_hierarchy.pdf")
+    plt.close(fig)
+
+    if bool(args.plot_3d):
+        plot_3d_ball(output_dir / "pusht_poincare_progress_hierarchy_3d.png", records_by_traj, int(args.dpi))
+
+    print(f"[poincare] wrote {figure_path}", flush=True)
+    print(f"[poincare] metrics: {json.dumps(metrics, indent=2)}", flush=True)
+
+
+if __name__ == "__main__":
+    main()