""" Multi-GPU DROID Preprocessing Script Processes full DROID dataset in parallel across multiple GPUs. Usage: # Machine 1 (GPUs 0-7): bash scripts/run_multigpu_machine1.sh # Machine 2 (GPUs 0-7): bash scripts/run_multigpu_machine2.sh Each GPU processes a subset of episodes based on GPU_ID % NUM_GPUS. """ import sys from pathlib import Path sys.path.append(str(Path(__file__).parent.parent)) import os import numpy as np import torch import mediapy as media import tensorflow as tf tf.config.set_visible_devices([], 'GPU') import tensorflow_datasets as tfds import cv2 import datetime import re import json from tqdm import tqdm from scipy.spatial.transform import Rotation as R from utils.load_camera_calibration import CameraCalibrationLoader from utils.franka_mesh_projection import FrankaMeshProjector # 7 gripper offsets in gripper frame GRIPPER_OFFSETS = np.array([ [0.0, 0.0, 0.0], # 0: gripper base [0.0, 0.045, 0.161], # 1: finger 1 tip [0.0, -0.045, 0.161], # 2: finger 2 tip [0.0, 0.045, 0.13], # 3: finger 1 end [0.0, -0.045, 0.13], # 4: finger 2 end [0.0, 0.0, 0.13], # 5: gripper center front [0.0, 0.0, 0.065], # 6: gripper center middle ]) def euler_xyz_to_rotation_matrix(euler_xyz): """Convert Euler XYZ angles to rotation matrix.""" return R.from_euler('xyz', euler_xyz).as_matrix() def transform_gripper_offsets(action): """Transform gripper offsets using action position and rotation.""" pos = action[:3] rot_euler = action[3:6] rot_matrix = euler_xyz_to_rotation_matrix(rot_euler) gripper_points_3d = (rot_matrix @ GRIPPER_OFFSETS.T).T + pos return gripper_points_3d def sample_arm_shaped_points(mesh_2d_visible, img_h, img_w, num_points=993, seed=None): """Sample points in arm shape around visible mesh vertices.""" if seed is not None: np.random.seed(seed) points = [] num_visible = len(mesh_2d_visible) if num_visible == 0: return np.random.rand(num_points, 2) * [img_w, img_h] # Gaussian around each visible mesh vertex points_per_mesh = min(50, num_points // max(num_visible, 1)) gaussian_sigma = 15.0 for mesh_pt in mesh_2d_visible: gaussian_pts = np.random.randn(points_per_mesh, 2) * gaussian_sigma + mesh_pt gaussian_pts[:, 0] = np.clip(gaussian_pts[:, 0], 0, img_w - 1) gaussian_pts[:, 1] = np.clip(gaussian_pts[:, 1], 0, img_h - 1) points.append(gaussian_pts) # Lines between visible meshes if num_visible >= 2: points_per_line = 10 for i in range(num_visible - 1): line_pts = np.linspace(mesh_2d_visible[i], mesh_2d_visible[i+1], points_per_line + 2) points.append(line_pts[1:-1]) # Fill remaining with uniform random current_count = sum(len(p) for p in points) remaining = num_points - current_count if remaining > 0: uniform_pts = np.random.rand(remaining, 2) * [img_w, img_h] points.append(uniform_pts) all_points = np.vstack(points) if points else np.empty((0, 2)) if len(all_points) < num_points: extra = np.random.rand(num_points - len(all_points), 2) * [img_w, img_h] all_points = np.vstack([all_points, extra]) elif len(all_points) > num_points: all_points = all_points[:num_points] return all_points def sample_wrist_points(img_h, img_w, num_sparse=300, num_dense=700, seed=None): """Sample wrist points: sparse uniform + dense in bottom 60%-100%.""" if seed is not None: np.random.seed(seed) sparse = np.random.rand(num_sparse, 2) * [img_w, img_h] # Dense in bottom 60%-100% region y_min = int(img_h * 0.60) y_max = img_h y_range = y_max - y_min dense_x = np.random.rand(num_dense) * img_w dense_y = np.random.rand(num_dense) * y_range + y_min dense = np.column_stack([dense_x, dense_y]) return np.vstack([sparse, dense]) def find_closest_calibration(episode, uuid_list): """Find closest calibration UUID for episode.""" try: recording_path = episode['episode_metadata']['recording_folderpath'].numpy().decode('utf-8') match = re.search(r'/([A-Z]+)/success/(\d{4}-\d{2}-\d{2})/\w+_\w+_+\d+_(\d{2}):(\d{2}):(\d{2})_\d{4}/', recording_path) if not match: return None lab, date, hour, minute, second = match.groups() episode_time = datetime.datetime.strptime(f"{date} {hour}:{minute}:{second}", "%Y-%m-%d %H:%M:%S") matching_calibs = [uuid for uuid in uuid_list if uuid.startswith(f"{lab}+") and f"+{date}-" in uuid] if len(matching_calibs) == 0: return None best_uuid = None min_time_diff = float('inf') for calib_uuid in matching_calibs: parts = calib_uuid.split('+') if len(parts) >= 3: time_str = parts[2].replace('_cameras', '') match_time = re.search(r'(\d{2})h-(\d{2})m-(\d{2})s', time_str) if match_time: calib_hour = int(match_time.group(1)) calib_min = int(match_time.group(2)) calib_sec = int(match_time.group(3)) calib_time = datetime.datetime.strptime( f"{date} {calib_hour}:{calib_min}:{calib_sec}", "%Y-%m-%d %H:%M:%S" ) time_diff = abs((episode_time - calib_time).total_seconds()) if time_diff < min_time_diff: min_time_diff = time_diff best_uuid = calib_uuid return best_uuid except: return None def process_episode(episode, episode_idx, projector, calib_loader, uuid, cotracker, device, max_frames=400, save_video=False, output_dir=None): """Process a single episode.""" # Get dual view params dual_params = calib_loader.get_dual_view_params(uuid, param_type='refined', require_refined=True) K_ext, E_ext = dual_params['exterior_1'] K_wrist, E_wrist = dual_params['wrist'] # First pass: count valid frames to check if episode is too long valid_frame_count = 0 for step in episode['steps']: img_ext = step['observation']['exterior_image_1_left'].numpy() img_wrist = step['observation']['wrist_image_left'].numpy() if img_ext is not None and img_wrist is not None: valid_frame_count += 1 if valid_frame_count > max_frames: # Episode is too long, skip it return None # Check minimum length if valid_frame_count < 10: return None # Collect frames and actions frames_ext = [] frames_wrist = [] actions = [] for step_idx, step in enumerate(episode['steps']): img_ext = step['observation']['exterior_image_1_left'].numpy() img_wrist = step['observation']['wrist_image_left'].numpy() action = step['action'].numpy() if img_ext is not None and img_wrist is not None: frames_ext.append(img_ext) frames_wrist.append(img_wrist) actions.append(action) T = len(frames_ext) img_h, img_w = frames_ext[0].shape[:2] # Step 1: Project mesh vertices for exterior view all_mesh_2d_ext = [] all_mesh_vis_ext = [] for t in range(T): gripper_3d = transform_gripper_offsets(actions[t]) mesh_2d, mesh_vis = projector._project_3d_to_2d( gripper_3d, K_ext, E_ext, img_h=img_h, img_w=img_w ) all_mesh_2d_ext.append(mesh_2d) all_mesh_vis_ext.append(mesh_vis) all_mesh_2d_ext = np.array(all_mesh_2d_ext) # [T, 7, 2] all_mesh_vis_ext = np.array(all_mesh_vis_ext) # [T, 7] # Check if at least some mesh points visible in first frame if np.sum(all_mesh_vis_ext[0]) < 2: return None # Step 2: Sample CoTracker query points at frame 0 mesh_2d_0 = all_mesh_2d_ext[0] mesh_2d_visible_0 = mesh_2d_0[all_mesh_vis_ext[0]] additional_points_ext = sample_arm_shaped_points( mesh_2d_visible_0, img_h, img_w, num_points=993, seed=episode_idx ) query_points_ext = np.vstack([mesh_2d_0, additional_points_ext]) # [1000, 2] query_points_wrist = sample_wrist_points( img_h, img_w, num_sparse=300, num_dense=700, seed=episode_idx ) # Step 3: Run CoTracker video_ext_np = np.array(frames_ext).transpose(0, 3, 1, 2) video_ext_tensor = torch.from_numpy(video_ext_np).float() / 255.0 video_ext_tensor = video_ext_tensor.unsqueeze(0).to(device) queries_ext = np.zeros((len(query_points_ext), 3)) queries_ext[:, 0] = 0 queries_ext[:, 1:] = query_points_ext queries_ext_tensor = torch.from_numpy(queries_ext).float().unsqueeze(0).to(device) with torch.no_grad(): tracks_ext, vis_ext = cotracker( video_ext_tensor, queries=queries_ext_tensor, backward_tracking=False ) tracks_ext = tracks_ext[0].cpu().numpy() # [T, 1000, 2] vis_ext = vis_ext[0].cpu().numpy() # [T, 1000] # Wrist view video_wrist_np = np.array(frames_wrist).transpose(0, 3, 1, 2) video_wrist_tensor = torch.from_numpy(video_wrist_np).float() / 255.0 video_wrist_tensor = video_wrist_tensor.unsqueeze(0).to(device) queries_wrist = np.zeros((len(query_points_wrist), 3)) queries_wrist[:, 0] = 0 queries_wrist[:, 1:] = query_points_wrist queries_wrist_tensor = torch.from_numpy(queries_wrist).float().unsqueeze(0).to(device) with torch.no_grad(): tracks_wrist, vis_wrist = cotracker( video_wrist_tensor, queries=queries_wrist_tensor, backward_tracking=False ) tracks_wrist = tracks_wrist[0].cpu().numpy() vis_wrist = vis_wrist[0].cpu().numpy() # Step 4: Save preview video if requested if save_video and output_dir is not None: video_frames = [] for t in range(T): # Exterior view viz_ext = frames_ext[t].copy() # Draw ground truth mesh vertices (blue hollow) for i in range(7): if all_mesh_vis_ext[t, i]: pt = tuple(all_mesh_2d_ext[t, i].astype(int)) cv2.circle(viz_ext, pt, 5, (255, 0, 0), 2) cv2.putText(viz_ext, str(i), (pt[0]+6, pt[1]-6), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (255, 0, 0), 1) # Draw tracked mesh vertices (red filled) - first 7 of CoTracker for i in range(7): if vis_ext[t, i]: pt = tuple(tracks_ext[t, i].astype(int)) cv2.circle(viz_ext, pt, 3, (0, 0, 255), -1) # Draw other tracked points (green) for i in range(7, len(tracks_ext[t])): if vis_ext[t, i]: pt = tuple(tracks_ext[t, i].astype(int)) cv2.circle(viz_ext, pt, 1, (0, 255, 0), -1) cv2.putText(viz_ext, f"Ext: GT mesh (blue) | Tracked mesh (red) | Others (green)", (5, 15), cv2.FONT_HERSHEY_SIMPLEX, 0.35, (255, 255, 255), 1) # Wrist view viz_wrist = frames_wrist[t].copy() for i in range(len(tracks_wrist[t])): if vis_wrist[t, i]: pt = tuple(tracks_wrist[t, i].astype(int)) color = (255, 255, 0) if i < 300 else (0, 255, 255) cv2.circle(viz_wrist, pt, 1, color, -1) cv2.putText(viz_wrist, f"Wrist: 300 sparse (cyan) + 700 dense bottom (yellow)", (5, 15), cv2.FONT_HERSHEY_SIMPLEX, 0.35, (255, 255, 255), 1) combined = np.concatenate([viz_ext, viz_wrist], axis=1) cv2.putText(combined, f"Episode {episode_idx} | Frame {t}/{T}", (5, img_h - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 255), 1) video_frames.append(combined) video_path = output_dir / f"preview_episode_{episode_idx:06d}.mp4" media.write_video(str(video_path), video_frames, fps=10) return { 'episode_idx': episode_idx, 'uuid': uuid, 'frames_exterior': np.array(frames_ext), 'frames_wrist': np.array(frames_wrist), 'actions': np.array(actions), 'mesh_vertices_2d_exterior': all_mesh_2d_ext, 'mesh_vertices_vis_exterior': all_mesh_vis_ext, 'tracks_exterior': tracks_ext, 'tracks_vis_exterior': vis_ext, 'tracks_wrist': tracks_wrist, 'tracks_vis_wrist': vis_wrist, } def main(): import argparse parser = argparse.ArgumentParser() parser.add_argument('--gpu-id', type=int, required=True, help='GPU ID (0-15 for 2 machines)') parser.add_argument('--num-gpus', type=int, default=16, help='Total number of GPUs') parser.add_argument('--machine-id', type=int, required=True, help='Machine ID (0 or 1)') parser.add_argument('--output-dir', type=str, required=True, help='Output directory') parser.add_argument('--max-frames', type=int, default=400, help='Max frames per episode') parser.add_argument('--preview-total', type=int, default=20, help='Total preview videos across all GPUs') args = parser.parse_args() # Set CUDA device os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu_id) device = torch.device('cuda:0') output_dir = Path(args.output_dir) output_dir.mkdir(parents=True, exist_ok=True) data_dir = output_dir / 'data' data_dir.mkdir(exist_ok=True) preview_dir = output_dir / 'preview_videos' preview_dir.mkdir(exist_ok=True) global_gpu_id = args.machine_id * 8 + args.gpu_id # Global GPU ID across machines print("=" * 80) print(f"Multi-GPU DROID Preprocessing") print("=" * 80) print(f" Machine ID: {args.machine_id}") print(f" Local GPU ID: {args.gpu_id}") print(f" Global GPU ID: {global_gpu_id}/{args.num_gpus}") print(f" Output: {output_dir}") print(f" Max frames: {args.max_frames}") print(f" Preview videos: {args.preview_total} total (distributed)") print("=" * 80) # Load calibration calib_dir = '/root/workspace/code/wmrl/Dual-Dynamics-Models/DROID-main/vision/u/wenlongh/datasets/droid_v4/cameras' calib_loader = CameraCalibrationLoader(calib_dir) projector = FrankaMeshProjector(use_gui=False) calib_path = Path(calib_dir) uuid_list = [f.stem.replace('_cameras', '') for f in sorted(calib_path.glob("*_cameras.json"))] print(f"Loaded {len(uuid_list)} camera calibrations") # Load CoTracker print("Loading CoTracker...") from cotracker.predictor import CoTrackerOnlinePredictor, CoTrackerPredictor # Try multiple checkpoint locations cotracker_paths = [ '/mnt/kevin/vlm_models/cotracker/scaled_offline.pth', '/mnt/kevin/vlm_models/hub/checkpoints/scaled_offline.pth', '/root/workspace/code/wmrl/Dual-Dynamics-Models/DROID-main/co-tracker/checkpoints/scaled_offline.pth', ] cotracker_checkpoint = None for path in cotracker_paths: if Path(path).exists(): cotracker_checkpoint = path print(f"Found CoTracker checkpoint: {cotracker_checkpoint}") break if cotracker_checkpoint is None: raise FileNotFoundError(f"CoTracker checkpoint not found. Tried:\n" + "\n".join(cotracker_paths)) cotracker = CoTrackerPredictor(checkpoint=cotracker_checkpoint) cotracker = cotracker.to(device) cotracker.eval() # Load DROID dataset print("Loading DROID dataset...") droid_path = '/mnt/kevin/data/droid/droid/1.0.0' builder = tfds.builder_from_directory(droid_path) dataset = builder.as_dataset(split='train') # Count total episodes print("Counting total episodes...") total_episodes = sum(1 for _ in dataset) print(f"Total episodes in dataset: {total_episodes}") # Calculate episodes for this GPU episodes_per_gpu = total_episodes // args.num_gpus start_idx = global_gpu_id * episodes_per_gpu end_idx = start_idx + episodes_per_gpu if global_gpu_id < args.num_gpus - 1 else total_episodes print(f"This GPU will process episodes {start_idx} to {end_idx-1} ({end_idx - start_idx} episodes)") # Determine preview strategy (distribute 20 videos evenly) preview_interval = max(1, (end_idx - start_idx) // max(1, args.preview_total // args.num_gpus)) processed_count = 0 skipped_count = 0 preview_count = 0 pbar = tqdm(total=end_idx - start_idx, desc=f"GPU {global_gpu_id}") for episode_idx, episode in enumerate(dataset): # Skip episodes not assigned to this GPU if episode_idx < start_idx: continue if episode_idx >= end_idx: break local_idx = episode_idx - start_idx # Find calibration uuid = find_closest_calibration(episode, uuid_list) if uuid is None or not calib_loader.has_refined_extrinsics(uuid): skipped_count += 1 pbar.update(1) continue # Decide if we save video for this episode save_video = (local_idx % preview_interval == 0) and (preview_count < args.preview_total // args.num_gpus) try: result = process_episode( episode, episode_idx, projector, calib_loader, uuid, cotracker, device, max_frames=args.max_frames, save_video=save_video, output_dir=preview_dir ) if result is None: skipped_count += 1 pbar.update(1) continue # Save NPZ npz_path = data_dir / f"episode_{episode_idx:06d}.npz" np.savez_compressed( npz_path, episode_idx=result['episode_idx'], uuid=result['uuid'], images_exterior=result['frames_exterior'], images_wrist=result['frames_wrist'], actions=result['actions'], mesh_vertices_2d_exterior=result['mesh_vertices_2d_exterior'], mesh_vertices_vis_exterior=result['mesh_vertices_vis_exterior'], tracks_exterior=result['tracks_exterior'], tracks_vis_exterior=result['tracks_vis_exterior'], tracks_wrist=result['tracks_wrist'], tracks_vis_wrist=result['tracks_vis_wrist'], mesh_indices=np.array([0, 1, 2, 3, 4, 5, 6], dtype=np.int32), ) processed_count += 1 if save_video: preview_count += 1 pbar.update(1) except Exception as e: print(f"\nError processing episode {episode_idx}: {e}") skipped_count += 1 pbar.update(1) continue pbar.close() # Save GPU-specific metadata metadata = { 'gpu_id': global_gpu_id, 'machine_id': args.machine_id, 'local_gpu_id': args.gpu_id, 'processed_episodes': processed_count, 'skipped_episodes': skipped_count, 'preview_videos': preview_count, 'episode_range': [start_idx, end_idx], 'split': 'train', 'camera_params': { 'exterior': { 'extrinsics': 'refined', 'intrinsics': 'measured', 'inversion': False }, 'wrist': { 'sampling': 'random', 'dense_region': 'bottom_60_100_pct' } }, 'point_distribution': { 'exterior': { 'total_tracked_points': 1000, 'mesh_vertices_tracked': 7, 'additional_points': 993, 'arm_shaped_strategy': 'gaussian_15px_per_mesh + lines_between', }, 'wrist': { 'total_tracked_points': 1000, 'sparse_uniform': 300, 'dense_bottom': 700 } }, 'image_resolution': [180, 320], 'max_frames_per_episode': args.max_frames, 'cotracker_model': 'scaled_offline.pth', 'cotracker_chunking': 'automatic_internal_only' } metadata_path = output_dir / f'metadata_gpu{global_gpu_id:02d}.json' with open(metadata_path, 'w') as f: json.dump(metadata, f, indent=2) print("\n" + "=" * 80) print(f"GPU {global_gpu_id} Complete") print("=" * 80) print(f" Processed: {processed_count} episodes") print(f" Skipped: {skipped_count} episodes") print(f" Preview videos: {preview_count}") print(f" Metadata: {metadata_path}") print("=" * 80) if __name__ == "__main__": main()