# Reprocess 4,976 DROID Episodes Across 5 Machines

## Quick Start

Run this command on each of the 5 machines:

```bash
cd /root/workspace/code/wmrl/Dual-Dynamics-Models/DROID-main
bash scripts/reprocess_all_5machines.sh <MACHINE_ID>
```

Where `<MACHINE_ID>` is:
- **Machine 1**: `0`
- **Machine 2**: `1`
- **Machine 3**: `2`
- **Machine 4**: `3`
- **Machine 5**: `4`

## Episode Distribution

Each machine processes a subset of the 4,976 episodes:

| Machine | Episodes     | Count |
|---------|--------------|-------|
| 0       | 0 → 995      | 995   |
| 1       | 995 → 1990   | 995   |
| 2       | 1990 → 2985  | 995   |
| 3       | 2985 → 3980  | 995   |
| 4       | 3980 → 4976  | 996   |

Each machine distributes its episodes across 8 GPUs (~124 episodes per GPU).

## Monitoring Progress

### Check logs
```bash
# Watch GPU 0 log in real-time
tail -f /mnt/kevin/data/droid_processed_1000pts/reprocessing_logs/m0_gpu0.log

# Check all GPU logs on machine 0
ls -lh /mnt/kevin/data/droid_processed_1000pts/reprocessing_logs/m0_*.log
```

### Check completion
```bash
# Count completed GPUs on machine 0
grep 'Complete:' /mnt/kevin/data/droid_processed_1000pts/reprocessing_logs/m0_*.log | wc -l
# Should output: 8 (when all GPUs done)

# Check success/error counts
grep -h 'Success:' /mnt/kevin/data/droid_processed_1000pts/reprocessing_logs/m0_*.log
```

### Monitor GPU usage
```bash
watch -n 1 nvidia-smi
# Should see all 8 GPUs at 70-90% utilization
```

## Verify Results

After all machines complete, verify track counts:

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

/mnt/kevin/envs/miniconda3/envs/atm_ati_vdm_droid/bin/python -c "
import numpy as np
from pathlib import Path
import random

data_dir = Path('/mnt/kevin/data/droid_processed_1000pts/data')
npz_files = sorted(data_dir.glob('episode_*.npz'))

# Sample 50 random episodes
samples = random.sample(npz_files, 50)

correct = 0
wrong = 0

for npz_path in samples:
    data = np.load(npz_path, allow_pickle=True)
    wrist_count = data['tracks_wrist'].shape[1]

    if wrist_count == 1105:
        correct += 1
    else:
        wrong += 1
        print(f'{npz_path.name}: wrist={wrist_count}')

print(f'\nResults from 50 random samples:')
print(f'  Correct (1105): {correct}')
print(f'  Wrong: {wrong}')
"
```

Expected output: All 50 samples should have 1105 wrist points.

## Troubleshooting

### Stop all reprocessing
```bash
pkill -f 'python.*episode'
```

### Restart a specific machine
```bash
# Stop
pkill -f 'python.*episode'

# Wait a few seconds
sleep 5

# Restart
bash scripts/reprocess_all_5machines.sh <MACHINE_ID>
```

### Check for stuck processes
```bash
ps aux | grep python | grep episode
```

## Estimated Time

- **Per episode**: ~30-60 seconds (depending on length)
- **Per GPU**: ~124 episodes × 45 sec avg = ~93 minutes
- **Total time**: ~1.5-2 hours (all machines in parallel)

## What Gets Updated

Each `.npz` file will be updated with:
- ✓ `tracks_wrist`: 1112 → **1105 points** (7 mesh + 98 grid + 1000 random)
- ✓ `tracks_exterior`: Already correct (1105 points)
- ✓ `mesh_vertices_2d_wrist_fixed`: Already exists
- ✓ All other fields: Unchanged

## Features

- ✅ **GPU distribution**: All 40 GPUs (5 machines × 8 GPUs) utilized
- ✅ **OOM handling**: Automatic retry with batching (batch_size=600)
- ✅ **Correct track counts**: 1105 points for both views
- ✅ **Progress tracking**: Individual log files per GPU
- ✅ **Resumable**: Skips already-processed episodes (checks track count)