"""Standalone track visualization from a saved checkpoint. Loads the policy (with all transforms), reads raw samples from the dataset parquet files directly, runs inference with return_tracks=True, and saves 2x3 grid visualizations. Does NOT use the training data loader. Usage: cd /mnt/filesystem-g0/Dual-Dynamics-Models/openpi HF_LEROBOT_HOME=data PYTHONPATH=src:$PYTHONPATH python scripts/visualize_tracks.py \ --config pi05_realworld_track_joint \ --checkpoint-dir checkpoints/pi05_realworld_track_joint/run1/15000 \ --num-samples 5 \ --output-dir track_viz_output """ import argparse import logging import os import matplotlib.pyplot as plt import numpy as np import pyarrow.parquet as pq from PIL import Image logging.basicConfig(level=logging.INFO, force=True) logger = logging.getLogger(__name__) DATA_ROOT = "data/realworld_ee_tracks_rlds" def load_sample(idx: int): """Load a single sample directly from parquet via pyarrow.""" parquet_path = os.path.join(DATA_ROOT, "data/chunk-000", f"episode_{idx:06d}.parquet") table = pq.read_table(parquet_path) # Get first row via column access (avoids pandas iloc bug) def get(col): return table[col][0].as_py() # Load images (stored as {'bytes': b'...', 'path': '...'} dicts) def load_image(col): import io as _io val = get(col) if isinstance(val, dict) and "bytes" in val: return np.array(Image.open(_io.BytesIO(val["bytes"])).convert("RGB")) elif isinstance(val, dict) and "path" in val: return np.array(Image.open(val["path"]).convert("RGB")) else: return np.array(Image.open(_io.BytesIO(val)).convert("RGB")) img_agent = load_image("image") img_wrist = load_image("wrist_image") # Track data agent_mesh = np.array(get("agentview_mesh_vertices_2d")).reshape(7, 2) wrist_mesh = np.array(get("wrist_mesh_vertices_2d")).reshape(7, 2) wrist_tracks = np.array(get("wrist_tracks")).reshape(32, 2) track_targets = np.array(get("track_targets_raw")).reshape(16, 39, 2) # Task prompt task_index = int(get("task_index")) import json tasks_path = os.path.join(DATA_ROOT, "meta/tasks.jsonl") with open(tasks_path) as f: tasks = [json.loads(line) for line in f] prompt = tasks[task_index]["task"] # Query points: 78D = [agent_mesh(7x2=14), wrist_mesh(7x2=14), wrist_uniform(25x2=50)] wrist_uniform = wrist_tracks[:25] query_points = np.concatenate([ agent_mesh.flatten(), wrist_mesh.flatten(), wrist_uniform.flatten(), ]) return { "img_agent": img_agent, "img_wrist": img_wrist, "agent_mesh": agent_mesh, "wrist_mesh": wrist_mesh, "wrist_tracks": wrist_tracks, "query_points": query_points, "track_targets": track_targets, "prompt": prompt, } def build_policy_input(sample): """Build the dict that the policy's infer() expects (pre-transform).""" return { "observation/image": sample["img_agent"], "observation/wrist_image": sample["img_wrist"], "observation/state": np.zeros(10, dtype=np.float32), "prompt": sample["prompt"], "agentview_mesh_vertices_2d": sample["agent_mesh"].astype(np.float32), "wrist_mesh_vertices_2d": sample["wrist_mesh"].astype(np.float32), "wrist_tracks": sample["wrist_tracks"].astype(np.float32), "track_targets_raw": sample["track_targets"].astype(np.float32), } def visualize(sample, predicted_tracks, step_name, sample_idx, output_dir): """Create 2x3 visualization grid and save.""" img_agent = sample["img_agent"] img_wrist = sample["img_wrist"] H, W = img_agent.shape[:2] # Query points query_agent = sample["agent_mesh"] # (7, 2) query_wrist = np.vstack([sample["wrist_mesh"], sample["wrist_tracks"][:25]]) # (32, 2) # Ground truth: (16, 39, 2) gt = sample["track_targets"] gt_agent = gt[:, :7, :] # (16, 7, 2) gt_wrist = gt[:, 7:, :] # (16, 32, 2) # Predicted: (16, 78) -> reshape timesteps = predicted_tracks.shape[0] pred = predicted_tracks.reshape(timesteps, 39, 2) pred_agent = pred[:, :7, :] # (16, 7, 2) pred_wrist = pred[:, 7:, :] # (16, 32, 2) fig, axes = plt.subplots(2, 3, figsize=(15, 10)) fig.suptitle(f"Track Prediction — ckpt {step_name} — sample {sample_idx}\n\"{sample['prompt']}\"", fontsize=14) # Row 1: Agentview axes[0, 0].imshow(img_agent) axes[0, 0].scatter(query_agent[:, 0] * W, query_agent[:, 1] * H, c="red", s=30) axes[0, 0].set_title(f"Agentview: Query ({len(query_agent)} pts)") axes[0, 0].axis("off") axes[0, 1].imshow(img_agent) for j in range(pred_agent.shape[1]): axes[0, 1].plot(pred_agent[:, j, 0] * W, pred_agent[:, j, 1] * H, alpha=0.6, linewidth=2) axes[0, 1].set_title(f"Agentview: Predicted") axes[0, 1].axis("off") axes[0, 2].imshow(img_agent) for j in range(gt_agent.shape[1]): axes[0, 2].plot(gt_agent[:, j, 0] * W, gt_agent[:, j, 1] * H, alpha=0.6, linewidth=2) axes[0, 2].set_title(f"Agentview: Ground Truth") axes[0, 2].axis("off") # Row 2: Wrist axes[1, 0].imshow(img_wrist) axes[1, 0].scatter(query_wrist[:, 0] * W, query_wrist[:, 1] * H, c="red", s=20) axes[1, 0].set_title(f"Eyeinhand: Query ({len(query_wrist)} pts)") axes[1, 0].axis("off") axes[1, 1].imshow(img_wrist) for j in range(pred_wrist.shape[1]): axes[1, 1].plot(pred_wrist[:, j, 0] * W, pred_wrist[:, j, 1] * H, alpha=0.5, linewidth=1.5) axes[1, 1].set_title(f"Eyeinhand: Predicted") axes[1, 1].axis("off") axes[1, 2].imshow(img_wrist) for j in range(gt_wrist.shape[1]): axes[1, 2].plot(gt_wrist[:, j, 0] * W, gt_wrist[:, j, 1] * H, alpha=0.5, linewidth=1.5) axes[1, 2].set_title(f"Eyeinhand: Ground Truth") axes[1, 2].axis("off") plt.tight_layout() save_path = os.path.join(output_dir, f"tracks_ckpt{step_name}_sample{sample_idx}.png") plt.savefig(save_path, dpi=150, bbox_inches="tight") plt.close(fig) logger.info(f"Saved: {save_path}") def main(): parser = argparse.ArgumentParser(description="Visualize track predictions from a checkpoint") parser.add_argument("--config", type=str, required=True) parser.add_argument("--checkpoint-dir", type=str, required=True) parser.add_argument("--num-samples", type=int, default=5) parser.add_argument("--output-dir", type=str, default="track_viz_output") parser.add_argument("--episode-start", type=int, default=0, help="First episode index") parser.add_argument("--episode-step", type=int, default=20, help="Step between episodes") args = parser.parse_args() os.makedirs(args.output_dir, exist_ok=True) # Load policy from openpi.training import config as _config from openpi.policies import policy_config as _policy_config config = _config.get_config(args.config) logger.info(f"Loading policy from {args.checkpoint_dir}") policy = _policy_config.create_trained_policy( config, args.checkpoint_dir, sample_kwargs={"return_tracks": True}, ) logger.info("Policy loaded") step_name = os.path.basename(args.checkpoint_dir) for i in range(args.num_samples): ep_idx = args.episode_start + i * args.episode_step logger.info(f"Sample {i+1}/{args.num_samples} (episode {ep_idx})") try: sample = load_sample(ep_idx) obs = build_policy_input(sample) result = policy.infer(obs) # Extract track predictions if "track_predictions" in result: pred_tracks = result["track_predictions"] elif "actions" in result: # Tracks might be in actions if no separate head pred_tracks = result["actions"] else: logger.warning(f"No track predictions found in result keys: {list(result.keys())}") continue visualize(sample, pred_tracks, step_name, i, args.output_dir) except Exception as e: logger.error(f"Error on episode {ep_idx}: {e}") import traceback traceback.print_exc() logger.info(f"Done! Visualizations saved to {args.output_dir}/") if __name__ == "__main__": main()