""" Analyze DROID dataset to check: 1. Episode length distribution 2. Percentage with refined extrinsics 3. Generate list of valid episode indices for processing """ import sys from pathlib import Path sys.path.append(str(Path(__file__).parent.parent)) import numpy as np import tensorflow as tf tf.config.set_visible_devices([], 'GPU') import tensorflow_datasets as tfds import datetime import re import json from tqdm import tqdm from utils.load_camera_calibration import CameraCalibrationLoader def find_closest_calibration(episode, uuid_list): """Find closest calibration by timestamp.""" 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 main(): print("=" * 80) print("Analyzing DROID Dataset") print("=" * 80) # Load calibration loader calib_dir = '/root/workspace/code/wmrl/Dual-Dynamics-Models/DROID-main/vision/u/wenlongh/datasets/droid_v4/cameras' calib_loader = CameraCalibrationLoader(calib_dir) calib_path = Path(calib_dir) uuid_list = [f.stem.replace('_cameras', '') for f in sorted(calib_path.glob("*_cameras.json"))] print(f"Total calibrations: {len(uuid_list)}") # Load dataset droid_path = '/mnt/kevin/data/droid/droid/1.0.0' builder = tfds.builder_from_directory(droid_path) dataset = builder.as_dataset(split='train') # Analyze samples num_samples = 100 print(f"\nAnalyzing {num_samples} episodes...") episode_lengths = [] has_refined = [] has_calibration = [] valid_episodes = [] for episode_idx, episode in tqdm(enumerate(dataset), total=num_samples): if episode_idx >= num_samples: break # Count episode length length = sum(1 for _ in episode['steps']) episode_lengths.append(length) # Check calibration uuid = find_closest_calibration(episode, uuid_list) has_calib = uuid is not None has_calibration.append(has_calib) # Check refined extrinsics has_ref = False if uuid: has_ref = calib_loader.has_refined_extrinsics(uuid) has_refined.append(has_ref) # Check if valid (has refined + reasonable length) is_valid = has_ref and length <= 400 and length >= 10 if is_valid: valid_episodes.append(episode_idx) # Statistics episode_lengths = np.array(episode_lengths) print("\n" + "=" * 80) print("Episode Length Statistics") print("=" * 80) print(f" Mean length: {episode_lengths.mean():.1f}") print(f" Median length: {np.median(episode_lengths):.1f}") print(f" Min length: {episode_lengths.min()}") print(f" Max length: {episode_lengths.max()}") print(f" Std dev: {episode_lengths.std():.1f}") print("\n Length distribution:") bins = [0, 50, 100, 150, 200, 250, 300, 350, 400, 500, 1000, 10000] for i in range(len(bins)-1): count = np.sum((episode_lengths >= bins[i]) & (episode_lengths < bins[i+1])) pct = 100 * count / len(episode_lengths) print(f" {bins[i]:4d}-{bins[i+1]:4d}: {count:3d} episodes ({pct:5.1f}%)") print("\n" + "=" * 80) print("Calibration Statistics") print("=" * 80) num_with_calib = sum(has_calibration) num_with_refined = sum(has_refined) print(f" Episodes with calibration: {num_with_calib}/{num_samples} ({100*num_with_calib/num_samples:.1f}%)") print(f" Episodes with refined extrinsics: {num_with_refined}/{num_samples} ({100*num_with_refined/num_samples:.1f}%)") print("\n" + "=" * 80) print("Valid Episodes (refined + length <= 400)") print("=" * 80) print(f" Valid episodes: {len(valid_episodes)}/{num_samples} ({100*len(valid_episodes)/num_samples:.1f}%)") # Filter criteria analysis print("\n" + "=" * 80) print("Filter Criteria Analysis") print("=" * 80) for max_len in [200, 300, 400, 500]: valid_count = sum(1 for i, (ref, length) in enumerate(zip(has_refined, episode_lengths)) if ref and length <= max_len and length >= 10) print(f" Max length {max_len:3d}: {valid_count}/{num_samples} valid ({100*valid_count/num_samples:.1f}%)") # Save valid episode indices output_file = Path('/tmp/droid_valid_episodes.json') output_data = { 'valid_episodes': valid_episodes, 'num_samples': num_samples, 'max_length': 400, 'min_length': 10, 'requires_refined_extrinsics': True, 'statistics': { 'mean_length': float(episode_lengths.mean()), 'median_length': float(np.median(episode_lengths)), 'pct_with_refined': float(100 * num_with_refined / num_samples) } } with open(output_file, 'w') as f: json.dump(output_data, f, indent=2) print(f"\nāœ“ Valid episode indices saved to: {output_file}") print("\n" + "=" * 80) print("Recommendation") print("=" * 80) if len(valid_episodes) / num_samples >= 0.5: print(f"āœ“ Good: {100*len(valid_episodes)/num_samples:.1f}% of episodes are valid") print(f" Filtering with max_length=400 is VIABLE") else: print(f"āš  Warning: Only {100*len(valid_episodes)/num_samples:.1f}% of episodes are valid") print(f" Consider relaxing constraints or accepting more episodes") if __name__ == "__main__": main()