Upload folder using huggingface_hub

convert_to_hdf5.py

@@ -0,0 +1,165 @@
+import h5py
+import cv2
+import numpy as np
+import argparse
+import csv
+import json
+from pathlib import Path
+import shutil
+
+def load_robot_data(csv_path):
+    """
+    Returns: master_ts, robot_ts, qpos, gripper
+    """
+    master_timestamps = []
+    robot_timestamps = []
+    qpos = []
+    gripper = []
+    
+    with open(csv_path, 'r') as f:
+        reader = csv.reader(f)
+        try:
+            header = next(reader)
+            
+            # Check format
+            # Format 1: master_timestamp, robot_timestamp, j0..j5, gripper
+            # Format 2: cam_timestamp, robot_timestamp, j0..j5, gripper (Previous version)
+            # Format 3: timestamp, j0..j5, gripper (Legacy)
+            
+            if header[0] == 'master_timestamp' or header[0] == 'cam_timestamp':
+                # New formats
+                for row in reader:
+                    master_timestamps.append(float(row[0]))
+                    robot_timestamps.append(float(row[1]))
+                    qpos.append([float(x) for x in row[2:8]])
+                    gripper.append(float(row[8]))
+            else:
+                # Legacy format
+                for row in reader:
+                    t = float(row[0])
+                    master_timestamps.append(t)
+                    robot_timestamps.append(t)
+                    qpos.append([float(x) for x in row[1:7]])
+                    gripper.append(float(row[7]))
+                    
+        except StopIteration:
+            return np.array([]), np.array([]), np.array([]), np.array([])
+            
+    return np.array(master_timestamps), np.array(robot_timestamps), np.array(qpos), np.array(gripper)
+
+def process_episode(episode_path, output_path):
+    print(f"Processing {episode_path}...")
+    
+    csv_path = episode_path / "robot_data.csv"
+    
+    if not csv_path.exists():
+        print(f"Skipping {episode_path}: Missing CSV")
+        return
+
+    # Load Robot Data
+    master_ts, robot_ts, qpos, gripper = load_robot_data(csv_path)
+    
+    if len(master_ts) == 0:
+        print(f"Skipping {episode_path}: Empty CSV")
+        return
+
+    num_frames = len(master_ts)
+    
+    # Find all camera directories
+    cam_dirs = sorted(list(episode_path.glob("cam_*")))
+    
+    if not cam_dirs:
+        print(f"Skipping {episode_path}: No camera directories found")
+        return
+
+    # Prepare HDF5 file
+    with h5py.File(output_path, 'w') as root:
+        root.attrs['sim'] = False
+        
+        obs = root.create_group('observations')
+        
+        # Robot State
+        obs.create_dataset('qpos', data=qpos)
+        obs.create_dataset('qvel', data=np.zeros_like(qpos)) # Placeholder, see below
+        
+        # Process Images
+        min_frames = num_frames
+        
+        for cam_dir in cam_dirs:
+            cam_name = cam_dir.name # e.g. cam_head
+            image_files = sorted(list(cam_dir.glob("*.jpg")), key=lambda x: int(x.stem))
+            
+            # Check count
+            if len(image_files) != num_frames:
+                print(f"Warning: {cam_name} frames ({len(image_files)}) != CSV rows ({num_frames}). Truncating.")
+                min_frames = min(min_frames, len(image_files))
+            
+            # Load images
+            # Note: Loading all to memory might be heavy for many cameras/long episodes
+            # Consider chunking if needed. For now, simple load.
+            images = []
+            for img_path in image_files[:min_frames]:
+                img = cv2.imread(str(img_path))
+                images.append(img)
+            
+            images = np.array(images)
+            obs.create_dataset(f'images/{cam_name}', data=images)
+            
+        # Truncate robot data if images were shorter
+        if min_frames < num_frames:
+            qpos = qpos[:min_frames]
+            gripper = gripper[:min_frames]
+            robot_ts = robot_ts[:min_frames]
+            master_ts = master_ts[:min_frames]
+            
+            # Re-save truncated qpos
+            del obs['qpos']
+            obs.create_dataset('qpos', data=qpos)
+
+        # Compute qvel
+        qvel = np.zeros_like(qpos)
+        if len(qpos) > 1:
+            dt = np.diff(robot_ts)
+            dt = np.where(dt == 0, 1e-3, dt)[:, None]
+            qvel[:-1] = (qpos[1:] - qpos[:-1]) / dt
+            qvel[-1] = qvel[-2]
+        
+        del obs['qvel']
+        obs.create_dataset('qvel', data=qvel)
+        
+        # Action
+        action = np.zeros_like(qpos)
+        action[:-1] = qpos[1:]
+        action[-1] = qpos[-1]
+        
+        root.create_dataset('action', data=action)
+        
+        # Store timestamps
+        # obs.create_dataset('timestamp', data=master_ts)
+        
+    print(f"Saved to {output_path}")
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert raw data to HDF5 for ACT")
+    parser.add_argument('--task', required=True, help="Task name")
+    parser.add_argument('--out', default="dataset.hdf5", help="Output HDF5 filename (or dir)")
+    args = parser.parse_args()
+    
+    data_root = Path("data")
+    task_dir = data_root / args.task
+    
+    if not task_dir.exists():
+        print(f"Task {args.task} not found in {data_root}")
+        return
+
+    episodes = sorted(list(task_dir.glob("episode_*")))
+    
+    output_dir = Path(args.out)
+    output_dir.mkdir(exist_ok=True, parents=True)
+    
+    for ep_dir in episodes:
+        out_name = f"{ep_dir.name}.hdf5"
+        process_episode(ep_dir, output_dir / out_name)
+
+if __name__ == "__main__":
+    main()

convert_to_lerobot.py

@@ -0,0 +1,666 @@
+"""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()

patch_lerobot_for_smolvla.py

@@ -0,0 +1,298 @@
+"""Patch an existing LeRobot v3 dataset to be usable for SmolVLA.
+
+This script is intended for the common situation where a dataset was converted for ACT
+but is missing SmolVLA-required language fields and/or uses an incompatible definition
+for observation.state.
+
+What it does:
+- Creates a patched copy of the dataset (optionally symlinking videos to avoid duplication)
+- Sets observation.state to the previous target (scheme-2): state[t] = action[t-1] within each episode
+  (state[0] is set to action[0] as a boundary condition)
+- Adds SmolVLA language inputs:
+    - observation.language.tokens
+    - observation.language.attention_mask
+  computed from each episode's metadata.json "task" string using a Transformers tokenizer.
+- Updates meta/info.json features and meta/stats.json.
+- Updates meta/tasks.parquet (task strings live in the dataframe index) and meta/episodes parquet "tasks".
+
+Usage example:
+  python backend/scripts/patch_lerobot_for_smolvla.py \
+    --dataset-dir backend/datasets/pick_up_objects \
+    --raw-dir backend/data/pick_up_objects \
+    --output-dir backend/datasets/pick_up_objects_smolvla \
+    --vlm-model-name HuggingFaceTB/SmolVLM2-500M-Video-Instruct \
+    --tokenizer-max-length 48
+
+Notes:
+- This does NOT re-encode videos.
+- Requires "transformers" to be installed in the current environment.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+try:
+    from transformers import AutoTokenizer
+
+    _TRANSFORMERS_AVAILABLE = True
+except Exception:
+    _TRANSFORMERS_AVAILABLE = False
+
+try:
+    from lerobot.datasets.compute_stats import DEFAULT_QUANTILES, get_feature_stats
+
+    _LEROBOT_STATS_AVAILABLE = True
+except Exception:
+    _LEROBOT_STATS_AVAILABLE = False
+
+
+STATE_KEY = "observation.state"
+ACTION_KEY = "action"
+LANG_TOKENS_KEY = "observation.language.tokens"
+LANG_MASK_KEY = "observation.language.attention_mask"
+
+
+def _iter_episode_dirs(raw_dir: Path) -> list[Path]:
+    eps = [p for p in raw_dir.iterdir() if p.is_dir() and p.name.startswith("episode_")]
+    eps.sort(key=lambda p: int(p.name.split("_")[1]))
+    return eps
+
+
+def _collect_tasks_from_raw(raw_dir: Path) -> list[str]:
+    tasks: list[str] = []
+    for ep_dir in _iter_episode_dirs(raw_dir):
+        meta_path = ep_dir / "metadata.json"
+        if not meta_path.exists():
+            continue
+        meta = json.loads(meta_path.read_text())
+        task = meta.get("task")
+        if isinstance(task, str) and task.strip():
+            tasks.append(task.strip())
+    # preserve order but unique
+    seen = set()
+    uniq: list[str] = []
+    for t in tasks:
+        if t not in seen:
+            seen.add(t)
+            uniq.append(t)
+    return uniq
+
+
+def _normalize_task_text(task: str) -> str:
+    # Keep it minimal and stable: convert snake_case to words.
+    return task.replace("_", " ").strip()
+
+
+def _encode_tasks(tasks: list[str], vlm_model_name: str, tokenizer_max_length: int) -> dict[str, tuple[list[int], list[int]]]:
+    if not _TRANSFORMERS_AVAILABLE:
+        raise RuntimeError(
+            "transformers is required to generate language tokens. Install it with `pip install transformers`."
+        )
+
+    tokenizer = AutoTokenizer.from_pretrained(vlm_model_name, use_fast=True)
+    encoded: dict[str, tuple[list[int], list[int]]] = {}
+    for task in tasks:
+        text = _normalize_task_text(task)
+        out = tokenizer(
+            text,
+            padding="max_length",
+            truncation=True,
+            max_length=tokenizer_max_length,
+            return_attention_mask=True,
+            return_tensors=None,
+        )
+        input_ids = list(map(int, out["input_ids"]))
+        attn = list(map(int, out["attention_mask"]))
+        if len(input_ids) != tokenizer_max_length or len(attn) != tokenizer_max_length:
+            raise ValueError("Tokenizer output length mismatch; expected fixed max_length")
+        encoded[task] = (input_ids, attn)
+
+    return encoded
+
+
+def _compute_stats(states: np.ndarray, actions: np.ndarray, existing_stats: dict) -> dict:
+    # Recompute state/action stats; preserve image stats unchanged.
+    stats = dict(existing_stats) if isinstance(existing_stats, dict) else {}
+
+    if _LEROBOT_STATS_AVAILABLE:
+        state_stats = get_feature_stats(states, axis=0, keepdims=False, quantile_list=DEFAULT_QUANTILES)
+        action_stats = get_feature_stats(actions, axis=0, keepdims=False, quantile_list=DEFAULT_QUANTILES)
+        stats[STATE_KEY] = {k: v.tolist() for k, v in state_stats.items()}
+        stats[ACTION_KEY] = {k: v.tolist() for k, v in action_stats.items()}
+    else:
+        stats[STATE_KEY] = {
+            "min": states.min(axis=0).tolist(),
+            "max": states.max(axis=0).tolist(),
+            "mean": states.mean(axis=0).tolist(),
+            "std": states.std(axis=0).tolist(),
+        }
+        stats[ACTION_KEY] = {
+            "min": actions.min(axis=0).tolist(),
+            "max": actions.max(axis=0).tolist(),
+            "mean": actions.mean(axis=0).tolist(),
+            "std": actions.std(axis=0).tolist(),
+        }
+
+    return stats
+
+
+def patch_dataset(
+    dataset_dir: Path,
+    raw_dir: Path,
+    output_dir: Path,
+    vlm_model_name: str,
+    tokenizer_max_length: int,
+    symlink_videos: bool,
+) -> None:
+    if not dataset_dir.exists():
+        raise FileNotFoundError(f"dataset_dir not found: {dataset_dir}")
+    if not raw_dir.exists():
+        raise FileNotFoundError(f"raw_dir not found: {raw_dir}")
+
+    tasks = _collect_tasks_from_raw(raw_dir)
+    if not tasks:
+        raise ValueError(f"No tasks found in raw metadata under {raw_dir}")
+    if len(tasks) != 1:
+        # The existing converter currently writes a single task_index=0 for all frames.
+        # If you truly have multiple tasks, you should re-convert with a corrected mapping.
+        raise ValueError(
+            f"Found {len(tasks)} unique tasks in raw data ({tasks}), but this dataset appears single-task. "
+            "Re-run conversion with multi-task support if needed."
+        )
+
+    task = tasks[0]
+    encoded = _encode_tasks([task], vlm_model_name, tokenizer_max_length)
+    tok, mask = encoded[task]
+
+    if output_dir.exists():
+        shutil.rmtree(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Copy data/meta; reuse videos via symlink if requested.
+    shutil.copytree(dataset_dir / "data", output_dir / "data")
+    shutil.copytree(dataset_dir / "meta", output_dir / "meta")
+
+    src_videos = dataset_dir / "videos"
+    if src_videos.exists():
+        if symlink_videos:
+            (output_dir / "videos").symlink_to(src_videos, target_is_directory=True)
+        else:
+            shutil.copytree(src_videos, output_dir / "videos")
+
+    # Patch tasks.parquet (task string is the index).
+    tasks_df = pd.DataFrame({"task_index": [0]}, index=[task])
+    tasks_df.to_parquet(output_dir / "meta" / "tasks.parquet", index=True)
+
+    # Patch episodes parquet (update tasks list entry).
+    episodes_paths = sorted((output_dir / "meta" / "episodes").glob("chunk-*/*.parquet"))
+    if not episodes_paths:
+        raise FileNotFoundError("No episodes parquet found under meta/episodes")
+    for ep_path in episodes_paths:
+        edf = pd.read_parquet(ep_path)
+        if "tasks" in edf.columns:
+            edf["tasks"] = [[task] for _ in range(len(edf))]
+        if "task_index" in edf.columns:
+            edf["task_index"] = 0
+        edf.to_parquet(ep_path, index=False)
+
+    # Patch data parquet(s).
+    data_paths = sorted((output_dir / "data").glob("chunk-*/*.parquet"))
+    if not data_paths:
+        raise FileNotFoundError("No data parquet found under data/")
+
+    all_states = []
+    all_actions = []
+
+    for dp in data_paths:
+        df = pd.read_parquet(dp)
+        required = {STATE_KEY, ACTION_KEY, "episode_index", "frame_index", "task_index"}
+        missing = required - set(df.columns)
+        if missing:
+            raise ValueError(f"Missing required columns in {dp}: {sorted(missing)}")
+
+        df = df.sort_values(["episode_index", "frame_index"]).reset_index(drop=False)
+        # Shift state within each episode: state[t] = action[t-1]
+        action_arr = np.stack(df[ACTION_KEY].to_numpy())
+        ep_idx = df["episode_index"].to_numpy()
+
+        state_arr = np.empty_like(action_arr)
+        # process per episode
+        start = 0
+        while start < len(df):
+            curr_ep = ep_idx[start]
+            end = start
+            while end < len(df) and ep_idx[end] == curr_ep:
+                end += 1
+            a = action_arr[start:end]
+            s = np.vstack([a[0:1], a[:-1]])
+            state_arr[start:end] = s
+            start = end
+
+        # Add language columns (same for all rows; single-task)
+        df[STATE_KEY] = [row.tolist() for row in state_arr]
+        df[LANG_TOKENS_KEY] = [tok for _ in range(len(df))]
+        df[LANG_MASK_KEY] = [mask for _ in range(len(df))]
+
+        # Restore original row order (by the previous dataframe index).
+        df = df.sort_values("index").drop(columns=["index"]).reset_index(drop=True)
+
+        dp.parent.mkdir(parents=True, exist_ok=True)
+        df.to_parquet(dp, index=False)
+
+        all_states.append(state_arr)
+        all_actions.append(action_arr)
+
+    # Update info.json features.
+    info_path = output_dir / "meta" / "info.json"
+    info = json.loads(info_path.read_text())
+    features = info.get("features", {})
+    features[LANG_TOKENS_KEY] = {"dtype": "int64", "shape": [tokenizer_max_length], "names": None}
+    features[LANG_MASK_KEY] = {"dtype": "int64", "shape": [tokenizer_max_length], "names": None}
+    info["features"] = features
+    info["total_tasks"] = 1
+    info_path.write_text(json.dumps(info, indent=2))
+
+    # Update stats.json.
+    stats_path = output_dir / "meta" / "stats.json"
+    existing_stats = json.loads(stats_path.read_text()) if stats_path.exists() else {}
+
+    states = np.concatenate(all_states, axis=0)
+    actions = np.concatenate(all_actions, axis=0)
+    stats = _compute_stats(states, actions, existing_stats)
+    stats_path.write_text(json.dumps(stats, indent=2))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Patch a LeRobot dataset for SmolVLA")
+    parser.add_argument("--dataset-dir", type=str, required=True)
+    parser.add_argument("--raw-dir", type=str, required=True)
+    parser.add_argument("--output-dir", type=str, required=True)
+    parser.add_argument(
+        "--vlm-model-name",
+        type=str,
+        default="HuggingFaceTB/SmolVLM2-500M-Video-Instruct",
+    )
+    parser.add_argument("--tokenizer-max-length", type=int, default=48)
+    parser.add_argument("--no-symlink-videos", action="store_true")
+
+    args = parser.parse_args()
+
+    patch_dataset(
+        dataset_dir=Path(args.dataset_dir),
+        raw_dir=Path(args.raw_dir),
+        output_dir=Path(args.output_dir),
+        vlm_model_name=args.vlm_model_name,
+        tokenizer_max_length=args.tokenizer_max_length,
+        symlink_videos=not args.no_symlink_videos,
+    )
+
+
+if __name__ == "__main__":
+    main()

test_camera_fps.py

@@ -0,0 +1,85 @@
+import cv2
+import time
+import sys
+
+def test_camera(device_id, width=640, height=480, fps=30):
+    print(f"\n=== Testing Camera Index {device_id} ===")
+    
+    # 优先使用 V4L2 后端
+    backend = cv2.CAP_V4L2 if hasattr(cv2, 'CAP_V4L2') else cv2.CAP_ANY
+    backend_name = "V4L2" if backend == cv2.CAP_V4L2 else "ANY"
+    print(f"Opening with backend: {backend_name}")
+
+    cap = cv2.VideoCapture(device_id, backend)
+    
+    if not cap.isOpened():
+        print(f"Error: Could not open camera {device_id}")
+        return
+
+    # 1. 强制 MJPG
+    print("Attempting to set MJPG format...")
+    cap.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'))
+    
+    # 2. 设置 FPS 和 分辨率
+    cap.set(cv2.CAP_PROP_FPS, fps)
+    cap.set(cv2.CAP_PROP_FRAME_WIDTH, width)
+    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, height)
+    
+    # 3. 关闭自动曝光 (Linux V4L2 特有，尝试通过 OpenCV 属性设置)
+    # 0.25 通常对应 'Manual'，但在不同驱动下可能不同，这里仅作为尝试
+    # cap.set(cv2.CAP_PROP_AUTO_EXPOSURE, 0.25) 
+
+    # 4. 读取实际生效的设置
+    actual_w = cap.get(cv2.CAP_PROP_FRAME_WIDTH)
+    actual_h = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
+    actual_fps = cap.get(cv2.CAP_PROP_FPS)
+    fourcc = int(cap.get(cv2.CAP_PROP_FOURCC))
+    codec = "".join([chr((fourcc >> 8 * i) & 0xFF) for i in range(4)])
+    
+    print(f"----------------------------------------")
+    print(f"Requested: {width}x{height} @ {fps} FPS, MJPG")
+    print(f"Actual   : {actual_w}x{actual_h} @ {actual_fps} FPS, Codec: {codec}")
+    print(f"----------------------------------------")
+    
+    if codec.upper() != "MJPG":
+        print("WARNING: Codec is NOT MJPG! This is likely the cause of low FPS.")
+
+    print("Warming up camera (skip 10 frames)...")
+    for _ in range(10):
+        cap.read()
+
+    print(f"Starting capture loop for 100 frames...")
+    count = 0
+    start_time = time.time()
+    
+    while count < 100:
+        ret, frame = cap.read()
+        if not ret:
+            print("Error: Failed to read frame during loop")
+            break
+        count += 1
+        # 显示简略进度
+        if count % 10 == 0:
+            sys.stdout.write(f"{count}..")
+            sys.stdout.flush()
+            
+    end_time = time.time()
+    duration = end_time - start_time
+    avg_fps = count / duration
+    
+    print(f"\n\nRESULT: Captured {count} frames in {duration:.2f} seconds.")
+    print(f"AVERAGE FPS: {avg_fps:.2f}")
+    
+    cap.release()
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python test_camera_fps.py <device_id> [width] [height] [fps]")
+        print("Example: python backend/scripts/test_camera_fps.py 0 640 480 30")
+    else:
+        dev_id = int(sys.argv[1])
+        w = int(sys.argv[2]) if len(sys.argv) > 2 else 640
+        h = int(sys.argv[3]) if len(sys.argv) > 3 else 480
+        f = int(sys.argv[4]) if len(sys.argv) > 4 else 30
+        test_camera(dev_id, w, h, f)
+

test_camera_manager_fps.py

@@ -0,0 +1,67 @@
+import time
+import argparse
+import logging
+
+from core.camera import CameraManager
+
+
+def main(devices, duration: float = 10.0):
+    """
+    使用项目里的 CameraManager / SingleCamera 逻辑，单独测试真实采集 FPS，
+    不经过 FastAPI / WebSocket / DataRecorder。
+    """
+    # Enable INFO logs so我们能看到 SingleCamera 初始化实际的分辨率 / FPS / 编码
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    )
+
+    cam_manager = CameraManager()
+
+    # 构造角色映射：head / wrist / left / right 按顺序分配
+    roles = ["head", "wrist", "left", "right", "aux"]
+    mapping = {}
+    for i, dev in enumerate(devices):
+        if i < len(roles):
+            mapping[roles[i]] = dev
+
+    print("Config mapping:", mapping)
+    cam_manager.configure(mapping, mock_all=False)
+    cam_manager.start_all()
+
+    t0 = time.time()
+    last_print = t0
+    print_interval = 1.0
+
+    try:
+        while time.time() - t0 < duration:
+            status = cam_manager.get_status()
+            now = time.time()
+            if now - last_print >= print_interval:
+                print(f"[{now - t0:5.2f}s] Camera status:")
+                for role, info in status.items():
+                    print(f"  - {role}: dev={info['device_id']}, fps={info['fps']:.2f}, mock={info['is_mock']}")
+                last_print = now
+            time.sleep(0.05)
+    finally:
+        cam_manager.stop_all()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "devices",
+        nargs="+",
+        type=int,
+        help="Camera device indices, e.g. 0 2",
+    )
+    parser.add_argument(
+        "--duration",
+        type=float,
+        default=10.0,
+        help="Test duration in seconds (default 10)",
+    )
+    args = parser.parse_args()
+    main(args.devices, args.duration)
+
+

test_dual_cameras_fps.py

@@ -0,0 +1,88 @@
+import cv2
+import threading
+import time
+import sys
+
+def capture_loop(device_id, width, height, fps, results, index):
+    print(f"[Cam {device_id}] Starting initialization...")
+    
+    backend = cv2.CAP_V4L2 if hasattr(cv2, 'CAP_V4L2') else cv2.CAP_ANY
+    cap = cv2.VideoCapture(device_id, backend)
+    
+    if not cap.isOpened():
+        print(f"[Cam {device_id}] FAILED to open.")
+        results[index] = 0.0
+        return
+
+    # 强制 MJPG
+    cap.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'))
+    cap.set(cv2.CAP_PROP_FPS, fps)
+    cap.set(cv2.CAP_PROP_FRAME_WIDTH, width)
+    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, height)
+    
+    # 检查实际 Codec
+    fourcc = int(cap.get(cv2.CAP_PROP_FOURCC))
+    codec = "".join([chr((fourcc >> 8 * i) & 0xFF) for i in range(4)])
+    actual_fps = cap.get(cv2.CAP_PROP_FPS)
+    print(f"[Cam {device_id}] Initialized. Codec: {codec}, Target: {fps}, Actual Report: {actual_fps}")
+
+    # 热身
+    for _ in range(10):
+        cap.read()
+        
+    print(f"[Cam {device_id}] Start capturing 100 frames...")
+    
+    count = 0
+    start_time = time.time()
+    
+    while count < 100:
+        ret, _ = cap.read()
+        if ret:
+            count += 1
+        else:
+            time.sleep(0.001)
+            
+    end_time = time.time()
+    cap.release()
+    
+    duration = end_time - start_time
+    avg_fps = count / duration
+    results[index] = avg_fps
+    print(f"[Cam {device_id}] FINISHED. Avg FPS: {avg_fps:.2f}")
+
+def test_dual_cameras(dev1, dev2):
+    print(f"=== Testing Dual Cameras Concurrent: {dev1} & {dev2} ===")
+    print("NOTE: If total bandwidth exceeds USB limit, FPS will drop.\n")
+    
+    results = [0.0, 0.0]
+    
+    t1 = threading.Thread(target=capture_loop, args=(dev1, 640, 480, 30, results, 0))
+    t2 = threading.Thread(target=capture_loop, args=(dev2, 640, 480, 30, results, 1))
+    
+    # 同时启动
+    t1.start()
+    t2.start()
+    
+    t1.join()
+    t2.join()
+    
+    print("\n=== FINAL RESULTS ===")
+    print(f"Camera {dev1}: {results[0]:.2f} FPS")
+    print(f"Camera {dev2}: {results[1]:.2f} FPS")
+    
+    if results[0] < 20 or results[1] < 20:
+        print("\n[!] LOW FPS DETECTED.")
+        print("Possible causes:")
+        print("1. USB Bandwidth saturation (Try plugging into different USB ports/hubs).")
+        print("2. Low light condition triggering auto-exposure lag.")
+        print("3. One camera fell back to YUYV instead of MJPG.")
+    else:
+        print("\n[OK] Both cameras running smoothly.")
+
+if __name__ == "__main__":
+    if len(sys.argv) < 3:
+        print("Usage: python backend/scripts/test_dual_cameras_fps.py <id1> <id2>")
+        print("Example: python backend/scripts/test_dual_cameras_fps.py 0 2")
+    else:
+        test_dual_cameras(int(sys.argv[1]), int(sys.argv[2]))
+