| |
| """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() |
|
|
