# ===================================================================================== # Minimal dependencies to run this file # ------------------------------------------------------------------------------------- # Python 3.10 # lerobot == 0.3.3 # MUST be 0.3.3 (CODEBASE_VERSION v2.1); # mmengine == 0.10.7 # DATASETS / TRANSFORMS registry + Compose # torch == 2.7.0 # tensors # numpy == 1.26.4 # index selection / arrays # torchcodec == 0.5 # default video backend for MP4 decoding # torchvision == 0.22.0 # pulled in by lerobot / torchcodec # # Quick install (CPU/CUDA torch as appropriate for your machine): # pip install "lerobot==0.3.3" "mmengine==0.10.7" \ # "torch==2.7.0" "numpy==1.26.4" "torchcodec==0.5" "torchvision==0.22.0" # ===================================================================================== import bisect import json import os import random import traceback from pathlib import Path import numpy as np import torch from lerobot.datasets.lerobot_dataset import LeRobotDataset from mmengine import DATASETS, TRANSFORMS from mmengine.dataset import Compose @TRANSFORMS.register_module() class SelectActionDims: """Select a subset of action dimensions from the raw action. The action is 89-dim; the model here only consumes 25 of them: joints 0:22 plus 83:86. `dims` may be given as an explicit list of indices, or as a list of [start, end) slice pairs (default below). Works on the ``action`` key whether it is a torch.Tensor or np.ndarray, and whether shaped (D,) or (T, D) — the last axis is indexed. """ def __init__(self, key="action", dims=None, slices=((0, 22), (83, 86))): self.key = key if dims is not None: self.indices = list(dims) else: self.indices = [i for s, e in slices for i in range(s, e)] def __call__(self, item): value = item[self.key] if isinstance(value, torch.Tensor): index = torch.as_tensor(self.indices, dtype=torch.long, device=value.device) item[self.key] = value.index_select(-1, index) else: item[self.key] = np.asarray(value)[..., self.indices] return item @DATASETS.register_module() class CustomLerobotDataset(LeRobotDataset): def __init__( self, repo_id: str, root=None, action_source="action", action_len=50, action_dim=25, action_type="absolute", action_mode="joint", info_json=None, pipeline=None, skip_instructions=("Keep still.",), max_retries=10, delta_timestamps=None, *args, **kwargs, ): super().__init__( repo_id=repo_id, root=root, image_transforms=None, delta_timestamps=delta_timestamps, ) self.action_source = action_source self.action_len = action_len self.action_dim = action_dim self.action_type = action_type self.action_mode = action_mode assert self.action_mode == "joint", "ee action not implementation." self.pipeline = Compose(pipeline) if pipeline is not None else Compose([]) self.skip_instructions = set(skip_instructions or ()) self.max_retries = max_retries json_path = Path(info_json) if not json_path.exists(): raise FileNotFoundError(f"Dataset info file not found: {info_json}") with json_path.open() as f: info_data = json.load(f) episodes = info_data.get("instruction_segments") if not isinstance(episodes, dict): raise ValueError(f"instruction_segments missing or invalid in {info_json}") self._subepisode_info: dict[int, dict[str, list]] = {} for episode_idx_str, episode_data in episodes.items(): episode_idx = int(episode_idx_str) if not isinstance(episode_data, list): raise TypeError("episode_data must be list type.") starts = [] ends = [] instrs = [] infos = [] for seg in episode_data: if not isinstance(seg, dict): raise TypeError("segment in episode_data must be list type.") start = seg.get("start_frame_index") end = seg.get("end_frame_index") instr = seg.get("instruction") info = seg.get("episode_status", "success") if isinstance(start, int) and isinstance(end, int) and isinstance(instr, str): starts.append(start) ends.append(end) instrs.append(instr) infos.append(info) else: raise ValueError("start/end_frame_index must be int, instruction must be string.") sorted_indices = sorted(range(len(starts)), key=lambda i: starts[i]) starts = [starts[i] for i in sorted_indices] ends = [ends[i] for i in sorted_indices] instrs = [instrs[i] for i in sorted_indices] infos = [infos[i] for i in sorted_indices] # Build logical segments: # 1. drop segments whose instruction is in skip_instructions (e.g. "Keep still.") # 2. merge consecutive *kept* segments that share the same instruction. # Because skip segments are removed first, "Do A / Keep still / Do A" collapses to # a single logical segment whose usable-frame list is [A1 frames] + [A2 frames] with # the still frames dropped in between — so an action chunk drawn from it is naturally # continuous and skips the still region. "Do A / Keep still / Do B" stays as two # separate segments (different instruction), so a chunk never crosses into Do B. # end_frame_index is treated as exclusive: a segment covers range(start, end). seg_starts = [] seg_ends = [] seg_instrs = [] seg_infos = [] seg_frames = [] for i in range(len(starts)): if instrs[i] in self.skip_instructions: continue cur_frames = list(range(starts[i], ends[i])) if not cur_frames: continue if seg_instrs and instrs[i] == seg_instrs[-1]: seg_frames[-1].extend(cur_frames) seg_ends[-1] = ends[i] else: seg_starts.append(starts[i]) seg_ends.append(ends[i]) seg_instrs.append(instrs[i]) seg_infos.append(infos[i]) seg_frames.append(cur_frames) if not seg_instrs: continue self._subepisode_info[episode_idx] = { "starts": seg_starts, "ends": seg_ends, "instrs": seg_instrs, "infos": seg_infos, "frames": [np.asarray(f, dtype=np.int64) for f in seg_frames], } if not self._subepisode_info: raise ValueError(f"No valid episode instructions found in {info_json}") self.usable_indices = self._build_usable_indices() def _build_usable_indices(self) -> list: """Global frame indices that participate in training.""" usable = [] for episode_idx, seg in self._subepisode_info.items(): ep_from = self.episode_data_index["from"][episode_idx].item() ep_len = self.episode_data_index["to"][episode_idx].item() - ep_from for frames in seg["frames"]: frames = frames[frames < ep_len] usable.extend((frames + ep_from).tolist()) usable.sort() return usable def _get_prompt(self, episode_idx, frame_index): episode_data = self._subepisode_info.get(episode_idx) if episode_data is None: raise ValueError(f"No instruction found for episode {episode_idx}") starts = episode_data["starts"] pos = bisect.bisect_right(starts, frame_index) - 1 if pos < 0: raise ValueError(f"Frame {frame_index} precedes the first valid segment of episode {episode_idx}.") prompt = episode_data["instrs"][pos] traj_info = episode_data["infos"][pos] seg_frames = episode_data["frames"][pos] if prompt is None: raise ValueError(f"No exact instruction found for episode {episode_idx}, frame {frame_index}") return prompt, traj_info, seg_frames def __getitem__(self, idx, pipeline=None) -> dict: last_exc = None for attempt in range(self.max_retries): try: return self._build_item(idx, pipeline=pipeline) except Exception as e: last_exc = e if attempt == 0: print( f"[CustomLerobotDataset] failed on index {idx} " f"(episode data error), resampling. First error: {repr(e)}" ) traceback.print_exc() idx = random.choice(self.usable_indices) raise RuntimeError( f"Failed to load a usable sample after {self.max_retries} resampling attempts. " f"Last error: {repr(last_exc)}" ) from last_exc def _build_item(self, idx, pipeline=None) -> dict: pipeline = pipeline if pipeline is not None else self.pipeline item = self.hf_dataset[idx] episode_idx = item["episode_index"].item() frame_idx = item["frame_index"].item() item["text"], item["traj_info"], seg_frames = self._get_prompt(episode_idx, frame_idx) curr_item = self._get_frame(item, episode_idx, pipeline=pipeline) return curr_item def _get_frame(self, item, episode_idx, pipeline=None) -> dict: pipeline = pipeline if pipeline is not None else self.pipeline query_indices, padding = self._get_query_indices(item["index"].item(), episode_idx) query_timestamps = self._get_query_timestamps(item["timestamp"].item(), query_indices) query_result = self._query_hf_dataset(query_indices) item = {**item, **padding, **query_result} if len(self.meta.video_keys) > 0: video_frames = self._query_videos(query_timestamps, episode_idx) item = {**video_frames, **item} return pipeline(item) if __name__ == "__main__": import argparse parser = argparse.ArgumentParser( description="Smoke test: read samples from a LeRobot V2.1 dataset via CustomLerobotDataset." ) parser.add_argument( "--root", default="/mnt/pfs/dataset/lerobot_data/challenge_data/upload/validation_data/fold_cloth_calib_valid_noise", help="LeRobot dataset root (contains data/ meta/ videos/).", ) parser.add_argument( "--repo-id", default="example_data", help="repo_id identifier (arbitrary when loading from a local root).", ) parser.add_argument( "--info-json", default=None, help="Path to info.json holding instruction_segments. Defaults to /meta/info.json.", ) parser.add_argument("--num-samples", type=int, default=3, help="How many usable frames to read.") args = parser.parse_args() info_json = args.info_json or os.path.join(args.root, "meta", "info.json") # _get_frame() always calls _get_query_indices(), which needs self.delta_indices # (built from delta_timestamps). Build a minimal "current frame only" ([0.0]) # delta_timestamps for every temporal feature (observation.* / action) so the # query path runs; a real training config would pass action-chunk offsets here. with open(info_json) as f: _features = json.load(f).get("features", {}) delta_timestamps = {key: [0.0] for key in _features if key == "action" or key.startswith("observation.")} skip_instructions=("Start remote operation.", "Invalid", "End remote operation.") print("=" * 70) print("Building CustomLerobotDataset") print(f" root = {args.root}") print(f" repo_id = {args.repo_id}") print(f" info_json = {info_json}") print(f" delta_timestamps = {{{', '.join(delta_timestamps)}}} -> [0.0]") print(f" pipeline = [SelectActionDims] (89 -> 25: dims 0:22 + 83:86)") print(f" skip_instructions = {skip_instructions}") print("=" * 70) dataset = CustomLerobotDataset( repo_id=args.repo_id, root=args.root, info_json=info_json, pipeline=[dict(type="SelectActionDims")], skip_instructions=skip_instructions, delta_timestamps=delta_timestamps, ) print(f"\nlen(dataset) (raw frames) : {len(dataset)}") print(f"len(dataset.usable_indices) : {len(dataset.usable_indices)}") print(f"num sub-episodes : {len(dataset._subepisode_info)}") if dataset.usable_indices: print(f"usable index range : " f"[{dataset.usable_indices[0]}, {dataset.usable_indices[-1]}]") def describe(value): if isinstance(value, torch.Tensor): return f"Tensor shape={tuple(value.shape)} dtype={value.dtype}" if isinstance(value, np.ndarray): return f"ndarray shape={value.shape} dtype={value.dtype}" if isinstance(value, (str, int, float, bool)): return f"{type(value).__name__}={value!r}" return f"{type(value).__name__}" n = min(args.num_samples, len(dataset.usable_indices)) print(f"\nReading {n} usable sample(s):") for i in range(n): idx = dataset.usable_indices[i * (len(dataset.usable_indices) // max(n, 1))] print("\n" + "-" * 70) print(f"sample {i}: global frame index = {idx}") item = dataset[idx] for key in sorted(item.keys()): print(f" {key:45s}: {describe(item[key])}") print("\n" + "=" * 70) print("OK: dataset built and samples read successfully.") print("=" * 70)