| |
| """Exercise the RLinf CFG dataset/transform path without launching Ray/FSDP. |
| |
| The script intentionally limits the local LeRobot view to the rows for which a |
| smoke advantage sidecar exists. It validates the exact transform stack used by |
| ``FSDPCfgWorker.build_dataloader`` and prints one collated CFG observation. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import logging |
| from pathlib import Path |
|
|
| import numpy as np |
| import pandas as pd |
| import torch |
| from torch.utils.data import DataLoader |
|
|
| import lerobot.common.datasets.lerobot_dataset as lerobot_dataset |
| import openpi.training.data_loader as openpi_data_loader |
| import openpi.transforms as transforms |
| from rlinf.data.datasets.recap.cfg_model import ( |
| AdvantagePreservingDataset, |
| TokenizePromptWithGuidance, |
| ) |
| from rlinf.data.datasets.recap.utils import cast_image_features |
| from rlinf.data.lerobot_paths import resolve_lerobot_dataset_root |
| from rlinf.models.embodiment.openpi.dataconfig import get_openpi_config |
|
|
|
|
| class _LookupLimitedDataset: |
| """Expose only sidecar-covered rows while retaining LeRobot lookahead. |
| |
| LeRobot's delta-timestamp query for row 0 reads the following nine rows. |
| Keeping the full decoder as the delegate avoids truncating those rows, but |
| the small ``hf_dataset`` view makes the advantage join check exactly the |
| rows present in the smoke sidecar. |
| """ |
|
|
| def __init__(self, delegate, count: int): |
| self._delegate = delegate |
| self.hf_dataset = delegate.hf_dataset.select(range(count)) |
|
|
| def __len__(self): |
| return len(self.hf_dataset) |
|
|
| def __getitem__(self, index): |
| return self._delegate[index] |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser() |
| parser.add_argument( |
| "--dataset", |
| type=Path, |
| default=Path( |
| "/data/myx/RL_post_train/datasets/recap_value_smoke/" |
| "libero10_task0_train" |
| ), |
| ) |
| parser.add_argument( |
| "--model", |
| type=Path, |
| default=Path( |
| "/data/myx/RL_post_train/checkpoints/base/RLinf-Pi05-LIBERO-SFT" |
| ), |
| ) |
| parser.add_argument("--advantage-tag", default="smoke") |
| parser.add_argument("--max-samples", type=int, default=8) |
| return parser.parse_args() |
|
|
|
|
| def main() -> int: |
| args = parse_args() |
| logging.basicConfig(level=logging.INFO) |
| for name, path in (("dataset", args.dataset), ("model", args.model)): |
| if not path.exists(): |
| raise FileNotFoundError(f"{name} path does not exist: {path}") |
| if args.max_samples < 1: |
| raise ValueError("--max-samples must be positive") |
|
|
| data_path = str(args.dataset.resolve()) |
| model_path = str(args.model.resolve()) |
| train_config = get_openpi_config( |
| "pi05_libero", model_path=model_path, batch_size=1, repo_id=data_path |
| ) |
| data_config = train_config.data.create(train_config.assets_dirs, train_config.model) |
| dataset_root = resolve_lerobot_dataset_root(data_path) |
| dataset_meta = lerobot_dataset.LeRobotDatasetMetadata( |
| data_path, root=dataset_root |
| ) |
| base_dataset = lerobot_dataset.LeRobotDataset( |
| data_path, |
| root=dataset_root, |
| delta_timestamps={ |
| key: [t / dataset_meta.fps for t in range(train_config.model.action_horizon)] |
| for key in data_config.action_sequence_keys |
| }, |
| ) |
| base_dataset.hf_dataset = cast_image_features(base_dataset.hf_dataset) |
|
|
| |
| |
| |
| n = min(args.max_samples, len(base_dataset.hf_dataset)) |
| base_dataset = _LookupLimitedDataset(base_dataset, n) |
|
|
| if data_config.prompt_from_task: |
| base_dataset = openpi_data_loader.TransformedDataset( |
| base_dataset, |
| [transforms.PromptFromLeRobotTask(dataset_meta.tasks)], |
| ) |
|
|
| tokenizer = None |
| for transform in data_config.model_transforms.inputs: |
| if hasattr(transform, "tokenizer"): |
| tokenizer = transform.tokenizer |
| break |
| if tokenizer is None: |
| raise RuntimeError("Could not find tokenizer in pi05_libero model transforms") |
|
|
| model_transforms = [] |
| for transform in data_config.model_transforms.inputs: |
| if type(transform).__name__ == "TokenizePrompt": |
| model_transforms.append( |
| TokenizePromptWithGuidance( |
| tokenizer=tokenizer, |
| discrete_state_input=getattr( |
| transform, "discrete_state_input", False |
| ), |
| ) |
| ) |
| else: |
| model_transforms.append(transform) |
|
|
| transforms_list = [ |
| *data_config.repack_transforms.inputs, |
| *data_config.data_transforms.inputs, |
| transforms.Normalize( |
| data_config.norm_stats, use_quantiles=data_config.use_quantile_norm |
| ), |
| *model_transforms, |
| ] |
| transformed_dataset = openpi_data_loader.TransformedDataset( |
| base_dataset, transforms_list |
| ) |
|
|
| adv_path = args.dataset / "meta" / f"advantages_{args.advantage_tag}.parquet" |
| adv_df = pd.read_parquet(adv_path) |
| advantages_lookup = dict( |
| zip( |
| zip( |
| adv_df["episode_index"].astype(int), |
| adv_df["frame_index"].astype(int), |
| ), |
| adv_df["advantage"].astype(bool), |
| ) |
| ) |
| final_dataset = AdvantagePreservingDataset( |
| base_dataset=base_dataset, |
| transformed_dataset=transformed_dataset, |
| advantages_lookup=advantages_lookup, |
| ) |
| loader = DataLoader( |
| final_dataset, |
| batch_size=1, |
| shuffle=False, |
| num_workers=0, |
| drop_last=True, |
| ) |
| batch = next(iter(loader)) |
| image_shapes = {key: list(value.shape) for key, value in batch["image"].items()} |
| token_shapes = { |
| key: list(value.shape) |
| for key, value in batch.items() |
| if key.startswith("tokenized_") |
| } |
| advantages = torch.as_tensor(batch["advantage"], dtype=torch.bool) |
| print( |
| "CFG_DATALOADER_PASS", |
| json.dumps( |
| { |
| "dataset_rows": len(final_dataset), |
| "image_shapes": image_shapes, |
| "state_shape": list(batch["state"].shape), |
| "actions_shape": list(batch["actions"].shape), |
| "token_shapes": token_shapes, |
| "advantage_shape": list(advantages.shape), |
| "advantage_values": advantages.tolist(), |
| "finite_images": all( |
| bool(np.isfinite(value.numpy()).all()) |
| for value in batch["image"].values() |
| ), |
| }, |
| sort_keys=True, |
| ), |
| ) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
