Delete cloud_s2/senbench_clouds2_wrapper.py

cloud_s2/senbench_clouds2_wrapper.py

@@ -1,155 +0,0 @@
-import kornia as K
-import torch
-from torchgeo.datasets import CloudCoverDetection
-from typing import ClassVar
-from collections.abc import Callable, Sequence
-from torch import Tensor
-from datetime import date
-import os
-import pandas as pd
-import numpy as np
-import rasterio
-from pyproj import Transformer
-from typing import TypeAlias
-Path: TypeAlias = str | os.PathLike[str]
-
-class SenBenchCloudS2(CloudCoverDetection):
-    url = None
-    all_bands = ('B02', 'B03', 'B04', 'B08')
-    splits: ClassVar[dict[str, str]] = {'train': 'public', 'val': 'private', 'test': 'private'}
-
-    def __init__(
-        self,
-        root: Path = 'data',
-        split: str = 'train',
-        bands: Sequence[str] = all_bands,
-        transforms: Callable[[dict[str, Tensor]], dict[str, Tensor]] | None = None,
-        download: bool = False,
-    ) -> None:
-
-        #super().__init__(root=root, split=split, bands=bands, transforms=transforms, download=download)
-        assert split in self.splits
-        assert set(bands) <= set(self.all_bands)
-
-        self.root = root
-        self.split = split
-        self.bands = bands
-        self.transforms = transforms
-        self.download = download
-
-        self.csv = os.path.join(self.root, self.split, f'{self.split}_metadata.csv')
-        self._verify()
-
-        self.metadata = pd.read_csv(self.csv)
-        
-        self.reference_date = date(1970, 1, 1)
-        self.patch_area = (16*10)**2 # patchsize 16 pix, gsd 10m
-
-    def __getitem__(self, index: int) -> dict[str, Tensor]:
-        """Returns a sample from dataset.
-
-        Args:
-            index: index to return
-
-        Returns:
-            data, metadata (lon,lat,days,area) and label at given index
-        """
-        chip_id = self.metadata.iat[index, 0]
-        date_str = self.metadata.iat[index, 2]
-        date_obj = date(int(date_str[:4]), int(date_str[5:7]), int(date_str[8:10]))
-        delta = (date_obj - self.reference_date).days
-
-        image, coord = self._load_image(chip_id)
-        label = self._load_target(chip_id)
-
-        meta_info = np.array([coord[0], coord[1], delta, self.patch_area]).astype(np.float32)
-
-        sample = {'image': image, 'mask': label, 'meta': torch.from_numpy(meta_info)}
-
-        if self.transforms is not None:
-            sample = self.transforms(sample)
-
-        # # add metadata
-        # sample['meta'] = torch.from_numpy(meta_info)
-
-        return sample
-
-    def _load_image(self, chip_id: str) -> Tensor:
-        """Load all source images for a chip.
-
-        Args:
-            chip_id: ID of the chip.
-
-        Returns:
-            a tensor of stacked source image data, coord (lon,lat)
-        """
-        path = os.path.join(self.root, self.split, f'{self.split}_features', chip_id)
-        images = []
-        coords = None
-        for band in self.bands:
-            with rasterio.open(os.path.join(path, f'{band}.tif')) as src:
-                images.append(src.read(1).astype(np.float32))
-                if coords is None:
-                    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
-
-        return torch.from_numpy(np.stack(images, axis=0)), (lon,lat)
-
-
-
-class SegDataAugmentation(torch.nn.Module):
-    def __init__(self, split, size):
-        super().__init__()
-
-        mean = torch.Tensor([0.0])
-        std = torch.Tensor([1.0])
-
-        self.norm = K.augmentation.Normalize(mean=mean, std=std)
-
-        if split == "train":
-            self.transform = K.augmentation.AugmentationSequential(
-                K.augmentation.Resize(size=size, align_corners=True),
-                K.augmentation.RandomRotation(degrees=90, p=0.5, align_corners=True),
-                K.augmentation.RandomHorizontalFlip(p=0.5),
-                K.augmentation.RandomVerticalFlip(p=0.5),
-                data_keys=["input", "mask"],
-            )
-        else:
-            self.transform = K.augmentation.AugmentationSequential(
-                K.augmentation.Resize(size=size, align_corners=True),
-                data_keys=["input", "mask"],
-            )
-
-    @torch.no_grad()
-    def forward(self, batch: dict[str,]):
-        """Torchgeo returns a dictionary with 'image' and 'label' keys, but engine expects a tuple"""
-        x,mask = batch["image"], batch["mask"]
-        x = self.norm(x)
-        x_out, mask_out = self.transform(x, mask)
-        return x_out.squeeze(0), mask_out.squeeze(0).squeeze(0), batch["meta"]
-
-class SenBenchCloudS2Dataset:
-    def __init__(self, config):
-        self.dataset_config = config
-        self.img_size = (config.image_resolution, config.image_resolution)
-        self.root_dir = config.data_path
-
-    def create_dataset(self):
-        train_transform = SegDataAugmentation(split="train", size=self.img_size)
-        eval_transform = SegDataAugmentation(split="test", size=self.img_size)
-
-        dataset_train = SenBenchCloudS2(
-            root=self.root_dir, split="train", transforms=train_transform
-        )
-        dataset_val = SenBenchCloudS2(
-            root=self.root_dir, split="val", transforms=eval_transform
-        )
-        dataset_test = SenBenchCloudS2(
-            root=self.root_dir, split="test", transforms=eval_transform
-        )
-
-        return dataset_train, dataset_val, dataset_test