Final report submission

.gitattributes

@@ -32,3 +32,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Paper.pdf filter=lfs diff=lfs merge=lfs -text

Paper.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c848cf800ba48198acd2e208da5cbed9bff28442ca3c02e74682fe87946bcda
+size 2988104

chabud.py

@@ -0,0 +1,752 @@
+##
+## chabud.py - Hilfsfunktionen für die ChaBuD ECML Challenge 2023
+##
+## CHANGES:
+## 2023-05-23: Erste Version veröffentlicht
+##
+## TODO:
+## * Funktion um Vorhersage als CSV zu speichern für Leaderboard
+## * Argument um Anzahl Trainingsepochen zu steuern (epoch, max_epoch, ... ?)
+## * Finales Modell ausgeben und ggf. auch Vorhersage auf Validierungsdaten speichern
+##
+import logging
+import os
+from pathlib import Path
+import pandas as pd
+import albumentations as A
+import albumentations.pytorch.transforms as Atorch
+import h5py
+import numpy as np
+import pytorch_lightning as pl
+import segmentation_models_pytorch as smp
+import torch
+import xarray as xr
+
+from pytorch_lightning.callbacks import ModelCheckpoint
+
+fn = Path("A:/CodingProjekte/DataMining/src/train_eval.hdf5")
+
+#Wir wollen ein Dataframe erstellen, welches nur die Namen der Datensätze enthält, die eine größere Brandfläche als 2% haben.
+#Sogesehen ist es dann eine whitelist
+
+def basic_df():
+    res = []
+    #Anzahl aller Datensätze ("name")
+    count_ds = 0
+
+    with h5py.File(fn, "r") as fd:
+
+        for name, ds in fd.items():
+            count_burnt_pixels = 0
+            #Standardmäßig ist überall ein pre_fire verfügbar
+            pre_miss = 0
+            #Weil wir den Datensatz schon gecheckt haben, ist ein sicherer Zugrif auf post_fire und mask möglich (hier fehlen keine ganzen Datensätze)
+            post = ds["post_fire"]
+            mask = ds["mask"]
+
+            count_burnt_pixels = np.sum(mask)
+            count_pixels =512 * 512
+            burnt_pixel_rel = count_burnt_pixels / count_pixels
+            #Anders als bei mask und Post müssen wir vor Zugriff überprüfen ob "pre_fire" überhaupt existiert - Vermeidung einer Fehlermeldung
+            if "pre_fire" not in ds:
+                pre_miss = 1
+            res.append({"name": name, "pre_missing": pre_miss, "burnt_pixel_abs": count_burnt_pixels, "burnt_pixel_rel": burnt_pixel_rel})
+
+        return pd.DataFrame(res)
+
+def miss_dp_df():
+    BANDS = ["coastal_aerosol", "blue", "green", "red",
+             "veg_red_1", "veg_red_2", "veg_red_3", "nir",
+             "veg_red_4", "water_vapour", "swir_1", "swir_2"]
+
+    res = basic_df().values
+
+    # miss_dp ist eine Liste mit "name", "pre" "post" (Werte von Pre + Postt werden mit den Bandnamen selektiert)
+    miss_count = 0
+    miss_dp = []
+    with h5py.File(fn, "r") as fd:
+        for x in res:
+            # skippe die Datensätze mit fehlendem Pre-Bild
+            # if x["pre_missing"] == 1:
+            #     continue
+            pre_miss = False
+
+            # Laden der Daten aus dem Originaldatensatz
+            name = x["name"]
+            ds = to_xarray(fd[name])
+            pre = ds["pre"][...]
+            post = ds["post"][...]
+            mask = ds["mask"][...]
+
+            if x["pre_missing"] == 1:
+                # Code für den Fall, dass 'pre_missing' gleich 1 ist
+                post_miss = []
+                for band in range(pre.shape[2]):
+                    post_miss.append((np.sum(post[band] == 0).values))
+                x_post_miss = xr.DataArray(post_miss, dims=["band"], coords={"band": BANDS})
+                miss_dp.append({"name": name, "pre": [], "post": x_post_miss.values})
+            else:
+                # Code für den Fall, dass 'pre_missing' nicht gleich 1 ist
+                pre_miss = []
+                post_miss = []
+                for band in range(pre.shape[2]):
+                    pre_miss.append((np.sum(pre[band] == 0).values))
+                    post_miss.append((np.sum(post[band] == 0).values))
+                x_pre_miss = xr.DataArray(pre_miss, dims=["band"], coords={"band": BANDS})
+                x_post_miss = xr.DataArray(post_miss, dims=["band"], coords={"band": BANDS})
+                miss_dp.append({"name": name, "pre": x_pre_miss.values, "post": x_post_miss.values})
+
+    return miss_dp
+
+
+def wl():
+    whitelist = []
+    df = basic_df()
+
+    for index, row in df.iterrows():
+        if row["burnt_pixel_rel"] < 0.0025:
+            continue
+        whitelist.append(row["name"])
+    return whitelist
+
+checkpoint_callback = ModelCheckpoint(
+    #dirpath='checkpoints/',
+    filename='model-{epoch:02d}-{val_iou:.2f}',
+    monitor='valid_iou',
+    mode='max',
+    save_top_k=3
+)
+
+
+__version__ = "1.0.0"
+logger = logging.getLogger(__name__)
+
+ds_path = "A:/CodingProjekte/DataMining/src/train_eval.hdf5"
+
+
+def to_xarray(dataset, pretty_band_names=True):
+    """Konvertiert ein HDF5-Gruppenobjekt, das Vor- und Nach-Brandbilder enthält, in xarray DataArrays.
+
+    Parameters
+    ----------
+    dataset : h5py.Group
+        Ein HDF5-Gruppenobjekt, das die Vor- und Nach-Brandbilder, die Maske und die Metadaten enthält.
+    pretty_band_names : bool, optional
+        Wenn True (Standard), werden die "Pretty" Bandnamen verwendet, ansonsten die ursprünglichen MSI Bandnummern.
+
+    Returns
+    -------
+    dict
+        Ein Dictionary, das die xarray DataArrays für die Vor- und Nach-Brandbilder, die Maske und die Fold-Informationen enthält.
+    """
+    if pretty_band_names:
+        BANDS = ["coastal_aerosol", "blue", "green", "red",
+                 "veg_red_1", "veg_red_2", "veg_red_3", "nir",
+                 "veg_red_4", "water_vapour", "swir_1", "swir_2"]
+    else:
+        BANDS = ["1", "2", "3", "4", "5", "6", "7", "8", "8a", "9", "11", "12"]
+
+    post = dataset["post_fire"][...].astype("float32") / 10000.0
+
+    try:
+        pre = dataset["pre_fire"][...].astype("float32") / 10000.0
+    except KeyError:
+        pre = np.zeros_like(post, dtype="float32")
+
+    mask = dataset["mask"][..., 0]
+
+    return {"pre": xr.DataArray(pre, dims=["x", "y", "band"], coords={"x": range(512), "y": range(512), "band": BANDS}),
+            "post": xr.DataArray(post, dims=["x", "y", "band"], coords={"x": range(512), "y": range(512), "band": BANDS}),
+            "mask": xr.DataArray(mask, dims=["x", "y"], coords={"x": range(512), "y": range(512)}),
+            "fold": dataset.attrs["fold"]}
+
+class BandExtractor:
+    def __init__(self, index, name) -> None:
+        self.index = index
+        self.name = name
+
+    def __call__(self, data):
+        if isinstance(data, np.ndarray):
+            return data[..., self.index]
+        elif isinstance(data, xr.DataArray):
+            return data.sel(band=self.name).values
+        else:
+            msg = "Unknown data format."
+            raise Exception(msg)
+
+    def __repr__(self) -> str:
+        return f'BandExtractor({self.index}, "{self.name}")'
+
+
+band_1 = BandExtractor(0, "coastal_aerosol")
+band_2 = BandExtractor(1, "blue")
+band_3 = BandExtractor(2, "green")
+band_4 = BandExtractor(3, "red")
+band_5 = BandExtractor(4, "veg_red_1")
+band_6 = BandExtractor(5, "veg_red_2")
+band_7 = BandExtractor(6, "veg_red_3")
+band_8 = BandExtractor(7, "nir")
+band_8a = BandExtractor(8, "veg_red_4")
+band_9 = BandExtractor(9, "water_vapour")
+band_11 = BandExtractor(10, "swir_1")
+band_12 = BandExtractor(11, "swir_2")
+
+
+def NBR(data):
+    """Normalized Burn Ratio.
+
+    nbr = (nir - swir_2) / (nir + swir_2)
+    """
+    if isinstance(data, np.ndarray):
+        nir = data[..., 7]
+        swir_2 = data[..., 11]
+    elif isinstance(data, xr.DataArray):
+        nir = data.sel(band="nir").values
+        swir_2 = data.sel(band="swir_2").values
+    else:
+        msg = "Unknown data format."
+        raise Exception(msg)
+
+    zaehler = nir - swir_2
+    nenner = nir + swir_2
+    return np.divide(zaehler, nenner, out=np.zeros_like(zaehler), where=nenner != 0.0)
+
+
+def NDVI(data):
+    """Normalized Difference Vegetation Index."""
+    if isinstance(data, np.ndarray):
+        red = data[..., 3]
+        nir = data[..., 7]
+    elif isinstance(data, xr.DataArray):
+        red = data.sel(band="red").values
+        nir = data.sel(band="nir").values
+    else:
+        msg = "Unknown data format."
+        raise Exception(msg)
+
+    zaehler = nir - red
+    nenner = nir + red
+    return np.divide(zaehler, nenner, out=np.zeros_like(zaehler), where=nenner != 0.0)
+
+
+def GNDVI(data):
+    """Green Normalized Difference Vegetation Index."""
+    if isinstance(data, np.ndarray):
+        green = data[..., 2]
+        red = data[..., 3]
+        nir = data[..., 7]
+    elif isinstance(data, xr.DataArray):
+        green = data.sel(band="green").values
+        red = data.sel(band="red").values
+        nir = data.sel(band="nir").values
+    else:
+        msg = "Unknown data format."
+        raise Exception(msg)
+
+    zaehler = nir - green
+    nenner = nir + red
+    return np.divide(zaehler, nenner, out=np.zeros_like(zaehler), where=nenner != 0.0)
+
+
+def EVI(data):
+    """Enhanced Vegetation Index."""
+    if isinstance(data, np.ndarray):
+        blue = data[..., 1]
+        red = data[..., 3]
+        nir = data[..., 7]
+    elif isinstance(data, xr.DataArray):
+        blue = data.sel(band="blue").values
+        red = data.sel(band="red").values
+        nir = data.sel(band="nir").values
+    else:
+        msg = "Unknown data format."
+        raise Exception(msg)
+
+    zaehler = nir - red
+    nenner = nir + 6 * red - 7.5 * blue + 1
+
+    return np.divide(zaehler, nenner, out=np.zeros_like(zaehler), where=nenner != 0.0)
+
+
+def AVI(data):
+    """Advanced Vegetation Index."""
+    if isinstance(data, np.ndarray):
+        red = data[..., 3]
+        nir = data[..., 7]
+    elif isinstance(data, xr.DataArray):
+        red = data.sel(band="red").values
+        nir = data.sel(band="nir").values
+    else:
+        msg = "Unknown data format."
+        raise Exception(msg)
+
+    base = nir * (1 - red) * (nir - red)
+    ## FIXME: Deal with cube roots of negative values?
+    return np.power(base, 1./3., out=np.zeros_like(base), where=base>0)
+
+
+def SAVI(data):
+    """Soil Adjusted Vegetation Index."""
+    if isinstance(data, np.ndarray):
+        red = data[..., 3]
+        nir = data[..., 7]
+    elif isinstance(data, xr.DataArray):
+        red = data.sel(band="red").values
+        nir = data.sel(band="nir").values
+    else:
+        msg = "Unknown data format."
+        raise Exception(msg)
+
+    return (nir - red) / (nir + red + 0.428) * 1.428
+
+
+def NDMI(data):
+    if isinstance(data, np.ndarray):
+        nir = data[..., 7]
+        swir_1 = data[..., 10]
+    elif isinstance(data, xr.DataArray):
+        nir = data.sel(band="nir").values
+        swir_1 = data.sel(band="swir_1").values
+    else:
+        msg = "Unknown data format."
+        raise Exception(msg)
+
+    zaehler = nir - swir_1
+    nenner = nir + swir_1
+    return np.divide(zaehler, nenner, out=np.zeros_like(zaehler), where=nenner != 0.0)
+
+
+def MSI(data):
+    """Moisture Stress Index.
+
+    Moisture Stress Index is used for canopy stress analysis, productivity
+    prediction and biophysical modeling. Interpretation of the MSI is inverted
+    relative to other water vegetation indices; thus, higher values of the
+    index indicate greater plant water stress and in inference, less soil
+    moisture content. The values of this index range from 0 to more than 3 with
+    the common range for green vegetation being 0.2 to 2.
+    """
+    if isinstance(data, np.ndarray):
+        nir = data[..., 7]
+        swir_1 = data[..., 10]
+    elif isinstance(data, xr.DataArray):
+        nir = data.sel(band="nir").values
+        swir_1 = data.sel(band="swir_1").values
+    else:
+        msg = "Unknown data format."
+        raise Exception(msg)
+
+    return swir_1 - nir
+
+
+def GCI(data):
+    """Green Chlorophyll Index."""
+    if isinstance(data, np.ndarray):
+        green = data[..., 2]
+        water_vapour = data[..., 9]
+    elif isinstance(data, xr.DataArray):
+        green = data.sel(band="green").values
+        water_vapour = data.sel(band="water_vapour").values
+    else:
+        msg = "Unknown data format."
+        raise Exception(msg)
+
+    return water_vapour - green
+
+
+def BSI(data):
+    """Bare Soil Index."""
+    if isinstance(data, np.ndarray):
+        blue = data[..., 1]
+        red = data[..., 3]
+        nir = data[..., 7]
+        swir_1 = data[..., 10]
+    elif isinstance(data, xr.DataArray):
+        blue = data.sel(band="blue").values
+        red = data.sel(band="red").values
+        nir = data.sel(band="nir").values
+        swir_1 = data.sel(band="swir_1").values
+    else:
+        msg = "Unknown data format."
+        raise Exception(msg)
+
+    swir_red = swir_1 + red
+    nir_blue = nir + blue
+    zaehler = swir_red - nir_blue
+    nenner = swir_red + nir_blue
+    return np.divide(zaehler, nenner, out=np.zeros_like(zaehler), where=nenner != 0.0)
+
+
+def NDWI(data):
+    """Normalized Difference Water Index."""
+    if isinstance(data, np.ndarray):
+        green = data[..., 2]
+        nir = data[..., 7]
+    elif isinstance(data, xr.DataArray):
+        green = data.sel(band="green").values
+        nir = data.sel(band="nir").values
+    else:
+        msg = "Unknown data format."
+        raise Exception(msg)
+
+    zaehler = green - nir
+    nenner = green + nir
+    return np.divide(zaehler, nenner, out=np.zeros_like(zaehler), where=nenner != 0.0)
+
+
+def NDSI(data):
+    """Normalized Difference Snow Index."""
+    if isinstance(data, np.ndarray):
+        green = data[..., 2]
+        swir_1 = data[..., 10]
+    elif isinstance(data, xr.DataArray):
+        green = data.sel(band="green").values
+        swir_1 = data.sel(band="swir_1").values
+    else:
+        msg = "Unknown data format."
+        raise Exception(msg)
+
+    zaehler = green - swir_1
+    nenner = green + swir_1
+    return np.divide(zaehler, nenner, out=np.zeros_like(zaehler), where=nenner != 0.0)
+
+
+def NDGI(data):
+    if isinstance(data, np.ndarray):
+        green = data[..., 2]
+        red = data[..., 3]
+    elif isinstance(data, xr.DataArray):
+        green = data.sel(band="green").values
+        red = data.sel(band="red").values
+    else:
+        msg = "Unknown data format."
+        raise Exception(msg)
+
+    zaehler = green - red
+    nenner = green + red
+    return np.divide(zaehler, nenner, out=np.zeros_like(zaehler), where=nenner != 0.0)
+
+#Die Bänder kommen in Channels
+class FiresDataset(torch.utils.data.Dataset):
+    def __init__(self, filename, folds=(0, 1, 2, 3, 4),
+                 channels=[],
+                 include_pre=False,
+                 transform=None) -> None:
+        self._filename = filename
+        self._fd = h5py.File(filename, "r")
+        self._channels = channels
+        self._transform = transform
+        self._names = []
+
+        whitelist = wl()
+        for name in self._fd:
+            if self._fd[name].attrs["fold"] not in folds:
+                continue
+            if name in whitelist:
+                self._names.append((name, "post_fire"))
+            if include_pre and "pre_fire" in self._fd[name]:
+                pre_image = self._fd[name]["pre_fire"][...]
+                # Include only "real" pre_fire images
+                if np.mean(pre_image > 0) > 0.8:
+                    self._names.append((name, "pre_fire"))
+
+    def number_of_channels(self):
+        return len(self._channels)
+
+    def __getitem__(self, idx):
+        name, state = self._names[idx]
+        data = self._fd[name][state][...].astype("float32") / 10000.0
+        if state == "pre_fire":
+            mask = np.zeros((512, 512), dtype="float32")
+        else:
+            mask = self._fd[name]["mask"][..., 0].astype("float32")
+
+        channels = []
+        for channel in self._channels:
+            channels.append(channel(data))
+
+        # Stack indices into a new image in CHW format.
+        image =  np.stack(channels)
+
+        if self._transform:
+            # Transpose image so we get HWC instead of CHW format.
+            # Transform is responsible for transposing back as required by PyTorch.
+            image = image.transpose((1, 2, 0))
+            xfrm = self._transform(image=image, mask=mask)
+            image, mask = xfrm["image"], xfrm["mask"]
+        logger.debug("Final tensor shape: %s", image.shape)
+
+        return {"image": image, "mask": mask[None, :]}
+
+    def __len__(self) -> int:
+        return len(self._names)
+
+
+class FireModel(pl.LightningModule):
+    def __init__(self,
+                 datafile,
+                 model,
+                 encoder,
+                 encoder_depth,
+                 encoder_weights,
+                 loss,
+                 channels,
+                 train_transform,
+                 train_use_pre_fire,
+                 n_cpus,
+                 batch_size,
+                 lr=0.00025,
+                 **kwargs) -> None:
+        super().__init__()
+        self.save_hyperparameters()
+        self.datafile = datafile
+        self.lr = lr
+        self.channels = channels
+        if model == "unet":
+            decoder_channels = [2**(8 - d) for d in range(encoder_depth, 0, -1)]
+            self.model = smp.Unet(encoder_name=encoder, encoder_depth=encoder_depth, encoder_weights=encoder_weights,
+                                  decoder_channels=decoder_channels,
+                                  in_channels=len(channels), classes=1)
+        elif model == "unetpp":
+            decoder_channels = [2**(8 - d) for d in range(encoder_depth, 0, -1)]
+            self.model = smp.UnetPlusPlus(encoder_name=encoder, encoder_depth=encoder_depth, encoder_weights=encoder_weights,
+                                          decoder_channels=decoder_channels,
+                                          in_channels=len(channels), classes=1)
+        elif model == "fpn":
+            if encoder_depth == 3:
+                upsampling = 1
+            elif encoder_depth == 4:
+                upsampling = 2
+            elif encoder_depth == 5:
+                upsampling = 4
+            else:
+                raise "FPN: Unsupported encoder depth {encoder_depth}."
+            self.model = smp.FPN(encoder_name=encoder, encoder_weights=encoder_weights, encoder_depth=encoder_depth,
+                                 upsampling=upsampling,
+                                 in_channels=len(channels), classes=1)
+        elif model == "dlv3":
+            self.model = smp.DeepLabV3(encoder_name=encoder, encoder_weights=encoder_weights, encoder_depth=encoder_depth,
+                                       in_channels=len(channels), classes=1)
+        elif model == "dlv3p":
+            if encoder_depth != 5:
+                raise f"Unsupported encoder depth {encoder_depth} for DeepLabV3+ (must be 5)."
+            self.model = smp.DeepLabV3Plus(encoder_name=encoder, encoder_weights=encoder_weights, encoder_depth=encoder_depth,
+                                           in_channels=len(channels), classes=1)
+        else:
+            raise f"Unsupported model '{model}'."
+
+        if loss == "dice":
+            self.loss_fn = smp.losses.DiceLoss(smp.losses.BINARY_MODE, from_logits=True)
+        elif loss == "bce":
+            self.loss_fn = smp.losses.SoftBCEWithLogitsLoss()
+        else:
+            raise f"Unsupported loss function '{loss}'."
+
+        self.train_transform = train_transform
+        self.train_use_pre_fire = train_use_pre_fire
+        self.n_cpus = n_cpus
+        self.batch_size = batch_size
+
+    def forward(self, image):
+        mask = self.model(image)
+        return mask
+
+    def shared_step(self, batch, stage):
+        image, mask = batch["image"], batch["mask"]
+
+        logits_mask = self.forward(image)
+        loss = self.loss_fn(logits_mask, mask)
+
+        prob_mask = logits_mask.sigmoid()
+        pred_mask = (prob_mask > 0.5).long()
+        tp, fp, fn, tn = smp.metrics.get_stats(pred_mask, mask.long(), mode="binary")
+        iou = smp.metrics.iou_score(tp, fp, fn, tn, reduction="micro-imagewise")
+
+        self.log(f"{stage}_loss", loss, on_step=False, on_epoch=True, prog_bar=True, logger=True)
+        self.log(f"{stage}_iou", iou, on_step=False, on_epoch=True, prog_bar=True, logger=True)
+        return loss
+
+    def training_step(self, batch, batch_idx):
+        return self.shared_step(batch, "train")
+
+    def train_dataloader(self):
+        train_ds = FiresDataset(self.datafile, folds=[1, 2, 3, 4],
+                                channels=self.channels,
+                                transform=self.train_transform,
+                                include_pre=self.train_use_pre_fire)
+        train_dl = torch.utils.data.DataLoader(train_ds,
+                                               batch_size=self.batch_size,
+                                               num_workers=self.n_cpus,
+                                               shuffle=True,
+                                               pin_memory=True,
+                                               drop_last=False)
+        return train_dl
+
+    def validation_step(self, batch, batch_idx):
+        return self.shared_step(batch, "valid")
+
+    def val_dataloader(self):
+        val_ds = FiresDataset(self.datafile, folds=[0],
+                              channels=self.channels,
+                              transform=None,
+                              include_pre=False)
+        val_dl = torch.utils.data.DataLoader(val_ds,
+                                             batch_size=self.batch_size,
+                                             num_workers=self.n_cpus,
+                                             shuffle=False,
+                                             pin_memory=True,
+                                             drop_last=False)
+        return val_dl
+
+    def test_step(self, batch, batch_idx):
+        return self.shared_step(batch, "test")
+
+    def configure_optimizers(self):
+        # TODO: Can we do better? We should probably implement a learning rate schedule?
+        return torch.optim.Adam(self.parameters(), lr=self.lr)
+
+
+def main(accelerator,
+         datafile,
+         batch_size,
+         channels,
+         n_cpus,
+         model,
+         encoder,
+         encoder_depth,
+         encoder_weights,
+         loss,
+         train_use_pre_fire,
+         train_use_augmentation,
+         learning_rate,
+         ):
+
+
+    if train_use_augmentation:
+        train_xfrm = A.Compose([
+            A.VerticalFlip(p=0.5),
+            A.HorizontalFlip(p=0.5),
+            A.Transpose(p=0.5),
+            A.RandomRotate90(p=0.5),
+            Atorch.ToTensorV2(),
+            ])
+    else:
+        train_xfrm = None
+
+    logger.info("Instantiating model.")
+    mdl = FireModel(datafile=datafile,
+                    model=model,
+                    encoder=encoder,
+                    encoder_depth=encoder_depth,
+                    encoder_weights=encoder_weights,
+                    loss=loss,
+                    channels=channels,
+                    n_cpus=n_cpus,
+                    train_transform=train_xfrm,
+                    train_use_pre_fire=train_use_pre_fire,
+                    batch_size=batch_size,
+                    lr=learning_rate)
+
+    trainer = pl.Trainer(accelerator=accelerator, devices="auto",
+                         log_every_n_steps=10, max_epochs=30, callbacks=[checkpoint_callback])
+#callbacks=[checkpoint_callback]
+    logger.info("Start training.")
+    trainer.fit(mdl)
+
+
+CHANNEL_MAP = {
+        "band_1": band_1,
+        "band_2": band_2,
+        "band_3": band_3,
+        "band_4": band_4,
+        "band_5": band_5,
+        "band_6": band_6,
+        "band_7": band_7,
+        "band_8": band_8,
+        "band_8a": band_8a,
+        "band_9": band_9,
+        "band_11": band_11,
+        "band_12": band_12,
+        "nbr": NBR,
+        "ndvi": NDVI,
+        "gndvi": GNDVI,
+        "evi": EVI,
+        "avi": AVI,
+        "savi": SAVI,
+        "ndmi": NDMI,
+        "msi": MSI,
+        "gci": GCI,
+        "bsi": BSI,
+        "ndwi": NDWI,
+        "ndsi": NDSI,
+        "ndgi": NDGI,
+        }
+
+if __name__ == "__main__":
+
+    import argparse  # Only import when needed
+
+    N_CPUS = int(os.getenv("SLURM_CPUS_PER_TASK", 1))
+    parser = argparse.ArgumentParser("chabud.py")
+    parser.add_argument("--accelerator", type=str, choices=["cpu", "gpu", "auto"], default="auto")
+    parser.add_argument("--datafile", type=Path, default=ds_path,
+                        help="Location of data file used for training.")
+    parser.add_argument("--n-cpus", type=int, default=N_CPUS, help="Number of CPU cores to use.")
+    parser.add_argument("--batch-size", type=int, default=2,
+                        help="Training and validation batch size.")
+    parser.add_argument("--learning-rate", type=float, default=0.00025,
+                        help="Learning rate of optimizer.")
+    parser.add_argument("--model", choices=["unet", "unetpp", "fpn", "dlv3", "dlv3p"], default="unet",
+                        help="Segmentation model")
+    parser.add_argument("--encoder", choices=["resnet18", "resnet34", "resnet50", "vgg13", "dpn68", "dpn92", "timm-efficientnet-b0"], default="resnet34",
+                        help="Encoder of segmentation model")
+    parser.add_argument("--encoder-depth", type=int, default=5,
+                        help="Depth of encoder stage")
+    parser.add_argument("--encoder-weights", choices=["random", "imagenet"], default="imagenet",
+                        help="Weight initialization for encoder")
+    parser.add_argument("--loss", choices=["dice", "bce"], default="dice",
+                        help="Loss function")
+    parser.add_argument("--train-use-pre_fire", action="store_true",
+                        help="Use pre_fire data for training?")
+    parser.add_argument("--train-use-augmentation", action="store_true",
+                        help="Use data augmentation in training step?")
+    parser.add_argument("--channels", nargs="+", choices=CHANNEL_MAP.keys(),
+                        default=["band_1", "band_2", "band_3", "band_4", "band_5", "band_6", "band_7", "band_8", "band_8a", "band_9", "band_11", "band_12"],
+                        help="Channels to use for prediction")
+    parser.add_argument("--log-level", type=str, choices=["info", "debug"], default="info")
+
+    args = parser.parse_args()
+
+    LOGGING_MAP = {"info": logging.INFO, "debug": logging.DEBUG}
+    logging.basicConfig(level=LOGGING_MAP[args.log_level],
+                        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+                        datefmt="%d-%b-%y %H:%M:%S")
+
+
+    if args.encoder_weights == "random":
+        args.encoder_weights = None
+
+    # Translate channel names to function that calculates the channel / index.
+    logger.info(f"Selected channels: {args.channels}")
+    channels = []
+    for channel in args.channels:
+        channels.append(CHANNEL_MAP[channel])
+
+
+    torch.set_num_threads(args.n_cpus)
+    torch.set_float32_matmul_precision("medium")
+
+    main(accelerator=args.accelerator,
+         datafile=args.datafile,
+         batch_size=args.batch_size,
+         learning_rate=args.learning_rate,
+         channels=channels,
+         n_cpus=args.n_cpus,
+         model=args.model,
+         encoder=args.encoder,
+         encoder_depth=args.encoder_depth,
+         encoder_weights=args.encoder_weights,
+         loss=args.loss,
+         train_use_pre_fire=args.train_use_pre_fire,
+         train_use_augmentation=args.train_use_augmentation)
+

distribution_mask_size.ipynb

@@ -0,0 +1,337 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "8b77c765-edb9-437f-bab9-9bb1217ab8a8",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-07-12T19:18:23.207656Z",
+     "iopub.status.busy": "2023-07-12T19:18:23.207403Z",
+     "iopub.status.idle": "2023-07-12T19:18:25.557392Z",
+     "shell.execute_reply": "2023-07-12T19:18:25.556690Z",
+     "shell.execute_reply.started": "2023-07-12T19:18:23.207621Z"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import h5py\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import xarray as xr\n",
+    "import skimage as ski\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib.colors import ListedColormap\n",
+    "from tqdm.auto import tqdm\n",
+    "from pathlib import Path\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "BASEDIR = Path(\"/global/public/chabud-ecml-pkdd2023/\")\n",
+    "fn = BASEDIR / \"train_eval.hdf5\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "1fafd16b-c043-4c47-9e30-2c75b72eaccf",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-07-12T19:18:25.562789Z",
+     "iopub.status.busy": "2023-07-12T19:18:25.561013Z",
+     "iopub.status.idle": "2023-07-12T19:18:25.571051Z",
+     "shell.execute_reply": "2023-07-12T19:18:25.569973Z",
+     "shell.execute_reply.started": "2023-07-12T19:18:25.562762Z"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "def to_xarray(dataset, pretty_band_names=True):\n",
+    "    \"\"\"Convert a single example into an xarray for easy access\"\"\"\n",
+    "    \n",
+    "    if pretty_band_names:\n",
+    "        BANDS = [\"coastal_aerosol\", \"blue\", \"green\", \"red\",\n",
+    "                 \"veg_red_1\", \"veg_red_2\", \"veg_red_3\", \"nir\", \n",
+    "                 \"veg_red_4\", \"water_vapour\", \"swir_1\", \"swir_2\"]\n",
+    "    else:\n",
+    "        BANDS = [\"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"8a\", \"9\", \"11\", \"12\"]\n",
+    "        \n",
+    "    post = dataset[\"post_fire\"][...].astype(\"float32\") / 10000.0\n",
+    "    \n",
+    "    # Da `pre_fire` manchmal fehlt ersetzen wir es durch 0 Werte was\n",
+    "    # eh der Platzhalter für einen fehlenden Messwert ist.\n",
+    "    try:\n",
+    "        pre = dataset[\"pre_fire\"][...].astype(\"float32\") / 10000.0\n",
+    "    except KeyError:\n",
+    "        pre = np.zeros_like(post, dtype=\"float32\")\n",
+    "        \n",
+    "    # Da die Maske nur ein \"Band\" hat können wir die dritte Dimension einfach\n",
+    "    # weglassen. Das erreichen wir in dem wir mit `0` am Ende indizieren.\n",
+    "    mask = dataset[\"mask\"][..., 0].astype(\"bool\")\n",
+    "    \n",
+    "    return {\"pre\": xr.DataArray(pre, dims=[\"x\", \"y\", \"band\"], coords={\"x\": range(512), \"y\": range(512), \"band\": BANDS}),\n",
+    "            \"post\": xr.DataArray(post, dims=[\"x\", \"y\", \"band\"], coords={\"x\": range(512), \"y\": range(512), \"band\": BANDS}),\n",
+    "            \"mask\": xr.DataArray(mask, dims=[\"x\", \"y\"], coords={\"x\": range(512), \"y\": range(512)}),\n",
+    "            \"fold\": dataset.attrs[\"fold\"]}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "385378a8-6c11-483c-a936-825af060f0c2",
+   "metadata": {},
+   "source": [
+    "The following code was used and edited in order to analize the effect on the median and standart deviation if data with a too small masks are removed. This was done so that the Neuronal Network gets trained to predict larger masks."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "3a4eb708-4a8d-484a-a3d5-79318fa2e1ce",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-07-12T19:18:25.575871Z",
+     "iopub.status.busy": "2023-07-12T19:18:25.574255Z",
+     "iopub.status.idle": "2023-07-12T19:18:36.454225Z",
+     "shell.execute_reply": "2023-07-12T19:18:36.453237Z",
+     "shell.execute_reply.started": "2023-07-12T19:18:25.575846Z"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "res = []\n",
+    "\n",
+    "with h5py.File(fn, \"r\") as fd:\n",
+    "    for name in fd:\n",
+    "        ds = to_xarray(fd[name])\n",
+    "        mask = ds[\"mask\"].values\n",
+    "        burned = np.sum(mask) / (512*512)\n",
+    "        #if(burned==1):\n",
+    "            #print(name)\n",
+    "        if(burned<=0.02):\n",
+    "            continue;\n",
+    "        res.append({\"burned\": burned})    \n",
+    "        #break;"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "450fe581-0d56-47e0-85d6-d82d3e22afde",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-07-12T19:18:36.460360Z",
+     "iopub.status.busy": "2023-07-12T19:18:36.458625Z",
+     "iopub.status.idle": "2023-07-12T19:18:36.467408Z",
+     "shell.execute_reply": "2023-07-12T19:18:36.466800Z",
+     "shell.execute_reply.started": "2023-07-12T19:18:36.460317Z"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "df = pd.DataFrame(res)\n",
+    "del res"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "87df05e4-3401-428a-88ea-98a9510933c8",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-07-12T19:18:36.471822Z",
+     "iopub.status.busy": "2023-07-12T19:18:36.470260Z",
+     "iopub.status.idle": "2023-07-12T19:18:36.788703Z",
+     "shell.execute_reply": "2023-07-12T19:18:36.787968Z",
+     "shell.execute_reply.started": "2023-07-12T19:18:36.471799Z"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.23417302673938228\n",
+      "0.26324914249621933\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.lines.Line2D at 0x150591a3e230>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "mean = np.mean(df[\"burned\"])\n",
+    "std = np.std(df[\"burned\"])\n",
+    "print(mean)\n",
+    "print(std)\n",
+    "#print(mean-std)\n",
+    "fig_1 = sns.displot(df, x=\"burned\", kind =\"ecdf\", height=5, aspect=3)\n",
+    "fig_1.ax.axvline(mean, color = \"red\")\n",
+    "#fig_1.ax.axvline(mean-std, color = \"blue\")\n",
+    "#fig_1.ax.axvline(std+mean, color = \"blue\")\n",
+    "#fig_1.savefig('size_mask_no_2.eps' , format = 'eps')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "826fa232-df66-44ec-bbe0-6d43459512f4",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-07-12T19:18:36.792861Z",
+     "iopub.status.busy": "2023-07-12T19:18:36.791384Z",
+     "iopub.status.idle": "2023-07-12T19:18:36.796827Z",
+     "shell.execute_reply": "2023-07-12T19:18:36.795906Z",
+     "shell.execute_reply.started": "2023-07-12T19:18:36.792836Z"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# wir sehen, dass die meisten Masken zwiscehn 0 und 20% des Bildes abdecken"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "1574fdb1-6442-4803-b8d0-b8355e1c2377",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-07-12T19:18:36.801555Z",
+     "iopub.status.busy": "2023-07-12T19:18:36.799900Z",
+     "iopub.status.idle": "2023-07-12T19:18:36.805446Z",
+     "shell.execute_reply": "2023-07-12T19:18:36.804561Z",
+     "shell.execute_reply.started": "2023-07-12T19:18:36.801531Z"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# ein treshhold von 2% für die Masken sorgt schon dafür, dass der Datensatz ausgeglichener wirkt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "e79099d4-e737-4909-9b18-1e900e6d73e0",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-07-12T19:24:35.628647Z",
+     "iopub.status.busy": "2023-07-12T19:24:35.628293Z",
+     "iopub.status.idle": "2023-07-12T19:24:35.854670Z",
+     "shell.execute_reply": "2023-07-12T19:24:35.853911Z",
+     "shell.execute_reply.started": "2023-07-12T19:24:35.628618Z"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "res_has_pre = []\n",
+    "res_no_pre = []\n",
+    "with h5py.File(fn, \"r\") as fd:\n",
+    "    for name, ds in fd.items():\n",
+    "        if \"pre_fire\" in ds:\n",
+    "            res_has_pre.append(name)\n",
+    "        else:\n",
+    "            res_no_pre.append(name)\n",
+    "        \n",
+    "x = [\"has_pre_fire\", \"missing_pre_fire\"]  # X-axis values\n",
+    "y = [len(res_has_pre), len(res_no_pre)]  # Y-axis values\n",
+    "\n",
+    "plt.bar(x, y)\n",
+    "#plt.show()\n",
+    "\n",
+    "plt.savefig('missing_prefire.eps')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "664466a8-906e-46c2-b269-336450464187",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5f48ae8f-32e9-457f-bf9a-e6aeddf2e86f",
+   "metadata": {
+    "execution": {
+     "iopub.status.busy": "2023-07-12T19:18:37.515168Z",
+     "iopub.status.idle": "2023-07-12T19:18:37.516757Z",
+     "shell.execute_reply": "2023-07-12T19:18:37.516583Z",
+     "shell.execute_reply.started": "2023-07-12T19:18:37.516563Z"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5cc93207-9157-459f-aab1-c712e6714b10",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.10 / DM",
+   "language": "python",
+   "name": "py310-dm"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

main.py

@@ -0,0 +1,36 @@
+import torch.cuda
+
+import chabud as ch
+
+ds_path = "A:/CodingProjekte/DataMining/src/train_eval.hdf5"
+
+# Press the green button in the gutter to run the script.
+if __name__ == '__main__':
+    print(ch.__version__)
+    print(torch.cuda.is_available())
+    # See PyCharm help at https://www.jetbrains.com/help/pycharm/
+    channels = ["band_1", "band_2", "band_3", "band_4", "band_5", "band_6", "band_7", "band_8", "band_8a", "band_9",
+                "band_11", "band_12", "nbr", "ndvi", "gndvi", "evi", "avi", "savi", "ndmi", "msi", "gci", "bsi", "ndwi",
+                "ndgi"]
+    # channels = ["band_1", "band_2", "band_3", "band_4", "band_5", "band_6", "band_7", "band_8", "band_8a", "band_9",
+    #             "band_11", "band_12", "nbr", "ndmi", "ndvi", "bsi", "ndwi"]
+    channels_fun = []
+
+    for channel in channels:
+        channels_fun.append(ch.CHANNEL_MAP[channel])
+
+    ch.main(accelerator="gpu",
+            datafile=ds_path,
+            batch_size=5,
+            learning_rate=0.00025,
+            channels=channels_fun,
+            n_cpus=0,
+            model="unet",
+            encoder="resnet34",
+            encoder_depth=5,
+            encoder_weights="imagenet",
+            loss="dice",
+            train_use_pre_fire=False,
+            train_use_augmentation=True)
+
+

submission.py

@@ -0,0 +1,149 @@
+import numpy as np
+import pandas as pd
+import h5py
+import torch
+from trimesh.voxel.runlength import dense_to_brle
+from pathlib import Path
+from matplotlib.colors import ListedColormap
+from collections import defaultdict
+from scipy import ndimage as ski
+from typing import Any, Union, Dict, Literal
+from numpy.typing import NDArray
+import matplotlib as plt
+
+import chabud
+from pathlib import Path
+dataset = Path("A:/CodingProjekte/DataMining/src/train_eval.hdf5")
+#Es liegen 15 vortrainierte Modelle auf dem Server im Verzeichnis
+#/global/public/chabud-ecml-pkdd2023/checkpoints/.
+#Sie können sich verfügbaren Checkpoints wie folgt anzeigen lassen:
+ckpt = Path('A:/CodingProjekte/DataMining/src/lightning_logs/version_30/checkpoints/model-epoch=25-val_iou=0.00.ckpt')
+
+#Sie können einen beliebigen Checkpoint wie folgt laden:
+mdl = chabud.FireModel.load_from_checkpoint(ckpt, map_location="cpu")
+
+# Vom Modell `mdl` benötigte Kanäle extrahieren
+# channels = np.stack([c(bands) for c in mdl.channels])
+
+
+# with torch.set_grad_enabled(False):
+#   # Modell auf 1xlen(channels)x512x512 großen Tensor anwenden
+#   # D.h. wir haben eine Batchgröße von 1 (ineffizient aber einfach).
+#   print(channels)
+#   # channels = channels.astype(float)
+#   pred = mdl.forward(torch.Tensor(channels[np.newaxis, ...])).sigmoid() > 0.5
+#   # Ersten beiden Dimensionen (batch und channel) löschen und in ein numpy Array wandeln
+#   pred = pred[0, 0, ...].detach().numpy()
+
+
+def process_dataset(scene, bands, true):
+    rgb = ski.exposure.adjust_gamma(np.clip(bands[..., [3, 2, 1]], 0, 1), 0.4)
+
+    channels = np.stack([c(bands) for c in mdl.channels])
+    with torch.set_grad_enabled(False):
+        pred = mdl.forward(torch.Tensor(channels[np.newaxis, ...])).sigmoid() > 0.5
+        pred = pred[0, 0, ...].detach().numpy()
+
+    cmap = ListedColormap(["white", "tab:brown", "tab:orange", "tab:blue"])
+    mask = np.zeros_like(pred, dtype=int)
+    mask = np.where(true & pred, 1, mask)
+    mask = np.where(~true & pred, 2, mask)
+    mask = np.where(true & ~pred, 3, mask)
+
+    true_edge = ski.feature.canny(true.astype("float")).astype("uint8")
+    pred_edge = ski.feature.canny(pred.astype("float")).astype("uint8")
+
+    fig, (axm, axi) = plt.subplots(ncols=2, figsize=(20, 10))
+    axm.imshow(mask, cmap=cmap, interpolation="nearest")
+
+    axi.imshow(rgb, interpolation="nearest")
+    axi.imshow(true_edge, cmap=ListedColormap(["#00000000", "tab:blue"]), interpolation="nearest")
+    axi.imshow(pred_edge, cmap=ListedColormap(["#00000000", "tab:orange"]), interpolation="nearest")
+
+    for ax in [axm, axi]:
+        ax.axes.xaxis.set_ticklabels([])
+        ax.axes.yaxis.set_ticklabels([])
+
+    fig.tight_layout()
+
+    fig.savefig(f"masks/{scene}-f_{dataset.attrs['fold']}.png")
+    plt.close()
+# class RandomModel:
+#     def __init__(self, shape):
+#         self.shape = shape
+#         return
+
+#     def __call__(self, input):
+#         # input is ignored, just generate some random predictions
+#         return np.random.randint(0, 2, size=self.shape, dtype=bool)
+
+class FixedModel:
+    def __init__(self, shape) -> None:
+        self.shape = shape
+        return
+
+    def __call__(self, input) -> Any:
+        # input is ignored, just generate a mask filled with zeros, with fixed pixels set to 1
+        mask = np.zeros(self.shape, dtype=bool)
+        mask[100:250, 100:250] = True
+        return mask
+
+
+def retrieve_validation_fold(path: Union[str, Path]) -> Dict[str, NDArray]:
+    result = defaultdict(dict)
+    with h5py.File(path, 'r') as fp:
+        for uuid, values in fp.items():
+            if values.attrs['fold'] != 0:
+                continue
+
+            result[uuid]['post'] = values['post_fire'][...]
+            # result[uuid]['pre'] = values['pre_fire'][...]
+
+    return dict(result)
+
+
+def compute_submission_mask(id: str, mask: NDArray):
+    brle = dense_to_brle(mask.astype(bool).flatten())
+    return {"id": id, "rle_mask": brle, "index": np.arange(len(brle))}
+
+
+#der Code aus dem letzten Workshop
+class PPModel:
+    def __init__(self,model):
+        self._model = model
+        self._model.eval()
+
+    def __call__(self,bands) -> Any:
+        #preprocessing
+        bands = bands /10000
+        channels = np.stack([c(bands) for c in self._model.channels])
+        channels = torch.Tensor(channels[np.newaxis, ...])
+        #Modell auswerten
+        with torch.set_grad_enabled(False):
+            mask = self._model.forward(channels).sigmoid() > 0.5
+        #postprocessing
+        mask = mask[0,0, ...].detach().numpy()
+        return mask
+
+
+
+if __name__ == '__main__':
+    validation_fold = retrieve_validation_fold('train_eval.hdf5')
+
+    # use a list to accumulate results
+    result = []
+    # instantiate the model
+    # model = FixedModel(shape=(512, 512))
+    model = PPModel(mdl)
+    for uuid in validation_fold:
+        input_images = validation_fold[uuid]['post']
+
+        # perform the prediction
+        predicted = model(input_images)
+        # convert the prediction in RLE format
+        encoded_prediction = compute_submission_mask(uuid, predicted)
+        result.append(pd.DataFrame(encoded_prediction))
+
+    # concatenate all dataframes
+    submission_df = pd.concat(result)
+    submission_df.to_csv('predictions.csv', index=False)