Update data_loader.py

data_loader.py

@@ -1,3 +1,17 @@
+from huggingface_hub import hf_hub_download
+import h5py
+import torch
+import numpy as np
+from torch.utils.data import Dataset, DataLoader
+
+def download_and_load_dataset(repo_id, filename="ucf_crime_features_labeled.h5"):
+    """Download the HDF5 file from Hugging Face and return the local path."""
+    hdf5_path = hf_hub_download(
+        repo_id=repo_id,
+        filename=filename,
+        repo_type="dataset"
+    )
+    return hdf5_path
 
 class UCFCrimeDataset(Dataset):
     """Dataset class for loading UCF-Crime features with temporal annotations."""
@@ -6,48 +20,147 @@ class UCFCrimeDataset(Dataset):
         self.hdf5_path = hdf5_path
         self.transform = transform
         
-        with h5py.File(hdf5_path, 'r') as f:
-            self.video_ids = list(f.keys())
+        # Open the HDF5 file
+        self.hdf5_file = h5py.File(hdf5_path, 'r')
+        
+        # Build list of video paths (category/video_name)
+        self.video_paths = []
+        for category_name in self.hdf5_file.keys():
+            category_group = self.hdf5_file[category_name]
+            for video_name in category_group.keys():
+                video_path = f"{category_name}/{video_name}"
+                self.video_paths.append(video_path)
         
+        # Filter by split if specified
         if split is not None:
-            filtered_ids = []
-            with h5py.File(hdf5_path, 'r') as f:
-                for video_id in self.video_ids:
-                    video_split = f[video_id].attrs.get('split', 'Unknown')
-                    if video_split.lower() == split.lower():
-                        filtered_ids.append(video_id)
-            self.video_ids = filtered_ids
+            filtered_paths = []
+            for video_path in self.video_paths:
+                video_group = self.hdf5_file[video_path]
+                video_split = video_group.attrs.get('split', 'Unknown')
+                
+                # Handle bytes type
+                if isinstance(video_split, bytes):
+                    video_split = video_split.decode('utf-8')
+                
+                # Case-insensitive comparison
+                if video_split.lower() == split.lower():
+                    filtered_paths.append(video_path)
+            
+            self.video_paths = filtered_paths
+            print(f"Loaded {len(self.video_paths)} videos for split: {split}")
     
     def __len__(self):
-        return len(self.video_ids)
+        return len(self.video_paths)
     
     def __getitem__(self, idx):
-        video_id = self.video_ids[idx]
-        with h5py.File(self.hdf5_path, 'r') as f:
-            features = np.array(f[f"{video_id}/features"])
-            labels = np.array(f[f"{video_id}/labels"])
+        video_path = self.video_paths[idx]
+        video_group = self.hdf5_file[video_path]
+        
+        features = np.array(video_group['features'])
+        labels = np.array(video_group['labels'])
         
+        # Convert to tensors
         features = torch.from_numpy(features).float()
         labels = torch.from_numpy(labels).float()
         
         if self.transform:
             features = self.transform(features)
         
+        # Get metadata
+        duration = video_group.attrs.get('duration', 0.0)
+        split = video_group.attrs.get('split', 'Unknown')
+        if isinstance(split, bytes):
+            split = split.decode('utf-8')
+        
         return {
-            'video_id': video_id,
+            'video_id': video_path,
             'features': features,
-            'labels': labels
+            'labels': labels,
+            'duration': duration,
+            'split': split
         }
+    
+    def close(self):
+        """Close the HDF5 file."""
+        if self.hdf5_file:
+            self.hdf5_file.close()
+
+def create_dataloaders_from_huggingface(repo_id, batch_size=16, num_workers=2):
+    """Download dataset from Hugging Face and create dataloaders."""
+    
+    # Download the HDF5 file
+    print(f"Downloading dataset from {repo_id}...")
+    hdf5_path = download_and_load_dataset(repo_id)
+    print(f"✓ Dataset downloaded to: {hdf5_path}")
+    
+    # Create datasets
+    print("\nCreating datasets...")
+    train_dataset = UCFCrimeDataset(hdf5_path, split='Train')
+    val_dataset = UCFCrimeDataset(hdf5_path, split='Val')
+    test_dataset = UCFCrimeDataset(hdf5_path, split='Test')
+    
+    # Create dataloaders
+    train_loader = DataLoader(
+        train_dataset, 
+        batch_size=batch_size, 
+        shuffle=True, 
+        num_workers=num_workers,
+        pin_memory=True
+    )
+    val_loader = DataLoader(
+        val_dataset, 
+        batch_size=batch_size, 
+        shuffle=False, 
+        num_workers=num_workers,
+        pin_memory=True
+    )
+    test_loader = DataLoader(
+        test_dataset, 
+        batch_size=batch_size, 
+        shuffle=False, 
+        num_workers=num_workers,
+        pin_memory=True
+    )
+    
+    print(f"\n{'='*60}")
+    print("Dataset Statistics:")
+    print(f"{'='*60}")
+    print(f"  Training set:   {len(train_dataset):>4} videos")
+    print(f"  Validation set: {len(val_dataset):>4} videos")
+    print(f"  Test set:       {len(test_dataset):>4} videos")
+    print(f"  Total:          {len(train_dataset) + len(val_dataset) + len(test_dataset):>4} videos")
+    print(f"{'='*60}")
+    
+    return train_loader, val_loader, test_loader, hdf5_path
 
-def create_dataloaders(hdf5_path, batch_size=16):
-    """Create train/validation/test dataloaders."""
-    train_dataset = UCFCrimeDataset(hdf5_path, split='train')
-    val_dataset = UCFCrimeDataset(hdf5_path, split='validation')
-    test_dataset = UCFCrimeDataset(hdf5_path, split='test')
+if __name__ == "__main__":
+    repo_id = "Rahima411/ucf-anomaly-detection-mapped"
+    
+    # Create dataloaders
+    train_loader, val_loader, test_loader, hdf5_path = create_dataloaders_from_huggingface(
+        repo_id=repo_id,
+        batch_size=16,
+        num_workers=2
+    )
     
-    train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=4)
-    val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=4)
-    test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, num_workers=4)
+    # Test loading batches
+    print("\nLoading Data...")
+    print("-" * 60)
     
-    return train_loader, val_loader, test_loader
+    for split_name, loader in [("Train", train_loader), ("Val", val_loader), ("Test", test_loader)]:
+        print(f"\n{split_name} set - First batch:")
+        for batch in loader:
+            print(f"  Batch size: {len(batch['video_id'])} videos")
+            print(f"  Features shape: {batch['features'].shape}")
+            print(f"  Labels shape: {batch['labels'].shape}")
+            print(f"  Sample video IDs: {batch['video_id'][:3]}")
+            
+            # Calculate anomaly statistics
+            labels_np = batch['labels'].numpy()
+            num_anomaly_frames = (labels_np == 1).sum()
+            total_frames = labels_np.size
+            anomaly_pct = 100 * num_anomaly_frames / total_frames if total_frames > 0 else 0
+            
+            print(f"  Anomaly frames: {num_anomaly_frames:,} / {total_frames:,} ({anomaly_pct:.2f}%)")
+            break  # Only show first batch