droid/scripts/MULTIGPU_PREPROCESSING_README.md

Multi-GPU DROID Preprocessing Guide

Process the entire DROID dataset in parallel using independent GPU processes (no inter-GPU communication).

Overview

• Mode: Independent processing (no DDP, no communication)
• Recommended: Single machine with 8 GPUs
• Optional: Two machines with 16 GPUs total
• Dataset: Full DROID train split (~70k episodes)
• Output: 1000 tracked points per view with visibility masks
• Preview videos: 20 total (distributed across GPUs)
• Processing time: ~10-20 seconds per episode

Quick Start

Single Machine (8 GPUs) - Recommended

cd /root/workspace/code/wmrl/Dual-Dynamics-Models/DROID-main
bash scripts/run_multigpu_single_machine.sh

How it works:

• 8 independent processes (one per GPU)
• No communication between processes
• Each GPU processes episodes where (episode_idx % 8) == gpu_id
• GPU 0: episodes 0, 8, 16, 24, ...
• GPU 1: episodes 1, 9, 17, 25, ...
• GPU 2: episodes 2, 10, 18, 26, ...
• etc.

Two Machines (16 GPUs) - Optional

If you want faster processing with 16 GPUs across 2 machines:

Machine 1 (GPUs 0-7, Global IDs 0-7)

cd /root/workspace/code/wmrl/Dual-Dynamics-Models/DROID-main
bash scripts/run_multigpu_machine1.sh

Machine 2 (GPUs 0-7, Global IDs 8-15)

cd /root/workspace/code/wmrl/Dual-Dynamics-Models/DROID-main
bash scripts/run_multigpu_machine2.sh

Important: Both machines should use the same shared output directory (e.g., /mnt/kevin/data/droid_processed_1000pts) accessible via NFS or similar.

Monitoring Progress

Check logs:

# Single machine
tail -f /mnt/kevin/data/droid_processed_1000pts/log_gpu0.txt

# Or for two machines:
# Machine 1
tail -f /mnt/kevin/data/droid_processed_1000pts/log_machine0_gpu0.txt

# Machine 2
tail -f /mnt/kevin/data/droid_processed_1000pts/log_machine1_gpu0.txt

Check all running processes:

ps aux | grep preprocess_droid_multigpu

Check GPU utilization:

nvidia-smi

Monitor specific GPU:

watch -n 1 nvidia-smi

How It Works

Episode Distribution

• Total episodes: ~70,832 in DROID train split
• Per GPU: ~4,427 episodes (70,832 / 16)
• Each GPU processes: episodes where (episode_idx % 16) == global_gpu_id

Global GPU Mapping

Machine	Local GPU	Global GPU	Episodes Range
1	0	0	0, 16, 32, ...
1	1	1	1, 17, 33, ...
...	...	...	...
1	7	7	7, 23, 39, ...
2	0	8	8, 24, 40, ...
2	1	9	9, 25, 41, ...
...	...	...	...
2	7	15	15, 31, 47, ...

Preview Video Distribution

• Total: 20 preview videos
• Per GPU: ~1-2 videos
• Distributed evenly across episode range

Output Structure

/mnt/kevin/data/droid_processed_1000pts/
├── data/
│   ├── episode_000000.npz  # Processed by GPU 0
│   ├── episode_000001.npz  # Processed by GPU 1
│   ├── episode_000002.npz  # Processed by GPU 2
│   └── ...
├── preview_videos/
│   ├── preview_episode_000000.mp4
│   ├── preview_episode_004427.mp4
│   └── ... (20 total)
├── metadata_gpu00.json  # GPU 0 stats
├── metadata_gpu01.json  # GPU 1 stats
├── ...
├── metadata_gpu15.json  # GPU 15 stats
├── log_machine0_gpu0.txt
├── log_machine0_gpu1.txt
├── ...
└── log_machine1_gpu7.txt

NPZ File Contents (per episode)

{
    'episode_idx': int,                              # Episode index
    'uuid': str,                                     # Calibration UUID
    'images_exterior': (T, 180, 320, 3),            # Exterior camera frames
    'images_wrist': (T, 180, 320, 3),               # Wrist camera frames
    'actions': (T, 7),                               # Robot actions (Euler XYZ)
    'mesh_vertices_2d_exterior': (T, 7, 2),         # Ground truth mesh (7 points)
    'mesh_vertices_vis_exterior': (T, 7),           # Mesh visibility mask
    'tracks_exterior': (T, 1000, 2),                # 1000 tracked points
    'tracks_vis_exterior': (T, 1000),               # Track visibility mask
    'tracks_wrist': (T, 1000, 2),                   # 1000 tracked points
    'tracks_vis_wrist': (T, 1000),                  # Track visibility mask
    'mesh_indices': (7,),                            # [0,1,2,3,4,5,6]
}

After Completion

Merge Metadata

Once all GPUs finish, merge the metadata files:

cd /root/workspace/code/wmrl/Dual-Dynamics-Models/DROID-main
python scripts/merge_multigpu_metadata.py \
    --output-dir /mnt/kevin/data/droid_processed_1000pts \
    --num-gpus 16

This will:

• Check all 16 GPU metadata files
• Report total processed/skipped episodes
• Create metadata_merged.json with full statistics
• Identify any missing/incomplete GPUs

Verify Output

# Count processed episodes
ls -1 /mnt/kevin/data/droid_processed_1000pts/data/episode_*.npz | wc -l

# Count preview videos
ls -1 /mnt/kevin/data/droid_processed_1000pts/preview_videos/preview_*.mp4 | wc -l

# Check total size
du -sh /mnt/kevin/data/droid_processed_1000pts/

Episode Filtering

Episodes are skipped (not processed) if they meet any of these criteria:

1. ❌ No refined extrinsics - Missing calibration data
2. ❌ Too short - Less than 10 valid frames
3. ❌ Too long - More than 400 valid frames (configurable)
4. ❌ Insufficient mesh visibility - Less than 2 mesh vertices visible in first frame

Note: Episodes > 400 frames are skipped entirely, not truncated. This ensures all saved trajectories are complete.

Configuration

Edit Output Directory

Modify in both launcher scripts:

OUTPUT_DIR="/mnt/kevin/data/droid_processed_1000pts"

Adjust Preview Count

Modify in both launcher scripts:

PREVIEW_TOTAL=20  # Change to desired number

Adjust Max Frames

Modify in both launcher scripts:

MAX_FRAMES=400  # Episodes longer than this will be SKIPPED (not truncated)

Troubleshooting

GPU Out of Memory

• Reduce MAX_FRAMES to 200 or 300
• CoTracker uses ~6-8GB VRAM for 400 frames

Process Killed/Crashed

• Check log file: cat /mnt/kevin/data/droid_processed_1000pts/log_machine*_gpu*.txt
• Resume by re-running the launcher (already-processed episodes will be skipped by file existence check)

Uneven Load Distribution

• Some GPUs may finish faster if they get episodes with fewer frames or more skipped episodes
• This is normal and expected

Network Storage Issues

• If using NFS, ensure good network bandwidth
• Consider using local storage and merging later if NFS is slow

Estimated Timing

Single Machine (8 GPUs)

• Per episode: 10-20 seconds (avg ~15s with 400 max frames)
• Per GPU: ~8,854 episodes × 15s = ~36.8 hours
• Total wall time: ~36-48 hours (all GPUs in parallel)
• Output size: ~500GB-1TB (depends on episode lengths and compression)

Two Machines (16 GPUs)

• Per episode: 10-20 seconds (avg ~15s with 400 max frames)
• Per GPU: ~4,427 episodes × 15s = ~18.4 hours
• Total wall time: ~18-24 hours (all GPUs in parallel)
• Output size: ~500GB-1TB (depends on episode lengths and compression)

Manual Single-GPU Test

Before full run, test on a single GPU:

cd /root/workspace/code/wmrl/Dual-Dynamics-Models/DROID-main

CUDA_VISIBLE_DEVICES=0 /mnt/kevin/envs/miniconda3/envs/atm_ati_vdm_droid/bin/python \
    scripts/preprocess_droid_multigpu.py \
    --gpu-id 0 \
    --machine-id 0 \
    --num-gpus 1 \  # Test with just 1 GPU
    --output-dir /tmp/droid_test \
    --max-frames 100 \
    --preview-total 3

Stopping All Processes

# Machine 1
pkill -f preprocess_droid_multigpu

# Machine 2
pkill -f preprocess_droid_multigpu

Point Distribution Details

Exterior View (1000 points)

• First 7 indices: Mesh vertices (tracked by CoTracker)
  • Also saved separately as ground truth in mesh_vertices_2d_exterior
• Indices 7-999 (993 points): Arm-shaped sampling
  • Gaussian clouds around visible mesh vertices (σ=15px)
  • Lines connecting mesh vertices
  • Uniform random fill

Wrist View (1000 points)

• First 300 indices: Sparse uniform across full image
• Indices 300-999 (700 points): Dense in bottom 60%-100% of image
  • Where gripper typically appears in wrist camera

Visibility Masks

• Value range: [0.0, 1.0]
• 0.0 = occluded/invisible
• 1.0 = fully visible
• This&That dataloader uses threshold of 0.7 by default

Next Steps

After preprocessing completes:

1. Run metadata merge script
2. Verify output with sample loading test
3. Update This&That VDM dataloader to use new DROID RLDS dataset
4. Begin ControlNet training with 1000-point tracks