Add dataset loader code

short_metaworld_loader.py

@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+"""
+Short-MetaWorld Dataset Loader
+Loads the dataset with proper structure preservation and task prompts.
+"""
+
+import os
+import pickle
+import json
+import glob
+from pathlib import Path
+from PIL import Image
+import torch
+import torchvision.transforms as T
+from torch.utils.data import Dataset
+
+class ShortMetaWorldDataset(Dataset):
+    """
+    Short-MetaWorld dataset loader that preserves the original structure.
+    
+    Args:
+        data_root (str): Path to the dataset root directory
+        task_list (list): List of tasks to load (default: all available tasks)
+        image_size (int): Target image size for transforms (default: 224)
+        transform (callable): Optional custom transform
+        load_prompts (bool): Whether to load task prompts (default: True)
+    """
+    
+    def __init__(self, data_root, task_list=None, image_size=224, transform=None, load_prompts=True):
+        self.data_root = Path(data_root)
+        self.image_size = image_size
+        
+        # Load task prompts
+        self.prompts = {}
+        if load_prompts:
+            prompt_file = self.data_root / "mt50_task_prompts.json"
+            if prompt_file.exists():
+                with open(prompt_file, 'r') as f:
+                    self.prompts = json.load(f)
+                print(f"📖 Loaded {len(self.prompts)} task prompts")
+            else:
+                print("⚠️ Task prompts not found, using fallback prompts")
+        
+        # Set up paths
+        self.img_root = self.data_root / "short-MetaWorld" / "short-MetaWorld" / "img_only"
+        self.data_pkl_root = self.data_root / "short-MetaWorld" / "r3m-processed" / "r3m_MT10_20"
+        
+        # Discover available tasks
+        available_tasks = []
+        if self.data_pkl_root.exists():
+            for pkl_file in self.data_pkl_root.glob("*.pkl"):
+                task_name = pkl_file.stem
+                if (self.img_root / task_name).exists():
+                    available_tasks.append(task_name)
+        
+        # Filter tasks if task_list provided
+        if task_list is not None:
+            self.tasks = [task for task in task_list if task in available_tasks]
+        else:
+            self.tasks = available_tasks
+        
+        print(f"📊 Loading {len(self.tasks)} tasks: {self.tasks}")
+        
+        # Default transform
+        if transform is None:
+            self.transform = T.Compose([
+                T.Resize((image_size, image_size)),
+                T.ToTensor(),
+            ])
+        else:
+            self.transform = transform
+        
+        # Load all trajectories
+        self.trajectories = self._load_trajectories()
+        print(f"✅ Loaded {len(self.trajectories)} trajectory steps")
+    
+    def _load_trajectories(self):
+        """Load all trajectory data"""
+        all_trajectories = []
+        
+        for task in self.tasks:
+            # Load pickle data
+            pkl_path = self.data_pkl_root / f"{task}.pkl"
+            if not pkl_path.exists():
+                print(f"⚠️ Pickle file not found: {pkl_path}")
+                continue
+                
+            with open(pkl_path, "rb") as f:
+                data = pickle.load(f)
+            
+            # Get image directories
+            task_img_dir = self.img_root / task
+            if not task_img_dir.exists():
+                print(f"⚠️ Image directory not found: {task_img_dir}")
+                continue
+            
+            # Process each trajectory
+            traj_dirs = sorted(task_img_dir.glob("*"), key=lambda x: int(x.name))
+            
+            for traj_idx, traj_dir in enumerate(traj_dirs):
+                if traj_idx >= len(data['actions']):
+                    continue
+                
+                # Get image paths
+                img_paths = sorted(traj_dir.glob("*.jpg"), 
+                                 key=lambda x: int(x.stem))
+                
+                num_steps = len(data['actions'][traj_idx])
+                num_images = len(img_paths)
+                
+                # Use minimum length to handle mismatched data
+                min_steps = min(num_images, num_steps)
+                if min_steps < 1:
+                    continue
+                
+                # Create trajectory entries
+                for step_idx in range(min_steps):
+                    trajectory_entry = {
+                        'task_name': task,
+                        'trajectory_id': traj_idx,
+                        'step_id': step_idx,
+                        'image_path': str(img_paths[step_idx]),
+                        'state': data['state'][traj_idx][step_idx][:7],  # First 7 dims
+                        'action': data['actions'][traj_idx][step_idx],
+                        'prompt': self._get_prompt(task)
+                    }
+                    all_trajectories.append(trajectory_entry)
+        
+        return all_trajectories
+    
+    def _get_prompt(self, task_name):
+        """Get prompt for a task"""
+        if task_name in self.prompts:
+            # Use simple prompt by default
+            return self.prompts[task_name].get('simple', f"Perform the task: {task_name.replace('-', ' ')}")
+        else:
+            return f"Perform the task: {task_name.replace('-', ' ')}"
+    
+    def get_task_info(self, task_name):
+        """Get comprehensive task information"""
+        if task_name in self.prompts:
+            return self.prompts[task_name]
+        return {"simple": f"Perform the task: {task_name.replace('-', ' ')}"}
+    
+    def get_available_tasks(self):
+        """Get list of available tasks"""
+        return self.tasks.copy()
+    
+    def get_dataset_stats(self):
+        """Get dataset statistics"""
+        task_counts = {}
+        for traj in self.trajectories:
+            task = traj['task_name']
+            task_counts[task] = task_counts.get(task, 0) + 1
+        
+        return {
+            'total_steps': len(self.trajectories),
+            'num_tasks': len(self.tasks),
+            'task_step_counts': task_counts,
+            'tasks': self.tasks
+        }
+    
+    def __len__(self):
+        return len(self.trajectories)
+    
+    def __getitem__(self, idx):
+        """Get a single trajectory step"""
+        traj = self.trajectories[idx]
+        
+        # Load and transform image
+        image = Image.open(traj['image_path']).convert("RGB")
+        image_tensor = self.transform(image)
+        
+        # Convert to tensors
+        state = torch.tensor(traj['state'], dtype=torch.float32)
+        action = torch.tensor(traj['action'], dtype=torch.float32)
+        
+        return {
+            'image': image_tensor,
+            'state': state,
+            'action': action,
+            'prompt': traj['prompt'],
+            'task_name': traj['task_name'],
+            'trajectory_id': traj['trajectory_id'],
+            'step_id': traj['step_id']
+        }
+
+# Example usage functions
+def load_short_metaworld(data_root, tasks=None, image_size=224):
+    """
+    Convenience function to load the dataset.
+    
+    Args:
+        data_root (str): Path to dataset root
+        tasks (list): List of tasks to load (None for all)
+        image_size (int): Image size for transforms
+    
+    Returns:
+        ShortMetaWorldDataset: The loaded dataset
+    """
+    return ShortMetaWorldDataset(
+        data_root=data_root,
+        task_list=tasks,
+        image_size=image_size
+    )
+
+def get_mt10_tasks():
+    """Get the MT10 task list"""
+    return [
+        "reach-v2", "push-v2", "pick-place-v2", "door-open-v2", "drawer-open-v2",
+        "drawer-close-v2", "button-press-topdown-v2", "button-press-v2", 
+        "button-press-wall-v2", "button-press-topdown-wall-v2"
+    ]
+
+def demo_usage():
+    """Demonstrate how to use the dataset"""
+    print("📖 Short-MetaWorld Dataset Usage Example")
+    print("=" * 50)
+    
+    # Load dataset
+    dataset = load_short_metaworld("./", tasks=get_mt10_tasks())
+    
+    # Print stats
+    stats = dataset.get_dataset_stats()
+    print(f"📊 Dataset Statistics:")
+    print(f"   Total steps: {stats['total_steps']}")
+    print(f"   Number of tasks: {stats['num_tasks']}")
+    print(f"   Available tasks: {stats['tasks']}")
+    
+    # Get a sample
+    if len(dataset) > 0:
+        sample = dataset[0]
+        print(f"\n📋 Sample data:")
+        print(f"   Image shape: {sample['image'].shape}")
+        print(f"   State shape: {sample['state'].shape}")
+        print(f"   Action shape: {sample['action'].shape}")
+        print(f"   Task: {sample['task_name']}")
+        print(f"   Prompt: {sample['prompt']}")
+
+if __name__ == "__main__":
+    demo_usage()