Upload cobench_bigearthnets12_wrapper_csv.py

l2_bigearthnet_s1s2/cobench_bigearthnets12_wrapper_csv.py

@@ -0,0 +1,329 @@
+import glob
+import os
+from typing import Callable, Optional
+from collections.abc import Sequence
+
+import kornia.augmentation as K
+import pandas as pd
+import rasterio
+import torch
+from torch import Generator, Tensor
+from torch.utils.data import random_split
+from torchgeo.datasets import BigEarthNet
+#from torchgeo.datasets.geo import NonGeoDataset
+
+from pyproj import Transformer
+from datetime import date
+import numpy as np
+import pdb
+import ast
+
+
+class CoBenchBigEarthNetS12(BigEarthNet):
+    #url = ''
+    splits = ('train', 'val', 'test')
+    label_filenames = {
+        'train': 'multilabel-train.csv',
+        'val': 'multilabel-val.csv',
+        'test': 'multilabel-test.csv',
+    }
+    image_size = (120, 120)
+    all_band_names_s1 = ('VV','VH')
+    all_band_names_s2 = ('B01', 'B02', 'B03', 'B04', 'B05', 'B06', 'B07', 'B08', 'B8A', 'B09', 'B11', 'B12')
+
+    def __init__(
+        self,
+        root: str = "data",
+        split: str = "train",
+        bands: str = "all",
+        band_names: Sequence[str] = ('B01', 'B02', 'B03', 'B04', 'B05', 'B06', 'B07', 'B08', 'B8A', 'B09', 'B11', 'B12'),
+        num_classes: int = 19,
+        transforms: Optional[Callable[[dict[str, Tensor]], dict[str, Tensor]]] = None,
+        download: bool = False,
+        checksum: bool = False,
+    ) -> None:
+
+        assert split in self.splits
+        assert bands in ['s1', 's2']
+        assert num_classes in [43, 19]
+        self.root = root
+        self.split = split
+        self.bands = bands
+        self.num_classes = num_classes
+        self.transforms = transforms
+
+
+        self.band_names = band_names
+        if self.bands == 's1':
+            self.all_band_names = self.all_band_names_s1
+        else:
+            self.all_band_names = self.all_band_names_s2
+        self.band_indices = [(self.all_band_names.index(b)+1) for b in band_names if b in self.all_band_names]
+
+        self.class2idx_43 = {c: i for i, c in enumerate(self.class_sets[43])}
+        self.class2idx_19 = {c: i for i, c in enumerate(self.class_sets[19])}
+        #self._verify()
+
+        #self.folders = self._load_folders()
+        self.img_paths = []
+        self.labels = []
+        self.csv = pd.read_csv(os.path.join(self.root,self.label_filenames[self.split]))
+        for i, row in self.csv.iterrows():
+            if self.bands == 's1':
+                s1_path = os.path.join(self.root, row['s1_path'])
+                self.img_paths.append(s1_path)
+            elif self.bands == 's2':
+                s2_path = os.path.join(self.root, row['s2_path'])
+                self.img_paths.append(s2_path)
+            labels = row['labels']
+            labels_list = ast.literal_eval(labels)
+            self.labels.append(labels_list)
+
+
+
+        self.patch_area = (16*10/1000)**2
+        self.reference_date = date(1970, 1, 1)
+
+    def __len__(self):
+        return len(self.img_paths)
+
+    def get_class2idx(self, label: str, level=19):
+        assert level == 19 or level == 43, "level must be 19 or 43"
+        return self.class2idx_19[label] if level == 19 else self.class2idx_43[label]
+
+    def _load_target(self, index: int) -> Tensor:
+        image_labels = self.labels[index]
+
+        # labels -> indices
+        indices = [
+            self.get_class2idx(label, level=self.num_classes) for label in image_labels
+        ]
+
+        image_target = torch.zeros(self.num_classes, dtype=torch.long)
+        image_target[indices] = 1
+
+        return image_target
+
+    def _load_image(self, index: int) -> Tensor:
+        path = self.img_paths[index]
+        # Bands are of different spatial resolutions
+        # Resample to (120, 120)
+        with rasterio.open(path) as src:
+            array = src.read(
+                self.band_indices,
+            ).astype('float32')
+
+            cx,cy = src.xy(src.height // 2, src.width // 2)
+            if src.crs.to_string() != 'EPSG:4326':
+                crs_transformer = Transformer.from_crs(src.crs, 'epsg:4326', always_xy=True)
+                lon, lat = crs_transformer.transform(cx,cy)
+            else:
+                lon, lat = cx, cy
+
+            if self.bands == 's1':
+                date_str = path.split('/')[-1].split('_')[4]
+            else:
+                date_str = path.split('/')[-1].split('_')[2]
+            date_obj = date(int(date_str[:4]), int(date_str[4:6]), int(date_str[6:8]))
+            delta = (date_obj - self.reference_date).days
+
+        tensor = torch.from_numpy(array).float()
+        return tensor, (lon,lat), delta
+
+    def __getitem__(self, index: int) -> dict[str, Tensor]:
+
+        image, coord, delta = self._load_image(index)
+        meta_info = np.array([coord[0], coord[1], delta, self.patch_area]).astype(np.float32)
+        label = self._load_target(index)
+        sample: dict[str, Tensor] = {'image': image, 'label': label, 'meta':meta_info}
+
+        if self.transforms is not None:
+            sample = self.transforms(sample)
+
+        return sample
+
+
+
+class ClsDataAugmentation(torch.nn.Module):
+
+    def __init__(self, split, size, bands, band_stats):
+        super().__init__()
+
+        self.bands = bands
+
+        if band_stats is not None:
+            mean = band_stats['mean']
+            std = band_stats['std']
+        else:
+            mean = [0.0]
+            std = [1.0]
+
+        mean = torch.Tensor(mean)
+        std = torch.Tensor(std)
+
+        if split == "train":
+            self.transform = torch.nn.Sequential(
+                K.Normalize(mean=mean, std=std),
+                K.Resize(size=size, align_corners=True),
+                K.RandomHorizontalFlip(p=0.5),
+                K.RandomVerticalFlip(p=0.5),
+            )
+        else:
+            self.transform = torch.nn.Sequential(
+                K.Normalize(mean=mean, std=std),
+                K.Resize(size=size, align_corners=True),
+            )
+
+    @torch.no_grad()
+    def forward(self, sample: dict[str,]):
+        """Torchgeo returns a dictionary with 'image' and 'label' keys, but engine expects a tuple."""
+        if self.bands == "rgb":
+            sample["image"] = sample["image"][1:4, ...].flip(dims=(0,))
+            # get in rgb order and then normalization can be applied
+        x_out = self.transform(sample["image"]).squeeze(0)
+        return x_out, sample["label"], sample["meta"]
+
+
+class ClsDataAugmentationSoftCon(torch.nn.Module):
+
+    def __init__(self, split, size, bands, band_stats):
+        super().__init__()
+
+        self.bands = bands
+
+        if band_stats is not None:
+            self.mean = band_stats['mean']
+            self.std = band_stats['std']
+        else:
+            self.mean = [0.0]
+            self.std = [1.0]
+
+        # mean = torch.Tensor(mean)
+        # std = torch.Tensor(std)
+
+        if split == "train":
+            self.transform = torch.nn.Sequential(
+                #K.Normalize(mean=mean, std=std),
+                K.Resize(size=size, align_corners=True),
+                K.RandomHorizontalFlip(p=0.5),
+                K.RandomVerticalFlip(p=0.5),
+            )
+        else:
+            self.transform = torch.nn.Sequential(
+                #K.Normalize(mean=mean, std=std),
+                K.Resize(size=size, align_corners=True),
+            )
+
+    @torch.no_grad()
+    def forward(self, sample: dict[str,]):
+        """Torchgeo returns a dictionary with 'image' and 'label' keys, but engine expects a tuple."""
+        if self.bands == 's1':
+            sample_img = sample["image"]
+            ### normalize s1
+            self.max_q = torch.quantile(sample_img.reshape(2,-1),0.99,dim=1)      
+            self.min_q = torch.quantile(sample_img.reshape(2,-1),0.01,dim=1)
+            img_bands = []
+            for b in range(2):
+                img = sample_img[b,:,:].clone()
+                ## outlier
+                max_q = self.max_q[b]
+                min_q = self.min_q[b]            
+                img = torch.clamp(img, min_q, max_q)
+                ## normalize
+                img = self.normalize(img,self.mean[b],self.std[b])         
+                img_bands.append(img)
+            sample_img = torch.stack(img_bands,dim=0) # VV,VH (w,h,c)
+        elif self.bands == 's2':
+            sample_img = sample["image"]
+            img_bands = []
+            for b in range(12):
+                img = sample_img[b,:,:].clone()
+                ## normalize
+                img = self.normalize(img,self.mean[b],self.std[b])         
+                img_bands.append(img)
+                if b==9:
+                    # pad zero to B10
+                    img_bands.append(torch.zeros_like(img))
+            sample_img = torch.stack(img_bands,dim=0)
+            
+        x_out = self.transform(sample_img).squeeze(0)
+        return x_out, sample["label"], sample["meta"]
+
+    @torch.no_grad()
+    def normalize(self, img, mean, std):
+        min_value = mean - 2 * std
+        max_value = mean + 2 * std
+        img = (img - min_value) / (max_value - min_value)
+        img = torch.clamp(img, 0, 1)
+        return img
+
+
+class CoBenchBigEarthNetS12Dataset:
+    def __init__(self, config):
+        self.dataset_config = config
+        self.img_size = (config.image_resolution, config.image_resolution)
+        self.root_dir = config.data_path
+        self.bands = config.modality
+        self.band_names = config.band_names
+        self.num_classes = config.num_classes
+        self.band_stats = config.band_stats
+        self.norm_form = config.norm_form if 'norm_form' in config else None
+
+        if self.bands == "rgb":
+            # start with rgb and extract later
+            self.input_bands = "s2"
+        else:
+            self.input_bands = self.bands
+
+    def create_dataset(self):
+
+        if self.norm_form == 'softcon':
+            train_transform = ClsDataAugmentationSoftCon(
+                split="train", size=self.img_size, bands=self.bands, band_stats=self.band_stats
+            )
+            eval_transform = ClsDataAugmentationSoftCon(
+                split="test", size=self.img_size, bands=self.bands, band_stats=self.band_stats
+            )
+        else:
+            train_transform = ClsDataAugmentation(
+                split="train", size=self.img_size, bands=self.bands, band_stats=self.band_stats
+            )
+            eval_transform = ClsDataAugmentation(
+                split="test", size=self.img_size, bands=self.bands, band_stats=self.band_stats
+            )
+
+        dataset_train = CoBenchBigEarthNetS12(
+            root=self.root_dir,
+            num_classes=self.num_classes,
+            split="train",
+            bands=self.input_bands,
+            band_names=self.band_names,
+            transforms=train_transform,
+        )
+
+        # num_subset_samples = int(0.1 * len(dataset_train))
+        # # Split the dataset into the subset and the remaining part
+        # subset_train, _ = random_split(
+        #     dataset_train,
+        #     [num_subset_samples, len(dataset_train) - num_subset_samples],
+        #     generator=Generator().manual_seed(42),
+        # )
+
+        dataset_val = CoBenchBigEarthNetS12(
+            root=self.root_dir,
+            num_classes=self.num_classes,
+            split="validation",
+            bands=self.input_bands,
+            band_names=self.band_names,
+            transforms=eval_transform,
+        )
+        dataset_test = CoBenchBigEarthNetS12(
+            root=self.root_dir,
+            num_classes=self.num_classes,
+            split="test",
+            bands=self.input_bands,
+            band_names=self.band_names,
+            transforms=eval_transform,
+        )
+
+        return dataset_train, dataset_val, dataset_test