Datasets:

yyyyyt
/

pick_object

@@ -1,666 +0,0 @@
-"""Convert pick_apple raw data to LeRobot v3.0 dataset format.
-This script converts raw robot demonstration data (robot_data.csv + camera images)
-to the LeRobot v3.0 dataset format.
-Language instructions are stored as raw text in the parquet under the `task`
-column (and indexed via `meta/tasks.parquet`). Token IDs / attention masks are
-generated dynamically at training time by the model's tokenizer/collator.
-Usage:
-    conda activate lerobot_env
-    python examples/learning_il/convert_pick_apple.py --input pick_apple --output data/pick_apple_lerobot
-Data structure expected:
-    pick_apple/
-    ├── episode_002/
-    │   ├── metadata.json
-    │   ├── robot_data.csv
-    │   ├── cam_head/
-    │   │   ├── 0.jpg, 1.jpg, ...
-    │   └── cam_wrist/
-    │       ├── 0.jpg, 1.jpg, ...
-    ...
-LeRobot v3.0 output structure:
-    data/pick_apple_lerobot/
-    ├── data/
-    │   └── chunk-000/
-    │       └── file-000.parquet
-    ├── videos/
-    │   └── chunk-000/
-    │       ├── observation.images.cam_head/
-    │       │   └── file-000.mp4
-    │       └── observation.images.cam_wrist/
-    │           └── file-000.mp4
-    └── meta/
-        ├── info.json
-        ├── stats.json
-        ├── tasks.parquet
-        └── episodes/
-            └── chunk-000/
-                └── file-000.parquet
-"""
-import argparse
-import json
-import shutil
-from pathlib import Path
-import cv2
-import numpy as np
-import pandas as pd
-from tqdm import tqdm
-# Import LeRobot's official statistics computation tools
-try:
-    from lerobot.datasets.compute_stats import DEFAULT_QUANTILES, get_feature_stats
-    LEROBOT_STATS_AVAILABLE = True
-except ImportError:
-    print("Warning: LeRobot stats module not available, will compute basic stats only")
-    LEROBOT_STATS_AVAILABLE = False
-def detect_cameras(episode_dir: Path) -> list[str]:
-    """Detect all cameras from an episode directory.
-    Prioritizes metadata.json if it contains a 'cameras' field,
-    otherwise scans for cam_* subdirectories.
-    Returns:
-        Sorted list of camera names (e.g., ['cam_head', 'cam_wrist'])
-    """
-    metadata_path = episode_dir / "metadata.json"
-    # Try to read from metadata first
-    if metadata_path.exists():
-        with open(metadata_path, "r") as f:
-            metadata = json.load(f)
-            if "cameras" in metadata:
-                cameras = [f"cam_{cam}" if not cam.startswith("cam_") else cam
-                          for cam in metadata["cameras"]]
-                return sorted(cameras)
-    # Fallback: scan directories
-    cameras = []
-    for subdir in episode_dir.iterdir():
-        if subdir.is_dir() and subdir.name.startswith("cam_"):
-            # Verify it contains images
-            if list(subdir.glob("*.jpg")) or list(subdir.glob("*.png")):
-                cameras.append(subdir.name)
-    return sorted(cameras)
-def validate_cameras_consistency(episode_dirs: list[Path]) -> list[str]:
-    """Validate that all episodes have the same cameras.
-    Args:
-        episode_dirs: List of episode directories
-    Returns:
-        List of camera names (sorted)
-    Raises:
-        ValueError: If cameras are inconsistent across episodes
-    """
-    if not episode_dirs:
-        raise ValueError("No episode directories provided")
-    # Detect cameras from first episode
-    reference_cameras = detect_cameras(episode_dirs[0])
-    if not reference_cameras:
-        raise ValueError(f"No cameras found in {episode_dirs[0]}")
-    print(f"Detected cameras: {reference_cameras}")
-    # Validate all other episodes have the same cameras
-    for episode_dir in episode_dirs[1:]:
-        cameras = detect_cameras(episode_dir)
-        if cameras != reference_cameras:
-            raise ValueError(
-                f"Camera mismatch in {episode_dir.name}:\n"
-                f"  Expected: {reference_cameras}\n"
-                f"  Found: {cameras}\n"
-                f"All episodes must have the same cameras."
-            )
-    return reference_cameras
-def get_episode_dirs(input_dir: Path) -> list[Path]:
-    """Get all episode directories sorted by episode number."""
-    episode_dirs = []
-    for d in input_dir.iterdir():
-        if d.is_dir() and d.name.startswith("episode_"):
-            episode_dirs.append(d)
-    episode_dirs.sort(key=lambda x: int(x.name.split("_")[1]))
-    return episode_dirs
-def load_episode_data(episode_dir: Path, cameras: list[str]) -> tuple[dict, pd.DataFrame, int]:
-    """Load metadata and robot data for an episode.
-    Args:
-        episode_dir: Path to episode directory
-        cameras: List of camera names to load
-    Returns:
-        Tuple of (metadata, robot_data, num_frames)
-    """
-    metadata_path = episode_dir / "metadata.json"
-    robot_data_path = episode_dir / "robot_data.csv"
-    with open(metadata_path, "r") as f:
-        metadata = json.load(f)
-    robot_data = pd.read_csv(robot_data_path)
-    # Count images for each camera
-    image_counts = []
-    for cam in cameras:
-        cam_dir = episode_dir / cam
-        num_images = len(list(cam_dir.glob("*.jpg"))) + len(list(cam_dir.glob("*.png")))
-        image_counts.append(num_images)
-    # num_frames is minimum of robot_data and all camera frame counts
-    num_frames = min(len(robot_data), *image_counts)
-    return metadata, robot_data, num_frames
-def compute_stats(all_states: np.ndarray, all_actions: np.ndarray, cameras: list[str]) -> dict:
-    """Compute dataset statistics for normalization with quantiles.
-    This function computes comprehensive statistics including:
-    - Basic stats: min, max, mean, std
-    - Quantiles: q01, q10, q50, q90, q99 (required for VLA models like pi05, smolvla)
-    For images, we use placeholder stats. LeRobot's factory.py will override
-    these with ImageNet stats when use_imagenet_stats=True (the default).
-    Args:
-        all_states: All state observations (N, state_dim)
-        all_actions: All actions (N, action_dim)
-        cameras: List of camera names (e.g., ['cam_head', 'cam_wrist'])
-    Returns:
-        Dictionary with statistics for each feature, including quantiles
-    """
-    print("Computing statistics (including quantiles for VLA models)...")
-    stats = {}
-    # Compute state statistics with quantiles
-    if LEROBOT_STATS_AVAILABLE:
-        state_stats = get_feature_stats(
-            all_states,
-            axis=0,  # Compute per-feature statistics across all samples
-            keepdims=False,
-            quantile_list=DEFAULT_QUANTILES  # [0.01, 0.10, 0.50, 0.90, 0.99]
-        )
-        # Convert numpy arrays to lists for JSON serialization
-        stats["observation.state"] = {k: v.tolist() for k, v in state_stats.items()}
-        # Compute action statistics with quantiles
-        action_stats = get_feature_stats(
-            all_actions,
-            axis=0,
-            keepdims=False,
-            quantile_list=DEFAULT_QUANTILES
-        )
-        stats["action"] = {k: v.tolist() for k, v in action_stats.items()}
-    else:
-        # Fallback to basic stats only (not recommended for VLA models)
-        print("Warning: Computing basic stats only. VLA models may fail without quantiles!")
-        stats = {
-            "observation.state": {
-                "min": all_states.min(axis=0).tolist(),
-                "max": all_states.max(axis=0).tolist(),
-                "mean": all_states.mean(axis=0).tolist(),
-                "std": all_states.std(axis=0).tolist(),
-            },
-            "action": {
-                "min": all_actions.min(axis=0).tolist(),
-                "max": all_actions.max(axis=0).tolist(),
-                "mean": all_actions.mean(axis=0).tolist(),
-                "std": all_actions.std(axis=0).tolist(),
-            },
-        }
-    # Add image stats for each camera (ImageNet stats format: (c, 1, 1))
-    # These are placeholders - LeRobot will use ImageNet stats by default
-    for cam in cameras:
-        cam_key = f"observation.images.{cam}"
-        stats[cam_key] = {
-            "mean": [[[0.485]], [[0.456]], [[0.406]]],  # ImageNet mean (c, 1, 1)
-            "std": [[[0.229]], [[0.224]], [[0.225]]],   # ImageNet std (c, 1, 1)
-            "min": [[[0.0]], [[0.0]], [[0.0]]],
-            "max": [[[1.0]], [[1.0]], [[1.0]]],
-        }
-    # Print summary of computed statistics
-    if LEROBOT_STATS_AVAILABLE:
-        print(f"✓ Computed statistics with {len(DEFAULT_QUANTILES)} quantiles")
-        print(f"  - observation.state: {list(stats['observation.state'].keys())}")
-        print(f"  - action: {list(stats['action'].keys())}")
-    else:
-        print("⚠ Computed basic statistics only (no quantiles)")
-    return stats
-def convert_dataset(
-    input_dir: Path,
-    output_dir: Path,
-    fps: int = 30,
-    task_description: str = "pick apple",
-    robot_type: str = "so100",
-    state_mode: str = "current_action",
-    action_mode: str = "next_action",
-    drop_last_frame: bool = True,
-) -> None:
-    """Convert raw data to LeRobot v3.0 format with dynamic camera support.
-    Automatically detects cameras from episode data and validates consistency.
-    """
-    print(f"Converting data from {input_dir} to {output_dir}")
-    if output_dir.exists():
-        print(f"Removing existing output directory: {output_dir}")
-        shutil.rmtree(output_dir)
-    # Get episode directories
-    episode_dirs = get_episode_dirs(input_dir)
-    print(f"Found {len(episode_dirs)} episodes")
-    # Detect and validate cameras across all episodes
-    cameras = validate_cameras_consistency(episode_dirs)
-    print(f"Using {len(cameras)} cameras: {cameras}")
-    # Create directory structure
-    data_dir = output_dir / "data" / "chunk-000"
-    videos_dir = output_dir / "videos" / "chunk-000"
-    meta_dir = output_dir / "meta"
-    episodes_meta_dir = meta_dir / "episodes" / "chunk-000"
-    for d in [data_dir, meta_dir, episodes_meta_dir]:
-        d.mkdir(parents=True, exist_ok=True)
-    # Create video directories for each camera
-    cam_dirs = {}
-    video_paths = {}
-    for cam in cameras:
-        cam_video_dir = videos_dir / f"observation.images.{cam}"
-        cam_video_dir.mkdir(parents=True, exist_ok=True)
-        cam_dirs[cam] = cam_video_dir
-        video_paths[cam] = cam_video_dir / "file-000.mp4"
-    # Pass 1: Collect episode data
-    print("\nPass 1: Collecting episode data...")
-    episode_data_list = []
-    total_video_frames = 0
-    for ep_idx, episode_dir in enumerate(tqdm(episode_dirs, desc="Loading")):
-        metadata, robot_data, num_frames = load_episode_data(episode_dir, cameras)
-        if num_frames == 0:
-            print(f"Warning: Skipping {episode_dir.name} - no frames")
-            continue
-        # We optionally drop the last frame to enable (state=u_t, action=u_{t+1}) alignment.
-        # This requires at least 2 frames per episode.
-        effective_frames = num_frames - 1 if drop_last_frame else num_frames
-        if effective_frames <= 0:
-            print(
-                f"Warning: Skipping {episode_dir.name} - not enough frames for drop_last_frame={drop_last_frame} "
-                f"(num_frames={num_frames})"
-            )
-            continue
-        # Prefer per-episode metadata task if available; fall back to CLI task_description.
-        ep_task = metadata.get("task") if isinstance(metadata, dict) else None
-        if not isinstance(ep_task, str) or not ep_task.strip():
-            ep_task = task_description
-        # Canonicalize task text for dataset storage (closer to LeRobot standard: raw text).
-        ep_task = ep_task.replace("_", " ").strip()
-        episode_data_list.append({
-            "ep_idx": len(episode_data_list),  # New sequential index
-            "episode_dir": episode_dir,
-            "metadata": metadata,
-            "task": ep_task,
-            "robot_data": robot_data,
-            "num_frames": num_frames,
-            "effective_frames": effective_frames,
-            "video_from_frame": total_video_frames,
-        })
-        total_video_frames += effective_frames
-    if len(episode_data_list) == 0:
-        raise ValueError(f"No valid episodes found in {input_dir} (all have 0 frames?)")
-    # Get image dimensions from first camera's first frame
-    first_ep = episode_data_list[0]
-    # Validate that all cameras share the same resolution (required by a single mp4 per camera)
-    height = width = None
-    for cam in cameras:
-        first_img_path = first_ep["episode_dir"] / cam / "0.jpg"
-        if not first_img_path.exists():
-            first_img_path = first_ep["episode_dir"] / cam / "0.png"
-        first_img = cv2.imread(str(first_img_path))
-        if first_img is None:
-            raise FileNotFoundError(f"Missing first frame for camera '{cam}' at {first_img_path}")
-        h, w = first_img.shape[:2]
-        if height is None:
-            height, width = h, w
-        elif (h, w) != (height, width):
-            raise ValueError(
-                f"Camera resolution mismatch. Expected {(height, width)} but '{cam}' has {(h, w)}. "
-                "Please resize/crop during conversion or ensure all cameras match."
-            )
-    image_shape = (height, width, 3)
-    print(f"Image shape: {image_shape}")
-    # Build task index mapping (supports multi-task datasets).
-    unique_tasks = []
-    seen_tasks = set()
-    for ep_data in episode_data_list:
-        t = ep_data.get("task", task_description)
-        if t not in seen_tasks:
-            seen_tasks.add(t)
-            unique_tasks.append(t)
-    task_to_index = {t: i for i, t in enumerate(unique_tasks)}
-    # NOTE: We intentionally do NOT pre-tokenize language here.
-    # Store raw task text in parquet under `task`, and let training-time
-    # tokenizer/collator generate tokens + attention masks dynamically.
-    # Pass 2: Create videos and collect data
-    print("\nPass 2: Creating videos and processing frames...")
-    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
-    writers = {}
-    for cam in cameras:
-        writers[cam] = cv2.VideoWriter(str(video_paths[cam]), fourcc, fps, (width, height))
-    all_data_records = []
-    episode_records = []
-    all_states = []
-    all_actions = []
-    global_frame_index = 0
-    for ep_data in tqdm(episode_data_list, desc="Processing"):
-        ep_idx = ep_data["ep_idx"]
-        episode_dir = ep_data["episode_dir"]
-        robot_data = ep_data["robot_data"]
-        num_frames = ep_data["num_frames"]
-        effective_frames = ep_data["effective_frames"]
-        video_from_frame = ep_data["video_from_frame"]
-        ep_task = ep_data.get("task", task_description)
-        ep_task_index = task_to_index.get(ep_task, 0)
-        # Write video frames for all cameras
-        for frame_idx in range(effective_frames):
-            for cam in cameras:
-                # Support both jpg and png; enforce 1 frame written per index to keep timestamps aligned.
-                img_path = episode_dir / cam / f"{frame_idx}.jpg"
-                if not img_path.exists():
-                    img_path = episode_dir / cam / f"{frame_idx}.png"
-                img = cv2.imread(str(img_path))
-                if img is None:
-                    raise FileNotFoundError(
-                        f"Missing/corrupted image for {episode_dir.name} cam={cam} frame={frame_idx}: {img_path}"
-                    )
-                writers[cam].write(img)
-        # Extract raw targets u_t.
-        state_columns = ["j0", "j1", "j2", "j3", "j4", "j5", "gripper"]
-        episode_u = robot_data[state_columns].values[:num_frames].astype(np.float32)
-        episode_u[:, -1] = episode_u[:, -1] / 1000.0  # Normalize gripper
-        # Align sequences for training.
-        # We always build per-frame records of length `effective_frames`.
-        if drop_last_frame:
-            # Default recommended alignment when images and proprio are synchronous at time t:
-            #   observation.state[t] = u_t
-            #   action[t] = u_{t+1}
-            # by dropping the last frame.
-            base_u = episode_u[:-1]  # u_0 .. u_{T-2}
-            next_u = episode_u[1:]   # u_1 .. u_{T-1}
-        else:
-            base_u = episode_u
-            next_u = episode_u
-        if state_mode == "current_action":
-            episode_states = base_u.copy()
-        elif state_mode == "prev_action":
-            # observation.state[t] = u_{t-1}, with boundary state[0] = u_0.
-            if len(base_u) == 1:
-                episode_states = base_u.copy()
-            else:
-                episode_states = np.vstack([base_u[0:1], base_u[:-1]])
-        else:
-            raise ValueError(f"Unsupported state_mode: {state_mode}")
-        if action_mode == "current_action":
-            episode_actions = base_u.copy()
-        elif action_mode == "next_action":
-            episode_actions = next_u.copy()
-        else:
-            raise ValueError(f"Unsupported action_mode: {action_mode}")
-        # IMPORTANT: timestamp should be relative to episode start, in seconds
-        # LeRobot uses this for video frame lookup: from_timestamp + timestamp
-        # So timestamp should be 0, 1/fps, 2/fps, ... for frame 0, 1, 2, ...
-        dataset_from_index = global_frame_index
-        # Create frame records (NO video columns - loaded separately)
-        for frame_idx in range(effective_frames):
-            # timestamp in seconds from episode start
-            frame_timestamp = frame_idx / fps
-            record = {
-                "observation.state": episode_states[frame_idx].tolist(),
-                "action": episode_actions[frame_idx].tolist(),
-                "timestamp": frame_timestamp,  # seconds from episode start
-                "episode_index": ep_idx,
-                "frame_index": frame_idx,
-                "index": global_frame_index,
-                "task": ep_task,
-                "task_index": ep_task_index,
-                "next.done": frame_idx == effective_frames - 1,
-            }
-            all_data_records.append(record)
-            all_states.append(episode_states[frame_idx])
-            all_actions.append(episode_actions[frame_idx])
-            global_frame_index += 1
-        # LeRobot v3 expects dataset_to_index to be EXCLUSIVE (right-open interval):
-        # frames for this episode are in [dataset_from_index, dataset_to_index)
-        dataset_to_index = global_frame_index
-        # Episode metadata with video references
-        episode_record = {
-            "episode_index": ep_idx,
-            "tasks": [ep_task],
-            "length": effective_frames,
-            "task_index": ep_task_index,
-            # Data file location
-            "data/chunk_index": 0,
-            "data/file_index": 0,
-            "dataset_from_index": dataset_from_index,
-            "dataset_to_index": dataset_to_index,
-        }
-        # Add video metadata for each camera dynamically
-        for cam in cameras:
-            video_key = f"observation.images.{cam}"
-            episode_record.update({
-                f"videos/{video_key}/chunk_index": 0,
-                f"videos/{video_key}/file_index": 0,
-                f"videos/{video_key}/from_timestamp": video_from_frame / fps,
-                # LeRobot expects to_timestamp to be the episode END time (exclusive), not last-frame time.
-                f"videos/{video_key}/to_timestamp": (video_from_frame + effective_frames) / fps,
-            })
-        episode_records.append(episode_record)
-    # Close video writers
-    for writer in writers.values():
-        writer.release()
-    print(f"Total frames: {global_frame_index}")
-    print(f"Total episodes: {len(episode_records)}")
-    # Compute statistics
-    all_states = np.array(all_states)
-    all_actions = np.array(all_actions)
-    stats = compute_stats(all_states, all_actions, cameras)
-    # Save data parquet
-    print("Saving data parquet...")
-    df = pd.DataFrame(all_data_records)
-    df.to_parquet(data_dir / "file-000.parquet", index=False)
-    # Save episodes parquet
-    print("Saving episodes metadata...")
-    episodes_df = pd.DataFrame(episode_records)
-    episodes_df.to_parquet(episodes_meta_dir / "file-000.parquet", index=False)
-    # Save tasks.parquet
-    # LeRobot v3 convention: task strings are stored in the dataframe index; task_index is a column.
-    tasks_items = sorted(task_to_index.items(), key=lambda kv: kv[1])
-    tasks_df = pd.DataFrame({"task_index": [idx for _, idx in tasks_items]}, index=[t for t, _ in tasks_items])
-    tasks_df.to_parquet(meta_dir / "tasks.parquet", index=True)
-    # Save stats.json
-    with open(meta_dir / "stats.json", "w") as f:
-        json.dump(stats, f, indent=2)
-    # Video info
-    video_info = {
-        "video.fps": fps,
-        "video.codec": "mp4v",
-        "video.pix_fmt": "yuv420p",
-        "video.is_depth_map": False,
-        "has_audio": False,
-    }
-    # Save info.json
-    features = {
-        "observation.state": {
-            "dtype": "float32",
-            "shape": [7],
-            "names": ["j0", "j1", "j2", "j3", "j4", "j5", "gripper"],
-        },
-        "action": {
-            "dtype": "float32",
-            "shape": [7],
-            "names": ["j0", "j1", "j2", "j3", "j4", "j5", "gripper"],
-        },
-    }
-    # Add camera features dynamically
-    for cam in cameras:
-        video_key = f"observation.images.{cam}"
-        features[video_key] = {
-            "dtype": "video",
-            "shape": list(image_shape),
-            "names": ["height", "width", "channel"],
-            "info": video_info,
-        }
-    # Add metadata features
-    features.update({
-        "timestamp": {"dtype": "float64", "shape": [1], "names": None},
-        "episode_index": {"dtype": "int64", "shape": [1], "names": None},
-        "frame_index": {"dtype": "int64", "shape": [1], "names": None},
-        "index": {"dtype": "int64", "shape": [1], "names": None},
-        "task": {"dtype": "string", "shape": [1], "names": None},
-        "task_index": {"dtype": "int64", "shape": [1], "names": None},
-        "next.done": {"dtype": "bool", "shape": [1], "names": None},
-    })
-    info = {
-        "codebase_version": "v3.0",
-        "robot_type": robot_type,
-        "fps": fps,
-        "total_episodes": len(episode_records),
-        "total_frames": global_frame_index,
-        "total_tasks": len(unique_tasks),
-        "total_videos": len(cameras),
-        "total_chunks": 1,
-        "chunks_size": global_frame_index,
-        "data_path": "data/chunk-{chunk_index:03d}/file-{file_index:03d}.parquet",
-        "video_path": "videos/chunk-{chunk_index:03d}/{video_key}/file-{file_index:03d}.mp4",
-        "splits": {"train": f"0:{len(episode_records)}"},
-        "features": features,
-    }
-    with open(meta_dir / "info.json", "w") as f:
-        json.dump(info, f, indent=2)
-    print(f"\nDataset conversion complete!")
-    print(f"Output directory: {output_dir}")
-    print(f"Cameras: {cameras}")
-    print(f"Total episodes: {len(episode_records)}")
-    print(f"Total frames: {global_frame_index}")
-    print(f"Total videos: {len(cameras)}")
-def main():
-    parser = argparse.ArgumentParser(description="Convert pick_apple data to LeRobot format")
-    parser.add_argument("--input", type=str, default="pick_apple")
-    parser.add_argument("--output", type=str, default="data/pick_apple_lerobot")
-    parser.add_argument("--fps", type=int, default=30)
-    parser.add_argument("--task", type=str, default="pick apple")
-    parser.add_argument("--robot-type", type=str, default="so100")
-    parser.add_argument(
-        "--state-mode",
-        type=str,
-        default="current_action",
-        choices=["prev_action", "current_action"],
-        help="How to construct observation.state from target commands u_t.",
-    )
-    parser.add_argument(
-        "--action-mode",
-        type=str,
-        default="next_action",
-        choices=["current_action", "next_action"],
-        help=(
-            "How to construct action targets from target commands u_t. "
-            "next_action uses u_{t+1} (recommended when dropping last frame)."
-        ),
-    )
-    parser.add_argument(
-        "--keep-last-frame",
-        action="store_true",
-        help="Keep the last frame (disables dropping). When enabled, action_mode=next_action becomes current_action.",
-    )
-    args = parser.parse_args()
-    input_dir = Path(args.input)
-    output_dir = Path(args.output)
-    if not input_dir.exists():
-        raise ValueError(f"Input directory does not exist: {input_dir}")
-    convert_dataset(
-        input_dir,
-        output_dir,
-        fps=args.fps,
-        task_description=args.task,
-        robot_type=args.robot_type,
-        state_mode=args.state_mode,
-        action_mode=args.action_mode,
-        drop_last_frame=not args.keep_last_frame,
-    )
-if __name__ == "__main__":
-    main()