""" Convert mcap files to lerobot format within a single file. Supports Human-in-the-Loop (HIL) data filtering by action_type. Example Usage: Notice: if use multiprocessing, please make sure the repo id is a temperary repo (e.g., we_d900_temp/accessory-return) to avoid multiple processes pushing to the same repo at the same time. After the conversion is done, you can rename the repo to the final name (e.g., we_d900/accessory-return). 1. Normal teleoperation data processing -> Without HIL filtering (keep all actions): python posttraining/scripts/dataset/convert_mcap_to_lerobot.py \ --task 'accessory-return' \ --num_process 40 \ --robot_type arx \ --repo_id we_d900_temp/accessory-return \ --final_dataset_repo_root we_d900 \ --tasks_json_path /home/shiduozhang/projects/tasks_hil.json \ --dataset_root /nas/volume1/scratch/datasets \ 2. Generate human-in-the-loop (HIL) data with filtering: python posttraining/scripts/dataset/convert_mcap_to_lerobot.py \ --task 'accessory-return' \ --num_process 40 \ --robot_type arx \ --repo_id we_d900_temp/accessory-return \ --final_dataset_repo_root we_d900 \ --tasks_json_path /home/shiduozhang/projects/tasks_hil.json \ --dataset_root /nas/volume1/scratch/datasets \ --hil_filter 3. With custom action types, e.g. only keep "teleop": python posttraining/scripts/dataset/convert_mcap_to_lerobot.py --task 'accessory-return' \ --num_process 40 \ --robot_type arx \ --repo_id we_d900_temp/accessory-return \ --final_dataset_repo_root we_d900 \ --tasks_json_path /home/shiduozhang/projects/tasks_hil.json \ --dataset_root /nas/volume1/scratch/datasets \ --action_types ["teleop"] """ from pathlib import Path import gc import os import cv2 import tqdm import json import subprocess import numpy as np import logging import shutil import pandas as pd from typing import Literal from mcap.reader import make_reader from lerobot.utils.constants import HF_LEROBOT_HOME from lerobot.datasets.lerobot_dataset import LeRobotDataset from typing import Iterable from foxglove_schemas_protobuf.CompressedImage_pb2 import CompressedImage from foxglove_schemas_protobuf.FrameTransforms_pb2 import FrameTransforms from packaging import version from concurrent.futures import ProcessPoolExecutor from lerobot.datasets.utils import load_tasks import pyarrow as pa import pyarrow.parquet as pq import dataclasses import argparse logger = logging.getLogger() DATASET_ROOT = "/nas/volume1/scratch/datasets" TASKS_JSON_PATH = "/home/shiduozhang/projects/tasks_hil.json" # Default commander_state values to keep for HIL data DEFAULT_HIL_ACTION_TYPES = {"INFERENCE", "TELEOP"} def load_task_folders(task_name: str, tasks_json_path: str = TASKS_JSON_PATH) -> list[str]: """ Load folder names for a specific task from tasks_merged.json. Args: task_name: The task name to look up tasks_json_path: Path to the tasks_merged.json file Returns: List of folder names for the task """ import json with open(tasks_json_path, "r", encoding="utf-8") as f: tasks = json.load(f) if task_name not in tasks: available_tasks = list(tasks.keys()) raise ValueError(f"Task '{task_name}' not found. Available tasks: {available_tasks}") return tasks[task_name] def get_mcap_info_from_folder(folder_path: str) -> tuple[str | None, str]: """ Get mcap file path and version from a folder. Args: folder_path: Path to the folder containing mcap and metadata.json Returns: Tuple of (mcap_file_path, mcap_version) """ import json from glob import glob # Find mcap file (recursively) mcap_files = glob(os.path.join(folder_path, "**/*.mcap"), recursive=True) if not mcap_files: # Fallback to non-recursive search mcap_files = glob(os.path.join(folder_path, "*.mcap")) if not mcap_files: logger.warning(f"No mcap file found in {folder_path}") return None, "1.12.7" # Default version mcap_path = mcap_files[0] # Read metadata.json for version metadata_path = os.path.join(folder_path, "metadata.json") mcap_version = "1.12.7" # Default version if os.path.exists(metadata_path): try: with open(metadata_path, "r", encoding="utf-8") as f: metadata = json.load(f) mcap_version = metadata.get("version", metadata.get("mcap_version", "1.12.7")) except Exception as e: logger.warning(f"Error reading metadata from {metadata_path}: {e}") return mcap_path, mcap_version ############################################# Protobuf Types ############################################# # -*- coding: utf-8 -*- # Generated by the protocol buffer compiler. DO NOT EDIT! # NO CHECKED-IN PROTOBUF GENCODE # source: robotics.proto # Protobuf Python Version: 5.29.4 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x0erobotics.proto\x12\x0cworld_engine\x1a\x1fgoogle/protobuf/timestamp.proto"\xc0\x01\n\x10RobotObservation\x12\x17\n\x0fjoint_positions\x18\x01 \x03(\x01\x12\x0e\n\x06\x65\x65_pos\x18\x02 \x03(\x01\x12-\n\ttimestamp\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x18\n\x10joint_velocities\x18\x04 \x03(\x01\x12\x10\n\x08\x63urrents\x18\x05 \x03(\x01\x12\x0f\n\x07torques\x18\x06 \x03(\x01\x12\x17\n\x0f\x63ommander_state\x18\x07 \x01(\t"L\n\x0bRobotAction\x12\x0e\n\x06\x61\x63tion\x18\x01 \x03(\x01\x12-\n\ttimestamp\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.Timestamp"\xbe\x02\n\x0eSyncTimestamps\x12:\n\x16robot_action_timestamp\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12?\n\x1brobot_observation_timestamp\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x38\n\x14top_camera_timestamp\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x39\n\x15left_camera_timestamp\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12:\n\x16right_camera_timestamp\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.Timestampb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "robotics_pb2", _globals) if not _descriptor._USE_C_DESCRIPTORS: DESCRIPTOR._loaded_options = None _globals["_ROBOTOBSERVATION"]._serialized_start = 66 _globals["_ROBOTOBSERVATION"]._serialized_end = 258 _globals["_ROBOTACTION"]._serialized_start = 260 _globals["_ROBOTACTION"]._serialized_end = 336 _globals["_SYNCTIMESTAMPS"]._serialized_start = 339 _globals["_SYNCTIMESTAMPS"]._serialized_end = 657 # @@protoc_insertion_point(module_scope) ############################################# Dataset Config ############################################# @dataclasses.dataclass(frozen=True) class DatasetConfig: use_videos: bool = True tolerance_s: float = 0.0001 image_writer_processes: int = 10 image_writer_threads: int = 5 video_backend: str | None = None DEFAULT_DATASET_CONFIG = DatasetConfig() ############################################# Robot Config ############################################# @dataclasses.dataclass(frozen=True) class DualArmConfig: robot_type: str = "piper" left_joint_idx: list[int] = dataclasses.field(default_factory=lambda: []) right_joint_idx: list[int] = dataclasses.field(default_factory=lambda: []) arm_joint_idx: list[int] = dataclasses.field(default_factory=lambda: []) # Exclude gripper motors: list[str] = dataclasses.field(default_factory=lambda: []) camera_keys: list[str] = dataclasses.field(default_factory=lambda: []) cam_key_maps: dict[str, str] = dataclasses.field(default_factory=lambda: {}) @dataclasses.dataclass(frozen=True) class DualPiperConfig(DualArmConfig): robot_type: str = "piper" left_joint_idx: list[int] = dataclasses.field(default_factory=lambda: [0, 1, 2, 3, 4, 5, 6]) right_joint_idx: list[int] = dataclasses.field(default_factory=lambda: [7, 8, 9, 10, 11, 12, 13]) arm_joint_idx: list[int] = dataclasses.field(default_factory=lambda: [0, 1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12]) # Exclude gripper motors: list[str] = dataclasses.field( default_factory=lambda: [ "left_waist", "left_shoulder", "left_elbow", "left_forearm_roll", "left_wrist_angle", "left_wrist_rotate", "left_gripper", "right_waist", "right_shoulder", "right_elbow", "right_forearm_roll", "right_wrist_angle", "right_wrist_rotate", "right_gripper", ] ) camera_keys: list[str] = dataclasses.field( default_factory=lambda: [ "left_camera", "right_camera", "top_camera", ] ) cam_key_maps: dict[str, str] = dataclasses.field( default_factory=lambda: { "left_camera": "cam_left_wrist", "right_camera": "cam_right_wrist", "top_camera": "cam_high", } ) @dataclasses.dataclass(frozen=True) class DualArxConfig(DualArmConfig): robot_type: str = "arx" left_joint_idx: list[int] = dataclasses.field(default_factory=lambda: [0, 1, 2, 3, 4, 5, 6]) right_joint_idx: list[int] = dataclasses.field(default_factory=lambda: [7, 8, 9, 10, 11, 12, 13]) arm_joint_idx: list[int] = dataclasses.field(default_factory=lambda: [0, 1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12]) # Exclude gripper motors: list[str] = dataclasses.field( default_factory=lambda: [ "left_waist", "left_shoulder", "left_elbow", "left_forearm_roll", "left_wrist_angle", "left_wrist_rotate", "left_gripper", "right_waist", "right_shoulder", "right_elbow", "right_forearm_roll", "right_wrist_angle", "right_wrist_rotate", "right_gripper", ] ) camera_keys: list[str] = dataclasses.field( default_factory=lambda: [ "left_camera", "right_camera", "top_camera", ] ) cam_key_maps: dict[str, str] = dataclasses.field( default_factory=lambda: { "left_camera": "cam_left_wrist", "right_camera": "cam_right_wrist", "top_camera": "cam_high", } ) ############################################# LeRobot Utils ############################################# def create_empty_dataset( repo_id: str, robot_type: str, mode: Literal["video", "image"] = "video", *, dataset_config: DatasetConfig = DEFAULT_DATASET_CONFIG, fps=60, image_size: tuple[int, int] = (320, 180), cam_key_maps: dict[str, str] = {}, motors: list[str] = [], generate_vel: bool = False, record_mcap_path: bool = False, ) -> LeRobotDataset: """Create an empty LeRobot dataset.""" cameras = list(cam_key_maps.values()) features = { "observation.state": { "dtype": "float32", "shape": (len(motors),), "names": motors, }, "observation.commander_state": { "dtype": "string", "shape": (1,), "names": ["commander_states"], }, "action": { "dtype": "float32", "shape": (len(motors),), "names": motors, }, } if record_mcap_path: features["mcap_path"] = { "dtype": "string", "shape": (1,), "names": ["mcap_path"], } if generate_vel: features["observation.velocity"] = { "dtype": "float32", "shape": (len(motors),), "names": motors, } features["action_vel"] = { "dtype": "float32", "shape": (len(motors),), "names": motors, } for cam in cameras: features[f"observation.images.{cam}"] = { "dtype": mode, "shape": (image_size[1], image_size[0], 3), "names": [ "height", "width", "channels", ], } features["subtask"] = { "dtype": "string", "shape": (1,), "names": ["subtask"], } if Path(HF_LEROBOT_HOME / repo_id).exists(): shutil.rmtree(HF_LEROBOT_HOME / repo_id) dataset = LeRobotDataset.create( repo_id=repo_id, fps=fps, robot_type=robot_type, features=features, use_videos=dataset_config.use_videos, tolerance_s=dataset_config.tolerance_s, image_writer_processes=dataset_config.image_writer_processes, image_writer_threads=dataset_config.image_writer_threads, video_backend=dataset_config.video_backend, ) dataset.meta.update_chunk_settings(data_files_size_in_mb=0, video_files_size_in_mb=0) return dataset def check_mcap_validity(data_dict_chunk: dict, action_threshold: float = 10.0) -> bool: actions_raw = data_dict_chunk["actions"] if np.max(np.abs(actions_raw)) > action_threshold: mcap_info = data_dict_chunk.get("mcap_path", "unknown") logger.warning( f"Skipping mcap file {mcap_info}: max abs actions value " f"{np.max(np.abs(actions_raw)):.4f} exceeds {action_threshold}" ) return True return False def populate_dataset_from_raw_loader( dataset: LeRobotDataset, raw_episode_loader: Iterable[dict], cam_keys: list[str], cam_key_maps: dict[str, str], task: str | list[str] = "Do something", generate_vel: bool = False, chunk_size: int = 1000, record_mcap_path: bool = False, ): """Populate a LeRobot dataset from a raw data loader.""" pbar = tqdm.tqdm(total=len(raw_episode_loader)) skip_current_episode = False is_first_chunk_of_episode = True # Track first chunk to avoid orphaned frames for is_new_episode, data_dict_chunk in raw_episode_loader: if is_new_episode: # Update the episode index if not skip_current_episode: dataset.save_episode() pbar.update(1) skip_current_episode = False # Reset for new episode is_first_chunk_of_episode = True # New episode starts # Only check validity on the FIRST chunk of each episode. # Checking on later chunks is unsafe: frames from earlier chunks are already # in the LeRobot buffer and cannot be undone, so setting skip_current_episode=True # mid-episode leaves orphan frames that corrupt the next episode. if is_first_chunk_of_episode: skip_current_episode = check_mcap_validity(data_dict_chunk) is_first_chunk_of_episode = False if skip_current_episode: continue num_frames_chunk = len(data_dict_chunk["joint_poses"]) camera_images = {key: data_dict_chunk["camera_images"][key] for key in cam_keys} valid_frames = list(range(num_frames_chunk)) joint_poses = data_dict_chunk["joint_poses"][valid_frames] ee_poses = data_dict_chunk["ee_poses"][valid_frames] if "commander_states" in data_dict_chunk: commander_states = [data_dict_chunk["commander_states"][i].lower() for i in valid_frames] else: commander_states = ["teleop"] * len(valid_frames) actions = data_dict_chunk["actions"][valid_frames] if generate_vel: joint_vel = data_dict_chunk["joint_vel"][valid_frames] actions_vel = data_dict_chunk["actions_vel"][valid_frames] for cam_key in cam_keys: camera_images[cam_key] = data_dict_chunk["camera_images"][cam_key][valid_frames] num_frames_chunk = len(joint_poses) # Get mcap_path if recording mcap_path = data_dict_chunk.get("mcap_path", "") if record_mcap_path else None if "task" in data_dict_chunk: task_episode = data_dict_chunk["task"] elif task is None: task_episode = "Do something" else: task_episode = task for frame_idx in range(num_frames_chunk): # FIXME: Allow the episode to change task within the episode frame = { "task": task_episode[frame_idx] if isinstance(task_episode, list) else task_episode, "observation.state": joint_poses[frame_idx], "action": actions[frame_idx], } if generate_vel: frame["observation.velocity"] = joint_vel[frame_idx] frame["action_vel"] = actions_vel[frame_idx] frame["observation.commander_state"] = commander_states[frame_idx] if record_mcap_path and mcap_path: frame["mcap_path"] = mcap_path for cam_key in cam_keys: frame[f"observation.images.{cam_key_maps[cam_key]}"] = camera_images[cam_key][frame_idx] frame["subtask"] = "TODO" # TODO: add subtask annotation dataset.add_frame(frame) # Save the last episode if not skip_current_episode: dataset.save_episode() pbar.update(1) pbar.close() ############################################# Utils ############################################# def resize_image(img_str, resize=True, image_size: tuple[int, int] = (320, 180)): # Handle case where input is already bytes if isinstance(img_str, bytes): img_bytes = img_str else: # Original code for hex string img_bytes = bytes.fromhex(img_str) img_np = np.frombuffer(img_bytes, dtype=np.uint8) img = cv2.imdecode(img_np, cv2.IMREAD_COLOR) if resize: img = cv2.resize(img, (image_size[0], image_size[1])) # Convert rgb to bgr img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) return img ############################################# Load raw data from mcap ############################################# def read_mcap_msg(mcap_path, cam_keys: list[str]): """ Read messages from an MCAP file. Args: mcap_path: Path to the MCAP file """ # Verify file exists if not os.path.exists(mcap_path): raise FileNotFoundError(f"MCAP file not found at {mcap_path}") # Dictionary to store message type handlers handlers = { "robot_observation": RobotObservation, "robot_action": RobotAction, "sync_timestamps": SyncTimestamps, "/tf": FrameTransforms, } for cam_key in cam_keys: handlers[cam_key] = CompressedImage # Statistics to track message counts message_counts = {topic: 0 for topic in handlers.keys()} messages = [] # Open and read the MCAP file with open(mcap_path, "rb") as f: reader = make_reader(f) # Iterate through all messages for schema, channel, message in reader.iter_messages(): # Get the appropriate message handler if channel.topic in handlers: message_type = handlers[channel.topic] parsed_msg = message_type() parsed_msg.ParseFromString(message.data) # Update message count message_counts[channel.topic] += 1 # Read out data based topic if channel.topic == "robot_observation": data = { "joint_positions": parsed_msg.joint_positions, "joint_velocities": parsed_msg.joint_velocities, "ee_pose": parsed_msg.ee_pos, "currents": parsed_msg.currents, "torques": parsed_msg.torques, "commander_state": parsed_msg.commander_state, } timestamp = parsed_msg.timestamp.ToNanoseconds() elif channel.topic == "robot_action": data = parsed_msg.action timestamp = parsed_msg.timestamp.ToNanoseconds() elif channel.topic == "sync_timestamps": data = { f"{k}_timestamp": parsed_msg.__getattribute__(f"{k}_timestamp").ToNanoseconds() for k in handlers.keys() if hasattr(parsed_msg, f"{k}_timestamp") } timestamp = min(data.values()) elif channel.topic in cam_keys: data = parsed_msg.data timestamp = parsed_msg.timestamp.ToNanoseconds() elif channel.topic == "tf": data = parsed_msg.data timestamp = parsed_msg.timestamp.ToNanoseconds() messages.append( { "timestamp": timestamp, "data": data, "channel": channel.topic, "schema": schema, } ) return messages def read_mcap_file(file_path, cam_keys: list[str]): """ Read messages from an MCAP file """ messages = read_mcap_msg(file_path, cam_keys=cam_keys) robot_joint_pos = {} robot_action = {} robo_ee_pose = {} commander_state = {} camera_images = {key: {} for key in cam_keys} sync_timestamps = {} for message in messages: data = message["data"] if message["channel"] == "robot_observation": robot_joint_pos[message["timestamp"]] = data["joint_positions"] commander_state[message["timestamp"]] = data["commander_state"] robo_ee_pose[message["timestamp"]] = data["ee_pose"] elif message["channel"] == "robot_action": robot_action[message["timestamp"]] = data elif message["channel"] in cam_keys: camera_images[message["channel"]][message["timestamp"]] = data elif message["channel"] == "sync_timestamps": sync_timestamps[message["timestamp"]] = data return { "robot_joint_pos": robot_joint_pos, "robot_action": robot_action, "robo_ee_pose": robo_ee_pose, "commander_state": commander_state, "camera_images": camera_images, "sync_timestamps": sync_timestamps, } def load_timed_data_from_mcap( mcap_file: str, cam_keys, fps=60, start_frame=0, max_frame=None, resize=True, image_size: tuple[int, int] = (320, 180), mcap_version: str = "0.0.0", generate_vel: bool = False, chunk_size: int = 1000, # Process data in chunks to reduce memory pressure robot_type: str = "piper", filter_action_types: set[str] | None = None, # HIL: action types to keep ): """Load the timed data from mcap with a given fps. Args: mcap_file: Path to the MCAP file cam_keys: List of camera keys fps: Frames per second start_frame: Starting frame index max_frame: Maximum number of frames to process resize: Whether to resize images image_size: Target image size (width, height) mcap_version: MCAP version string generate_vel: Whether to generate velocity data chunk_size: Process data in chunks robot_type: Type of robot filter_action_types: Set of action types to keep (e.g., {"inference", "teleoperation"}). If None, all actions are kept. """ # Read MCAP file mcap_dict = read_mcap_file(mcap_file, cam_keys=cam_keys) ds_sync_timestamps = mcap_dict["sync_timestamps"] # If there are no explicit sync_timestamps in the MCAP, build a fallback # nearest-neighbor synchronization using robot_observation timestamps as the # reference timeline and matching camera & action timestamps to the closest # available times. This keeps behavior robust when recordings don't emit # a dedicated sync message. if not ds_sync_timestamps: logger.info("No sync_timestamps found in MCAP; building fallback nearest-neighbor sync using camera as reference") from bisect import bisect_left def nearest(sorted_list, value): if not sorted_list: return None i = bisect_left(sorted_list, value) if i == 0: return sorted_list[0] if i == len(sorted_list): return sorted_list[-1] before = sorted_list[i - 1] after = sorted_list[i] if abs(after - value) < abs(value - before): return after else: return before # tolerance for matching (seconds -> nanoseconds). fallback_tol_s = max(DEFAULT_DATASET_CONFIG.tolerance_s, 1.0 / fps / 2.0) tol_ns = int(fallback_tol_s * 1e9) # prepare sorted timestamp lists obs_ts = sorted(mcap_dict["robot_joint_pos"].keys()) action_ts = sorted(mcap_dict["robot_action"].keys()) cam_ts_map = {k: sorted(mcap_dict["camera_images"][k].keys()) for k in cam_keys} # Use the first camera as the reference timeline reference_cam_key = cam_keys[0] reference_cam_ts = cam_ts_map.get(reference_cam_key, []) if not reference_cam_ts: logger.warning(f"Reference camera {reference_cam_key} has no timestamps") ds_sync_timestamps = {} else: ds_sync_timestamps = {} for cam_t in reference_cam_ts: sync = {} sync[f"{reference_cam_key}_timestamp"] = cam_t # nearest robot observation no = nearest(obs_ts, cam_t) if no is None or abs(no - cam_t) > tol_ns: continue sync["robot_observation_timestamp"] = no # nearest action na = nearest(action_ts, cam_t) if na is None or abs(na - cam_t) > tol_ns: continue sync["robot_action_timestamp"] = na # nearest timestamps for other cameras skip = False for cam_key in cam_keys: if cam_key == reference_cam_key: continue # already added nc = nearest(cam_ts_map.get(cam_key, []), cam_t) if nc is None or abs(nc - cam_t) > tol_ns: # If camera is missing or too far from reference camera, skip this frame skip = True break sync[f"{cam_key}_timestamp"] = nc if skip: continue # use reference camera timestamp as the dict key for ordering ds_sync_timestamps[cam_t] = sync # Pre-allocate arrays for the current chunk chunk_joint_poses = [] chunk_ee_poses = [] chunk_commander_states = [] chunk_actions = [] chunk_camera_images = {key: [] for key in cam_keys} episode_length = 0 has_zero_ts = False has_missing_ts = False filtered_count = 0 # Count of frames filtered by action_type # Process timestamps in sorted order sorted_timestamps = sorted(ds_sync_timestamps.keys()) total_frames = len(sorted_timestamps) for idx, key in enumerate(sorted_timestamps): if idx < start_frame: continue if max_frame is not None and idx >= (start_frame + max_frame): break sync_ts = ds_sync_timestamps[key] # Skip if any camera timestamp is None or 0 is_zero_ts = False for cam_key in cam_keys: if sync_ts[f"{cam_key}_timestamp"] is None or sync_ts[f"{cam_key}_timestamp"] == 0: is_zero_ts = True break if is_zero_ts: has_zero_ts = True continue # Check existence of sync_ts in all camera_images is_missing_ts = False for cam_key in cam_keys: if sync_ts[f"{cam_key}_timestamp"] not in mcap_dict["camera_images"][cam_key]: logger.warning(f"Sync timestamp {sync_ts[f'{cam_key}_timestamp']} not found in {cam_key} camera images, mcap file: {mcap_file}") is_missing_ts = True break if is_missing_ts: has_missing_ts = True continue # HIL Filtering: Check commander_state and skip if not in filter set if filter_action_types is not None: obs_ts = sync_ts["robot_observation_timestamp"] cmd_state = mcap_dict["commander_state"].get(obs_ts, "") if cmd_state not in filter_action_types: filtered_count += 1 continue episode_length += 1 # Process current frame joint_pos = np.array(mcap_dict["robot_joint_pos"][sync_ts["robot_observation_timestamp"]]).reshape(1, -1) ee_pos = np.array(mcap_dict["robo_ee_pose"][sync_ts["robot_observation_timestamp"]]).reshape(1, -1) commander_state = mcap_dict["commander_state"][sync_ts["robot_observation_timestamp"]] if filter_action_types is not None: commander_state = "ap_" + commander_state.lower() # Prefix with "ap_" to indicate it's autopilot state (e.g., "ap_inference", "ap_teleop") action = np.array(mcap_dict["robot_action"][sync_ts["robot_action_timestamp"]]).reshape(1, -1) # Append to current chunk chunk_joint_poses.append(joint_pos) chunk_ee_poses.append(ee_pos) chunk_commander_states.append(commander_state) chunk_actions.append(action) # Process images for cam_key in cam_keys: img_data = mcap_dict["camera_images"][cam_key][sync_ts[f"{cam_key}_timestamp"]] img = resize_image(img_data, resize=resize, image_size=image_size) chunk_camera_images[cam_key].append(img) # Process chunk if it reaches the specified size or we're at the end if len(chunk_joint_poses) >= chunk_size or idx == total_frames - 1: # Skip if no data in chunk (all frames were filtered) if len(chunk_joint_poses) == 0: continue # Convert lists to numpy arrays joint_poses_chunk = np.concatenate(chunk_joint_poses, axis=0).astype(np.float32) ee_poses_chunk = np.concatenate(chunk_ee_poses, axis=0).astype(np.float32) actions_chunk = np.concatenate(chunk_actions, axis=0).astype(np.float32) # Version-aware action normalization if version.parse(mcap_version) <= version.parse("1.10.1"): actions_chunk[:, 6] = actions_chunk[:, 6] / 0.08 actions_chunk[:, 13] = actions_chunk[:, 13] / 0.08 # if robot_type == "arx" and version.parse(mcap_version) <= version.parse("1.12.7"): # actions_chunk[:, 6] = actions_chunk[:, 6] * 0.08 # actions_chunk[:, 13] = actions_chunk[:, 13] * 0.08 # Process camera images camera_images_chunk = {} for cam_key in cam_keys: camera_images_chunk[cam_key] = np.stack(chunk_camera_images[cam_key], axis=0).astype(np.uint8) # Generate velocities if requested if generate_vel: joint_vel_chunk = np.diff(joint_poses_chunk, axis=0) joint_vel_chunk = np.concatenate([joint_vel_chunk, np.zeros((1, joint_vel_chunk.shape[1]))], axis=0).astype(np.float32) actions_vel_chunk = np.diff(actions_chunk, axis=0) actions_vel_chunk = np.concatenate([actions_vel_chunk, np.zeros((1, actions_vel_chunk.shape[1]))], axis=0).astype(np.float32) # Yield the current chunk chunk_data = { "joint_poses": joint_poses_chunk, "ee_poses": ee_poses_chunk, "commander_states": chunk_commander_states, "actions": actions_chunk, "camera_images": camera_images_chunk, "info": { "has_zero_ts": has_zero_ts, "has_missing_ts": has_missing_ts, "filtered_count": filtered_count, # Include filtered count in info }, } if generate_vel: chunk_data["joint_vel"] = joint_vel_chunk chunk_data["actions_vel"] = actions_vel_chunk yield chunk_data # Clear chunk data chunk_joint_poses = [] chunk_ee_poses = [] chunk_commander_states = [] chunk_actions = [] chunk_camera_images = {key: [] for key in cam_keys} # Force garbage collection gc.collect() # Log filtering statistics if filter_action_types is not None and filtered_count > 0: logger.info(f"HIL filtering: {filtered_count} frames filtered out (kept action_types: {filter_action_types})") ############################################# Generate LeRobot Dataset ############################################# class McapDataLoader: """ Load data from mcap files and convert to LeRobot format. McapDataLoader load mcap in chunks to reduce memory pressure. """ def __init__( self, mcap_files: list[str], mcap_versions: list[str], cam_keys: list[str], image_size: tuple[int, int], generate_vel: bool = False, chunk_size: int = 1000, robot_type: str = "piper", record_mcap_path: bool = False, filter_action_types: set[str] | None = None, # HIL: action types to keep ): self.mcap_files = mcap_files self.mcap_versions = mcap_versions self.cam_keys = cam_keys self.image_size = image_size self.generate_vel = generate_vel self.episode_idx = 0 self.chunk_size = chunk_size self.robot_type = robot_type self.record_mcap_path = record_mcap_path self.filter_action_types = filter_action_types def __len__(self): return len(self.mcap_files) def __iter__(self): while self.episode_idx < len(self.mcap_files): mcap_file = self.mcap_files[self.episode_idx] mcap_version = self.mcap_versions[self.episode_idx] print(f"Processing {mcap_file} with version {mcap_version}") # Ensure the loop variable exists even if the loader yields nothing data_dict_chunk = None for _i, data_dict_chunk in enumerate(load_timed_data_from_mcap( mcap_file, cam_keys=self.cam_keys, image_size=self.image_size, mcap_version=mcap_version, generate_vel=self.generate_vel, chunk_size=self.chunk_size, robot_type=self.robot_type, filter_action_types=self.filter_action_types, # Pass HIL filter )): # Add mcap_path to chunk data if recording if self.record_mcap_path: data_dict_chunk["mcap_path"] = mcap_file yield (_i == 0) and (self.episode_idx != 0), data_dict_chunk # Clear memory (only delete if assigned) if data_dict_chunk is not None: del data_dict_chunk # Collect garbage gc.collect() # Increment episode index self.episode_idx += 1 def populate_dataset_from_mcap( task: str | list[str], dataset: LeRobotDataset, mcap_files: list[str], mcap_versions: list[str], episodes: list[int] | None = None, image_size: tuple[int, int] = (320, 180), cam_keys: list[str] = ["top_camera", "left_camera", "right_camera"], cam_key_maps: dict[str, str] = { "top_camera": "cam_high", "left_camera": "cam_left_wrist", "right_camera": "cam_right_wrist", }, arm_joint_idx: list[int] = [0, 1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12], generate_vel: bool = False, chunk_size: int = 1000, robot_type: str = "piper", record_mcap_path: bool = False, filter_action_types: set[str] | None = None, # HIL: action types to keep ) -> LeRobotDataset: """ Populate the dataset with the raw data from the mcap files. Args: dataset: The dataset to populate. mcap_files: The list of mcap files to populate the dataset with. mcap_versions: The list of mcap versions corresponding to the mcap files. episodes: The list of episodes to populate the dataset with. image_size: The size of the images to resize to. generate_vel: Whether to generate velocity data. record_mcap_path: Whether to record mcap path in the dataset. filter_action_types: Set of action types to keep (e.g., {"inference", "teleoperation"}). """ if episodes is None: episodes = range(len(mcap_files)) mcap_data_loader = McapDataLoader( mcap_files=mcap_files, mcap_versions=mcap_versions, cam_keys=cam_keys, image_size=image_size, generate_vel=generate_vel, chunk_size=chunk_size, robot_type=robot_type, record_mcap_path=record_mcap_path, filter_action_types=filter_action_types, # Pass HIL filter ) populate_dataset_from_raw_loader( dataset=dataset, raw_episode_loader=mcap_data_loader, cam_keys=cam_keys, cam_key_maps=cam_key_maps, task=task, generate_vel=generate_vel, chunk_size=chunk_size, record_mcap_path=record_mcap_path, ) def convert_mcap_to_lerobot( repo_id: str, task: str, mcap_files: list[str], mcap_versions: list[str], robot_type: str, fps: int, episodes: list[int] | None = None, push_to_hub: bool = False, mode: str = "video", image_size: tuple[int, int] = (320, 180), robot_config: DualPiperConfig = DualPiperConfig(), dataset_config: DatasetConfig = DEFAULT_DATASET_CONFIG, generate_vel: bool = False, chunk_size: int = 1000, record_mcap_path: bool = False, filter_action_types: set[str] | None = None, # HIL: action types to keep **kwargs ): if (HF_LEROBOT_HOME / repo_id).exists(): shutil.rmtree(HF_LEROBOT_HOME / repo_id) dataset = create_empty_dataset( repo_id, robot_type=robot_type, mode=mode, dataset_config=dataset_config, fps=fps, image_size=image_size, cam_key_maps=robot_config.cam_key_maps, motors=robot_config.motors, generate_vel=generate_vel, record_mcap_path=record_mcap_path, ) dataset = populate_dataset_from_mcap( task=task, dataset=dataset, mcap_files=mcap_files, mcap_versions=mcap_versions, episodes=episodes, image_size=image_size, cam_keys=robot_config.camera_keys, cam_key_maps=robot_config.cam_key_maps, arm_joint_idx=robot_config.arm_joint_idx, generate_vel=generate_vel, chunk_size=chunk_size, robot_type=robot_type, record_mcap_path=record_mcap_path, filter_action_types=filter_action_types, # Pass HIL filter ) if push_to_hub: dataset.push_to_hub() def process_worker( process_id: int, process_episodes: list[int], repo_id: str, task: str, mcap_files: list[str], mcap_versions: list[str], robot_type: str, fps: int, mode: str, image_size: tuple[int, int], dataset_config: DatasetConfig, generate_vel: bool, chunk_size: int, record_mcap_path: bool, filter_action_types: set[str] | None = None, # HIL: action types to keep ): temp_repo_id = f"{repo_id}_{process_id}" process_mcap_files = [mcap_files[i] for i in process_episodes] process_mcap_versions = [mcap_versions[i] for i in process_episodes] # Create and populate dataset for this process convert_mcap_to_lerobot( repo_id=temp_repo_id, task=task, mcap_files=process_mcap_files, mcap_versions=process_mcap_versions, robot_type=robot_type, fps=fps, episodes=process_episodes, push_to_hub=False, mode=mode, image_size=image_size, dataset_config=dataset_config, generate_vel=generate_vel, chunk_size=chunk_size, record_mcap_path=record_mcap_path, filter_action_types=filter_action_types, # Pass HIL filter ) return temp_repo_id def convert_mcap_to_lerobot_multiple_process( repo_id: str, task: str, mcap_files: list[str], mcap_versions: list[str], num_processes: int = 4, robot_type: str = "piper", fps: int = 60, episodes: list[int] | None = None, mode: Literal["video", "image"] = "video", image_size: tuple[int, int] = (320, 180), robot_config=DualPiperConfig(), dataset_config: DatasetConfig = DEFAULT_DATASET_CONFIG, generate_vel: bool = False, chunk_size: int = 1000, push_to_hub: bool = False, record_mcap_path: bool = False, filter_action_types: set[str] | None = None, # HIL: action types to keep ) -> list[str]: """ Convert MCAP files to LeRobot format using multiple processes. Each process processes a subset of episodes and saves to a temporary repo. Returns a list of temporary repo_ids that need to be merged. Args: repo_id: Base repo_id for the dataset task: Task name mcap_files: List of MCAP file paths mcap_versions: List of MCAP versions num_processes: Number of processes to use fps: Frames per second episodes: List of episode indices to process mode: Dataset mode (video or image) image_size: Size of images dataset_config: Dataset configuration generate_vel: Whether to generate velocity data filter_action_types: Set of action types to keep (e.g., {"inference", "teleoperation"}). Returns: List of temporary repo_ids that need to be merged """ if episodes is None: episodes = list(range(len(mcap_files))) # Split episodes among processes episodes_per_process = len(episodes) // num_processes remaining_episodes = len(episodes) % num_processes process_episodes = [] start_idx = 0 for i in range(num_processes): # Distribute remaining episodes among processes extra = 1 if i < remaining_episodes else 0 end_idx = start_idx + episodes_per_process + extra process_episodes.append(episodes[start_idx:end_idx]) start_idx = end_idx temp_repo_ids = [] # Create and start processes using ProcessPoolExecutor with ProcessPoolExecutor(max_workers=num_processes) as executor: futures = [] for i in range(num_processes): future = executor.submit( process_worker, i, process_episodes[i], repo_id, task, mcap_files, mcap_versions, robot_type, fps, mode, image_size, dataset_config, generate_vel, chunk_size, record_mcap_path, filter_action_types, # Pass HIL filter ) futures.append(future) # Wait for all processes to complete and collect results for future in futures: temp_repo_ids.append(future.result()) return temp_repo_ids ############################################# Convert Task to LeRobot ############################################# def convert_task_to_lerobot( task_name: str, repo_id: str | None = None, robot_type: str = "piper", fps: int = 60, mode: str = "video", image_size: tuple[int, int] = (320, 180), robot_config: DualArmConfig | None = None, dataset_config: DatasetConfig = DEFAULT_DATASET_CONFIG, generate_vel: bool = False, chunk_size: int = 1000, num_processes: int = 1, push_to_hub: bool = False, tasks_json_path: str = TASKS_JSON_PATH, dataset_root: str = DATASET_ROOT, filter_action_types: set[str] | None = None, # HIL: action types to keep, final_dataset_repo_root: str | Path = "we_d900", ): """ Convert all mcap files for a specific task to a single LeRobot dataset. Args: task_name: The task name from tasks_merged.json repo_id: Repository ID for the dataset (default: task_name with spaces replaced by underscores) robot_type: Type of robot ("piper" or "arx") fps: Frames per second mode: Dataset mode ("video" or "image") image_size: Size of images to resize to robot_config: Robot configuration (auto-selected based on robot_type if None) dataset_config: Dataset configuration generate_vel: Whether to generate velocity data chunk_size: Process data in chunks num_processes: Number of processes for parallel processing push_to_hub: Whether to push to Hugging Face Hub tasks_json_path: Path to tasks_merged.json dataset_root: Root directory containing the dataset folders filter_action_types: Set of action types to keep (e.g., {"inference", "teleoperation"}). Default is None (keep all). For HIL data, use DEFAULT_HIL_ACTION_TYPES. """ # Load folders for the task folders = load_task_folders(task_name, tasks_json_path) print(f"Found {len(folders)} folders for task '{task_name}'") # Collect mcap files and versions mcap_files = [] mcap_versions = [] for folder in tqdm.tqdm(folders, desc="Collecting mcap files"): if os.path.exists(folder): folder_path = folder elif os.path.exists(os.path.join(dataset_root, folder)): folder_path = os.path.join(dataset_root, folder) elif os.path.exists(os.path.join(dataset_root, task_name, folder)): folder_path = os.path.join(dataset_root, task_name, folder) else: raise FileNotFoundError(f"Folder {folder} not found in dataset_root {dataset_root}") mcap_path, mcap_version = get_mcap_info_from_folder(folder_path) if mcap_path: mcap_files.append(mcap_path) mcap_versions.append(mcap_version) print(f"Found {len(mcap_files)} mcap files") if not mcap_files: print("No mcap files found, exiting") return # Set default repo_id if repo_id is None: repo_id = f"worldengine/{task_name.replace(' ', '_').lower()}" # Set default robot_config based on robot_type if robot_config is None: if robot_type == "arx": robot_config = DualArxConfig() else: robot_config = DualPiperConfig() # Log HIL filtering info if filter_action_types is not None: print(f"HIL filtering enabled: keeping action_types {filter_action_types}") # Convert to LeRobot dataset config = { "mcap_files": mcap_files, "mcap_versions": mcap_versions, "robot_type": robot_type, "fps": fps, "mode": mode, "num_processes": num_processes, "image_size": image_size, "robot_config": robot_config, "dataset_config": dataset_config, "generate_vel": generate_vel, "chunk_size": chunk_size, "repo_id": repo_id, "task": task_name, "episodes": None, "push_to_hub": push_to_hub, "record_mcap_path": True, # Always record mcap path "filter_action_types": filter_action_types, # HIL filter } if num_processes > 1: temp_repo_ids = convert_mcap_to_lerobot_multiple_process(**config) if not isinstance(temp_repo_ids, list): temp_repo_ids = [temp_repo_ids] # Filter out empty temp datasets (workers that produced 0 episodes have no tasks.parquet) non_empty_repo_ids = [] for tmp_id in temp_repo_ids: tasks_parquet = Path(HF_LEROBOT_HOME) / tmp_id / "meta" / "tasks.parquet" if tasks_parquet.exists(): non_empty_repo_ids.append(tmp_id) else: print(f" Skipping empty temp dataset (0 episodes): {tmp_id}") if not non_empty_repo_ids: print("All worker datasets are empty — no episodes to merge. Aborting.") return print(f"Merging {len(non_empty_repo_ids)}/{len(temp_repo_ids)} non-empty temporary datasets...") repo_ids_str = json.dumps(non_empty_repo_ids) cmd = [ "python", "-m", "lerobot.scripts.lerobot_edit_dataset", "--repo_id", f"{final_dataset_repo_root}/{task_name}", "--operation.type", "merge", "--operation.repo_ids", repo_ids_str, "--data_files_size_in_mb", "0", "--video_files_size_in_mb", "0" ] try: result = subprocess.run( cmd, check=True, capture_output=True, text=True ) print("Command executed successfully!") print("STDOUT:", result.stdout) return result except subprocess.CalledProcessError as e: print(f"Error executing command: {e}") print("STDERR:", e.stderr) raise finally: # Delete all temp datasets (including empty ones) for repo_id in temp_repo_ids: tmp_path = Path(HF_LEROBOT_HOME) / repo_id if tmp_path.exists(): shutil.rmtree(tmp_path) else: convert_mcap_to_lerobot(**config) print(f"Dataset saved to {HF_LEROBOT_HOME / repo_id}") if __name__ == "__main__": parser = argparse.ArgumentParser(description="Convert MCAP files to LeRobot format (with HIL support).") parser.add_argument("--task", type=str, default=None, required=True, help="Task name from tasks_merged.json to convert") parser.add_argument("--num_process", type=int, default=1, help="Number of processes to use") parser.add_argument("--robot_type", type=str, default="piper", help="Type of robot (e.g., 'arx', 'piper')") parser.add_argument("--repo_id", type=str, default=None, help="Repository ID for the dataset") parser.add_argument("--fps", type=int, default=60, help="Frames per second") parser.add_argument("--tasks_json_path", type=str, default=TASKS_JSON_PATH, help="The json path to store the raw data directories of each task") parser.add_argument("--dataset_root", type=str, default=DATASET_ROOT, help="the dataset root of the raw mcap data") parser.add_argument("--final_dataset_repo_root", type=str, default="we_d900", help="The final dataset repo root to save the merged dataset") parser.add_argument( "--hil_filter", action="store_true", help="Enable HIL filtering: only keep 'inference' and 'teleoperation' action types" ) parser.add_argument( "--action_types", type=str, nargs="+", default=None, help="Custom action types to keep (e.g., --action_types inference teleoperation). Overrides --hil_filter." ) args = parser.parse_args() # Determine action types 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=args.repo_id, robot_type=args.robot_type, fps=args.fps, 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 )