dataloader/custom_lerobot_dataset.py

# =====================================================================================
# 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 <root>/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)