Added docstrings to the custom classes.

ben_txt_datamodule.py

@@ -188,6 +188,12 @@ class BENImageReader:
 
 
 class BENTxTDataset(Dataset):
+    """
+    PyTorch Dataset for BigEarthNet.txt.
+    
+    This dataset class loads the textual annotations from BigEarthNet.txt toegther with the satellite imagery (Sentinel-1 and Sentinel-2) from the BigEarthNet-v2.0 dataset (converted to LMDB format).
+    It supports various filtering options to create custom dataset splits based on textual annotation metadata, such as type or category, or image metadata like country, season, and climate zone.
+    """
     _expected_columns = {'s1_name', 'output', 'longitude', 'country', 'climate_zone', 'type', 'input', 'split', 'latitude', 'ID', 'patch_id', 'category', 'season'}
 
     def __init__(
@@ -208,7 +214,39 @@ class BENTxTDataset(Dataset):
             ref_token: Optional[str] = None,
             info_fn: Callable = lambda x: x,
     ):
+        """
+        Initialize the BigEarthNet.txt Dataset.
+        
+        Args:
+            lmdb_file: Path to the LMDB file containing the BigEarthNet-v2.0 image data.
+            metadata_file: Path to the BigEarthNet.txt Parquet file.
+            bands: Band names to load. Can be a predefined combination key ('RGB', 'S2-10m20m', 'S1S2-10m20m', 'all') or an iterable of band names, i.e., ('B04', 'B03', 'B02').
+            img_size: Target image size for interpolation (default: 120).
+            upsample_mode: Interpolation mode for resizing ('nearest', 'bilinear', 'bicubic', etc.).
+                Default: 'nearest'.
+            types: Optional filter for annotation types (e.g., 'binary', 'mcq', 'captioning', 'bounding box').
+            categories: Optional filter for annotation categories. See [here](TODO) for possible type-category combinations or retrieve them by yourself using some kind of database tool on the Parquet file.
+            countries: Optional filter for acquisition countries (e.g., 'Austria', 'Belgium', 'Finland', 'Ireland', 'Kosovo', 'Lithuania', 'Luxembourg', 'Portugal', 'Serbia', 'Switzerland').
+            seasons: Optional filter for seasons (e.g., 'Spring', 'Summer', 'Fall', 'Winter').
+            climate_zones: Optional filter for climate zones. See [here](TODO) for possible climate_zones values or retrieve them by yourself using some kind of database tool on the Parquet file. 
+            transform: Optional torchvision transform to apply to images.
+            splits: Optional filter for dataset splits ('train', 'validation', 'test', 'bench').
+            point_token: Optional tuple of [start_token, end_token] to wrap <point> tags in text.
+            ref_token: Optional tuple of [start_token, end_token] to wrap <ref> tags in text.
+            info_fn: Optional callback function for logging information during initialization.
+        """
         super().__init__()
+        
+        if isinstance(bands, str):
+            assert bands in _predefined_bandcombinations, f"{bands} not in predefined options: {_predefined_bandcombinations.keys()}"
+            bands = _predefined_bandcombinations[bands]
+        elif isinstance(bands, Iterable):
+            bands = list(bands)
+        elif bands is None:
+            bands = _predefined_bandcombinations['all']
+        else:
+            raise NotImplementedError(f"{bands} is not supported")
+
         self.image_reader = BENImageReader(lmdb_file, metadata_file, bands, img_size, upsample_mode, info_fn=info_fn)
 
         self.text_data = pd.read_parquet(metadata_file)
@@ -240,9 +278,24 @@ class BENTxTDataset(Dataset):
         assert len(self.ref_token) == 2, "Reference tokens must have length 2."
 
     def __len__(self):
+        """Return the number of samples in the dataset."""
         return len(self.text_data)
 
     def __getitem__(self, idx):
+        """
+        Get a sample from the dataset.
+        
+        Args:
+            idx: Index of the sample to retrieve.
+        
+        Returns:
+            dict: A dictionary containing:
+                - 'image_input': Tensor of shape (num_bands, img_size, img_size) containing normalized
+                  satellite imagery.
+                - 'text_input': String containing the text query/caption with tokens replaced based on
+                  point_token and ref_token settings.
+                - 'reference_output': The expected output/answer for the given input.
+        """
         sample = self.text_data.iloc[idx]
         img_id = sample.patch_id
         img_data = self.image_reader[img_id]
@@ -265,6 +318,26 @@ class BENTxTDataset(Dataset):
 
 
 class BENTxTDataModule(pl.LightningDataModule):
+    """
+    PyTorch Lightning DataModule for BigEarthNet.txt.
+    
+    This DataModule provides a structured interface for loading and preprocessing BigEarthNet.txt 
+    data for use with PyTorch Lightning training loops. It automatically handles train, 
+    validation, test, and benchmark dataset splits, with proper train/eval transforms and 
+    DataLoader configuration.
+    
+    The module manages:
+    - Automatic dataset setup for different training stages
+    - Image preprocessing and normalization based on selected bands
+    - DataLoader creation with appropriate batch sizes and worker processes
+    - GPU pinning when CUDA is available
+    
+    Attributes:
+        train_ds (BENTxTDataset): Training dataset instance.
+        val_ds (BENTxTDataset): Validation dataset instance.
+        test_ds (BENTxTDataset): Test dataset instance.
+        bench_ds (BENTxTDataset): Benchmark dataset instance.
+    """
     train_ds = None
     val_ds = None
     test_ds = None
@@ -290,6 +363,33 @@ class BENTxTDataModule(pl.LightningDataModule):
             ref_token: Iterable[str] = None,
             info_fn: Optional[Callable] = lambda x: x,
     ):
+        """
+        Initialize the BigEarthNet.txt DataModule.
+        
+        Args:
+            lmdb_file: Path to the LMDB file containing the BigEarthNet-v2.0 image data.
+            metadata_file: Path to the BigEarthNet.txt Parquet file.
+            bands: Band names to load. Can be a predefined combination key ('RGB', 'S2-10m20m', 'S1S2-10m20m', 'all') or an iterable of band names, i.e., ('B04', 'B03', 'B02').
+            img_size: Target image size for interpolation (default: 120).
+            upsample_mode: Interpolation mode for resizing ('nearest', 'bilinear', 'bicubic', etc.).
+                Default: 'nearest'.
+            types: Optional filter for annotation types (e.g., 'binary', 'mcq', 'captioning', 'bounding box').
+            categories: Optional filter for annotation categories. See [here](TODO) for possible type-category combinations or retrieve them by yourself using some kind of database tool on the Parquet file.
+            countries: Optional filter for acquisition countries (e.g., 'Austria', 'Belgium', 'Finland', 'Ireland', 'Kosovo', 'Lithuania', 'Luxembourg', 'Portugal', 'Serbia', 'Switzerland').
+            seasons: Optional filter for seasons (e.g., 'Spring', 'Summer', 'Fall', 'Winter').
+            climate_zones: Optional filter for climate zones. See [here](TODO) for possible climate_zones values or retrieve them by yourself using some kind of database tool on the Parquet file. 
+            transform: Optional torchvision transform to apply to images.
+            num_workers_dataloader: Number of worker processes for DataLoaders (default: 4).
+                Set to 0 to disable multiprocessing.
+            batch_size: Batch size for DataLoaders (default: 16).
+            image_transforms_train: Custom image transforms for training. If None, uses default
+                augmentations (resize, flip, normalize).
+            image_transforms_eval: Custom image transforms for evaluation/validation. If None,
+                uses simple normalization.
+            point_token: Optional tuple of [start_token, end_token] to wrap <point> tags in text.
+            ref_token: Optional tuple of [start_token, end_token] to wrap <ref> tags in text.
+            info_fn: Optional callback function for logging during initialization.
+        """
         super().__init__()
         self.num_workers_dataloader = num_workers_dataloader
         self.batch_size = batch_size
@@ -329,6 +429,18 @@ class BENTxTDataModule(pl.LightningDataModule):
         self.eval_transforms = image_transforms_eval if image_transforms_eval is not None else default_transform(img_size, mean=self.mean, std=self.std)
 
     def setup(self, stage: Optional[str] = None) -> None:
+        """
+        Create train/val/test/bench datasets based on the specified stage.
+        
+        This method is called by PyTorch Lightning during trainer initialization.
+        
+        Args:
+            stage: The training stage - one of 'fit', 'test', 'bench', or None. If None,
+                all datasets are created. Default: None.
+                - 'fit': Creates train and validation datasets
+                - 'test': Creates test dataset (includes both 'test' and 'bench' splits)
+                - 'bench': Creates benchmark dataset
+        """
         if stage == "fit" or stage is None:
             self.train_ds = BENTxTDataset(
                 **self.ds_kwargs,
@@ -356,13 +468,17 @@ class BENTxTDataModule(pl.LightningDataModule):
 
 
     def train_dataloader(self):
+        """Create and return the training DataLoader with shuffling and augmentations."""
         return DataLoader(self.train_ds, batch_size=self.batch_size, num_workers=self.num_workers_dataloader, shuffle=True, pin_memory=self.pin_memory, collate_fn=collate_mixed)
 
     def val_dataloader(self):
+        """Create and return the validation DataLoader without shuffling."""
         return DataLoader(self.val_ds, batch_size=self.batch_size, num_workers=self.num_workers_dataloader, shuffle=False, pin_memory=self.pin_memory, collate_fn=collate_mixed)
 
     def test_dataloader(self):
+        """Create and return the test DataLoader (includes both 'test' and 'bench' splits)."""
         return DataLoader(self.test_ds, batch_size=self.batch_size, num_workers=self.num_workers_dataloader, shuffle=False, pin_memory=self.pin_memory, collate_fn=collate_mixed)
 
     def bench_dataloader(self):
+        """Create and return the benchmark DataLoader."""
         return DataLoader(self.bench_ds, batch_size=self.batch_size, num_workers=self.num_workers_dataloader, shuffle=False, pin_memory=self.pin_memory, collate_fn=collate_mixed)

example_data_loading.py

@@ -3,10 +3,10 @@ from ben_txt_datamodule import BENTxTDataset, BENTxTDataModule
 def create_dataset_example():
     # Datasets example using the Red (B04), Green (B03), and Blue (B02) band from the Sentinel-2 images.
     ds_rgb = BENTxTDataset(
-        lmdb_file="Encoded-BigEarthNet/",
-        metadata_file="BigEarthNet.txt.parquet",
-        bands=("B04", "B03", "B02"),
-        img_size=120
+        lmdb_file = "Encoded-BigEarthNet/",
+        metadata_file = "BigEarthNet.txt.parquet",
+        bands = ("B04", "B03", "B02"),
+        img_size = 120
     )
 
     sample = ds_rgb[0]
@@ -18,19 +18,19 @@ def create_datamodule_example():
     # Lightning DataModule example using the 10m and 20m spatial resolution bands from Sentinel-1 and Sentinel-2 and multiple metadata filters.
     # The datamodule will create 4 dataloaders: train, val, test, and bench.
     dm = BENTxTDataModule(
-        image_lmdb_file="Encoded-BigEarthNet/",
-        metadata_file="BigEarthNet.txt.parquet",
-        bands='S1S2-10m20m',
-        img_size=120,
-        batch_size=1,
-        num_workers_dataloader=0,
+        image_lmdb_file = "Encoded-BigEarthNet/",
+        metadata_file = "BigEarthNet.txt.parquet",
+        bands = 'S1S2-10m20m',
+        img_size = 120,
+        batch_size = 1,
+        num_workers_dataloader = 0,
         types = ['mcq'],
         categories = ['climate zone'],
         countries = ['Portugal', 'Finland'],
         seasons = ['Summer'],
         climate_zones = None,
         point_token = ['<point>', '</point>'],
-        ref_token=['<ref>', '</ref>']
+        ref_token = ['<ref>', '</ref>']
     )
     dm.setup()