clean up raw dataset

helper_scripts/LEROBOT_V3_CONVERSION_PLAN.md

@@ -0,0 +1,688 @@
+# LeRobot v3.0 Conversion Plan for PiPER Picking Tests Dataset
+
+## Executive Summary
+
+Converting piper_picking_tests from HDF5+PNG format to LeRobot v3.0 (Parquet+MP4) for VLA fine-tuning.
+
+**VERIFIED Dataset Stats (from actual files):**
+- Episodes: 13
+- Tasks: 12 (unique picking tasks)
+- Total frames: 5,016
+- Cameras: 2 (table_cam 800×720, wrist_cam **1280×720**)
+- FPS: **11-12 FPS** (verified from actual timestamps, NOT 30!)
+- Robot: 7-DOF arm
+- Current size: ~480 MB (PNG images + HDF5)
+- Expected output: ~150-200 MB (compressed MP4)
+- **Dependencies:** LeRobot v0.4.3, PyAV 15.1.0, PyTorch 2.7.1 (all installed ✅)
+
+**Data Sources:**
+- **State/Action/Timestamps**: HDF5 files (`observation/state`, `action`, `timestamp`)
+- **Images**: PNG files referenced by paths in HDF5
+- **FPS**: Calculated from actual timestamp data
+
+**Strategy:** LIBERO multi-task approach with separate tasks.parquet and task_index in frames.
+
+**Reference:** See `lerobotv3_format_explanation.md` for complete v3.0 format knowledge.
+
+## Current Format (VERIFIED)
+
+### Actual File Organization
+```
+piper_picking_tests/
+├── {episode_name}_{timestamp}.hdf5      # 13 files, 58-98 KB each
+├── {episode_name}_{timestamp}.json      # Episode metadata (optional, not used)
+└── {task_name}_images/                  # 12 folders (NOTE: task name, NOT episode name!)
+    ├── observation.images.table_cam/    # PNG frames (800×720), frame_000000.png format
+    └── observation.images.wrist_cam/    # PNG frames (1280×720), frame_000000.png format
+```
+
+**IMPORTANT:** Image folder naming uses task name only (e.g., `cleaningcloth_images`), not full episode name with timestamp!
+
+### HDF5 Structure (VERIFIED from pencil episode)
+```python
+observation/state       # [n_frames, 7] float32 - joint angles in degrees
+action                  # [n_frames, 7] float32 - commands  
+timestamp               # [n_frames] float64 - frame timestamps in seconds
+episode_index           # [n_frames] int64 - all same value per episode
+observation/images/table_cam  # [n_frames] object - paths to PNG files
+observation/images/wrist_cam  # [n_frames] object - paths to PNG files
+```
+
+**Key Finding:** HDF5 stores **PATHS** to images, not the images themselves!
+- Example: `b'cleaningcloth_images/observation.images.table_cam/frame_000000.png'`
+- Images are separate PNG files at 800×720 (table) and 1280×720 (wrist)
+- **Image naming:** Current format uses `frame_000000.png` (underscore), but LeRobot's `encode_video_frames` expects `frame-000000.png` (dash)
+- **Solution:** Copy/rename images during conversion to match required format
+
+### Verified Episode List
+```python
+EPISODES = {
+    'cleaningcloth_20251104_205021': (168 frames, 14.6s),
+    'fillamentroll_20251104_204834': (276 frames, 23.1s),
+    'gamecontroller_20251104_203816': (335 frames, 25.0s),
+    'hexwrench_20251104_204002': (333 frames, 24.4s),
+    'pencil_20251104_205415': (297 frames, 23.2s),
+    'scissors_20251104_204120': (290 frames, 21.0s),
+    'scissors_hidden_20251104_205751': (358 frames, 28.6s),
+    'screwdriver_20251104_203022': (324 frames, 24.8s),
+    'smallkey_20251104_203257': (529 frames, 39.7s),
+    'smallpaper_20251104_203636': (429 frames, 31.2s),
+    'smallwoodenstick_20251104_204353': (485 frames, 34.4s),
+    'thinmetaldisk_20251104_204557': (764 frames, 55.5s),
+    'thinmetaldisk_20251104_204721': (428 frames, 30.7s),
+}
+# Total: 5,016 frames
+```
+
+### Image Resolution (CORRECTED)
+- **table_cam**: 800×720 (W×H) RGB PNG
+- **wrist_cam**: 1280×720 (W×H) RGB PNG ← **NOT 640×480!**
+- File sizes: ~387 KB (table), ~619 KB (wrist) per frame
+- Total images per episode: 2 × n_frames PNG files
+
+## Target v3.0 Structure
+
+```
+piper_picking_tests_v3/
+├── meta/
+│   ├── info.json                        # Dataset configuration
+│   ├── stats.json                       # Aggregated statistics
+│   ├── tasks.parquet                    # 12 task descriptions (LIBERO style)
+│   └── episodes/
+│       └── chunk-000/
+│           └── file-000.parquet         # 13 episode metadata (NO tasks field)
+├── data/
+│   └── chunk-000/
+│       └── file-000.parquet             # All 5,016 frames (WITH task_index)
+└── videos/
+    ├── observation.images.table_cam/
+    │   └── chunk-000/
+    │       ├── file-000.mp4             # Episode 0 (cleaningcloth)
+    │       ├── file-001.mp4             # Episode 1 (fillamentroll)
+    │       └── ...                      # 13 videos total
+    └── observation.images.wrist_cam/
+        └── chunk-000/
+            └── ...                      # 13 videos total
+```
+
+### Why LIBERO Multi-Task Approach?
+
+**Chosen because:**
+- ✅ 12 distinct tasks (multi-task dataset)
+- ✅ Clean task management via tasks.parquet
+- ✅ Explicit task conditioning with task_index
+- ✅ Scalable for adding more tasks
+- ✅ One video per episode (flexible loading)
+
+### Video Encoding Strategy
+
+**Using LeRobot's built-in `encode_video_frames` function (recommended):**
+```python
+from lerobot.datasets.video_utils import encode_video_frames
+import shutil
+from pathlib import Path
+
+def prepare_and_encode_video(image_paths, output_path, fps=12, temp_dir=None):
+    """
+    Prepare images and encode to MP4 using LeRobot's encode_video_frames.
+    
+    NOTE: encode_video_frames expects images named 'frame-XXXXXX.png' (dash, not underscore)
+    """
+    temp = Path(temp_dir) if temp_dir else Path(output_path).parent / "temp_frames"
+    temp.mkdir(parents=True, exist_ok=True)
+    
+    # Copy images with correct naming (frame-XXXXXX.png)
+    for i, src_path in enumerate(image_paths):
+        dst = temp / f"frame-{i:06d}.png"
+        shutil.copy(src_path, dst)
+    
+    # Encode using LeRobot's function
+    encode_video_frames(
+        imgs_dir=temp,
+        video_path=output_path,
+        fps=fps,
+        vcodec="libsvtav1",  # AV1 codec (default)
+        pix_fmt="yuv420p",
+        crf=30,              # Quality (lower = better, 0-51)
+        overwrite=True
+    )
+    
+    # Cleanup temp directory
+    shutil.rmtree(temp)
+```
+
+**✅ TESTED and VERIFIED:**
+- 10 frames (800×720) encoded to 0.10 MB MP4 using libsvtav1
+- Video properties: 800×720, AV1 codec (libdav1d decoder)
+- Encoding parameters: YUV420, CRF 30, GOP 2
+
+**Expected compression:**
+- PNG: ~480 MB total (all episodes, both cameras)
+- MP4 (libsvtav1): ~150-200 MB total (60-70% compression)
+- Per episode: ~6-12 MB per camera, both cameras)
+- MP4 (av1): ~150-200 MB total (60-70% compression)
+- Per episode: ~6-12 MB per camera
+
+## Conversion Requirements
+
+### 1. Task Language Descriptions (CRITICAL for VLA)
+
+**Current:** Task names only (`"screwdriver"`, `"scissors"`)
+**Required:** Natural language instructions for VLA models (SmolVLA, Pi0, XVLA)
+
+```python
+TASK_LANGUAGE_MAP = {
+    0: "Pick up the cleaning cloth from the table.",
+    1: "Grasp and pick up the filament roll.",
+    2: "Pick up the game controller from the table.",
+    3: "Pick up the hex wrench tool.",
+    4: "Grasp and pick up the pencil.",
+    5: "Pick up the scissors from the table.",
+    6: "Find and pick up the scissors that are partially hidden.",
+    7: "Pick up the screwdriver from the table.",
+    8: "Grasp and pick up the small key.",
+    9: "Pick up the small piece of paper.",
+    10: "Pick up the small wooden stick.",
+    11: "Pick up the thin metal disk.",
+}
+```
+
+**Episode-to-task mapping:**
+```python
+EPISODE_TO_TASK = {
+    'cleaningcloth_20251104_205021': 0,
+    'fillamentroll_20251104_204834': 1,
+    'gamecontroller_20251104_203816': 2,
+    'hexwrench_20251104_204002': 3,
+    'pencil_20251104_205415': 4,
+    'scissors_20251104_204120': 5,
+    'scissors_hidden_20251104_205751': 6,
+    'screwdriver_20251104_203022': 7,
+    'smallkey_20251104_203257': 8,
+    'smallpaper_20251104_203636': 9,
+    'smallwoodenstick_20251104_204353': 10,
+    'thinmetaldisk_20251104_204557': 11,
+    'thinmetaldisk_20251104_204721': 11,  # Same task, different demo
+}
+```
+
+### 2. Create tasks.parquet
+
+Task descriptions as DataFrame INDEX (LIBERO style):
+```python
+import pandas as pd
+
+# Create tasks DataFrame
+tasks_data = {'task_index': list(range(12))}
+task_descriptions = list(TASK_LANGUAGE_MAP.values())
+tasks_df = pd.DataFrame(tasks_data, index=task_descriptions)
+
+# Save to parquet
+tasks_df.to_parquet('meta/tasks.parquet')
+```
+
+### 3. Data Parquet Schema
+
+Frame-level data with task_index:
+```python
+{
+    'observation.state': float32[7],   # Joint angles
+    'action': float32[7],               # Commands
+    'timestamp': float32,               # Frame time
+    'frame_index': int64,               # Frame in episode
+    'episode_index': int64,             # Which episode
+    'index': int64,                     # Global frame index
+    'task_index': int64,                # Maps to tasks.parquet ← CRITICAL!
+    'next.done': bool                   # Last frame marker
+}
+```
+
+### 4. Episode Metadata Schema
+
+NO tasks field (LIBERO approach):
+```python
+{
+    'episode_index': int64,
+    'length': int64,                    # Number of frames
+    
+    # Data file mappings
+    'data/chunk_index': 0,
+    'data/file_index': 0,
+    'dataset_from_index': int64,
+    'dataset_to_index': int64,
+    
+    # Video file mappings (per camera)
+    'videos/observation.images.table_cam/chunk_index': 0,
+    'videos/observation.images.table_cam/file_index': int64,
+    'videos/observation.images.table_cam/from_timestamp': float,
+    'videos/observation.images.table_cam/to_timestamp': float,
+    
+    # Per-episode statistics
+    'stats/action/min': float32[7],
+    'stats/action/max': float32[7],
+    // ... other stats
+}
+```
+
+### Step 1: Setup
+
+```python
+import h5py
+import json
+import pandas as pd
+import numpy as np
+from pathlib import Path
+from PIL import Image
+import shutil
+import tempfile
+
+# CORRECT import paths for LeRobot v0.4.3
+from lerobot.datasets.lerobot_dataset import LeRobotDataset
+from lerobot.datasets.video_utils import encode_video_frames
+
+# Dependencies (ALL INSTALLED ✅)
+# - lerobot v0.4.3 (installed from local repo)
+# - av 15.1.0 (PyAV for video encoding)
+    "observation.images.table_cam": {
+        "dtype": "video",
+        "shape": [720, 800, 3],  # Height × Width × Channels
+        "names": ["height", "width", "channel"],
+        "video_info": {
+            "video.fps": 12.0,  # ACTUAL FPS from timestamps (not 30!)
+            "video.codec": "libsvtav1",  # CORRECT codec name
+            "video.pix_fmt": "yuv420p",
+            "video.is_depth_map": False,
+            "has_audio": False
+        }
+    },
+    "observation.images.wrist_cam": {
+        "dtype": "video",
+        "shape": [720, 1280, 3],  # Height × Width × Channels ← CORRECTED!
+        "names": ["height", "width", "channel"],
+        "video_info": {
+            "video.fps": 12.0,  # ACTUAL FPS from timestamps (not 30!)
+            "video.codec": "libsvtav1",  # CORRECT codec name
+            "video.pix_fmt": "yuv420p",
+            "video.is_depth_map": False,
+            "has_audio": False
+        }
+    },  "video_info": {
+            "video.fps": 30.0,
+            "video.codec": "av1",
+            "video.pix_fmt": "yuv420p",
+            "video.is_depth_map": False,
+            "has_audio": False
+        }
+    },
+    "observation.images.wrist_cam": {
+        "dtype": "video",
+        "shape": [720, 1280, 3],  # Height × Width × Channels ← CORRECTED!
+        "names": ["height", "width", "channel"],
+        "video_info": {
+            "video.fps": 30.0,
+            "video.codec": "av1",
+            "video.pix_fmt": "yuv420p",
+            "video.is_depth_map": False,
+            "has_audio": False
+        }
+    },
+    "observation.state": {
+        "dtype": "float32",
+        "shape": [7],
+        "names": {"motors": ["joint_1", "joint_2", "joint_3", "joint_4",
+                              "joint_5", "joint_6", "joint_7"]},
+        "fps": 30.0
+    },
+    "action": {
+        "dtype": "float32",
+        "shape": [7],
+        "names": {"motors": ["joint_1", "joint_2", "joint_3", "joint_4",
+                              "joint_5", "joint_6", "joint_7"]},
+        "fps": 30.0
+    },
+    "episode_index": {"dtype": "int64", "shape": [1], "names": None, "fps": 30.0},
+    "frame_index": {"dtype": "int64", "shape": [1], "names": None, "fps": 30.0},
+    "timestamp": {"dtype": "float32", "shape": [1], "names": None, "fps": 30.0},
+    "next.done": {"dtype": "bool", "shape": [1], "names": None, "fps": 30.0},
+    "index": {"dtype": "int64", "shape": [1], "names": None, "fps": 30.0},
+    "task_index": {"dtype": "int64", "shape": [1], "names": None, "fps": 30.0},
+}
+```
+
+### Step 3: Create Tasks Parquet (LIBERO Style)
+
+```python
+def create_tasks_parquet(output_dir):
+    """Create meta/tasks.parquet with task descriptions as index."""
+    task_descriptions = [
+        "Pick up the cleaning cloth from the table.",
+        "Grasp and pick up the filament roll.",
+        "Pick up the game controller from the table.",
+        "Pick up the hex wrench tool.",
+        "Grasp and pick up the pencil.",
+        "Pick up the scissors from the table.",
+        "Find and pick up the scissors that are partially hidden.",
+        "Pick up the screwdriver from the table.",
+        "Grasp and pick up the small key.",
+        "Pick up the small piece of paper.",
+        "Pick up the small wooden stick.",
+        "Pick up the thin metal disk.",
+    ]
+    
+    tasks_data = {'task_index': list(range(12))}
+    tasks_df = pd.DataFrame(tasks_data, index=task_descriptions)
+    
+    output_path = Path(output_dir) / 'meta' / 'tasks.parquet'
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    tasks_df.to_parquet(output_path)
+    print(f"Created {output_path}")
+```
+
+### Step 4: Main Conversion Function
+
+```python
+def convert_piper_to_lerobot_v3(
+    source_path: Path,
+    output_path: Path,
+    repo_id: str = "your_username/piper_picking_tests"
+):
+    """Convert PiPER dataset to LeRobot v3.0 format."""
+    
+    # Episode to task mapping (from verified data)
+    EPISODE_TO_TASK = {
+        'cleaningcloth_20251104_205021': 0,
+        'fillamentroll_20251104_204834': 1,
+        'gamecontroller_20251104_203816': 2,
+        'hexwrench_20251104_204002': 3,
+        'pencil_20251104_205415': 4,
+        'scissors_20251104_204120': 5,
+        'scissors_hidden_20251104_205751': 6,
+        'screwdriver_20251104_203022': 7,
+        'smallkey_20251104_203257': 8,
+    # Create dataset
+    dataset = LeRobotDataset.create(
+        repo_id=repo_id,
+        fps=12,  # ACTUAL FPS from timestamp analysis
+        features=PIPER_FEATURES,
+        root=output_path,
+        robot_type="piper",
+        use_videos=True,
+    )
+    # Create dataset
+    dataset = LeRobotDataset.create(
+        repo_id=repo_id,
+        fps=30,
+        features=PIPER_FEATURES,
+        root=output_path,
+        robot_type="piper",
+        use_videos=True,
+    )
+    
+    # Process each episode
+    for ep_idx, ep_name in enumerate(episodes):
+        print(f"\nProcessing episode {ep_idx}: {ep_name}")
+        task_idx = EPISODE_TO_TASK[ep_name]
+        
+        # Load HDF5 data
+        hdf5_path = source_path / f"{ep_name}.hdf5"
+        with h5py.File(hdf5_path, 'r') as f:
+            # Load arrays from HDF5
+            states = f['observation/state'][:]
+            actions = f['action'][:]
+            timestamps = f['timestamp'][:]
+            n_frames = len(timestamps)
+            
+            # Get image paths from HDF5
+            table_paths = [p.decode('utf-8') for p in f['observation/images/table_cam'][:]]
+            wrist_paths = [p.decode('utf-8') for p in f['observation/images/wrist_cam'][:]]
+        
+        print(f"  Frames: {n_frames}, Task: {task_idx}")
+        
+        # Add frames
+        for frame_idx in range(n_frames):
+            # Load images from paths stored in HDF5
+            # NOTE: Paths use task name (e.g., cleaningcloth_images), not episode name
+            table_img_path = source_path / table_paths[frame_idx]
+            wrist_img_path = source_path / wrist_paths[frame_idx]
+            
+            # Verify files exist
+            if not table_img_path.exists():
+                raise FileNotFoundError(f"Missing table image: {table_img_path}")
+            if not wrist_img_path.exists():
+                raise FileNotFoundError(f"Missing wrist image: {wrist_img_path}")
+            
+            table_img = Image.open(table_img_path)
+            wrist_img = Image.open(wrist_img_path)
+            
+            frame = {
+                "observation.state": states[frame_idx],
+                "action": actions[frame_idx],
+                "observation.images.table_cam": np.array(table_img),
+                "observation.images.wrist_cam": np.array(wrist_img),
+                "timestamp": timestamps[frame_idx],
+                "next.done": frame_idx == n_frames - 1,
+                "task_index": task_idx,  # LIBERO approach
+            }
+            
+            dataset.add_frame(frame)
+        
+        # Save episode (NO task parameter - we use task_index in frames)
+        dataset.save_episode()
+        print(f"  ✓ Saved {n_frames} frames")
+    
+    # Create tasks.parquet
+    create_tasks_parquet(output_path)
+    
+    # Finalize dataset
+    print("\nFinalizing dataset...")
+    dataset.finalize()
+    print("Conversion complete!")
+    
+    return dataset
+
+# Usage
+if __name__ == "__main__":
+    source = Path("/home/charith/projects/PiPER/piper_picking_tests")
+    output = Path("/home/charith/projects/PiPER/piper_picking_tests_v3")
+    
+    dataset = convert_piper_to_lerobot_v3(source, output)
+```
+
+### Step 5: Validation
+
+```python
+def validate_dataset(dataset_path):
+    """Validate converted dataset."""
+    from lerobot.common.datasets.lerobot_dataset import LeRobotDataset
+    
+    # Load dataset
+    dataset = LeRobotDataset(str(dataset_path))
+    
+    print(f"Total episodes: {dataset.num_episodes}")
+    print(f"Total frames: {dataset.num_frames}")
+    print(f"Total tasks: {len(dataset.meta.tasks) if hasattr(dataset.meta, 'tasks') else 'N/A'}")
+    
+    # Check tasks.parquet
+    tasks_path = dataset_path / 'meta' / 'tasks.parquet'
+    if tasks_path.exists():
+        tasks_df = pd.read_parquet(tasks_path)
+        print(f"\nTasks parquet: {len(tasks_df)} tasks")
+        print(tasks_df.head())
+    
+    # Load sample episode
+    sample = dataset[0]
+    print(f"\nSample frame keys: {sample.keys()}")
+    print(f"Task index: {sample.get('task_index', 'NOT FOUND')}")
+    
+    # Check video playback
+    print(f"\nVideo shapes:")
+    for key in sample.keys():
+        if 'image' in key:
+            print(f"  {key}: {sample[key].shape}")
+    
+    return dataset
+```
+
+## Testing Plan
+
+### Phase 1: Single Episode Test (30 min)
+```bash
+# Test on screwdriver episode only
+python convert_script.py --episode screwdriver_20251104_203022
+```
+
+**Validate:**
+- [ ] HDF5 data loads correctly (observation/state, action, timestamp)
+- [ ] Images load and convert to video
+- [ ] task_index assigned correctly
+- [ ] Episode metadata has file mappings
+- [ ] Can load with LeRobotDataset
+
+### Phase 2: Full Conversion (1-2 hours)
+```bash
+# Convert all 13 episodes
+python convert_script.py --all
+```
+
+**Validate:**
+- [ ] All 13 episodes present
+- [ ] 5,016 total frames
+- [ ] tasks.parquet has 12 tasks
+- [ ] Video quality acceptable
+- [ ] File sizes reasonable (~210 MB total)
+
+### Phase 3: VLA Compatibility Test
+```python
+# Test with VLA model loading
+from lerobot.common.datasets.lerobot_dataset import LeRobotDataset
+
+dataset = LeRobotDataset("path/to/piper_picking_tests_v3")
+
+# Check task conditioning
+sample = dataset[0]
+assert 'task_index' in sample
+print(f"Task: {dataset.meta.tasks.iloc[sample['task_index']].name}")
+
+# Try loading with VLA model
+# from lerobot.common.policies.vla import SmolVLA
+# model = SmolVLA(...)
+# model.select_action(sample)
+```
+
+## Expected Outcomes
+
+### File Structure
+```
+piper_picking_tests_v3/  (~150-200 MB total)
+├── meta/
+│   ├── info.json         (~10 KB)
+│   ├── stats.json        (~2 KB)
+│   ├── tasks.parquet     (~5 KB)
+│   └── episodes/
+│       └── chunk-000/
+│           └── file-000.parquet  (~50 KB)
+├── data/
+│   └── chunk-000/
+│       └── file-000.parquet      (~400 KB)
+└── videos/
+    ├── observation.images.table_cam/
+    │   └── chunk-000/
+    │       └── file-000.mp4 to file-012.mp4  (~75 MB total)
+    └── observation.images.wrist_cam/
+        └── chunk-000/
+            └── file-000.mp4 to file-012.mp4  (~120 MB total)
+```
+
+### Statistics
+### Dependencies Installed ✅
+- ✅ **LeRobot v0.4.3** - Installed in editable mode from `/home/charith/projects/PiPER/lerobot`
+- ✅ **PyAV 15.1.0** - Video encoding/decoding (downgraded from 16.0.1 for compatibility)
+- ✅ **PyTorch 2.7.1** - Deep learning framework with CUDA 12.6
+- ✅ **torchvision 0.22.1** - Image/video processing
+## Next Steps
+
+1. ✅ **Knowledge documented** in `lerobotv3_format_explanation.md`
+2. ✅ **Conversion plan created** (this file)
+3. ✅ **Dependencies installed** - LeRobot v0.4.3, PyAV 15.1.0, PyTorch 2.7.1
+4. ✅ **Strategy validated** - End-to-end pipeline tested with 10 frames
+5. ✅ **Video encoding verified** - libsvtav1 codec produces correct output
+6. ⏭️ **Implement full conversion script**
+7. ⏭️ **Test on single episode** (cleaningcloth or pencil)
+8. ⏭️ **Debug and refine**
+9. ⏭️ **Run full conversion** (all 13 episodes)
+10. ⏭️ **Validate with VLA models**
+11. ⏭️ **(Optional) Push to Hugging Face Hub**)
+- **Metadata**: <100 KB total
+
+### Dependencies Installed
+- ✅ PyAV (av) - Video encoding/decoding
+- ✅ OpenCV (cv2) - Already available
+- ✅ h5py, pillow, pandas, pyarrow - Already installed
+
+## Next Steps
+
+1. ✅ **Knowledge documented** in `lerobotv3_format_explanation.md`
+2. ✅ **Conversion plan created** (this file)
+3. ⏭️ **Implement conversion script**
+4. ⏭️ **Test on single episode**
+5. ⏭️ **Debug and refine**
+6. ⏭️ **Run full conversion**
+7. ⏭️ **Validate with VLA models**
+8. ⏭️ **(Optional) Push to Hugging Face Hub**
+### Critical for Success
+- ✅ Use LIBERO approach (tasks.parquet + task_index in frames)
+- ✅ Natural language task descriptions (not just labels!)
+- ✅ Correct HDF5 paths: `observation/state` (singular)
+- ✅ One video per episode (13 files per camera)
+- ✅ task_index in every frame
+- ✅ NO tasks field in episode metadata
+- ✅ **Correct import paths:** `lerobot.datasets.*` (NOT `lerobot.common.datasets.*`)
+- ✅ **Actual FPS:** 11-12 FPS (calculate from timestamps, don't assume 30)
+- ✅ **Image folder naming:** Uses task name only, not full episode name
+- ✅ **Image renaming:** Copy `frame_XXXXXX.png` → `frame-XXXXXX.png` for encode_video_frames
+- ✅ **Codec name:** `libsvtav1` (not just `av1`)tate` (singular)
+- ✅ One video per episode (13 files per camera)
+- ✅ task_index in every frame
+- ✅ NO tasks field in episode metadata
+
+### Common Mistakes to Avoid
+- ❌ Using `observations/state` instead of `observation/state`
+- ❌ Using task names instead of language descriptions
+- ❌ Adding tasks field to episodes (SVLA style, not needed for LIBERO)
+- ❌ Forgetting task_index in frames
+- ❌ Consolidating all videos into one file (use one per episode for multi-task)
+**Last Updated:** December 10, 2025
+
+---
+
+## Testing Summary (December 10, 2025)
+
+### ✅ Pipeline Validation Complete
+
+**Test Episode:** cleaningcloth_20251104_205021 (168 frames)
+
+**Results:**
+1. ✅ **All imports successful** - LeRobotDataset, encode_video_frames, PyAV, h5py, PIL
+2. ✅ **HDF5 data loading** - States (168,7), Actions (168,7), Timestamps (168) all loaded correctly
+3. ✅ **Image path resolution** - Successfully read paths from HDF5 and loaded PNG files
+4. ✅ **Video encoding** - 10 frames encoded to 0.10 MB MP4 using libsvtav1 codec
+5. ✅ **Video verification** - Output is 800×720, AV1 codec (libdav1d), playable
+6. ✅ **FPS calculation** - Actual FPS is 11.53 (NOT 30 as initially assumed!)
+
+**Key Findings:**
+- Calculated FPS from timestamps: **11.53 FPS** (episode duration 14.6s for 168 frames)
+- Video codec: libsvtav1 (SVT-AV1 Encoder v3.0.0)
+- Encoding parameters: Preset M10, CRF 30, YUV420, 800×720
+- Compression: 10 frames = 0.10 MB (excellent compression ratio)
+- Image paths in HDF5 use task name: `cleaningcloth_images/...` (not full episode name)
+
+**Next Action:** Create full conversion script and test with complete episode
+## References
+
+- **Complete format knowledge**: `lerobotv3_format_explanation.md`
+- [LeRobot v3.0 Documentation](https://huggingface.co/docs/lerobot/lerobot-dataset-v3)
+- [Porting Datasets Guide](https://huggingface.co/docs/lerobot/porting_datasets_v3)
+- [DROID Example](https://github.com/huggingface/lerobot/blob/main/examples/port_datasets/port_droid.py)
+
+**Last Updated:** December 2025
+

helper_scripts/lerobotv3_format_explanation.md

@@ -0,0 +1,762 @@
+# LeRobot v3.0 Format Complete Knowledge Base
+
+## Table of Contents
+1. [Overview](#overview)
+2. [Critical Requirements](#critical-requirements)
+3. [Dataset Structure](#dataset-structure)
+4. [Two Valid Task Approaches](#two-valid-task-approaches)
+5. [Chunking Strategy](#chunking-strategy)
+6. [Episode-to-File Mapping](#episode-to-file-mapping)
+7. [Configuration Parameters](#configuration-parameters)
+8. [Best Practices](#best-practices)
+9. [v2.1 vs v3.0 Changes](#v21-vs-v30-changes)
+10. [Our Dataset Strategy](#our-dataset-strategy)
+
+---
+
+## Overview
+
+LeRobot v3.0 introduces a **consolidated file format** for improved scalability, efficiency, and standardization. Instead of one file per episode (v2.1), v3.0 groups multiple episodes into larger Parquet data files and MP4 video files.
+
+**Key Benefits:**
+- **Scalability**: Handle massive datasets (1M+ episodes)
+- **Efficiency**: Fewer, larger files = faster I/O
+- **Standardization**: Parquet for all metadata
+- **Flexibility**: Configurable chunking strategies
+
+**Source:** Verified against Phospho.ai documentation and real datasets (SVLA, LIBERO)
+
+---
+
+## Critical Requirements
+
+### 1. Language Instructions are MANDATORY for VLA
+
+**All Vision-Language-Action (VLA) models require natural language task descriptions:**
+- **SmolVLA**: Processes language through tokenizer, conditions actions on language embeddings
+- **Pi0/Pi0.5**: Uses Paligemma (vision-language model), requires task descriptions
+- **XVLA**: Uses Florence-2 backbone with language tokenizer
+
+**Quality Requirements:**
+- ✅ **Full sentences**: "Pick up the red cube from the left side"
+- ❌ **Not labels**: "red_cube" or "pickup"
+- ✅ **Specific & descriptive**: Include object details, spatial context
+- ✅ **Natural language**: How a human would describe the task
+- ✅ **Goal-oriented**: Describe what to achieve, not just object names
+
+**Example (from LIBERO dataset):**
+```
+"put the white mug on the left plate and put the yellow and white mug on the right plate"
+"put the yellow and white mug in the microwave and close it"
+"turn on the stove and put the moka pot on it"
+```
+
+### 2. Proper HDF5 Paths (if converting from HDF5)
+
+**Correct structure:**
+- `observation/state` (singular, not `observations/state`)
+- `action` (singular, not `actions`)
+- `timestamp` (singular, not `timestamps`)
+
+---
+
+## Dataset Structure
+
+### Complete v3.0 Directory Layout
+
+```
+dataset_name/
+├── meta/
+│   ├── info.json                        # Dataset configuration
+│   ├── stats.json                       # Aggregated statistics
+│   ├── tasks.parquet                    # Task definitions (optional, see approaches below)
+│   └── episodes/
+│       ├── chunk-000/
+│       │   ├── file-000.parquet         # Episodes 0-999 metadata
+│       │   └── file-001.parquet         # Episodes 1000-1999 metadata (if >1000 episodes)
+│       └── chunk-001/                   # If >1000 episode metadata files
+│           └── file-000.parquet
+├── data/
+│   ├── chunk-000/
+│   │   ├── file-000.parquet             # Frame data for episodes 0-14
+│   │   ├── file-001.parquet             # Frame data for episodes 15-29
+│   │   └── ...                          # More files based on data_files_size_in_mb
+│   └── chunk-001/                       # If >1000 data files
+│       └── file-000.parquet
+└── videos/
+    ├── observation.images.camera1/
+    │   ├── chunk-000/
+    │   │   ├── file-000.mp4             # Video(s) for episodes 0-N
+    │   │   ├── file-001.mp4
+    │   │   └── ...                      # Number depends on strategy
+    │   └── chunk-001/                   # If >1000 video files
+    │       └── file-000.mp4
+    └── observation.images.camera2/
+        └── chunk-000/
+            └── ...
+```
+
+### File Schemas
+
+#### meta/info.json
+```json
+{
+    "codebase_version": "v3.0",
+    "robot_type": "piper",
+    "total_episodes": 13,
+    "total_frames": 5016,
+    "total_tasks": 12,
+    "total_videos": 26,
+    "total_chunks": 1,
+    "chunks_size": 1000,
+    "data_files_size_in_mb": 50,
+    "video_files_size_in_mb": 200,
+    "fps": 30,
+    "features": {
+        "observation.state": {
+            "dtype": "float32",
+            "shape": [7],
+            "names": {"motors": ["joint_1", ..., "joint_7"]},
+            "fps": 30.0
+        },
+        "action": {
+            "dtype": "float32",
+            "shape": [7],
+            "names": {"motors": ["joint_1", ..., "joint_7"]},
+            "fps": 30.0
+        },
+        "observation.images.table_cam": {
+            "dtype": "video",
+            "shape": [720, 800, 3],
+            "video_info": {
+                "video.fps": 30.0,
+                "video.codec": "av1",
+                "video.pix_fmt": "yuv420p"
+            }
+        }
+        // ... other features
+    }
+}
+```
+
+#### data/chunk-000/file-000.parquet
+Frame-level data:
+```python
+{
+    'observation.state': [7],          # Robot state
+    'action': [7],                     # Robot action
+    'timestamp': float,                # Frame timestamp
+    'frame_index': int,                # Frame within episode
+    'episode_index': int,              # Which episode
+    'index': int,                      # Global frame index
+    'task_index': int,                 # Maps to tasks.parquet (LIBERO approach)
+    'next.done': bool                  # True on last frame of episode
+}
+```
+
+#### meta/episodes/chunk-000/file-000.parquet
+Episode-level metadata:
+```python
+{
+    'episode_index': 0,
+    'length': 324,                                    # Number of frames
+    
+    # Data file location
+    'data/chunk_index': 0,                            # Which data chunk
+    'data/file_index': 0,                             # Which file in that chunk
+    'dataset_from_index': 0,                          # Start frame in that file
+    'dataset_to_index': 324,                          # End frame in that file
+    
+    # Video file locations (per camera)
+    'videos/observation.images.table_cam/chunk_index': 0,
+    'videos/observation.images.table_cam/file_index': 0,
+    'videos/observation.images.table_cam/from_timestamp': 0.0,
+    'videos/observation.images.table_cam/to_timestamp': 10.8,
+    
+    'videos/observation.images.wrist_cam/chunk_index': 0,
+    'videos/observation.images.wrist_cam/file_index': 0,
+    'videos/observation.images.wrist_cam/from_timestamp': 0.0,
+    'videos/observation.images.wrist_cam/to_timestamp': 10.8,
+    
+    # Per-episode statistics
+    'stats/action/min': [7],
+    'stats/action/max': [7],
+    'stats/action/mean': [7],
+    'stats/action/std': [7],
+    'stats/observation.state/min': [7],
+    'stats/observation.state/max': [7],
+    // ... other stats
+    
+    # Task information (optional, depends on approach)
+    'tasks': ["Pick up the screwdriver from the table."],  # SVLA approach
+    'task_index': 7                                         # LIBERO approach
+}
+```
+
+#### meta/tasks.parquet (LIBERO approach)
+```python
+# Task descriptions are the INDEX of the DataFrame!
+index (task description)                              | task_index
+------------------------------------------------------|------------
+"put the white mug on the left plate and..."         | 0
+"put the white mug on the plate and put..."          | 1
+"pick up the screwdriver from the table."            | 7
+```
+
+#### meta/stats.json
+Aggregated statistics for normalization:
+```json
+{
+    "observation.state": {
+        "mean": [7 values],
+        "std": [7 values],
+        "min": [7 values],
+        "max": [7 values]
+    },
+    "action": {
+        "mean": [7 values],
+        "std": [7 values],
+        "min": [7 values],
+        "max": [7 values]
+    }
+}
+```
+
+---
+
+## Two Valid Task Approaches
+
+### Approach 1: Tasks in Episode Metadata (SVLA Style)
+
+**Use when:**
+- Single task repeated across all episodes
+- Per-episode task variations needed
+- Episodes can have multiple task descriptions
+
+**Structure:**
+```python
+# meta/episodes/chunk-000/file-000.parquet
+{
+    'episode_index': 0,
+    'tasks': ['Put the red cube on top of the blue cube.'],  # List of strings
+    'length': 447,
+    // ... other metadata
+}
+```
+
+**Example Dataset:** svla_so100_stacking
+- 56 episodes, 1 task
+- All episodes do same task
+- Task stored in each episode's metadata
+
+**Pros:**
+- Simple for single-task datasets
+- Allows per-episode task variations
+- Tasks directly in episode metadata
+
+**Cons:**
+- Redundant for multi-task datasets
+- Harder to manage many distinct tasks
+
+### Approach 2: Separate tasks.parquet (LIBERO Style) ✅
+
+**Use when:**
+- Multiple distinct tasks in dataset
+- Each episode demonstrates one task
+- Want centralized task management
+
+**Structure:**
+```python
+# meta/tasks.parquet (task descriptions are INDEX!)
+index="Pick up the screwdriver..." | task_index=7
+
+# data/chunk-000/file-000.parquet (each frame)
+{
+    'observation.state': [...],
+    'action': [...],
+    'task_index': 7,  # Maps to tasks.parquet!
+    'episode_index': 0,
+    // ... other frame data
+}
+
+# meta/episodes/chunk-000/file-000.parquet
+{
+    'episode_index': 0,
+    'length': 214,
+    # NO tasks field!
+    // ... video metadata, data indices
+}
+```
+
+**Example Dataset:** LIBERO
+- 1,693 episodes, 40 tasks
+- Each episode has one task type
+- tasks.parquet centralizes task definitions
+
+**Pros:**
+- ✅ Clean task definition management
+- ✅ Define each task once
+- ✅ Easy to add new tasks
+- ✅ Better for multi-task datasets
+- ✅ Explicit task conditioning via task_index
+
+**Cons:**
+- Extra file to manage
+- Slightly more complex lookup
+
+**Both approaches are valid v3.0 and work with VLA models!**
+
+---
+
+## Chunking Strategy
+
+### Three Types of Chunking
+
+#### 1. Directory Chunks (`chunks_size`)
+**Purpose:** Limit number of FILES per directory for filesystem performance
+
+**Configuration:**
+```json
+{
+    "chunks_size": 1000  // Max 1000 files per chunk-XXX directory
+}
+```
+
+**When it splits:**
+- ✅ More than 1000 files → creates chunk-001, chunk-002, etc.
+- ❌ Fewer than 1000 files → everything stays in chunk-000
+
+**Example (LIBERO videos):**
+```
+1,693 video files (one per episode):
+- chunk-000/: file-000.mp4 through file-999.mp4 (1000 files)
+- chunk-001/: file-000.mp4 through file-692.mp4 (693 files)
+```
+
+**Why:** File system performance degrades with 1000+ files in one directory
+
+#### 2. Data File Chunks (`data_files_size_in_mb`)
+**Purpose:** Target parquet file size for efficient I/O
+
+**Configuration:**
+```json
+{
+    "data_files_size_in_mb": 100  // Target ~100MB per data parquet file
+}
+```
+
+**How it works:**
+- Multiple episodes consolidated into each parquet file
+- System creates new file when size target reached
+- Episode metadata tracks which file contains each episode
+
+**Examples:**
+- **LIBERO**: 273,465 frames → 377 files (~730 frames per file, ~100MB each)
+- **SVLA**: 22,956 frames → 1 file (~20MB total, under target)
+- **PIPER**: 5,016 frames → 1 file (~0.4MB total, well under target)
+
+**Key Insight:** Data files often contain MULTIPLE episodes!
+
+#### 3. Video File Strategy (`video_files_size_in_mb`)
+**Purpose:** Target video file size for streaming/download
+
+**Configuration:**
+```json
+{
+    "video_files_size_in_mb": 500  // Target ~500MB per video file
+}
+```
+
+**Two valid strategies:**
+
+**Strategy A: One video per episode (LIBERO)**
+- Each episode = separate MP4 file
+- Good for: Different episode lengths, multi-task, selective loading
+- Example: LIBERO has 1,693 MP4s per camera (one per episode)
+
+**Strategy B: Multiple episodes per video (SVLA)**
+- Episodes concatenated into fewer large videos
+- Good for: Uniform episodes, sequential access, single-task
+- Example: SVLA has 1 MP4 per camera (all 56 episodes concatenated)
+
+**Both are valid v3.0!** Choice depends on dataset characteristics.
+
+### Comparison: Data vs Video Chunking
+
+| Aspect | Data Files | Video Files |
+|--------|-----------|-------------|
+| **Consolidation** | Always multiple episodes per file | Depends on strategy |
+| **File count** | Few (377 in LIBERO) | Can be many (1,693 in LIBERO) or few (1 in SVLA) |
+| **When splits** | Based on data size | Based on strategy choice |
+| **Directory chunks** | Rare (377 < 1000) | Common if one-per-episode (1693 > 1000) |
+| **Episode mapping** | Via from/to indices | Via timestamps or per-file |
+
+### When to Split into Chunks?
+
+| Scenario | Data Chunks | Video Chunks | Directory Chunks |
+|----------|-------------|--------------|------------------|
+| **Small dataset (<100 episodes)** | 1 file in chunk-000 | 1 file or 1-per-episode in chunk-000 | All in chunk-000 |
+| **Medium dataset (100-1000 episodes)** | Multiple files in chunk-000 | Multiple files in chunk-000 | All in chunk-000 |
+| **Large dataset (1000-10000 episodes)** | Many files, maybe 2 chunks | Many files, likely 2-10 chunks | Multiple chunk-XXX dirs |
+| **Massive dataset (>10000 episodes)** | Many files, many chunks | Many files, many chunks | Many chunk-XXX dirs |
+
+---
+
+## Episode-to-File Mapping
+
+### How the System Tracks Episodes
+
+Episode metadata includes ALL location information:
+
+```python
+{
+    'episode_index': 1234,
+    
+    # Where is the data?
+    'data/chunk_index': 0,           # data/chunk-000/
+    'data/file_index': 82,            # file-082.parquet
+    'dataset_from_index': 123450,     # Starts at global frame 123450
+    'dataset_to_index': 123774,       # Ends at global frame 123774 (324 frames)
+    
+    # Where are the videos?
+    'videos/observation.images.camera1/chunk_index': 1,     # videos/.../chunk-001/
+    'videos/observation.images.camera1/file_index': 234,    # file-234.mp4
+    'videos/observation.images.camera1/from_timestamp': 0.0,
+    'videos/observation.images.camera1/to_timestamp': 10.8, # 324 frames @ 30fps
+}
+```
+
+### Lookup Process
+
+**To load episode 1234:**
+1. Read `meta/episodes/chunk-000/file-XXX.parquet`
+2. Find row where `episode_index == 1234`
+3. **For data:** Go to `data/chunk-000/file-082.parquet`, read rows 123450-123774
+4. **For video:** Go to `videos/.../chunk-001/file-234.mp4`, decode timestamps 0.0-10.8
+
+### Patterns
+
+**LIBERO (one video per episode):**
+```python
+video_file_index == episode_index  # Direct mapping!
+from_timestamp == 0.0              # Each video starts at 0
+```
+
+**SVLA (all episodes in one video):**
+```python
+video_file_index == 0              # All episodes in file-000.mp4
+from_timestamp varies              # Use timestamps to locate episode
+```
+
+---
+
+## Configuration Parameters
+
+### Complete info.json Configuration
+
+```json
+{
+    "codebase_version": "v3.0",
+    "robot_type": "your_robot",
+    "total_episodes": 13,
+    "total_frames": 5016,
+    "total_tasks": 12,
+    "total_videos": 26,
+    "total_chunks": 1,
+    
+    "chunks_size": 1000,                  // Max FILES per directory chunk
+    "data_files_size_in_mb": 100,         // Target size for EACH data parquet
+    "video_files_size_in_mb": 500,        // Target size for EACH video MP4
+    
+    "fps": 30,
+    "features": { /* ... */ }
+}
+```
+
+### What Each Parameter Controls
+
+| Parameter | Controls | Example | Impact |
+|-----------|----------|---------|--------|
+| `chunks_size` | Max files per chunk-XXX dir | 1000 | 1693 files → 2 chunks |
+| `data_files_size_in_mb` | Target data file size | 100 | Creates new file when reached |
+| `video_files_size_in_mb` | Target video file size | 500 | Strategy-dependent |
+| `fps` | Frame rate | 30 | Affects timestamp calculations |
+
+**Common mistake:** Thinking `chunks_size` controls episodes per chunk
+**Reality:** It controls FILES per directory (for filesystem performance)
+
+---
+
+## Best Practices
+
+### Language Instructions
+
+1. **Be specific**: "Pick up the red cube from the left side" > "pick cube"
+2. **Include spatial context**: "Put the mug on the left plate"
+3. **Describe the goal**: Not just object names
+4. **Use natural language**: How a human would explain it
+5. **Consistency**: Similar phrasing for similar tasks
+6. **Variation**: Multiple phrasings help generalization
+
+### Dataset Quality for VLA Fine-Tuning
+
+From SmolVLA/Pi0 documentation:
+
+1. **50+ episodes recommended** for good performance
+2. **Language diversity**: Vary descriptions, include context
+3. **Visual variations**: Multiple object positions, angles
+4. **Multiple camera views**: Helps spatial understanding
+5. **Consistent frame rate**: 30 FPS standard
+6. **Quality over quantity**: Good demos > many poor demos
+
+### Chunking Recommendations
+
+**Small datasets (<100 episodes):**
+```json
+{
+    "chunks_size": 1000,
+    "data_files_size_in_mb": 50,
+    "video_files_size_in_mb": 200
+}
+```
+- Use LIBERO approach (one video per episode)
+- All in chunk-000
+- 1 data file sufficient
+
+**Medium datasets (100-1000 episodes):**
+```json
+{
+    "chunks_size": 1000,
+    "data_files_size_in_mb": 100,
+    "video_files_size_in_mb": 500
+}
+```
+- Use LIBERO approach if multi-task
+- May need multiple data files
+- All in chunk-000
+
+**Large datasets (>1000 episodes):**
+```json
+{
+    "chunks_size": 1000,
+    "data_files_size_in_mb": 100,
+    "video_files_size_in_mb": 500
+}
+```
+- Will need multiple chunks
+- Many data files
+- Consider SVLA consolidation if single-task
+
+---
+
+## v2.1 vs v3.0 Changes
+
+### File Organization
+
+**v2.1:**
+```
+dataset/
+├── episode_000000.parquet
+├── episode_000001.parquet
+├── video_000000.mp4
+├── video_000001.mp4
+└── ...
+```
+- One file per episode
+- Can have 1000s of files
+- Scattered structure
+
+**v3.0:**
+```
+dataset/
+├── data/chunk-000/file-000.parquet       # Many episodes
+├── videos/.../chunk-000/file-000.mp4     # One or many episodes
+└── meta/episodes/chunk-000/file-000.parquet
+```
+- Consolidated files
+- Organized chunks
+- Metadata-driven access
+
+### Metadata Format
+
+**v2.1:**
+- tasks.jsonl (JSON Lines)
+- episodes_stats.jsonl
+- JSON-based metadata
+
+**v3.0:**
+- tasks.parquet (Parquet)
+- meta/episodes/chunk-000/*.parquet
+- Parquet-based metadata
+
+**Benefits:** Columnar storage, compression, schema evolution
+
+### Scalability
+
+**v2.1:**
+- Works well for <1000 episodes
+- File system struggles with large datasets
+- Slow directory listing
+
+**v3.0:**
+- Handles millions of episodes
+- Efficient chunk-based organization
+- Fast I/O with larger files
+
+### Migration
+
+**Automatic conversion available:**
+```bash
+python scripts/convert_dataset_v2_to_v3.py
+```
+
+**Or create v3.0 directly using LeRobotDataset.create()**
+
+---
+
+## Our Dataset Strategy
+
+### piper_picking_tests Characteristics
+
+```
+Total Episodes: 13
+Total Frames: 5,016
+Total Tasks: 12 (one duplicate: scissors/scissors_hidden)
+Cameras: 2 (table_cam 800×720, wrist_cam 640×480)
+FPS: 30
+Robot: 7-DOF arm
+State: 7D joint angles
+Action: 7D commands
+```
+
+### Recommended Structure: LIBERO Multi-Task Style
+
+**Why LIBERO approach?**
+- ✅ Multi-task dataset (12 distinct tasks)
+- ✅ Each episode = one task type
+- ✅ Easier task management
+- ✅ Better for VLA training
+- ✅ Explicit task conditioning
+
+**File Structure:**
+```
+piper_picking_tests_v3/
+├── meta/
+│   ├── info.json
+│   ├── stats.json
+│   ├── tasks.parquet                    # 12 tasks, descriptions as index
+│   └── episodes/
+│       └── chunk-000/
+│           └── file-000.parquet         # 13 episodes (NO tasks field)
+├── data/
+│   └── chunk-000/
+│       └── file-000.parquet             # All 5,016 frames (WITH task_index)
+└── videos/
+    ├── observation.images.table_cam/
+    │   └── chunk-000/
+    │       ├── file-000.mp4             # Episode 0 (cleaningcloth)
+    │       ├── file-001.mp4             # Episode 1 (fillamentroll)
+    │       └── ...                      # 13 files total
+    └── observation.images.wrist_cam/
+        └── chunk-000/
+            └── ...                      # 13 files total
+```
+
+### Configuration
+
+```json
+{
+    "codebase_version": "v3.0",
+    "robot_type": "piper",
+    "total_episodes": 13,
+    "total_frames": 5016,
+    "total_tasks": 12,
+    "chunks_size": 1000,
+    "data_files_size_in_mb": 50,
+    "video_files_size_in_mb": 200,
+    "fps": 30
+}
+```
+
+### Task Language Mapping
+
+```python
+TASK_LANGUAGE_MAP = {
+    0: "Pick up the cleaning cloth from the table.",
+    1: "Grasp and pick up the filament roll.",
+    2: "Pick up the game controller from the table.",
+    3: "Pick up the hex wrench tool.",
+    4: "Grasp and pick up the pencil.",
+    5: "Pick up the scissors from the table.",
+    6: "Find and pick up the scissors that are partially hidden.",
+    7: "Pick up the screwdriver from the table.",
+    8: "Grasp and pick up the small key.",
+    9: "Pick up the small piece of paper.",
+    10: "Pick up the small wooden stick.",
+    11: "Pick up the thin metal disk.",
+}
+```
+
+### Expected Sizes
+
+- **Data parquet**: ~0.4 MB (5,016 frames × 80 bytes/frame)
+- **Videos**: ~8 MB per episode per camera (compressed av1)
+  - 13 episodes × 2 cameras × 8 MB = ~208 MB total
+- **Metadata**: <1 MB
+- **Total**: ~210 MB (vs 6.2 GB current PNG format)
+
+### Why This Strategy?
+
+1. ✅ **Multi-task structure** matches dataset nature
+2. ✅ **One video per episode** enables flexible loading
+3. ✅ **LIBERO approach** provides clean task management
+4. ✅ **task_index in frames** ensures proper VLA conditioning
+5. ✅ **Single chunk** sufficient for 13 episodes
+6. ✅ **Scalable** if we add more episodes later
+
+---
+
+## Verification Checklist
+
+### Format Compliance
+- [ ] data/ directory with parquet files
+- [ ] videos/ directories with MP4 files (av1 codec)
+- [ ] meta/info.json with v3.0 schema
+- [ ] meta/episodes/ with parquet metadata
+- [ ] meta/tasks.parquet (if LIBERO approach)
+- [ ] meta/stats.json with aggregated statistics
+
+### Data Integrity
+- [ ] All episodes present (13)
+- [ ] All frames present (5,016)
+- [ ] All tasks defined (12)
+- [ ] task_index in data frames (LIBERO approach)
+- [ ] Episode metadata includes file mappings
+- [ ] Videos playable and correct length
+
+### VLA Compatibility
+- [ ] Language instructions are natural, descriptive
+- [ ] task_index maps correctly to language descriptions
+- [ ] Can load with LeRobotDataset.load()
+- [ ] Test with SmolVLA/Pi0 data loading
+- [ ] Language conditioning works in VLA models
+
+### Statistics
+- [ ] Per-episode stats in episode metadata
+- [ ] Aggregated stats in meta/stats.json
+- [ ] Reasonable value ranges
+- [ ] Mean/std suitable for normalization
+
+---
+
+## References
+
+- [Phospho.ai LeRobot Dataset Documentation](https://docs.phospho.ai/learn/lerobot-dataset)
+- [LeRobot v3.0 Official Docs](https://huggingface.co/docs/lerobot/lerobot-dataset-v3)
+- [Porting Datasets Guide](https://huggingface.co/docs/lerobot/porting_datasets_v3)
+- **Example Datasets Analyzed:**
+  - svla_so100_stacking (56 episodes, 1 task, SVLA approach)
+  - LIBERO (1,693 episodes, 40 tasks, LIBERO approach)
+
+**Document Version:** 1.0 (December 2025)
+**Verified Against:** LeRobot v3.0, Phospho.ai docs, SVLA, LIBERO datasets