#!/usr/bin/env python3 """ Unified MCAP → LeRobot pipeline Runs the full conversion in sequence: 1. MCAP → LeRobot v3.0 (full-episode or DAgger-segment mode) 2. Fix dataset bugs (episode metadata file_index + optional gripper scaling) 3. v3.0 → v2.1 (saved alongside v3.0; original v3.0 is preserved) Usage (full-episode mode): python convert_mcap_pipeline.py \\ --task insert-mouse-battery \\ --robot_type arx \\ --final_dataset_repo_root we_d900 \\ --tasks_json_path /path/to/tasks_hil.json \\ --dataset_root /nas/volume1/scratch/datasets \\ --num_process 40 Usage (DAgger-segment mode): python convert_mcap_pipeline.py \\ --task insert-mouse-battery \\ --robot_type arx \\ --mode dagger \\ --min_segment_length 10 \\ --final_dataset_repo_root we_d900 \\ --tasks_json_path /path/to/tasks_hil.json \\ --dataset_root /nas/volume1/scratch/datasets \\ --num_process 20 Output locations (for final_dataset_repo_root=we_d900, task=insert-mouse-battery): v3.0: $HF_LEROBOT_HOME/we_d900/insert-mouse-battery v2.1: $HF_LEROBOT_HOME/we_d900/insert-mouse-battery_v21 """ import argparse import json import logging import shutil import subprocess import sys from pathlib import Path import numpy as np import pandas as pd import pyarrow as pa import pyarrow.parquet as pq import jsonlines import tqdm # ── import sibling convert scripts ──────────────────────────────────────────── _SCRIPTS_DIR = Path(__file__).parent sys.path.insert(0, str(_SCRIPTS_DIR)) from convert_mcap_to_lerobot import ( # noqa: E402 convert_task_to_lerobot, DEFAULT_HIL_ACTION_TYPES, DATASET_ROOT, TASKS_JSON_PATH, ) from convert_mcap_to_lerobot_dagger_segment import ( # noqa: E402 convert_task_to_lerobot_dagger, ) # ── lerobot utils ───────────────────────────────────────────────────────────── from lerobot.utils.constants import HF_LEROBOT_HOME # noqa: E402 from lerobot.datasets.utils import ( # noqa: E402 DEFAULT_CHUNK_SIZE, DEFAULT_TASKS_PATH, DEFAULT_VIDEO_PATH, LEGACY_EPISODES_PATH, LEGACY_EPISODES_STATS_PATH, LEGACY_TASKS_PATH, load_info, load_nested_dataset, unflatten_dict, write_info, ) # ── constants ───────────────────────────────────────────────────────────────── GRIPPER_THRESHOLD = 0.1 # gripper max below this → needs rescaling GRIPPER_SCALE = 0.08 # old recordings store gripper in [0, 0.08] V21 = "v2.1" V30 = "v3.0" LEGACY_DATA_PATH = "data/chunk-{episode_chunk:03d}/episode_{episode_index:06d}.parquet" LEGACY_VIDEO_PATH = "videos/chunk-{episode_chunk:03d}/{video_key}/episode_{episode_index:06d}.mp4" # ══════════════════════════════════════════════════════════════════════════════ # Step 2: Fix dataset bugs (inlined from tools/fix_lerobot_dataset.py) # ══════════════════════════════════════════════════════════════════════════════ def fix_file_index(root: Path) -> int: """ Rebuild data/file_index in meta/episodes/*.parquet from actual data files. Bug: convert scripts that use rglob("*.parquet") accidentally pick up meta parquet files and produce duplicate / wrong data/file_index entries. Returns number of corrected episode entries. """ # Build ground-truth: episode_index → (chunk_idx, file_idx) ep_to_file: dict[int, tuple[int, int]] = {} for p in sorted((root / "data").glob("*/*.parquet")): chunk_idx = int(p.parent.name.split("-")[1]) file_idx = int(p.stem.split("-")[1]) df_ep = pd.read_parquet(p, columns=["episode_index"]) for ep in df_ep["episode_index"].unique(): ep_to_file[int(ep)] = (chunk_idx, file_idx) fixed_count = 0 for eps_file in sorted((root / "meta" / "episodes").glob("*/*.parquet")): df = pd.read_parquet(eps_file) changed = False for i, row in df.iterrows(): ep = int(row["episode_index"]) if ep not in ep_to_file: continue correct_chunk, correct_file = ep_to_file[ep] if (int(row["data/chunk_index"]) != correct_chunk or int(row["data/file_index"]) != correct_file): df.at[i, "data/chunk_index"] = correct_chunk df.at[i, "data/file_index"] = correct_file fixed_count += 1 changed = True if changed: df.to_parquet(eps_file, index=False) return fixed_count def needs_gripper_fix(root: Path, gripper_indices: list[int] = [6, 13]) -> list[tuple[Path, float]]: """ Check which data parquet files have gripper values in [0, 0.08] range (old MCAP format) instead of [0, 1]. Returns list of (path, current_max) for files that need fixing. """ data_files = sorted((root / "data").glob("*/*.parquet")) to_fix = [] for pf in tqdm.tqdm(data_files, desc=" Checking gripper values", leave=False): table = pq.read_table(pf) if "action" not in table.column_names: continue actions = np.array([r.as_py() for r in table.column("action")], dtype=np.float32) if actions.ndim != 2: continue gripper_max = max( (actions[:, idx].max() for idx in gripper_indices if idx < actions.shape[1]), default=0.0, ) if gripper_max <= GRIPPER_THRESHOLD: to_fix.append((pf, float(gripper_max))) return to_fix def fix_gripper(files_to_fix: list[tuple[Path, float]], gripper_indices: list[int] = [6, 13]) -> int: """ Rescale gripper dimensions from [0, 0.08] to [0, 1] in-place. Returns number of files modified. """ modified = 0 for pf, _ in tqdm.tqdm(files_to_fix, desc=" Fixing gripper", leave=False): table = pq.read_table(pf) if "action" not in table.column_names: continue action_col = table.column("action") actions = np.array([r.as_py() for r in action_col], dtype=np.float32) if actions.ndim != 2: continue for idx in gripper_indices: if idx < actions.shape[1]: actions[:, idx] = np.clip(actions[:, idx] / GRIPPER_SCALE, 0.0, 1.0) new_col = pa.array([row.tolist() for row in actions], type=action_col.type) col_idx = table.column_names.index("action") table = table.set_column(col_idx, "action", new_col) pq.write_table(table, pf) modified += 1 return modified def run_fixes(dataset_path: Path, fix_gripper_flag: bool = False): """Run all dataset bug fixes on a v3.0 dataset in-place.""" info_path = dataset_path / "meta" / "info.json" if not info_path.exists(): logging.warning(f" No info.json found at {dataset_path}, skipping fixes") return with open(info_path) as f: info = json.load(f) version = info.get("codebase_version", "unknown") if version != V30: logging.warning(f" Dataset version is {version}, skipping v3.0-specific fixes") return # Fix 1: episode metadata file_index logging.info(" [fix 1/2] Checking episodes metadata (data/file_index)...") n_fixed = fix_file_index(dataset_path) if n_fixed > 0: logging.info(f" ✓ Fixed {n_fixed} file_index entries") else: logging.info(" ✓ file_index OK") # Fix 2: gripper scaling — auto-detected from actual values; skipped only with --no_fix_gripper logging.info(" [fix 2/2] Checking gripper values...") files_to_fix = needs_gripper_fix(dataset_path) if files_to_fix: if fix_gripper_flag: logging.info( f" Detected {len(files_to_fix)} files with gripper in [0,0.08] range → auto-rescaling to [0,1]" ) n_fixed = fix_gripper(files_to_fix) logging.info(f" ✓ Fixed gripper in {n_fixed} files") else: logging.warning( f" ⚠ Skipping gripper fix (--no_fix_gripper): " f"{len(files_to_fix)} files still have gripper in [0,0.08] range" ) else: logging.info(" ✓ Gripper values OK (no rescaling needed)") # ══════════════════════════════════════════════════════════════════════════════ # Step 3: v3.0 → v2.1 (inlined from convert_lerobot_v30_to_v21.py) # ══════════════════════════════════════════════════════════════════════════════ def _to_jsonable(obj): """Recursively convert numpy types to JSON-serializable Python objects.""" if isinstance(obj, dict): return {str(k): _to_jsonable(v) for k, v in obj.items()} if isinstance(obj, (list, tuple)): return [_to_jsonable(v) for v in obj] if isinstance(obj, np.ndarray): if obj.dtype == object: return [_to_jsonable(v) for v in obj.tolist()] return obj.tolist() if isinstance(obj, np.generic): return obj.item() return obj def _load_episodes_metadata(root: Path) -> pd.DataFrame: episodes_dir = root / "meta" / "episodes" ds = load_nested_dataset(episodes_dir) return ds.to_pandas() def _load_tasks(root: Path) -> pd.DataFrame: tasks_path = root / DEFAULT_TASKS_PATH return pd.read_parquet(tasks_path) def _get_video_keys(root: Path) -> list[str]: info = load_info(root) return sorted(k for k, ft in info["features"].items() if ft["dtype"] == "video") def _get_image_keys(root: Path) -> list[str]: info = load_info(root) return [k for k, ft in info["features"].items() if ft["dtype"] == "image"] def _convert_tasks_to_jsonl(root: Path, new_root: Path): df_tasks = _load_tasks(root) tasks_path = new_root / LEGACY_TASKS_PATH tasks_path.parent.mkdir(parents=True, exist_ok=True) with jsonlines.open(tasks_path, mode="w") as writer: for task_str, row in df_tasks.iterrows(): writer.write({"task_index": int(row["task_index"]), "task": str(task_str)}) def _convert_episodes_to_jsonl(root: Path, new_root: Path): df_episodes = _load_episodes_metadata(root) df_tasks = _load_tasks(root) task_index_to_task = {int(row["task_index"]): str(t) for t, row in df_tasks.iterrows()} episodes_path = new_root / LEGACY_EPISODES_PATH episodes_path.parent.mkdir(parents=True, exist_ok=True) stats_path = new_root / LEGACY_EPISODES_STATS_PATH stats_columns = [c for c in df_episodes.columns if c.startswith("stats/")] with jsonlines.open(episodes_path, mode="w") as ep_w, \ jsonlines.open(stats_path, mode="w") as st_w: for _, row in df_episodes.iterrows(): episode_index = int(row["episode_index"]) if "tasks" in row: tasks = list(row["tasks"]) if isinstance(row["tasks"], (list, tuple)) else [row["tasks"]] else: task_idx = row.get("task_index", 0) tasks = [task_index_to_task.get(int(task_idx), "")] length = int(row["dataset_to_index"] - row["dataset_from_index"]) ep_w.write({"episode_index": episode_index, "tasks": tasks[0][0], "length": length}) if stats_columns: stats_dict = {} for col in stats_columns: key = col[6:] # strip "stats/" value = row[col] if hasattr(value, "tolist"): value = value.tolist() stats_dict[key] = value unflat = _to_jsonable(unflatten_dict(stats_dict)) st_w.write({"episode_index": episode_index, "stats": unflat}) def _convert_data_files(root: Path, new_root: Path): from datasets import Features, Image data_paths = sorted((root / "data").glob("*/*.parquet")) if not data_paths: logging.warning("No data files found for v2.1 conversion") return image_keys = _get_image_keys(root) all_data = pd.concat([pd.read_parquet(p) for p in data_paths], ignore_index=True) for episode_index, ep_df in tqdm.tqdm( all_data.groupby("episode_index"), desc=" Writing v2.1 data files" ): chunk_idx = episode_index // DEFAULT_CHUNK_SIZE out_path = new_root / LEGACY_DATA_PATH.format( episode_chunk=chunk_idx, episode_index=episode_index ) out_path.parent.mkdir(parents=True, exist_ok=True) ep_df = ep_df.copy().sort_values("frame_index").reset_index(drop=True) if image_keys: schema = pa.Schema.from_pandas(ep_df) features = Features.from_arrow_schema(schema) for key in image_keys: features[key] = Image() schema = features.arrow_schema else: schema = None ep_df.to_parquet(out_path, index=False, schema=schema) def _split_video(src: Path, dst: Path, start_time: float, end_time: float): dst.parent.mkdir(parents=True, exist_ok=True) cmd = [ "ffmpeg", "-y", "-ss", str(start_time), "-i", str(src), "-t", str(end_time - start_time), "-c", "copy", "-avoid_negative_ts", "make_zero", str(dst), ] result = subprocess.run(cmd, capture_output=True, text=True) if result.returncode != 0: raise RuntimeError(f"ffmpeg failed: {result.stderr}") def _convert_video_files(root: Path, new_root: Path): video_keys = _get_video_keys(root) if not video_keys: return df_episodes = _load_episodes_metadata(root) for video_key in video_keys: chunk_col = f"videos/{video_key}/chunk_index" file_col = f"videos/{video_key}/file_index" from_ts_col = f"videos/{video_key}/from_timestamp" to_ts_col = f"videos/{video_key}/to_timestamp" if chunk_col not in df_episodes.columns: logging.warning(f" Missing video metadata for {video_key}, skipping") continue for _, row in tqdm.tqdm( df_episodes.iterrows(), desc=f" Converting {video_key} videos", total=len(df_episodes), ): episode_index = int(row["episode_index"]) src = root / DEFAULT_VIDEO_PATH.format( video_key=video_key, chunk_index=int(row[chunk_col]), file_index=int(row[file_col]), ) if not src.exists(): logging.warning(f" Source video not found: {src}") continue legacy_chunk = episode_index // DEFAULT_CHUNK_SIZE dst = new_root / LEGACY_VIDEO_PATH.format( episode_chunk=legacy_chunk, video_key=video_key, episode_index=episode_index, ) _split_video(src, dst, float(row[from_ts_col]), float(row[to_ts_col])) def _convert_info(root: Path, new_root: Path): info = load_info(root) df_episodes = _load_episodes_metadata(root) num_episodes = len(df_episodes) total_chunks = (num_episodes // DEFAULT_CHUNK_SIZE) + (1 if num_episodes % DEFAULT_CHUNK_SIZE else 0) info["codebase_version"] = V21 info["total_chunks"] = total_chunks info["total_videos"] = num_episodes * len(_get_video_keys(root)) info.pop("data_files_size_in_mb", None) info.pop("video_files_size_in_mb", None) info["data_path"] = LEGACY_DATA_PATH if info.get("video_path") is not None: info["video_path"] = LEGACY_VIDEO_PATH for key in info["features"]: if "fps" in info["features"][key] and info["features"][key]["dtype"] != "video": del info["features"][key]["fps"] write_info(info, new_root) def convert_v30_to_v21(v30_path: Path) -> Path: """ Convert a v3.0 dataset to v2.1, saving the result at {v30_path}_v21. The original v3.0 dataset is left intact. Returns the path to the new v2.1 dataset. """ info_path = v30_path / "meta" / "info.json" if not info_path.exists(): raise FileNotFoundError(f"No info.json at {v30_path}") with open(info_path) as f: version = json.load(f).get("codebase_version", "unknown") if version != V30: raise ValueError(f"Expected v3.0 dataset, got {version}") v21_path = v30_path.parent / f"{v30_path.name}_v21" if v21_path.exists(): logging.info(f" Removing existing v2.1 dir: {v21_path}") shutil.rmtree(v21_path) logging.info(f" Converting {v30_path.name} → {v21_path.name}") _convert_info(v30_path, v21_path) _convert_tasks_to_jsonl(v30_path, v21_path) _convert_episodes_to_jsonl(v30_path, v21_path) _convert_data_files(v30_path, v21_path) _convert_video_files(v30_path, v21_path) return v21_path # ══════════════════════════════════════════════════════════════════════════════ # Pipeline orchestration # ══════════════════════════════════════════════════════════════════════════════ def run_pipeline(args): logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s") # ── Determine output path ───────────────────────────────────────────────── # Single-process: HF_LEROBOT_HOME / repo_id # Multi-process: HF_LEROBOT_HOME / final_dataset_repo_root / task_name if args.num_process > 1: v30_path = Path(HF_LEROBOT_HOME) / args.final_dataset_repo_root / args.task repo_id = f"{args.final_dataset_repo_root}_temp/{args.task}" else: repo_id = f"{args.final_dataset_repo_root}/{args.task}" v30_path = Path(HF_LEROBOT_HOME) / repo_id # ── Step 1: MCAP → v3.0 ────────────────────────────────────────────────── print(f"\n{'='*60}") print(f"Step 1: MCAP → LeRobot v3.0 (mode={args.mode})") print(f" task: {args.task}") print(f" robot_type: {args.robot_type}") print(f" num_process: {args.num_process}") print(f" output: {v30_path}") print(f"{'='*60}") if args.mode == "full": # Determine HIL filter filter_action_types = None if args.action_types: filter_action_types = set(args.action_types) elif args.hil_filter: filter_action_types = DEFAULT_HIL_ACTION_TYPES convert_task_to_lerobot( task_name=args.task, repo_id=repo_id, robot_type=args.robot_type, num_processes=args.num_process, tasks_json_path=args.tasks_json_path, dataset_root=args.dataset_root, filter_action_types=filter_action_types, final_dataset_repo_root=args.final_dataset_repo_root, ) elif args.mode == "dagger": convert_task_to_lerobot_dagger( task_name=args.task, repo_id=repo_id, robot_type=args.robot_type, num_processes=args.num_process, tasks_json_path=args.tasks_json_path, dataset_root=args.dataset_root, min_segment_length=args.min_segment_length, action_threshold=args.action_threshold, final_dataset_repo_root=args.final_dataset_repo_root, ) else: raise ValueError(f"Unknown mode: {args.mode}. Use 'full' or 'dagger'.") if not v30_path.exists(): raise RuntimeError( f"Conversion completed but dataset not found at expected path: {v30_path}\n" f"Check HF_LEROBOT_HOME ({HF_LEROBOT_HOME}) and final_dataset_repo_root." ) # ── Step 2: Fix bugs ────────────────────────────────────────────────────── print(f"\n{'='*60}") print("Step 2: Fix dataset bugs") print(f" dataset: {v30_path}") print(f"{'='*60}") run_fixes(v30_path, fix_gripper_flag=not args.no_fix_gripper) # ── Step 3: v3.0 → v2.1 ────────────────────────────────────────────────── if args.no_v21: print("\nStep 3: Skipped (--no_v21)") else: print(f"\n{'='*60}") print("Step 3: v3.0 → v2.1") print(f"{'='*60}") v21_path = convert_v30_to_v21(v30_path) print(f" ✓ v2.1 dataset saved to: {v21_path}") print(f"\n{'='*60}") print("Pipeline complete!") print(f" v3.0: {v30_path}") if not args.no_v21: print(f" v2.1: {v30_path.parent / (v30_path.name + '_v21')}") print(f"{'='*60}\n") # ══════════════════════════════════════════════════════════════════════════════ # Entry point # ══════════════════════════════════════════════════════════════════════════════ def main(): parser = argparse.ArgumentParser( description="Unified MCAP → LeRobot pipeline (v3.0 + fix + v2.1)", formatter_class=argparse.ArgumentDefaultsHelpFormatter, ) # ── required ────────────────────────────────────────────────────────────── parser.add_argument("--task", type=str, required=True, help="Task name (key in tasks_json_path)") parser.add_argument("--robot_type", type=str, required=True, help="Robot type: 'arx' or 'piper'") # ── paths ───────────────────────────────────────────────────────────────── parser.add_argument("--tasks_json_path", type=str, default=TASKS_JSON_PATH, help="Path to tasks JSON mapping task names to episode folders") parser.add_argument("--dataset_root", type=str, default=DATASET_ROOT, help="Root directory containing raw MCAP episode folders") parser.add_argument("--final_dataset_repo_root", type=str, default="we_d900", help="Subdirectory under HF_LEROBOT_HOME for the output dataset") # ── conversion mode ─────────────────────────────────────────────────────── parser.add_argument("--mode", type=str, default="full", choices=["full", "dagger"], help="'full' = full episode per MCAP; 'dagger' = teleop segments only") parser.add_argument("--num_process", type=int, default=1, help="Number of parallel worker processes") # ── full mode options ───────────────────────────────────────────────────── parser.add_argument("--hil_filter", action="store_true", help="[full mode] Keep only INFERENCE+TELEOP frames (HIL filtering)") parser.add_argument("--action_types", type=str, nargs="+", default=None, help="[full mode] Custom action types to keep (overrides --hil_filter)") # ── dagger mode options ─────────────────────────────────────────────────── parser.add_argument("--min_segment_length", type=int, default=10, help="[dagger mode] Minimum teleop segment length (frames)") parser.add_argument("--action_threshold", type=float, default=10.0, help="[dagger mode] Discard segments with max|action| above this value") # ── fix options ─────────────────────────────────────────────────────────── parser.add_argument("--no_fix_gripper", action="store_true", help="Disable auto gripper rescaling. By default the script detects " "files with gripper in [0,0.08] range and rescales to [0,1] automatically.") # ── output options ──────────────────────────────────────────────────────── parser.add_argument("--no_v21", action="store_true", help="Skip v2.1 conversion (keep v3.0 only)") args = parser.parse_args() run_pipeline(args) if __name__ == "__main__": main()