Add LeRobot converter

scripts/convert_real_datasets_to_lerobot_v3.py

@@ -0,0 +1,925 @@
+#!/usr/bin/env python3
+"""Convert RealDatasets MP4 episodes into masked LeRobot v3 datasets.
+
+The source tree is read-only. Camera 2 is stored as the wrist camera and
+camera 4 as the front camera. Recorded frames are mapped to a strict 30 Hz
+timeline. Missing timeline slots receive black images, NaN state/action values,
+and false validity masks. Original videos and timestamp metadata are hard-linked
+or copied into each task dataset's ``raw_video`` directory.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import re
+import shutil
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import av
+import cv2
+import numpy as np
+import pyarrow.dataset as pa_dataset
+from lerobot.configs.video import RGBEncoderConfig
+from lerobot.datasets import LeRobotDataset
+from lerobot.datasets.compute_stats import compute_episode_stats as lerobot_compute_episode_stats
+import lerobot.datasets.dataset_writer as dataset_writer_module
+from tqdm import tqdm
+
+
+TARGET_FPS = 30
+OUTPUT_WIDTH = 848
+OUTPUT_HEIGHT = 480
+SOURCE_WIDTH = 1920
+SOURCE_HEIGHT = 1080
+SOURCE_CROP_WIDTH = 1908
+SOURCE_CROP_LEFT = (SOURCE_WIDTH - SOURCE_CROP_WIDTH) // 2
+
+WRIST_KEY = "observation.images.wrist"
+FRONT_KEY = "observation.images.front"
+WRIST_VALID_KEY = "observation.images.wrist_valid"
+FRONT_VALID_KEY = "observation.images.front_valid"
+STATE_KEY = "observation.state"
+STATE_VALID_KEY = "observation.state_valid"
+ACTION_KEY = "action"
+ACTION_VALID_KEY = "action_valid"
+SOURCE_TIMESTAMP_KEY = "source.timestamp"
+SOURCE_RELATIVE_TIMESTAMP_KEY = "source.timestamp_relative"
+SOURCE_ORIGINAL_TIMESTAMP_KEY = "source.original_timestamp"
+SOURCE_ORIGINAL_RELATIVE_TIMESTAMP_KEY = "source.original_timestamp_relative"
+SOURCE_FRAME_INDEX_KEY = "source.frame_index"
+
+TASK_NAME_TO_SLUG = {
+    "抓娃娃": "pack_sloth",
+    "对折毛巾": "fold_cloth",
+    "放置绳子": "insert_rope",
+}
+SLUG_TO_TASK_NAME = {slug: name for name, slug in TASK_NAME_TO_SLUG.items()}
+
+STATE_NAMES = ["x", "y", "z", "qx", "qy", "qz", "qw", "gripper"]
+ACTION_NAMES = [
+    "delta_x",
+    "delta_y",
+    "delta_z",
+    "delta_rx",
+    "delta_ry",
+    "delta_rz",
+    "gripper",
+]
+
+
+@dataclass(frozen=True)
+class PoseStep:
+    position: np.ndarray
+    quaternion: np.ndarray
+    gripper: float
+
+
+@dataclass(frozen=True)
+class Timeline:
+    source_to_target: list[int]
+    target_to_source: list[int]
+
+
+@dataclass(frozen=True)
+class EpisodeResult:
+    source_frames: int
+    target_frames: int
+    inserted_frames: int
+    valid_actions: int
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--data-root",
+        type=Path,
+        default=Path.home() / "real-datasets-transfer" / "google-drive",
+    )
+    parser.add_argument(
+        "--output-root",
+        type=Path,
+        default=Path.home() / "real-datasets-transfer" / "lerobot-output",
+    )
+    parser.add_argument("--repo-id", default="Zili2002/RealDatasets")
+    parser.add_argument(
+        "--tasks",
+        nargs="+",
+        choices=sorted(SLUG_TO_TASK_NAME),
+        default=sorted(SLUG_TO_TASK_NAME),
+    )
+    parser.add_argument("--max-episodes", type=int)
+    parser.add_argument("--overwrite", action="store_true")
+    parser.add_argument("--skip-raw-video", action="store_true")
+    parser.add_argument("--skip-validation", action="store_true")
+    parser.add_argument("--image-writer-threads", type=int, default=8)
+    parser.add_argument("--encoder-threads", type=int, default=4)
+    parser.add_argument("--video-files-size-mb", type=int, default=500)
+    parser.add_argument("--data-files-size-mb", type=int, default=100)
+    parser.add_argument("--crf", type=int, default=23)
+    parser.add_argument("--preset", default="fast")
+    return parser.parse_args()
+
+
+def require_positive(name: str, value: int | None) -> None:
+    if value is not None and (isinstance(value, bool) or value <= 0):
+        raise ValueError(f"{name} must be positive, got {value!r}")
+
+
+def install_masked_statistics_hook() -> None:
+    """Exclude invalid rows and black placeholders from LeRobot statistics."""
+
+    mask_by_feature = {
+        WRIST_KEY: WRIST_VALID_KEY,
+        FRONT_KEY: FRONT_VALID_KEY,
+        STATE_KEY: STATE_VALID_KEY,
+        ACTION_KEY: ACTION_VALID_KEY,
+        SOURCE_TIMESTAMP_KEY: WRIST_VALID_KEY,
+        SOURCE_RELATIVE_TIMESTAMP_KEY: WRIST_VALID_KEY,
+        SOURCE_ORIGINAL_TIMESTAMP_KEY: WRIST_VALID_KEY,
+        SOURCE_ORIGINAL_RELATIVE_TIMESTAMP_KEY: WRIST_VALID_KEY,
+        SOURCE_FRAME_INDEX_KEY: WRIST_VALID_KEY,
+    }
+    excluded_statistics_features = {
+        WRIST_VALID_KEY,
+        FRONT_VALID_KEY,
+        STATE_VALID_KEY,
+        ACTION_VALID_KEY,
+    }
+
+    def masked_compute_episode_stats(
+        episode_data: dict[str, Any],
+        features: dict[str, dict],
+        quantile_list: list[float] | None = None,
+    ) -> dict:
+        filtered_data = dict(episode_data)
+
+        for feature_key, mask_key in mask_by_feature.items():
+            if feature_key not in filtered_data or mask_key not in filtered_data:
+                continue
+
+            mask = np.asarray(filtered_data[mask_key], dtype=bool).reshape(-1)
+            values = filtered_data[feature_key]
+            if len(values) != len(mask):
+                raise ValueError(
+                    f"Statistics mask mismatch for {feature_key}: "
+                    f"values={len(values)}, mask={len(mask)}"
+                )
+
+            if isinstance(values, list):
+                filtered_values = [
+                    value for value, is_valid in zip(values, mask, strict=True) if is_valid
+                ]
+            else:
+                filtered_values = np.asarray(values)[mask]
+
+            if len(filtered_values) < 2:
+                raise ValueError(
+                    f"Need at least two valid values for {feature_key} statistics"
+                )
+            filtered_data[feature_key] = filtered_values
+
+        statistics_features = {
+            key: value
+            for key, value in features.items()
+            if key not in excluded_statistics_features
+        }
+        statistics_data = {
+            key: value
+            for key, value in filtered_data.items()
+            if key in statistics_features
+        }
+        return lerobot_compute_episode_stats(
+            statistics_data,
+            statistics_features,
+            quantile_list=quantile_list,
+        )
+
+    dataset_writer_module.compute_episode_stats = masked_compute_episode_stats
+
+
+def task_records(data_root: Path, source_task_name: str) -> list[Path]:
+    task_root = data_root / source_task_name
+    if not task_root.is_dir():
+        raise FileNotFoundError(f"Source task directory is missing: {task_root}")
+
+    records = []
+    for path in task_root.glob("record_*"):
+        match = re.fullmatch(r"record_(\d+)", path.name)
+        if path.is_dir() and match is not None:
+            records.append((int(match.group(1)), path))
+    records.sort(key=lambda item: item[0])
+    if not records:
+        raise ValueError(f"No record_NNN directories found in {task_root}")
+    return [path for _, path in records]
+
+
+def exactly_one(paths: list[Path], description: str) -> Path:
+    if len(paths) != 1:
+        raise ValueError(f"Expected one {description}, found {paths}")
+    return paths[0]
+
+
+def source_files(record_dir: Path) -> tuple[Path, Path, Path, Path]:
+    action_json = exactly_one(
+        sorted((record_dir / "action").glob("action_data_*.json")),
+        f"action JSON in {record_dir}",
+    )
+    timestamps_json = record_dir / "video" / "frame_timestamps.json"
+    if not timestamps_json.is_file():
+        raise FileNotFoundError(timestamps_json)
+    camera_2 = exactly_one(
+        sorted((record_dir / "video").glob("camera_2_*.mp4")),
+        f"camera 2 MP4 in {record_dir}",
+    )
+    camera_4 = exactly_one(
+        sorted((record_dir / "video").glob("camera_4_*.mp4")),
+        f"camera 4 MP4 in {record_dir}",
+    )
+    return action_json, timestamps_json, camera_2, camera_4
+
+
+def load_pose_steps(action_json: Path) -> list[PoseStep]:
+    payload = json.loads(action_json.read_text(encoding="utf-8"))
+    rows = payload.get("data")
+    if not isinstance(rows, list) or len(rows) < 2:
+        raise ValueError(f"Invalid or too-short action data: {action_json}")
+
+    steps: list[PoseStep] = []
+    for index, row in enumerate(rows):
+        try:
+            pose = row["end_effector_pose"]
+            position = pose["position"]
+            orientation = pose["orientation"]
+            xyz = np.asarray(
+                [position["x"], position["y"], position["z"]],
+                dtype=np.float64,
+            )
+            quaternion = np.asarray(
+                [
+                    orientation["x"],
+                    orientation["y"],
+                    orientation["z"],
+                    orientation["w"],
+                ],
+                dtype=np.float64,
+            )
+            gripper = float(row["gripper_command"])
+        except (KeyError, TypeError, ValueError) as error:
+            raise ValueError(f"Bad pose at {action_json} row {index}") from error
+
+        if (
+            not np.isfinite(xyz).all()
+            or not np.isfinite(quaternion).all()
+            or not math.isfinite(gripper)
+        ):
+            raise ValueError(f"Non-finite pose at {action_json} row {index}")
+
+        norm = float(np.linalg.norm(quaternion))
+        if norm < 1e-8:
+            raise ValueError(f"Zero quaternion at {action_json} row {index}")
+        quaternion /= norm
+        if steps and float(np.dot(steps[-1].quaternion, quaternion)) < 0.0:
+            quaternion = -quaternion
+        steps.append(PoseStep(xyz, quaternion, gripper))
+
+    return steps
+
+
+def load_timestamps(timestamps_json: Path) -> tuple[dict[str, Any], list[float]]:
+    metadata = json.loads(timestamps_json.read_text(encoding="utf-8"))
+    timestamps = metadata.get("timestamps_unix")
+    if not isinstance(timestamps, list) or len(timestamps) < 2:
+        raise ValueError(f"Invalid timestamps: {timestamps_json}")
+    parsed = [float(value) for value in timestamps]
+    if not np.isfinite(np.asarray(parsed)).all():
+        raise ValueError(f"Non-finite timestamps: {timestamps_json}")
+    if any(current <= previous for previous, current in zip(parsed, parsed[1:])):
+        raise ValueError(f"Timestamps are not strictly increasing: {timestamps_json}")
+    return metadata, parsed
+
+
+def build_timeline(timestamps: list[float]) -> Timeline:
+    start = timestamps[0]
+    source_to_target: list[int] = []
+    previous_slot = -1
+
+    for timestamp in timestamps:
+        relative = (timestamp - start) * TARGET_FPS
+        ideal_slot = int(math.floor(relative + 0.5))
+        slot = max(ideal_slot, previous_slot + 1)
+        source_to_target.append(slot)
+        previous_slot = slot
+
+    target_to_source = [-1] * (source_to_target[-1] + 1)
+    for source_index, target_index in enumerate(source_to_target):
+        if target_to_source[target_index] != -1:
+            raise RuntimeError(f"Duplicate target timeline index: {target_index}")
+        target_to_source[target_index] = source_index
+
+    return Timeline(source_to_target, target_to_source)
+
+
+def quaternion_inverse(quaternion: np.ndarray) -> np.ndarray:
+    result = quaternion.copy()
+    result[:3] *= -1.0
+    return result
+
+
+def quaternion_multiply(left: np.ndarray, right: np.ndarray) -> np.ndarray:
+    lx, ly, lz, lw = left
+    rx, ry, rz, rw = right
+    return np.asarray(
+        [
+            lw * rx + lx * rw + ly * rz - lz * ry,
+            lw * ry - lx * rz + ly * rw + lz * rx,
+            lw * rz + lx * ry - ly * rx + lz * rw,
+            lw * rw - lx * rx - ly * ry - lz * rz,
+        ],
+        dtype=np.float64,
+    )
+
+
+def quaternion_to_rotation_vector(quaternion: np.ndarray) -> np.ndarray:
+    quaternion = quaternion / np.linalg.norm(quaternion)
+    if quaternion[3] < 0.0:
+        quaternion = -quaternion
+    vector = quaternion[:3]
+    vector_norm = float(np.linalg.norm(vector))
+    if vector_norm < 1e-10:
+        return 2.0 * vector
+    angle = 2.0 * math.atan2(vector_norm, float(quaternion[3]))
+    return vector / vector_norm * angle
+
+
+def make_state(step: PoseStep) -> np.ndarray:
+    return np.asarray(
+        [*step.position, *step.quaternion, step.gripper],
+        dtype=np.float32,
+    )
+
+
+def make_action(current: PoseStep, following: PoseStep) -> np.ndarray:
+    delta_position = following.position - current.position
+    delta_quaternion = quaternion_multiply(
+        quaternion_inverse(current.quaternion),
+        following.quaternion,
+    )
+    delta_rotation = quaternion_to_rotation_vector(delta_quaternion)
+    return np.asarray(
+        [*delta_position, *delta_rotation, following.gripper],
+        dtype=np.float32,
+    )
+
+
+def make_terminal_action(step: PoseStep) -> np.ndarray:
+    return np.asarray(
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, step.gripper],
+        dtype=np.float32,
+    )
+
+
+def process_video_frame(frame: av.VideoFrame, path: Path, frame_index: int) -> np.ndarray:
+    image = frame.to_ndarray(format="rgb24")
+    if image.shape != (SOURCE_HEIGHT, SOURCE_WIDTH, 3):
+        raise ValueError(
+            f"Unexpected frame shape in {path} at {frame_index}: {image.shape}"
+        )
+    cropped = image[
+        :,
+        SOURCE_CROP_LEFT : SOURCE_CROP_LEFT + SOURCE_CROP_WIDTH,
+        :,
+    ]
+    resized = cv2.resize(
+        cropped,
+        (OUTPUT_WIDTH, OUTPUT_HEIGHT),
+        interpolation=cv2.INTER_AREA,
+    )
+    return np.ascontiguousarray(resized, dtype=np.uint8)
+
+
+def link_or_copy(source: Path, destination: Path) -> None:
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    if destination.exists():
+        if destination.samefile(source):
+            return
+        raise FileExistsError(destination)
+    try:
+        os.link(source, destination)
+    except OSError:
+        shutil.copy2(source, destination)
+
+
+def save_raw_video(
+    task_output_root: Path,
+    record_dir: Path,
+    timestamps_json: Path,
+    camera_2: Path,
+    camera_4: Path,
+    timeline: Timeline,
+) -> None:
+    raw_record_root = task_output_root / "raw_video" / record_dir.name
+    raw_record_root.mkdir(parents=True, exist_ok=True)
+    for source in (timestamps_json, camera_2, camera_4):
+        link_or_copy(source, raw_record_root / source.name)
+
+    mapping = {
+        "target_fps": TARGET_FPS,
+        "source_frame_count": len(timeline.source_to_target),
+        "target_frame_count": len(timeline.target_to_source),
+        "inserted_frame_count": timeline.target_to_source.count(-1),
+        "source_frame_to_target_index": timeline.source_to_target,
+        "target_to_source_frame_index": timeline.target_to_source,
+        "image_valid": [index >= 0 for index in timeline.target_to_source],
+    }
+    mapping_path = raw_record_root / "timeline_30hz.json"
+    temporary = mapping_path.with_suffix(".json.tmp")
+    temporary.write_text(
+        json.dumps(mapping, ensure_ascii=False, separators=(",", ":")),
+        encoding="utf-8",
+    )
+    os.replace(temporary, mapping_path)
+
+
+def features() -> dict[str, dict[str, Any]]:
+    vector_name = lambda values: {"axes": values}
+    scalar_name = lambda value: {"axes": [value]}
+    return {
+        WRIST_KEY: {
+            "dtype": "video",
+            "shape": (OUTPUT_HEIGHT, OUTPUT_WIDTH, 3),
+            "names": ["height", "width", "channels"],
+        },
+        FRONT_KEY: {
+            "dtype": "video",
+            "shape": (OUTPUT_HEIGHT, OUTPUT_WIDTH, 3),
+            "names": ["height", "width", "channels"],
+        },
+        STATE_KEY: {
+            "dtype": "float32",
+            "shape": (8,),
+            "names": vector_name(STATE_NAMES),
+        },
+        ACTION_KEY: {
+            "dtype": "float32",
+            "shape": (7,),
+            "names": vector_name(ACTION_NAMES),
+        },
+        SOURCE_TIMESTAMP_KEY: {
+            "dtype": "float64",
+            "shape": (1,),
+            "names": scalar_name("unix_seconds"),
+        },
+        SOURCE_RELATIVE_TIMESTAMP_KEY: {
+            "dtype": "float64",
+            "shape": (1,),
+            "names": scalar_name("seconds"),
+        },
+        SOURCE_ORIGINAL_TIMESTAMP_KEY: {
+            "dtype": "float64",
+            "shape": (1,),
+            "names": scalar_name("unix_seconds"),
+        },
+        SOURCE_ORIGINAL_RELATIVE_TIMESTAMP_KEY: {
+            "dtype": "float64",
+            "shape": (1,),
+            "names": scalar_name("seconds"),
+        },
+        SOURCE_FRAME_INDEX_KEY: {
+            "dtype": "int64",
+            "shape": (1,),
+            "names": scalar_name("index"),
+        },
+        WRIST_VALID_KEY: {
+            "dtype": "bool",
+            "shape": (1,),
+            "names": scalar_name("valid"),
+        },
+        FRONT_VALID_KEY: {
+            "dtype": "bool",
+            "shape": (1,),
+            "names": scalar_name("valid"),
+        },
+        STATE_VALID_KEY: {
+            "dtype": "bool",
+            "shape": (1,),
+            "names": scalar_name("valid"),
+        },
+        ACTION_VALID_KEY: {
+            "dtype": "bool",
+            "shape": (1,),
+            "names": scalar_name("valid"),
+        },
+    }
+
+
+def create_dataset(
+    root: Path,
+    repo_id: str,
+    args: argparse.Namespace,
+) -> LeRobotDataset:
+    encoder = RGBEncoderConfig(
+        vcodec="h264",
+        pix_fmt="yuv420p",
+        g=2,
+        crf=args.crf,
+        preset=args.preset,
+    )
+    return LeRobotDataset.create(
+        repo_id=repo_id,
+        root=root,
+        robot_type="fr3",
+        fps=TARGET_FPS,
+        features=features(),
+        use_videos=True,
+        video_backend="pyav",
+        image_writer_threads=args.image_writer_threads,
+        streaming_encoding=False,
+        encoder_threads=args.encoder_threads,
+        rgb_encoder=encoder,
+        metadata_buffer_size=10,
+        video_files_size_in_mb=args.video_files_size_mb,
+        data_files_size_in_mb=args.data_files_size_mb,
+    )
+
+
+def process_episode(
+    dataset: LeRobotDataset,
+    task_output_root: Path,
+    task_slug: str,
+    record_dir: Path,
+    copy_raw_video: bool,
+) -> EpisodeResult:
+    action_json, timestamps_json, camera_2_path, camera_4_path = source_files(
+        record_dir
+    )
+    steps = load_pose_steps(action_json)
+    timestamp_metadata, timestamps = load_timestamps(timestamps_json)
+    timeline = build_timeline(timestamps)
+
+    expected_count = len(steps)
+    if len(timestamps) != expected_count:
+        raise ValueError(
+            f"Action/timestamp mismatch in {record_dir}: "
+            f"actions={expected_count}, timestamps={len(timestamps)}"
+        )
+    if int(timestamp_metadata.get("frame_count", -1)) != expected_count:
+        raise ValueError(
+            f"Timestamp metadata count mismatch in {record_dir}: "
+            f"metadata={timestamp_metadata.get('frame_count')}, expected={expected_count}"
+        )
+
+    source_actions = [
+        make_action(steps[index], steps[index + 1])
+        for index in range(expected_count - 1)
+    ]
+    source_actions.append(make_terminal_action(steps[-1]))
+
+    black_image = np.zeros(
+        (OUTPUT_HEIGHT, OUTPUT_WIDTH, 3),
+        dtype=np.uint8,
+    )
+    nan_state = np.full(8, np.nan, dtype=np.float32)
+    nan_action = np.full(7, np.nan, dtype=np.float32)
+    start_timestamp = timestamps[0]
+    valid_actions = 0
+
+    with av.open(str(camera_2_path)) as camera_2_container, av.open(
+        str(camera_4_path)
+    ) as camera_4_container:
+        camera_2_frames = iter(camera_2_container.decode(video=0))
+        camera_4_frames = iter(camera_4_container.decode(video=0))
+
+        for target_index, source_index in enumerate(timeline.target_to_source):
+            nominal_relative = target_index / TARGET_FPS
+            nominal_timestamp = start_timestamp + nominal_relative
+
+            if source_index < 0:
+                wrist_image = black_image
+                front_image = black_image
+                state = nan_state
+                action = nan_action
+                original_timestamp = math.nan
+                original_relative = math.nan
+                image_valid = False
+                state_valid = False
+                action_valid = False
+            else:
+                try:
+                    camera_2_frame = next(camera_2_frames)
+                    camera_4_frame = next(camera_4_frames)
+                except StopIteration as error:
+                    raise ValueError(
+                        f"Video ended before frame {source_index} in {record_dir}"
+                    ) from error
+
+                wrist_image = process_video_frame(
+                    camera_2_frame,
+                    camera_2_path,
+                    source_index,
+                )
+                front_image = process_video_frame(
+                    camera_4_frame,
+                    camera_4_path,
+                    source_index,
+                )
+                state = make_state(steps[source_index])
+                action = source_actions[source_index]
+                original_timestamp = timestamps[source_index]
+                original_relative = original_timestamp - start_timestamp
+                image_valid = True
+                state_valid = True
+
+                action_valid = True
+                valid_actions += 1
+
+            dataset.add_frame(
+                {
+                    WRIST_KEY: wrist_image,
+                    FRONT_KEY: front_image,
+                    STATE_KEY: state,
+                    ACTION_KEY: action,
+                    SOURCE_TIMESTAMP_KEY: np.asarray(
+                        [nominal_timestamp],
+                        dtype=np.float64,
+                    ),
+                    SOURCE_RELATIVE_TIMESTAMP_KEY: np.asarray(
+                        [nominal_relative],
+                        dtype=np.float64,
+                    ),
+                    SOURCE_ORIGINAL_TIMESTAMP_KEY: np.asarray(
+                        [original_timestamp],
+                        dtype=np.float64,
+                    ),
+                    SOURCE_ORIGINAL_RELATIVE_TIMESTAMP_KEY: np.asarray(
+                        [original_relative],
+                        dtype=np.float64,
+                    ),
+                    SOURCE_FRAME_INDEX_KEY: np.asarray(
+                        [source_index],
+                        dtype=np.int64,
+                    ),
+                    WRIST_VALID_KEY: np.asarray([image_valid], dtype=np.bool_),
+                    FRONT_VALID_KEY: np.asarray([image_valid], dtype=np.bool_),
+                    STATE_VALID_KEY: np.asarray([state_valid], dtype=np.bool_),
+                    ACTION_VALID_KEY: np.asarray([action_valid], dtype=np.bool_),
+                    "task": task_slug,
+                }
+            )
+
+        if next(camera_2_frames, None) is not None:
+            raise ValueError(f"Camera 2 has extra frames in {record_dir}")
+        if next(camera_4_frames, None) is not None:
+            raise ValueError(f"Camera 4 has extra frames in {record_dir}")
+
+    dataset.save_episode(parallel_encoding=True)
+
+    if copy_raw_video:
+        save_raw_video(
+            task_output_root,
+            record_dir,
+            timestamps_json,
+            camera_2_path,
+            camera_4_path,
+            timeline,
+        )
+
+    return EpisodeResult(
+        source_frames=expected_count,
+        target_frames=len(timeline.target_to_source),
+        inserted_frames=timeline.target_to_source.count(-1),
+        valid_actions=valid_actions,
+    )
+
+
+def assert_no_nan_stats(path: Path) -> None:
+    stats = json.loads(path.read_text(encoding="utf-8"))
+
+    def visit(value: Any, location: str) -> None:
+        if isinstance(value, dict):
+            for key, item in value.items():
+                visit(item, f"{location}.{key}")
+        elif isinstance(value, list):
+            for index, item in enumerate(value):
+                visit(item, f"{location}[{index}]")
+        elif isinstance(value, float) and not math.isfinite(value):
+            raise ValueError(f"Non-finite statistic at {location}: {value}")
+
+    visit(stats, "stats")
+
+
+def validate_task_output(
+    task_root: Path,
+    repo_id: str,
+    expected_episodes: int,
+    expected_source_frames: int,
+    expected_target_frames: int,
+) -> None:
+    assert_no_nan_stats(task_root / "meta" / "stats.json")
+
+    table = pa_dataset.dataset(task_root / "data", format="parquet").to_table(
+        columns=[
+            "episode_index",
+            SOURCE_FRAME_INDEX_KEY,
+            WRIST_VALID_KEY,
+            FRONT_VALID_KEY,
+            STATE_KEY,
+            STATE_VALID_KEY,
+            ACTION_KEY,
+            ACTION_VALID_KEY,
+        ]
+    )
+    if table.num_rows != expected_target_frames:
+        raise ValueError(
+            f"Parquet frame count mismatch: {table.num_rows} != "
+            f"{expected_target_frames}"
+        )
+
+    rows = table.to_pylist()
+    real_rows = 0
+    for row_index, row in enumerate(rows):
+        source_index = int(row[SOURCE_FRAME_INDEX_KEY])
+        wrist_valid = bool(row[WRIST_VALID_KEY])
+        front_valid = bool(row[FRONT_VALID_KEY])
+        state_valid = bool(row[STATE_VALID_KEY])
+        action_valid = bool(row[ACTION_VALID_KEY])
+        state = np.asarray(row[STATE_KEY], dtype=np.float32)
+        action = np.asarray(row[ACTION_KEY], dtype=np.float32)
+
+        if wrist_valid != front_valid:
+            raise ValueError(f"Camera validity mismatch at row {row_index}")
+        if source_index < 0:
+            if wrist_valid or state_valid or action_valid:
+                raise ValueError(f"Invalid inserted-row mask at row {row_index}")
+            if not np.isnan(state).all() or not np.isnan(action).all():
+                raise ValueError(f"Inserted row is not NaN-filled at row {row_index}")
+        else:
+            real_rows += 1
+            if not wrist_valid or not state_valid:
+                raise ValueError(f"Invalid real-row mask at row {row_index}")
+            if not np.isfinite(state).all() or not np.isfinite(action).all():
+                raise ValueError(f"Real row has non-finite data at row {row_index}")
+
+    if real_rows != expected_source_frames:
+        raise ValueError(
+            f"Real frame count mismatch: {real_rows} != {expected_source_frames}"
+        )
+
+    for video_key in (WRIST_KEY, FRONT_KEY):
+        video_root = task_root / "videos" / video_key
+        video_frames = 0
+        for video_path in sorted(video_root.rglob("*.mp4")):
+            with av.open(str(video_path)) as container:
+                stream = container.streams.video[0]
+                frame_count = int(stream.frames or 0)
+                if frame_count == 0:
+                    frame_count = sum(1 for _ in container.decode(video=0))
+                video_frames += frame_count
+                if (stream.width, stream.height) != (OUTPUT_WIDTH, OUTPUT_HEIGHT):
+                    raise ValueError(
+                        f"Unexpected output dimensions in {video_path}: "
+                        f"{stream.width}x{stream.height}"
+                    )
+        if video_frames != expected_target_frames:
+            raise ValueError(
+                f"{video_key} frame count mismatch: {video_frames} != "
+                f"{expected_target_frames}"
+            )
+
+    loaded = LeRobotDataset(
+        repo_id=repo_id,
+        root=task_root,
+        video_backend="pyav",
+        return_uint8=True,
+    )
+    if loaded.meta.total_episodes != expected_episodes:
+        raise ValueError(
+            f"Loaded episode count mismatch: {loaded.meta.total_episodes} != "
+            f"{expected_episodes}"
+        )
+    if len(loaded) != expected_target_frames:
+        raise ValueError(
+            f"Loaded frame count mismatch: {len(loaded)} != "
+            f"{expected_target_frames}"
+        )
+    sample_indices = sorted({0, len(loaded) // 2, len(loaded) - 1})
+    for index in sample_indices:
+        sample = loaded[index]
+        for video_key in (WRIST_KEY, FRONT_KEY):
+            if tuple(sample[video_key].shape) != (3, OUTPUT_HEIGHT, OUTPUT_WIDTH):
+                raise ValueError(
+                    f"Unexpected loaded image shape for {video_key} at {index}: "
+                    f"{tuple(sample[video_key].shape)}"
+                )
+
+
+def convert_task(
+    args: argparse.Namespace,
+    task_slug: str,
+) -> None:
+    source_task_name = SLUG_TO_TASK_NAME[task_slug]
+    records = task_records(args.data_root, source_task_name)
+    if args.max_episodes is not None:
+        records = records[: args.max_episodes]
+
+    task_output_root = args.output_root / task_slug
+    if task_output_root.exists():
+        if not args.overwrite:
+            raise FileExistsError(
+                f"Output exists; pass --overwrite to replace it: {task_output_root}"
+            )
+        shutil.rmtree(task_output_root)
+    task_output_root.parent.mkdir(parents=True, exist_ok=True)
+
+    dataset = create_dataset(task_output_root, args.repo_id, args)
+    source_frames = 0
+    target_frames = 0
+    inserted_frames = 0
+    valid_actions = 0
+    started = time.monotonic()
+
+    try:
+        for record_dir in tqdm(records, desc=task_slug):
+            result = process_episode(
+                dataset,
+                task_output_root,
+                task_slug,
+                record_dir,
+                copy_raw_video=not args.skip_raw_video,
+            )
+            source_frames += result.source_frames
+            target_frames += result.target_frames
+            inserted_frames += result.inserted_frames
+            valid_actions += result.valid_actions
+            print(
+                f"{task_slug}/{record_dir.name}: "
+                f"source={result.source_frames} target={result.target_frames} "
+                f"inserted={result.inserted_frames} "
+                f"valid_actions={result.valid_actions}",
+                flush=True,
+            )
+    finally:
+        dataset.finalize()
+
+    elapsed = time.monotonic() - started
+    summary = {
+        "task": task_slug,
+        "source_task": source_task_name,
+        "episodes": len(records),
+        "source_frames": source_frames,
+        "target_frames": target_frames,
+        "inserted_frames": inserted_frames,
+        "valid_actions": valid_actions,
+        "fps": TARGET_FPS,
+        "width": OUTPUT_WIDTH,
+        "height": OUTPUT_HEIGHT,
+        "elapsed_seconds": elapsed,
+    }
+    (task_output_root / "conversion_summary.json").write_text(
+        json.dumps(summary, ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+
+    if not args.skip_validation:
+        validate_task_output(
+            task_output_root,
+            args.repo_id,
+            expected_episodes=len(records),
+            expected_source_frames=source_frames,
+            expected_target_frames=target_frames,
+        )
+
+    print(json.dumps(summary, ensure_ascii=False), flush=True)
+
+
+def main() -> None:
+    args = parse_args()
+    require_positive("--max-episodes", args.max_episodes)
+    require_positive("--image-writer-threads", args.image_writer_threads)
+    require_positive("--encoder-threads", args.encoder_threads)
+    require_positive("--video-files-size-mb", args.video_files_size_mb)
+    require_positive("--data-files-size-mb", args.data_files_size_mb)
+
+    args.data_root = args.data_root.expanduser().resolve()
+    args.output_root = args.output_root.expanduser().resolve()
+    if not args.data_root.is_dir():
+        raise FileNotFoundError(args.data_root)
+    if args.output_root == args.data_root or args.data_root in args.output_root.parents:
+        raise ValueError("Output root must not be inside the source data root")
+
+    av.logging.set_level(av.logging.ERROR)
+    cv2.setNumThreads(1)
+    cv2.ocl.setUseOpenCL(False)
+    install_masked_statistics_hook()
+
+    for task_slug in args.tasks:
+        convert_task(args, task_slug)
+
+
+if __name__ == "__main__":
+    main()