#!/usr/bin/env python3 from __future__ import annotations import openpi.shared.local_cache_bootstrap # noqa: F401 import argparse import dataclasses import os import textwrap from typing import Any import numpy as np def _shape(x) -> tuple[int, ...]: return tuple(np.asarray(x).shape) def _print_present_shapes(title: str, item: dict[str, Any], keys: list[str]) -> None: print(title) for k in keys: if k in item: print(f" {k}: {_shape(item[k])}") def _set_jax_device(device: str) -> None: if device == "cpu": os.environ["JAX_PLATFORMS"] = "cpu" os.environ["JAX_PLATFORM_NAME"] = "cpu" os.environ.setdefault("XLA_PYTHON_CLIENT_PREALLOCATE", "false") def _infer_stage(config_name: str, cfg: Any) -> str: include_track_targets = getattr(getattr(cfg, "data", object()), "include_track_targets", None) if isinstance(include_track_targets, bool): return "stage2" if include_track_targets else "stage1" if "stage2" in config_name: return "stage2" if "stage1" in config_name: return "stage1" return "unknown" def _validate_batch_schema( *, obs: Any, targets: Any, stage: str, expected_batch_size: int, action_horizon: int, track_head_dim: int | None, ) -> None: if len(obs.images) == 0: raise AssertionError("observation.image is empty") if np.asarray(obs.state).shape[0] != expected_batch_size: raise AssertionError( f"Unexpected batch size in observation.state: {np.asarray(obs.state).shape[0]} (expected {expected_batch_size})" ) if stage == "stage1": if isinstance(targets, dict): raise AssertionError("Stage1 should emit tensor actions targets, got dict") target_shape = _shape(targets) if len(target_shape) < 2 or target_shape[1] != action_horizon: raise AssertionError( f"Stage1 actions target has unexpected shape {target_shape}; expected (*, {action_horizon}, ...)" ) return if stage == "stage2": if not isinstance(targets, dict): raise AssertionError("Stage2 should emit dict targets with actions and track_targets") missing = {"actions", "track_targets"} - set(targets.keys()) if missing: raise AssertionError(f"Stage2 targets missing keys: {sorted(missing)}") action_shape = _shape(targets["actions"]) if len(action_shape) < 2 or action_shape[1] != action_horizon: raise AssertionError( f"Stage2 actions target has unexpected shape {action_shape}; expected (*, {action_horizon}, ...)" ) track_shape = _shape(targets["track_targets"]) if len(track_shape) != 3: raise AssertionError(f"Stage2 track_targets should be rank-3 (B,T,D), got {track_shape}") if track_shape[1] != action_horizon: raise AssertionError( f"Stage2 track_targets horizon mismatch: got {track_shape[1]}, expected {action_horizon}" ) if track_head_dim is not None and track_shape[2] != track_head_dim: raise AssertionError( f"Stage2 track_targets dim mismatch: got {track_shape[2]}, expected {track_head_dim}" ) def main() -> None: parser = argparse.ArgumentParser( description="Inspect Libero dataloader schema for stage1/stage2 configs.", epilog=textwrap.dedent( """ Cache defaults match scripts/train.py (see openpi.shared.local_cache_bootstrap). Stage2 OOM fallback: --device=cpu --batch-size 1 """ ), formatter_class=argparse.RawDescriptionHelpFormatter, ) parser.add_argument("--config-name", required=True) parser.add_argument("--batch-size", type=int, default=2) parser.add_argument("--num-batches", type=int, default=1) parser.add_argument("--skip-norm-stats", action="store_true") parser.add_argument( "--inspect-sample", action="store_true", help="Print one raw dataset sample and its training-format preprocessed sample shapes.", ) parser.add_argument( "--device", choices=("auto", "cpu"), default="auto", help="Set --device=cpu for stage2 inspection to avoid GPU OOM false negatives.", ) args = parser.parse_args() if args.device == "cpu": _set_jax_device("cpu") print("device=cpu (JAX forced to CPU)") import openpi.training.config as training_config import openpi.training.data_loader as data_loader cfg = training_config.get_config(args.config_name) cfg = dataclasses.replace(cfg, batch_size=args.batch_size, num_workers=0) stage = _infer_stage(args.config_name, cfg) if not os.getenv("HF_HOME"): print("hint: import openpi.shared.local_cache_bootstrap first, or set HF_HOME / HF_LEROBOT_HOME") if stage == "stage2" and args.device != "cpu": print("hint: if you hit OOM, retry with --device=cpu --batch-size 1") data_config = cfg.data.create(cfg.assets_dirs, cfg.model) norm_stats = None if args.skip_norm_stats else data_config.norm_stats preprocess_chain = data_loader.build_dataset_preprocess_transforms(data_config, norm_stats=norm_stats) print(f"preprocess.transforms={len(preprocess_chain)}") if args.inspect_sample: raw_dataset = data_loader.create_torch_dataset(data_config, cfg.model.action_horizon, cfg.model) raw_item = raw_dataset[0] _print_present_shapes( "raw_sample", raw_item, [ "image", "wrist_image", "agentview_mesh_vertices_2d", "wrist_mesh_vertices_2d", "wrist_tracks", "track_targets_raw", "actions", ], ) preprocessed = data_loader.preprocess_dataset_item(raw_item, data_config, norm_stats=norm_stats) _print_present_shapes( "preprocessed_sample", preprocessed, [ "observation/image", "observation/wrist_image", "observation/query_state", "track_targets", "actions", ], ) loader = data_loader.create_data_loader( cfg, shuffle=False, num_batches=args.num_batches, skip_norm_stats=args.skip_norm_stats, ) print(f"config={args.config_name}") print(f"repo_id={loader.data_config().repo_id}") for i, (obs, targets) in enumerate(loader): print(f"batch_index={i}") print(f"observation.state shape={_shape(obs.state)}") print(f"observation.image keys={sorted(obs.images.keys())}") for k in sorted(obs.images): print(f"image[{k}] shape={_shape(obs.images[k])}") if isinstance(targets, dict): print(f"targets.keys={sorted(targets.keys())}") for k in sorted(targets): print(f"targets[{k}] shape={_shape(targets[k])}") else: print(f"targets.shape={_shape(targets)}") _validate_batch_schema( obs=obs, targets=targets, stage=stage, expected_batch_size=args.batch_size, action_horizon=cfg.model.action_horizon, track_head_dim=getattr(cfg.model, "track_head_dim", None), ) print("schema_validation=ok") if __name__ == "__main__": main()