readd cod modifications

configs/datamodule/focus150.yaml

@@ -1,8 +1,10 @@
 _target_: src.datamodules.focus_datamodule.FocusDataModule
 
 data_dir: ${data_dir}/focus150 # data_dir is specified in config.yaml
-csv_file: ${data_dir}/focus150/metadata.csv
+csv_train_file: ${data_dir}/focus150/train_metadata.csv
+csv_val_file: ${data_dir}/focus150/validation_metadata.csv
+csv_test_file: ${data_dir}/focus150/test_metadata.csv
+
 batch_size: 64
-train_val_test_split_percentage: [0.7, 0.15, 0.15]
 num_workers: 0
 pin_memory: False

configs/experiment/focusConvMSE_besthyp_150.yaml

@@ -0,0 +1,40 @@
+# @package _global_
+
+# to execute this experiment run:
+# python train.py experiment=example
+
+defaults:
+  - override /datamodule: focus150.yaml
+  - override /model: focusConv_150.yaml
+  - override /callbacks: default.yaml
+  - override /logger: many_loggers
+  - override /trainer: default.yaml
+
+# all parameters below will be merged with parameters from default configurations set above
+# this allows you to overwrite only specified parameters
+
+# name of the run determines folder name in logs
+name: "focusConvMSE_150"
+seed: 12345
+
+trainer:
+  min_epochs: 1
+  max_epochs: 100
+
+model:
+  image_size: 150
+  pool_size: 2
+  conv1_size: 3
+  conv1_channels: 9
+  conv2_size: 7
+  conv2_channels: 6
+  lin1_size: 32
+  lin2_size: 72
+  output_size: 1
+  lr: 0.001
+  weight_decay: 0.0005
+
+datamodule:
+  batch_size: 64
+  augmentation: True
+  

configs/experiment/focusResNet101_pretrained_150.yaml

@@ -0,0 +1,33 @@
+# @package _global_
+
+# to execute this experiment run:
+# python train.py experiment=example
+
+defaults:
+  - override /datamodule: focus150.yaml
+  - override /model: focusResNet_150.yaml
+  - override /callbacks: default.yaml
+  - override /logger: many_loggers
+  - override /trainer: default.yaml
+
+# all parameters below will be merged with parameters from default configurations set above
+# this allows you to overwrite only specified parameters
+
+# name of the run determines folder name in logs
+name: "focusResNet101pretrained_150"
+seed: 12345
+
+trainer:
+  min_epochs: 1
+  max_epochs: 100
+
+model:
+  resnet_type: "resnet101"
+  pretrained: True
+  lr: 0.0011538
+  weight_decay: 0.0005
+
+datamodule:
+  batch_size: 64
+  augmentation: True
+  

configs/experiment/focusResNet_150.yaml

@@ -0,0 +1,33 @@
+# @package _global_
+
+# to execute this experiment run:
+# python train.py experiment=example
+
+defaults:
+  - override /datamodule: focus150.yaml
+  - override /model: focusResNet_150.yaml
+  - override /callbacks: default.yaml
+  - override /logger: many_loggers
+  - override /trainer: default.yaml
+
+# all parameters below will be merged with parameters from default configurations set above
+# this allows you to overwrite only specified parameters
+
+# name of the run determines folder name in logs
+name: "focusResNet_150"
+seed: 12345
+
+trainer:
+  min_epochs: 1
+  max_epochs: 100
+
+model:
+  resnet_type: "resnet50"
+  pretrained: false
+  lr: 0.001
+  weight_decay: 0.0005
+
+datamodule:
+  batch_size: 128
+  augmentation: True
+  

configs/hparams_search/focusResNetMSE_150.yaml

@@ -0,0 +1,70 @@
+# @package _global_
+
+# example hyperparameter optimization of some experiment with Optuna:
+# python train.py -m hparams_search=mnist_optuna experiment=example
+
+defaults:
+  - override /datamodule: focus150.yaml
+  - override /model: focusResNet_150.yaml
+  - override /hydra/sweeper: optuna
+
+# choose metric which will be optimized by Optuna
+# make sure this is the correct name of some metric logged in lightning module!
+optimized_metric: "val/mae_best"
+
+datamodule:
+  batch_size: 64
+  augmentation: True
+
+name: "focusResNet_150_hyperparameter_search"
+
+# here we define Optuna hyperparameter search
+# it optimizes for value returned from function with @hydra.main decorator
+# docs: https://hydra.cc/docs/next/plugins/optuna_sweeper
+hydra:
+  sweeper:
+    _target_: hydra_plugins.hydra_optuna_sweeper.optuna_sweeper.OptunaSweeper
+
+    # storage URL to persist optimization results
+    # for example, you can use SQLite if you set 'sqlite:///example.db'
+    storage: null
+
+    # name of the study to persist optimization results
+    study_name: focusResNet_150_hyperparameter
+
+    # number of parallel workers
+    n_jobs: 1
+
+    # 'minimize' or 'maximize' the objective
+    direction: minimize
+
+    # total number of runs that will be executed
+    n_trials: 20
+
+    # choose Optuna hyperparameter sampler
+    # docs: https://optuna.readthedocs.io/en/stable/reference/samplers.html
+    sampler:
+      _target_: optuna.samplers.TPESampler
+      seed: 12345
+      n_startup_trials: 10 # number of random sampling runs before optimization starts
+
+    # define range of hyperparameters
+    search_space:
+      model.pretrained:
+        type: categorical
+        choices: [true, false]
+      model.lr:
+        type: float
+        low: 0.0001
+        high: 0.01
+      model.resnet_type:
+        type: categorical
+        choices: [
+          "ResNet", 
+          "resnet18",
+          "resnet34",
+          "resnet50",
+          "resnet101",
+          "resnext50_32x4d",
+          "wide_resnet50_2",
+        ]

configs/model/focusResNet_150.yaml

@@ -0,0 +1,6 @@
+_target_: src.models.focus_resnet_module.ResNetLitModule
+
+resnet_type: "resnet50"
+pretrained: false
+lr: 0.001
+weight_decay: 0.0005

data/focus150/data_ascaris.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a130ae8a06978312f912f52ac1483cb1d2b278e3719bc10328cc39f8371107d
+size 53392355

data/focus150/data_hookworm.json

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

data/focus150/data_schistosoma.json

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

data/focus150/data_trichuris.json

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

data/focus150/test_metadata.csv

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

data/focus150/train_metadata.csv

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

data/focus150/validation_metadata.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9bc5da3f5fa7ed919d5728594df752f1d1cd2dd3a506c4fe507639bfdf9a2a1d
+size 119551

src/datamodules/focus_datamodule.py

@@ -1,5 +1,5 @@
 import os
-from typing import Optional, Tuple
+from typing import List, Optional, Tuple
 import pandas as pd
 from skimage import io
 
@@ -14,7 +14,9 @@ from torchvision.transforms import transforms
 class FocusDataSet(Dataset):
     """Dataset for z-stacked images of neglected tropical diseaeses."""
 
-    def __init__(self, csv_file, root_dir, transform=None, in_memory=True):
+    def __init__(
+        self, csv_file, root_dir, transform=None, in_memory=True, additional_col_list=[]
+    ):
         """Initialize focus satck dataset.
 
         Args:
@@ -25,8 +27,17 @@ class FocusDataSet(Dataset):
         """
         self.metadata = pd.read_csv(csv_file)
         self.in_memory = in_memory
+
+        self.additional_col_index = {}
+
+        _col_list = list(additional_col_list)  # clone list to avoid modifying default
+        for attribute in _col_list:
+            self.additional_col_index[attribute] = self.metadata.columns.get_loc(
+                attribute
+            )
+
         self.col_index_path = self.metadata.columns.get_loc("image_path")
-        self.col_index_focus = self.metadata.columns.get_loc("focus_value")
+        self.col_index_focus = self.metadata.columns.get_loc("focus_height")
         self.root_dir = root_dir
         self.transform = transform
 
@@ -56,7 +67,7 @@ class FocusDataSet(Dataset):
             idx (int) The index of the sample that is to be retrieved
 
         Returns:
-            Item/Items which is a dictionary containing "image" and "focus_value"
+            Item/Items which is a dictionary containing "image" and "focus_height"
         """
         if torch.is_tensor(idx):
             idx = idx.tolist()
@@ -69,11 +80,14 @@ class FocusDataSet(Dataset):
         if self.transform:
             image = self.transform(image)
 
-        focus_value = torch.from_numpy(
+        focus_height = torch.from_numpy(
             np.asarray(self.metadata.iloc[idx, self.col_index_focus])
         ).float()
 
-        sample = {"image": image, "focus_value": focus_value}
+        sample = {"image": image, "focus_height": focus_height}
+
+        for attr, col_idx in self.additional_col_index.items():
+            sample[attr] = self.metadata.iloc[idx, col_idx]
 
         return sample
 
@@ -86,27 +100,59 @@ class FocusDataModule(LightningDataModule):
     def __init__(
         self,
         data_dir: str = "data/",
-        csv_file: str = "data/metadata.csv",
-        train_val_test_split_percentage: Tuple[int, int, int] = (0.75, 0.15, 0.15),
+        csv_train_file: str = "data/train_metadata.csv",
+        csv_val_file: str = "data/validation_metadata.csv",
+        csv_test_file: str = "data/test_metadata.csv",
         batch_size: int = 64,
         num_workers: int = 0,
         pin_memory: bool = False,
         in_memory: bool = True,
+        augmentation: bool = False,
+        additional_col_list: List[str] = [],
     ):
         super().__init__()
 
         # this line allows to access init params with 'self.hparams' attribute
         self.save_hyperparameters(logger=False)
 
+        transform_list = [
+            transforms.ToTensor(),
+            transforms.ConvertImageDtype(torch.float),
+        ]
+
+        self.base_transforms = []
+        self.base_transforms.extend(transform_list)
+        self.base_transforms = transforms.Compose(self.base_transforms)
+
+        if augmentation:
+            transform_list.extend(
+                [
+                    transforms.RandomHorizontalFlip(p=0.5),
+                    transforms.RandomVerticalFlip(p=0.5),
+                    transforms.RandomChoice(
+                        [
+                            transforms.RandomApply(
+                                [transforms.RandomRotation((90, 90))], p=0.5
+                            ),
+                            transforms.RandomApply(
+                                [transforms.RandomRotation((180, 180))], p=0.5
+                            ),
+                            transforms.RandomApply(
+                                [transforms.RandomRotation((270, 270))], p=0.5
+                            ),
+                        ]
+                    ),
+                ]
+            )
+
         # data transformations
-        self.transforms = transforms.Compose(
-            [transforms.ToTensor(), transforms.ConvertImageDtype(torch.float)]
-        )
+        self.transforms = transforms.Compose(transform_list)
 
         self.data_train: Optional[Dataset] = None
         self.data_val: Optional[Dataset] = None
         self.data_test: Optional[Dataset] = None
         self.in_memory = in_memory
+        self.additional_col_list = additional_col_list
 
     def prepare_data(self):
         """This method is not implemented as of yet.
@@ -123,24 +169,28 @@ class FocusDataModule(LightningDataModule):
 
         # load datasets only if they're not loaded already
         if not self.data_train and not self.data_val and not self.data_test:
-            dataset = FocusDataSet(
-                self.hparams.csv_file,
+            self.data_train = FocusDataSet(
+                self.hparams.csv_train_file,
                 self.hparams.data_dir,
                 transform=self.transforms,
                 in_memory=self.in_memory,
+                additional_col_list=self.additional_col_list,
             )
-            train_length = int(
-                len(dataset) * self.hparams.train_val_test_split_percentage[0]
-            )
-            val_length = int(
-                len(dataset) * self.hparams.train_val_test_split_percentage[1]
+
+            self.data_val = FocusDataSet(
+                self.hparams.csv_val_file,
+                self.hparams.data_dir,
+                transform=self.base_transforms,
+                in_memory=self.in_memory,
+                additional_col_list=self.additional_col_list,
             )
-            test_length = len(dataset) - val_length - train_length
 
-            self.data_train, self.data_val, self.data_test = random_split(
-                dataset=dataset,
-                lengths=(train_length, test_length, val_length),
-                generator=torch.Generator().manual_seed(42),
+            self.data_test = FocusDataSet(
+                self.hparams.csv_test_file,
+                self.hparams.data_dir,
+                transform=self.base_transforms,
+                in_memory=self.in_memory,
+                additional_col_list=self.additional_col_list,
             )
 
     def train_dataloader(self):

src/models/focus_conv_module.py

@@ -98,7 +98,7 @@ class FocusConvLitModule(LightningModule):
 
     def step(self, batch: Any):
         x = batch["image"]
-        y = batch["focus_value"]
+        y = batch["focus_height"]
         logits = self.forward(x)
         loss = self.criterion(logits, y.unsqueeze(1))
         preds = torch.squeeze(logits)

src/models/focus_module.py

@@ -83,7 +83,7 @@ class FocusLitModule(LightningModule):
 
     def step(self, batch: Any):
         x = batch["image"]
-        y = batch["focus_value"]
+        y = batch["focus_height"]
         logits = self.forward(x)
         loss = self.criterion(logits, y.unsqueeze(1))
         preds = torch.squeeze(logits)
@@ -208,7 +208,7 @@ class FocusMSELitModule(LightningModule):
 
     def step(self, batch: Any):
         x = batch["image"]
-        y = batch["focus_value"]
+        y = batch["focus_height"]
         logits = self.forward(x)
         loss = self.criterion(logits, y.unsqueeze(1))
         preds = torch.squeeze(logits)

src/models/focus_resnet_module.py

@@ -0,0 +1,162 @@
+from typing import Any, List
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+from pytorch_lightning import LightningModule
+from torchmetrics import MaxMetric, MeanAbsoluteError, MinMetric
+from torchmetrics.classification.accuracy import Accuracy
+import torchvision.models as models
+
+
+class ResNetLitModule(LightningModule):
+    def __init__(
+        self,
+        resnet_type: str = "ResNet",
+        pretrained=False,
+        lr: float = 0.001,
+        weight_decay: float = 0.0005,
+    ):
+        """Initialize function for a resnet module.
+
+        Args:
+            resnet_type (str, optional): Type of the used resnet network. Defaults to
+                "ResNet".
+                Can be one of the following values: "ResNet", "resnet18",
+                    "resnet34", "resnet50", "resnet101", "resnet152", "resnext50_32x4d",
+                    "resnext101_32x8d", "wide_resnet50_2", "wide_resnet101_2"
+            pretrained (bool, optional): if True loads pytorch pretrained models.
+                Defaults to False.
+        """
+        super().__init__()
+
+        # this line allows to access init params with 'self.hparams' attribute
+        # it also ensures init params will be stored in ckpt
+        self.save_hyperparameters(logger=False)
+
+        # loss function
+        self.criterion = torch.nn.MSELoss()
+
+        # use separate metric instance for train, val and test step
+        # to ensure a proper reduction over the epoch
+        self.train_mae = MeanAbsoluteError()
+        self.val_mae = MeanAbsoluteError()
+        self.test_mae = MeanAbsoluteError()
+
+        # for logging best so far validation accuracy
+        self.val_mae_best = MinMetric()
+
+        self.pretrained = pretrained
+
+        if resnet_type == "ResNet":
+            resnet_constructor = models.ResNet()
+        elif resnet_type == "resnet18":
+            resnet_constructor = models.resnet18
+        elif resnet_type == "resnet34":
+            resnet_constructor = models.resnet34
+        elif resnet_type == "resnet50":
+            resnet_constructor = models.resnet50
+        elif resnet_type == "resnet101":
+            resnet_constructor = models.resnet101
+        elif resnet_type == "resnet152":
+            resnet_constructor = models.resnet152
+        elif resnet_type == "resnext50_32x4d":
+            resnet_constructor = models.resnext50_32x4d
+        elif resnet_type == "resnext101_32x8d":
+            resnet_constructor = models.resnext101_32x8d
+        elif resnet_type == "wide_resnet50_2":
+            resnet_constructor = models.wide_resnet50_2
+        elif resnet_type == "wide_resnet101_2":
+            resnet_constructor = models.wide_resnet101_2
+        else:
+            raise Exception(f"did not find model type: {resnet_type}")
+
+        backbone = resnet_constructor(pretrained=pretrained)
+        # init a pretrained resnet
+
+        num_filters = backbone.fc.in_features
+        layers = list(backbone.children())[:-1]
+        self.feature_extractor = nn.Sequential(*layers)
+
+        self.fc = nn.Linear(num_filters, 1)
+
+    def forward(self, x):
+        representations = self.feature_extractor(x).flatten(1)
+        x = self.fc(representations)
+        return x
+
+    def step(self, batch: Any):
+        x = batch["image"]
+        y = batch["focus_height"]
+        logits = self.forward(x)
+        loss = self.criterion(logits, y.unsqueeze(1))
+        preds = torch.squeeze(logits)
+        return loss, preds, y
+
+    def training_step(self, batch: Any, batch_idx: int):
+        loss, preds, targets = self.step(batch)
+
+        # log train metrics
+        mae = self.train_mae(preds, targets)
+        self.log("train/loss", loss, on_step=False, on_epoch=True, prog_bar=False)
+        self.log("train/mae", mae, on_step=False, on_epoch=True, prog_bar=True)
+
+        # we can return here dict with any tensors
+        # and then read it in some callback or in `training_epoch_end()`` below
+        # remember to always return loss from `training_step()` or else
+        # backpropagation will fail!
+        return {"loss": loss, "preds": preds, "targets": targets}
+
+    def training_epoch_end(self, outputs: List[Any]):
+        # `outputs` is a list of dicts returned from `training_step()`
+        pass
+
+    def validation_step(self, batch: Any, batch_idx: int):
+        loss, preds, targets = self.step(batch)
+
+        # log val metrics
+        mae = self.val_mae(preds, targets)
+        self.log("val/loss", loss, on_step=False, on_epoch=True, prog_bar=False)
+        self.log("val/mae", mae, on_step=False, on_epoch=True, prog_bar=True)
+
+        return {"loss": loss, "preds": preds, "targets": targets}
+
+    def validation_epoch_end(self, outputs: List[Any]):
+        mae = self.val_mae.compute()  # get val accuracy from current epoch
+        self.val_mae_best.update(mae)
+        self.log(
+            "val/mae_best", self.val_mae_best.compute(), on_epoch=True, prog_bar=True
+        )
+
+    def test_step(self, batch: Any, batch_idx: int):
+        loss, preds, targets = self.step(batch)
+
+        # log test metrics
+        mae = self.test_mae(preds, targets)
+        self.log("test/loss", loss, on_step=False, on_epoch=True)
+        self.log("test/mae", mae, on_step=False, on_epoch=True)
+
+    def test_epoch_end(self, outputs: List[Any]):
+        print(outputs)
+        pass
+
+    def on_epoch_end(self):
+        # reset metrics at the end of every epoch
+        self.train_mae.reset()
+        self.test_mae.reset()
+        self.val_mae.reset()
+
+    def configure_optimizers(self):
+        """Choose what optimizers and learning-rate schedulers.
+
+        Normally you'd need one. But in the case of GANs or similar you might
+        have multiple.
+
+        See examples here:
+            https://pytorch-lightning.readthedocs.io/en/latest/common/lightning_module.html#configure-optimizers
+        """
+        return torch.optim.Adam(
+            params=self.parameters(),
+            lr=self.hparams.lr,
+            weight_decay=self.hparams.weight_decay,
+        )