| |
| from __future__ import annotations |
|
|
| import openpi.shared.local_cache_bootstrap |
|
|
| 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() |
|
|
