Create eit_pytorch_loader.py

eit_pytorch_loader.py

@@ -0,0 +1,316 @@
+"""
+EIT Dataset Loader - Direct Python Class (No HuggingFace script loading)
+
+This loader provides direct access to the EIT dataset stored in HDF5 format.
+Can be used standalone or wrapped for HuggingFace datasets compatibility.
+"""
+
+import h5py
+import numpy as np
+from pathlib import Path
+from typing import Dict, List, Tuple, Optional
+import torch
+from torch.utils.data import Dataset
+
+
+class EITDataset(Dataset):
+    """
+    PyTorch Dataset for EIT (Electrical Impedance Tomography) data.
+    
+    Args:
+        data_dir: Base directory containing the dataset
+        subset: Which dataset to load ("CirclesOnly" or "FourObjects")
+        split: Which split to load ("train", "val", or "test")
+        image_resolution: Image resolution ("32_log", "64_log", "128_log", or "256")
+        load_to_memory: If True, load all data to RAM (faster but memory intensive)
+    """
+    
+    def __init__(
+        self,
+        data_dir: str,
+        subset: str = "CirclesOnly",
+        split: str = "train",
+        image_resolution: str = "128_log",
+        load_to_memory: bool = False
+    ):
+        self.data_dir = Path(data_dir)
+        self.subset = subset
+        self.split = split
+        self.image_resolution = image_resolution
+        self.load_to_memory = load_to_memory
+        
+        # Paths
+        self.subset_path = self.data_dir / subset
+        self.h5_path = self.subset_path / "dataset.h5"
+        
+        # Map split name to file name
+        split_map = {"train": "train.txt", "val": "val.txt", "test": "test.txt"}
+        self.split_file = self.subset_path / "parameters" / split_map[split]
+        
+        # Load split indices
+        self._load_split_indices()
+        
+        # Load data to memory if requested
+        if self.load_to_memory:
+            self._load_to_memory()
+        else:
+            self.cached_data = None
+    
+    def _load_split_indices(self):
+        """Load the indices for this split."""
+        with open(self.split_file, 'r') as f:
+            self.indices = [int(line.strip()) for line in f if line.strip()]
+    
+    def _load_to_memory(self):
+        """Load all data for this split into memory."""
+        print(f"Loading {len(self.indices)} samples to memory...")
+        self.cached_data = []
+        
+        with h5py.File(self.h5_path, "r") as h5_file:
+            voltage_data = h5_file["volt"]["16"]
+            image_data = h5_file["image"][self.image_resolution]
+            
+            # Determine graph key
+            graph_key = self.image_resolution if self.image_resolution != "256" else "128_log"
+            has_graph = graph_key in h5_file["graph"]
+            
+            for sample_idx in self.indices:
+                voltage = voltage_data[:, sample_idx].astype(np.float32)
+                image = image_data[:, :, sample_idx].astype(np.float32)
+                
+                sample = {
+                    'voltage_measurements': voltage,
+                    'conductivity_map': image,
+                    'sample_id': sample_idx
+                }
+                
+                if has_graph:
+                    graph = h5_file["graph"][graph_key][:, sample_idx].astype(np.float32)
+                    sample['graph_representation'] = graph
+                
+                self.cached_data.append(sample)
+        
+        print("Data loaded to memory!")
+    
+    def __len__(self) -> int:
+        return len(self.indices)
+    
+    def __getitem__(self, idx: int) -> Dict[str, np.ndarray]:
+        """Get a single sample."""
+        if self.cached_data is not None:
+            # Return from cached data
+            return self.cached_data[idx]
+        
+        # Read from HDF5 file on-the-fly
+        sample_idx = self.indices[idx]
+        
+        with h5py.File(self.h5_path, "r") as h5_file:
+            voltage = h5_file["volt"]["16"][:, sample_idx].astype(np.float32)
+            image = h5_file["image"][self.image_resolution][:, :, sample_idx].astype(np.float32)
+            
+            sample = {
+                'voltage_measurements': voltage,
+                'conductivity_map': image,
+                'sample_id': sample_idx
+            }
+            
+            # Add graph representation if available
+            graph_key = self.image_resolution if self.image_resolution != "256" else "128_log"
+            if graph_key in h5_file["graph"]:
+                graph = h5_file["graph"][graph_key][:, sample_idx].astype(np.float32)
+                sample['graph_representation'] = graph
+        
+        return sample
+    
+    def get_image_shape(self) -> Tuple[int, int]:
+        """Get the shape of conductivity maps."""
+        resolution_map = {
+            "32_log": (32, 32),
+            "64_log": (64, 64),
+            "128_log": (128, 128),
+            "256": (256, 256)
+        }
+        return resolution_map.get(self.image_resolution, (128, 128))
+    
+    def get_statistics(self) -> Dict:
+        """Calculate dataset statistics."""
+        print("Calculating statistics...")
+        voltage_sum = np.zeros(256, dtype=np.float64)
+        voltage_sq_sum = np.zeros(256, dtype=np.float64)
+        image_sum = 0.0
+        image_sq_sum = 0.0
+        n_samples = len(self)
+        
+        with h5py.File(self.h5_path, "r") as h5_file:
+            voltage_data = h5_file["volt"]["16"]
+            image_data = h5_file["image"][self.image_resolution]
+            
+            for sample_idx in self.indices:
+                voltage = voltage_data[:, sample_idx]
+                image = image_data[:, :, sample_idx]
+                
+                voltage_sum += voltage
+                voltage_sq_sum += voltage ** 2
+                image_sum += np.sum(image)
+                image_sq_sum += np.sum(image ** 2)
+        
+        n_pixels = n_samples * self.get_image_shape()[0] * self.get_image_shape()[1]
+        
+        stats = {
+            'voltage_mean': voltage_sum / n_samples,
+            'voltage_std': np.sqrt(voltage_sq_sum / n_samples - (voltage_sum / n_samples) ** 2),
+            'image_mean': image_sum / n_pixels,
+            'image_std': np.sqrt(image_sq_sum / n_pixels - (image_sum / n_pixels) ** 2),
+            'n_samples': n_samples
+        }
+        
+        return stats
+
+
+class EITDataModule:
+    """
+    Convenience class to manage all splits of the EIT dataset.
+    
+    Args:
+        data_dir: Base directory containing the dataset
+        subset: Which dataset to load ("CirclesOnly" or "FourObjects")
+        image_resolution: Image resolution ("32_log", "64_log", "128_log", or "256")
+        batch_size: Batch size for DataLoaders
+        num_workers: Number of workers for DataLoaders
+        load_to_memory: If True, load all data to RAM
+    """
+    
+    def __init__(
+        self,
+        data_dir: str,
+        subset: str = "CirclesOnly",
+        image_resolution: str = "128_log",
+        batch_size: int = 32,
+        num_workers: int = 4,
+        load_to_memory: bool = False
+    ):
+        self.data_dir = data_dir
+        self.subset = subset
+        self.image_resolution = image_resolution
+        self.batch_size = batch_size
+        self.num_workers = num_workers
+        self.load_to_memory = load_to_memory
+        
+        # Create datasets
+        self.train_dataset = EITDataset(
+            data_dir, subset, "train", image_resolution, load_to_memory
+        )
+        self.val_dataset = EITDataset(
+            data_dir, subset, "val", image_resolution, load_to_memory
+        )
+        self.test_dataset = EITDataset(
+            data_dir, subset, "test", image_resolution, load_to_memory
+        )
+    
+    def train_dataloader(self, **kwargs):
+        """Get training DataLoader."""
+        from torch.utils.data import DataLoader
+        return DataLoader(
+            self.train_dataset,
+            batch_size=kwargs.get('batch_size', self.batch_size),
+            shuffle=True,
+            num_workers=kwargs.get('num_workers', self.num_workers),
+            pin_memory=True
+        )
+    
+    def val_dataloader(self, **kwargs):
+        """Get validation DataLoader."""
+        from torch.utils.data import DataLoader
+        return DataLoader(
+            self.val_dataset,
+            batch_size=kwargs.get('batch_size', self.batch_size),
+            shuffle=False,
+            num_workers=kwargs.get('num_workers', self.num_workers),
+            pin_memory=True
+        )
+    
+    def test_dataloader(self, **kwargs):
+        """Get test DataLoader."""
+        from torch.utils.data import DataLoader
+        return DataLoader(
+            self.test_dataset,
+            batch_size=kwargs.get('batch_size', self.batch_size),
+            shuffle=False,
+            num_workers=kwargs.get('num_workers', self.num_workers),
+            pin_memory=True
+        )
+    
+    def get_statistics(self):
+        """Get statistics for all splits."""
+        return {
+            'train': self.train_dataset.get_statistics(),
+            'val': self.val_dataset.get_statistics(),
+            'test': self.test_dataset.get_statistics()
+        }
+
+
+# Example usage
+if __name__ == "__main__":
+    print("="*60)
+    print("EIT Dataset Loader - Example Usage")
+    print("="*60)
+    
+    # Create dataset
+    data_dir = "/mnt/f/MSS/EIT-Dataset/uploadedDataset"
+    
+    print("\n1. Creating datasets...")
+    train_dataset = EITDataset(
+        data_dir=data_dir,
+        subset="CirclesOnly",
+        split="train",
+        image_resolution="128_log",
+        load_to_memory=False
+    )
+    
+    print(f"   Train dataset size: {len(train_dataset)}")
+    print(f"   Image shape: {train_dataset.get_image_shape()}")
+    
+    # Get a sample
+    print("\n2. Loading a sample...")
+    sample = train_dataset[0]
+    print(f"   Keys: {list(sample.keys())}")
+    print(f"   Voltage measurements shape: {sample['voltage_measurements'].shape}")
+    print(f"   Conductivity map shape: {sample['conductivity_map'].shape}")
+    if 'graph_representation' in sample:
+        print(f"   Graph representation shape: {sample['graph_representation'].shape}")
+    print(f"   Sample ID: {sample['sample_id']}")
+    
+    # Create DataModule
+    print("\n3. Creating EITDataModule...")
+    data_module = EITDataModule(
+        data_dir=data_dir,
+        subset="CirclesOnly",
+        image_resolution="128_log",
+        batch_size=4,
+        num_workers=0  # Set to 0 for testing, increase for training
+    )
+    
+    print(f"   Train samples: {len(data_module.train_dataset)}")
+    print(f"   Val samples: {len(data_module.val_dataset)}")
+    print(f"   Test samples: {len(data_module.test_dataset)}")
+    
+    # Create DataLoader
+    print("\n4. Creating DataLoader and getting a batch...")
+    train_loader = data_module.train_dataloader()
+    batch = next(iter(train_loader))
+    print(f"   Batch voltage shape: {batch['voltage_measurements'].shape}")
+    print(f"   Batch image shape: {batch['conductivity_map'].shape}")
+    print(f"   Batch IDs: {batch['sample_id'].tolist()}")
+    
+    # Test different configurations
+    print("\n5. Testing different resolutions...")
+    for resolution in ["32_log", "64_log", "128_log", "256"]:
+        try:
+            ds = EITDataset(data_dir, "CirclesOnly", "train", resolution)
+            print(f"   {resolution}: {len(ds)} samples, shape: {ds.get_image_shape()}")
+        except Exception as e:
+            print(f"   {resolution}: Error - {e}")
+    
+    print("\n" + "="*60)
+    print("All tests completed successfully!")
+    print("="*60)