from pathlib import Path from typing import Callable from typing import Dict from typing import Iterable from typing import Optional from typing import Union import lmdb import numpy as np import pandas as pd import torch import torch.nn.functional as F import torchvision.transforms as transforms from safetensors.numpy import load as safetensor_load from torch.utils.data import Dataset, DataLoader try: import lightning.pytorch as pl except ImportError: import pytorch_lightning as pl _s1_bandnames = ["VV", "VH"] _s2_bandnames = ["B01", "B02", "B03", "B04", "B05", "B06", "B07", "B08", "B8A", "B09", "B11", "B12"] _predefined_bandcombinations = { "RGB": ["B04", "B03", "B02"], "S2-10m20m": ["B02", "B03", "B04", "B05", "B06", "B07", "B08", "B8A", "B11", "B12"], "S1S2-10m20m": ["VV", "VH", "B02", "B03", "B04", "B05", "B06", "B07", "B08", "B8A", "B11", "B12"], "all": _s1_bandnames + _s2_bandnames, } """ This file contains band statistics for BigEarthNet v2 (including S1 stats from v1) after interpolating the images to 120x120 with nearest neighbor. The statistics are calculated based on the images of the official train split. """ means = { "B01": 361.0767822265625, "B02": 438.3720703125, "B03": 614.0556640625, "B04": 588.4096069335938, "B05": 942.8433227539062, "B06": 1769.931640625, "B07": 2049.551513671875, "B08": 2193.2919921875, "B09": 2241.455322265625, "B11": 1568.226806640625, "B12": 997.7324829101562, "B8A": 2235.556640625, "VH": -19.352558135986328, "VV": -12.643863677978516, } stds = { "B01": 575.0687255859375, "B02": 607.02685546875, "B03": 603.2968139648438, "B04": 684.56884765625, "B05": 738.4326782226562, "B06": 1100.4560546875, "B07": 1275.805419921875, "B08": 1369.3717041015625, "B09": 1316.393310546875, "B11": 1070.1612548828125, "B12": 813.5276489257812, "B8A": 1356.5440673828125, "VH": 5.590505599975586, "VV": 5.133493900299072, } def default_train_transform(img_size, mean, std): return transforms.Compose( [ transforms.Resize(img_size, antialias=True), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), transforms.Normalize(mean, std), ] ) def default_transform(img_size, mean, std): return transforms.Compose( [ transforms.Resize(img_size, antialias=True), transforms.Normalize(mean, std), ] ) def collate_mixed(batch): images = [] texts = [] outputs = [] for item in batch: images.append(item["image_input"]) texts.append(item["text_input"]) outputs.append(item["reference_output"]) # stack the images into a tensor batch images = torch.stack(images, dim=0) return { "image_input": images, "text_input": texts, # list of strings "reference_output": outputs, # list of arbitrary items } class BENImageReader: def __init__( self, image_lmdb_file: Union[str, Path], metadata_file: Union[str, Path], bands: Iterable[str], img_size: int = 120, upsample_mode: str = "nearest", info_fn: Optional[Callable] = lambda x: x, ): self.img_size = img_size self.upsample_mode = upsample_mode self.image_lmdb_file = image_lmdb_file self.bands = bands self.env = None info_fn(f"Using bandorder {self.bands}") self.uses_s1 = any([x in _s1_bandnames for x in self.bands]) self.uses_s2 = any([x in _s2_bandnames for x in self.bands]) metadata = pd.read_parquet(metadata_file) self.mapping = {p: s for p, s in zip(metadata["patch_id"], metadata["s1_name"])} info_fn("S1-S2 mapping created") def stack_and_interpolate( self, data: Dict[str, np.ndarray], ) -> np.array: def _interpolate(img_data): if not img_data.shape[-2:] == (self.img_size, self.img_size): return F.interpolate( torch.Tensor(np.float32(img_data)).unsqueeze(0).unsqueeze(0), (self.img_size, self.img_size), mode=self.upsample_mode, align_corners=True if self.upsample_mode in ["bilinear", "bicubic"] else None, ).squeeze() else: return torch.Tensor(np.float32(img_data)) return torch.stack([_interpolate(data[x]) for x in self.bands]) def open_env(self): if self.env is None: print("Opening LMDB environment ...") self.env = lmdb.open( str(self.image_lmdb_file), readonly=True, lock=False, meminit=False, readahead=True, map_size=8 * 1024 ** 3, # 8GB blocked for caching max_spare_txns=16, # expected number of concurrent transactions (e.g. threads/workers) ) def __getitem__(self, key: str): # open lmdb file if not opened yet self.open_env() img_data_dict: dict = {} if self.uses_s2: assert self.env is not None, "Environment not opened yet" # read image data for S2v2 with self.env.begin(write=False, buffers=True) as txn: byte_data = txn.get(key.encode()) img_data_dict.update(safetensor_load(bytes(byte_data))) if self.uses_s1: # read image data for S1 assert self.mapping is not None, "S1 bands are used, but no mapping is provided" s1_key = self.mapping[key] assert self.env is not None, "Environment not opened yet" with self.env.begin(write=False, buffers=True) as txn: byte_data = txn.get(s1_key.encode()) img_data_dict.update(safetensor_load(bytes(byte_data))) img_data_dict = {k: v for k, v in img_data_dict.items() if k in self.bands} img_data = self.stack_and_interpolate(img_data_dict) return img_data 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__( self, lmdb_file: Union[str, Path], metadata_file: Union[str, Path], bands: Iterable[str], img_size: int = 120, upsample_mode: str = "nearest", types: Optional[Iterable[str]] = None, categories: Optional[Iterable[str]] = None, countries: Optional[Iterable[str]] = None, seasons: Optional[Iterable[str]] = None, climate_zones: Optional[Iterable[str]] = None, transform: Optional[Callable] = None, splits: Optional[Iterable[str]] = None, point_token: Optional[str] = None, 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](https://huggingface.co/datasets/BIFOLD-BigEarthNetv2-0/BigEarthNet.txt/sql-console/8okbuKf) 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](https://huggingface.co/datasets/BIFOLD-BigEarthNetv2-0/BigEarthNet.txt/sql-console/3xLT8_u) 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 tags in text. ref_token: Optional tuple of [start_token, end_token] to wrap 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) # check the format of the text file assert self._expected_columns.issubset(set(self.text_data.columns)), f"The text data at {metadata_file} does not contain the expected columns" info_fn(f"Loaded text data with {len(self.text_data)} entries") if types is not None: self.text_data = self.text_data[self.text_data["type"].isin(types)] if categories is not None: self.text_data = self.text_data[self.text_data["category"].isin(categories)] if countries is not None: self.text_data = self.text_data[self.text_data["country"].isin(countries)] if seasons is not None: self.text_data = self.text_data[self.text_data["season"].isin(seasons)] if climate_zones is not None: self.text_data = self.text_data[self.text_data["climate_zone"].isin(climate_zones)] self.text_data = self.text_data.reset_index(drop=True) info_fn(f"After filtering, text data contains {len(self.text_data)} entries") if splits is not None: self.text_data = self.text_data[self.text_data["split"].isin(splits)].reset_index(drop=True) info_fn(f"Split {splits} text data contains {len(self.text_data)} entries") self.transform = transform self.point_token = ["", ""] if point_token is None else point_token assert len(self.point_token) == 2, "Point tokens must have length 2." self.ref_token = ["", ""] if ref_token is None else ref_token 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 the stacked bands, applying image transformations if transform is provided. - '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] if self.transform is not None: img_data = self.transform(img_data) text_in = sample.input.replace("", self.ref_token[0]).replace("", self.ref_token[1]) text_in = text_in.replace("", self.point_token[0]).replace("", self.point_token[1]) if sample.type in {'binary', 'mcq', 'captioning', 'bounding box'}: output = sample.output else: raise NotImplementedError(f"{sample.type} is not supported") return { "image_input": img_data, "text_input": text_in, "reference_output": output, } 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 bench_ds = None def __init__( self, image_lmdb_file: Union[str, Path], metadata_file: Union[str, Path], bands: Optional[Union[Iterable[str], str]] = None, img_size: int = 120, upsample_mode: str = "nearest", types: Optional[Iterable[str]] = None, categories: Optional[Iterable[str]] = None, countries: Optional[Iterable[str]] = None, seasons: Optional[Iterable[str]] = None, climate_zones: Optional[Iterable[str]] = None, num_workers_dataloader: Optional[int] = 4, batch_size: Optional[int] = 16, image_transforms_train: Optional[Callable] = None, image_transforms_eval: Optional[Callable] = None, point_token: Iterable[str] = None, 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](https://huggingface.co/datasets/BIFOLD-BigEarthNetv2-0/BigEarthNet.txt/sql-console/KzrmYgF) 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](https://huggingface.co/datasets/BIFOLD-BigEarthNetv2-0/BigEarthNet.txt/sql-console/SUU1DwA) 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 tags in text. ref_token: Optional tuple of [start_token, end_token] to wrap 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 self.pin_memory = torch.cuda.is_available() if isinstance(bands, str): assert bands in _predefined_bandcombinations, f"{bands} not in predefined options: {_predefined_bandcombinations.keys()}" self.bands = _predefined_bandcombinations[bands] elif isinstance(bands, Iterable): self.bands = list(bands) elif bands is None: self.bands = _predefined_bandcombinations['all'] else: raise NotImplementedError(f"{bands} is not supported") self.ds_kwargs = { "lmdb_file": image_lmdb_file, "metadata_file": metadata_file, "bands": self.bands, "img_size": img_size, "upsample_mode": upsample_mode, "types": types, "categories": categories, "countries": countries, "seasons": seasons, "climate_zones": climate_zones, "point_token": point_token, "ref_token": ref_token, "info_fn": info_fn, } # set mean and std based on bands selected self.mean = [means[b] for b in self.bands] self.std = [stds[b] for b in self.bands] self.train_transforms = image_transforms_train if image_transforms_train is not None else default_train_transform(img_size, mean=self.mean, std=self.std) 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, splits=['train'], transform=self.train_transforms ) self.val_ds = BENTxTDataset( **self.ds_kwargs, splits=['validation'], transform=self.eval_transforms ) if stage == "test" or stage is None: self.test_ds = BENTxTDataset( **self.ds_kwargs, splits=['test', 'bench'], transform=self.eval_transforms ) if stage == "bench" or stage is None: self.bench_ds = BENTxTDataset( **self.ds_kwargs, splits=['bench'], transform=self.eval_transforms ) 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)