Repository: Sllambias/yucca (language: python)

Issue:
Update documentation
- [ ] ReadMe
- [ ] Task Conversion
- [ ] Changing Parameters
- [ ] Improve Ensemble documentation


Discussion / hints:

Fix patch:
diff --git a/.gitignore b/.gitignore
index e9cedbcc..944dd6ca 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,6 +3,9 @@ __pycache__/
 *.py[cod]
 *$py.class
 
+# PyTest folders
+tests/data/yucca_*
+
 # C extensions
 *.so
 
diff --git a/README.md b/README.md
index bade804c..57942c45 100644
--- a/README.md
+++ b/README.md
@@ -10,36 +10,43 @@
 </div>
 
 # Yucca
-All-Purpose Segmentation Framework. Yucca is designed to be plug-and-play while still being heavily customizable. This allows users to employ the basic Yucca models as solid baselines but it also allows users to change and experiment with exact features in a robust and thoroughly tested research environment. The Yucca project is inspired by Fabien Isensee's [nnUNet](https://github.com/MIC-DKFZ/nnUNet).
+End-to-end modular machine learning framework for classification, segmentation and unsupervised learning. Yucca is designed to be plug-and-play while still allowing for effortless customization. This allows users to employ the basic Yucca models as solid baselines, but it also allows users to change and experiment with exact features in a robust and thoroughly tested research environment. The Yucca project is inspired by Fabien Isensee's [nnUNet](https://github.com/MIC-DKFZ/nnUNet).
 
 ![alt text](yucca/documentation/illustrations/end_to_end_diagram.svg?raw=true)
 
 # Table of Contents
 - [Guides](#guides)
 - [Installation](#installation)
+- [Introduction to Yucca](#introduction-to-yucca)
 - [Task Conversion](#task-conversion)
 - [Preprocessing](#preprocessing)
 - [Training](#training)
 - [Inference](#inference)
 - [Ensembles](#ensembles)
+- [Classification](#classification-models)
+- [Segmentation](#segmentation-models)
+- [Unsupervised](#unsupervised-models)
 
 # Guides
 
-- [Task Conversion](yucca/documentation/tutorials/task_conversion.md)
-- [Changing Parameters](yucca/documentation/tutorials/changing_parameters.md#model--training)
-- [Environment Variables](yucca/documentation/tutorials/environment_variables.md)
-
+- [Changing Parameters](yucca/documentation/guides/changing_parameters.md#model--training)
+- [Environment Variables](yucca/documentation/guides/environment_variables.md)
+- [FAQ](yucca/documentation/guides/FAQ.md)
+- [Run Scripts Advanced](yucca/documentation/guides/run_scripts_advanced.md)
+- [Task Conversion](yucca/documentation/guides/task_conversion.md)
+ 
 # Installation
 
-## Install the project after clone using Conda
+## Install an editable version of the project with Cuda support using Conda
 
-Create a python=3.10 environment for Yucca to avoid conflicts with other projects. 
+Create a python=3.10 or python=3.11 environment exclusively for Yucca to avoid conflicts with other projects. 
 
 IMPORTANT: First install Pytorch for GPU following appropriate instructions from e.g. https://pytorch.org/get-started/locally/.
 Then navigate to Yucca and install the package from there.
 
-For an Ubuntu system with Cuda=>12.1:
+For an Ubuntu system with Cuda=>12.1 and python=3.11:
 ```
+> git clone https://github.com/Sllambias/yucca.git
 > conda create -n yuccaenv python=3.11
 > conda activate yuccaenv
 > conda install -c anaconda setuptools
@@ -49,18 +56,7 @@ For an Ubuntu system with Cuda=>12.1:
 > pip install -e .
 ```
 
-
-For an Ubuntu system with Cuda 11.7:
-```
-> conda create -n yuccaenv python=3.10
-> conda activate yuccaenv
-> conda install -c anaconda setuptools
-> conda install -c "nvidia/label/cuda-11.7.1" cuda-toolkit
-> conda install pytorch==1.13.1 torchvision==0.14.1 torchaudio==0.13.1 pytorch-cuda=11.7 -c pytorch -c nvidia
-> cd yucca
-> pip install -e .
-```
-To use other CUDA or PyTorch versions refer to 1. for the current PyTorch installation, 2. for previous versions and 3. for the appropriate CUDA toolkit. Note that the CUDA versions used in the PyTorch and CUDA-toolkit installations should match (in the example above both use 11.7) 
+To use other CUDA or PyTorch versions refer to 1. for the current PyTorch installation, 2. for previous versions and 3. for the appropriate CUDA toolkit. Note that the CUDA versions used in the PyTorch and CUDA-toolkit installations should match (in the example above both use 12.1).
 
 1. https://pytorch.org/get-started/locally/
 2. https://pytorch.org/get-started/previous-versions/
@@ -75,6 +71,8 @@ this will install the code from github, not an eventual local clone.
 
 
 # Weights & Biases
+Weights & Biases is the main tool for experiment tracking in Yucca. It is extremely useful to understand how your models are behaving and often also why. Although it can be disabled, it is heavily encouraged to install and use it with Yucca.
+
 Navigate to https://wandb.ai/home and log in or sign up for Weights and Biases.
 Activate the appropriate environment, install Weights and Biases and log in by following the instructions (i.e. paste the key from https://wandb.ai/authorize into the terminal).
 ```console
@@ -86,119 +84,123 @@ wandb: You can find your API key in your browser here: https://wandb.ai/authoriz
 wandb: Paste an API key from your profile and hit enter, or press ctrl+c to quit:
 ```
 
-# Task Conversion
+# Introduction to Yucca
 
-Prior to preprocessing and training all datasets must be converted to a Yucca-compliant task. This is done to ensure reproducibility and eliminate data leakage. For a tutorial see the [Task Conversion Guide](yucca/documentation/tutorials/task_conversion.md).
+The Yucca pipeline comprises the 4 processes illustrated in the [diagram](#yucca). In the first step, the user is expected to prepare the data for Yucca. In the remaining three steps, Yucca will take over regarding file management.
+  1. **The Task Conversion** step requires that the user _converts_ their arbitrarily structured data to the file and folder structure Yucca requires. From now on, Yucca will handle the data. Task Conversion involves moving and renaming the data along with creating a metadata file.
+  2. **The Preprocessing step** takes the Task Converted data and preprocesses it and then subsequently saves it in its preprocessed state in the format expected by the Yucca training process.
+  3. **The Training step** takes the preprocessed data and trains a model, and then subsequently saves it along with its checkpoints and metadata.
+  4. **The Inference step** takes the trained model and applies it to a task-converted (but not preprocessed) test set. During inference, the unseen samples are preprocessed with the same preprocessor used in the preprocessing step. Predictions are then saved. When inference is concluded, the predictions are evaluated against the ground truth, and a .json file containing the results is saved next to the predictions.
 
-# Preprocessing
+## Environment Variables
 
-Preprocessing is carried out using the `yucca_preprocess` command, which calls the [`run_preprocessing.py`](yucca/run/run_preprocessing.py) script. For help and all the available arguments see the output of the `-h` flag below.
+Initially, the environment variables used in Yucca must be defined. To set these, see the [Environment Variables](yucca/documentation/guides/environment_variables.md) guide. 
 
-```console
-> yucca_preprocess -h
-usage: yucca_preprocess [-h] -t TASK [-pl PL] [--disable_unit_tests DISABLE_UNIT_TESTS] [--threads THREADS]
+## Task Conversion
 
-options:
-  -h, --help            show this help message and exit
-  -t TASK, --task TASK  Name of the task to preprocess. Should be of format: TaskXXX_MYTASK
-  -pl PL                Experiment Planner Class to employ. Defaults to the YuccaPlanner
-  --disable_unit_tests DISABLE_UNIT_TESTS
-                        Enable or disable unittesting
-```
+Before preprocessing and training, all datasets must be converted to Yucca-compliant tasks. This is done to ensure reproducibility and eliminate data leakage. For a tutorial see the [Task Conversion Guide](yucca/documentation/guides/task_conversion.md).
 
-An example of preprocessing a task called `Task001_Brains` with the default planner:
-```
-> yucca_preprocess -t Task001_Brains
-```
+## Preprocessing
 
-Internally, the `yucca_preprocess` command calls a planner and preprocessor class.
-Initially, the appropriate planner is called. This is by default the [`YuccaPlannerV2`](yucca/planning/YuccaPlannerV2.py). The planner defines the normalization operation, spacing/resolution and orientation and saves relevant properties in a .pkl file for later use.
+Preprocessing is carried out using the `yucca_preprocess` command. For advanced usage see: [`run_scripts_advanced.py`](yucca/documentation/guides/run_scripts_advanced.md#preprocessing)
 
-Afterwards, the preprocessor is called. This is by default the [`YuccaPreprocessor`](yucca/preprocessing/YuccaPreprocessor.py). This preprocesses training data according to the operations and values supplied by the chosen planner. As such the preprocessor should very rarely be changed, while the planner will often be changed to employ alternative preprocessing schemes.
+Basic Yucca preprocessing relies on three CLI flags:
+  1. **-t**: The target task-converted raw data to be preprocessed.
+  2. **-pl**: The Planner class, which is responsible for determining *what* we do in preprocessing and *how* it is done. This includes setting the normalization, resizing, resampling and transposition operations and any values associated with them. The planner class defaults to the `YuccaPlanner`, but it can also be any custom planner found or created in the [Planner directory](yucca/planning) and its subdirectories.
+  3. **-pr**: The Preprocessor class. The Preprocessor is a workhorse that receives an instruction manual from the Planner, which it carries out. The Preprocessor can be one of `YuccaPreprocessor` (default), `ClassificationPreprocessor` and `UnsupervisedPreprocessor`. The only aspect in which they differ is how they expect the ground truth to look. The `YuccaPreprocessor` expects to find images, the `ClassificationPreprocessor` expects to find .txt files with image-level classes and the `UnsupervisedPreprocessor` expects not to find any ground truth. 
 
-# Training
+An example of preprocessing a task called `Task001_Brains` with the default planner and the `ClassificationPreprocessor`:
+```
+> yucca_preprocess -t Task001_Brains -pr ClassificationPreprocessor
+```
 
-Training is carried out using the `yucca_train` command, which calls the [`run_training.py`](yucca/run/run_training.py) script. Prior to training the `yucca_preprocessing` command must be used to preprocess data and create the appropriate plan folder and `_plans.json` file. For help and all the available arguments see the output of the `-h` flag below.
+## Training
 
-```console
-> yucca_train -h
-usage: yucca_train [-h] [-t TASK] [-m M] [-d D] [-tr TR] [-pl PL] [-f F] [--lr LR] [--loss LOSS] [--mom MOM] [--continue_train]
+Training is carried out using the `yucca_train` command. For advanced usage see: [`run_scripts_advanced.py`](yucca/documentation/guides/run_scripts_advanced.md#training). Before training any models, a preprocessed dataset must be prepared using the `yucca_preprocessing` command.
 
-options:
-  -h, --help            show this help message and exit
-  -t TASK, --task TASK  Name of the task used for training. The data should already be preprocessed using yucca_preprocessArgument should be of format: TaskXXX_MYTASK
-  -m M                  Model Architecture. Should be one of MultiResUNet or UNet Note that this is case sensitive. Defaults to the standard UNet.
-  -d D                  Dimensionality of the Model. Can be 3D, 25D or 2D. Defaults to 3D.
-  -tr TR                Trainer Class to be used. Defaults to the basic YuccaTrainer
-  -pl PL                Plan ID to be used. This specifies which plan and preprocessed data to use for training on the given task. Defaults to the YuccaPlans folder
-  -f F                  Fold to use for training. Unless manually assigned, folds [0,1,2,3,4] will be created automatically. Defaults to training on fold 0
-  --lr LR               Should only be used to employ alternative Learning Rate. Format should be scientific notation e.g. 1e-4.
-  --loss LOSS           Should only be used to employ alternative Loss Function
-  --mom MOM             Should only be used to employ alternative Momentum.
-  --continue_train      continue training a previously saved checkpoint.
-```
-To start training using the default Trainer Class and plans file simply supply (1) the task with `-t` (2) the model architecture with `-m` and (3) the dimensions with `-d`. An example of training on a task called `Task001_Brains`, using a 3D `MultiResUnet`:
+Basic Yucca training relies on five CLI flags:
+  1. **-t**: The target preprocessed data on which the model will be trained.
+  2. **-d**: The model dimensions. This can be either 2D or 3D (default).
+  3. **-m**: The model architecture. This includes any model implemented in the [Model directory](yucca/network_architectures/networks). Including, but not limited to, `U-Net`, `UNetR`, `MultiResUNet` and `ResNet50`.
+  4. **-man**: The Manager to use. This defaults to the `YuccaManager`.
+  5. **-pl**: The Planner used to preprocess the training data. This defaults to the `YuccaPlanner`.
+
+An example of training a `MultiResUNet` with the default Manager on a task called `Task001_Brains` that has been preprocessed using the default `YuccaPlanner`:
+ using a 2D `MultiResUnet`:
 ```
-> yucca_train -t Task001_Brains -m MultiResUNet
+> yucca_train -t Task001_Brains -m MultiResUNet -d 2D
 ```
 
-By default this will use the [YuccaTrainerV2](yucca/training/trainers/YuccaTrainerV2.py). To change Trainer use the `-tr` flag. The Trainer Class defines the model training parameters. This includes: learning rate, learning rate scheduler, momentum, loss function, optimizer, batch size, epochs, foreground oversampling, patch size and data augmentation scheme. To change the values of these parameters see [Changing Parameters](yucca/documentation/tutorials/changing_parameters.md#model--training). To use plan files created by non-default Planners use `-pl` and specify the name of the alternative plan file. To specify which fold to train on use `-f`. By default training is done on fold 0 (unless manually specified we create 5 random splits).
+## Inference
+
+Inference is carried out using the `yucca_inference` command. For advanced usage see: [`run_scripts_advanced.py`](yucca/documentation/guides/run_scripts_advanced.md#inference). Prior to inference, the model must be trained using the `yucca_train` command, and the target dataset must be task-converted.
+
+Basic Yucca inference relies on six CLI flags.
+  1. **-t**: The target task-converted raw data on which to run inference.
+  2. **-s**: The source task on which the model was trained.
+  3. **-d**: The dimensions of the trained model.
+  4. **-m**: The architecture of the trained model.
+  5. **-man**: The Manager to use. This defaults to the `YuccaManager`.
+  6. **-pl**: The Planner used to preprocess the training data.
 
-An example of training on a task called `Task002_NotBrains`, using a 2D `MultiResUnet` with the `CustomTrainer` and `CustomPlans` on fold 3:
+An example of running inference on the test set of a task called `Task001_Brains`, using a 3D `MultiResUnet` trained on the train set of the same task:
 ```
-> yucca_train -t Task002_NotBrains -m MultiResUNet -d 2D -tr CustomTrainer -pl CustomPlans -f 3
+> yucca_inference -t Task001_Brains -s Task001_Brains -m MultiResUNet
+```
+An example of running inference on the test set of a task called `Task002_Lungs`, using a 2D `UNet` trained on a task called `Task001_Brains`:
+```
+> yucca_inference -t Task002_NotBrains -s Task001_Brains -d 2D -m UNet
 ```
 
-# Inference
+## Ensembles
 
-Inference is carried out using the `yucca_inference` command, which calls the [`run_inference.py`](yucca/run/run_inference.py) script. This relies on models previously trained using the `yucca_train` command. For help and all the available arguments see the output of the `-h` flag below. 
+To train an ensemble of models we use the `yucca_preprocess`, `yucca_train` and `yucca_inference` commands. For advanced usage see: [`run_scripts_advanced.py`](yucca/documentation/guides/run_scripts_advanced.md#ensembles). A common application of model ensembles is to train 2D models on each of the three axes of 3D data (either denoted as the X-, Y- and Z-axis or, in medical imaging, the axial, sagittal and coronal views) and then fuse their predictions in inference. 
 
+To train 3 models on the three axes of a 3D dataset called `Task001_Brains` prepare three preprocessed versions of the dataset using the three Planners `YuccaPlannerX`, `YuccaPlannerY` and `YuccaPlannerZ`:
 ```console
-> yucca_inference -h
-usage: yucca_inference [-h] -s S -t T [-f F] [-m M] [-d D] [-tr TR] [-pl PL] [-chk CHK] [--ensemble] [--not_strict] [--save_softmax] [--overwrite] [--no_eval] [--predict_train]
-
-options:
-  -h, --help       show this help message and exit
-  -s S             Name of the source task i.e. what the model is trained on. Should be of format: TaskXXX_MYTASK
-  -t T             Name of the target task i.e. the data to be predicted. Should be of format: TaskXXX_MYTASK
-  -f F             Select the fold that was used to train the model desired for inference. Defaults to looking for a model trained on fold 0.
-  -m M             Model Architecture. Defaults to UNet.
-  -d D             2D, 25D or 3D model. Defaults to 3D.
-  -tr TR           Full name of Trainer Class. e.g. 'YuccaTrainer_DCE' or 'YuccaTrainerV2'. Defaults to YuccaTrainerV2.
-  -pl PL           Plan ID. Defaults to YuccaPlannerV2
-  -chk CHK         Checkpoint to use for inference. Defaults to checkpoint_best.
-  --ensemble       Used to initialize data preprocessing for ensemble/2.5D training
-  --not_strict     Strict determines if all expected modalities must be present, with the appropriate suffixes (e.g. '_000.nii.gz'). Only touch if you know what you're doing.
-  --save_softmax   Save softmax outputs. Required for softmax fusion.
-  --overwrite      Overwrite existing predictions
-  --no_eval        Disable evaluation and creation of metrics file (result.json)
-  --predict_train  Predict on the training set. Useful for debugging.
+> yucca_preprocess -t Task001_Brains -pl YuccaPlannerX
+> yucca_preprocess -t Task001_Brains -pl YuccaPlannerY
+> yucca_preprocess -t Task001_Brains -pl YuccaPlannerZ
 ```
 
-To run inference using the default Trainer Class, plan file and folds supply (1) the source task (what the model is trained on) with `-s` (2) the target task (what we want to predict) with `-t` (3) the model architecture with `-m` and (4) the dimensions with `-d`.
-
-An example of running inference on the test set of a task called `Task001_Brains`, using a 3D `MultiResUnet` trained on the same task:
-```
-> yucca_inference -s Task001_Brains -t Task001_Brains -m MultiResUNet
+Then, train three 2D models one on each version of the preprocessed dataset:
+```console
+> yucca_train -t Task001_Brains -pl YuccaPlannerX -d 2D
+> yucca_train -t Task001_Brains -pl YuccaPlannerY -d 2D
+> yucca_train -t Task001_Brains -pl YuccaPlannerZ -d 2D
 ```
-If, on the other hand, we were to run inference on a new task called Task002_NotBrains, using a 2D UNet trained on Task001_Brains with a custom Trainer Class:
+
+Then, run inference on the target dataset with each trained model.
+```console
+> yucca_inference -t Task001_Brains -pl YuccaPlannerX -d 2D
+> yucca_inference -t Task001_Brains -pl YuccaPlannerY -d 2D
+> yucca_inference -t Task001_Brains -pl YuccaPlannerZ -d 2D
 ```
-> yucca_inference -s Task001_Brains -t Task002_NotBrains -d 2D -tr CustomTrainer
+
+Finally, fuse their results and evaluate the predictions.
+```console
+> yucca_ensemble --in_dirs /path/to/predictionsX /path/to/predictionsY /path/to/predictionsZ --out_dir /path/to/ensemble_predictionsXYZ
 ```
 
-# Ensembles
+## Classification models
 
-Using an ensemble of models can be achieved manually and automatically. 
-The automatic method trains 3 models on the axial, sagittal and coronal views and combine these in inference. It is called using the `--ensemble` flag available for [`yucca_preprocess`](#preprocessing), [yucca_train](#training) and [yucca_inference](#inference). The preprocessor will preprocess the selected Task 3 times, one for each of the views, and save the preprocessed datasets in separate folders with the suffixes `X`, `Y` and `Z`, e.g. `yucca_preprocessed/TaskXXX_MYTASK/YuccaPlannerV2X`. The trainer will train a model on each of the three views and save the trained models using the same suffixes, e.g. `yucca_models/TaskXXX_MYTASK/YuccaTrainerV2_YuccaPlannerV2X`. Then, the softmax outputs from the three models are fused to create the final prediction and saved in a folder suffixed by `_Ensemble`, e.g. `yucca_results/TaskXXX_MYTASK/UNet2D/YuccaTrainerV2_YuccaPlannerV2_Ensemble`.
+Training classification models is carried out by:
+  1. Converting your raw dataset to a Yucca compliant format with class labels in individual `.txt` files. See the [Task Conversion guide](yucca/documentation/guides/task_conversion.md) for instructions on how to convert your datasets.
+  2. Selecting a Planner that:
+    1. Always preprocesses the task converted dataset using the `ClassificationPreprocessor`, such as the [`ClassificationPlanner`](yucca/planning/ClassificationPlanner.py). This preprocessor expects to find `.txt` files rather than image files in the label folders and it does not perform any preprocessing on the labels. Alternatively, the `ClassificationPreprocessor` can be selected using the `-pr ClassificationPreprocessor` flag in `yucca_preprocess` 
+    2. Resamples images to a fixed target size, such as the [`YuccaPlanner_224x224`](yucca/planning/resampling/YuccaPlanner_224x224.py). Having a fixed image size enables training models on full images, rather than patches of images. This is often necessary in classification where we want 1 (or very few) image-level prediction.
+  3. Selecting a manager that trains models on full-size images. This is any manager with the ```patch_based_training=False```, such as the [`YuccaManager_NoPatches`](yucca/training/managers/alternative_managers/YuccaManager_NoPatches.py).
+  4. Selecting a model architecture that supports classification. Currently that is limited to the [`ResNet50`](yucca/network_architectures/networks/resnet.py) but most networks can be adapted to support this with limited changes (in essence, this can be achieved by adding a Linear layer with input channels equal to the flattened output of the penultimate layer and output channels equals to the number of classes in the dataset).
+  5. Running `yucca_inference` with the `--task_type classification` flag. 
 
-The manual method can be used to speed up the process or use different ensembles og e.g. different folds rather than views. The speedup comes from the fact that the `--ensemble` flag isn't capable of handling parallel model training, it is therefore quite slow as models will only be trained sequentially. To "parallelize" this, you can train models on each of the three preprocessed datasets:
-```console
-> yucca_train -t Task002_NotBrains -d 2D -pl YuccaPlannerV2X
-> yucca_train -t Task002_NotBrains -d 2D -pl YuccaPlannerV2Y
-> yucca_train -t Task002_NotBrains -d 2D -pl YuccaPlannerV2Z
-```
-Preprocessing and inference can also be "parallelized" in the same way, but that will rarely be necessary for speed optimization as these are fairly fast operations. 
+## Segmentation models
 
+Training segmentation models is carried out by following the standard procedure introduced in the [Introduction to Yucca](yucca)
 
+## Unsupervised models
 
+Training Unsupervised models is carried out by:
+  1. Converting your raw dataset to a Yucca compliant format with no label files. See the [Task Conversion guide](yucca/documentation/guides/task_conversion.md) for instructions on how to convert your datasets.
+  2. Selecting a Planner that always preprocesses the task converted dataset using the `UnsupervisedPreprocessor`, such as the [`UnsupervisedPlanner`](yucca/planning/YuccaPlanner.py). This preprocessor expects to find no label files. Alternatively, the `UnsupervisedPreprocessor` can be selected using the `-pr UnsupervisedPreprocessor` flag in `yucca_preprocess`.
 
+When models are trained on a dataset preprocessed with the UnsupervisedPreprocessor, Yucca will use the `unsupervised` preset in the [`YuccaAugmentationComposer`](yucca/training/augmentation/YuccaAugmentationComposer.py). This sets (1) `skip_label` to True (which means we don't expect a label in the array), (2) `copy_image_to_label` to True, which means the image data is copied to also be the label data (the image is copied after applying normal augmentations) and finally, (3) `mask_image_for_reconstruction` to True, which means we randomly mask the image data (this is applied AFTER the image is copied to the label). 
diff --git a/yucca/documentation/guides/FAQ.md b/yucca/documentation/guides/FAQ.md
new file mode 100644
index 00000000..a781b125
--- /dev/null
+++ b/yucca/documentation/guides/FAQ.md
@@ -0,0 +1,5 @@
+# Out of Memory errors (OOM)
+
+1. Verify that `keep_in_ram` is disabled in the [`YuccaTrainDataset`](/yucca/yucca/training/data_loading/YuccaDataset.py). This setting should only be enabled for smaller datasets as it will quickly results in OOM errors for large datasets.
+2. Reduce the number of workers used in the DataLoaders.
+3. Increase the number of CPU's available.
diff --git a/yucca/documentation/guides/changing_parameters.md b/yucca/documentation/guides/changing_parameters.md
new file mode 100644
index 00000000..eb04a59a
--- /dev/null
+++ b/yucca/documentation/guides/changing_parameters.md
@@ -0,0 +1,291 @@
+# Table of Contents
+- [Guide to Changing Yucca Parameters](#guide-to-changing-yucca-parameters)
+- [Subclassing](#subclassing)
+- [Preprocessing](#preprocessing)
+  * [Spacing](#size-or-spacing)
+  * [Orientation](#orientation)
+  * [Normalization](#normalization)
+- [Training](#training)
+  * [Data Augmentation](#data-augmentation)
+  * [Data Splits](#data-splits)
+  * [Learning Rate](#learning-rate)
+  * [Learning Rate Scheduler](#learning-rate-scheduler)
+  * [Loss Function](#loss-function)
+  * [Model Architecture](#model-architecture)
+  * [Model Dimensionality](#model-dimensionality)
+  * [Momentum](#momentum)
+  * [Optimizer](#optimizer)
+- [Inference](#inference)
+  * [Evaluation](#evaluation)
+  * [Fusion](#fusion)
+
+
+# Guide to Changing Yucca Parameters
+## Subclassing
+Changing parameters in Yucca is generally achieved using subclasses. This means, to change a given parameter (1) Subclass the class defining the parameter, (2) change the value of the parameter to the desired value and (3) create a new .py file in the (sub)directory of the parent class.
+
+E.g. to lower the starting Learning Rate we subclass YuccaManager - the default class responsible for handling model training, and change the variable self.learning_rate variable from 1e-3 to 1e-5.
+
+We call this new Manager "YuccaManager_1e5" and save it as "YuccaManager_1e5.py" in the /yucca/training/managers directory as this is where the Parent Class is located. Alternatively it can be saved in a subdirectory of the directory of the parent class e.g. /yucca/training/managers/lr. 
+
+```
+from yucca.training.managers.YuccaManager import YuccaManager
+
+class YuccaManager_1e5(YuccaManager):
+    def __init__(self, *args, **kwargs):
+        super().__init__(learning_rate=learning_rate, *args, **kwargs)
+    self.learning_rate = 1e-5
+
+```
+
+# Preprocessing
+Unless otherwise mentioned, preprocessing variables and functions are handled by the YuccaPlanners. For optimal results, it is advisable to subclass the default planner when applying changes.
+
+**Default Planner Class: [YuccaPlanner](/yucca/planning/YuccaPlanner.py)**
+
+## Size OR Spacing
+Parent: default planner class
+
+Function: *determine_target_size_from_fixed_size_or_spacing*
+
+Either a fixed target size or a fixed target spacing can be specified. By default the preprocessor will set the fixed target spacing to the median spacing of the dataset but this can be overriden if a fixed spacing is desired. To facilitate training on full images (as opposed to the default patch-based training) a fixed target size must be used. 
+
+To set the fixed target spacing to [0.5, 0.5, 1.]:
+```
+def determine_target_size_from_fixed_size_or_spacing(self):
+    self.fixed_target_size = None
+    self.fixed_target_spacing = [0.5, 0.5, 1.]
+```
+
+To set the fixed target size to the size of the largest image of the original/unprocessed dataset:
+```
+def determine_target_size_from_fixed_size_or_spacing(self):
+    self.fixed_target_size = self.dataset_properties["original_max_size"]
+    self.fixed_target_spacing = None
+```
+
+## Orientation
+Parent: default planner class
+
+Variable 1: *self.target_coordinate_system*
+- used to ensure uniform starting orientations. This is applied before any transposition. NOTE: This will only be applied to samples with valid nifti headers (either using qform or sform codes).
+
+Variable 2: *self.transpose_forward* 
+- used to transpose samples from the starting position to a target orientation.
+
+Variable 3: *self.transpose_backward*
+- used to transpose samples back from the target orientation to the starting position. This should only be used if samples are transposed by *transpose_forward*. This is applied during inference to revert any transform applied by *transpose_forward*.
+
+For example, if it is desired to first reorient all NIFTI samples to 'LPS' as the starting position, and then transpose them from [h, w, d] to [d, h, w] during training, and finally back from [d, h, w] to [h, w, d] in inference do:
+
+```
+self.target_coordinate_system = 'LPS'
+self.transpose_forward = [2, 0, 1]
+self.transpose_backward = [1, 2, 0]
+```
+
+By default *transpose_forward* and *transpose_backward* are both = [0, 1, 2] which means samples are NOT transposed.
+This means 2D models are trained on the sagittal view (because images are always sliced in the first dimension, i.e. image[slice, :, :]).
+The YuccaPlannerY and YuccaPlannerZ are existing YuccaPlanner implementations designed to train models on the Coronal and Axial views, respectively.
+
+## Normalization
+Parent: default planner class
+
+Variable: *self.norm_op* 
+
+To find currently implemented normalization operations see the [normalizer function](/yucca/preprocessing/normalization.py). 
+
+For example if 'minmax' (otherwise known as 0-1 normalization) is desired:
+```
+self.norm_op = 'minmax'
+```
+
+# Training
+Unless otherwise mentioned, training variables and functions are handled by the YuccaManagers. For optimal results, it is advisable to subclass the default class when applying changes.
+
+**Default Manager Class: [YuccaManager](/yucca/training/managers/YuccaManager.py)**
+
+## Data Augmentation
+Parent: default Manager class
+
+Variable: *self.augmentation_params*
+
+Changing the data augmentation parameters is achieved by defining a dictionary of augmentation parameters in the Manager, which will then automatically apply these settings to the composed augmentations. The default augmentation parameters can be found in the `setup_default_params` method of the [`YuccaAugmentationComposer`](/yucca/yucca/training/augmentation/YuccaAugmentationComposer.py). Most augmentations have a variable called "X_p_per_sample" with a floating point value between 0.0-1.0 which controls the probability they are applied to each sample. To disable an augmentation set this probability to 0.0. Some augmentations also have variables that control the possible intensity ranges of the augmentation, such as the `"rotation_x": (-30.0, 30.0)` specifying the minimum and maximum degree of rotation around the X-axis.
+
+
+To disable blurring entirely and modify the scaling range do:
+```
+from yucca.training.managers.YuccaManager import YuccaManager
+
+class YuccaManager_NewUserSetup(YuccaManager):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.augmentation_parameters = {"blurring_p_per_sample": 0.0,
+                                        "scale_factor": (0.7, 1.3)}
+```
+
+## Data Splits
+CLI: `yucca_train`, `yucca_finetune` and `yucca_inference`
+
+Variables: *--split_idx*, *--split_data_method* and *--split_data_param*
+
+NOTE: Do not confuse this with the train-test splits. These must be handled in [Task Conversion](/yucca/yucca/documentation/tutorials/task_conversion.md).
+
+Training/Validation data splits can be automatically generated using simple dataset splits or the K-Fold method. First select the method with `--split_data_method` and then supply the desired parameter with `--split_data_param`. If the method is `simple_train_val_split` valid parameter values are between 0.0-1.0, so a valid configuration could be `--split_data_method simple_train_val_split --split_data_param 0.33`. For `kfold` valid parameters are integers > 1. When using K-Fold the `--split_idx` can be used to select which fold to use for training. When using `split_data_method simple_train_val_split` you do not need to specify the `--split_idx` as there will only be one split of the specified configuration.  By default Yucca will generate 5-Folds and train on Fold 0. 
+
+Newly generated splits are saved in the `splits.pkl` file next to the preprocessed dataset. If this file already exists Yucca will reuse splits generated with the same configuration. To reuse a split previously generated using `--split_data_method simple_train_val_split --split_data_param 0.33` simply specify `--split_data_method simple_train_val_split --split_data_param 0.33` again. To reuse the 5 folds generated with `--split_data_kfold 5` but train on a fold 1 instead of 0 simply specify `--split_data_kfold 5` again, but this time with `--split_idx 1`.
+
+
+This means, for any dataset it's partitioned into five parts [0, 1, 2, 3, 4], which we use to create 5 splits:
+```
+{
+'kfold': 
+    {'5': 
+        [
+        {'train': [1, 2, 3, 4], 'val': [0]}, 
+        {'train': [0, 2, 3, 4], 'val': [1]}, 
+        {'train': [0, 1, 3, 4], 'val': [2]}, 
+        {'train': [0, 1, 2, 4], 'val': [3]}, 
+        {'train': [0, 1, 2, 3], 'val': [4]}, 
+        ]
+    }
+'simple_train_val_split:
+    {'0.40': 
+        [
+        {'train': [0, 2, 4], 'val': [1, 3]}
+        ]
+    }
+}
+```
+
+If you wish to use predefined splits, you have to manufacture a splits file and save it (or append to an existing file) in the folder of the task's preprocessed data (e.g. "/path/to/YuccaData/yucca_preprocessed/TaskXXX_MyTask/splits.pkl").
+
+When doing this, the contents of the manufactured split file should be a list containing a dictionary:
+```
+{
+'mycustomsplit':
+    {'version0':
+        [
+        {'train': [0], 'val': [1, 2, 3, 4]}
+        ]
+    }
+}
+```
+Which is then selected using `--split_data_method custom --split_data_param version0`
+
+## Deep Supervision
+CLI: In training and finetuning deep supervision is enabled using the --ds flag. 
+
+## Learning Rate
+Parent: default Manager class
+
+Variable: self.learning\_rate
+
+```
+from yucca.training.managers.YuccaManager import YuccaManager
+
+class YuccaManager_LowerLR(YuccaManager):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.learning_rate = 1e-5
+```
+
+CLI: Can also be changed using --lr flag.
+
+## Learning Rate Scheduler
+Parent: [YuccaLightningModule](/yucca/yucca/training/lightning_modules/YuccaLightningModule.py)
+
+Variable: self.lr\_scheduler
+- Used to determine the LR Scheduler CLASS
+
+```
+from yucca.training.lightning_modules.YuccaLightningModule import YuccaLightningModule
+from torch import optim
+
+class YuccaLightningModule_StepLRS(YuccaLightningModule):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.lr_scheduler = optim.lr_scheduler.StepLR
+```
+
+For an illustration of how a wide selection of Torch.Optim LR Schedulers work see the [LR Scheduler Illustration Notebook](/yucca/documentation/illustrations/learning_rate_schedulers.ipynb).
+The notebook illustrates the effect of the scheduling algorithms with different parameters. 
+
+## Loss Function
+Parent: default Manager class
+
+Variable: self.loss
+
+The loss class must be saved in /yucca/training/loss_and_optim/loss_functions and be a subclass of nn.Module.
+
+```
+from yucca.training.managers.YuccaManager import YuccaManager
+from yucca.training.loss_and_optim.loss_functions import NLL
+
+class YuccaManager_NLL(YuccaManager):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.loss = NLL
+```
+
+Can also be changed using *yucca_train* --loss flag.
+
+## Model Architecture
+CLI: In both training and inference model architecture is specified using the -m flag. Currently supported architectures can be found in [networks](yucca/yucca/network_architectures/networks).
+
+## Model Dimensionality
+CLI: In both preprocessing, training and inference dimension is specified using the -d flag. Currently supported is: "2D" and "3D".
+
+## Momentum
+Parent: default Manager class
+
+Variable: self.momentum 
+
+```
+from yucca.training.managers.YuccaManager import YuccaManager
+
+class YuccaManager_mom95(YuccaManager):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.momentum= 0.95
+```
+
+CLI: Can also be changed using *yucca_train* --mom flag.
+
+## Optimizer
+Parent: [YuccaLightningModule](/yucca/yucca/training/lightning_modules/YuccaLightningModule.py)
+
+Variable: self.optim
+
+```
+from yucca.training.lightning_modules.YuccaLightningModule import YuccaLightningModule
+from torch import optim
+
+class YuccaLightningModule_Adam(YuccaLightningModule):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.optim = optim.Adam
+```
+
+## Patch Based Training
+Parent: default Manager class
+
+Variable: self.patch_based_training 
+
+```
+from yucca.training.managers.YuccaManager import YuccaManager
+
+class YuccaManager_NoPatches(YuccaManager):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.patch_based_training = False
+```
+
+This is used to train models on full-size images. Requires datasets are preprocessed using a Planner using fixed_target_size to ensure that all samples have identical dimensions.
+
+# Inference
+Changing inference parameters not implemented currently.
+
+## Evaluation
+## Pixel/Object
+## Fusion
diff --git a/yucca/documentation/tutorials/environment_variables.md b/yucca/documentation/guides/environment_variables.md
similarity index 100%
rename from yucca/documentation/tutorials/environment_variables.md
rename to yucca/documentation/guides/environment_variables.md
diff --git a/yucca/documentation/guides/run_scripts_advanced.md b/yucca/documentation/guides/run_scripts_advanced.md
new file mode 100644
index 00000000..3db24e68
--- /dev/null
+++ b/yucca/documentation/guides/run_scripts_advanced.md
@@ -0,0 +1,162 @@
+# Task Conversion
+The `yucca_convert_task` supplies an API to access previously created Task Conversion scripts wrapped in `convert` functions.
+Generally new users will need to write their own Task Conversion scripts but in some cases they might have already been written (e.g. for very popular Challenge datasets)
+
+usage: yucca_convert_task [-h] -t TASK [-p PATH] [-d SUBDIR]
+
+options:
+  -h, --help            show this help message and exit
+  -t TASK, --task TASK  Name of the task to preprocess. Should be of format: TaskXXX_MYTASK
+  -p PATH, --path PATH  Path to source data
+  -d SUBDIR, --subdir SUBDIR
+                        Directory of data inside source data
+
+The -t flag must point to the name of a previously created task conversion script, such as the [OASIS script](/yucca/yucca/task_conversion/Task001_OASIS.py). The -p flag points to the parent directory of the dataset folder. If left empty this defaults to [`yucca_source`](/yucca/yucca/documentation/tutorials/environment_variables.md). The -d flag points to the specific dataset directory inside the parent directory. 
+
+If the OASIS dataset was located in /path/to/all/my/datasets/specific_dataset123 the command should be:
+`yucca_convert_task -t Task001_OASIS -p /path/to/all/my/datasets -d specific_dataset123`
+
+# Preprocessing
+
+The `yucca_preprocess` CLI invokes the [`run_preprocessing.py`](yucca/run/run_preprocessing.py) script.
+For help and all the available arguments see the output of the `-h` flag below.
+
+```console
+usage: yucca_preprocess [-h] -t TASK [-pl PL] [-pr PR] [-v V] [--ensemble] [--disable_sanity_checks DISABLE_SANITY_CHECKS]
+
+options:
+  -h, --help            show this help message and exit
+  -t TASK, --task TASK  Name of the task to preprocess. Should be of format: TaskXXX_MYTASK
+  -pl PL                Experiment Planner Class to employ. Defaults to the YuccaPlanner
+  -pr PR                Preprocessor Class to employ. Defaults to the YuccaPreprocessor, but can be YuccaPreprocessor_CLS for classification tasks
+  -v V                  Designate target view or orientation to obtain with transposition. Standard settings will handle this for you, but use this to manually specify. Can be 'X', 'Y' or 'Z'
+  --ensemble            Used to initialize data preprocessing for ensemble/2.5D training
+  --disable_sanity_checks DISABLE_SANITY_CHECKS
+                        Enable or disable sanity checks
+```
+
+**-t**, **-pl** and **-pr** are covered in the front page [ReadMe](/yucca/README.md#preprocessing).
+
+**-v**: Used to transpose images to a different orientation. Primarily used to train 2D models on a specific orientation.
+**--ensemble**: Used to automatically preprocess 3 versions of the dataset using the X, Y and Z views. Can be manually obtained by preprocessing the dataset thrice with `-v X`, `-v Y` and `-v Z`.
+**--disable_sanity_checks**: should only be used if you are aware something will violate sanity checks, but you want to still continue.
+
+Internally, the `yucca_preprocess` command calls a planner and preprocessor class.
+Initially, the appropriate planner is called. This is by default the [`YuccaPlanner`](yucca/yucca/planning/YuccaPlanner.py). The planner first collects dataset statistics can be used during preprocessing. These are saved in a `dataset_properties.pkl` file. Then, it specifies _what_ will happen during preprocessing. This includes the normalization operation, target spacing or size/resolution and orientation.
+
+Afterwards, the preprocessor is called. This is by default the [`YuccaPreprocessor`](yucca/yucca/preprocessing/YuccaPreprocessor.py). This preprocesses training data according to the operations and values supplied by planner. As such the preprocessor should very rarely be changed, while the planner will often be changed to employ alternative preprocessing schemes.
+
+# Training
+
+The `yucca_train` CLI invokes the [`run_training.py`](yucca/run/run_training.py) script.
+For help and all the available arguments see the output of the `-h` flag below.
+
+```console
+> yucca_train -h
+usage: yucca_train [-h] [-t TASK] [-d D] [-m M] [-man MAN] [-pl PL] [--disable_logging] [--ds] [--epochs EPOCHS] [--experiment EXPERIMENT] [--loss LOSS] [--lr LR] [--mom MOM] [--new_version]
+                   [--patch_size PATCH_SIZE] [--precision PRECISION] [--profile] [--split_idx SPLIT_IDX] [--split_data_method SPLIT_DATA_METHOD] [--split_data_param SPLIT_DATA_PARAM]
+                   [--train_batches_per_step TRAIN_BATCHES_PER_STEP] [--val_batches_per_step VAL_BATCHES_PER_STEP]
+
+options:
+  -h, --help            show this help message and exit
+  -t TASK, --task TASK  Name of the task used for training. The data should already be preprocessed using yucca_preprocessArgument should be of format: TaskXXX_MYTASK
+  -d D                  Dimensionality of the Model. Can be 3D or 2D. Defaults to 3D. Note that this will always be 2D if ensemble is enabled.
+  -m M                  Model Architecture. Should be one of MultiResUNet or UNet Note that this is case sensitive. Defaults to the standard UNet.
+  -man MAN              Manager Class to be used. Defaults to the basic YuccaManager
+  -pl PL                Plan ID to be used. This specifies which plan and preprocessed data to use for training on the given task. Defaults to the YuccaPlanne folder
+  --disable_logging     disable logging.
+  --ds                  Used to enable deep supervision
+  --epochs EPOCHS       Used to specify the number of epochs for training. Default is 1000
+  --experiment EXPERIMENT
+                        A name for the experiment being performed, with no spaces.
+  --loss LOSS           Should only be used to employ alternative Loss Function
+  --lr LR               Should only be used to employ alternative Learning Rate.
+  --mom MOM             Should only be used to employ alternative Momentum.
+  --new_version         Start a new version, instead of continuing from the most recent.
+  --patch_size PATCH_SIZE
+                        Use your own patch_size. Example: if 32 is provided and the model is 3D we will use patch size (32, 32, 32). Can also be min, max or mean.
+  --precision PRECISION
+  --profile             Enable profiling.
+  --split_idx SPLIT_IDX
+                        idx of splits to use for training.
+  --split_data_method SPLIT_DATA_METHOD
+                        Specify splitting method. Either kfold, simple_train_val_split
+  --split_data_param SPLIT_DATA_PARAM
+                        Specify the parameter for the selected split method. For KFold use an int, for simple_split use a float between 0.0-1.0.
+  --train_batches_per_step TRAIN_BATCHES_PER_STEP
+  --val_batches_per_step VAL_BATCHES_PER_STEP
+```
+
+**-t**, **-d**, **-m**, **-man** and **-pl** are covered in the front page [ReadMe](/yucca/README.md#training).
+
+**--disable_logging**: Disables logging to WandB and a local logfile. The hparams.yaml will still be saved for experiment inspection and reproducibility.
+**--ds**: Enables deep supervision. Note that not all models support this. Currently supported is `UNet`.
+**--epochs**: Used to change the number of epochs to train for. 
+**--experiment**: Used to change the name of the experiment. This can be useful to sort runs in WandB by specific keys.
+**--loss**: Used to change the loss functions. This is mainly intended to be for experimental purposes. For permanent solutions create a specific Manager for the experiment.
+**--lr**: Used to change the learning rate. This is mainly intended to be for experimental purposes. For permanent solutions create a specific Manager for the experiment.
+**--mom**: Used to change the momentum. This is mainly intended to be for experimental purposes. For permanent solutions create a specific Manager for the experiment.
+**--patch_size**: Used to manually specify a patch size rather than letting Yucca calculate a suitable patch size for the dataset.
+**--precision**: Used to specify which precision the model should be trained with.
+**--profile**: Used to enable profiling for more in-depth debugging.
+**--split_idx**: Used to specify which fold/split to use for training. This is almost exclusively used for K-Fold splits.
+**--split_data_method**: Used to specify which splitting method to use for training. 
+**--split_data_param**: Used to specify the param used for the split method.
+**--train_batches_per_step**: Used to specify how many batches are trained on per step. Defaults to 250.
+**--train_batches_per_step**: Used to specify how many batches are validated on per step. Defaults to 50.
+
+An example of training on a task called `Task002_NotBrains`, using a 2D `MultiResUnet` with the `YuccaManager_NoPatches` and `YuccaPlanner_224x224` on fold 3 of a 5-Fold split:
+```
+> yucca_train -t Task002_NotBrains -m MultiResUNet -d 2D -man YuccaManager_NoPatches -pl YuccaPlanner_224x224 -f 3
+```
+
+# Inference
+
+
+The `yucca_inference` CLI invokes the [`run_inference.py`](yucca/run/run_inference.py) script.
+For help and all the available arguments see the output of the `-h` flag below.
+
+```console
+> yucca_inference -h
+usage: yucca_inference [-h] -s S -t T [-d D] [-m M] [-man MAN] [-pl PL] [-chk CHECKPOINT] [--disable_tta] [--experiment EXPERIMENT] [--no_eval] [--predict_train] [--profile] [--save_softmax] [--split_idx SPLIT_IDX]
+                       [--split_data_method SPLIT_DATA_METHOD] [--split_data_param SPLIT_DATA_PARAM] [--version VERSION]
+
+options:
+  -h, --help            show this help message and exit
+  -s S                  Name of the source task i.e. what the model is trained on. Should be of format: TaskXXX_MYTASK
+  -t T                  Name of the target task i.e. the data to be predicted. Should be of format: TaskXXX_MYTASK
+  -d D                  2D or 3D model. Defaults to 3D.
+  -m M                  Model Architecture. Defaults to UNet.
+  -man MAN              Full name of Trainer Class. e.g. 'YuccaTrainer_DCE' or 'YuccaTrainer'. Defaults to YuccaTrainer.
+  -pl PL                Planner. Defaults to YuccaPlanner
+  -chk CHECKPOINT, --checkpoint CHECKPOINT
+                        Checkpoint to use for inference. Defaults to model_best.
+  --disable_tta         Used to disable test-time augmentations (mirroring)
+  --experiment EXPERIMENT
+                        A name for the experiment being performed, wiht no spaces.
+  --no_eval             Disable evaluation and creation of metrics file (result.json)
+  --predict_train       Predict on the training set. Useful for debugging.
+  --profile             Used to enable inference profiling
+  --save_softmax        Save softmax outputs. Required for softmax fusion.
+  --split_idx SPLIT_IDX
+                        idx of splits to use for training.
+  --split_data_method SPLIT_DATA_METHOD
+                        Specify splitting method. Either kfold, simple_train_val_split
+  --split_data_param SPLIT_DATA_PARAM
+                        Specify the parameter for the selected split method. For KFold use an int, for simple_split use a float between 0.0-1.0.
+  --version VERSION     Version to use for inference. Defaults to the newest version.
+```
+
+**-s**, **-t**, **-d**, **-m**, **-man** and **-pl** are covered in the front page [ReadMe](/yucca/README.md#inference).
+
+**--checkpoint**: Used to specify which checkpoint should be used to generate the predictions. Defaults to the "best.ckpt".
+**--disable_tta**: Disables Test-Time augmentations. This only has an impact for models eligible for Test-Time augmentations. So far this is limited to models trained with the Mirroring augmentations enabled.
+**--experiment**: Used to specify if non-default experiment name was used in training.
+**--no_eval**: Disables evaluation. Useful to avoid running into errors when predicting test sets without labels.
+**--predict_train**: Used to predict the train-set of the target task. Useful for debugging, to test if a model trained on the train set X performs as well as we would expect on the train set of X 
+**--profile**: Enables inference profiling for in-depth debugging
+**--save_softmax**: Enables saving softmax outputs rather than argmaxed predictions
+**--split_idx**: Used to specify if non-default split idx was used to train the model.
+**--split_data_method**: Used to specify if non-default split method was used to train the model.
+**--split_data_param**: Used to specify if non-default split param was used to train the model.
+**--version**:
\ No newline at end of file
diff --git a/yucca/documentation/tutorials/task_conversion.md b/yucca/documentation/guides/task_conversion.md
similarity index 57%
rename from yucca/documentation/tutorials/task_conversion.md
rename to yucca/documentation/guides/task_conversion.md
index edbe5cab..a15bc85b 100644
--- a/yucca/documentation/tutorials/task_conversion.md
+++ b/yucca/documentation/guides/task_conversion.md
@@ -1,6 +1,6 @@
 # Task Conversion
 
-Yucca uses the data structure presented in the Medical Segmentation Challenge [see @https://arxiv.org/pdf/1902.09063.pdf; https://arxiv.org/pdf/1902.09063.pdf]. This includes naming conventions, directory structures and descriptor files (dataset.json).
+Yucca uses the data structure presented in the Medical Segmentation Challenge [see @https://arxiv.org/pdf/1902.09063.pdf]. This includes naming conventions, directory structures and descriptor files (dataset.json).
 
 # File and Folder Structure
 Yucca reads/writes data from/to four directories specified by the user where the directories contain respectively `raw_data`, `preprocessed_data`, `models` and `results`. The paths to these directories should be specified in your environment variables as seen [here](/yucca/documentation/tutorials/environment_variables.md).
@@ -12,20 +12,22 @@ Yucca expects raw data to be located in subdirectories of the `raw_data` directo
 
 ### Task Names 
 Datasets must be assigned a Task Name of the format `TaskXXX_MYTASK` where `XXX` is a unique 3-digit identifier and `MYTASK` is a freely chosen dataset name. 
-For instance, the OASIS hippocampus segmentation dataset is called `Task001_OASIS`. Which means that Yucca will assume the raw data is found at; `raw_data/Task001_OASIS`
+For instance, the OASIS hippocampus segmentation dataset is called `Task001_OASIS`. Which means that Yucca will assume raw data can be found at; `raw_data/Task001_OASIS`
 
 ### Train/Test Split
-Inside the task directory (e.g. `raw_data/Task001_OASIS`) data should be split into Train and Test splits (subdirectories) in almost all cases. However, to completely avoid any data leakage, Yucca will NOT do this for you. To ensure a clear division between training and testing data Yucca will automatically only train on data placed in subdirectories called `imagesTr` (training). Therefore, you have to save training and testing samples in appropriately named directories. Training images and labels should be in placed in the subdirectories `imagesTr` and `labelsTr` respectively. And, if they exist, testing images and labels should be placed in the subdirectories `imagesTs` and `labelsTs` respectively.
+Inside the task directory (e.g. `raw_data/Task001_OASIS`) data should be split into Train and Test splits (subdirectories) in almost all cases. To completely avoid any data leakage, Yucca will NOT do this for you. To ensure a clear division between training and testing data Yucca will automatically only train on data placed in subdirectories called `imagesTr` (training). Therefore, you have to save training and testing samples in appropriately named directories. Training images and labels should be in placed in the subdirectories `imagesTr` and `labelsTr` respectively. And, if they exist, testing images and labels should be placed in the subdirectories `imagesTs` and `labelsTs` respectively.
 
 ### File Names
-Image files must be named according to the format `ID_MODALITY.nii.gz` where `ID` is replaced by e.g. `sub_01` and `MODALITY` is replaced by the appropriate modality identifier.
-If the dataset only contains a single modality (e.g. T1 MR images) all files are simply suffixed with the same modality identifier `000`.
-If the dataset contains multiple modalities each sequence should be assigned a unique modality suffix. For example, for a dataset containining T1 and CT images, the T1 images could be assigned the `000` suffix and the CT images could be suffixed by `001`.
-Labels are stored WITHOUT the modality identifier.
+Image files must be named according to the format `ID_MODALITY.EXTENSION`.
+- `ID` is the unique case identifier, such as `sub_01` or `image_4125`.
+- `MODALITY` is a 3 digit suffix that identifies the modality of an **image**. For example, the imaging technique (e.g. T1, CT or ultrasound) or timepoint. Yucca uses this information to (1) normalize each modality individually and (2) concatenate cases (in the channel dimension) that have multiple images. If the dataset only contains one modality (or you wish to treat all modalities as one) simply suffix all images with the modality identifier `000` - this is generally the approach. If the dataset contains multiple modalities each should be assigned a unique modality suffix. For example, for a medical imaging dataset containing T1 and CT images for all labels, the T1 images could be assigned by `000` and the CT images could be suffixed by `001`. Note that any **labels** are stored without modality identifiers.
+- `EXTENSION` is any of the supported file extensions. Currently `.nii.gz` and `.png` is supported for the imagesTr and ImagesTs folders. For the labelsTr and labelsTs folders `.nii.gz`, `.png` and `.txt` are supported.
 
-### Example Directory Structure (for a multimodal dataset):
+### Example Directory Structure for a multimodal segmentation dataset:
 This is how the contents of your `raw_data` folder could look:
 - Note that we still only have 1 label (segmentation) per subject, even though each subject may have multiple images (e.g. both CT and MRI scans).
+- If this was a classification dataset the labelsTr and labelsTs folders should be populated with `.txt` files containing the class(es) of the case.
+- If this was an unsupervised dataset the labelsTr and labelsTs folder should be empty.
 ```
 raw_data/
 ├── Task001_OASIS/
@@ -55,7 +57,6 @@ raw_data/
 ### Task Conversion Scripts
 Task conversion can be performed by running the [`run_task_conversion.py`](/yucca/yucca/run/run_task_conversion.py) which executes a task conversion according to one of the files in `yucca/yucca/task_conversion`. For some tasks a task conversion file already exists (e.g. [`Task001_OASIS`](/yucca/yucca/task_conversion/Task001_OASIS.py)) but otherwise a task conversion file must be created. A template for task conversion files can be found [here](/yucca/yucca/task_conversion/template.py).
 
-
 # Preprocessing
 
 **Registration**:
@@ -65,19 +66,3 @@ Each image(s)/label pair must be properly registered and shaped. This implies id
 Ensure that only the correct labels are present in the ground truth segmentations.
 
 In some cases each token of a given type is assigned a unique label. E.g. in a microbleed segmentation/detection task each bleed in an image is labeled with incrementing integers. This is often highly undesirable as the segmentation network will treat each label as unique types rather than tokens of the same type.
-
-Changing all non-background labels to a single label can be achieved using:
-```
-# SITK METHOD
-      import SimpleITK as sitk
-      segmentation = sitk.ReadImage('path/to/seg01.nii.gz')
-      label = sitk.Mask(label, sitk.Not(label != 0), 1)
-
-# NIBABEL METHOD
-      import nibabel as nib
-      segmentation = nib.load('path/to/seg01.nii.gz')
-      data = segmentation.get_fdata()
-      data[data != 0] = 1
-      segmentation = nib.Nifti1Image(data, segmentation.affine, segmentation.header)
-```
-However, beware to not use this in cases where it is desirable to have multiple labels (e.g. for a left and right hippocampus or white and gray matter)
diff --git a/yucca/documentation/tutorials/changing_parameters.md b/yucca/documentation/tutorials/changing_parameters.md
deleted file mode 100644
index 58ff4335..00000000
--- a/yucca/documentation/tutorials/changing_parameters.md
+++ /dev/null
@@ -1,287 +0,0 @@
-# Table of Contents
-- [Guide to Changing Yucca Parameters](#guide-to-changing-yucca-parameters)
-- [Subclassing](#subclassing)
-- [Preprocessing](#preprocessing)
-  * [Spacing](#spacing)
-  * [Orientation](#orientation)
-  * [Normalization](#normalization)
-- [Training](#training)
-  * [Data Augmentation](#data-augmentation)
-  * [Data Splits](#data-splits)
-  * [Learning Rate](#learning-rate)
-  * [Learning Rate Scheduler](#learning-rate-scheduler)
-  * [Loss Function](#loss-function)
-  * [Model Architecture](#model-architecture)
-  * [Model Dimensionality](#model-dimensionality)
-  * [Momentum](#momentum)
-  * [Optimizer](#optimizer)
-- [Inference](#inference)
-  * [Evaluation](#evaluation)
-  * [Fusion](#fusion)
-
-
-# Guide to Changing Yucca Parameters
-## Subclassing
-Changing parameters in Yucca is generally achieved using subclasses. (1) Subclass the class defining the parameter of interest, (2) change the variable to the desired value and (3) create a new .py file in the (sub)directory of the parent class.
-
-E.g. to lower the starting Learning Rate we subclass YuccaTrainerV2 - the default class responsible for handling model training, and change the variable \_DEFAULT\_STARTING\_LR variable from 1e-3 to 1e-5.
-
-We call this new trainer "YuccaTrainerV2_LowerLR" and save it as "YuccaTrainerV2_LowerLR.py" in the /yucca/training/trainers directory as this is where the Parent Class is located. Alternatively it can be saved in a subdirectory of the directory of the parent class e.g. /yucca/training/trainers/lr. 
-
-```
-from yucca.training.trainers.YuccaTrainerV2 import YuccaTrainerV2
-
-class YuccaTrainerV2_1e5(YuccaTrainerV2):
-    def __init__(self, model, model_dimensions: str, task: str, folds: str | int, plan_id: str,
-                 starting_lr: float = None, loss_fn: str = None, momentum: float = None,
-                 continue_training: bool = False):
-        super().__init__(model, model_dimensions, task, folds, plan_id, starting_lr, 
-                         loss_fn, momentum, continue_training)
-        self._DEFAULT_STARTING_LR = 1e-5
-        
-```
-
-# Preprocessing
-Unless otherwise mentioned, preprocessing variables and functions are handled by the YuccaPlanners. For optimal results, it is advisable to subclass the default planner when applying changes.
-
-**Default Planner Class: [YuccaPlannerV2](/yucca/planning/YuccaPlannerV2.py)**
-
-## Spacing
-Parent: default planner class
-
-Function: *determine_spacing*
-
-E.g. if a fixed spacing of [0.5, 0.5, 1.] is desired:
-
-```
-def determine_spacing(self):
-    return [0.5, 0.5, 1.]
-```
-
-## Orientation
-Parent: default planner class
-
-Variable 1: *self.target_coordinate_system*
-- used to ensure uniform starting orientations. This is applied before any transposition. NOTE: This will only be applied to samples with valid nifti headers (either using qform or sform codes).
-
-Variable 2: *self.transpose_forward* 
-- used to transpose samples from the starting position to a target orientation.
-
-Variable 3: *self.transpose_backward*
-- used to transpose samples back from the target orientation to the starting position. This should only be used if samples are transposed by *transpose_forward*. This is applied during inference to revert any transform applied by *transpose_forward*.
-
-For example, if it is desired to first reorient all samples to 'LPS' as the starting position, and then transpose them from [x, y, z] to [z, x, y] during training so it effectively becomes SLP, and finally back from [z, x, y] to [x, y, z] in inference do:
-```
-self.target_coordinate_system = 'LPS'
-self.transpose_forward = [2, 0, 1]
-self.transpose_backward = [1, 2, 0]
-```
-
-By default *transpose_forward* and *transpose_backward* are both = [0, 1, 2] which means samples are NOT transposed.
-This means 2D models are trained on the sagittal view (because images are always sliced in the first dimension, i.e. image[slice, :, :]).
-The YuccaPlannerY and YuccaPlannerZ are existing YuccaPlanner implementations designed to train models on the Coronal and Axial views, respectively.
-
-## Normalization
-Parent: default planner class
-
-Variable: *self.norm_op* 
-
-To find currently implemented normalization operations see the [normalizer function](/yucca/preprocessing/normalization.py). 
-
-For example if 'minmax' (otherwise known as 0-1 normalization) is desired:
-```
-self.norm_op = 'minmax'
-```
-
-# Training
-Unless otherwise mentioned, preprocessing variables and functions are handled by the YuccaTrainers. For optimal results, it is advisable to subclass the default class when applying changes.
-
-**Default Trainer Class: [YuccaTrainerV2](/yucca/training/trainers/YuccaTrainerV2.py)**
-
-## Data Augmentation
-Parent: default trainer class
-
-Method: *setup_DA*
-Variable: *self.augmentation_parameters*
-
-Changing the data augmentation scheme can be done in two ways. The first method is suitable for minor changes. The second is suitable for major changes.
-
-To make minor changes you should subclass the parent and redefine the *setup_DA* method. Use the super() function to call the parent *setup_DA* function first, and then change the appropriate parameters.
-
-```
-def setup_DA(self):
-    super().setup_DA()
-    self.augmentation_parameters["do_ElasticDeform"] = False
-```
-
-Refer to the [default_augmentation_params](/yucca/training/augmentation/default_augmentation_params.py) for all valid arguments.
-
-To make major changes you should (1) subclass the parent and redefine the *setup_DA* method and (2) create a new dictionary of augmentation parameters with the same keys as the [default_augmentation_params](/yucca/training/augmentation/default_augmentation_params.py) (3) change the desired values (4) save this as a new .py file in the /yucca/training/augmentation folder (5) import and assign your new dictionary to *self.augmentation_parameters* in your subclassed trainer:
-
-```
-from yucca.training.augmentation.my_new_params import MyNew_3D_params, MyNew_2D_params
-
-def setup_DA(self):
-    if self.model_dimensions == '3D':
-        self.augmentation_parameters = MyNew_3D_params
-    if self.model_dimensions in ['2D', '25D']:
-        self.augmentation_parameters = MyNew_2D_params
-```
-
-## Data Splits
-Parent: default trainer class
-
-Method: *split_data*
-
-NOTE: Do not confuse this with the train-test splits. These must be handled in [Task Conversion](/yucca/documentation/tutorials/task_conversion.md).
-
-By default Training-Validation data splits are created by the *split_data* method the first time a model is trained on a given task. The method randomly partitions the data into 5 equal parts. Subsequently, 5 train-val splits are created by withholding each of the parts as validation data and combining the remaning four parts into training data, equating to a 80%/20% split. Although these splits are randomly generated, each trainer uses a fixed random seed for reproducibility. 
-
-This means, for any dataset it's partitioned into five parts [0, 1, 2, 3, 4], which we use to create 5 splits:
-```
-[
-    {train: [1, 2, 3, 4], val: [0]}, 
-    {train: [0, 2, 3, 4], val: [1]}, 
-    {train: [0, 1, 3, 4], val: [2]}, 
-    {train: [0, 1, 2, 4], val: [3]}, 
-    {train: [0, 1, 2, 3], val: [4]}, 
-]
-```
-To specify which split to train on, use the "-f" flag followed by an integer in [0, 4]. By default split 0 ({train: [1, 2, 3, 4], val: [0]}) is used. 
-
-If you wish to use predefined splits, you have to manufacture a splits file and save it in the folder of the task's preprocessed data (e.g. "/path/to/YuccaData/yucca_preprocessed/TaskXXX_MyTask/splits.pkl"). The Trainer will only create the random splits if no "splits.pkl" file is already present in the preprocessed folder. Therefore, manually placing one there will effectively block the Trainer from creating a new splits file.
-
-When doing this, the contents of the manufactured splits file should be a list containing a dictionary:
-```
-[
-    {train: [case1, case2, case3], val: [case4, case5]},
-]
-```
-Which is then selected with the "-f 0" flag in *yucca_train* and *yucca_inference*.
-
-If you wish to change the method you should subclass the parent class and redefine the *split_data* method to use the desired functions or split ratios.
-
-## Learning Rate
-Parent: default trainer class
-
-Variable: self.\_DEFAULT\_STARTING\_LR 
-
-Subclass the parent and change the variable to the desired value using scientific notation.
-
-```
-from yucca.training.trainers.YuccaTrainerV2 import YuccaTrainerV2
-
-class YuccaTrainerV2_LowerLR(YuccaTrainerV2):
-    def __init__(self, model, model_dimensions: str, task: str, folds: str | int, plan_id: str,
-                 starting_lr: float = None, loss_fn: str = None, momentum: float = None,
-                 continue_training: bool = False):
-        super().__init__(model, model_dimensions, task, folds, plan_id, starting_lr, 
-                         loss_fn, momentum, continue_training)
-        self._DEFAULT_STARTING_LR = 1e-5
-```
-
-Can also be changed using *yucca_train* --lr flag.
-
-## Learning Rate Scheduler
-For an illustration of how a wide selection of Torch.Optim LR Schedulers work see the [LR Scheduler Illustration Notebook](/yucca/documentation/illustrations/learning_rate_schedulers.ipynb).
-The notebook illustrates the effect of the scheduling algorithms with different parameters. 
-
-Parent: default trainer class
-
-Variable 1: self.lr\_scheduler
-- Used to determine the LR Scheduler CLASS
-Variable 2: self.lr\_scheduler\_kwargs
-- Used to supply arguments to the chosen scheduler. key,value pairs irrelevant to the scheduler class will be filtered out automatically.
-Subclass the parent and change the variables to the desired values.
-
-```
-from yucca.training.trainers.YuccaTrainerV2 import YuccaTrainerV2
-from torch import optim
-
-class YuccaTrainerV2_StepLRS(YuccaTrainerV2):
-    def __init__(self, model, model_dimensions: str, task: str, folds: str | int, plan_id: str,
-                 starting_lr: float = None, loss_fn: str = None, momentum: float = None,
-                 continue_training: bool = False):
-        super().__init__(model, model_dimensions, task, folds, plan_id, starting_lr, 
-                         loss_fn, momentum, continue_training)
-        self.lr_scheduler = optim.lr_scheduler.StepLR
-        self.lr_scheduler_kwargs = {'step_size':50, 'gamma':0.9}
-```
-
-## Loss Function
-Parent: default trainer class
-
-Variable: self.\_DEFAULT\_LOSS
-
-Subclass the parent and change the variable to the desired loss class. The loss class must be saved in /yucca/training/loss_functions and be a subclass of nn.Module.
-
-```
-from yucca.training.trainers.YuccaTrainerV2 import YuccaTrainerV2
-from yucca.training.loss_functions import NLL
-
-class YuccaTrainerV2_NLL(YuccaTrainerV2):
-    def __init__(self, model, model_dimensions: str, task: str, folds: str | int, plan_id: str,
-                 starting_lr: float = None, loss_fn: str = None, momentum: float = None,
-                 continue_training: bool = False):
-        super().__init__(model, model_dimensions, task, folds, plan_id, starting_lr, 
-                         loss_fn, momentum, continue_training)
-        self._DEFAULT_LOSS = NLL
-```
-
-Can also be changed using *yucca_train* --loss flag.
-
-## Model Architecture
-Changing architecture is entirely handled in the command line. In both training and inference model architecture is specified using the -m flag. Currently supported is: "UNet", "MultiResUnet", "UNetR" and "UXNet".
-
-## Model Dimensionality
-Changing model dimensionality is entirely handled in the command line. In both preprocessing, training and inference dimension is specified using the -d flag. Currently supported is: "2D" and "3D".
-
-## Momentum
-
-Parent: default trainer class
-
-Variable: self.\_DEFAULT\_MOMENTUM
-
-Subclass the parent and change the variable to the desired value.
-
-```
-from yucca.training.trainers.YuccaTrainerV2 import YuccaTrainerV2
-
-class YuccaTrainerV2_mom95(YuccaTrainerV2):
-    def __init__(self, model, model_dimensions: str, task: str, folds: str | int, plan_id: str,
-                 starting_lr: float = None, loss_fn: str = None, momentum: float = None,
-                 continue_training: bool = False):
-        super().__init__(model, model_dimensions, task, folds, plan_id, starting_lr, 
-                         loss_fn, momentum, continue_training)
-        self._DEFAULT_MOMENTUM= 0.95
-```
-
-Can also be changed using *yucca_train* --mom flag.
-
-## Optimizer
-
-Parent: default trainer class
-
-Variable: self.optim
-
-Subclass the parent and change the variable to the desired torch optimizer class.
-
-```
-from yucca.training.trainers.YuccaTrainerV2 import YuccaTrainerV2
-from torch import optim
-
-class YuccaTrainerV2_Adam(YuccaTrainerV2):
-    def __init__(self, model, model_dimensions: str, task: str, folds: str | int, plan_id: str,
-                 starting_lr: float = None, loss_fn: str = None, momentum: float = None,
-                 continue_training: bool = False):
-        super().__init__(model, model_dimensions, task, folds, plan_id, starting_lr, 
-                         loss_fn, momentum, continue_training)
-        self.optim = optim.Adam
-```
-
-# Inference
-Changing inference parameters not implemented currently.
-
-## Evaluation
-## Pixel/Object
-## Fusion
diff --git a/yucca/evaluation/loggers.py b/yucca/evaluation/loggers.py
index 369417bb..0cb9ac0e 100644
--- a/yucca/evaluation/loggers.py
+++ b/yucca/evaluation/loggers.py
@@ -1,5 +1,6 @@
 import sys
 import os
+import logging
 from argparse import Namespace
 from lightning.pytorch.loggers.logger import Logger
 from pytorch_lightning.utilities.rank_zero import rank_zero_only
@@ -37,6 +38,11 @@ def __init__(
         self.hparams: Dict[str, Any] = {}
         self.NAME_HPARAMS_FILE = "hparams.yaml"
 
+        if self.disable_logging is False:
+            if self.log_file is None:
+                self.create_logfile()
+            self.duplicate_console_out_to_log_file(self.log_file)
+
     @property
     def name(self):
         return self._name
@@ -70,11 +76,18 @@ def create_logfile(self):
         )
         with open(self.log_file, "w") as f:
             f.write("Starting model training")
-            print("Starting model training \n" f'{"log file:":20} {self.log_file} \n')
+            logging.info("Starting model training \n" f'{"log file:":20} {self.log_file} \n')
             f.write("\n")
             f.write(f'{"log file:":20} {self.log_file}')
             f.write("\n")
 
+    @rank_zero_only
+    def duplicate_console_out_to_log_file(self, log_file):
+        # Add the log_file as a duplicate handler of lightning outputs
+        logging.getLogger("lightning.pytorch").addHandler(logging.FileHandler(log_file))
+        # Add the log_file as a duplicate handler of lightning outputs
+        logging.getLogger().addHandler(logging.FileHandler(log_file))
+
     @rank_zero_only
     def log_hyperparams(self, params: Union[Dict[str, Any], Namespace]) -> None:  # type: ignore[override]
         params = _convert_params(params)
@@ -83,9 +96,7 @@ def log_hyperparams(self, params: Union[Dict[str, Any], Namespace]) -> None:  #
     @rank_zero_only
     def log_metrics(self, metrics, step):
         if self.disable_logging:
-            pass
-        if self.log_file is None:
-            self.create_logfile()
+            return
         # metrics is a dictionary of metric names and values
         # your code to record metrics goes here
         t = strftime("%Y_%m_%d_%H_%M_%S", localtime())
diff --git a/yucca/image_processing/transforms/BiasField.py b/yucca/image_processing/transforms/BiasField.py
index bdf09581..170c3f4b 100644
--- a/yucca/image_processing/transforms/BiasField.py
+++ b/yucca/image_processing/transforms/BiasField.py
@@ -3,12 +3,6 @@
 
 
 class BiasField(YuccaTransform):
-    """
-    variables in DIKU_3D_augmentation_params:
-        do_biasField
-        biasField_p_per_sample
-    """
-
     def __init__(self, data_key="image", p_per_sample=1):
         self.data_key = data_key
         self.p_per_sample = p_per_sample
diff --git a/yucca/image_processing/transforms/Blur.py b/yucca/image_processing/transforms/Blur.py
index d57a4125..e3280526 100644
--- a/yucca/image_processing/transforms/Blur.py
+++ b/yucca/image_processing/transforms/Blur.py
@@ -5,21 +5,6 @@
 
 
 class Blur(YuccaTransform):
-    """
-    WRAPPER FOR NNUNET AUGMENT GAMMA: https://github.com/MIC-DKFZ/batchgenerators/blob/8822a08a7dbfa4986db014e6a74b040778164ca6/batchgenerators/augmentations/color_augmentations.py
-
-    Augments by changing 'gamma' of the image (same as gamma correction in photos or computer monitors
-
-    :param gamma_range: range to sample gamma from. If one value is smaller than 1 and the other one is
-    larger then half the samples will have gamma <1 and the other >1 (in the inverval that was specified).
-    Tuple of float. If one value is < 1 and the other > 1 then half the images will be augmented with gamma values
-    smaller than 1 and the other half with > 1
-    :param invert_image: whether to invert the image before applying gamma augmentation
-    :param retain_stats: Gamma transformation will alter the mean and std of the data in the patch. If retain_stats=True,
-    the data will be transformed to match the mean and standard deviation before gamma augmentation. retain_stats
-    can also be callable (signature retain_stats() -> bool)
-    """
-
     def __init__(self, data_key="image", p_per_sample=1, p_per_channel=0.5, sigma=(0.5, 1.0)):
         self.data_key = data_key
         self.p_per_sample = p_per_sample
diff --git a/yucca/image_processing/transforms/CopyImageToSeg.py b/yucca/image_processing/transforms/CopyImageToSeg.py
index a0215b8e..f6025cae 100644
--- a/yucca/image_processing/transforms/CopyImageToSeg.py
+++ b/yucca/image_processing/transforms/CopyImageToSeg.py
@@ -2,13 +2,6 @@
 
 
 class CopyImageToSeg(YuccaTransform):
-    """
-    variables in CopyImageToSeg
-    data_key
-    label_key
-
-    """
-
     def __init__(self, copy=False, data_key="image", label_key="label"):
         self.copy = copy
         self.data_key = data_key
diff --git a/yucca/image_processing/transforms/Ghosting.py b/yucca/image_processing/transforms/Ghosting.py
index 6c765289..2cc5084d 100644
--- a/yucca/image_processing/transforms/Ghosting.py
+++ b/yucca/image_processing/transforms/Ghosting.py
@@ -4,15 +4,6 @@
 
 
 class MotionGhosting(YuccaTransform):
-    """
-    variables in DIKU_3D_augmentation_params:
-        do_motionGhosting
-        motionGhosting_p_per_sample
-        motionGhosting_alpha
-        motionGhosting_numReps
-        motionGhosting_axes
-    """
-
     def __init__(
         self,
         data_key="image",
diff --git a/yucca/image_processing/transforms/Mirror.py b/yucca/image_processing/transforms/Mirror.py
index 53786334..f5f0e6b6 100644
--- a/yucca/image_processing/transforms/Mirror.py
+++ b/yucca/image_processing/transforms/Mirror.py
@@ -3,14 +3,6 @@
 
 
 class Mirror(YuccaTransform):
-    """
-    variables in DIKU_3D_augmentation_params:
-        do_multiplicativeNoise
-        multiplicativeNoise_p_per_sample
-        multiplicativeNoise_mean
-        multiplicativeNoise_sigma
-    """
-
     def __init__(
         self,
         data_key="image",
diff --git a/yucca/image_processing/transforms/Noise.py b/yucca/image_processing/transforms/Noise.py
index 14446a85..b7b987ed 100644
--- a/yucca/image_processing/transforms/Noise.py
+++ b/yucca/image_processing/transforms/Noise.py
@@ -4,14 +4,6 @@
 
 
 class AdditiveNoise(YuccaTransform):
-    """
-    variables in DIKU_3D_augmentation_params:
-        do_additiveNoise
-        additiveNoise_p_per_sample
-        additiveNoise_mean
-        additiveNoise_sigma
-    """
-
     def __init__(self, data_key="image", p_per_sample=1, mean=(0.0, 0.0), sigma=(1e-3, 1e-4)):
         self.data_key = data_key
         self.p_per_sample = p_per_sample
diff --git a/yucca/image_processing/transforms/Ringing.py b/yucca/image_processing/transforms/Ringing.py
index e2bd4774..6ec68204 100644
--- a/yucca/image_processing/transforms/Ringing.py
+++ b/yucca/image_processing/transforms/Ringing.py
@@ -3,14 +3,6 @@
 
 
 class GibbsRinging(YuccaTransform):
-    """
-    variables in DIKU_3D_augmentation_params:
-        do_gibbsRinging
-        gibbsRinging_p_per_sample
-        gibbsRinging_cutFreq
-        gibbsRinging_axes
-    """
-
     def __init__(self, data_key="image", p_per_sample=1, cutFreq=(96, 129), axes=(0, 3)):
         self.data_key = data_key
         self.p_per_sample = p_per_sample
diff --git a/yucca/image_processing/transforms/SimulateLowres.py b/yucca/image_processing/transforms/SimulateLowres.py
index 74912062..145c194b 100644
--- a/yucca/image_processing/transforms/SimulateLowres.py
+++ b/yucca/image_processing/transforms/SimulateLowres.py
@@ -4,8 +4,6 @@
 
 
 class SimulateLowres(YuccaTransform):
-    """ """
-
     def __init__(
         self,
         data_key="image",
diff --git a/yucca/image_processing/transforms/Spatial.py b/yucca/image_processing/transforms/Spatial.py
index 8ddba0fb..36a70a50 100644
--- a/yucca/image_processing/transforms/Spatial.py
+++ b/yucca/image_processing/transforms/Spatial.py
@@ -18,16 +18,6 @@
 
 
 class Spatial(YuccaTransform):
-    """
-    variables in aug_params:
-            do_Rotation
-            Rotation_p_per_sample
-            Rotation_p_per_channel
-            Rotation_x_rot
-            Rotation_y_rot
-            Rotation_z_rot
-    """
-
     def __init__(
         self,
         data_key="image",
diff --git a/yucca/image_processing/transforms/cropping_and_padding.py b/yucca/image_processing/transforms/cropping_and_padding.py
index 16177f29..a4d5e2f6 100644
--- a/yucca/image_processing/transforms/cropping_and_padding.py
+++ b/yucca/image_processing/transforms/cropping_and_padding.py
@@ -4,17 +4,6 @@
 
 
 class CropPad(YuccaTransform):
-    """
-    The possible input for CropPad can be either 2D or 3D data and the output can be either 2D
-    or 3D data. Each dimension is either padded or cropped to the desired patch size.
-    For 3D input to 3D output and 2D input to 2D output each dimension is simply
-    either padded or cropped to the desired patch size.
-    For 3D input to 2D output we extract a slice from the first dimension to attain a 2D image.
-    Afterwards the the last 2 dimensions are padded or cropped to the patch size.
-
-    For available modes see: https://numpy.org/doc/stable/reference/generated/numpy.pad.html
-    """
-
     def __init__(
         self,
         data_key="image",
diff --git a/yucca/image_processing/transforms/formatting.py b/yucca/image_processing/transforms/formatting.py
index 472018dd..6faa738f 100644
--- a/yucca/image_processing/transforms/formatting.py
+++ b/yucca/image_processing/transforms/formatting.py
@@ -4,10 +4,6 @@
 
 
 class RemoveSegChannelAxis(YuccaTransform):
-    """
-    Basically a wrapper for np.squeeze
-    """
-
     def __init__(self, label_key="label", channel_to_remove=1):
         self.label_key = label_key
         self.channel = channel_to_remove
diff --git a/yucca/network_architectures/networks/YuccaNet.py b/yucca/network_architectures/networks/YuccaNet.py
index 6a73e5ef..babca847 100644
--- a/yucca/network_architectures/networks/YuccaNet.py
+++ b/yucca/network_architectures/networks/YuccaNet.py
@@ -76,7 +76,7 @@ def _sliding_window_predict3D(self, data, patch_size, overlap):
         """
         canvas = torch.zeros(
             (1, self.num_classes, *data.shape[2:]),
-            device=torch.device(get_available_device),
+            device=torch.device(get_available_device()),
         )
 
         x_steps, y_steps, z_steps = get_steps_for_sliding_window(data.shape[2:], patch_size, overlap)
@@ -96,7 +96,7 @@ def _sliding_window_predict2D(self, data, patch_size, overlap):
         """
         canvas = torch.zeros(
             (1, self.num_classes, *data.shape[2:]),
-            device=torch.device(get_available_device),
+            device=torch.device(get_available_device()),
         )
 
         px, py = patch_size
diff --git a/yucca/planning/ClassificationPlanner.py b/yucca/planning/ClassificationPlanner.py
new file mode 100644
index 00000000..2e5a6d3b
--- /dev/null
+++ b/yucca/planning/ClassificationPlanner.py
@@ -0,0 +1,8 @@
+from yucca.planning.YuccaPlanner import YuccaPlanner
+
+
+class ClassificationPlanner(YuccaPlanner):
+    def __init__(self, task, preprocessor=None, threads=2, disable_unittests=False, view=None):
+        super().__init__(task, preprocessor, threads, disable_unittests, view)
+        self.name = str(self.__class__.__name__) + str(view or "")
+        self.preprocessor = "ClassificationPreprocessor"
diff --git a/yucca/preprocessing/ClassificationPreprocessor.py b/yucca/preprocessing/ClassificationPreprocessor.py
index 8fe81153..dca134d0 100644
--- a/yucca/preprocessing/ClassificationPreprocessor.py
+++ b/yucca/preprocessing/ClassificationPreprocessor.py
@@ -30,6 +30,7 @@ def preprocess_train_subject(self, subject_id):
         images[0] = images[0].T
 
         logging.info(
+            f"Preprocessed case: {subject_id} \n"
             f"size before: {image_props['original_size']} size after: {image_props['new_size']} \n"
             f"spacing before: {image_props['original_spacing']} spacing after: {image_props['new_spacing']} \n"
             f"Saving {subject_id} in {arraypath} \n"
diff --git a/yucca/preprocessing/UnsupervisedPreprocessor.py b/yucca/preprocessing/UnsupervisedPreprocessor.py
index 9188d2bb..a8e01cbf 100644
--- a/yucca/preprocessing/UnsupervisedPreprocessor.py
+++ b/yucca/preprocessing/UnsupervisedPreprocessor.py
@@ -41,6 +41,7 @@ def preprocess_train_subject(self, subject_id):
         images = np.array(images)
 
         logging.info(
+            f"Preprocessed case: {subject_id} \n"
             f"size before: {image_props['original_size']} size after: {image_props['new_size']} \n"
             f"spacing before: {image_props['original_spacing']} spacing after: {image_props['new_spacing']} \n"
             f"Saving {subject_id} in {arraypath} \n"
diff --git a/yucca/preprocessing/YuccaPreprocessor.py b/yucca/preprocessing/YuccaPreprocessor.py
index 097efcc4..c2a640d2 100644
--- a/yucca/preprocessing/YuccaPreprocessor.py
+++ b/yucca/preprocessing/YuccaPreprocessor.py
@@ -94,7 +94,9 @@ def initialize_properties(self):
         self.transpose_forward = np.array(self.plans["transpose_forward"], dtype=int)
         self.transpose_backward = np.array(self.plans["transpose_backward"], dtype=int)
         self.target_spacing = self.plans["target_spacing"]
-        self.target_size = np.array(self.plans.get("target_size"), dtype=int) if self.plans.get("target_size") else None
+        self.target_size = (
+            np.array(self.plans.get("target_size"), dtype=int) if self.plans.get("target_size") not in ["null", None] else None
+        )
 
     def run(self):
         self.initialize_properties()
@@ -167,6 +169,7 @@ def preprocess_train_subject(self, subject_id):
         images = np.vstack((np.array(images), np.array(label)[np.newaxis]))
 
         logging.info(
+            f"Preprocessed case: {subject_id} \n"
             f"size before: {image_props['original_size']} size after: {image_props['new_size']} \n"
             f"spacing before: {image_props['original_spacing']} spacing after: {image_props['new_spacing']} \n"
             f"Saving {subject_id} in {arraypath} \n"
@@ -180,7 +183,6 @@ def preprocess_train_subject(self, subject_id):
 
     def _preprocess_train_subject(self, subject_id, label_exists: bool, preprocess_label: bool):
         image_props = {}
-        logging.info(f"Preprocessing: {subject_id}")
 
         # First find relevant images by their paths and save them in the image property pickle
         # Then load them as images
@@ -464,7 +466,6 @@ def transpose_case(
                 f"len(transpose) == {len(transpose)} \n"
             )
             images[i] = images[i].transpose(transpose)
-            logging.info(f"Transposed with: {transpose} \n")
 
         if label is not None:
             label = label.transpose(transpose)
@@ -588,8 +589,6 @@ def resample_and_normalize_case(
             assert image is not None
             images[i] = normalizer(image, scheme=norm_op[i], intensities=self.intensities[i])
 
-        logging.info(f"Normalized with: {norm_op[0]} \n")
-
         # Resample to target shape and spacing
         for i in range(len(images)):
             try:
diff --git a/yucca/run/run_evaluation.py b/yucca/run/run_evaluation.py
index 48e61887..ce01ce3c 100644
--- a/yucca/run/run_evaluation.py
+++ b/yucca/run/run_evaluation.py
@@ -28,12 +28,6 @@ def main():
         help="Name of the target task i.e. the data to be predicted. " "Should be of format: TaskXXX_MYTASK",
         required=False,
     )
-    parser.add_argument(
-        "-f",
-        help="Select the fold that was used to train the model desired for inference. "
-        "Defaults to looking for a model trained on fold 0.",
-        default="0",
-    )
     parser.add_argument("-m", help="Model Architecture. Defaults to UNet.", default="UNet")
     parser.add_argument("-d", help="2D, 25D or 3D model. Defaults to 3D.", default="3D")
     parser.add_argument(
@@ -42,9 +36,14 @@ def main():
         default="YuccaManager",
     )
     parser.add_argument("-pl", help="Plan ID. Defaults to YuccaPlanner", default="YuccaPlanner")
-    parser.add_argument("-chk", help="Checkpoint to use for inference. Defaults to best.", default="best")
-
+    parser.add_argument("-chk", help="Checkpoint used for inference. Defaults to best.", default="best")
     parser.add_argument("-c", nargs="*", help="Classes to include for evaluation", type=str)
+
+    # Alternatively, these can be used to manually specify paths
+    parser.add_argument("--pred", help="manually specify path to predicted segmentations", default=None, required=False)
+    parser.add_argument("--gt", help="manually specify path to ground truth", default=None, required=False)
+
+    # Optionals (infrequently changed)
     parser.add_argument(
         "--task_type",
         default="segmentation",
@@ -52,17 +51,9 @@ def main():
         required=False,
         help="Defaults to segmentation. Set to 'classification' for classification tasks.",
     )
-    parser.add_argument("--pred", help="path to predicted segmentations", default=None, required=False)
-    parser.add_argument("--gt", help="path to ground truth", default=None, required=False)
-    parser.add_argument("--obj_eval", help="enable object evaluation", action="store_true", default=None, required=False)
     parser.add_argument(
         "--as_binary", help="run evaluation as if data was binary", action="store_true", default=None, required=False
     )
-
-    # Optionals (infrequently changed)
-    parser.add_argument(
-        "--version", "-v", help="version number of the model. Defaults to 0.", default=0, type=int, required=False
-    )
     parser.add_argument(
         "--experiment",
         help="A name for the experiment being performed, with no spaces.",
@@ -75,7 +66,19 @@ def main():
         action="store_true",
         required=False,
     )
-
+    parser.add_argument("--obj_eval", help="enable object evaluation", action="store_true", default=None, required=False)
+    parser.add_argument("--split_idx", type=int, help="idx of splits to use for training.", default=0)
+    parser.add_argument(
+        "--split_data_method", help="Specify splitting method. Either kfold, simple_train_val_split", default="kfold"
+    )
+    parser.add_argument(
+        "--split_data_param",
+        help="Specify the parameter for the selected split method. For KFold use an int, for simple_split use a float between 0.0-1.0.",
+        default=5,
+    )
+    parser.add_argument(
+        "--version", "-v", help="version number of the model. Defaults to 0.", default=0, type=int, required=False
+    )
     args = parser.parse_args()
 
     source_task = maybe_get_task_from_task_id(args.s)
@@ -83,7 +86,6 @@ def main():
     manager_name = args.man
     model = args.m
     dimensions = args.d
-    folds = args.f
     plan_id = args.pl
     checkpoint = args.chk
     obj = args.obj_eval
@@ -94,7 +96,9 @@ def main():
     num_version = args.version
     task_type = args.task_type
     use_wandb = not args.no_wandb
-
+    split_idx = args.split_idx
+    split_data_method = args.split_data_method
+    split_data_param = args.split_data_param
     assert (predpath and gtpath) or source_task, "Either supply BOTH paths or the source task"
 
     if not predpath:
@@ -107,7 +111,7 @@ def main():
             source_task,
             model + "__" + dimensions,
             manager_name + "__" + plan_id,
-            "fold_" + folds,
+            f"{split_data_method}_{split_data_param}_fold_{split_idx}",
             "version_" + str(num_version),
             checkpoint,
         )
diff --git a/yucca/run/run_finetune.py b/yucca/run/run_finetune.py
index e3c1ac2f..1a9b7c14 100644
--- a/yucca/run/run_finetune.py
+++ b/yucca/run/run_finetune.py
@@ -19,6 +19,12 @@ def main():
     parser.add_argument("-chk", "--checkpoint", help="Path to the checkpoint from where the weights should be restored. ")
 
     # Optional arguments with default values #
+    parser.add_argument(
+        "-d",
+        help="Dimensionality of the Model. Can be 3D or 2D. "
+        "Defaults to 3D. Note that this will always be 2D if ensemble is enabled.",
+        default="3D",
+    )
     parser.add_argument(
         "-m",
         help="Model Architecture. Should be one of MultiResUNet or UNet"
@@ -26,12 +32,6 @@ def main():
         "Defaults to the standard UNet.",
         default="UNet",
     )
-    parser.add_argument(
-        "-d",
-        help="Dimensionality of the Model. Can be 3D or 2D. "
-        "Defaults to 3D. Note that this will always be 2D if ensemble is enabled.",
-        default="3D",
-    )
     parser.add_argument(
         "-man",
         help="Manager Class to be used. " "Defaults to the basic YuccaManager",
@@ -45,88 +45,87 @@ def main():
         default="YuccaPlanner",
     )
 
+    # Optionals that can be changed experimentally. For long term solutions these should be specified by a unique Manager.
     parser.add_argument(
-        "--epochs", help="Used to specify the number of epochs for training. Default is 1000", type=int, default=1000
+        "--batch_size",
+        type=int,
+        default=None,
+        help="Batch size to be used for training. Overrides the batch size specified in the plan.",
     )
+    parser.add_argument("--disable_logging", help="disable logging.", action="store_true", default=False)
+    parser.add_argument("--ds", help="Used to enable deep supervision", default=False, action="store_true")
     parser.add_argument(
-        "--experiment",
-        help="A name for the experiment being performed, wiht no spaces.",
-        default="finetune",
+        "--epochs", help="Used to specify the number of epochs for training. Default is 1000", type=int, default=1000
     )
-    # The following can be changed to run training with alternative LR, Loss and/or Momentum ###
+    parser.add_argument("--experiment", help="A name for the experiment being performed, with no spaces.", default="finetune")
+    parser.add_argument("--loss", help="Should only be used to employ alternative Loss Function", default=None)
     parser.add_argument(
         "--lr",
         help="Should only be used to employ alternative Learning Rate. Format should be scientific notation e.g. 1e-4.",
         default=1e-3,
     )
-    parser.add_argument("--loss", help="Should only be used to employ alternative Loss Function", default=None)
+    parser.add_argument("--max_vram", type=int, default=12)
     parser.add_argument("--mom", help="Should only be used to employ alternative Momentum.", default=0.9)
-
-    parser.add_argument("--disable_logging", help="disable logging. ", action="store_true", default=False)
     parser.add_argument(
         "--new_version",
         help="Start a new version, instead of continuing from the most recent. ",
         action="store_true",
         default=False,
     )
-    parser.add_argument("--profile", help="Enable profiling.", action="store_true", default=False)
+    parser.add_argument(
+        "--num_workers",
+        type=int,
+        help="Num workers used in the DataLoaders. By default this will be inferred from the number of available CPUs-1",
+        default=None,
+    )
     parser.add_argument(
         "--patch_size",
         type=str,
         help="Use your own patch_size. Example: if 32 is provided and the model is 3D we will use patch size (32, 32, 32). Can also be min, max or mean.",
-    )
-    parser.add_argument("--precision", type=str, default="bf16-mixed")
-    parser.add_argument("--train_batches_per_step", type=int, default=250)
-    parser.add_argument("--val_batches_per_step", type=int, default=50)
-    parser.add_argument("--max_vram", type=int, default=12)
-
-    # Split configs
-    parser.add_argument(
-        "--split_data_ratio",
-        type=float,
-        help="Use a simple train/val split where `split_data_ratio` is the fraction of items used for the val split.",
         default=None,
     )
+    parser.add_argument("--precision", type=str, default="bf16-mixed")
+    parser.add_argument("--profile", help="Enable profiling.", action="store_true", default=False)
+    parser.add_argument("--split_idx", type=int, help="idx of splits to use for training.", default=0)
     parser.add_argument(
-        "--split_data_kfold", type=int, help="Use kfold split where `split_data_kfold` is amount of folds.", default=None
+        "--split_data_method", help="Specify splitting method. Either kfold, simple_train_val_split", default="kfold"
     )
-    parser.add_argument("-f", "--split_idx", type=int, help="idx of splits to use for training.", default=0)
-
     parser.add_argument(
-        "--num_workers",
-        type=int,
-        help="Num workers used in the DataLoaders. By default this will be inferred from the number of available CPUs-1",
-        default=None,
+        "--split_data_param",
+        help="Specify the parameter for the selected split method. For KFold use an int, for simple_split use a float between 0.0-1.0.",
+        default=5,
     )
+    parser.add_argument("--train_batches_per_step", type=int, default=250)
+    parser.add_argument("--val_batches_per_step", type=int, default=50)
 
     args = parser.parse_args()
 
     task = maybe_get_task_from_task_id(args.task)
     checkpoint = args.checkpoint
-    model_name = args.m
     dimensions = args.d
-    experiment = args.experiment
+    model_name = args.m
     manager_name = args.man
-    momentum = args.mom
-    lr = args.lr
+    planner = args.pl
+
+    batch_size = args.batch_size
     log = not args.disable_logging
+    deep_supervision = args.ds
+    epochs = args.epochs
+    experiment = args.experiment
     loss = args.loss
+    lr = args.lr
+    max_vram = args.max_vram
+    momentum = args.mom
     new_version = args.new_version
+    num_workers = args.num_workers
     patch_size = args.patch_size
-    planner = args.pl
+    precision = args.precision
     profile = args.profile
-
-    num_workers = args.num_workers
     split_idx = args.split_idx
-    split_data_ratio = args.split_data_ratio
-    split_data_kfold = args.split_data_kfold
-
-    if split_data_kfold is None and split_data_ratio is None:
-        split_data_kfold = 5
-
-    assert (split_data_kfold is not None and split_data_ratio is None) or (
-        split_data_kfold is None and split_data_ratio is not None
-    ), "It is not allowed to provide both `split_data_ratio` and `split_data_kfold`."
+    split_data_method = args.split_data_method
+    split_data_param = args.split_data_param
+    train_batches_per_step = args.train_batches_per_step
+    val_batches_per_step = args.val_batches_per_step
 
     if patch_size is not None:
         if patch_size not in ["mean", "max", "min"]:
@@ -139,42 +138,33 @@ def main():
         class_name=manager_name,
         current_module="yucca.training.managers",
     )
-    # checkpoint = join(
-    #    yucca_models,
-    #    source_task,
-    #    model + "__" + dimensions,
-    #    manager_name + "__" + planner,
-    #    f"fold_{str(folds)}",
-    #    f"version_{str(version)}",
-    #    "checkpoints",
-    #    f"{checkpoint}.ckpt",
-    # )
 
     manager = manager(
+        batch_size=batch_size,
         ckpt_path=checkpoint,
         continue_from_most_recent=not new_version,
-        deep_supervision=False,
+        deep_supervision=deep_supervision,
         enable_logging=log,
         experiment=experiment,
         loss=loss,
         learning_rate=lr,
-        max_epochs=args.epochs,
-        max_vram=args.max_vram,
+        max_epochs=epochs,
+        max_vram=max_vram,
         model_dimensions=dimensions,
         model_name=model_name,
         momentum=momentum,
         num_workers=num_workers,
         patch_size=patch_size,
         planner=planner,
-        precision=args.precision,
+        precision=precision,
         profile=profile,
         split_idx=split_idx,
-        split_data_kfold=split_data_kfold,
-        split_data_ratio=split_data_ratio,
+        split_data_method=split_data_method,
+        split_data_param=split_data_param,
         step_logging=False,
         task=task,
-        train_batches_per_step=args.train_batches_per_step,
-        val_batches_per_step=args.val_batches_per_step,
+        train_batches_per_step=train_batches_per_step,
+        val_batches_per_step=val_batches_per_step,
         **kwargs,
     )
     manager.run_finetuning()
diff --git a/yucca/run/run_inference.py b/yucca/run/run_inference.py
index 866323eb..acfc0c76 100644
--- a/yucca/run/run_inference.py
+++ b/yucca/run/run_inference.py
@@ -42,14 +42,6 @@ def main():
         default="best",
     )
     parser.add_argument("-d", "--dimensions", help="2D or 3D model. Defaults to 3D.", default="3D")
-
-    parser.add_argument(
-        "-f",
-        "--fold",
-        help="Select the fold that was used to train the model desired for inference. "
-        "Defaults to looking for a model trained on fold 0.",
-        default="0",
-    )
     parser.add_argument("-m", "--model", help="Model Architecture. Defaults to UNet.", default="UNet")
     parser.add_argument(
         "-man",
@@ -58,19 +50,35 @@ def main():
         default="YuccaManager",
     )
     parser.add_argument("-pl", "--planner", help="Planner. Defaults to YuccaPlanner", default="YuccaPlanner")
+    parser.add_argument("--split_idx", type=int, help="idx of splits to use for training.", default=0)
+    parser.add_argument(
+        "--split_data_method", help="Specify splitting method. Either kfold, simple_train_val_split", default="kfold"
+    )
+    parser.add_argument(
+        "--split_data_param",
+        help="Specify the parameter for the selected split method. For KFold use an int, for simple_split use a float between 0.0-1.0.",
+        default=5,
+    )
+    parser.add_argument(
+        "--task_type",
+        default="segmentation",
+        type=str,
+        required=False,
+        help="Defaults to segmentation. Set to 'classification' for classification tasks.",
+    )
     parser.add_argument(
         "-v",
         "--version",
         help="Version to use for inference. Defaults to the newest version.",
         default=None,
     )
+
     # Optionals (occasionally changed)
     parser.add_argument(
         "--experiment",
         help="A name for the experiment being performed, with no spaces.",
         default="default",
     )
-
     parser.add_argument(
         "--disable_tta",
         help="Used to disable test-time augmentations (mirroring)",
@@ -91,13 +99,6 @@ def main():
         action="store_true",
         required=False,
     )
-    parser.add_argument(
-        "--no_sliding_window",
-        help="Disable sliding window prediction and instead use fixed patch/input size",
-        default=False,
-        action="store_true",
-        required=False,
-    )
     # parser.add_argument(
     #    "--overwrite",
     #    default=False,
@@ -125,13 +126,6 @@ def main():
         required=False,
         help="Save softmax outputs. Required for softmax fusion.",
     )
-    parser.add_argument(
-        "--task_type",
-        default="segmentation",
-        type=str,
-        required=False,
-        help="Defaults to segmentation. Set to 'classification' for classification tasks.",
-    )
 
     args = parser.parse_args()
 
@@ -145,10 +139,11 @@ def main():
     manager_name = args.manager
     model = args.model
     planner = args.planner
-    profile = args.profile
-    split_idx = int(args.fold)
-    version = args.version
+    split_idx = args.split_idx
+    split_data_method = args.split_data_method
+    split_data_param = args.split_data_param
     task_type = args.task_type
+    version = args.version
 
     # Optionals (occasionally changed)
     experiment = args.experiment
@@ -156,11 +151,17 @@ def main():
     no_eval = args.no_eval
     # overwrite = args.overwrite
     predict_train = args.predict_train
+    profile = args.profile
     save_softmax = args.save_softmax
     use_wandb = not args.no_wandb
 
     path_to_versions = join(
-        yucca_models, source_task, model + "__" + dimensions, manager_name + "__" + planner, experiment, f"fold_{split_idx}"
+        yucca_models,
+        source_task,
+        model + "__" + dimensions,
+        manager_name + "__" + planner,
+        experiment,
+        f"{split_data_method}_{split_data_param}_fold_{split_idx}",
     )
     if version is None:
         versions = [int(i.split("_")[-1]) for i in subdirs(path_to_versions, join=False)]
@@ -172,7 +173,7 @@ def main():
         model + "__" + dimensions,
         manager_name + "__" + planner,
         experiment,
-        f"fold_{split_idx}",
+        f"{split_data_method}_{split_data_param}_fold_{split_idx}",
         f"version_{version}",
         "checkpoints",
         checkpoint + ".ckpt",
@@ -199,6 +200,8 @@ def main():
         model_dimensions=dimensions,
         task=source_task,
         split_idx=split_idx,
+        split_data_method=split_data_method,
+        split_data_param=split_data_param,
         planner=planner,
         profile=profile,
     )
@@ -213,7 +216,7 @@ def main():
         source_task,
         model + "__" + dimensions,
         manager_name + "__" + planner,
-        f"fold_{split_idx}",
+        f"{split_data_method}_{split_data_param}_fold_{split_idx}",
         f"version_{version}",
         checkpoint,
     )
diff --git a/yucca/run/run_preprocessing.py b/yucca/run/run_preprocessing.py
index 713c3aa7..f9b287c0 100644
--- a/yucca/run/run_preprocessing.py
+++ b/yucca/run/run_preprocessing.py
@@ -33,9 +33,6 @@ def main():
     )
     parser.add_argument("--disable_sanity_checks", help="Enable or disable sanity checks", default=False)
 
-    # parser.add_argument("--threads", help="Number of threads/processes. \n"
-    #                    "Don't touch this unless you know what you're doing.", default=2)
-
     args = parser.parse_args()
 
     task = maybe_get_task_from_task_id(args.task)
@@ -44,7 +41,6 @@ def main():
     view = args.v
     disable_sanity_checks = args.disable_sanity_checks
     ensemble = args.ensemble
-    # threads = args.threads
 
     if not ensemble:
         planner = recursive_find_python_class(
diff --git a/yucca/run/run_training.py b/yucca/run/run_training.py
index c39e6f9b..f554d4f0 100644
--- a/yucca/run/run_training.py
+++ b/yucca/run/run_training.py
@@ -18,6 +18,12 @@ def main():
     )
 
     # Optional arguments with default values #
+    parser.add_argument(
+        "-d",
+        help="Dimensionality of the Model. Can be 3D or 2D. "
+        "Defaults to 3D. Note that this will always be 2D if ensemble is enabled.",
+        default="3D",
+    )
     parser.add_argument(
         "-m",
         help="Model Architecture. Should be one of MultiResUNet or UNet"
@@ -25,12 +31,6 @@ def main():
         "Defaults to the standard UNet.",
         default="UNet",
     )
-    parser.add_argument(
-        "-d",
-        help="Dimensionality of the Model. Can be 3D or 2D. "
-        "Defaults to 3D. Note that this will always be 2D if ensemble is enabled.",
-        default="3D",
-    )
     parser.add_argument(
         "-man",
         help="Manager Class to be used. " "Defaults to the basic YuccaManager",
@@ -44,22 +44,27 @@ def main():
         default="YuccaPlanner",
     )
 
-    parser.add_argument("--epochs", help="Used to specify the number of epochs for training. Default is 1000")
-    # The following can be changed to run training with alternative LR, Loss and/or Momentum ###
+    # Optionals that can be changed experimentally. For long term solutions these should be specified by a unique Manager.
+    parser.add_argument(
+        "--batch_size",
+        type=int,
+        default=None,
+        help="Batch size to be used for training. Overrides the batch size specified in the plan.",
+    )
+    parser.add_argument("--disable_logging", help="disable logging.", action="store_true", default=False)
+    parser.add_argument("--ds", help="Used to enable deep supervision", default=False, action="store_true")
+    parser.add_argument(
+        "--epochs", help="Used to specify the number of epochs for training. Default is 1000", type=int, default=1000
+    )
+    parser.add_argument("--experiment", help="A name for the experiment being performed, with no spaces.", default="default")
+    parser.add_argument("--loss", help="Should only be used to employ alternative Loss Function", default=None)
     parser.add_argument(
         "--lr",
         help="Should only be used to employ alternative Learning Rate. Format should be scientific notation e.g. 1e-4.",
         default=1e-3,
     )
-    parser.add_argument("--loss", help="Should only be used to employ alternative Loss Function", default=None)
+    parser.add_argument("--max_vram", type=int, default=12)
     parser.add_argument("--mom", help="Should only be used to employ alternative Momentum.", default=0.9)
-    parser.add_argument("--ds", help="Used to enable deep supervision", default=False, action="store_true")
-    parser.add_argument(
-        "--disable_logging",
-        help="disable logging. ",
-        action="store_true",
-        default=False,
-    )
     parser.add_argument(
         "--new_version",
         help="Start a new version, instead of continuing from the most recent. ",
@@ -67,98 +72,69 @@ def main():
         default=False,
     )
     parser.add_argument(
-        "--profile",
-        help="Enable profiling.",
-        action="store_true",
-        default=False,
-    )
-
-    parser.add_argument(
-        "--experiment",
-        help="A name for the experiment being performed, wiht no spaces.",
-        default="default",
+        "--num_workers",
+        type=int,
+        help="Num workers used in the DataLoaders. By default this will be inferred from the number of available CPUs-1",
+        default=None,
     )
-
     parser.add_argument(
         "--patch_size",
         type=str,
         help="Use your own patch_size. Example: if 32 is provided and the model is 3D we will use patch size (32, 32, 32). Can also be min, max or mean.",
         default=None,
     )
-
-    parser.add_argument(
-        "--batch_size",
-        "-bs",
-        type=int,
-        default=None,
-        help="Batch size to be used for training. Overrides the batch size specified in the plan.",
-    )
-    # Split configs
+    parser.add_argument("--precision", type=str, default="bf16-mixed")
+    parser.add_argument("--profile", help="Enable profiling.", action="store_true", default=False)
+    parser.add_argument("--split_idx", type=int, help="idx of splits to use for training.", default=0)
     parser.add_argument(
-        "--split_data_ratio",
-        type=float,
-        help="Use a simple train/val split where `split_data_ratio` is the fraction of items used for the val split.",
-        default=None,
+        "--split_data_method", help="Specify splitting method. Either kfold, simple_train_val_split", default="kfold"
     )
     parser.add_argument(
-        "--split_data_kfold", type=int, help="Use kfold split where `split_data_kfold` is amount of folds.", default=None
+        "--split_data_param",
+        help="Specify the parameter for the selected split method. For KFold use an int, for simple_split use a float between 0.0-1.0.",
+        default=5,
     )
-    parser.add_argument("-f", "--split_idx", type=int, help="idx of splits to use for training.", default=0)
-
-    parser.add_argument("--precision", type=str, default="bf16-mixed")
-
     parser.add_argument("--train_batches_per_step", type=int, default=250)
     parser.add_argument("--val_batches_per_step", type=int, default=50)
 
-    parser.add_argument(
-        "--num_workers",
-        type=int,
-        help="Num workers used in the DataLoaders. By default this will be inferred from the number of available CPUs-1",
-        default=None,
-    )
-
     args = parser.parse_args()
 
+    # Required
     task = maybe_get_task_from_task_id(args.task)
-    model_name = args.m
+
+    # Optionals (frequently changed)
     dimensions = args.d
+    model_name = args.m
+    manager_name = args.man
+    planner = args.pl
+
+    # Optionals (occasionally changed)
+    log = not args.disable_logging
     batch_size = args.batch_size
     deep_supervision = args.ds
     epochs = args.epochs
-    manager_name = args.man
-    lr = args.lr
-    log = not args.disable_logging
+    experiment = args.experiment
     loss = args.loss
+    lr = args.lr
+    max_vram = args.max_vram
     momentum = args.mom
-    patch_size = args.patch_size
     new_version = args.new_version
-    planner = args.pl
+    num_workers = args.num_workers
+    patch_size = args.patch_size
+    precision = args.precision
     profile = args.profile
-    experiment = args.experiment
-
     split_idx = args.split_idx
-    split_data_ratio = args.split_data_ratio
-    split_data_kfold = args.split_data_kfold
-
-    num_workers = args.num_workers
-
-    if split_data_kfold is None and split_data_ratio is None:
-        split_data_kfold = 5
-
-    assert (split_data_kfold is not None and split_data_ratio is None) or (
-        split_data_kfold is None and split_data_ratio is not None
-    ), "It is not allowed to provide both `split_data_ratio` and `split_data_kfold`."
+    split_data_method = args.split_data_method
+    split_data_param = args.split_data_param
+    train_batches_per_step = args.train_batches_per_step
+    val_batches_per_step = args.val_batches_per_step
 
     if patch_size is not None:
         if patch_size not in ["mean", "max", "min"]:
             patch_size = (int(patch_size),) * 3 if dimensions == "3D" else (int(patch_size),) * 2
 
-    # checkpoint = args.chk
     kwargs = {}
 
-    if epochs:
-        kwargs["max_epochs"] = int(epochs)
-
     assert model_name in [
         "MedNeXt",
         "MultiResUNet",
@@ -182,24 +158,26 @@ def main():
         continue_from_most_recent=not new_version,
         deep_supervision=deep_supervision,
         enable_logging=log,
-        split_idx=split_idx,
-        split_data_ratio=split_data_ratio,
-        split_data_kfold=split_data_kfold,
         loss=loss,
         learning_rate=lr,
+        max_epochs=epochs,
+        max_vram=max_vram,
         model_dimensions=dimensions,
         model_name=model_name,
         momentum=momentum,
         num_workers=num_workers,
         planner=planner,
-        precision=args.precision,
+        precision=precision,
         profile=profile,
+        split_idx=split_idx,
+        split_data_method=split_data_method,
+        split_data_param=split_data_param,
         step_logging=False,
         task=task,
         batch_size=batch_size,
         experiment=experiment,
-        train_batches_per_step=args.train_batches_per_step,
-        val_batches_per_step=args.val_batches_per_step,
+        train_batches_per_step=train_batches_per_step,
+        val_batches_per_step=val_batches_per_step,
         **kwargs,
     )
     manager.run_training()
diff --git a/yucca/task_conversion/Task000_TEST_CLASSIFICATION.py b/yucca/task_conversion/Task000_TEST_CLASSIFICATION.py
new file mode 100644
index 00000000..5a2cee12
--- /dev/null
+++ b/yucca/task_conversion/Task000_TEST_CLASSIFICATION.py
@@ -0,0 +1,79 @@
+# ONLY used to run tests
+from batchgenerators.utilities.file_and_folder_operations import join, maybe_mkdir_p, subfiles
+from yucca.task_conversion.utils import generate_dataset_json
+import shutil
+from yucca.paths import yucca_raw_data
+from tqdm import tqdm
+from sklearn.model_selection import train_test_split
+
+
+def convert(path: str, subdir: str = "dataset_test0_classification"):
+    # INPUT DATA
+    path = join(path, subdir)
+    label_suffix = ".txt"
+    image_suffix = ".nii.gz"
+
+    # Train/Test Splits
+    labels_dir = join(path, "all_labels")
+    images_dir = join(path, "all_images")
+
+    training_samples, test_samples = train_test_split(
+        subfiles(labels_dir, join=False, suffix=label_suffix), random_state=859032
+    )
+
+    # OUTPUT DATA
+    # Target names
+    task_name = "Task000_TEST_CLASSIFICATION"
+    task_prefix = "TEST_CLASSIFICATION"
+
+    # Target paths
+    target_base = join(yucca_raw_data, task_name)
+
+    target_imagesTr = join(target_base, "imagesTr")
+    target_labelsTr = join(target_base, "labelsTr")
+
+    target_imagesTs = join(target_base, "imagesTs")
+    target_labelsTs = join(target_base, "labelsTs")
+
+    maybe_mkdir_p(target_imagesTr)
+    maybe_mkdir_p(target_labelsTs)
+    maybe_mkdir_p(target_imagesTs)
+    maybe_mkdir_p(target_labelsTr)
+
+    for sTr in tqdm(training_samples, desc="Train"):
+        sTr = sTr[: -len(label_suffix)]
+        src_image_file_path = join(images_dir, sTr + image_suffix)
+        src_label_path = join(labels_dir, sTr + label_suffix)
+
+        dst_image_file_path = f"{target_imagesTr}/{task_prefix}_{sTr}_000.nii.gz"
+        dst_label_path = f"{target_labelsTr}/{task_prefix}_{sTr}.txt"
+        shutil.copy2(src_image_file_path, dst_image_file_path)
+        shutil.copy2(src_label_path, dst_label_path)
+    del sTr
+
+    for sTs in tqdm(test_samples, desc="Test"):
+        sTs = sTs[: -len(label_suffix)]
+
+        # Loading relevant modalities and the ground truth
+        src_image_file_path = join(images_dir, sTs + image_suffix)
+        src_label_path = join(labels_dir, sTs + label_suffix)
+
+        dst_image_file_path = f"{target_imagesTs}/{task_prefix}_{sTs}_000.nii.gz"
+        dst_label_path = f"{target_labelsTs}/{task_prefix}_{sTs}.nii.gz"
+        shutil.copy2(src_image_file_path, dst_image_file_path)
+        shutil.copy2(src_label_path, dst_label_path)
+    del sTs
+
+    generate_dataset_json(
+        join(target_base, "dataset.json"),
+        target_imagesTr,
+        target_imagesTs,
+        ("TestModality",),
+        labels={0: "background", 1: "FakeLabel1"},
+        dataset_name=task_name,
+        dataset_description="Test Dataset",
+        dataset_reference="",
+    )
+
+
+# %%
diff --git a/yucca/task_conversion/Task000_TEST_SEGMENTATION.py b/yucca/task_conversion/Task000_TEST_SEGMENTATION.py
new file mode 100644
index 00000000..49e504ef
--- /dev/null
+++ b/yucca/task_conversion/Task000_TEST_SEGMENTATION.py
@@ -0,0 +1,89 @@
+"""
+ONLY used to run tests
+The data in the test folder was generated using the following lines of code:
+
+ims = []
+labs = []
+for i in range(7):
+    arr = np.random.rand(32, 32, 32)
+    lab = np.random.randint(0, 2, (32, 32, 32)).astype(float)
+    ims.append(nib.Nifti1Image(arr, affine=np.eye(4)))
+    labs.append(nib.Nifti1Image(lab, affine=np.eye(4)))
+
+"""
+
+from batchgenerators.utilities.file_and_folder_operations import join, maybe_mkdir_p, subfiles
+from yucca.task_conversion.utils import generate_dataset_json
+import shutil
+from yucca.paths import yucca_raw_data
+from tqdm import tqdm
+from sklearn.model_selection import train_test_split
+
+
+def convert(path: str, subdir: str = "dataset_test0"):
+    # INPUT DATA
+    path = join(path, subdir)
+    suffix = ".nii.gz"
+
+    # Train/Test Splits
+    labels_dir = join(path, "all_labels")
+    images_dir = join(path, "all_images")
+
+    training_samples, test_samples = train_test_split(subfiles(labels_dir, join=False, suffix=suffix), random_state=859032)
+
+    # OUTPUT DATA
+    # Target names
+    task_name = "Task000_TEST_SEGMENTATION"
+    task_prefix = "TEST_SEGMENTATION"
+
+    # Target paths
+    target_base = join(yucca_raw_data, task_name)
+
+    target_imagesTr = join(target_base, "imagesTr")
+    target_labelsTr = join(target_base, "labelsTr")
+
+    target_imagesTs = join(target_base, "imagesTs")
+    target_labelsTs = join(target_base, "labelsTs")
+
+    maybe_mkdir_p(target_imagesTr)
+    maybe_mkdir_p(target_labelsTs)
+    maybe_mkdir_p(target_imagesTs)
+    maybe_mkdir_p(target_labelsTr)
+
+    for sTr in tqdm(training_samples, desc="Train"):
+        sTr = sTr[: -len(suffix)]
+        src_image_file_path = join(images_dir, sTr + suffix)
+        src_label_path = join(labels_dir, sTr + suffix)
+
+        dst_image_file_path = f"{target_imagesTr}/{task_prefix}_{sTr}_000.nii.gz"
+        dst_label_path = f"{target_labelsTr}/{task_prefix}_{sTr}.nii.gz"
+        shutil.copy2(src_image_file_path, dst_image_file_path)
+        shutil.copy2(src_label_path, dst_label_path)
+    del sTr
+
+    for sTs in tqdm(test_samples, desc="Test"):
+        sTs = sTs[: -len(suffix)]
+
+        # Loading relevant modalities and the ground truth
+        src_image_file_path = join(images_dir, sTs + suffix)
+        src_label_path = join(labels_dir, sTs + suffix)
+
+        dst_image_file_path = f"{target_imagesTs}/{task_prefix}_{sTs}_000.nii.gz"
+        dst_label_path = f"{target_labelsTs}/{task_prefix}_{sTs}.nii.gz"
+        shutil.copy2(src_image_file_path, dst_image_file_path)
+        shutil.copy2(src_label_path, dst_label_path)
+    del sTs
+
+    generate_dataset_json(
+        join(target_base, "dataset.json"),
+        target_imagesTr,
+        target_imagesTs,
+        ("TestModality",),
+        labels={0: "background", 1: "FakeLabel1"},
+        dataset_name=task_name,
+        dataset_description="Test Dataset",
+        dataset_reference="",
+    )
+
+
+# %%
diff --git a/yucca/task_conversion/Task000_TEST_UNSUPERVISED.py b/yucca/task_conversion/Task000_TEST_UNSUPERVISED.py
new file mode 100644
index 00000000..9fe03095
--- /dev/null
+++ b/yucca/task_conversion/Task000_TEST_UNSUPERVISED.py
@@ -0,0 +1,79 @@
+"""
+ONLY used to run tests
+The data in the test folder was generated using the following lines of code:
+
+ims = []
+labs = []
+for i in range(7):
+    arr = np.random.rand(32, 32, 32)
+    lab = np.random.randint(0, 2, (32, 32, 32)).astype(float)
+    ims.append(nib.Nifti1Image(arr, affine=np.eye(4)))
+    labs.append(nib.Nifti1Image(lab, affine=np.eye(4)))
+
+"""
+
+from batchgenerators.utilities.file_and_folder_operations import join, maybe_mkdir_p, subfiles
+from yucca.task_conversion.utils import generate_dataset_json
+import shutil
+from yucca.paths import yucca_raw_data
+from tqdm import tqdm
+from sklearn.model_selection import train_test_split
+
+
+def convert(path: str, subdir: str = "dataset_test0"):
+    # INPUT DATA
+    path = join(path, subdir)
+    suffix = ".nii.gz"
+
+    # Train/Test Splits
+    labels_dir = join(path, "all_labels")
+    images_dir = join(path, "all_images")
+
+    training_samples, test_samples = train_test_split(subfiles(labels_dir, join=False, suffix=suffix), random_state=859032)
+
+    # OUTPUT DATA
+    # Target names
+    task_name = "Task000_TEST_UNSUPERVISED"
+    task_prefix = "TEST_UNSUPERVISED"
+
+    # Target paths
+    target_base = join(yucca_raw_data, task_name)
+
+    target_imagesTr = join(target_base, "imagesTr")
+
+    target_imagesTs = join(target_base, "imagesTs")
+
+    maybe_mkdir_p(target_imagesTr)
+    maybe_mkdir_p(target_imagesTs)
+
+    for sTr in tqdm(training_samples, desc="Train"):
+        sTr = sTr[: -len(suffix)]
+        src_image_file_path = join(images_dir, sTr + suffix)
+
+        dst_image_file_path = f"{target_imagesTr}/{task_prefix}_{sTr}_000.nii.gz"
+        shutil.copy2(src_image_file_path, dst_image_file_path)
+    del sTr
+
+    for sTs in tqdm(test_samples, desc="Test"):
+        sTs = sTs[: -len(suffix)]
+
+        # Loading relevant modalities and the ground truth
+        src_image_file_path = join(images_dir, sTs + suffix)
+
+        dst_image_file_path = f"{target_imagesTs}/{task_prefix}_{sTs}_000.nii.gz"
+        shutil.copy2(src_image_file_path, dst_image_file_path)
+    del sTs
+
+    generate_dataset_json(
+        join(target_base, "dataset.json"),
+        target_imagesTr,
+        target_imagesTs,
+        ("TestModality",),
+        labels={},
+        dataset_name=task_name,
+        dataset_description="Test Dataset",
+        dataset_reference="",
+    )
+
+
+# %%
diff --git a/yucca/training/augmentation/YuccaAugmentationComposer.py b/yucca/training/augmentation/YuccaAugmentationComposer.py
index 9f4b5ee8..92315aa6 100644
--- a/yucca/training/augmentation/YuccaAugmentationComposer.py
+++ b/yucca/training/augmentation/YuccaAugmentationComposer.py
@@ -115,7 +115,7 @@ def apply_task_type_specific_preset(self, task_type_preset):
             self.skip_label = True
             self.copy_image_to_label = True
             # This should be uncommented when masking is properly implemented
-            # augmentation_parameter_dict["mask_image_for_reconstruction"] = True
+            # self.mask_image_for_reconstruction = True
 
     def overwrite_params(self, parameter_dict):
         for key, value in parameter_dict.items():
diff --git a/yucca/training/configuration/configure_checkpoint.py b/yucca/training/configuration/configure_checkpoint.py
index c1566949..9a248b91 100644
--- a/yucca/training/configuration/configure_checkpoint.py
+++ b/yucca/training/configuration/configure_checkpoint.py
@@ -4,6 +4,7 @@
 from typing import Union
 from yucca.training.configuration.configure_paths import PathConfig
 from yucca.utils.dict import without_keys
+import logging
 
 
 @dataclass
@@ -88,10 +89,10 @@ def get_checkpoint_config(
 def find_checkpoint_path(ckpt_path: Union[str, None], continue_from_most_recent: bool, version: int, version_dir: str):
     if ckpt_path:
         assert isfile(ckpt_path)
-        print(f"Using ckpt file: {ckpt_path}")
+        logging.info(f"Using ckpt file: {ckpt_path}")
         return ckpt_path
     elif version is not None and continue_from_most_recent and isfile(join(version_dir, "checkpoints", "last.ckpt")):
-        print("Using last checkpoint and continuing training")
+        logging.info("Using last checkpoint and continuing training")
         return join(version_dir, "checkpoints", "last.ckpt")
     else:
         return None
diff --git a/yucca/training/configuration/configure_input_dims.py b/yucca/training/configuration/configure_input_dims.py
index 8785e649..449b4f07 100644
--- a/yucca/training/configuration/configure_input_dims.py
+++ b/yucca/training/configuration/configure_input_dims.py
@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 from typing import Tuple, Union, Optional, Literal
-
 from yucca.network_architectures.utils.model_memory_estimation import find_optimal_tensor_dims
+import logging
 
 
 @dataclass
@@ -89,7 +89,7 @@ def get_input_dims_config(
     if plan.get("batch_size") and plan.get("batch_size") != batch_size:
         raise UserWarning(f"Overwriting batch size from plan ({plan.get('batch_size')}) with {batch_size}")
 
-    print(f"Using batch size: {batch_size} and patch size: {patch_size}")
+    logging.info(f"Using batch size: {batch_size} and patch size: {patch_size}")
 
     return InputDimensionsConfig(
         batch_size=batch_size,
diff --git a/yucca/training/configuration/configure_plans.py b/yucca/training/configuration/configure_plans.py
index 95452c66..5c3063f7 100644
--- a/yucca/training/configuration/configure_plans.py
+++ b/yucca/training/configuration/configure_plans.py
@@ -6,6 +6,7 @@
 from yucca.preprocessing.ClassificationPreprocessor import ClassificationPreprocessor
 from yucca.utils.dict import without_keys
 from yucca.utils.files_and_folders import recursive_find_python_class
+import logging
 
 
 @dataclass
@@ -57,7 +58,7 @@ def get_plan_config(
 def load_plans(plans_path):
     # If plans is still none the ckpt files were either empty/invalid or didn't exist and we load the plans
     # from the preprocessed folder.
-    print("Exhausted other options: loading plans.json")
+    logging.info("Loading plans.json")
     return load_json(plans_path)
 
 
diff --git a/yucca/training/configuration/configure_task.py b/yucca/training/configuration/configure_task.py
index e3f54ed3..26fe4958 100644
--- a/yucca/training/configuration/configure_task.py
+++ b/yucca/training/configuration/configure_task.py
@@ -5,20 +5,21 @@
 @dataclass
 class TaskConfig:
     continue_from_most_recent: bool
+    experiment: str
     manager_name: str
     model_dimensions: str
     model_name: str
     patch_based_training: bool
     planner_name: str
     split_idx: int
-    task: str
-    experiment: str
     split_method: str
     split_param: Union[str, float, int]
+    task: str
 
     def lm_hparams(self):
         return {
             "continue_from_most_recent": self.continue_from_most_recent,
+            "experiment": self.experiment,
             "manager_name": self.manager_name,
             "model_dimensions": self.model_dimensions,
             "model_name": self.model_name,
@@ -26,6 +27,8 @@ def lm_hparams(self):
             "planner_name": self.planner_name,
             "task": self.task,
             "split_idx": self.split_idx,
+            "split_method": self.split_method,
+            "split_param": self.split_param,
             "experiment": self.experiment,
         }
 
@@ -40,13 +43,11 @@ def get_task_config(
     patch_based_training: bool = True,
     experiment: str = "default",
     split_idx: int = 0,
-    split_data_kfold: Optional[int] = 5,
-    split_data_ratio: Optional[float] = None,
+    split_data_method: Optional[int] = "kfold",
+    split_data_param: Optional[float] = 5,
 ):
     assert model_dimensions is not None
 
-    split_method, split_param = split_method_and_param(split_data_kfold, split_data_ratio)
-
     return TaskConfig(
         task=task,
         continue_from_most_recent=continue_from_most_recent,
@@ -57,31 +58,6 @@ def get_task_config(
         planner_name=planner_name,
         experiment=experiment,
         split_idx=split_idx,
-        split_method=split_method,
-        split_param=split_param,
+        split_method=split_data_method,
+        split_param=split_data_param,
     )
-
-
-def split_method_and_param(split_data_kfold, split_data_ratio):
-    """
-    Note:
-        You can only provide one of `k` or `split_data_ratio`.
-        - If `k` is provided we will split with `k-fold`.
-        - If `split_data_ratio` is provided it determines the fraction of items used for the val split.
-    """
-
-    assert (split_data_kfold is not None and split_data_ratio is None) or (
-        split_data_kfold is None and split_data_ratio is not None
-    ), "You must provide excatly one of either `split_data_kfold  or `split_data_ratio`."
-    if split_data_ratio is not None:
-        assert (
-            0 < split_data_ratio < 1
-        ), "`split_data_ratio` must be a number between 0 and 1 and determines the fraction of items used for the val split"
-    if split_data_kfold is not None:
-        assert split_data_kfold > 0
-        assert isinstance(split_data_kfold, int), "`split_data_kfold  should be an integer"
-
-    if split_data_kfold is not None:
-        return "kfold", split_data_kfold
-    else:  # split_data_ratio is not None
-        return "simple_train_val_split", split_data_ratio
diff --git a/yucca/training/configuration/split_data.py b/yucca/training/configuration/split_data.py
index dd44b4ff..f819b9f7 100644
--- a/yucca/training/configuration/split_data.py
+++ b/yucca/training/configuration/split_data.py
@@ -10,7 +10,7 @@
 
 @dataclass
 class SplitConfig:
-    splits: Union[dict[dict[list[dict]]], None]  # Contains `{ method: { parameter_value: [splits] }}`
+    splits: Union[dict[dict[list[dict]]], None] = None  # Contains `{ method: { parameter_value: [splits] }}`
     method: str = None
     param: Union[int, float] = None
 
@@ -58,9 +58,9 @@ def get_split_config(method: str, param: Union[str, float, int], path_config: Pa
     file_names = get_file_names(path_config.train_data_dir)
 
     if method == "kfold":
-        splits[method][param] = kfold_split(file_names, param)
+        splits[method][param] = kfold_split(file_names, int(param))
     elif method == "simple_train_val_split":
-        splits[method][param] = simple_split(file_names, param)
+        splits[method][param] = simple_split(file_names, float(param))
     else:
         assert split_is_precomputed(
             splits, method, param
diff --git a/yucca/training/data_loading/YuccaDataModule.py b/yucca/training/data_loading/YuccaDataModule.py
index 7a0598ef..e30399bf 100644
--- a/yucca/training/data_loading/YuccaDataModule.py
+++ b/yucca/training/data_loading/YuccaDataModule.py
@@ -1,5 +1,6 @@
 import lightning as pl
 import torchvision
+import logging
 import torch
 from typing import Literal, Optional
 from torch.utils.data import DataLoader, Sampler
@@ -9,7 +10,6 @@
 from yucca.training.configuration.configure_plans import PlanConfig
 from yucca.training.data_loading.YuccaDataset import YuccaTestDataset, YuccaTrainDataset
 from yucca.training.data_loading.samplers import InfiniteRandomSampler
-import logging
 
 
 class YuccaDataModule(pl.LightningDataModule):
@@ -89,7 +89,7 @@ def __init__(
         logging.info(f"Using {self.num_workers} workers")
 
     def setup(self, stage: Literal["fit", "test", "predict"]):
-        print(f"Setting up data for stage: {stage}")
+        logging.info(f"Setting up data for stage: {stage}")
         expected_stages = ["fit", "test", "predict"]
         assert stage in expected_stages, "unexpected stage. " f"Expected: {expected_stages} and found: {stage}"
 
@@ -100,6 +100,9 @@ def setup(self, stage: Literal["fit", "test", "predict"]):
             self.train_samples = [join(self.train_data_dir, i) for i in self.splits_config.train(self.split_idx)]
             self.val_samples = [join(self.train_data_dir, i) for i in self.splits_config.val(self.split_idx)]
 
+            logging.info(f"Training on samples: {self.train_samples}")
+            logging.info(f"Validating on samples: {self.val_samples}")
+
             self.train_dataset = YuccaTrainDataset(
                 self.train_samples,
                 composed_transforms=self.composed_train_transforms,
@@ -121,7 +124,7 @@ def setup(self, stage: Literal["fit", "test", "predict"]):
             self.pred_dataset = YuccaTestDataset(self.pred_data_dir, suffix=self.image_extension)
 
     def train_dataloader(self):
-        print(f"Starting training with data from: {self.train_data_dir}")
+        logging.info(f"Starting training with data from: {self.train_data_dir}")
         sampler = self.train_sampler(self.train_dataset) if self.train_sampler is not None else None
         return DataLoader(
             self.train_dataset,
@@ -146,5 +149,5 @@ def test_dataloader(self):
         return None
 
     def predict_dataloader(self):
-        print("Starting inference")
+        logging.info("Starting inference")
         return DataLoader(self.pred_dataset, num_workers=self.num_workers, batch_size=1)
diff --git a/yucca/training/data_loading/YuccaDataset.py b/yucca/training/data_loading/YuccaDataset.py
index 8d8e5acb..89c4cdb9 100644
--- a/yucca/training/data_loading/YuccaDataset.py
+++ b/yucca/training/data_loading/YuccaDataset.py
@@ -5,9 +5,7 @@
 import logging
 from batchgenerators.utilities.file_and_folder_operations import subfiles, load_pickle
 from yucca.image_processing.transforms.cropping_and_padding import CropPad
-from yucca.image_processing.transforms.formatting import (
-    NumpyToTorch,
-)
+from yucca.image_processing.transforms.formatting import NumpyToTorch
 
 
 class YuccaTrainDataset(torch.utils.data.Dataset):
@@ -98,7 +96,7 @@ def __getitem__(self, idx):
         elif self.task_type == "unsupervised":
             data_dict = {"image": data, "label": None}
         else:
-            print(f"Task Type not recognized. Found {self.task_type}")
+            logging.error(f"Task Type not recognized. Found {self.task_type}")
         return self._transform(data_dict, case)
 
     def _transform(self, data_dict, case):
diff --git a/yucca/training/managers/YuccaManager.py b/yucca/training/managers/YuccaManager.py
index edf9adcf..0798b0f4 100644
--- a/yucca/training/managers/YuccaManager.py
+++ b/yucca/training/managers/YuccaManager.py
@@ -65,8 +65,8 @@ def __init__(
         precision: str = "bf16-mixed",
         profile: bool = False,
         split_idx: int = 0,
-        split_data_ratio: float = None,
-        split_data_kfold: int = 5,
+        split_data_method: str = "kfold",
+        split_data_param: int = 5,
         step_logging: bool = False,
         task: str = None,
         experiment: str = "default",
@@ -79,13 +79,13 @@ def __init__(
         self.deep_supervision = deep_supervision
         self.enable_logging = enable_logging
         self.experiment = experiment
-        self.learning_rate = learning_rate
+        self.learning_rate = float(learning_rate)
         self.loss = loss
         self.max_epochs = max_epochs
         self.max_vram = max_vram
         self.model_dimensions = model_dimensions
         self.model_name = model_name
-        self.momentum = momentum
+        self.momentum = float(momentum)
         self.name = self.__class__.__name__
         self.num_workers = num_workers
         self.augmentation_params = augmentation_params
@@ -96,8 +96,8 @@ def __init__(
         self.precision = precision
         self.profile = profile
         self.split_idx = split_idx
-        self.split_data_ratio = split_data_ratio
-        self.split_data_kfold = split_data_kfold
+        self.split_data_method = split_data_method
+        self.split_data_param = split_data_param
         self.step_logging = step_logging
         self.task = task
         self.train_batches_per_step = train_batches_per_step
@@ -114,6 +114,7 @@ def __init__(
             if not torch.cuda.is_bf16_supported():
                 self.precision = self.precision.replace("bf", "")
 
+        # Statics
         self.trainer = L.Trainer
 
     def initialize(
@@ -136,8 +137,8 @@ def initialize(
             planner_name=self.planner,
             experiment=self.experiment,
             split_idx=self.split_idx,
-            split_data_ratio=self.split_data_ratio,
-            split_data_kfold=self.split_data_kfold,
+            split_data_method=self.split_data_method,
+            split_data_param=self.split_data_param,
         )
 
         path_config = get_path_config(task_config=task_config)
@@ -157,6 +158,20 @@ def initialize(
             stage=stage,
         )
 
+        callback_config = get_callback_config(
+            save_dir=path_config.save_dir,
+            version_dir=path_config.version_dir,
+            ckpt_version_dir=self.ckpt_config.ckpt_version_dir,
+            ckpt_wandb_id=self.ckpt_config.ckpt_wandb_id,
+            experiment=task_config.experiment,
+            version=path_config.version,
+            enable_logging=self.enable_logging,
+            log_lr=True,
+            prediction_output_dir=prediction_output_dir,
+            profile=self.profile,
+            save_softmax=save_softmax,
+        )
+
         if stage == "fit":
             splits_config = get_split_config(task_config.split_method, task_config.split_param, path_config)
         else:
@@ -181,20 +196,6 @@ def initialize(
             task_type_preset=plan_config.task_type,
         )
 
-        callback_config = get_callback_config(
-            save_dir=path_config.save_dir,
-            version_dir=path_config.version_dir,
-            ckpt_version_dir=self.ckpt_config.ckpt_version_dir,
-            ckpt_wandb_id=self.ckpt_config.ckpt_wandb_id,
-            experiment=task_config.experiment,
-            version=path_config.version,
-            enable_logging=self.enable_logging,
-            log_lr=True,
-            prediction_output_dir=prediction_output_dir,
-            profile=self.profile,
-            save_softmax=save_softmax,
-        )
-
         self.model_module = YuccaLightningModule(
             config=task_config.lm_hparams()
             | path_config.lm_hparams()
@@ -226,8 +227,8 @@ def initialize(
         )
 
         if (
-            not isinstance(self.data_module.train_sampler, InfiniteRandomSampler) and self.train_batches_per_step is not None
-        ) or (not isinstance(self.data_module.val_sampler, InfiniteRandomSampler) and self.val_batches_per_step is not None):
+            not issubclass(self.data_module.train_sampler, InfiniteRandomSampler) and self.train_batches_per_step is not None
+        ) or (not issubclass(self.data_module.val_sampler, InfiniteRandomSampler) and self.val_batches_per_step is not None):
             print("Warning: you are limiting the amount of batches pr. step, but not sampling using InfiniteRandomSampler.")
 
         self.trainer = L.Trainer(
@@ -235,6 +236,7 @@ def initialize(
             default_root_dir=path_config.save_dir,
             limit_train_batches=self.train_batches_per_step,
             limit_val_batches=self.val_batches_per_step,
+            log_every_n_steps=min(self.train_batches_per_step, 50),
             logger=callback_config.loggers,
             precision=self.precision,
             profiler=callback_config.profiler,
diff --git a/yucca/training/managers/alternative_trainers/YuccaManager_NoPatches.py b/yucca/training/managers/alternative_managers/YuccaManager_NoPatches.py
similarity index 100%
rename from yucca/training/managers/alternative_trainers/YuccaManager_NoPatches.py
rename to yucca/training/managers/alternative_managers/YuccaManager_NoPatches.py
diff --git a/yucca/training/managers/alternative_trainers/YuccaManager_PatchSizeMax.py b/yucca/training/managers/alternative_managers/YuccaManager_PatchSizeMax.py
similarity index 100%
rename from yucca/training/managers/alternative_trainers/YuccaManager_PatchSizeMax.py
rename to yucca/training/managers/alternative_managers/YuccaManager_PatchSizeMax.py
diff --git a/yucca/training/managers/alternative_trainers/__init__.py b/yucca/training/managers/alternative_managers/__init__.py
similarity index 100%
rename from yucca/training/managers/alternative_trainers/__init__.py
rename to yucca/training/managers/alternative_managers/__init__.py
diff --git a/yucca/training/managers/lr/YuccaManager_1e2.py b/yucca/training/managers/lr/YuccaManager_1e2.py
deleted file mode 100644
index b1b7b5ba..00000000
--- a/yucca/training/managers/lr/YuccaManager_1e2.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from yucca.training.managers.YuccaManager import YuccaManager
-
-
-class YuccaManager_1e2(YuccaManager):
-    def __init__(
-        self,
-        model,
-        model_dimensions: str,
-        task: str,
-        folds: str | int,
-        plan_id: str,
-        starting_lr: float = None,
-        loss_fn: str = None,
-        momentum: float = None,
-        continue_training: bool = False,
-    ):
-        super().__init__(model, model_dimensions, task, folds, plan_id, starting_lr, loss_fn, momentum, continue_training)
-        self._DEFAULT_STARTING_LR = 1e-2
diff --git a/yucca/training/managers/lr/YuccaManager_1e5.py b/yucca/training/managers/lr/YuccaManager_1e5.py
new file mode 100644
index 00000000..60336e87
--- /dev/null
+++ b/yucca/training/managers/lr/YuccaManager_1e5.py
@@ -0,0 +1,7 @@
+from yucca.training.managers.YuccaManager import YuccaManager
+
+
+class YuccaManager_1e5(YuccaManager):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.learning_rate = 1e-5
diff --git a/yucca/utils/saving.py b/yucca/utils/saving.py
index 1adb61cb..13956bae 100644
--- a/yucca/utils/saving.py
+++ b/yucca/utils/saving.py
@@ -89,7 +89,7 @@ def __init__(self, output_dir, save_softmax, write_interval):
         self.output_dir = output_dir
         self.save_softmax = save_softmax
 
-    def write_on_batch_end(self, _trainer, _pl_module, data_dict, _batch_indices):
+    def write_on_batch_end(self, _trainer, _pl_module, data_dict, _batch_indices, _batch, _batch_idx, _dataloader_idx):
         # this will create N (num processes) files in `output_dir` each containing
         # the predictions of it's respective rank
         logits, properties, case_id = (


Test patch:
diff --git a/tests/conftest.py b/tests/conftest.py
index 1a16cef6..e67a6a93 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,12 +1,46 @@
 import pytest
 import os
+import shutil
+import subprocess
 from pathlib import Path
 
 
 @pytest.fixture(scope="session", autouse=True)
 def set_env():
-    os.environ["YUCCA_PREPROCESSED_DATA"] = str(Path(__file__).parent.absolute() / "data")
-    os.environ["YUCCA_RAW_DATA"] = str(Path(__file__).parent.absolute() / "data")
-    os.environ["YUCCA_MODELS"] = str(Path(__file__).parent.absolute() / "data")
-    os.environ["YUCCA_RESULTS"] = str(Path(__file__).parent.absolute() / "data")
-    os.environ["YUCCA_SOURCE"] = str(Path(__file__).parent.absolute() / "data")
+    os.environ["YUCCA_SOURCE"] = str(Path(__file__).parent.absolute() / "data" / "raw_unstructured_data")
+
+    yucca_raw_data = str(Path(__file__).parent.absolute() / "data" / "yucca_raw_data")
+    os.environ["YUCCA_RAW_DATA"] = yucca_raw_data
+    if os.path.isdir(yucca_raw_data):
+        shutil.rmtree(yucca_raw_data)
+
+    yucca_preprocessed_data = str(Path(__file__).parent.absolute() / "data" / "yucca_preprocessed")
+    os.environ["YUCCA_PREPROCESSED_DATA"] = yucca_preprocessed_data
+    if os.path.isdir(yucca_preprocessed_data):
+        shutil.rmtree(yucca_preprocessed_data)
+
+    yucca_models = str(Path(__file__).parent.absolute() / "data" / "yucca_models")
+    os.environ["YUCCA_MODELS"] = yucca_models
+    if os.path.isdir(yucca_models):
+        shutil.rmtree(yucca_models)
+
+    yucca_results = str(Path(__file__).parent.absolute() / "data" / "yucca_results")
+    os.environ["YUCCA_RESULTS"] = yucca_results
+    if os.path.isdir(yucca_results):
+        shutil.rmtree(yucca_results)
+
+
+@pytest.fixture
+def setup_preprocessed_segmentation_data(request):
+    from yucca.paths import yucca_raw_data, yucca_preprocessed_data
+
+    subprocess.run(["yucca_convert_task", "-t", "Task000_TEST_SEGMENTATION"], check=True)
+    subprocess.run(["yucca_preprocess", "-t", "Task000_TEST_SEGMENTATION"], check=True)
+
+    def finalizer():
+        shutil.rmtree(yucca_raw_data)
+        shutil.rmtree(yucca_preprocessed_data)
+
+    request.addfinalizer(finalizer)
+
+    return
diff --git a/tests/data/Task000_Test/YuccaPlanner/YuccaPlanner_plans.json b/tests/data/Task000_Test/YuccaPlanner/YuccaPlanner_plans.json
deleted file mode 100644
index 3c318fd6..00000000
--- a/tests/data/Task000_Test/YuccaPlanner/YuccaPlanner_plans.json
+++ /dev/null
@@ -1,18 +0,0 @@
-{
-    "preprocessor": "YuccaPreprocessor",
-    "dataset_properties":{
-        "classes": [
-            "0",
-            "1",
-            "2"
-        ],
-        "tasks": {},
-        "label_hierarchy": {},
-        "modalities": {
-            "0": "T1"
-        }
-    },
-    "new_min_size": [32,32,32],
-    "new_mean_size": [32,32,32],
-    "new_max_size": [32,32,32]
-}
diff --git a/tests/data/Task000_Test/YuccaPlanner/testsubject_1.npy b/tests/data/Task000_Test/YuccaPlanner/testsubject_1.npy
deleted file mode 100644
index 528cbaa5..00000000
Binary files a/tests/data/Task000_Test/YuccaPlanner/testsubject_1.npy and /dev/null differ
diff --git a/tests/data/Task000_Test/YuccaPlanner/testsubject_1.pkl b/tests/data/Task000_Test/YuccaPlanner/testsubject_1.pkl
deleted file mode 100644
index 29782ca3..00000000
Binary files a/tests/data/Task000_Test/YuccaPlanner/testsubject_1.pkl and /dev/null differ
diff --git a/tests/data/Task000_Test/YuccaPlanner/testsubject_2.npy b/tests/data/Task000_Test/YuccaPlanner/testsubject_2.npy
deleted file mode 100644
index 528cbaa5..00000000
Binary files a/tests/data/Task000_Test/YuccaPlanner/testsubject_2.npy and /dev/null differ
diff --git a/tests/data/Task000_Test/YuccaPlanner/testsubject_2.pkl b/tests/data/Task000_Test/YuccaPlanner/testsubject_2.pkl
deleted file mode 100644
index 29782ca3..00000000
Binary files a/tests/data/Task000_Test/YuccaPlanner/testsubject_2.pkl and /dev/null differ
diff --git a/tests/data/Task000_Test/YuccaPlanner/testsubject_3.npy b/tests/data/Task000_Test/YuccaPlanner/testsubject_3.npy
deleted file mode 100644
index 528cbaa5..00000000
Binary files a/tests/data/Task000_Test/YuccaPlanner/testsubject_3.npy and /dev/null differ
diff --git a/tests/data/Task000_Test/YuccaPlanner/testsubject_3.pkl b/tests/data/Task000_Test/YuccaPlanner/testsubject_3.pkl
deleted file mode 100644
index 29782ca3..00000000
Binary files a/tests/data/Task000_Test/YuccaPlanner/testsubject_3.pkl and /dev/null differ
diff --git a/tests/data/Task000_Test/YuccaPlanner/testsubject_4.npy b/tests/data/Task000_Test/YuccaPlanner/testsubject_4.npy
deleted file mode 100644
index 528cbaa5..00000000
Binary files a/tests/data/Task000_Test/YuccaPlanner/testsubject_4.npy and /dev/null differ
diff --git a/tests/data/Task000_Test/YuccaPlanner/testsubject_4.pkl b/tests/data/Task000_Test/YuccaPlanner/testsubject_4.pkl
deleted file mode 100644
index 29782ca3..00000000
Binary files a/tests/data/Task000_Test/YuccaPlanner/testsubject_4.pkl and /dev/null differ
diff --git a/tests/data/Task000_Test/YuccaPlanner/testsubject_5.npy b/tests/data/Task000_Test/YuccaPlanner/testsubject_5.npy
deleted file mode 100644
index 528cbaa5..00000000
Binary files a/tests/data/Task000_Test/YuccaPlanner/testsubject_5.npy and /dev/null differ
diff --git a/tests/data/Task000_Test/YuccaPlanner/testsubject_5.pkl b/tests/data/Task000_Test/YuccaPlanner/testsubject_5.pkl
deleted file mode 100644
index 29782ca3..00000000
Binary files a/tests/data/Task000_Test/YuccaPlanner/testsubject_5.pkl and /dev/null differ
diff --git a/tests/data/Task000_Test/splits.pkl b/tests/data/Task000_Test/splits.pkl
deleted file mode 100644
index 8528e6d6..00000000
Binary files a/tests/data/Task000_Test/splits.pkl and /dev/null differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0/all_images/test_0.nii.gz b/tests/data/raw_unstructured_data/dataset_test0/all_images/test_0.nii.gz
new file mode 100644
index 00000000..463548d2
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0/all_images/test_0.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0/all_images/test_1.nii.gz b/tests/data/raw_unstructured_data/dataset_test0/all_images/test_1.nii.gz
new file mode 100644
index 00000000..df0903a6
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0/all_images/test_1.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0/all_images/test_2.nii.gz b/tests/data/raw_unstructured_data/dataset_test0/all_images/test_2.nii.gz
new file mode 100644
index 00000000..2bbfdb3f
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0/all_images/test_2.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0/all_images/test_3.nii.gz b/tests/data/raw_unstructured_data/dataset_test0/all_images/test_3.nii.gz
new file mode 100644
index 00000000..6b909477
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0/all_images/test_3.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0/all_images/test_4.nii.gz b/tests/data/raw_unstructured_data/dataset_test0/all_images/test_4.nii.gz
new file mode 100644
index 00000000..737833f5
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0/all_images/test_4.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0/all_images/test_5.nii.gz b/tests/data/raw_unstructured_data/dataset_test0/all_images/test_5.nii.gz
new file mode 100644
index 00000000..be01cde3
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0/all_images/test_5.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0/all_images/test_6.nii.gz b/tests/data/raw_unstructured_data/dataset_test0/all_images/test_6.nii.gz
new file mode 100644
index 00000000..58254af0
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0/all_images/test_6.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_0.nii.gz b/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_0.nii.gz
new file mode 100644
index 00000000..05b06ccf
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_0.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_1.nii.gz b/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_1.nii.gz
new file mode 100644
index 00000000..c7ceb707
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_1.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_2.nii.gz b/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_2.nii.gz
new file mode 100644
index 00000000..b660b4c2
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_2.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_3.nii.gz b/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_3.nii.gz
new file mode 100644
index 00000000..d1c0777f
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_3.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_4.nii.gz b/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_4.nii.gz
new file mode 100644
index 00000000..4a758642
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_4.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_5.nii.gz b/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_5.nii.gz
new file mode 100644
index 00000000..08db3671
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_5.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_6.nii.gz b/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_6.nii.gz
new file mode 100644
index 00000000..54443962
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0/all_labels/test_6.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_0.nii.gz b/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_0.nii.gz
new file mode 100644
index 00000000..463548d2
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_0.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_1.nii.gz b/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_1.nii.gz
new file mode 100644
index 00000000..df0903a6
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_1.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_2.nii.gz b/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_2.nii.gz
new file mode 100644
index 00000000..2bbfdb3f
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_2.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_3.nii.gz b/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_3.nii.gz
new file mode 100644
index 00000000..6b909477
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_3.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_4.nii.gz b/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_4.nii.gz
new file mode 100644
index 00000000..737833f5
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_4.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_5.nii.gz b/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_5.nii.gz
new file mode 100644
index 00000000..be01cde3
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_5.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_6.nii.gz b/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_6.nii.gz
new file mode 100644
index 00000000..58254af0
Binary files /dev/null and b/tests/data/raw_unstructured_data/dataset_test0_classification/all_images/test_6.nii.gz differ
diff --git a/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_0.txt b/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_0.txt
new file mode 100644
index 00000000..573541ac
--- /dev/null
+++ b/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_0.txt
@@ -0,0 +1,1 @@
+0
diff --git a/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_1.txt b/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_1.txt
new file mode 100644
index 00000000..573541ac
--- /dev/null
+++ b/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_1.txt
@@ -0,0 +1,1 @@
+0
diff --git a/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_2.txt b/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_2.txt
new file mode 100644
index 00000000..573541ac
--- /dev/null
+++ b/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_2.txt
@@ -0,0 +1,1 @@
+0
diff --git a/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_3.txt b/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_3.txt
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_3.txt
@@ -0,0 +1,1 @@
+1
diff --git a/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_4.txt b/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_4.txt
new file mode 100644
index 00000000..573541ac
--- /dev/null
+++ b/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_4.txt
@@ -0,0 +1,1 @@
+0
diff --git a/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_5.txt b/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_5.txt
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_5.txt
@@ -0,0 +1,1 @@
+1
diff --git a/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_6.txt b/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_6.txt
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/tests/data/raw_unstructured_data/dataset_test0_classification/all_labels/test_6.txt
@@ -0,0 +1,1 @@
+1
diff --git a/tests/test_configurations.py b/tests/test_configurations.py
index 5641571d..16caf809 100644
--- a/tests/test_configurations.py
+++ b/tests/test_configurations.py
@@ -1,5 +1,4 @@
-def test_configurations():
-    import os
+def test_configurations(setup_preprocessed_segmentation_data):
     from yucca.training.configuration.configure_callbacks import get_callback_config
     from yucca.training.configuration.configure_paths import get_path_config
     from yucca.training.configuration.configure_plans import get_plan_config
@@ -8,9 +7,8 @@ def test_configurations():
     from yucca.training.configuration.split_data import get_split_config
     from yucca.training.configuration.configure_checkpoint import get_checkpoint_config
     from yucca.training.configuration.configure_seed import seed_everything_and_get_seed_config
-    from yucca.paths import yucca_preprocessed_data
 
-    task_config = get_task_config(task="Task000_Test")
+    task_config = get_task_config(task="Task000_TEST_SEGMENTATION")
     assert task_config is not None and isinstance(task_config.continue_from_most_recent, bool)
 
     path_config = get_path_config(task_config=task_config)
diff --git a/tests/test_end_to_end.py b/tests/test_end_to_end.py
new file mode 100644
index 00000000..a8f556fe
--- /dev/null
+++ b/tests/test_end_to_end.py
@@ -0,0 +1,125 @@
+import os
+import subprocess
+
+
+def test_task_convert():
+    subprocess.run(["yucca_convert_task", "-t", "Task000_TEST_SEGMENTATION"], check=True)
+    subprocess.run(["yucca_convert_task", "-t", "Task000_TEST_CLASSIFICATION"], check=True)
+    subprocess.run(["yucca_convert_task", "-t", "Task000_TEST_UNSUPERVISED"], check=True)
+
+
+def test_preprocessing():
+    subprocess.run(["yucca_preprocess", "-t", "Task000_TEST_SEGMENTATION"], check=True)
+    subprocess.run(["yucca_preprocess", "-t", "Task000_TEST_UNSUPERVISED", "-pl", "UnsupervisedPlanner"], check=True)
+    subprocess.run(
+        [
+            "yucca_preprocess",
+            "-t",
+            "Task000_TEST_CLASSIFICATION",
+            "-pl",
+            "YuccaPlanner_MaxSize",
+            "-pr",
+            "ClassificationPreprocessor",
+        ],
+        check=True,
+    )
+
+
+def test_training():
+    # First: a very basic short training
+    subprocess.run(
+        [
+            "yucca_train",
+            "-t",
+            "Task000_TEST_SEGMENTATION",
+            "-m",
+            "TinyUNet",
+            "--epochs",
+            "2",
+            "--batch_size",
+            "2",
+            "--disable_logging",
+            "--train_batches_per_step",
+            "3",
+            "--val_batches_per_step",
+            "3",
+        ],
+        check=True,
+    )
+
+
+def test_finetune():
+    from yucca.paths import yucca_models
+
+    chk = os.path.join(
+        yucca_models,
+        "Task000_TEST_SEGMENTATION",
+        "TinyUNet__3D",
+        "YuccaManager__YuccaPlanner",
+        "default",
+        "kfold_5_fold_0",
+        "version_0",
+        "checkpoints",
+        "best.ckpt",
+    )
+    # Second: a training with a lot of changed parameters
+    subprocess.run(
+        [
+            "yucca_finetune",
+            "-t",
+            "Task000_TEST_UNSUPERVISED",
+            "-chk",
+            chk,
+            "-m",
+            "TinyUNet",
+            "-d",
+            "2D",
+            "-pl",
+            "UnsupervisedPlanner",
+            "--lr",
+            "0.0006",
+            "--mom",
+            "0.99",
+            "--disable_logging",
+            "--new_version",
+            "--profile",
+            "--experiment",
+            "NonDefault",
+            "--patch_size",
+            "32",
+            "--split_idx",
+            "0",
+            "--split_data_param",
+            "0.7",
+            "--split_data_method",
+            "simple_train_val_split",
+            "--epochs",
+            "2",
+            "--batch_size",
+            "2",
+            "--train_batches_per_step",
+            "2",
+            "--val_batches_per_step",
+            "2",
+        ],
+        check=True,
+    )
+
+
+def test_inference():
+    # First: a very basic short training
+    subprocess.run(
+        [
+            "yucca_inference",
+            "-s",
+            "Task000_TEST_SEGMENTATION",
+            "-t",
+            "Task000_TEST_SEGMENTATION",
+            "-d",
+            "3D",
+            "-m",
+            "TinyUNet",
+            "--no_wandb",
+        ],
+        check=True,
+    )
diff --git a/tests/test_training.py b/tests/test_training.py
deleted file mode 100644
index ab033288..00000000
--- a/tests/test_training.py
+++ /dev/null
@@ -1,29 +0,0 @@
-def test_2D_training():
-    from yucca.training.managers.YuccaManager import YuccaManager
-
-    manager = YuccaManager(
-        task="Task000_Test",
-        fast_dev_run=True,
-        enable_logging=False,
-        model_name="TinyUNet",
-        model_dimensions="2D",
-        precision="bf16-mixed",
-        accelerator="cpu",
-    )
-    manager.run_training()
-
-
-def test_3D_training():
-    from yucca.training.managers.YuccaManager import YuccaManager
-
-    manager = YuccaManager(
-        task="Task000_Test",
-        fast_dev_run=True,
-        enable_logging=False,
-        model_name="TinyUNet",
-        model_dimensions="3D",
-        num_workers=0,
-        precision="bf16-mixed",
-        accelerator="cpu",
-    )
-    manager.run_training()
diff --git a/yucca/documentation/tests/transforms/augmentation_timings.ipynb b/yucca/documentation/tests/transforms/augmentation_timings.ipynb
index 4039a1ad..cddcd215 100644
--- a/yucca/documentation/tests/transforms/augmentation_timings.ipynb
+++ b/yucca/documentation/tests/transforms/augmentation_timings.ipynb
@@ -2,14 +2,15 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Data is shaped : (1, 1, 256, 287, 256)\n"
+      "3D shape:  (128, 96, 24)\n",
+      "3D shape with batch and channel dimension:  (2, 1, 128, 96, 24)\n"
      ]
     }
    ],
@@ -33,51 +34,56 @@
     "im = nib.load(example_file)\n",
     "imarr = im.get_fdata()[:, :, :, 0]\n",
     "\n",
-    "# If you want to use a local example for more realistic times, replace the imarr variable\n",
-    "# My local variable:\n",
-    "local_file = '/home/zcr545/YuccaData/yucca_raw_data/Task001_TestTask/imagesTr/TestTask_1000_000.nii.gz'\n",
-    "im = nib.load(local_file)\n",
-    "imarr = im.get_fdata()\n",
+    "\n",
+    "# If you want to use a local example for dataset specific times, \n",
+    "# uncomment the following and supply the path to a local image the imarr variable\n",
+    "\n",
+    "#local_file = 'YOUR/PATH/HERE'\n",
+    "#im = nib.load(local_file)\n",
+    "#imarr = im.get_fdata()\n",
     "\n",
     "# Convert it to the format expected of the transforms\n",
     "# a dict of {\"image\": image, \"seg\": segmentation}\n",
     "# with samples for dims (b, c, x, y, z) for 3D or (b, c, x, y) for 2D\n",
+    "# In this case we use slice 12 for an image of (128, 96, 24) - adapt this as you please.\n",
+    "print(\"3D shape: \", imarr.shape)\n",
     "imarr = imarr[np.newaxis, np.newaxis]\n",
+    "imarr = np.vstack([imarr]*2)\n",
     "seg = np.zeros(imarr.shape)\n",
-    "datadict = {\"image\": imarr, \"seg\": seg}\n",
-    "print(\"Data is shaped :\", imarr.shape)"
+    "datadict = {\"image\": imarr, \"label\": seg}\n",
+    "print(\"3D shape with batch and channel dimension: \", imarr.shape)\n",
+    "\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
     "idx = np.array(imarr.shape[2:])//4\n",
     "imarr_half = imarr[:, :, idx[0]:-idx[0], idx[1]:-idx[1], idx[2]:-idx[2]]\n",
     "seg_half = np.zeros(imarr_half.shape)\n",
-    "datadict_half = {\"image\": imarr_half, \"seg\": seg_half}"
+    "datadict_half = {\"image\": imarr_half, \"label\": seg_half}"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Rotation:  8.736863824000011 \n",
-      "  Rotation half:  1.0467968265002128\n"
+      "Rotation:  0.4538204999998925 \n",
+      "  Rotation half:  0.04848909999986972\n"
      ]
     }
    ],
    "source": [
     "# Applying Rotation\n",
-    "tform = Spatial(do_rot=True,\n",
-    "                x_rot_in_degrees=(0, 0),\n",
+    "tform = Spatial(x_rot_in_degrees=(0, 0),\n",
     "                y_rot_in_degrees=(0, 0),\n",
     "                z_rot_in_degrees=(45, 45))\n",
     "print(\"Rotation: \", timeit.timeit(lambda: tform(**deepcopy(datadict)), number=iterations)/iterations, \"\\n \",\n",
@@ -86,15 +92,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Deformation:  18.89154750749958 \n",
-      "  Deformation half:  2.274235193000095\n"
+      "Deformation:  0.2743619000000308 \n",
+      "  Deformation half:  0.05162790000008499\n"
      ]
     }
    ],
@@ -102,8 +108,7 @@
     "# Applying Deformation\n",
     "from yucca.image_processing.transforms.Spatial import Spatial\n",
     "\n",
-    "tform = Spatial(do_deform=True,\n",
-    "                deform_alpha=(700, 700),\n",
+    "tform = Spatial(deform_alpha=(700, 700),\n",
     "                deform_sigma=(10, 10))\n",
     "print(\"Deformation: \", timeit.timeit(lambda: tform(**deepcopy(datadict)), number=iterations)/iterations, \"\\n \",\n",
     "      \"Deformation half: \", timeit.timeit(lambda: tform(**deepcopy(datadict_half)), number=iterations)/iterations)\n"
@@ -111,50 +116,46 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Scaling:  5.013034512499871 \n",
-      "  Scaling half:  0.638087225000163\n"
+      "Scaling:  0.3436143499998252 \n",
+      "  Scaling half:  0.045838400000093316\n"
      ]
     }
    ],
    "source": [
     "# Applying Scaling\n",
-    "tform = Spatial(do_scale=True,\n",
-    "                scale_factor=(1.5, 1.5))\n",
+    "tform = Spatial(scale_factor=(1.5, 1.5))\n",
     "print(\"Scaling: \", timeit.timeit(lambda: tform(**deepcopy(datadict)), number=iterations)/iterations, \"\\n \",\n",
     "      \"Scaling half: \", timeit.timeit(lambda: tform(**deepcopy(datadict_half)), number=iterations)/iterations)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Rotation, Deformation and Scaling WITHOUT cropping:  14.831546043000344 \n",
-      "  Rotation, Deformation and Scaling WITHOUT cropping half:  1.8724256274999789\n"
+      "Rotation, Deformation and Scaling WITHOUT cropping:  0.2800752000000557 \n",
+      "  Rotation, Deformation and Scaling WITHOUT cropping half:  0.0313183000000663\n"
      ]
     }
    ],
    "source": [
     "# Applying Rotation, Deformation and Scaling WITHOUT cropping\n",
-    "tform = Spatial(do_rot=True,\n",
-    "                x_rot_in_degrees=(0, 0),\n",
+    "tform = Spatial(x_rot_in_degrees=(0, 0),\n",
     "                y_rot_in_degrees=(0, 0),\n",
     "                z_rot_in_degrees=(45, 45),\n",
-    "                do_deform=True,\n",
     "                deform_alpha=(700, 700),\n",
     "                deform_sigma=(10, 10),\n",
-    "                do_scale=True,\n",
     "                scale_factor=(1.5, 1.5))\n",
     "print(\"Rotation, Deformation and Scaling WITHOUT cropping: \", timeit.timeit(lambda: tform(**deepcopy(datadict)), number=iterations)/iterations, \"\\n \",\n",
     "      \"Rotation, Deformation and Scaling WITHOUT cropping half: \", timeit.timeit(lambda: tform(**deepcopy(datadict_half)), number=iterations)/iterations)\n",
@@ -163,42 +164,36 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Rotation, Deformation and Scaling WITH cropping:  3.245525150499816 \n",
-      "  Rotation, Deformation and Scaling WITH cropping half:  1.8999758925001515\n"
+      "Rotation, Deformation and Scaling WITH cropping:  0.06260975000009239 \n",
+      "  Rotation, Deformation and Scaling WITH cropping half:  0.030556599999954415\n"
      ]
     }
    ],
    "source": [
     "# Applying Rotation, Deformation and Scaling WITH cropping\n",
-    "tform = Spatial(do_crop=True,\n",
+    "tform = Spatial(crop=True,\n",
     "                patch_size=np.array(imarr.shape[2:])//2,\n",
-    "                do_rot=True,\n",
     "                x_rot_in_degrees=(0, 0),\n",
     "                y_rot_in_degrees=(0, 0),\n",
     "                z_rot_in_degrees=(45, 45),\n",
-    "                do_deform=True,\n",
     "                deform_alpha=(700, 700),\n",
     "                deform_sigma=(10, 10),\n",
-    "                do_scale=True,\n",
     "                scale_factor=(1.5, 1.5))\n",
     "# Applying Rotation, Deformation and Scaling WITH cropping\n",
-    "tform2 = Spatial(do_crop=True,\n",
+    "tform2 = Spatial(crop=True,\n",
     "                patch_size=np.array(imarr_half.shape[2:])//2,\n",
-    "                do_rot=True,\n",
     "                x_rot_in_degrees=(0, 0),\n",
     "                y_rot_in_degrees=(0, 0),\n",
     "                z_rot_in_degrees=(45, 45),\n",
-    "                do_deform=True,\n",
     "                deform_alpha=(700, 700),\n",
     "                deform_sigma=(10, 10),\n",
-    "                do_scale=True,\n",
     "                scale_factor=(1.5, 1.5))\n",
     "print(\"Rotation, Deformation and Scaling WITH cropping: \", timeit.timeit(lambda: tform(**deepcopy(datadict)), number=iterations)/iterations, \"\\n \",\n",
     "      \"Rotation, Deformation and Scaling WITH cropping half: \", timeit.timeit(lambda: tform(**deepcopy(datadict_half)), number=iterations)/iterations)\n",
@@ -207,15 +202,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Additive Noise:  1.4583239190001223 \n",
-      "  Additive Noise half:  0.168274997500248\n"
+      "Additive Noise:  0.030095100000153252 \n",
+      "  Additive Noise half:  0.004527999999936583\n"
      ]
     }
    ],
@@ -229,15 +224,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Multiplicative Noise:  1.7251039340003445 \n",
-      "  Multiplicative Noise half:  0.19161714600022606\n"
+      "Multiplicative Noise:  0.054680250000046726 \n",
+      "  Multiplicative Noise half:  0.005203549999805546\n"
      ]
     }
    ],
@@ -253,15 +248,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Bias Field:  6.7102291085002435 \n",
-      "  Bias Field half:  0.5645473719996517\n"
+      "Bias Field:  0.11863205000008747 \n",
+      "  Bias Field half:  0.013049900000169146\n"
      ]
     }
    ],
@@ -274,15 +269,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Motion Ghosting:  3.656702298500022 \n",
-      "  Motion Ghosting half:  0.4397559460003322\n"
+      "Motion Ghosting:  0.13636829999995825 \n",
+      "  Motion Ghosting half:  0.015186950000042998\n"
      ]
     }
    ],
@@ -290,22 +285,22 @@
     "# Applying Motion Ghosting\n",
     "tform = MotionGhosting(p_per_sample=1, alpha=(0.6, 0.6),\n",
     "                       numReps=(3, 4),\n",
-    "                       dims=(0, 1))\n",
+    "                       axes=(0, 1))\n",
     "print(\"Motion Ghosting: \", timeit.timeit(lambda: tform(**deepcopy(datadict)), number=iterations)/iterations, \"\\n \",\n",
     "      \"Motion Ghosting half: \", timeit.timeit(lambda: tform(**deepcopy(datadict_half)), number=iterations)/iterations)\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Gibbs Ringing:  3.764839685500192 \n",
-      "  Gibbs Ringing half:  0.47306435049995343\n"
+      "Gibbs Ringing:  0.13577650000001995 \n",
+      "  Gibbs Ringing half:  0.01198219999992034\n"
      ]
     }
    ],
@@ -313,7 +308,7 @@
     "\n",
     "# Applying Gibbs Ringing\n",
     "tform = GibbsRinging(p_per_sample=1, cutFreq=(30, 36),\n",
-    "                     dim=(0, 1))\n",
+    "                     axes=(0, 1))\n",
     "print(\"Gibbs Ringing: \", timeit.timeit(lambda: tform(**deepcopy(datadict)), number=iterations)/iterations, \"\\n \",\n",
     "      \"Gibbs Ringing half: \", timeit.timeit(lambda: tform(**deepcopy(datadict_half)), number=iterations)/iterations)\n"
    ]
@@ -335,7 +330,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.15"
+   "version": "3.10.13"
   },
   "orig_nbformat": 4,
   "vscode": {
diff --git a/yucca/documentation/tests/transforms/augmentation_timings2D.ipynb b/yucca/documentation/tests/transforms/augmentation_timings2D.ipynb
index 9ffae555..bf1d3e94 100644
--- a/yucca/documentation/tests/transforms/augmentation_timings2D.ipynb
+++ b/yucca/documentation/tests/transforms/augmentation_timings2D.ipynb
@@ -2,14 +2,16 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Data is shaped : (50, 1, 287, 256)\n"
+      "3D shape:  (128, 96, 24)\n",
+      "2D shape:  (128, 96)\n",
+      "2D shape with batch and channel dimension:  (50, 1, 128, 96)\n"
      ]
     }
    ],
@@ -33,52 +35,55 @@
     "im = nib.load(example_file)\n",
     "imarr = im.get_fdata()[:, :, :, 0]\n",
     "\n",
-    "# If you want to use a local example for more realistic times, replace the imarr variable\n",
-    "# My local variable:\n",
-    "local_file = '/home/zcr545/YuccaData/yucca_raw_data/Task001_TestTask/imagesTr/TestTask_1000_000.nii.gz'\n",
-    "im = nib.load(local_file)\n",
-    "imarr = im.get_fdata()\n",
+    "# If you want to use a local example for dataset specific times, \n",
+    "# uncomment the following and supply the path to a local image the imarr variable\n",
+    "\n",
+    "#local_file = 'YOUR/PATH/HERE'\n",
+    "#im = nib.load(local_file)\n",
+    "#imarr = im.get_fdata()\n",
     "\n",
     "# Convert it to the format expected of the transforms\n",
     "# a dict of {\"image\": image, \"seg\": segmentation}\n",
     "# with samples for dims (b, c, x, y, z) for 3D or (b, c, x, y) for 2D\n",
-    "imarr = imarr[np.newaxis, np.newaxis, 120]\n",
+    "# In this case we use slice 12 for an image of (128, 96, 24) - adapt this as you please.\n",
+    "print(\"3D shape: \", imarr.shape)\n",
+    "imarr = imarr[np.newaxis, np.newaxis, :, :, 12]\n",
     "imarr = np.vstack([imarr]*50)\n",
     "seg = np.zeros(imarr.shape)\n",
-    "datadict = {\"image\": imarr, \"seg\": seg}\n",
-    "print(\"Data is shaped :\", imarr.shape)"
+    "datadict = {\"image\": imarr, \"label\": seg}\n",
+    "print(\"2D shape: \", imarr.shape[2:])\n",
+    "print(\"2D shape with batch and channel dimension: \", imarr.shape)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
     "idx = np.array(imarr.shape[2:])//4\n",
     "imarr_half = imarr[:, :, idx[0]:-idx[0], idx[1]:-idx[1]]\n",
     "seg_half = np.zeros(imarr_half.shape)\n",
-    "datadict_half = {\"image\": imarr_half, \"seg\": seg_half}"
+    "datadict_half = {\"image\": imarr_half, \"label\": seg_half}"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Rotation:  0.69137513556052 \n",
-      "  Rotation half:  0.16872628044802696\n"
+      "Rotation:  0.07687035000003561 \n",
+      "  Rotation half:  0.019398150000142778\n"
      ]
     }
    ],
    "source": [
     "# Applying Rotation\n",
-    "tform = Spatial(do_rot=True,\n",
-    "                x_rot_in_degrees=(0, 0),\n",
+    "tform = Spatial(x_rot_in_degrees=(0, 0),\n",
     "                y_rot_in_degrees=(0, 0),\n",
     "                z_rot_in_degrees=(45, 45))\n",
     "print(\"Rotation: \", timeit.timeit(lambda: tform(**deepcopy(datadict)), number=iterations)/iterations, \"\\n \",\n",
@@ -87,15 +92,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Deformation:  0.08075533551163971 \n",
-      "  Deformation half:  0.020874093053862453\n"
+      "Deformation:  0.07694740000010825 \n",
+      "  Deformation half:  0.019714600000042992\n"
      ]
     }
    ],
@@ -103,8 +108,7 @@
     "# Applying Deformation\n",
     "from yucca.image_processing.transforms.Spatial import Spatial\n",
     "\n",
-    "tform = Spatial(do_deform=True,\n",
-    "                deform_alpha=(700, 700),\n",
+    "tform = Spatial(deform_alpha=(700, 700),\n",
     "                deform_sigma=(10, 10))\n",
     "print(\"Deformation: \", timeit.timeit(lambda: tform(**deepcopy(datadict)), number=iterations)/iterations, \"\\n \",\n",
     "      \"Deformation half: \", timeit.timeit(lambda: tform(**deepcopy(datadict_half)), number=iterations)/iterations)\n"
@@ -112,50 +116,46 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Scaling:  0.04478159046266228 \n",
-      "  Scaling half:  0.011757174506783485\n"
+      "Scaling:  0.07160910000015974 \n",
+      "  Scaling half:  0.01951615000007223\n"
      ]
     }
    ],
    "source": [
     "# Applying Scaling\n",
-    "tform = Spatial(do_scale=True,\n",
-    "                scale_factor=(1.5, 1.5))\n",
+    "tform = Spatial(scale_factor=(1.5, 1.5))\n",
     "print(\"Scaling: \", timeit.timeit(lambda: tform(**deepcopy(datadict)), number=iterations)/iterations, \"\\n \",\n",
     "      \"Scaling half: \", timeit.timeit(lambda: tform(**deepcopy(datadict_half)), number=iterations)/iterations)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Rotation, Deformation and Scaling WITHOUT cropping:  0.06604640500154346 \n",
-      "  Rotation, Deformation and Scaling WITHOUT cropping half:  0.017682411009445786\n"
+      "Rotation, Deformation and Scaling WITHOUT cropping:  0.057532350000201404 \n",
+      "  Rotation, Deformation and Scaling WITHOUT cropping half:  0.015599049999991621\n"
      ]
     }
    ],
    "source": [
     "# Applying Rotation, Deformation and Scaling WITHOUT cropping\n",
-    "tform = Spatial(do_rot=True,\n",
-    "                x_rot_in_degrees=(0, 0),\n",
+    "tform = Spatial(x_rot_in_degrees=(0, 0),\n",
     "                y_rot_in_degrees=(0, 0),\n",
     "                z_rot_in_degrees=(45, 45),\n",
-    "                do_deform=True,\n",
     "                deform_alpha=(700, 700),\n",
     "                deform_sigma=(10, 10),\n",
-    "                do_scale=True,\n",
     "                scale_factor=(1.5, 1.5))\n",
     "print(\"Rotation, Deformation and Scaling WITHOUT cropping: \", timeit.timeit(lambda: tform(**deepcopy(datadict)), number=iterations)/iterations, \"\\n \",\n",
     "      \"Rotation, Deformation and Scaling WITHOUT cropping half: \", timeit.timeit(lambda: tform(**deepcopy(datadict_half)), number=iterations)/iterations)\n",
@@ -164,42 +164,36 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Rotation, Deformation and Scaling WITH cropping:  0.03380152699537575 \n",
-      "  Rotation, Deformation and Scaling WITH cropping half:  0.018688353477045894\n"
+      "Rotation, Deformation and Scaling WITH cropping:  0.032720100000005914 \n",
+      "  Rotation, Deformation and Scaling WITH cropping half:  0.021289699999897493\n"
      ]
     }
    ],
    "source": [
     "# Applying Rotation, Deformation and Scaling WITH cropping\n",
-    "tform = Spatial(do_crop=True,\n",
+    "tform = Spatial(crop=True,\n",
     "                patch_size=np.array(imarr.shape[2:])//2,\n",
-    "                do_rot=True,\n",
     "                x_rot_in_degrees=(0, 0),\n",
     "                y_rot_in_degrees=(0, 0),\n",
     "                z_rot_in_degrees=(45, 45),\n",
-    "                do_deform=True,\n",
     "                deform_alpha=(700, 700),\n",
     "                deform_sigma=(10, 10),\n",
-    "                do_scale=True,\n",
-    "                scale_factor=(1.5, 1.5))\n",
+    "               scale_factor=(1.5, 1.5))\n",
     "# Applying Rotation, Deformation and Scaling WITH cropping\n",
-    "tform2 = Spatial(do_crop=True,\n",
+    "tform2 = Spatial(crop=True,\n",
     "                patch_size=np.array(imarr_half.shape[2:])//2,\n",
-    "                do_rot=True,\n",
     "                x_rot_in_degrees=(0, 0),\n",
     "                y_rot_in_degrees=(0, 0),\n",
     "                z_rot_in_degrees=(45, 45),\n",
-    "                do_deform=True,\n",
     "                deform_alpha=(700, 700),\n",
     "                deform_sigma=(10, 10),\n",
-    "                do_scale=True,\n",
     "                scale_factor=(1.5, 1.5))\n",
     "print(\"Rotation, Deformation and Scaling WITH cropping: \", timeit.timeit(lambda: tform(**deepcopy(datadict)), number=iterations)/iterations, \"\\n \",\n",
     "      \"Rotation, Deformation and Scaling WITH cropping half: \", timeit.timeit(lambda: tform(**deepcopy(datadict_half)), number=iterations)/iterations)\n",
@@ -208,15 +202,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 28,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Additive Noise:  0.005201684427447617 \n",
-      "  Additive Noise half:  0.001380642526783049\n"
+      "Additive Noise:  0.019864849999976286 \n",
+      "  Additive Noise half:  0.00764219999996385\n"
      ]
     }
    ],
@@ -230,15 +224,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Multiplicative Noise:  0.005420221481472254 \n",
-      "  Multiplicative Noise half:  0.001492150011472404\n"
+      "Multiplicative Noise:  0.025139599999874918 \n",
+      "  Multiplicative Noise half:  0.0059195500000441825\n"
      ]
     }
    ],
@@ -254,15 +248,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 30,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Bias Field:  0.013610106543637812 \n",
-      "  Bias Field half:  0.00410760601516813\n"
+      "Bias Field:  0.046703000000206885 \n",
+      "  Bias Field half:  0.031693199999836\n"
      ]
     }
    ],
@@ -275,15 +269,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Motion Ghosting:  0.007532176445238292 \n",
-      "  Motion Ghosting half:  0.001929886406287551\n"
+      "Motion Ghosting:  0.029291249999914726 \n",
+      "  Motion Ghosting half:  0.010056399999939458\n"
      ]
     }
    ],
@@ -298,15 +292,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Gibbs Ringing:  0.007934359484352171 \n",
-      "  Gibbs Ringing half:  0.0016921929782256484\n"
+      "Gibbs Ringing:  0.035132399999838526 \n",
+      "  Gibbs Ringing half:  0.012108300000136296\n"
      ]
     }
    ],
@@ -318,13 +312,6 @@
     "print(\"Gibbs Ringing: \", timeit.timeit(lambda: tform(**deepcopy(datadict)), number=iterations)/iterations, \"\\n \",\n",
     "      \"Gibbs Ringing half: \", timeit.timeit(lambda: tform(**deepcopy(datadict_half)), number=iterations)/iterations)\n"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
@@ -343,7 +330,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.15"
+   "version": "3.10.13"
   },
   "orig_nbformat": 4,
   "vscode": {
diff --git a/yucca/documentation/tests/transforms/cropping_and_padding.ipynb b/yucca/documentation/tests/transforms/cropping_and_padding.ipynb
index 233ca96b..42fd6c73 100644
--- a/yucca/documentation/tests/transforms/cropping_and_padding.ipynb
+++ b/yucca/documentation/tests/transforms/cropping_and_padding.ipynb
@@ -2,22 +2,22 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7fc60a8ce980>"
+       "<matplotlib.image.AxesImage at 0x20b535eb070>"
       ]
      },
-     "execution_count": 1,
+     "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -44,22 +44,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7fc60aaf9e10>"
+       "<matplotlib.image.AxesImage at 0x20b53678b50>"
       ]
      },
-     "execution_count": 2,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -77,22 +77,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7fc6182e4a00>"
+       "<matplotlib.image.AxesImage at 0x20b53700970>"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -110,22 +110,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7fc618342cb0>"
+       "<matplotlib.image.AxesImage at 0x20b53776320>"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -144,22 +144,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7fc5e03d70d0>"
+       "<matplotlib.image.AxesImage at 0x20b53804850>"
       ]
      },
-     "execution_count": 22,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -174,33 +174,6 @@
     "imarr_cropped = croppad({\"image\": imarr[np.newaxis], \"label\": None}, image_properties={\"foreground_locations\": []})\n",
     "plt.imshow(imarr_cropped[\"image\"][0, :, :], cmap=\"gray\")"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(128, 96, 24)"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "imarr.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {