diff --git a/__dataset/sample/0000.png b/__dataset/sample/0000.png
new file mode 100644
index 0000000000000000000000000000000000000000..ce25c2661b89874ae55e34af6e9ebe50cdfc74cf
Binary files /dev/null and b/__dataset/sample/0000.png differ
diff --git a/__dataset/sample/0001.jpg b/__dataset/sample/0001.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..e0180b392028a185391564502f0de688f20ef9a8
Binary files /dev/null and b/__dataset/sample/0001.jpg differ
diff --git a/__dataset/sample/0002.png b/__dataset/sample/0002.png
new file mode 100644
index 0000000000000000000000000000000000000000..59503c0ca5336465d49f683a169188979746421a
Binary files /dev/null and b/__dataset/sample/0002.png differ
diff --git a/app.py b/app.py
new file mode 100644
index 0000000000000000000000000000000000000000..40ab624a0ad40eb21b1c88fecac802fb827f1e99
--- /dev/null
+++ b/app.py
@@ -0,0 +1,66 @@
+import sys
+sys.path.append("src")
+from interactive_pipe import interactive_pipeline
+from rstor.analyzis.interactive.pipelines import natural_inference_pipeline, morph_canvas, CANVAS
+from rstor.analyzis.interactive.model_selection import get_default_models
+from pathlib import Path
+from rstor.analyzis.parser import get_parser
+import argparse
+from batch_processing import Batch
+from interactive_pipe.data_objects.image import Image
+from rstor.analyzis.interactive.images import image_selector
+from rstor.analyzis.interactive.crop import plug_crop_selector
+from rstor.analyzis.interactive.metrics import plug_configure_metrics
+from interactive_pipe import interactive, KeyboardControl
+
+
+def plug_morph_canvas():
+    interactive(
+        canvas=KeyboardControl(CANVAS[0], CANVAS, name="canvas", keyup="p", modulo=True)
+    )(morph_canvas)
+
+
+def image_loading_batch(input: Path, args: argparse.Namespace) -> dict:
+    """Wrapper to load images files from a directory using batch_processing
+    """
+
+    if not args.disable_preload:
+        img = Image.from_file(input).data
+        return {"name": input.name, "path": input, "buffer": img}
+    else:
+        return {"name": input.name, "path": input, "buffer": None}
+
+
+def main(argv):
+    batch = Batch(argv)
+    batch.set_io_description(
+        input_help='input image files',
+        output_help=argparse.SUPPRESS
+    )
+    parser = get_parser()
+    parser.add_argument("-nop", "--disable-preload", action="store_true", help="Disable images preload")
+    args = batch.parse_args(parser)
+    # batch.set_multiprocessing_enabled(False)
+    img_list = batch.run(image_loading_batch)
+    if args.keyboard:
+        image_control = KeyboardControl(0, [0, len(img_list)-1], keydown="3", keyup="9", modulo=True)
+    else:
+        image_control = (0, [0, len(img_list)-1])
+    interactive(image_index=image_control)(image_selector)
+    plug_crop_selector(num_pad=args.keyboard)
+    plug_configure_metrics(key_shortcut="a")  # "a" if args.keyboard else None)
+    plug_morph_canvas()
+    model_dict = get_default_models(args.experiments, Path(args.models_storage), keyboard_control=args.keyboard)
+    interactive_pipeline(
+        gui=args.backend,
+        cache=True,
+        safe_input_buffer_deepcopy=False
+    )(natural_inference_pipeline)(
+        img_list,
+        model_dict
+    )
+
+
+if __name__ == "__main__":
+    # main(sys.argv[1:])
+    main(["-e", "6002", "-i", "__dataset/sample/*.*g",  "-b","gradio"])
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4762900092df03143a217230090f6aeec0864b53
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,6 @@
+interactive-pipe>=0.7.8
+opencv_python_headless==4.8.0.74
+torch>=2.0.0
+tqdm
+
+
diff --git a/scripts/configuration.py b/scripts/configuration.py
new file mode 100644
index 0000000000000000000000000000000000000000..b79caf1cfa2e3bc5ea33e619a849a1200647d0f6
--- /dev/null
+++ b/scripts/configuration.py
@@ -0,0 +1,18 @@
+from pathlib import Path
+
+NB_ID = "blind-deblurring-from-synthetic-data"  # This will be the name which appears on Kaggle.
+GIT_USER = "balthazarneveu"  # Your git user name
+GIT_REPO = "blind-deblurring-from-synthetic-data"  # Your current git repo
+# Keep free unless you need to acess kaggle datasets. You'll need to modify the remote_training_template.ipynb.
+KAGGLE_DATASET_LIST = [
+    "balthazarneveu/deadleaves-div2k-512", # Deadleaves classic
+    "balthazarneveu/deadleaves-primitives-div2k-512", # Deadleaves with extra primitives
+    "balthazarneveu/motion-blur-kernels", # Motion blur kernels
+    "joe1995/div2k-dataset",
+]
+WANDBSPACE = "deblur-from-deadleaves"
+TRAIN_SCRIPT = "scripts/train.py"  # Location of the training script
+
+ROOT_DIR = Path(__file__).parent
+OUTPUT_FOLDER_NAME = "__output"
+INFERENCE_FOLDER_NAME = "__inference"
diff --git a/scripts/infer.py b/scripts/infer.py
new file mode 100644
index 0000000000000000000000000000000000000000..bfa1339e7036ab5d47c685e40e4e64fc067bd630
--- /dev/null
+++ b/scripts/infer.py
@@ -0,0 +1,205 @@
+from configuration import ROOT_DIR, OUTPUT_FOLDER_NAME, INFERENCE_FOLDER_NAME
+from rstor.analyzis.parser import get_models_parser
+from batch_processing import Batch
+from rstor.properties import (
+    DEVICE, NAME, PRETTY_NAME, DATALOADER, CONFIG_DEAD_LEAVES, VALIDATION,
+    BATCH_SIZE, SIZE,
+    REDUCTION_SKIP,
+    TRACES_TARGET, TRACES_DEGRADED, TRACES_RESTORED, TRACES_METRICS, TRACES_ALL,
+    SAMPLER_SATURATED,
+    CONFIG_DEGRADATION,
+    DATASET_DIV2K,
+    DATASET_DL_DIV2K_512,
+    DATASET_DL_EXTRAPRIMITIVES_DIV2K_512,
+    METRIC_PSNR, METRIC_SSIM, METRIC_LPIPS,
+    DEGRADATION_BLUR_MAT, DEGRADATION_BLUR_NONE
+)
+from rstor.data.dataloader import get_data_loader
+from tqdm import tqdm
+from pathlib import Path
+import torch
+from typing import Optional
+import argparse
+import sys
+from rstor.analyzis.interactive.model_selection import get_default_models
+from rstor.learning.metrics import compute_metrics
+from interactive_pipe.data_objects.image import Image
+from interactive_pipe.data_objects.parameters import Parameters
+from typing import List
+from itertools import product
+import pandas as pd
+ALL_TRACES = [TRACES_TARGET, TRACES_DEGRADED, TRACES_RESTORED, TRACES_METRICS]
+
+
+def parse_int_pairs(s):
+    try:
+        # Split the input string by spaces to separate pairs, then split each pair by ',' and convert to tuple of ints
+        return [tuple(map(int, item.split(','))) for item in s.split()]
+    except ValueError:
+        raise argparse.ArgumentTypeError("Must be a series of pairs 'a,b' separated by spaces.")
+
+
+def get_parser(parser: Optional[argparse.ArgumentParser] = None, batch_mode=False) -> argparse.ArgumentParser:
+    parser = get_models_parser(
+        parser=parser,
+        help="Inference on validation set",
+        default_models_path=ROOT_DIR/OUTPUT_FOLDER_NAME)
+    if not batch_mode:
+        parser.add_argument("-o", "--output-dir", type=str, default=ROOT_DIR /
+                            INFERENCE_FOLDER_NAME, help="Output directory")
+    parser.add_argument("--cpu", action="store_true", help="Force CPU")
+    parser.add_argument("--traces", "-t", nargs="+", type=str, choices=ALL_TRACES+[TRACES_ALL],
+                        help="Traces to be computed", default=TRACES_ALL)
+    parser.add_argument("--size", type=parse_int_pairs,
+                        default=[(256, 256)], help="Size of the images like '256,512 512,512'")
+    parser.add_argument("--std-dev", type=parse_int_pairs, default=[(0, 50)],
+                        help="Noise standard deviation (a, b) as pairs separated by spaces, e.g., '0,50 8,8 6,10'")
+    parser.add_argument("-n", "--number-of-images", type=int, default=None,
+                        required=False, help="Number of images to process")
+    parser.add_argument("-d", "--dataset", type=str,
+                        choices=[None,  DATASET_DL_DIV2K_512, DATASET_DIV2K, DATASET_DL_EXTRAPRIMITIVES_DIV2K_512],
+                        default=None),
+    parser.add_argument("-b", "--blur", action="store_true")
+    parser.add_argument("--blur-index", type=int, nargs="+", default=None)
+    return parser
+
+
+def to_image(img: torch.Tensor):
+    return img.permute(0, 2, 3, 1).cpu().numpy()
+
+
+def infer(model, dataloader, config, device, output_dir: Path, traces: List[str] = ALL_TRACES, number_of_images=None, degradation_key=CONFIG_DEAD_LEAVES,
+          chosen_metrics=[METRIC_PSNR, METRIC_SSIM]):  # add METRIC_LPIPS here!
+    img_index = 0
+    if TRACES_ALL in traces:
+        traces = ALL_TRACES
+    if TRACES_METRICS in traces:
+        all_metrics = {}
+    else:
+        all_metrics = None
+    with torch.no_grad():
+        model.eval()
+        for img_degraded, img_target in tqdm(dataloader):
+            img_degraded = img_degraded.to(device)
+            img_target = img_target.to(device)
+            img_restored = model(img_degraded)
+            if TRACES_METRICS in traces:
+                metrics_input_per_image = compute_metrics(
+                    img_degraded, img_target, reduction=REDUCTION_SKIP, chosen_metrics=chosen_metrics)
+                metrics_per_image = compute_metrics(
+                    img_restored, img_target, reduction=REDUCTION_SKIP, chosen_metrics=chosen_metrics)
+                # print(metrics_per_image)
+            img_degraded = to_image(img_degraded)
+            img_target = to_image(img_target)
+            img_restored = to_image(img_restored)
+            for idx in range(img_restored.shape[0]):
+                degradation_parameters = dataloader.dataset.current_degradation[img_index]
+                common_prefix = f"{img_index:05d}_{img_degraded.shape[-3]:04d}x{img_degraded.shape[-2]:04d}"
+                common_prefix += f"_noise=[{config[DATALOADER][degradation_key]['noise_stddev'][0]:02d},{config[DATALOADER][degradation_key]['noise_stddev'][1]:02d}]"
+                suffix_deg = ""
+                if degradation_parameters['noise_stddev'] > 0:
+                    suffix_deg += f"_noise={round(degradation_parameters['noise_stddev']):02d}"
+                suffix_deg += f"_blur={degradation_parameters['blur_kernel_id']:04d}"
+                #if degradation_parameters.get("blur_kernel_id", False) else ""
+                save_path_pred = output_dir/f"{common_prefix}_pred{suffix_deg}_{config[PRETTY_NAME]}.png"
+                save_path_degr = output_dir/f"{common_prefix}_degr{suffix_deg}.png"
+                save_path_targ = output_dir/f"{common_prefix}_targ.png"
+                if TRACES_RESTORED in traces:
+                    Image(img_restored[idx]).save(save_path_pred)
+                if TRACES_DEGRADED in traces:
+                    Image(img_degraded[idx]).save(save_path_degr)
+                if TRACES_TARGET in traces:
+                    Image(img_target[idx]).save(save_path_targ)
+                if TRACES_METRICS in traces:
+                    # current_metrics = {"in": {}, "out": {}}
+                    # for key, value in metrics_per_image.items():
+                    #     print(f"{key}: {value[idx]:.3f}")
+                    #     current_metrics["in"][key] = metrics_input_per_image[key][idx].item()
+                    #     current_metrics["out"][key] = metrics_per_image[key][idx].item()
+                    current_metrics = {}
+                    for key, value in metrics_per_image.items():
+                        current_metrics["in_"+key] = metrics_input_per_image[key][idx].item()
+                        current_metrics["out_"+key] = metrics_per_image[key][idx].item()
+                    current_metrics["degradation"] = degradation_parameters
+                    current_metrics["size"] = (img_degraded.shape[-3], img_degraded.shape[-2])
+                    current_metrics["deadleaves_config"] = config[DATALOADER][degradation_key]
+                    current_metrics["restored"] = save_path_pred.relative_to(output_dir).as_posix()
+                    current_metrics["degraded"] = save_path_degr.relative_to(output_dir).as_posix()
+                    current_metrics["target"] = save_path_targ.relative_to(output_dir).as_posix()
+                    current_metrics["model"] = config[PRETTY_NAME]
+                    current_metrics["model_id"] = config[NAME]
+                    Parameters(current_metrics).save(output_dir/f"{common_prefix}_metrics.json")
+                    # for key, value in all_metrics.items():
+
+                    all_metrics[img_index] = current_metrics
+                img_index += 1
+                if number_of_images is not None and img_index > number_of_images:
+                    return all_metrics
+    return all_metrics
+
+
+def infer_main(argv, batch_mode=False):
+    parser = get_parser(batch_mode=batch_mode)
+    if batch_mode:
+        batch = Batch(argv)
+        batch.set_io_description(
+            input_help='input image files',
+            output_help=f'output directory {str(ROOT_DIR/INFERENCE_FOLDER_NAME)}',
+        )
+        batch.parse_args(parser)
+    else:
+        args = parser.parse_args(argv)
+    device = "cpu" if args.cpu else DEVICE
+    dataset = args.dataset
+    blur_flag = args.blur
+    for exp in args.experiments:
+        model_dict = get_default_models([exp], Path(args.models_storage), interactive_flag=False)
+        # print(list(model_dict.keys()))
+        current_model_dict = model_dict[list(model_dict.keys())[0]]
+        model = current_model_dict["model"]
+        config = current_model_dict["config"]
+        for std_dev, size, blur_index in product(args.std_dev, args.size, args.blur_index):
+            if dataset is None:
+                config[DATALOADER][CONFIG_DEAD_LEAVES] = dict(
+                    blur_kernel_half_size=[0, 0],
+                    ds_factor=1,
+                    noise_stddev=list(std_dev),
+                    sampler=SAMPLER_SATURATED
+                )
+                config[DATALOADER]["gpu_gen"] = True
+                config[DATALOADER][SIZE] = size
+                config[DATALOADER][BATCH_SIZE][VALIDATION] = 1 if size[0] > 512 else 4
+            else:
+                config[DATALOADER][CONFIG_DEGRADATION] = dict(
+                    noise_stddev=list(std_dev),
+                    degradation_blur=DEGRADATION_BLUR_MAT if blur_flag else DEGRADATION_BLUR_NONE,
+                    blur_index=blur_index
+                )
+                config[DATALOADER][NAME] = dataset
+                config[DATALOADER][SIZE] = size
+                config[DATALOADER][BATCH_SIZE][VALIDATION] = 1 if size[0] > 512 else 4
+            dataloader = get_data_loader(config, frozen_seed=42)
+            # print(config)
+            output_dir = Path(args.output_dir)/(config[NAME] + "_" +
+                                                config[PRETTY_NAME])  # + "_" + f"{size[0]:04d}x{size[1]:04d}")
+            output_dir.mkdir(parents=True, exist_ok=True)
+
+            all_metrics = infer(model, dataloader[VALIDATION], config, device, output_dir,
+                                traces=args.traces, number_of_images=args.number_of_images,
+                                degradation_key=CONFIG_DEAD_LEAVES if dataset is None else CONFIG_DEGRADATION)
+            if all_metrics is not None:
+                # print(all_metrics)
+                df = pd.DataFrame(all_metrics).T
+                prefix = f"{size[0]:04d}x{size[1]:04d}"
+                if not (std_dev[0] == 0 and std_dev[1] == 0):
+                    prefix += f"_noise=[{std_dev[0]:02d},{std_dev[1]:02d}]"
+                if blur_index is not None:
+                    prefix += f"_blur={blur_index:02d}"
+                prefix += f"_{config[PRETTY_NAME]}"
+                df.to_csv(output_dir/f"__{prefix}_metrics_.csv", index=False)
+                # Normally this could go into another script to handle the metrics analyzis
+                # print(df)
+
+
+if __name__ == "__main__":
+    infer_main(sys.argv[1:])
diff --git a/scripts/interactive_inference_natural.py b/scripts/interactive_inference_natural.py
new file mode 100644
index 0000000000000000000000000000000000000000..209bc9025b829b3bfc8459f639678eb1071a5038
--- /dev/null
+++ b/scripts/interactive_inference_natural.py
@@ -0,0 +1,65 @@
+import sys
+sys.path.append("src")
+from interactive_pipe import interactive_pipeline
+from rstor.analyzis.interactive.pipelines import natural_inference_pipeline, morph_canvas, CANVAS
+from rstor.analyzis.interactive.model_selection import get_default_models
+from pathlib import Path
+from rstor.analyzis.parser import get_parser
+import argparse
+from batch_processing import Batch
+from interactive_pipe.data_objects.image import Image
+from rstor.analyzis.interactive.images import image_selector
+from rstor.analyzis.interactive.crop import plug_crop_selector
+from rstor.analyzis.interactive.metrics import plug_configure_metrics
+from interactive_pipe import interactive, KeyboardControl
+
+
+def plug_morph_canvas():
+    interactive(
+        canvas=KeyboardControl(CANVAS[0], CANVAS, name="canvas", keyup="p", modulo=True)
+    )(morph_canvas)
+
+
+def image_loading_batch(input: Path, args: argparse.Namespace) -> dict:
+    """Wrapper to load images files from a directory using batch_processing
+    """
+
+    if not args.disable_preload:
+        img = Image.from_file(input).data
+        return {"name": input.name, "path": input, "buffer": img}
+    else:
+        return {"name": input.name, "path": input, "buffer": None}
+
+
+def main(argv):
+    batch = Batch(argv)
+    batch.set_io_description(
+        input_help='input image files',
+        output_help=argparse.SUPPRESS
+    )
+    parser = get_parser()
+    parser.add_argument("-nop", "--disable-preload", action="store_true", help="Disable images preload")
+    args = batch.parse_args(parser)
+    # batch.set_multiprocessing_enabled(False)
+    img_list = batch.run(image_loading_batch)
+    if args.keyboard:
+        image_control = KeyboardControl(0, [0, len(img_list)-1], keydown="3", keyup="9", modulo=True)
+    else:
+        image_control = (0, [0, len(img_list)-1])
+    interactive(image_index=image_control)(image_selector)
+    plug_crop_selector(num_pad=args.keyboard)
+    plug_configure_metrics(key_shortcut="a")  # "a" if args.keyboard else None)
+    plug_morph_canvas()
+    model_dict = get_default_models(args.experiments, Path(args.models_storage), keyboard_control=args.keyboard)
+    interactive_pipeline(
+        gui=args.backend,
+        cache=True,
+        safe_input_buffer_deepcopy=False
+    )(natural_inference_pipeline)(
+        img_list,
+        model_dict
+    )
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/scripts/interactive_inference_synthetic.py b/scripts/interactive_inference_synthetic.py
new file mode 100644
index 0000000000000000000000000000000000000000..956c335e180675e582082572dfc2bd374710def8
--- /dev/null
+++ b/scripts/interactive_inference_synthetic.py
@@ -0,0 +1,25 @@
+import sys
+sys.path.append("src")
+from interactive_pipe import interactive_pipeline
+from rstor.synthetic_data.interactive.interactive_dead_leaves import dead_leave_plugin
+from rstor.analyzis.interactive.pipelines import deadleave_inference_pipeline
+from rstor.analyzis.interactive.model_selection import get_default_models
+from rstor.analyzis.interactive.crop import plug_crop_selector
+from rstor.analyzis.interactive.metrics import plug_configure_metrics
+from pathlib import Path
+from rstor.analyzis.parser import get_parser
+
+
+def main(argv):
+    parser = get_parser()
+    args = parser.parse_args(argv)
+    plug_crop_selector(num_pad=args.keyboard)
+    model_dict = get_default_models(args.experiments, Path(args.models_storage))
+    dead_leave_plugin(ds=1)
+    plug_configure_metrics(key_shortcut="a")
+    interactive_pipeline(gui="auto", cache=True, safe_input_buffer_deepcopy=False)(
+        deadleave_inference_pipeline)(model_dict)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/scripts/metrics_analyzis.ipynb b/scripts/metrics_analyzis.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..f2aac503f68838de20b2bf6431f7025fa877b5e2
--- /dev/null
+++ b/scripts/metrics_analyzis.ipynb
@@ -0,0 +1,251 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "import pandas as pd\n",
+    "from matplotlib import pyplot as plt\n",
+    "from configuration import ROOT_DIR\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inference_path = ROOT_DIR/\"__inference_comparison\"\n",
+    "inference_path_str = str(inference_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Generate a few images\n",
+    "!python infer.py -e 1004 2003 2005  -o $inference_path_str -t target degraded restored --size \"512,512 256,256 128,128\" --std-dev \"40,40\" -n 1\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python infer.py -e 1004 2003 2005 -o $inference_path_str -t metrics --size \"512,512 256,256 128,128\" --std-dev \"1,1 5,5 10,10 20,20 30,30 40,40 50,50 80,80\" -n 5\n",
+    "# Note ! we could call python directly instead of using command line"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 118,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def snr_to_sigma(snr):\n",
+    "    return  10**(-snr/20.)*255.\n",
+    "def sigma_to_snr(sigma):\n",
+    "    return -20.*np.log10(sigma/255.)\n",
+    "\n",
+    "def plot_results(selected_paths, title=None, diff=True):\n",
+    "    # plt.figure(figsize=(10, 10))\n",
+    "    fig, ax = plt.subplots(layout='constrained', figsize=(10, 10))\n",
+    "    for selected_path, selected_regex in selected_paths:\n",
+    "        selected_path = Path(selected_path)\n",
+    "        assert selected_path.exists()\n",
+    "        results_path = sorted(list(selected_path.glob(selected_regex)))\n",
+    "        stats = []\n",
+    "        for result_path in results_path:\n",
+    "            df = pd.read_csv(result_path)\n",
+    "            in_psnr = df[\"in_PSNR\"].mean()\n",
+    "            out_psnr = df[\"out_PSNR\"].mean()\n",
+    "            stats.append({\n",
+    "                \"in_psnr\": in_psnr,\n",
+    "                \"out_psnr\": out_psnr,\n",
+    "            })\n",
+    "            label = selected_path.name + \" \" + df[\"size\"][0]\n",
+    "        stats_array = pd.DataFrame(stats)\n",
+    "        x_data = stats_array[\"in_psnr\"].copy()\n",
+    "        x_data = snr_to_sigma(x_data)\n",
+    "\n",
+    "        ax.plot(\n",
+    "            x_data,\n",
+    "            stats_array[\"out_psnr\"]-stats_array[\"in_psnr\"] if diff else stats_array[\"out_psnr\"],\n",
+    "            \"-o\",\n",
+    "            label=label\n",
+    "        )\n",
+    "            # label=selected_path.name)\n",
+    "    if not diff:\n",
+    "        neutral_sigma = np.linspace(1, 80, 80)\n",
+    "        ax.plot(neutral_sigma, sigma_to_snr(neutral_sigma), \"k--\", alpha=0.1, label=\"Neutral\")\n",
+    "    secax = ax.secondary_xaxis('top', functions=(sigma_to_snr, snr_to_sigma))\n",
+    "    secax.set_xlabel('PSNR [db]')\n",
+    "    \n",
+    "    ax.set_xlabel(\"sigma 255\")\n",
+    "    ax.set_ylabel(\"PSNR improvement\" if diff else \"PSNR out\")\n",
+    "    plt.xlim(1., 50.)\n",
+    "    if diff:\n",
+    "        plt.ylim(0, 15)\n",
+    "    if title is not None:\n",
+    "        plt.title(title)\n",
+    "    plt.legend()\n",
+    "    plt.grid()\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 119,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "selected_paths = [\n",
+    "    (inference_path/\"1004_Vanilla denoise only - ds=1 - noisy 0-50\", \"*0128*.csv\"), \n",
+    "    (inference_path/\"2005_NAFNet TresLight denoise  0-50 gpu dl - 128x128\", \"*0128*.csv\"),\n",
+    "    (inference_path/\"2003_NAFNet denoise  0-50 gpu dl - 128x128\", \"*0128*.csv\"),\n",
+    "]\n",
+    "plot_results(selected_paths, title=\"Image 128x128\", diff=False)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 120,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "selected_paths = [\n",
+    "    (inference_path/\"1004_Vanilla denoise only - ds=1 - noisy 0-50\", \"*0128*.csv\"), \n",
+    "    (inference_path/\"2005_NAFNet TresLight denoise  0-50 gpu dl - 128x128\", \"*0128*.csv\"),\n",
+    "    (inference_path/\"2003_NAFNet denoise  0-50 gpu dl - 128x128\", \"*0128*.csv\"),\n",
+    "]\n",
+    "plot_results(selected_paths, title=\"Image 128x128\", diff=True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 122,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "selected_paths = [\n",
+    "    (inference_path/\"1004_Vanilla denoise only - ds=1 - noisy 0-50\", \"*0512*.csv\"),\n",
+    "    (inference_path/\"2005_NAFNet TresLight denoise  0-50 gpu dl - 128x128\",\"*0512*.csv\"),\n",
+    "    (inference_path/\"2003_NAFNet denoise  0-50 gpu dl - 128x128\",\"*0512*.csv\"),\n",
+    "]\n",
+    "plot_results(selected_paths, title=\"Image 512x512\", diff=True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 123,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "selected_paths = [\n",
+    "\n",
+    "    (inference_path/\"2003_NAFNet denoise  0-50 gpu dl - 128x128\", \"*0128*.csv\"),\n",
+    "    (inference_path/\"2003_NAFNet denoise  0-50 gpu dl - 128x128\",\"*0256*.csv\"),\n",
+    "    (inference_path/\"2003_NAFNet denoise  0-50 gpu dl - 128x128\",\"*0512*.csv\"),\n",
+    "]\n",
+    "plot_results(selected_paths)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 126,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "selected_paths = [\n",
+    "    (inference_path/\"2005_NAFNet TresLight denoise  0-50 gpu dl - 128x128\", \"*0128*.csv\"),\n",
+    "    (inference_path/\"2005_NAFNet TresLight denoise  0-50 gpu dl - 128x128\", \"*0256*.csv\"),\n",
+    "    (inference_path/\"2005_NAFNet TresLight denoise  0-50 gpu dl - 128x128\", \"*0512*.csv\"),\n",
+    "]\n",
+    "plot_results(selected_paths)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "robotics",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/scripts/quantitative_results.ipynb b/scripts/quantitative_results.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..1d979f451db67ac1fbf923c31e0453427673bf01
--- /dev/null
+++ b/scripts/quantitative_results.ipynb
@@ -0,0 +1,513 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Quantitative evaluation results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "import pandas as pd\n",
+    "from matplotlib import pyplot as plt\n",
+    "from configuration import ROOT_DIR\n",
+    "from rstor.properties import DATASET_DIV2K, DATASET_DL_DIV2K_512, DATASET_DL_EXTRAPRIMITIVES_DIV2K_512\n",
+    "from rstor.analyzis.metrics_plots import plot_results\n",
+    "# from infer import main\n",
+    "import numpy as np\n",
+    "\n",
+    "# 3001 = NafNet41M DL\n",
+    "# 3101 = NafNet41M Div2k\n",
+    "# 3050 = NafNet41M DL_Prim\n",
+    "# 3020 = Vanilla DL\n",
+    "# 3120 = Vanilla Div2k"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:05<00:00,  5.91s/it]\n",
+      "  0%|                                                   | 0/100 [00:05<?, ?it/s]\n",
+      "  0%|                                                   | 0/100 [00:02<?, ?it/s]\n",
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:00<00:00,  2.38it/s]\n",
+      "  0%|                                                   | 0/100 [00:00<?, ?it/s]\n",
+      "  0%|                                                   | 0/100 [00:00<?, ?it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "for dataset in [DATASET_DL_DIV2K_512]:\n",
+    "    inference_path = ROOT_DIR/\"__denoising_illustrations\"/dataset\n",
+    "    inference_path_str = str(inference_path)\n",
+    "    # 3001 3101 3050 3120 3020\n",
+    "    !python infer.py -e 3001 3020 -o $inference_path_str -t metrics all --size \"512,512\" --std-dev \"25,25 50,50\" -n 1 --dataset $dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:06<00:00,  6.17s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:17<00:03,  3.24s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:18<00:03,  3.27s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:23<00:03,  3.48s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:24<00:03,  3.50s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:25<00:03,  3.55s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:25<00:03,  3.56s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:24<00:03,  3.51s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:18<00:03,  3.25s/it]\n",
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:06<00:00,  6.64s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:22<00:03,  3.44s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:22<00:03,  3.44s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:23<00:03,  3.47s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:24<00:03,  3.51s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:25<00:03,  3.55s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:25<00:03,  3.58s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:26<00:03,  3.60s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:23<00:03,  3.48s/it]\n",
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:06<00:00,  6.07s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:23<00:03,  3.49s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:24<00:03,  3.52s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:25<00:03,  3.58s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:26<00:03,  3.62s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:27<00:03,  3.64s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:27<00:03,  3.65s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:26<00:03,  3.61s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [01:19<00:03,  3.30s/it]\n",
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:00<00:00,  4.86it/s]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [00:28<00:01,  1.17s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [00:27<00:01,  1.15s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [00:27<00:01,  1.15s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [00:28<00:01,  1.19s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [00:29<00:01,  1.23s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [00:29<00:01,  1.23s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [00:27<00:01,  1.13s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [00:21<00:00,  1.12it/s]\n",
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:00<00:00,  7.74it/s]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [00:28<00:01,  1.20s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [00:29<00:01,  1.22s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [00:28<00:01,  1.17s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [00:28<00:01,  1.19s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [00:27<00:01,  1.15s/it]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [00:23<00:00,  1.00it/s]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [00:20<00:00,  1.15it/s]\n",
+      " 96%|█████████████████████████████████████████▎ | 24/25 [00:19<00:00,  1.24it/s]\n",
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:05<00:00,  5.86s/it]\n",
+      " 24%|██████████                                | 24/100 [01:16<04:00,  3.17s/it]\n",
+      " 24%|██████████                                | 24/100 [01:13<03:51,  3.05s/it]\n",
+      " 24%|██████████                                | 24/100 [01:13<03:53,  3.07s/it]\n",
+      " 24%|██████████                                | 24/100 [01:13<03:53,  3.07s/it]\n",
+      " 24%|██████████                                | 24/100 [01:13<03:52,  3.06s/it]\n",
+      " 24%|██████████                                | 24/100 [01:13<03:51,  3.05s/it]\n",
+      " 24%|██████████                                | 24/100 [01:11<03:47,  2.99s/it]\n",
+      " 24%|██████████                                | 24/100 [01:08<03:37,  2.86s/it]\n",
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:07<00:00,  7.01s/it]\n",
+      " 24%|██████████                                | 24/100 [01:12<03:49,  3.02s/it]\n",
+      " 24%|██████████                                | 24/100 [01:10<03:44,  2.95s/it]\n",
+      " 24%|██████████                                | 24/100 [01:10<03:42,  2.93s/it]\n",
+      " 24%|██████████                                | 24/100 [01:10<03:43,  2.94s/it]\n",
+      " 24%|██████████                                | 24/100 [01:10<03:43,  2.95s/it]\n",
+      " 24%|██████████                                | 24/100 [01:10<03:44,  2.95s/it]\n",
+      " 24%|██████████                                | 24/100 [01:10<03:44,  2.95s/it]\n",
+      " 24%|██████████                                | 24/100 [01:09<03:40,  2.90s/it]\n",
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:05<00:00,  5.97s/it]\n",
+      " 24%|██████████                                | 24/100 [01:15<03:58,  3.13s/it]\n",
+      " 24%|██████████                                | 24/100 [01:14<03:56,  3.12s/it]\n",
+      " 24%|██████████                                | 24/100 [01:15<03:58,  3.14s/it]\n",
+      " 24%|██████████                                | 24/100 [01:14<03:57,  3.12s/it]\n",
+      " 24%|██████████                                | 24/100 [01:14<03:56,  3.11s/it]\n",
+      " 24%|██████████                                | 24/100 [01:14<03:55,  3.09s/it]\n",
+      " 24%|██████████                                | 24/100 [01:13<03:51,  3.05s/it]\n",
+      " 24%|██████████                                | 24/100 [01:09<03:39,  2.89s/it]\n",
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:00<00:00,  4.66it/s]\n",
+      " 24%|██████████                                | 24/100 [00:14<00:47,  1.60it/s]\n",
+      " 24%|██████████                                | 24/100 [00:14<00:46,  1.64it/s]\n",
+      " 24%|██████████                                | 24/100 [00:14<00:45,  1.66it/s]\n",
+      " 24%|██████████                                | 24/100 [00:14<00:46,  1.65it/s]\n",
+      " 24%|██████████                                | 24/100 [00:15<00:47,  1.59it/s]\n",
+      " 24%|██████████                                | 24/100 [00:15<00:47,  1.59it/s]\n",
+      " 24%|██████████                                | 24/100 [00:13<00:42,  1.77it/s]\n",
+      " 24%|██████████                                | 24/100 [00:12<00:38,  2.00it/s]\n",
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:00<00:00,  5.16it/s]\n",
+      " 24%|██████████                                | 24/100 [00:16<00:53,  1.43it/s]\n",
+      " 24%|██████████                                | 24/100 [00:16<00:53,  1.43it/s]\n",
+      " 24%|██████████                                | 24/100 [00:15<00:48,  1.57it/s]\n",
+      " 24%|██████████                                | 24/100 [00:14<00:46,  1.62it/s]\n",
+      " 24%|██████████                                | 24/100 [00:14<00:44,  1.69it/s]\n",
+      " 24%|██████████                                | 24/100 [00:13<00:42,  1.80it/s]\n",
+      " 24%|██████████                                | 24/100 [00:11<00:37,  2.02it/s]\n",
+      " 24%|██████████                                | 24/100 [00:11<00:35,  2.15it/s]\n",
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:06<00:00,  6.23s/it]\n",
+      " 24%|██████████                                | 24/100 [01:17<04:06,  3.24s/it]\n",
+      " 24%|██████████                                | 24/100 [01:13<03:52,  3.06s/it]\n",
+      " 24%|██████████                                | 24/100 [01:13<03:51,  3.04s/it]\n",
+      " 24%|██████████                                | 24/100 [01:13<03:51,  3.04s/it]\n",
+      " 24%|██████████                                | 24/100 [01:12<03:50,  3.04s/it]\n",
+      " 24%|██████████                                | 24/100 [01:12<03:49,  3.02s/it]\n",
+      " 24%|██████████                                | 24/100 [01:11<03:46,  2.98s/it]\n",
+      " 24%|██████████                                | 24/100 [01:08<03:37,  2.86s/it]\n",
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:05<00:00,  5.56s/it]\n",
+      " 24%|██████████                                | 24/100 [01:14<03:54,  3.09s/it]\n",
+      " 24%|██████████                                | 24/100 [01:12<03:48,  3.01s/it]\n",
+      " 24%|██████████                                | 24/100 [01:11<03:45,  2.97s/it]\n",
+      " 24%|██████████                                | 24/100 [01:11<03:46,  2.98s/it]\n",
+      " 24%|██████████                                | 24/100 [01:11<03:47,  2.99s/it]\n",
+      " 24%|██████████                                | 24/100 [01:11<03:47,  2.99s/it]\n",
+      " 24%|██████████                                | 24/100 [01:11<03:46,  2.98s/it]\n",
+      " 24%|██████████                                | 24/100 [01:09<03:41,  2.92s/it]\n",
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:05<00:00,  5.74s/it]\n",
+      " 24%|██████████                                | 24/100 [01:16<04:01,  3.17s/it]\n",
+      " 24%|██████████                                | 24/100 [01:15<03:58,  3.14s/it]\n",
+      " 24%|██████████                                | 24/100 [01:15<03:58,  3.14s/it]\n",
+      " 24%|██████████                                | 24/100 [01:15<03:59,  3.15s/it]\n",
+      " 24%|██████████                                | 24/100 [01:14<03:57,  3.12s/it]\n",
+      " 24%|██████████                                | 24/100 [01:14<03:55,  3.09s/it]\n",
+      " 24%|██████████                                | 24/100 [01:12<03:49,  3.03s/it]\n",
+      " 24%|██████████                                | 24/100 [01:09<03:38,  2.88s/it]\n",
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:00<00:00,  6.45it/s]\n",
+      " 24%|██████████                                | 24/100 [00:16<00:52,  1.46it/s]\n",
+      " 24%|██████████                                | 24/100 [00:15<00:50,  1.52it/s]\n",
+      " 24%|██████████                                | 24/100 [00:15<00:48,  1.56it/s]\n",
+      " 24%|██████████                                | 24/100 [00:15<00:48,  1.57it/s]\n",
+      " 24%|██████████                                | 24/100 [00:15<00:48,  1.55it/s]\n",
+      " 24%|██████████                                | 24/100 [00:14<00:46,  1.63it/s]\n",
+      " 24%|██████████                                | 24/100 [00:13<00:43,  1.76it/s]\n",
+      " 24%|██████████                                | 24/100 [00:12<00:38,  1.97it/s]\n",
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:00<00:00,  5.15it/s]\n",
+      " 24%|██████████                                | 24/100 [00:18<00:57,  1.32it/s]\n",
+      " 24%|██████████                                | 24/100 [00:17<00:55,  1.36it/s]\n",
+      " 24%|██████████                                | 24/100 [00:15<00:50,  1.50it/s]\n",
+      " 24%|██████████                                | 24/100 [00:15<00:48,  1.56it/s]\n",
+      " 24%|██████████                                | 24/100 [00:14<00:45,  1.66it/s]\n",
+      " 24%|██████████                                | 24/100 [00:13<00:41,  1.84it/s]\n",
+      " 24%|██████████                                | 24/100 [00:11<00:37,  2.02it/s]\n",
+      " 24%|██████████                                | 24/100 [00:11<00:35,  2.16it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 3001 = NafNet41M DL\n",
+    "# 3101 = NafNet41M Div2k\n",
+    "# 3050 = NafNet41M DL_Prim\n",
+    "# 3020 = Vanilla DL\n",
+    "# 3120 = Vanilla Div2k\n",
+    "for dataset in [DATASET_DIV2K, DATASET_DL_DIV2K_512, DATASET_DL_EXTRAPRIMITIVES_DIV2K_512]:\n",
+    "    inference_path = ROOT_DIR/\"__quantitative_study_denoise_full_comparisons\"/dataset\n",
+    "    inference_path_str = str(inference_path)\n",
+    "    !python infer.py -e 3001 3101 3050 3120 3020 -o $inference_path_str -t metrics restored --size \"512,512\" --std-dev \"2,2 5,5 10,10 15,15 25,25 35,35 50,50 80,80\" -n 96 --dataset $dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:03<00:00,  3.64s/it]\n",
+      " 32%|██████████████                              | 8/25 [00:14<00:30,  1.78s/it]\n",
+      " 32%|██████████████                              | 8/25 [00:10<00:21,  1.26s/it]\n",
+      " 32%|██████████████                              | 8/25 [00:11<00:24,  1.43s/it]\n",
+      " 32%|██████████████                              | 8/25 [00:10<00:22,  1.32s/it]\n",
+      " 32%|██████████████                              | 8/25 [00:10<00:21,  1.28s/it]\n",
+      " 32%|██████████████                              | 8/25 [00:08<00:17,  1.02s/it]\n",
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:02<00:00,  2.39s/it]\n",
+      "  8%|███▍                                       | 8/100 [00:08<01:38,  1.07s/it]\n",
+      "  8%|███▍                                       | 8/100 [00:04<00:53,  1.70it/s]\n",
+      "  8%|███▍                                       | 8/100 [00:04<00:54,  1.68it/s]\n",
+      "  8%|███▍                                       | 8/100 [00:05<01:01,  1.49it/s]\n",
+      "  8%|███▍                                       | 8/100 [00:05<01:01,  1.49it/s]\n",
+      "  8%|███▍                                       | 8/100 [00:04<00:52,  1.75it/s]\n",
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:03<00:00,  3.51s/it]\n",
+      "  8%|███▍                                       | 8/100 [00:09<01:54,  1.24s/it]\n",
+      "  8%|███▍                                       | 8/100 [00:06<01:11,  1.29it/s]\n",
+      "  8%|███▍                                       | 8/100 [00:06<01:10,  1.30it/s]\n",
+      "  8%|███▍                                       | 8/100 [00:05<01:08,  1.35it/s]\n",
+      "  8%|███▍                                       | 8/100 [00:05<01:04,  1.44it/s]\n",
+      "  8%|███▍                                       | 8/100 [00:04<00:56,  1.62it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 3001 = NafNet41M DL\n",
+    "# 3101 = NafNet41M Div2k\n",
+    "# 3050 = NafNet41M DL_Prim\n",
+    "# 3020 = Vanilla DL\n",
+    "# 3120 = Vanilla Div2k\n",
+    "for dataset in [DATASET_DIV2K, DATASET_DL_DIV2K_512, DATASET_DL_EXTRAPRIMITIVES_DIV2K_512]:\n",
+    "    inference_path = ROOT_DIR/\"__quantitative_study_denoise_full\"/dataset\n",
+    "    inference_path_str = str(inference_path)\n",
+    "    !python infer.py -e 3120 -o $inference_path_str -t metrics restored --size \"512,512\" --std-dev \"2,2 5,5 10,10 25,25 50,50 80,80\" -n 32 --dataset $dataset\n",
+    "    # !python infer.py -e 3020 -o $inference_path_str -t metrics restored --size \"512,512\" --std-dev \"2,2 5,5 10,10 25,25 50,50 80,80\" -n 32 --dataset $dataset\n",
+    "    # !python infer.py -e 3001 3101 3050 -o $inference_path_str -t metrics restored --size \"512,512\" --std-dev \"2,2 5,5 10,10 25,25 50,50 80,80\" -n 32 --dataset $dataset\n",
+    "    # !python infer.py -e 3001 3101 3050 -o $inference_path_str -t metrics restored --size \"512,512\" --std-dev \"15,15 35,35\" -n 32 --dataset $dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:09<00:00,  9.49s/it]\n",
+      "  4%|█▊                                          | 1/25 [00:09<03:54,  9.78s/it]\n",
+      "  4%|█▊                                          | 1/25 [00:06<02:25,  6.06s/it]\n",
+      "Loading models: 100%|█████████████████████████████| 1/1 [00:08<00:00,  8.04s/it]\n",
+      "  1%|▍                                          | 1/100 [00:07<12:25,  7.53s/it]\n",
+      "  1%|▍                                          | 1/100 [00:06<10:48,  6.55s/it]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 3011, 3001, 3020, 3120\n",
+    "for dataset in [DATASET_DIV2K, DATASET_DL_DIV2K_512]:\n",
+    "    inference_path = ROOT_DIR/\"__quantitative_study\"/dataset\n",
+    "    inference_path_str = str(inference_path)\n",
+    "    # !python infer.py -e 3001 3020 3120 -o $inference_path_str -t metrics restored --size \"512,512\" --std-dev \"25,25 50,50\" -n 4 --dataset $dataset\n",
+    "    !python infer.py -e 3101 -o $inference_path_str -t metrics restored --size \"512,512\" --std-dev \"25,25 50,50\" -n 4 --dataset $dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 3011, 3001, 3020, 3120\n",
+    "for dataset in [DATASET_DIV2K, DATASET_DL_DIV2K_512]:\n",
+    "    inference_path = ROOT_DIR/\"__quantitative_study_massive\"/dataset\n",
+    "    inference_path_str = str(inference_path)\n",
+    "    # !python infer.py -e 3001 3020 3120 -o $inference_path_str -t metrics restored --size \"512,512\" --std-dev \"25,25 50,50\" -n 4 --dataset $dataset\n",
+    "    !python infer.py -e 3101 -o $inference_path_str -t metrics restored --size \"1024,512\" --std-dev \"25,25 50,50\" -n 4 --dataset $dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "# 3001 = NafNet41M DL\n",
+    "# 3020 = Vanilla DL\n",
+    "experiment_list_compare = [\n",
+    "    3001, 3020,\n",
+    "]\n",
+    "for dataset in [DATASET_DL_DIV2K_512]:\n",
+    "    inference_path = ROOT_DIR/\"__quantitative_study_denoise_full_comparisons\"/dataset\n",
+    "    dir_inp =[(list(inference_path.glob(f\"{exp:04d}_*\"))[0], \"*.csv\") for exp in experiment_list_compare]\n",
+    "    stats = plot_results(dir_inp, title=dataset.replace(\"_512\", \"\").replace(\"_div2k\", \"\").replace(\"_\", \" \"), diff=False, ylim=(20 , 45))\n",
+    "for k, val in stats.items():\n",
+    "    print(k)\n",
+    "    print(val)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The autoreload extension is already loaded. To reload it, use:\n",
+      "  %reload_ext autoreload\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3001_NAFNet41.4M denoise - DL_DIV2K_512 0-50 256x256 (512, 512) | 25 | 28.19dB | 0.935\n",
+      "3101_NAFNet41.4M denoise - DIV2K_512 0-50 256x256 (512, 512) | 25 | 25.38dB | 0.880\n",
+      "3001_NAFNet41.4M denoise - DL_DIV2K_512 0-50 256x256 (512, 512) | 50 | 23.57dB | 0.826\n",
+      "3101_NAFNet41.4M denoise - DIV2K_512 0-50 256x256 (512, 512) | 50 | 21.92dB | 0.760\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3001_NAFNet41.4M denoise - DL_DIV2K_512 0-50 256x256 (512, 512) | 25 | 29.82dB | 0.845\n",
+      "3101_NAFNet41.4M denoise - DIV2K_512 0-50 256x256 (512, 512) | 25 | 31.71dB | 0.888\n",
+      "3001_NAFNet41.4M denoise - DL_DIV2K_512 0-50 256x256 (512, 512) | 50 | 26.74dB | 0.743\n",
+      "3101_NAFNet41.4M denoise - DIV2K_512 0-50 256x256 (512, 512) | 50 | 28.53dB | 0.809\n"
+     ]
+    }
+   ],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "# 3001 = NafNet41M DL\n",
+    "# 3020 = Vanilla DL\n",
+    "experiment_list_compare = [\n",
+    "    3001, 3101,\n",
+    "]\n",
+    "for dataset in [DATASET_DL_DIV2K_512, DATASET_DIV2K]:\n",
+    "    inference_path = ROOT_DIR/\"__quantitative_study_denoise_full_comparisons\"/dataset\n",
+    "    dir_inp =[(list(inference_path.glob(f\"{exp:04d}_*\"))[0], \"*.csv\") for exp in experiment_list_compare]\n",
+    "    stats = plot_results(dir_inp, title=dataset.replace(\"_512\", \"\").replace(\"_div2k\", \"\").replace(\"_\", \" \"), diff=False, ylim=(20 , 45))\n",
+    "    for sigma in [25, 50]:\n",
+    "        for k, val in stats.items():\n",
+    "            extracted_table = val[val[\"noise_stddev\"] == sigma]\n",
+    "            print(\n",
+    "                f'{k} | {sigma} | {extracted_table[\"out_psnr\"].iloc[0]:0.2f}dB | {extracted_table[\"ssim\"].iloc[0]:0.3f}')\n",
+    "# for k, val in stats.items():\n",
+    "#     print(k)\n",
+    "#     print(val)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3001_NAFNet41.4M denoise - DL_DIV2K_512 0-50 256x256 (512, 512) | 25 | 28.19dB | 0.935\n",
+      "3020_Vanilla denoise DL  0-50 - noisy 0-50 (512, 512) | 25 | 26.38dB | 0.887\n",
+      "3001_NAFNet41.4M denoise - DL_DIV2K_512 0-50 256x256 (512, 512) | 50 | 23.57dB | 0.826\n",
+      "3020_Vanilla denoise DL  0-50 - noisy 0-50 (512, 512) | 50 | 22.18dB | 0.742\n"
+     ]
+    }
+   ],
+   "source": [
+    "for sigma in [25, 50]:\n",
+    "    for k, val in stats.items():\n",
+    "    # print(k)\n",
+    "    # print()\n",
+    "        extracted_table = val[val[\"noise_stddev\"] == sigma]\n",
+    "        print(\n",
+    "            f'{k} | {sigma} | {extracted_table[\"out_psnr\"].iloc[0]:0.2f}dB | {extracted_table[\"ssim\"].iloc[0]:0.3f}')\n",
+    "        # print(val[val[\"noise_stddev\"] == 50])\n",
+    "        # print(val[val.noise_std == 50])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# 3001 = NafNet41M DL\n",
+    "# 3101 = NafNet41M Div2k\n",
+    "# 3050 = NafNet41M DL_Prim\n",
+    "# 3020 = Vanilla DL\n",
+    "# 3120 = Vanilla Div2k\n",
+    "experiment_list_compare = [\n",
+    "    3101, 3020, 3001, 3050, 3120\n",
+    "]\n",
+    "for dataset in [DATASET_DIV2K, DATASET_DL_DIV2K_512, DATASET_DL_EXTRAPRIMITIVES_DIV2K_512]:\n",
+    "    inference_path = ROOT_DIR/\"__quantitative_study_denoise_full_comparisons\"/dataset\n",
+    "    dir_inp =[(list(inference_path.glob(f\"{exp:04d}_*\"))[0], \"*.csv\") for exp in experiment_list_compare]\n",
+    "    plot_results(dir_inp, title=dataset.replace(\"_512\", \"\").replace(\"_div2k\", \"\").replace(\"_\", \" \"), diff=False, ylim=(20 , 45))\n",
+    "    \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "robotics",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/scripts/remote_training.py b/scripts/remote_training.py
new file mode 100644
index 0000000000000000000000000000000000000000..8507ac3b470bd7ed93850adfb767bd62a248b80e
--- /dev/null
+++ b/scripts/remote_training.py
@@ -0,0 +1,116 @@
+import kaggle
+from pathlib import Path, PurePosixPath
+import json
+try:
+    from __kaggle_login import kaggle_users
+except ImportError:
+    raise ImportError("Please create a __kaggle_login.py file with a kaggle_users" +
+                      "dict containing your Kaggle credentials.")
+import argparse
+import sys
+import subprocess
+from configuration import ROOT_DIR, OUTPUT_FOLDER_NAME
+from train import get_parser as get_train_parser
+from typing import Optional
+from configuration import KAGGLE_DATASET_LIST, NB_ID, GIT_USER, GIT_REPO, TRAIN_SCRIPT
+
+
+def get_git_branch_name():
+    try:
+        branch_name = subprocess.check_output(["git", "branch", "--show-current"]).strip().decode()
+        return branch_name
+    except subprocess.CalledProcessError:
+        return "Error: Could not determine the Git branch name."
+
+
+def prepare_notebook(
+    output_nb_path: Path,
+    exp: int,
+    branch: str,
+    git_user: str = None,
+    git_repo: str = None,
+    template_nb_path: Path = Path(__file__).parent/"remote_training_template.ipynb",
+    wandb_flag: bool = False,
+    output_dir: Path = "scripts/"+OUTPUT_FOLDER_NAME,
+    dataset_files: Optional[list] = None,
+    train_script: str = TRAIN_SCRIPT
+):
+    assert git_user is not None, "Please provide a git username for the repo"
+    assert git_repo is not None, "Please provide a git repo name for the repo"
+    expressions = [
+        ("exp", f"{exp}"),
+        ("branch", f"\'{branch}\'"),
+        ("git_user", f"\'{git_user}\'"),
+        ("git_repo", f"\'{git_repo}\'"),
+        ("wandb_flag", "True" if wandb_flag else "False"),
+        ("output_dir", "None" if output_dir is None else f"\'{output_dir}\'"),
+        ("dataset_files", "None" if dataset_files is None else f"{dataset_files}"),
+        ("train_script", "\'"+train_script+"\'")
+    ]
+    with open(template_nb_path) as f:
+        template_nb = f.readlines()
+        for line_idx, li in enumerate(template_nb):
+            for expr, expr_replace in expressions:
+                if f"!!!{expr}!!!" in li:
+                    template_nb[line_idx] = template_nb[line_idx].replace(f"!!!{expr}!!!", expr_replace)
+        template_nb = "".join(template_nb)
+    with open(output_nb_path, "w") as w:
+        w.write(template_nb)
+
+
+def main(argv):
+    parser = argparse.ArgumentParser(description="Train a model on Kaggle using a script")
+    parser.add_argument("-n", "--nb_id", type=str, help="Notebook name in kaggle", default=NB_ID)
+    parser.add_argument("-u", "--user", type=str, help="Kaggle user", choices=list(kaggle_users.keys()))
+    parser.add_argument("--branch", type=str, help="Git branch name", default=get_git_branch_name())
+    parser.add_argument("-p", "--push", action="store_true", help="Push")
+    parser.add_argument("-d", "--download", action="store_true", help="Download results")
+    get_train_parser(parser)
+    args = parser.parse_args(argv)
+    nb_id = args.nb_id
+    exp_str = "_".join(f"{exp:04d}" for exp in args.exp)
+    kaggle_user = kaggle_users[args.user]
+    uname_kaggle = kaggle_user["username"]
+    kaggle.api._load_config(kaggle_user)
+    if args.download:
+        tmp_dir = ROOT_DIR/f"__tmp_{exp_str}"
+        tmp_dir.mkdir(exist_ok=True, parents=True)
+        kaggle.api.kernels_output_cli(f"{kaggle_user['username']}/{nb_id}", path=str(tmp_dir))
+        subprocess.run(["tar", "-xzf", tmp_dir/"output.tgz"])
+        # @FIXME: windows probably does not have tar command
+        import shutil
+        shutil.rmtree(tmp_dir, ignore_errors=True)
+        return
+    kernel_root = ROOT_DIR/f"__nb_{uname_kaggle}"
+    kernel_root.mkdir(exist_ok=True, parents=True)
+
+    kernel_path = kernel_root/exp_str
+    kernel_path.mkdir(exist_ok=True, parents=True)
+    branch = args.branch
+    config = {
+        "id": str(PurePosixPath(f"{kaggle_user['username']}")/nb_id),
+        "title": nb_id.lower(),
+        "code_file": f"{nb_id}.ipynb",
+        "language": "python",
+        "kernel_type": "notebook",
+        "is_private": "true",
+        "enable_gpu": "true" if not args.cpu else "false",
+        "enable_tpu": "false",
+        "enable_internet": "true",
+        "dataset_sources": KAGGLE_DATASET_LIST,
+        "competition_sources": [],
+        "kernel_sources": [],
+        "model_sources": []
+    }
+    prepare_notebook((kernel_path/nb_id).with_suffix(".ipynb"), args.exp, branch,
+                     git_user=GIT_USER, git_repo=GIT_REPO, wandb_flag=not args.no_wandb)
+    assert (kernel_path/nb_id).with_suffix(".ipynb").exists()
+    with open(kernel_path/"kernel-metadata.json", "w") as f:
+        json.dump(config, f, indent=4)
+
+    if args.push:
+        kaggle.api.kernels_push_cli(str(kernel_path))
+
+
+if __name__ == '__main__':
+    main(sys.argv[1:])
diff --git a/scripts/remote_training_template.ipynb b/scripts/remote_training_template.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..e02e90e71795f8e6a5c93d11e344ba96e3b60cfb
--- /dev/null
+++ b/scripts/remote_training_template.ipynb
@@ -0,0 +1 @@
+{"cells":[{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["exp = !!!exp!!!\n","branch = !!!branch!!!\n","git_user = !!!git_user!!!\n","git_repo = !!!git_repo!!!\n","wandb_flag = !!!wandb_flag!!!\n","output_dir = !!!output_dir!!!\n","dataset_files = !!!dataset_files!!!\n","train_script = !!!train_script!!!"]},{"cell_type":"markdown","metadata":{},"source":["# Clone git repo"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["%cd ~\n","!git clone https://github.com/$git_user/$git_repo >/dev/null\n","%cd $git_repo\n","!git checkout $branch\n","!pip install -e ."]},{"cell_type":"markdown","metadata":{},"source":["# Load Kaggle datasets"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["!mkdir __dataset/deadleaves_div2k_512\n","!cp /kaggle/input/deadleaves-div2k-512/deadleaves_div2k_512/* \"__dataset/deadleaves_div2k_512\""]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["!mkdir __dataset/deadleaves_primitives_div2k_512\n","!cp /kaggle/input/deadleaves-primitives-div2k-512/deadleaves_primitives_div2k_512/* \"__dataset/deadleaves_primitives_div2k_512\""]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["!mkdir __dataset/div2k\n","!cp -r \"/kaggle/input/div2k-dataset/DIV2K_train_HR\" \"__dataset/div2k/\"\n","!cp -r \"/kaggle/input/div2k-dataset/DIV2K_valid_HR/\" \"__dataset/div2k/\""]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["!mkdir __dataset/kernels\n","!cp \"/kaggle/input/motion-blur-kernels/custom_blur_centered.mat\" __dataset/kernels/"]},{"cell_type":"markdown","metadata":{},"source":["# Setup weights and biases"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["if wandb_flag:\n","    from kaggle_secrets import UserSecretsClient\n","    user_secrets = UserSecretsClient()\n","    wandb_api_key = user_secrets.get_secret(\"wandb_api_key\")\n","\n","    !pip install wandb >/dev/null\n","    !wandb login $wandb_api_key"]},{"cell_type":"markdown","metadata":{},"source":["# Launch training"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["exp_str = ' '.join([str(e) for e in exp])\n","wb_ext = \"-nowb\" if not wandb_flag else \"\"\n","!python $train_script -e $exp_str $wb_ext"]},{"cell_type":"markdown","metadata":{},"source":["# Prepare outputs"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["if output_dir is not None:\n","    !tar -cvzf /kaggle/working/output.tgz $output_dir"]}],"metadata":{"kaggle":{"accelerator":"gpu","dataSources":[{"datasetId":4234777,"sourceId":7299921,"sourceType":"datasetVersion"}],"dockerImageVersionId":30626,"isGpuEnabled":true,"isInternetEnabled":true,"language":"python","sourceType":"notebook"},"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.10.12"}},"nbformat":4,"nbformat_minor":4}
diff --git a/scripts/save_deadleaves.py b/scripts/save_deadleaves.py
new file mode 100644
index 0000000000000000000000000000000000000000..76bd0bb2e1f1628323c991cc6fcee347a3733018
--- /dev/null
+++ b/scripts/save_deadleaves.py
@@ -0,0 +1,172 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Mar 23 15:38:28 2024
+
+@author: jamyl
+"""
+import cv2
+from pathlib import Path
+from time import perf_counter
+import matplotlib.pyplot as plt
+from typing import Tuple
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch.utils.data import Dataset
+from numba import cuda
+from tqdm import tqdm
+import argparse
+from rstor.synthetic_data.dead_leaves_gpu import gpu_dead_leaves_chart
+from rstor.utils import DEFAULT_TORCH_FLOAT_TYPE
+from rstor.properties import DATASET_PATH, DATASET_DL_RANDOMRGB_1024, DATASET_DL_DIV2K_1024, SAMPLER_NATURAL, SAMPLER_UNIFORM, DATASET_DL_DIV2K_512, DATASET_DL_EXTRAPRIMITIVES_DIV2K_512
+
+
+class DeadLeavesDatasetGPU(Dataset):
+    def __init__(
+        self,
+        size: Tuple[int, int] = (128, 128),
+        length: int = 1000,
+        frozen_seed: int = None,  # useful for validation set!
+        ds_factor: int = 5,
+        **config_dead_leaves
+    ):
+
+        self.frozen_seed = frozen_seed
+        self.ds_factor = ds_factor
+        self.size = (size[0]*ds_factor, size[1]*ds_factor)
+        self.length = length
+        self.config_dead_leaves = config_dead_leaves
+
+        # downsample kernel
+        sigma = 3/5
+        k_size = 5  # This fits with sigma = 3/5, the cutoff value is 0.0038 (neglectable)
+        x = (torch.arange(k_size) - 2).to('cuda')
+        kernel = torch.stack(torch.meshgrid((x, x), indexing='ij'))
+        dist_sq = kernel[0]**2 + kernel[1]**2
+        kernel = (-dist_sq.square()/(2*sigma**2)).exp()
+        kernel = kernel / kernel.sum()
+        self.downsample_kernel = kernel.repeat(3, 1, 1, 1)  # shape [3, 1, k_size, k_size]
+
+    def __len__(self) -> int:
+        return self.length
+
+    def __getitem__(self, idx: int) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Get a single deadleave chart and its degraded version.
+
+        Args:
+            idx (int): index of the item to retrieve
+
+        Returns:
+            Tuple[torch.Tensor, torch.Tensor]: degraded chart, target chart
+        """
+        seed = self.frozen_seed + idx if self.frozen_seed is not None else None
+
+        # Return numba device array
+        numba_chart = gpu_dead_leaves_chart(self.size, seed=seed, **self.config_dead_leaves)
+        if self.ds_factor > 1:
+            # print(f"Downsampling {chart.shape} with factor {self.ds_factor}...")
+
+            # Downsample using strided gaussian conv (sigma=3/5)
+            th_chart = torch.as_tensor(numba_chart, dtype=DEFAULT_TORCH_FLOAT_TYPE,
+                                       device="cuda").permute(2, 0, 1)[None]  # [b, c, h, w]
+            th_chart = F.pad(th_chart,
+                             pad=(2, 2, 0, 0),
+                             mode="replicate")
+            th_chart = F.conv2d(th_chart,
+                                self.downsample_kernel,
+                                padding='valid',
+                                groups=3,
+                                stride=self.ds_factor)
+
+            # Convert back to numba
+            numba_chart = cuda.as_cuda_array(th_chart.permute(0, 2, 3, 1))  # [b, h, w, c]
+
+        # convert back to numpy (temporary for legacy)
+        chart = numba_chart.copy_to_host()[0]
+
+        return chart
+
+
+def generate_images(path: Path, dataset: Dataset, imin=0):
+    for i in tqdm(range(imin, dataset.length)):
+        img = dataset[i]
+        img = (img * 255).astype(np.uint8)
+        out_path = path / "{:04d}.png".format(i)
+        cv2.imwrite(out_path.as_posix(), img)
+
+
+def bench(dataset):
+
+    print("dataset initialised")
+    t1 = perf_counter()
+    chart = dataset[0]
+
+    d = (perf_counter()-t1)
+    print(f"generation done {d}")
+    print(f"{d*1_000/60} min for 1_000")
+    plt.imshow(chart)
+    plt.show()
+
+
+if __name__ == "__main__":
+    argparser = argparse.ArgumentParser()
+    argparser.add_argument("-o", "--output-dir", type=str, default=str(DATASET_PATH))
+    argparser.add_argument(
+        "-n", "--name", type=str,
+        choices=[DATASET_DL_RANDOMRGB_1024, DATASET_DL_DIV2K_1024,
+                 DATASET_DL_DIV2K_512, DATASET_DL_EXTRAPRIMITIVES_DIV2K_512],
+        default=DATASET_DL_RANDOMRGB_1024
+    )
+    argparser.add_argument("-b", "--benchmark", action="store_true")
+    default_config = dict(
+        size=(1_024, 1_024),
+        length=1_000,
+        frozen_seed=42,
+        background_color=(0.2, 0.4, 0.6),
+        colored=True,
+        radius_min=5,
+        radius_max=2_000,
+        ds_factor=5,
+    )
+
+    args = argparser.parse_args()
+    dataset_dir = args.output_dir
+    name = args.name
+    path = Path(dataset_dir)/name
+    # print(path)
+    path.mkdir(parents=True, exist_ok=True)
+    if name == DATASET_DL_RANDOMRGB_1024:
+        config = default_config
+        config["sampler"] = SAMPLER_UNIFORM
+    elif name == DATASET_DL_DIV2K_1024:
+        config = default_config
+        config["sampler"] = SAMPLER_NATURAL
+        config["natural_image_list"] = sorted(
+            list((DATASET_PATH / "div2k" / "DIV2K_train_HR" / "DIV2K_train_HR").glob("*.png"))
+        )
+    elif name == DATASET_DL_DIV2K_512:
+        config = default_config
+        config["size"] = (512, 512)
+        config["rmin"] = 3
+        config["length"] = 4000
+        config["sampler"] = SAMPLER_NATURAL
+        config["natural_image_list"] = sorted(
+            list((DATASET_PATH / "div2k" / "DIV2K_train_HR" / "DIV2K_train_HR").glob("*.png"))
+        )
+    elif name == DATASET_DL_EXTRAPRIMITIVES_DIV2K_512:
+        config = default_config
+        config["size"] = (512, 512)
+        config["sampler"] = SAMPLER_NATURAL
+        config["circle_primitives"] = False
+        config["length"] = 4000
+        config["natural_image_list"] = sorted(
+            list((DATASET_PATH / "div2k" / "DIV2K_train_HR" / "DIV2K_train_HR").glob("*.png"))
+        )
+    else:
+        raise NotImplementedError
+    dataset = DeadLeavesDatasetGPU(**config)
+    if args.benchmark:
+        bench(dataset)
+    else:
+        generate_images(path, dataset)
diff --git a/scripts/train.py b/scripts/train.py
new file mode 100644
index 0000000000000000000000000000000000000000..31b78b3dcafe07015575dc6d4dfd1762d14c4f0c
--- /dev/null
+++ b/scripts/train.py
@@ -0,0 +1,171 @@
+import sys
+import argparse
+from typing import Optional
+import torch
+import logging
+from pathlib import Path
+import json
+from tqdm import tqdm
+from rstor.properties import (
+    ID, NAME, NB_EPOCHS,
+    TRAIN, VALIDATION, LR,
+    LOSS_MSE, METRIC_PSNR, METRIC_SSIM,
+    DEVICE, SCHEDULER_CONFIGURATION, SCHEDULER, REDUCELRONPLATEAU,
+    REDUCTION_SUM,
+    SELECTED_METRICS,
+    LOSS
+)
+from rstor.learning.metrics import compute_metrics
+from rstor.learning.loss import compute_loss
+from torch.optim.lr_scheduler import ReduceLROnPlateau
+from configuration import WANDBSPACE, ROOT_DIR, OUTPUT_FOLDER_NAME
+from rstor.learning.experiments import get_training_content
+from rstor.learning.experiments_definition import get_experiment_config
+WANDB_AVAILABLE = False
+try:
+    WANDB_AVAILABLE = True
+    import wandb
+except ImportError:
+    logging.warning("Could not import wandb. Disabling wandb.")
+    pass
+
+
+def get_parser(parser: Optional[argparse.ArgumentParser] = None) -> argparse.ArgumentParser:
+    if parser is None:
+        parser = argparse.ArgumentParser(description="Train a model")
+    parser.add_argument("-e", "--exp", nargs="+", type=int, required=True, help="Experiment id")
+    parser.add_argument("-o", "--output-dir", type=str, default=ROOT_DIR/OUTPUT_FOLDER_NAME, help="Output directory")
+    parser.add_argument("-nowb", "--no-wandb", action="store_true", help="Disable weights and biases")
+    parser.add_argument("--cpu", action="store_true", help="Force CPU")
+    return parser
+
+
+def training_loop(
+    model,
+    optimizer,
+    dl_dict: dict,
+    config: dict,
+    scheduler=None,
+    device: str = DEVICE,
+    wandb_flag: bool = False,
+    output_dir: Path = None,
+):
+    best_accuracy = 0.
+    chosen_metrics = config.get(SELECTED_METRICS, [METRIC_PSNR, METRIC_SSIM])
+    for n_epoch in tqdm(range(config[NB_EPOCHS])):
+        current_metrics = {
+            TRAIN: 0.,
+            VALIDATION: 0.,
+            LR: optimizer.param_groups[0]['lr'],
+        }
+        for met in chosen_metrics:
+            current_metrics[met] = 0.
+        for phase in [TRAIN, VALIDATION]:
+            total_elements = 0
+            if phase == TRAIN:
+                model.train()
+            else:
+                model.eval()
+            for x, y in tqdm(dl_dict[phase], desc=f"{phase} - Epoch {n_epoch}"):
+                x, y = x.to(device), y.to(device)
+                optimizer.zero_grad()
+                with torch.set_grad_enabled(phase == TRAIN):
+                    y_pred = model(x)
+                    loss = compute_loss(y_pred, y, mode=config.get(LOSS, LOSS_MSE))
+                    if torch.isnan(loss):
+                        print(f"Loss is NaN at epoch {n_epoch} and phase {phase}!")
+                        continue
+                    if phase == TRAIN:
+                        loss.backward()
+                        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.)
+                        optimizer.step()
+                current_metrics[phase] += loss.item()
+                if phase == VALIDATION:
+                    metrics_on_batch = compute_metrics(
+                        y_pred,
+                        y,
+                        chosen_metrics=chosen_metrics,
+                        reduction=REDUCTION_SUM
+                    )
+                    total_elements += y_pred.shape[0]
+                    for k, v in metrics_on_batch.items():
+                        current_metrics[k] += v
+
+            current_metrics[phase] /= (len(dl_dict[phase]))
+            if phase == VALIDATION:
+                for k, v in metrics_on_batch.items():
+                    current_metrics[k] /= total_elements
+                    try:
+                        current_metrics[k] = current_metrics[k].item()
+                    except AttributeError:
+                        pass
+        debug_print = f"{phase}: Epoch {n_epoch} - Loss: {current_metrics[phase]:.3e} "
+        for k, v in current_metrics.items():
+            if k not in [TRAIN, VALIDATION, LR]:
+                debug_print += f"{k}: {v:.3} |"
+        print(debug_print)
+        if scheduler is not None and isinstance(scheduler, ReduceLROnPlateau):
+            scheduler.step(current_metrics[VALIDATION])
+        if output_dir is not None:
+            with open(output_dir/f"metrics_{n_epoch}.json", "w") as f:
+                json.dump(current_metrics, f)
+        if wandb_flag:
+            wandb.log(current_metrics)
+        if best_accuracy < current_metrics[METRIC_PSNR]:
+            best_accuracy = current_metrics[METRIC_PSNR]
+            if output_dir is not None:
+                print("new best model saved!")
+                torch.save(model.state_dict(), output_dir/"best_model.pt")
+    if output_dir is not None:
+        torch.save(model.cpu().state_dict(), output_dir/"last_model.pt")
+    return model
+
+
+def train(config: dict, output_dir: Path, device: str = DEVICE, wandb_flag: bool = False):
+    logging.basicConfig(level=logging.INFO)
+    logging.info(f"Training experiment {config[ID]} on device {device}...")
+    output_dir.mkdir(parents=True, exist_ok=True)
+    with open(output_dir/"config.json", "w") as f:
+        json.dump(config, f)
+    model, optimizer, dl_dict = get_training_content(config, training_mode=True, device=device)
+    model.to(device)
+    if wandb_flag:
+        import wandb
+        wandb.init(
+            project=WANDBSPACE,
+            entity="balthazarneveu",
+            name=config[NAME],
+            tags=["debug"],
+            # tags=["base"],
+            config=config
+        )
+    scheduler = None
+    if config.get(SCHEDULER, False):
+        scheduler_config = config[SCHEDULER_CONFIGURATION]
+        if config[SCHEDULER] == REDUCELRONPLATEAU:
+            scheduler = ReduceLROnPlateau(optimizer, mode='min', verbose=True, **scheduler_config)
+        else:
+            raise NameError(f"Scheduler {config[SCHEDULER]} not implemented")
+    model = training_loop(model, optimizer, dl_dict, config, scheduler=scheduler, device=device,
+                          wandb_flag=wandb_flag, output_dir=output_dir)
+
+    if wandb_flag:
+        wandb.finish()
+
+
+def train_main(argv):
+    parser = get_parser()
+    args = parser.parse_args(argv)
+    if not WANDB_AVAILABLE:
+        args.no_wandb = True
+    device = "cpu" if args.cpu else DEVICE
+    for exp in args.exp:
+        config = get_experiment_config(exp)
+        print(config)
+        output_dir = Path(args.output_dir)/config[NAME]
+        logging.info(f"Training experiment {config[ID]} on device {device}...")
+        train(config, device=device, output_dir=output_dir, wandb_flag=not args.no_wandb)
+
+
+if __name__ == "__main__":
+    train_main(sys.argv[1:])
diff --git a/src/rstor/__init__.py b/src/rstor/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/rstor/analyzis/interactive/crop.py b/src/rstor/analyzis/interactive/crop.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef93e645e6d03fccc26129169288b4af8a9ffce9
--- /dev/null
+++ b/src/rstor/analyzis/interactive/crop.py
@@ -0,0 +1,75 @@
+import cv2
+import numpy as np
+from interactive_pipe import interactive
+
+
+def get_color_channel_offset(image):
+    # size is defined in power of 2
+    if len(image.shape) == 2:
+        offset = 0
+    elif len(image.shape) == 3:
+        channel_guesser_max_size = 4
+        if image.shape[0] <= channel_guesser_max_size:  # channel first C,H,W
+            offset = 0
+        elif image.shape[-1] <= channel_guesser_max_size:  # channel last or numpy H,W,C
+            offset = 1
+    else:
+        raise NameError(f"Not supported shape {image.shape}")
+    return offset
+
+
+def crop_selector(image, center_x=0.5, center_y=0.5, size=9., global_params={}):
+    offset = get_color_channel_offset(image)
+    crop_size_pixels = int(2.**(size)/2.)
+    h, w = image.shape[-2-offset], image.shape[-1-offset]
+    ar = w/h
+    half_crop_h, half_crop_w = crop_size_pixels, int(ar*crop_size_pixels)
+
+    def round(val):
+        return int(np.round(val))
+    center_x_int = round(half_crop_w + center_x*(w-2*half_crop_w))
+    center_y_int = round(half_crop_h + center_y*(h-2*half_crop_h))
+    start_x = max(0, center_x_int-half_crop_w)
+    start_y = max(0, center_y_int-half_crop_h)
+    end_x = min(start_x+2*half_crop_w, w-1)
+    end_y = min(start_y+2*half_crop_h, h-1)
+    start_x = max(0, end_x-2*half_crop_w)
+    start_y = max(0, end_y-2*half_crop_h)
+    MAX_ALLOWED_SIZE = 512
+    w_resize = int(min(MAX_ALLOWED_SIZE, w))
+    h_resize = int(w_resize/w*h)
+    h_resize = int(min(MAX_ALLOWED_SIZE, h_resize))
+    w_resize = int(h_resize/h*w)
+    global_params["crop"] = (start_x, start_y, end_x, end_y)
+    global_params["resize"] = (w_resize, h_resize)
+    return
+
+
+def plug_crop_selector(num_pad: bool = False):
+    interactive(
+        center_x=(0.5, [0., 1.], "cx", ["4" if num_pad else "left", "6" if num_pad else "right"]),
+        center_y=(0.5, [0., 1.], "cy", ["8" if num_pad else "up", "2" if num_pad else "down"]),
+        size=(9., [6., 13., 0.3], "crop size", ["+", "-"])
+    )(crop_selector)
+
+
+def crop(*images, global_params={}):
+    images_resized = []
+    for image in images:
+        offset = get_color_channel_offset(image)
+        start_x, start_y, end_x, end_y = global_params["crop"]
+        w_resize, h_resize = global_params["resize"]
+        if offset == 0:
+            crop = image[..., start_y:end_y, start_x:end_x]
+        if offset == 1:
+            crop = image[..., start_y:end_y, start_x:end_x, :]
+        image_resized = cv2.resize(crop, (w_resize, h_resize), interpolation=cv2.INTER_NEAREST)
+        images_resized.append(image_resized)
+    return tuple(images_resized)
+
+
+def rescale_thumbnail(image, global_params={}):
+    if image is None:  # support no blur kernel!
+        return None
+    resize_dim = max(global_params.get("resize", (512, 512)))
+    return cv2.resize(image, (resize_dim, resize_dim), interpolation=cv2.INTER_NEAREST)
diff --git a/src/rstor/analyzis/interactive/degradation.py b/src/rstor/analyzis/interactive/degradation.py
new file mode 100644
index 0000000000000000000000000000000000000000..264f25381ed96e318d309875ef1a73b0c088ef4b
--- /dev/null
+++ b/src/rstor/analyzis/interactive/degradation.py
@@ -0,0 +1,71 @@
+import numpy as np
+from interactive_pipe import interactive
+from skimage.filters import gaussian
+from rstor.properties import DATASET_BLUR_KERNEL_PATH
+from scipy.io import loadmat
+import cv2
+
+
+@interactive(
+    sigma=(3/5, [0., 2.])
+)
+def downsample(chart: np.ndarray, sigma=3/5, global_params={}):
+    ds_factor = global_params.get("ds_factor", 5)
+    if sigma > 0.:
+        ds_chart = gaussian(chart, sigma=(sigma, sigma, 0), mode='nearest', cval=0, preserve_range=True, truncate=4.0)
+    else:
+        ds_chart = chart.copy()
+    ds_chart = ds_chart[ds_factor//2::ds_factor, ds_factor//2::ds_factor]
+    return ds_chart
+
+
+@interactive(
+    k_size_x=(0, [0, 10]),
+    k_size_y=(0, [0, 10]),
+)
+def degrade_blur_gaussian(chart: np.ndarray, k_size_x: int = 1, k_size_y: int = 1):
+    if k_size_x == 0 and k_size_y == 0:
+        blurred = chart
+    blurred = cv2.GaussianBlur(chart, (2*k_size_x+1, 2*k_size_y+1), 0)
+    return blurred
+
+
+@interactive(
+    noise_stddev=(0., [0., 50.])
+)
+def degrade_noise(img: np.ndarray, noise_stddev=0., global_params={}):
+    seed = global_params.get("seed", 42)
+    np.random.seed(seed)
+    if noise_stddev > 0.:
+        noise = np.random.normal(0, noise_stddev/255., img.shape)
+        img = img.copy()+noise
+    return img
+
+
+@interactive(
+    ksize=(3, [1, 10])
+)
+def get_blur_kernel_box(ksize=3):
+    return np.ones((ksize, ksize), dtype=np.float32) / (1.*ksize**2)
+
+
+@interactive(
+    blur_index=(-1, [-1, 1000])
+)
+def get_blur_kernel(blur_index: int = -1, global_params={}):
+    if blur_index == -1:
+        return None
+    blur_mat = global_params.get("blur_mat", False)
+    if blur_mat is False:
+        blur_mat = loadmat(DATASET_BLUR_KERNEL_PATH)["kernels"].squeeze()
+        global_params["blur_mat"] = blur_mat
+    blur_k = blur_mat[blur_index]
+    blur_k = blur_k/blur_k.sum()
+    return blur_k
+
+
+def degrade_blur(img: np.ndarray, blur_kernel: np.ndarray, global_params={}):
+    if blur_kernel is None:
+        return img
+    img_blur = cv2.filter2D(img, -1, blur_kernel)
+    return img_blur
diff --git a/src/rstor/analyzis/interactive/images.py b/src/rstor/analyzis/interactive/images.py
new file mode 100644
index 0000000000000000000000000000000000000000..b4b2b70b0bb2a8f08621a2307c5daf4473b8ebba
--- /dev/null
+++ b/src/rstor/analyzis/interactive/images.py
@@ -0,0 +1,10 @@
+from interactive_pipe.data_objects.image import Image
+from typing import List
+
+
+def image_selector(image_list: List[dict], image_index: int = 0) -> dict:
+    current_image = image_list[image_index % len(image_list)]
+    img = current_image.get("buffer", None)
+    if img is None:
+        img = Image.from_file(current_image["path"]).data
+    return img
diff --git a/src/rstor/analyzis/interactive/inference.py b/src/rstor/analyzis/interactive/inference.py
new file mode 100644
index 0000000000000000000000000000000000000000..f367220e8b95e70a8e8013952eaffb0f97c7a395
--- /dev/null
+++ b/src/rstor/analyzis/interactive/inference.py
@@ -0,0 +1,12 @@
+import torch
+import numpy as np
+from rstor.properties import DEVICE
+
+
+def infer(degraded: np.ndarray, model: torch.nn.Module):
+    degraded_tensor = torch.from_numpy(degraded).permute(-1, 0, 1).float().unsqueeze(0)
+    model.eval()
+    with torch.no_grad():
+        output = model(degraded_tensor.to(DEVICE))
+    output = output.squeeze().permute(1, 2, 0).cpu().numpy()
+    return np.ascontiguousarray(output)
diff --git a/src/rstor/analyzis/interactive/metrics.py b/src/rstor/analyzis/interactive/metrics.py
new file mode 100644
index 0000000000000000000000000000000000000000..e130fe3f0ffb2e272db2b27210ac2fac8a3f8931
--- /dev/null
+++ b/src/rstor/analyzis/interactive/metrics.py
@@ -0,0 +1,36 @@
+from rstor.learning.metrics import compute_metrics, ALL_METRICS
+import torch
+import numpy as np
+from rstor.properties import METRIC_PSNR, METRIC_SSIM
+from interactive_pipe import interactive, KeyboardControl
+from typing import Optional
+
+
+def plug_configure_metrics(key_shortcut: Optional[str] = None) -> None:
+    interactive(
+        advanced_metrics=KeyboardControl(False, keydown=key_shortcut) if key_shortcut is not None else (True,)
+    )(configure_metrics)
+
+
+def configure_metrics(advanced_metrics=False, global_params={}) -> None:
+    chosen_metrics = ALL_METRICS if advanced_metrics else [METRIC_PSNR, METRIC_SSIM]
+    global_params["chosen_metrics"] = chosen_metrics
+
+
+def get_metrics(prediction: torch.Tensor, target: torch.Tensor,
+                image_name: str,  # use functools.partial to root where you want the title to appear
+                global_params: dict = {}) -> None:
+    if isinstance(prediction, np.ndarray):
+        prediction_ = torch.from_numpy(prediction).permute(-1, 0, 1).float().unsqueeze(0)
+    else:
+        prediction_ = prediction
+    if isinstance(target, np.ndarray):
+        target_ = torch.from_numpy(target).permute(-1, 0, 1).float().unsqueeze(0)
+    else:
+        target_ = target
+    chosen_metrics = global_params.get("chosen_metrics", [METRIC_PSNR])
+    metrics = compute_metrics(prediction_, target_, chosen_metrics=chosen_metrics)
+    global_params["metrics"] = metrics
+    title = f"{image_name}: "
+    title += " ".join([f"{key}: {value:.4f}" for key, value in metrics.items()])
+    global_params["__output_styles"][image_name] = {"title": title, "image_name": image_name}
diff --git a/src/rstor/analyzis/interactive/model_selection.py b/src/rstor/analyzis/interactive/model_selection.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ca78c037e43b79415444b683397b9d7002e4cde
--- /dev/null
+++ b/src/rstor/analyzis/interactive/model_selection.py
@@ -0,0 +1,58 @@
+import torch
+from interactive_pipe import KeyboardControl
+from rstor.learning.experiments import get_training_content
+from rstor.learning.experiments_definition import get_experiment_config
+from rstor.properties import DEVICE, PRETTY_NAME
+from tqdm import tqdm
+from pathlib import Path
+from typing import List, Tuple
+
+from interactive_pipe import interactive
+MODELS_PATH = Path("scripts")/"__output"
+
+
+def model_selector(models_dict: dict, global_params={}, model_name="vanilla"):
+    if isinstance(model_name, str):
+        current_model = models_dict[model_name]
+    elif isinstance(model_name, int):
+        model_names = [name for name in models_dict.keys()]
+        current_model = models_dict[model_names[model_name % len(model_names)]]
+    else:
+        raise ValueError(f"Model name {model_name} not understood")
+    global_params["model_config"] = current_model["config"]
+    return current_model["model"]
+
+
+def get_model_from_exp(exp: int, model_storage: Path = MODELS_PATH, device=DEVICE) -> Tuple[torch.nn.Module, dict]:
+    config = get_experiment_config(exp)
+    model, _, _ = get_training_content(config, training_mode=False)
+    model_path = torch.load(model_storage/f"{exp:04d}"/"best_model.pt")
+    assert model_path is not None, f"Model {exp} not found"
+    model.load_state_dict(model_path)
+    model = model.to(device)
+    return model, config
+
+
+def get_default_models(
+    exp_list: List[int] = [1000, 1001],
+    model_storage: Path = MODELS_PATH,
+    keyboard_control: bool = False,
+    interactive_flag: bool = True
+) -> dict:
+    model_dict = {}
+    assert model_storage.exists(), f"Model storage {model_storage} does not exist"
+    for exp in tqdm(exp_list, desc="Loading models"):
+        model, config = get_model_from_exp(exp, model_storage=model_storage)
+        name = config.get(PRETTY_NAME, f"{exp:04d}")
+        model_dict[name] = {
+            "model": model,
+            "config": config
+        }
+    exp_names = [name for name in model_dict.keys()]
+    if interactive_flag:
+        if keyboard_control:
+            model_control = KeyboardControl(0, [0, len(exp_names)-1], keydown="pagedown", keyup="pageup", modulo=True)
+        else:
+            model_control = (exp_names[0], exp_names)
+        interactive(model_name=model_control)(model_selector)  # Create the model dialog
+    return model_dict
diff --git a/src/rstor/analyzis/interactive/pipelines.py b/src/rstor/analyzis/interactive/pipelines.py
new file mode 100644
index 0000000000000000000000000000000000000000..382b5faf46e55885b4a0268c839061ec12991836
--- /dev/null
+++ b/src/rstor/analyzis/interactive/pipelines.py
@@ -0,0 +1,61 @@
+from rstor.synthetic_data.interactive.interactive_dead_leaves import generate_deadleave
+from rstor.analyzis.interactive.crop import crop_selector, crop, rescale_thumbnail
+from rstor.analyzis.interactive.inference import infer
+from rstor.analyzis.interactive.degradation import degrade_noise, degrade_blur, downsample, degrade_blur_gaussian, get_blur_kernel
+from rstor.analyzis.interactive.model_selection import model_selector
+from rstor.analyzis.interactive.images import image_selector
+from rstor.analyzis.interactive.metrics import get_metrics, configure_metrics
+from interactive_pipe import interactive, KeyboardControl
+from typing import Tuple, List
+from functools import partial
+import numpy as np
+
+
+get_metrics_restored = partial(get_metrics, image_name="restored")
+get_metrics_degraded = partial(get_metrics, image_name="degraded")
+
+
+def deadleave_inference_pipeline(models_dict: dict) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    groundtruth = generate_deadleave()
+    groundtruth = downsample(groundtruth)
+    model = model_selector(models_dict)
+    degraded = degrade_blur_gaussian(groundtruth)
+    degraded = degrade_noise(degraded)
+    restored = infer(degraded, model)
+    crop_selector(restored)
+    groundtruth, degraded, restored = crop(groundtruth, degraded, restored)
+    configure_metrics()
+    get_metrics_restored(restored, groundtruth)
+    get_metrics_degraded(degraded, groundtruth)
+    return groundtruth, degraded, restored
+
+
+CANVAS_DICT = {
+    "demo": [["degraded", "restored"]],
+    "landscape_light": [["degraded", "restored", "groundtruth"]],
+    "landscape": [["degraded", "restored", "blur_kernel", "groundtruth"]],
+    "full": [["degraded", "restored"], ["blur_kernel", "groundtruth"]]
+}
+CANVAS = list(CANVAS_DICT.keys())
+
+
+def morph_canvas(canvas=CANVAS[0], global_params={}):
+    global_params["__pipeline"].outputs = CANVAS_DICT[canvas]
+    return None
+
+
+def natural_inference_pipeline(input_image_list: List[np.ndarray], models_dict: dict):
+    model = model_selector(models_dict)
+    img_clean = image_selector(input_image_list)
+    crop_selector(img_clean)
+    groundtruth = crop(img_clean)
+    blur_kernel = get_blur_kernel()
+    degraded = degrade_blur(groundtruth, blur_kernel)
+    degraded = degrade_noise(degraded)
+    blur_kernel = rescale_thumbnail(blur_kernel)
+    restored = infer(degraded, model)
+    configure_metrics()
+    get_metrics_restored(restored, groundtruth)
+    get_metrics_degraded(degraded, groundtruth)
+    morph_canvas()
+    return [[degraded, restored], [blur_kernel, groundtruth]]
diff --git a/src/rstor/analyzis/metrics_plots.py b/src/rstor/analyzis/metrics_plots.py
new file mode 100644
index 0000000000000000000000000000000000000000..95a2a364d596568d4798aef26817f5f13ecab311
--- /dev/null
+++ b/src/rstor/analyzis/metrics_plots.py
@@ -0,0 +1,73 @@
+import json
+import matplotlib.pyplot as plt
+import numpy as np
+from pathlib import Path
+import pandas as pd
+
+
+def snr_to_sigma(snr):
+    return 10**(-snr/20.)*255.
+
+
+def sigma_to_snr(sigma):
+    return -20.*np.log10(sigma/255.)
+
+
+def plot_results(selected_paths, title=None, diff=True, ylim=None):
+    # plt.figure(figsize=(10, 10))
+    all_stats = {}
+    fig, ax = plt.subplots(layout='constrained', figsize=(10, 10))
+    for selected_path, selected_regex in selected_paths:
+        selected_path = Path(selected_path)
+        assert selected_path.exists()
+        results_path = sorted(list(selected_path.glob(selected_regex)))
+        stats = []
+        for result_path in results_path:
+            df = pd.read_csv(result_path)
+            in_psnr = df["in_PSNR"].mean()
+            out_psnr = df["out_PSNR"].mean()
+            out_ssim = df["out_SSIM"].mean()
+            noise_stddev = np.array([
+                float(el.replace("}", "").split(":")[1]) for el in df["degradation"]]).mean()
+            stats.append({
+                # "label": label,
+                "in_psnr": in_psnr,
+                "out_psnr": out_psnr,
+                "noise_stddev": noise_stddev,
+                "ssim": out_ssim
+            })
+            label = selected_path.name + " " + df["size"][0]
+        
+        stats_array = pd.DataFrame(stats)
+        all_stats[label] = stats_array
+        x_data = stats_array["in_psnr"].copy()
+        x_data = snr_to_sigma(x_data)
+
+        ax.plot(
+            x_data,
+            stats_array["out_psnr"]-stats_array["in_psnr"] if diff else stats_array["out_psnr"],
+            "-o",
+            label=label
+        )
+        # label=selected_path.name)
+    if not diff:
+        neutral_sigma = np.linspace(1, 80, 80)
+        ax.plot(neutral_sigma, sigma_to_snr(neutral_sigma), "k--", alpha=0.1, label="Neutral")
+    secax = ax.secondary_xaxis('top', functions=(sigma_to_snr, snr_to_sigma))
+    secax.set_xlabel('PSNR [db]')
+
+    ax.set_xlabel("sigma 255")
+    ax.set_ylabel("PSNR improvement" if diff else "PSNR out")
+    plt.xlim(1., 50.)
+    if diff:
+        plt.ylim(0, 15)
+    else:
+        if ylim is not None:
+            plt.ylim(*ylim)
+    if title is not None:
+        plt.title(title)
+    plt.legend()
+    plt.grid()
+    plt.show()
+
+    return all_stats
diff --git a/src/rstor/analyzis/parser.py b/src/rstor/analyzis/parser.py
new file mode 100644
index 0000000000000000000000000000000000000000..86cc868822bc7576333148cd1947b49d58f5122d
--- /dev/null
+++ b/src/rstor/analyzis/parser.py
@@ -0,0 +1,26 @@
+from rstor.analyzis.interactive.model_selection import MODELS_PATH
+import argparse
+
+
+def get_models_parser(parser: argparse.ArgumentParser = None, help: str = "Inference",
+                      default_models_path: str = MODELS_PATH) -> argparse.ArgumentParser:
+    if parser is None:
+        parser = argparse.ArgumentParser(description=help)
+    parser.add_argument("-e", "--experiments", type=int, nargs="+", required=True,
+                        help="Experience indexes to be used at inference time")
+    parser.add_argument("-m", "--models-storage", type=str, help="Model storage path", default=default_models_path)
+    return parser
+
+
+def get_parser(
+    parser: argparse.ArgumentParser = None,
+    help: str = "Live inference pipeline"
+) -> argparse.ArgumentParser:
+    """Generic parser for live interactive inference
+    """
+    if parser is None:
+        parser = argparse.ArgumentParser(description=help)
+    get_models_parser(parser=parser, help=help)
+    parser.add_argument("-k", "--keyboard", action="store_true", help="Keyboard control - less sliders")
+    parser.add_argument("-b", "--backend", default="gradio", help="Backend to use for the GUI", choices=["gradio", "qt"])
+    return parser
diff --git a/src/rstor/architecture/base.py b/src/rstor/architecture/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa33fde196343450fe5508bd139be90f5b0add73
--- /dev/null
+++ b/src/rstor/architecture/base.py
@@ -0,0 +1,56 @@
+import torch
+from rstor.properties import LEAKY_RELU, RELU, SIMPLE_GATE
+from typing import Optional, Tuple
+
+
+class SimpleGate(torch.nn.Module):
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x1, x2 = x.chunk(2, dim=1)
+        return x1 * x2
+
+
+def get_non_linearity(activation: str):
+    if activation == LEAKY_RELU:
+        non_linearity = torch.nn.LeakyReLU()
+    elif activation == RELU:
+        non_linearity = torch.nn.ReLU()
+    elif activation is None:
+        non_linearity = torch.nn.Identity()
+    elif activation == SIMPLE_GATE:
+        non_linearity = SimpleGate()
+    else:
+        raise ValueError(f"Unknown activation {activation}")
+    return non_linearity
+
+
+class BaseModel(torch.nn.Module):
+    """Base class for all restoration models with additional useful methods"""
+
+    def count_parameters(self):
+        return sum(p.numel() for p in self.parameters() if p.requires_grad)
+
+    def receptive_field(
+        self,
+        channels: Optional[int] = 3,
+        size: Optional[int] = 256,
+        device: Optional[str] = None
+    ) -> Tuple[int, int]:
+        """Compute the receptive field of the model
+
+        Returns:
+            int: receptive field
+        """
+        input_tensor = torch.ones(1, channels, size, size, requires_grad=True)
+        if device is not None:
+            input_tensor = input_tensor.to(device)
+        out = self.forward(input_tensor)
+        grad = torch.zeros_like(out)
+        grad[..., out.shape[-2]//2, out.shape[-1]//2] = torch.nan  # set NaN gradient at the middle of the output
+        out.backward(gradient=grad)
+        self.zero_grad()
+        receptive_field_mask = input_tensor.grad.isnan()[0, 0]
+        receptive_field_indexes = torch.where(receptive_field_mask)
+        # Count NaN in the input
+        receptive_x = 1+receptive_field_indexes[-1].max() - receptive_field_indexes[-1].min()  # Horizontal x
+        receptive_y = 1+receptive_field_indexes[-2].max() - receptive_field_indexes[-2].min()  # Vertical y
+        return receptive_x.item(), receptive_y.item()
diff --git a/src/rstor/architecture/convolution_blocks.py b/src/rstor/architecture/convolution_blocks.py
new file mode 100644
index 0000000000000000000000000000000000000000..8db549f51d9f682ce873556c6339b47946bf90dd
--- /dev/null
+++ b/src/rstor/architecture/convolution_blocks.py
@@ -0,0 +1,47 @@
+import torch
+from rstor.properties import LEAKY_RELU
+from rstor.architecture.base import get_non_linearity
+
+
+class BaseConvolutionBlock(torch.nn.Module):
+    def __init__(
+        self,
+        ch_in: int,
+        ch_out: int,
+        k_size: int,
+        activation=LEAKY_RELU,
+        bias: bool = True
+    ) -> None:
+        super().__init__()
+        self.conv = torch.nn.Conv2d(ch_in, ch_out, k_size, padding=k_size//2, bias=bias)
+        self.non_linearity = get_non_linearity(activation)
+        self.conv_non_lin = torch.nn.Sequential(self.conv, self.non_linearity)
+
+    def forward(self, x_in: torch.Tensor) -> torch.Tensor:
+        return self.conv_non_lin(x_in)
+
+
+class ResConvolutionBlock(torch.nn.Module):
+    def __init__(
+        self,
+        ch_in: int,
+        ch_out: int,
+        k_size: int,
+        activation=LEAKY_RELU,
+        bias: bool = True,
+        residual: bool = True
+    ) -> None:
+        super().__init__()
+        self.conv1 = torch.nn.Conv2d(ch_in, ch_out, k_size, padding=k_size//2, bias=bias)
+        self.non_linearity = get_non_linearity(activation)
+        self.conv2 = torch.nn.Conv2d(ch_out, ch_out, k_size, padding=k_size//2, bias=bias)
+        self.residual = residual
+
+    def forward(self, x_in: torch.Tensor) -> torch.Tensor:
+        y = self.conv1(x_in)
+        y = self.non_linearity(y)
+        y = self.conv2(y)
+        if self.residual:
+            y = x_in + y
+        y = self.non_linearity(y)
+        return y
diff --git a/src/rstor/architecture/nafnet.py b/src/rstor/architecture/nafnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c0f79f987997f5112d3c6401358ac2c87735f88
--- /dev/null
+++ b/src/rstor/architecture/nafnet.py
@@ -0,0 +1,299 @@
+"""
+NAFNet: Non linear activation free neural network
+Architecture adapted from Simple Baselines for Image Restoration
+https://github.com/megvii-research/NAFNet/tree/main
+"""
+from torch import nn
+import torch.nn.functional as F
+import torch
+from rstor.architecture.base import BaseModel, get_non_linearity
+from typing import Optional, List
+from rstor.properties import RELU, SIMPLE_GATE
+
+
+class LayerNormFunction(torch.autograd.Function):
+
+    @staticmethod
+    def forward(ctx, x, weight, bias, eps):
+        ctx.eps = eps
+        N, C, H, W = x.size()
+        mu = x.mean(1, keepdim=True)
+        var = (x - mu).pow(2).mean(1, keepdim=True)
+        y = (x - mu) / (var + eps).sqrt()
+        ctx.save_for_backward(y, var, weight)
+        y = weight.view(1, C, 1, 1) * y + bias.view(1, C, 1, 1)
+        return y
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        eps = ctx.eps
+
+        N, C, H, W = grad_output.size()
+        y, var, weight = ctx.saved_variables
+        g = grad_output * weight.view(1, C, 1, 1)
+        mean_g = g.mean(dim=1, keepdim=True)
+
+        mean_gy = (g * y).mean(dim=1, keepdim=True)
+        gx = 1. / torch.sqrt(var + eps) * (g - y * mean_gy - mean_g)
+        return gx, (grad_output * y).sum(dim=3).sum(dim=2).sum(dim=0), grad_output.sum(dim=3).sum(dim=2).sum(
+            dim=0), None
+
+
+class LayerNorm2d(nn.Module):
+    def __init__(self, channels, eps=1e-6):
+        super(LayerNorm2d, self).__init__()
+        self.register_parameter('weight', nn.Parameter(torch.ones(channels)))
+        self.register_parameter('bias', nn.Parameter(torch.zeros(channels)))
+        self.eps = eps
+
+    def forward(self, x):
+        return LayerNormFunction.apply(x, self.weight, self.bias, self.eps)
+
+
+class NAFBlock(nn.Module):
+    def __init__(
+        self,
+        c, DW_Expand=2, FFN_Expand=2, drop_out_rate=0.,
+        activation: Optional[str] = SIMPLE_GATE,
+        layer_norm_flag: Optional[bool] = True,
+        channel_attention_flag: Optional[bool] = True,
+    ):
+        super().__init__()
+        self.layer_norm_flag = layer_norm_flag
+        self.channel_attention_flag = channel_attention_flag
+        dw_channel = c * DW_Expand
+        half_dw_channel = dw_channel // 2
+        self.conv1 = nn.Conv2d(in_channels=c, out_channels=dw_channel, kernel_size=1,
+                               padding=0, stride=1, groups=1, bias=True)
+        self.conv2 = nn.Conv2d(
+            in_channels=dw_channel,
+            out_channels=dw_channel if activation == SIMPLE_GATE else half_dw_channel,
+            kernel_size=3,
+            padding=1, stride=1,
+            groups=dw_channel if activation == SIMPLE_GATE else half_dw_channel,
+            bias=True
+        )
+        # To grand the same amount of parameters between Simple Gate and ReLU versions...
+        # Conv2 has to reduce the number of channels to half but... using grouped convolution
+        # w -> w/2 ... not really a depthwise convolution but rather by channels of 2!
+        self.conv3 = nn.Conv2d(in_channels=half_dw_channel, out_channels=c,
+                               kernel_size=1, padding=0, stride=1, groups=1, bias=True)
+
+        # Simplified Channel Attention
+        if self.channel_attention_flag:
+            self.sca = nn.Sequential(
+                nn.AdaptiveAvgPool2d(1),
+                nn.Conv2d(in_channels=half_dw_channel, out_channels=half_dw_channel, kernel_size=1,
+                          padding=0, stride=1,
+                          groups=1, bias=True),
+            )
+
+        # SimpleGate
+        self.sg = get_non_linearity(activation)
+        ffn_channel = FFN_Expand
+        half_ffn_channel = ffn_channel // 2 if activation == SIMPLE_GATE else ffn_channel
+        self.conv4 = nn.Conv2d(
+            in_channels=c,
+            out_channels=ffn_channel if activation == SIMPLE_GATE else half_ffn_channel,
+            kernel_size=1,
+            padding=0, stride=1, groups=1, bias=True)
+        self.conv5 = nn.Conv2d(in_channels=half_ffn_channel, out_channels=c,
+                               kernel_size=1, padding=0, stride=1, groups=1, bias=True)
+        if self.layer_norm_flag:
+            self.norm1 = LayerNorm2d(c)
+            self.norm2 = LayerNorm2d(c)
+
+        self.dropout1 = nn.Dropout(drop_out_rate) if drop_out_rate > 0. else nn.Identity()
+        self.dropout2 = nn.Dropout(drop_out_rate) if drop_out_rate > 0. else nn.Identity()
+
+        self.beta = nn.Parameter(torch.zeros((1, c, 1, 1)), requires_grad=True)
+        self.gamma = nn.Parameter(torch.zeros((1, c, 1, 1)), requires_grad=True)
+
+    def forward(self, inp):
+        x = inp
+        if self.layer_norm_flag:
+            x = self.norm1(x)
+
+        x = self.conv1(x)
+        x = self.conv2(x)
+        x = self.sg(x)
+        if self.channel_attention_flag:
+            x = x * self.sca(x)
+        x = self.conv3(x)
+
+        x = self.dropout1(x)
+
+        y = inp + x * self.beta
+
+        x = self.conv4(self.norm2(y) if self.layer_norm_flag else y)
+        x = self.sg(x)
+        x = self.conv5(x)
+
+        x = self.dropout2(x)
+
+        return y + x * self.gamma
+
+
+class NAFNet(BaseModel):
+    def __init__(
+            self,
+            img_channel: Optional[int] = 3,
+            width: Optional[int] = 16,
+            middle_blk_num: Optional[int] = 1,
+            enc_blk_nums: List[int] = [],
+            dec_blk_nums: List[int] = [],
+            activation: Optional[bool] = SIMPLE_GATE,
+            layer_norm_flag: Optional[bool] = True,
+            channel_attention_flag: Optional[bool] = True,
+    ) -> None:
+        super().__init__()
+
+        self.intro = nn.Conv2d(
+            in_channels=img_channel,
+            out_channels=width,
+            kernel_size=3,
+            padding=1, stride=1,
+            groups=1,
+            bias=True
+        )
+        config_block = {
+            "activation": activation,
+            "layer_norm_flag": layer_norm_flag,
+            "channel_attention_flag": channel_attention_flag
+        }
+        self.ending = nn.Conv2d(
+            in_channels=width, out_channels=img_channel, kernel_size=3,
+            padding=1, stride=1, groups=1,
+            bias=True)
+
+        self.encoders = nn.ModuleList()
+        self.decoders = nn.ModuleList()
+        self.middle_blks = nn.ModuleList()
+        self.ups = nn.ModuleList()
+        self.downs = nn.ModuleList()
+
+        chan = width
+        for num in enc_blk_nums:
+            self.encoders.append(
+                nn.Sequential(
+                    *[NAFBlock(chan, **config_block) for _ in range(num)]
+                )
+            )
+            self.downs.append(
+                nn.Conv2d(chan, 2*chan, 2, 2)
+            )
+            chan = chan * 2
+
+        self.middle_blks = \
+            nn.Sequential(
+                *[NAFBlock(chan, **config_block) for _ in range(middle_blk_num)]
+            )
+
+        for num in dec_blk_nums:
+            self.ups.append(
+                nn.Sequential(
+                    nn.Conv2d(chan, chan * 2, 1, bias=False),
+                    nn.PixelShuffle(2)
+                )
+            )
+            chan = chan // 2
+            self.decoders.append(
+                nn.Sequential(
+                    *[NAFBlock(chan, **config_block) for _ in range(num)]
+                )
+            )
+
+        self.padder_size = 2 ** len(self.encoders)
+
+    def forward(self, inp: torch.Tensor) -> torch.Tensor:
+        B, C, H, W = inp.shape
+        inp = self.sanitize_image_size(inp)
+
+        x = self.intro(inp)
+
+        encs = []
+
+        for encoder, down in zip(self.encoders, self.downs):
+            x = encoder(x)
+            encs.append(x)
+            x = down(x)
+
+        x = self.middle_blks(x)
+
+        for decoder, up, enc_skip in zip(self.decoders, self.ups, encs[::-1]):
+            x = up(x)
+            x = x + enc_skip
+            x = decoder(x)
+
+        x = self.ending(x)
+        x = x + inp
+
+        return x[:, :, :H, :W]
+
+    def sanitize_image_size(self, x: torch.Tensor) -> torch.Tensor:
+        _, _, h, w = x.size()
+        mod_pad_h = (self.padder_size - h % self.padder_size) % self.padder_size
+        mod_pad_w = (self.padder_size - w % self.padder_size) % self.padder_size
+        x = F.pad(x, (0, mod_pad_w, 0, mod_pad_h))
+        return x
+
+
+class UNet(NAFNet):
+    def __init__(
+            self,
+            activation: Optional[bool] = RELU,
+            layer_norm_flag: Optional[bool] = False,
+            channel_attention_flag: Optional[bool] = False,
+            **kwargs):
+        super().__init__(
+            activation=activation,
+            layer_norm_flag=layer_norm_flag,
+            channel_attention_flag=channel_attention_flag, **kwargs)
+
+
+if __name__ == '__main__':
+    tiny_recetive_field = True
+    if tiny_recetive_field:
+        enc_blks = [1, 1, 2]
+        middle_blk_num = 1
+        dec_blks = [1, 1, 1]
+        width = 16
+        # Receptive field is 208x208
+    else:
+        enc_blks = [1, 1, 1, 28]
+        middle_blk_num = 1
+        dec_blks = [1, 1, 1, 1]
+        width = 2
+        # Receptive field is 544x544
+    device = "cpu"
+
+    for model_name in ["NAFNet", "UNet"]:
+        if model_name == "NAFNet":
+            model = NAFNet(
+                img_channel=3,
+                width=width,
+                middle_blk_num=middle_blk_num,
+                enc_blk_nums=enc_blks,
+                dec_blk_nums=dec_blks,
+                activation=SIMPLE_GATE,
+                layer_norm_flag=False,
+                channel_attention_flag=False
+            )
+        if model_name == "UNet":
+            model = UNet(
+                img_channel=3,
+                width=width,
+                middle_blk_num=middle_blk_num,
+                enc_blk_nums=enc_blks,
+                dec_blk_nums=dec_blks
+            )
+        model.to(device)
+        with torch.no_grad():
+            x = torch.randn(1, 3, 256, 256).to(device)
+            y = model(x)
+
+            # print(y.shape)
+            # print(y)
+            # print(model)
+            print(f"{model.count_parameters()/1E3:.2f}k parameters")
+        print(model.receptive_field(size=256 if tiny_recetive_field else 1024, device=device))
diff --git a/src/rstor/architecture/selector.py b/src/rstor/architecture/selector.py
new file mode 100644
index 0000000000000000000000000000000000000000..108af16090ebddf004c0b3bb57d8630e5eec4c74
--- /dev/null
+++ b/src/rstor/architecture/selector.py
@@ -0,0 +1,19 @@
+from rstor.properties import MODEL, NAME, N_PARAMS, ARCHITECTURE
+from rstor.architecture.stacked_convolutions import StackedConvolutions
+from rstor.architecture.nafnet import NAFNet, UNet
+import torch
+
+
+def load_architecture(config: dict) -> torch.nn.Module:
+    conf_model = config[MODEL][ARCHITECTURE]
+    if config[MODEL][NAME] == StackedConvolutions.__name__:
+        model = StackedConvolutions(**conf_model)
+    elif config[MODEL][NAME] == NAFNet.__name__:
+        model = NAFNet(**conf_model)
+    elif config[MODEL][NAME] == UNet.__name__:
+        model = UNet(**conf_model)
+    else:
+        raise ValueError(f"Unknown model {config[MODEL][NAME]}")
+    config[MODEL][N_PARAMS] = model.count_parameters()
+    config[MODEL]["receptive_field"] = model.receptive_field()
+    return model
diff --git a/src/rstor/architecture/stacked_convolutions.py b/src/rstor/architecture/stacked_convolutions.py
new file mode 100644
index 0000000000000000000000000000000000000000..dbdec0ad4c1d79d4656266eb6538895edb0f2f06
--- /dev/null
+++ b/src/rstor/architecture/stacked_convolutions.py
@@ -0,0 +1,30 @@
+from rstor.architecture.base import BaseModel
+from rstor.architecture.convolution_blocks import BaseConvolutionBlock, ResConvolutionBlock
+from rstor.properties import LEAKY_RELU
+import torch
+
+
+class StackedConvolutions(BaseModel):
+    def __init__(self,
+                 ch_in: int = 3,
+                 ch_out: int = 3,
+                 h_dim: int = 64,
+                 num_layers: int = 8,
+                 k_size: int = 3,
+                 activation: str = LEAKY_RELU,
+                 bias: bool = True,
+                 ) -> None:
+        super().__init__()
+        assert num_layers % 2 == 0, "Number of layers should be even"
+        self.conv_in_modality = BaseConvolutionBlock(
+            ch_in, h_dim, k_size, activation=activation, bias=bias)
+        conv_list = []
+        for _i in range(num_layers-2):
+            conv_list.append(ResConvolutionBlock(
+                h_dim, h_dim, k_size, activation=activation, bias=bias, residual=True))
+        self.conv_out_modality = BaseConvolutionBlock(
+            h_dim, ch_out, k_size, activation=None, bias=bias)
+        self.conv_stack = torch.nn.Sequential(self.conv_in_modality, *conv_list, self.conv_out_modality)
+
+    def forward(self, x_in: torch.Tensor) -> torch.Tensor:
+        return self.conv_stack(x_in)
diff --git a/src/rstor/data/augmentation.py b/src/rstor/data/augmentation.py
new file mode 100644
index 0000000000000000000000000000000000000000..567dc2bd1ae6f03d5d07a0096f31c0934e28e618
--- /dev/null
+++ b/src/rstor/data/augmentation.py
@@ -0,0 +1,27 @@
+import torch
+from typing import Tuple, Optional
+
+
+def augment_flip(
+    img: torch.Tensor,
+    flip: Optional[Tuple[bool, bool]] = None
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Roll pixels horizontally to avoid negative index
+
+    Args:
+        img (torch.Tensor): [N, 3, H, W] image tensor
+        lab (torch.Tensor): [N, 3, H, W] label tensor
+        flip (Optional[bool], optional): forced flip_h, flip_v value. Defaults to None.
+        If not provided, a random flip_h, flip_v values are used
+    Returns:
+        torch.Tensor, torch.Tensor: flipped image, labels
+
+    """
+    if flip is None:
+        flip = torch.randint(0, 2, (2,))
+    flipped_img = img
+    if flip[0] > 0:
+        flipped_img = torch.flip(flipped_img, (-1,))
+    if flip[1] > 0:
+        flipped_img = torch.flip(flipped_img, (-2,))
+    return flipped_img
diff --git a/src/rstor/data/dataloader.py b/src/rstor/data/dataloader.py
new file mode 100644
index 0000000000000000000000000000000000000000..d987a7f547e362f06eabc92062456248fa6e9ca9
--- /dev/null
+++ b/src/rstor/data/dataloader.py
@@ -0,0 +1,120 @@
+from torch.utils.data import DataLoader
+from rstor.data.synthetic_dataloader import DeadLeavesDataset, DeadLeavesDatasetGPU
+from rstor.data.stored_images_dataloader import RestorationDataset
+from rstor.properties import (
+    DATALOADER, BATCH_SIZE, TRAIN, VALIDATION, LENGTH, CONFIG_DEAD_LEAVES, SIZE, NAME, CONFIG_DEGRADATION,
+    DATASET_SYNTH_LIST, DATASET_DIV2K,
+    DATASET_PATH
+)
+from typing import Optional
+from random import seed, shuffle
+
+
+def get_data_loader_synthetic(config, frozen_seed=42):
+    # print(config[DATALOADER].get(CONFIG_DEAD_LEAVES, {}))
+    if config[DATALOADER].get("gpu_gen", False):
+        print("Using GPU dead leaves generator")
+        ds = DeadLeavesDatasetGPU
+    else:
+        ds = DeadLeavesDataset
+    dl_train = ds(config[DATALOADER][SIZE], config[DATALOADER][LENGTH][TRAIN],
+                  frozen_seed=None, **config[DATALOADER].get(CONFIG_DEAD_LEAVES, {}))
+    dl_valid = ds(config[DATALOADER][SIZE], config[DATALOADER][LENGTH][VALIDATION],
+                  frozen_seed=frozen_seed, **config[DATALOADER].get(CONFIG_DEAD_LEAVES, {}))
+    dl_dict = create_dataloaders(config, dl_train, dl_valid)
+    return dl_dict
+
+
+def create_dataloaders(config, dl_train, dl_valid) -> dict:
+    dl_dict = {
+        TRAIN: DataLoader(
+            dl_train,
+            shuffle=True,
+            batch_size=config[DATALOADER][BATCH_SIZE][TRAIN],
+        ),
+        VALIDATION: DataLoader(
+            dl_valid,
+            shuffle=False,
+            batch_size=config[DATALOADER][BATCH_SIZE][VALIDATION]
+        ),
+        # TEST: DataLoader(dl_test, shuffle=False, batch_size=config[DATALOADER][BATCH_SIZE][TEST])
+    }
+    return dl_dict
+
+
+def get_data_loader_from_disk(config, frozen_seed: Optional[int] = 42) -> dict:
+    ds = RestorationDataset
+    dataset_name = config[DATALOADER][NAME]  # NAME shall be here!
+    if dataset_name == DATASET_DIV2K:
+        dataset_root = DATASET_PATH/DATASET_DIV2K
+        train_root = dataset_root/"DIV2K_train_HR"/"DIV2K_train_HR"
+        valid_root = dataset_root/"DIV2K_valid_HR"/"DIV2K_valid_HR"
+        train_files = sorted(list(train_root.glob("*.png")))
+        train_files = 5*train_files  # Just to get 4000 elements...
+        valid_files = sorted(list(valid_root.glob("*.png")))
+    elif dataset_name in DATASET_SYNTH_LIST:
+        dataset_root = DATASET_PATH/dataset_name
+        all_files = sorted(list(dataset_root.glob("*.png")))
+        seed(frozen_seed)
+        shuffle(all_files)  # Easy way to perform cross validation if neeeded
+        cut_index = int(0.9*len(all_files))
+        train_files = all_files[:cut_index]
+        valid_files = all_files[cut_index:]
+    dl_train = ds(
+        train_files,
+        size=config[DATALOADER][SIZE],
+        frozen_seed=None,
+        **config[DATALOADER].get(CONFIG_DEGRADATION, {})
+    )
+    dl_valid = ds(
+        valid_files,
+        size=config[DATALOADER][SIZE],
+        frozen_seed=frozen_seed,
+        **config[DATALOADER].get(CONFIG_DEGRADATION, {})
+    )
+    dl_dict = create_dataloaders(config, dl_train, dl_valid)
+    return dl_dict
+
+
+def get_data_loader(config, frozen_seed=42):
+    dataset_name = config[DATALOADER].get(NAME, False)
+    if dataset_name:
+        return get_data_loader_from_disk(config, frozen_seed)
+    else:
+        return get_data_loader_synthetic(config, frozen_seed)
+
+
+if __name__ == "__main__":
+    # Example of usage synthetic dataset
+    for dataset_name in [DATASET_DIV2K, None, DATASET_DL_DIV2K_512, DATASET_DL_DIV2K_1024]:
+        if dataset_name is None:
+            dead_leaves_dataset = DeadLeavesDatasetGPU(colored=True)
+            dl = DataLoader(dead_leaves_dataset, batch_size=4, shuffle=True)
+        else:
+            # Example of usage stored images dataset
+            config = {
+                DATALOADER: {
+                    NAME: dataset_name,
+                    SIZE: (128, 128),
+                    BATCH_SIZE: {
+                        TRAIN: 4,
+                        VALIDATION: 4
+                    },
+                }
+            }
+            dl_dict = get_data_loader(config)
+            dl = dl_dict[TRAIN]
+            # dl = dl_dict[VALIDATION]
+        for i, (batch_inp, batch_target) in enumerate(dl):
+            print(batch_inp.shape, batch_target.shape)  # Should print [batch_size, size[0], size[1], 3] for each batch
+            if i == 1:  # Just to break the loop after two batches for demonstration
+                import matplotlib.pyplot as plt
+                plt.subplot(1, 2, 1)
+                plt.imshow(batch_inp.permute(0, 2, 3, 1).reshape(-1, batch_inp.shape[-1], 3).cpu().numpy())
+                plt.title("Degraded")
+                plt.subplot(1, 2, 2)
+                plt.imshow(batch_target.permute(0, 2, 3, 1).reshape(-1, batch_inp.shape[-1], 3).cpu().numpy())
+                plt.title("Target")
+                plt.show()
+                # print(batch_target)
+                break
diff --git a/src/rstor/data/degradation.py b/src/rstor/data/degradation.py
new file mode 100644
index 0000000000000000000000000000000000000000..8d5ee00f493862ddb46e34904fa2bac6c1be0d8a
--- /dev/null
+++ b/src/rstor/data/degradation.py
@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Sun Mar 24 01:21:46 2024
+
+@author: jamyl
+"""
+import torch
+from rstor.properties import DATASET_BLUR_KERNEL_PATH
+import random
+from scipy.io import loadmat
+import cv2
+
+
+class Degradation():
+    def __init__(self,
+                 length: int = 1000,
+                 frozen_seed: int = None):
+        self.frozen_seed = frozen_seed
+        self.current_degradation = {}
+
+
+class DegradationNoise(Degradation):
+    def __init__(self,
+                 length: int = 1000,
+                 noise_stddev: float = [0., 50.],
+                 frozen_seed: int = None):
+        super().__init__(length, frozen_seed)
+        self.noise_stddev = noise_stddev
+
+        if frozen_seed is not None:
+            random.seed(frozen_seed)
+            self.noise_stddev = [(self.noise_stddev[1] - self.noise_stddev[0]) *
+                                 random.random() + self.noise_stddev[0] for _ in range(length)]
+
+    def __call__(self, x: torch.Tensor, idx: int):
+        # WARNING! INPLACE OPERATIONS!!!!!
+        # expects x of shape [b, c, h, w]
+        assert x.ndim == 4
+        assert x.shape[1] in [1, 3]
+
+        if self.frozen_seed is not None:
+            std_dev = self.noise_stddev[idx]
+        else:
+            std_dev = (self.noise_stddev[1] - self.noise_stddev[0]) * random.random() + self.noise_stddev[0]
+
+        if std_dev > 0.:
+            # x += (std_dev/255.)*np.random.randn(*x.shape)
+            x += (std_dev/255.)*torch.randn(*x.shape, device=x.device)
+        self.current_degradation[idx] = {
+            "noise_stddev": std_dev
+        }
+        return x
+
+
+class DegradationBlurMat(Degradation):
+    def __init__(self,
+                 length: int = 1000,
+                 frozen_seed: int = None,
+                 blur_index: int = None):
+        super().__init__(length, frozen_seed)
+
+        kernels = loadmat(DATASET_BLUR_KERNEL_PATH)["kernels"].squeeze()
+        # conversion to torch (the shape of the kernel is not constant)
+        self.kernels = tuple([
+            torch.from_numpy(kernel/kernel.sum(keepdims=True)).unsqueeze(0).unsqueeze(0)
+            for kernel in kernels] + [torch.ones((1, 1)).unsqueeze(0).unsqueeze(0)])
+        self.n_kernels = len(self.kernels)
+
+        if frozen_seed is not None:
+            random.seed(frozen_seed)
+            self.kernel_ids = [random.randint(0, self.n_kernels-1) for _ in range(length)]
+        if blur_index is not None:
+            self.frozen_seed = 42
+            self.kernel_ids = [blur_index for _ in range(length)]
+
+    def __call__(self, x: torch.Tensor, idx: int):
+        # expects x of shape [b, c, h, w]
+        assert x.ndim == 4
+        assert x.shape[1] in [1, 3]
+        device = x.device
+
+        if self.frozen_seed is not None:
+            kernel_id = self.kernel_ids[idx]
+        else:
+            kernel_id = random.randint(0, self.n_kernels-1)
+
+        kernel = self.kernels[kernel_id].to(device).repeat(3, 1, 1, 1).float()  # repeat for grouped conv
+        _, _, kh, kw = kernel.shape
+        # We use padding = same to make
+        # sure that the output size does not depend on the kernel.
+
+        # define nn.Conf layer to define both padding mode and padding value...
+        conv_layer = torch.nn.Conv2d(in_channels=x.shape[1],
+                                     out_channels=x.shape[1],
+                                     kernel_size=(kh, kw),
+                                     padding="same",
+                                     padding_mode='replicate',
+                                     groups=3,
+                                     bias=False)
+
+        # Set the predefined kernel as weights and freeze the parameters
+        with torch.no_grad():
+            conv_layer.weight = torch.nn.Parameter(kernel)
+            conv_layer.weight.requires_grad = False
+        # breakpoint()
+        x = conv_layer(x)
+        # Alternative Functional version with 0 padding :
+        # x = F.conv2d(x, kernel, padding="same", groups=3)
+
+        self.current_degradation[idx] = {
+            "blur_kernel_id": kernel_id
+        }
+        return x
+
+
+class DegradationBlurGauss(Degradation):
+    def __init__(self,
+                 length: int = 1000,
+                 blur_kernel_half_size: int = [0, 2],
+                 frozen_seed: int = None):
+        super().__init__(length, frozen_seed)
+
+        self.blur_kernel_half_size = blur_kernel_half_size
+        # conversion to torch (the shape of the kernel is not constant)
+        if frozen_seed is not None:
+            random.seed(self.frozen_seed)
+            self.blur_kernel_half_size = [
+                (
+                    random.randint(self.blur_kernel_half_size[0], self.blur_kernel_half_size[1]),
+                    random.randint(self.blur_kernel_half_size[0], self.blur_kernel_half_size[1])
+                ) for _ in range(length)
+            ]
+
+    def __call__(self, x: torch.Tensor, idx: int):
+        # expects x of shape [b, c, h, w]
+        assert x.ndim == 4
+        assert x.shape[1] in [1, 3]
+        device = x.device
+
+        if self.frozen_seed is not None:
+            k_size_x, k_size_y = self.blur_kernel_half_size[idx]
+        else:
+            k_size_x = random.randint(self.blur_kernel_half_size[0], self.blur_kernel_half_size[1])
+            k_size_y = random.randint(self.blur_kernel_half_size[0], self.blur_kernel_half_size[1])
+
+        k_size_x = 2 * k_size_x + 1
+        k_size_y = 2 * k_size_y + 1
+
+        x = x.squeeze(0).permute(1, 2, 0).cpu().numpy()
+        x = cv2.GaussianBlur(x, (k_size_x, k_size_y), 0)
+        x = torch.from_numpy(x).to(device).permute(2, 0, 1).unsqueeze(0)
+
+        self.current_degradation[idx] = {
+            "blur_kernel_half_size": (k_size_x, k_size_y),
+        }
+        return x
diff --git a/src/rstor/data/stored_images_dataloader.py b/src/rstor/data/stored_images_dataloader.py
new file mode 100644
index 0000000000000000000000000000000000000000..6726026acfd48077c23ccfc47b51172ac08c86da
--- /dev/null
+++ b/src/rstor/data/stored_images_dataloader.py
@@ -0,0 +1,156 @@
+import torch
+from torch.utils.data import DataLoader, Dataset
+from rstor.data.augmentation import augment_flip
+from rstor.data.degradation import DegradationBlurMat, DegradationBlurGauss, DegradationNoise
+from rstor.properties import DEVICE, AUGMENTATION_FLIP, AUGMENTATION_ROTATE, DEGRADATION_BLUR_NONE, DEGRADATION_BLUR_MAT, DEGRADATION_BLUR_GAUSS
+from rstor.properties import DATALOADER, BATCH_SIZE, TRAIN, VALIDATION, LENGTH, CONFIG_DEAD_LEAVES, SIZE
+from typing import Tuple, Optional, Union
+from torchvision import transforms
+# from torchvision.transforms import RandomCrop
+from pathlib import Path
+from tqdm import tqdm
+from time import time
+from torchvision.io import read_image
+IMAGES_FOLDER = "images"
+
+
+def load_image(path):
+    return read_image(str(path))
+
+
+class RestorationDataset(Dataset):
+    def __init__(
+        self,
+        images_path: Path,
+        size: Tuple[int, int] = (128, 128),
+        device: str = DEVICE,
+        preloaded: bool = False,
+        augmentation_list: Optional[list] = [],
+        frozen_seed: int = None,  # useful for validation set!
+        blur_kernel_half_size: int = [0, 2],
+        noise_stddev: float = [0., 50.],
+        degradation_blur=DEGRADATION_BLUR_NONE,
+        blur_index=None,
+        **_extra_kwargs
+    ):
+        self.preloaded = preloaded
+        self.augmentation_list = augmentation_list
+        self.device = device
+        self.frozen_seed = frozen_seed
+        if not isinstance(images_path, list):
+            self.path_list = sorted(list(images_path.glob("*.png")))
+        else:
+            self.path_list = images_path
+
+        self.length = len(self.path_list)
+
+        self.n_samples = len(self.path_list)
+        # If we can preload everything in memory, we can do it
+        if preloaded:
+            self.data_list = [load_image(pth) for pth in tqdm(self.path_list)]
+        else:
+            self.data_list = self.path_list
+
+        # if AUGMENTATION_FLIP in self.augmentation_list:
+        #     img_data = augment_flip(img_data)
+        # img_data = self.cropper(img_data)
+        self.transforms = []
+
+        if self.frozen_seed is None:
+            if AUGMENTATION_FLIP in self.augmentation_list:
+                self.transforms.append(transforms.RandomHorizontalFlip(p=0.5))
+                self.transforms.append(transforms.RandomVerticalFlip(p=0.5))
+            if AUGMENTATION_ROTATE in self.augmentation_list:
+                self.transforms.append(transforms.RandomRotation(degrees=180))
+
+        crop = transforms.RandomCrop(size) if frozen_seed is None else transforms.CenterCrop(size)
+        self.transforms.append(crop)
+        self.transforms = transforms.Compose(self.transforms)
+
+        # self.cropper = RandomCrop(size=size)
+
+        self.degradation_blur_type = degradation_blur
+        if degradation_blur == DEGRADATION_BLUR_GAUSS:
+            self.degradation_blur = DegradationBlurGauss(self.length,
+                                                         blur_kernel_half_size,
+                                                         frozen_seed)
+            self.blur_deg_str = "blur_kernel_half_size"
+        elif degradation_blur == DEGRADATION_BLUR_MAT:
+            self.degradation_blur = DegradationBlurMat(self.length,
+                                                       frozen_seed,
+                                                       blur_index)
+            self.blur_deg_str = "blur_kernel_id"
+        elif degradation_blur == DEGRADATION_BLUR_NONE:
+            pass
+        else:
+            raise ValueError(f"Unknown degradation blur {degradation_blur}")
+
+        self.degradation_noise = DegradationNoise(self.length,
+                                                  noise_stddev,
+                                                  frozen_seed)
+        self.current_degradation = {}
+
+    def __getitem__(self, index: int) -> Tuple[torch.Tensor, Union[torch.Tensor, None]]:
+        """Access a specific image from dataset and augment
+
+        Args:
+            index (int): access index
+
+        Returns:
+            torch.Tensor: image tensor [C, H, W]
+        """
+        if self.preloaded:
+            img_data = self.data_list[index]
+        else:
+            img_data = load_image(self.data_list[index])
+        img_data = img_data.to(self.device)
+
+        # if AUGMENTATION_FLIP in self.augmentation_list:
+        #     img_data = augment_flip(img_data)
+        # img_data = self.cropper(img_data)
+
+        img_data = self.transforms(img_data)
+        img_data = img_data.float()/255.
+        degraded_img = img_data.clone().unsqueeze(0)
+
+        self.current_degradation[index] = {}
+        if self.degradation_blur_type != DEGRADATION_BLUR_NONE:
+            degraded_img = self.degradation_blur(degraded_img, index)
+            self.current_degradation[index][self.blur_deg_str] = self.degradation_blur.current_degradation[index][self.blur_deg_str]
+
+        degraded_img = self.degradation_noise(degraded_img, index)
+        self.current_degradation[index]["noise_stddev"] = self.degradation_noise.current_degradation[index]["noise_stddev"]
+
+        degraded_img = degraded_img.squeeze(0)
+        self.current_degradation[index] = {
+            "noise_stddev": self.degradation_noise.current_degradation[index]["noise_stddev"]
+        }
+        try:
+            self.current_degradation[index][self.blur_deg_str] = self.degradation_blur.current_degradation[index][self.blur_deg_str]
+        except KeyError:
+            pass
+
+        return degraded_img, img_data
+
+    def __len__(self):
+        return self.n_samples
+
+
+if __name__ == "__main__":
+    dataset_restoration = RestorationDataset(
+        Path("__dataset/div2k/DIV2K_train_HR/DIV2K_train_HR/"),
+        preloaded=True,
+    )
+    dataloader = DataLoader(
+        dataset_restoration,
+        batch_size=16,
+        shuffle=True
+    )
+    start = time()
+    total = 0
+    for batch in tqdm(dataloader):
+        # print(batch.shape)
+        torch.cuda.synchronize()
+        total += batch.shape[0]
+    end = time()
+    print(f"Time elapsed: {(end-start)/total*1000.:.2f}ms/image")
diff --git a/src/rstor/data/synthetic_dataloader.py b/src/rstor/data/synthetic_dataloader.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac2bc128e8652ae042a697c9709dae3c5f6600a8
--- /dev/null
+++ b/src/rstor/data/synthetic_dataloader.py
@@ -0,0 +1,187 @@
+
+import torch
+import torch.nn.functional as F
+from torch.utils.data import Dataset
+from typing import Tuple
+from rstor.data.degradation import DegradationBlurMat, DegradationBlurGauss, DegradationNoise
+from rstor.properties import DEVICE, AUGMENTATION_FLIP, DEGRADATION_BLUR_NONE, DEGRADATION_BLUR_MAT, DEGRADATION_BLUR_GAUSS
+from rstor.synthetic_data.dead_leaves_cpu import cpu_dead_leaves_chart
+from rstor.synthetic_data.dead_leaves_gpu import gpu_dead_leaves_chart
+import cv2
+from skimage.filters import gaussian
+import random
+import numpy as np
+
+from rstor.utils import DEFAULT_TORCH_FLOAT_TYPE
+
+
+class DeadLeavesDataset(Dataset):
+    def __init__(
+        self,
+        size: Tuple[int, int] = (128, 128),
+        length: int = 1000,
+        frozen_seed: int = None,  # useful for validation set!
+        blur_kernel_half_size: int = [0, 2],
+        ds_factor: int = 5,
+        noise_stddev: float = [0., 50.],
+        degradation_blur=DEGRADATION_BLUR_NONE,
+        **config_dead_leaves
+        # number_of_circles: int = -1,
+        # background_color: Optional[Tuple[float, float, float]] = (0.5, 0.5, 0.5),
+        # colored: Optional[bool] = False,
+        # radius_mean: Optional[int] = -1,
+        # radius_stddev: Optional[int] = -1,
+    ):
+
+        self.frozen_seed = frozen_seed
+        self.ds_factor = ds_factor
+        self.size = (size[0]*ds_factor, size[1]*ds_factor)
+        self.length = length
+        self.config_dead_leaves = config_dead_leaves
+        self.blur_kernel_half_size = blur_kernel_half_size
+        self.noise_stddev = noise_stddev
+        
+
+        self.degradation_blur_type = degradation_blur
+        if degradation_blur == DEGRADATION_BLUR_GAUSS:
+            self.degradation_blur = DegradationBlurGauss(self.length,
+                                                         blur_kernel_half_size,
+                                                         frozen_seed)
+            self.blur_deg_str = "blur_kernel_half_size"
+        elif degradation_blur == DEGRADATION_BLUR_MAT:
+            self.degradation_blur = DegradationBlurMat(self.length,
+                                                       frozen_seed)
+            self.blur_deg_str = "blur_kernel_id"
+        elif degradation_blur == DEGRADATION_BLUR_NONE:
+            pass
+        else:
+            raise ValueError(f"Unknown degradation blur {degradation_blur}")
+            
+        self.degradation_noise = DegradationNoise(self.length,
+                                                  noise_stddev,
+                                                  frozen_seed)
+        self.current_degradation = {}
+
+    def __len__(self):
+        return self.length
+
+    def __getitem__(self, idx: int) -> Tuple[torch.Tensor, torch.Tensor]:
+        # TODO there is a bug on this cpu version, the dead leaved dont appear ot be right
+        seed = self.frozen_seed + idx if self.frozen_seed is not None else None
+        chart = cpu_dead_leaves_chart(self.size, seed=seed, **self.config_dead_leaves)
+
+        if self.ds_factor > 1:
+            # print(f"Downsampling {chart.shape} with factor {self.ds_factor}...")
+            sigma = 3/5
+            chart = gaussian(
+                chart, sigma=(sigma, sigma, 0), mode='nearest',
+                cval=0, preserve_range=True, truncate=4.0)
+            chart = chart[::self.ds_factor, ::self.ds_factor]
+
+        th_chart = torch.from_numpy(chart).permute(2, 0, 1).unsqueeze(0)
+        degraded_chart = th_chart
+
+        self.current_degradation[idx] = {}
+        if self.degradation_blur_type != DEGRADATION_BLUR_NONE:
+            degraded_chart = self.degradation_blur(degraded_chart, idx)
+            self.current_degradation[idx][self.blur_deg_str] = self.degradation_blur.current_degradation[idx][self.blur_deg_str]
+        
+        degraded_chart = self.degradation_noise(degraded_chart, idx)
+        self.current_degradation[idx]["noise_stddev"] = self.degradation_noise.current_degradation[idx]["noise_stddev"]
+        
+        degraded_chart = degraded_chart.squeeze(0)
+        th_chart = th_chart.squeeze(0)
+
+        return degraded_chart, th_chart
+
+
+class DeadLeavesDatasetGPU(Dataset):
+    def __init__(
+        self,
+        size: Tuple[int, int] = (128, 128),
+        length: int = 1000,
+        frozen_seed: int = None,  # useful for validation set!
+        blur_kernel_half_size: int = [0, 2],
+        ds_factor: int = 5,
+        noise_stddev: float = [0., 50.],
+        use_gaussian_kernel=True,
+        **config_dead_leaves
+        # number_of_circles: int = -1,
+        # background_color: Optional[Tuple[float, float, float]] = (0.5, 0.5, 0.5),
+        # colored: Optional[bool] = False,
+        # radius_mean: Optional[int] = -1,
+        # radius_stddev: Optional[int] = -1,
+    ):
+        self.frozen_seed = frozen_seed
+        self.ds_factor = ds_factor
+        self.size = (size[0]*ds_factor, size[1]*ds_factor)
+        self.length = length
+        self.config_dead_leaves = config_dead_leaves
+
+        # downsample kernel
+        sigma = 3/5
+        k_size = 5  # This fits with sigma = 3/5, the cutoff value is 0.0038 (neglectable)
+        x = (torch.arange(k_size) - 2).to('cuda')
+        kernel = torch.stack(torch.meshgrid((x, x), indexing='ij'))
+        kernel.requires_grad = False
+        dist_sq = kernel[0]**2 + kernel[1]**2
+        kernel = (-dist_sq.square()/(2*sigma**2)).exp()
+        kernel = kernel / kernel.sum()
+        self.downsample_kernel = kernel.repeat(3, 1, 1, 1)  # shape [3, 1, k_size, k_size]
+        self.downsample_kernel.requires_grad = False
+        self.use_gaussian_kernel = use_gaussian_kernel
+        if use_gaussian_kernel:
+            self.degradation_blur = DegradationBlurGauss(length,
+                                                         blur_kernel_half_size,
+                                                         frozen_seed)
+        else:
+            self.degradation_blur = DegradationBlurMat(length,
+                                                       frozen_seed)
+
+        self.degradation_noise = DegradationNoise(length,
+                                                  noise_stddev,
+                                                  frozen_seed)
+        self.current_degradation = {}
+
+    def __len__(self) -> int:
+        return self.length
+
+    def __getitem__(self, idx: int) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Get a single deadleave chart and its degraded version.
+
+        Args:
+            idx (int): index of the item to retrieve
+
+        Returns:
+            Tuple[torch.Tensor, torch.Tensor]: degraded chart, target chart
+        """
+        seed = self.frozen_seed + idx if self.frozen_seed is not None else None
+
+        # Return numba device array
+        numba_chart = gpu_dead_leaves_chart(self.size, seed=seed, **self.config_dead_leaves)
+        th_chart = torch.as_tensor(numba_chart, dtype=DEFAULT_TORCH_FLOAT_TYPE, device="cuda")[
+            None].permute(0, 3, 1, 2)  # [1, c, h, w]
+        if self.ds_factor > 1:
+            # Downsample using strided gaussian conv (sigma=3/5)
+            th_chart = F.pad(th_chart,
+                             pad=(2, 2, 0, 0),
+                             mode="replicate")
+            th_chart = F.conv2d(th_chart,
+                                self.downsample_kernel,
+                                padding='valid',
+                                groups=3,
+                                stride=self.ds_factor)
+
+        degraded_chart = self.degradation_blur(th_chart, idx)
+        degraded_chart = self.degradation_noise(degraded_chart, idx)
+
+        blur_deg_str = "blur_kernel_half_size" if self.use_gaussian_kernel else "blur_kernel_id"
+        self.current_degradation[idx] = {
+            blur_deg_str: self.degradation_blur.current_degradation[idx][blur_deg_str],
+            "noise_stddev": self.degradation_noise.current_degradation[idx]["noise_stddev"]
+        }
+
+        degraded_chart = degraded_chart.squeeze(0)
+        th_chart = th_chart.squeeze(0)
+
+        return degraded_chart, th_chart
diff --git a/src/rstor/learning/experiments.py b/src/rstor/learning/experiments.py
new file mode 100644
index 0000000000000000000000000000000000000000..5131a7fa78cbe3015211d8f48d1eb3d2ea4dd597
--- /dev/null
+++ b/src/rstor/learning/experiments.py
@@ -0,0 +1,24 @@
+from rstor.properties import DEVICE, OPTIMIZER, PARAMS
+from rstor.architecture.selector import load_architecture
+from rstor.data.dataloader import get_data_loader
+from typing import Tuple
+import torch
+
+
+def get_training_content(
+        config: dict,
+        training_mode: bool = False,
+        device=DEVICE) -> Tuple[torch.nn.Module, torch.optim.Optimizer, dict]:
+    model = load_architecture(config)
+    optimizer, dl_dict = None, None
+    if training_mode:
+        optimizer = torch.optim.Adam(model.parameters(), **config[OPTIMIZER][PARAMS])
+        dl_dict = get_data_loader(config)
+    return model, optimizer, dl_dict
+
+
+if __name__ == "__main__":
+    from rstor.learning.experiments_definition import default_experiment
+    config = default_experiment(1)
+    model, optimizer, dl_dict = get_training_content(config, training_mode=True)
+    print(config)
diff --git a/src/rstor/learning/experiments_definition.py b/src/rstor/learning/experiments_definition.py
new file mode 100644
index 0000000000000000000000000000000000000000..38245029236515c9c4c95cef5f2c797f76e9d012
--- /dev/null
+++ b/src/rstor/learning/experiments_definition.py
@@ -0,0 +1,489 @@
+from rstor.properties import (NB_EPOCHS, DATALOADER, BATCH_SIZE, SIZE, LENGTH,
+                              TRAIN, VALIDATION, SCHEDULER, REDUCELRONPLATEAU,
+                              MODEL, ARCHITECTURE, ID, NAME, SCHEDULER_CONFIGURATION, OPTIMIZER, PARAMS, LR,
+                              LOSS, LOSS_MSE, CONFIG_DEAD_LEAVES,
+                              SELECTED_METRICS, METRIC_PSNR, METRIC_SSIM, METRIC_LPIPS,
+                              DATASET_DL_DIV2K_512, DATASET_DIV2K,
+                              CONFIG_DEGRADATION,
+                              PRETTY_NAME,
+                              DEGRADATION_BLUR_NONE, DEGRADATION_BLUR_MAT, DEGRADATION_BLUR_GAUSS,
+                              AUGMENTATION_FLIP, AUGMENTATION_ROTATE,
+                              DATASET_DL_EXTRAPRIMITIVES_DIV2K_512)
+
+
+from typing import Tuple
+
+
+def model_configurations(config, model_preset="StackedConvolutions", bias: bool = True) -> dict:
+    if model_preset == "StackedConvolutions":
+        config[MODEL] = {
+            ARCHITECTURE: dict(
+                num_layers=8,
+                k_size=3,
+                h_dim=16,
+                bias=bias
+            ),
+            NAME: "StackedConvolutions"
+        }
+    elif model_preset == "NAFNet" or model_preset == "UNet":
+        # https://github.com/megvii-research/NAFNet/blob/main/options/test/GoPro/NAFNet-width64.yml
+        config[MODEL] = {
+            ARCHITECTURE: dict(
+                width=64,
+                enc_blk_nums=[1, 1, 1, 28],
+                middle_blk_num=1,
+                dec_blk_nums=[1, 1, 1, 1],
+            ),
+            NAME: model_preset
+        }
+    else:
+        raise ValueError(f"Unknown model preset {model_preset}")
+
+
+def presets_experiments(
+    exp: int,
+    b: int = 32,
+    n: int = 50,
+    bias: bool = True,
+    length: int = 5000,
+    data_size: Tuple[int, int] = (128, 128),
+    model_preset: str = "StackedConvolutions",
+    lpips: bool = False
+) -> dict:
+    config = {
+        ID: exp,
+        NAME: f"{exp:04d}",
+        NB_EPOCHS: n
+    }
+    config[DATALOADER] = {
+        BATCH_SIZE: {
+            TRAIN: b,
+            VALIDATION: b
+        },
+        SIZE: data_size,  # (width, height)
+        LENGTH: {
+            TRAIN: length,
+            VALIDATION: 800
+        }
+    }
+    config[OPTIMIZER] = {
+        NAME: "Adam",
+        PARAMS: {
+            LR: 1e-3
+        }
+    }
+    model_configurations(config, model_preset=model_preset, bias=bias)
+    config[SCHEDULER] = REDUCELRONPLATEAU
+    config[SCHEDULER_CONFIGURATION] = {
+        "factor": 0.8,
+        "patience": 5
+    }
+    config[LOSS] = LOSS_MSE
+    config[SELECTED_METRICS] = [METRIC_PSNR, METRIC_SSIM]
+    if lpips:
+        config[SELECTED_METRICS].append(METRIC_LPIPS)
+    return config
+
+
+def get_experiment_config(exp: int) -> dict:
+    if exp == -1:
+        config = presets_experiments(exp, length=10, n=2)
+    elif exp == -2:
+        config = presets_experiments(exp, length=10, n=2, lpips=True)
+    elif exp == -3:
+        config = presets_experiments(exp, n=20)
+        config[DATALOADER]["gpu_gen"] = True
+        config[DATALOADER][CONFIG_DEAD_LEAVES] = dict(
+            blur_kernel_half_size=[0, 0],
+            ds_factor=1,
+            noise_stddev=[0., 50.]
+        )
+        config[PRETTY_NAME] = "Vanilla denoise only - ds=1 - noisy 0-50"
+    elif exp == -4:
+        config = presets_experiments(exp, b=4, n=20)
+        config[DATALOADER][NAME] = DATASET_DL_DIV2K_512
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(
+            noise_stddev=[0., 50.]
+        )
+        config[PRETTY_NAME] = "Vanilla exp from disk - noisy 0-50"
+    elif exp == 1000:
+        config = presets_experiments(exp, n=60)
+        config[PRETTY_NAME] = "Vanilla small blur"
+        config[DATALOADER][CONFIG_DEAD_LEAVES] = dict(blur_kernel_half_size=[0, 2], ds_factor=1, noise_stddev=[0., 0.])
+    elif exp == 1001:
+        config = presets_experiments(exp, n=60)
+        config[DATALOADER][CONFIG_DEAD_LEAVES] = dict(blur_kernel_half_size=[0, 6], ds_factor=1, noise_stddev=[0., 0.])
+        config[PRETTY_NAME] = "Vanilla large blur 0 - 6"
+    elif exp == 1002:
+        config = presets_experiments(exp, n=6)  # Less epochs because of the large downsample factor
+        config[DATALOADER][CONFIG_DEAD_LEAVES] = dict(blur_kernel_half_size=[0, 2], ds_factor=5, noise_stddev=[0., 0.])
+        config[PRETTY_NAME] = "Vanilla small blur - ds=5"
+    elif exp == 1003:
+        config = presets_experiments(exp, n=6)  # Less epochs because of the large downsample factor
+        config[DATALOADER][CONFIG_DEAD_LEAVES] = dict(blur_kernel_half_size=[0, 2], ds_factor=5, noise_stddev=[0., 50.])
+        config[PRETTY_NAME] = "Vanilla small blur - ds=5 - noisy 0-50"
+    elif exp == 1004:
+        config = presets_experiments(exp, n=60)
+        config[DATALOADER][CONFIG_DEAD_LEAVES] = dict(blur_kernel_half_size=[0, 0], ds_factor=1, noise_stddev=[0., 50.])
+        config[PRETTY_NAME] = "Vanilla denoise only - ds=1 - noisy 0-50"
+    elif exp == 1005:
+        config = presets_experiments(exp, bias=False, n=60)
+        config[DATALOADER][CONFIG_DEAD_LEAVES] = dict(blur_kernel_half_size=[0, 0], ds_factor=1, noise_stddev=[0., 50.])
+        config[PRETTY_NAME] = "Vanilla denoise only - ds=1 - noisy 0-50 - bias free"
+    elif exp == 1006:
+        config = presets_experiments(exp, n=60)
+        config[PRETTY_NAME] = "Vanilla small blur - noisy 0-50"
+        config[DATALOADER][CONFIG_DEAD_LEAVES] = dict(blur_kernel_half_size=[0, 2], ds_factor=1, noise_stddev=[0., 50.])
+    elif exp == 1007:
+        config = presets_experiments(exp, n=60)
+        config[PRETTY_NAME] = "Vanilla large blur 0 - 6 - noisy 0-50"
+        config[DATALOADER][CONFIG_DEAD_LEAVES] = dict(blur_kernel_half_size=[0, 6], ds_factor=1, noise_stddev=[0., 50.])
+    elif exp == 2000:
+        config = presets_experiments(exp, n=60,  b=16, model_preset="NAFNet")
+        config[PRETTY_NAME] = "NAFNet denoise 0-50"
+        config[DATALOADER][CONFIG_DEAD_LEAVES] = dict(
+            blur_kernel_half_size=[0, 0],
+            ds_factor=1,
+            noise_stddev=[0., 50.]
+        )
+    elif exp == 2001:
+        config = presets_experiments(exp, n=60,  b=16, model_preset="UNet")
+        config[PRETTY_NAME] = "UNEt denoise 0-50"
+        config[DATALOADER][CONFIG_DEAD_LEAVES] = dict(
+            blur_kernel_half_size=[0, 0],
+            ds_factor=1,
+            noise_stddev=[0., 50.]
+        )
+    elif exp == 2002:
+        config = presets_experiments(exp, n=20,  b=8, data_size=(256, 256), model_preset="NAFNet")
+        config[PRETTY_NAME] = "NAFNet denoise  0-50 gpu dl 256x256"
+        config[DATALOADER]["gpu_gen"] = True
+        config[DATALOADER][CONFIG_DEAD_LEAVES] = dict(
+            blur_kernel_half_size=[0, 0],
+            ds_factor=1,
+            noise_stddev=[0., 50.]
+        )
+    elif exp == 2003:
+        config = presets_experiments(exp, n=20,  b=8, data_size=(128, 128), model_preset="NAFNet")
+        config[PRETTY_NAME] = "NAFNet denoise  0-50 gpu dl - 128x128"
+        config[DATALOADER]["gpu_gen"] = True
+        config[DATALOADER][CONFIG_DEAD_LEAVES] = dict(
+            blur_kernel_half_size=[0, 0],
+            ds_factor=1,
+            noise_stddev=[0., 50.]
+        )
+    elif exp == 2004:
+        config = presets_experiments(exp, n=20,  b=16, data_size=(128, 128), model_preset="NAFNet")
+        config[PRETTY_NAME] = "NAFNet Light denoise  0-50 gpu dl - 128x128"
+        config[DATALOADER]["gpu_gen"] = True
+        config[DATALOADER][CONFIG_DEAD_LEAVES] = dict(
+            blur_kernel_half_size=[0, 0],
+            ds_factor=1,
+            noise_stddev=[0., 50.]
+        )
+        config[MODEL][ARCHITECTURE] = dict(
+            width=64,
+            enc_blk_nums=[1, 1, 1, 2],
+            middle_blk_num=1,
+            dec_blk_nums=[1, 1, 1, 1],
+        )
+    elif exp == 2005:
+        config = presets_experiments(exp, n=20,  b=16, data_size=(128, 128), model_preset="NAFNet")
+        config[PRETTY_NAME] = "NAFNet TresLight denoise  0-50 gpu dl - 128x128"
+        config[DATALOADER]["gpu_gen"] = True
+        config[DATALOADER][CONFIG_DEAD_LEAVES] = dict(
+            blur_kernel_half_size=[0, 0],
+            ds_factor=1,
+            noise_stddev=[0., 50.]
+        )
+        config[MODEL][ARCHITECTURE] = dict(
+            width=64,
+            enc_blk_nums=[1, 1, 2],
+            middle_blk_num=1,
+            dec_blk_nums=[1, 1, 1],
+        )
+    elif exp == 2006:
+        config = presets_experiments(exp, n=20,  b=16, data_size=(128, 128), model_preset="NAFNet")
+        config[PRETTY_NAME] = "NAFNet TresLight denoise  0-50 ds=5 gpu dl - 128x128"
+        config[DATALOADER]["gpu_gen"] = True
+        config[DATALOADER][CONFIG_DEAD_LEAVES] = dict(
+            blur_kernel_half_size=[0, 0],
+            ds_factor=5,
+            noise_stddev=[0., 50.]
+        )
+        config[MODEL][ARCHITECTURE] = dict(
+            width=64,
+            enc_blk_nums=[1, 1, 2],
+            middle_blk_num=1,
+            dec_blk_nums=[1, 1, 1],
+        )
+    elif exp == 2007:
+        config = presets_experiments(exp, n=20,  b=16, data_size=(128, 128), model_preset="NAFNet")
+        config[PRETTY_NAME] = "NAFNet denoise  0-50 gpu dl -ds=5 128x128"
+        config[DATALOADER]["gpu_gen"] = True
+        config[DATALOADER][CONFIG_DEAD_LEAVES] = dict(
+            blur_kernel_half_size=[0, 0],
+            ds_factor=5,
+            noise_stddev=[0., 50.]
+        )
+    elif exp == 1008:
+        config = presets_experiments(exp, n=20)
+        config[DATALOADER]["gpu_gen"] = True
+        config[DATALOADER][CONFIG_DEAD_LEAVES] = dict(
+            blur_kernel_half_size=[0, 0],
+            ds_factor=5,
+            noise_stddev=[0., 50.]
+        )
+        config[PRETTY_NAME] = "Vanilla denoise only - ds=5 - noisy 0-50"
+    # ---------------------------------
+    # Pure DL DENOISING trainings!
+    # ---------------------------------
+    elif exp == 3000:
+        config = presets_experiments(exp, n=30,  b=4, model_preset="NAFNet")
+        config[PRETTY_NAME] = "NAFNet denoise - DL_DIV2K_512 0-50"
+        config[DATALOADER][NAME] = DATASET_DL_DIV2K_512
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(
+            noise_stddev=[0., 50.]
+        )
+        config[DATALOADER][SIZE] = (256, 256)
+    elif exp == 3001:  # ENABLE GRADIENT CLIPPING
+        config = presets_experiments(exp, n=30,  b=8, model_preset="NAFNet")
+        config[PRETTY_NAME] = "NAFNet41.4M denoise - DL_DIV2K_512 0-50 256x256"
+        config[DATALOADER][NAME] = DATASET_DL_DIV2K_512
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(
+            noise_stddev=[0., 50.]
+        )
+        config[DATALOADER][SIZE] = (256, 256)
+    elif exp == 3002:  # ENABLE GRADIENT CLIPPING
+        config = presets_experiments(exp, n=30,  b=16, model_preset="NAFNet")
+        config[PRETTY_NAME] = "NAFNet41.4M denoise - DL_DIV2K_512 0-50 128x128"
+        config[DATALOADER][NAME] = DATASET_DL_DIV2K_512
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(
+            noise_stddev=[0., 50.]
+        )
+        config[DATALOADER][SIZE] = (128, 128)
+    elif exp == 3010 or exp == 3011:  # exp 3011 = REDO with Gradient clipping
+        config = presets_experiments(exp, n=50,  b=4, model_preset="NAFNet")
+        config[PRETTY_NAME] = "NAFNet3.4M Light denoise - DL_DIV2K_512 0-50 256x256"
+        config[DATALOADER][NAME] = DATASET_DL_DIV2K_512
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(
+            noise_stddev=[0., 50.]
+        )
+        config[MODEL][ARCHITECTURE] = dict(
+            width=64,
+            enc_blk_nums=[1, 1, 2],
+            middle_blk_num=1,
+            dec_blk_nums=[1, 1, 1],
+        )
+        config[DATALOADER][SIZE] = (256, 256)
+    elif exp == 3020:
+        config = presets_experiments(exp, b=32, n=50)
+        config[DATALOADER][NAME] = DATASET_DL_DIV2K_512
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(
+            noise_stddev=[0., 50.]
+        )
+        config[PRETTY_NAME] = "Vanilla denoise DL  0-50 - noisy 0-50"
+    # ---------------------------------
+    # Pure DIV2K DENOISING trainings!
+    # ---------------------------------
+    elif exp == 3120:
+        config = presets_experiments(exp, b=32, n=50)
+        config[DATALOADER][NAME] = DATASET_DIV2K
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(
+            noise_stddev=[0., 50.]
+        )
+        config[PRETTY_NAME] = "Vanilla DIV2K_512 0-50 - noisy 0-50"
+    elif exp == 3111:
+        config = presets_experiments(exp, n=50,  b=4, model_preset="NAFNet")
+        config[PRETTY_NAME] = "NAFNet3.4M Light denoise - DIV2K_512 0-50 256x256"
+        config[DATALOADER][NAME] = DATASET_DIV2K
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(noise_stddev=[0., 50.])
+        config[MODEL][ARCHITECTURE] = dict(
+            width=64,
+            enc_blk_nums=[1, 1, 2],
+            middle_blk_num=1,
+            dec_blk_nums=[1, 1, 1],
+        )
+        config[DATALOADER][SIZE] = (256, 256)
+    elif exp == 3101:
+        config = presets_experiments(exp, n=30,  b=8, model_preset="NAFNet")
+        config[PRETTY_NAME] = "NAFNet41.4M denoise - DIV2K_512 0-50 256x256"
+        config[DATALOADER][NAME] = DATASET_DIV2K
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(
+            noise_stddev=[0., 50.]
+        )
+        config[DATALOADER][SIZE] = (256, 256)
+    # ---------------------------------
+    # Pure EXTRA PRIMITIVES
+    # ---------------------------------
+    elif exp == 3030:
+        config = presets_experiments(exp, b=128, n=50)
+        config[DATALOADER][NAME] = DATASET_DL_EXTRAPRIMITIVES_DIV2K_512
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(
+            noise_stddev=[0., 50.]
+        )
+        config[PRETTY_NAME] = "Vanilla DL_PRIMITIVES_512 0-50 - noisy 0-50"
+        # config[DATALOADER][SIZE] = (256, 256)
+    elif exp == 3040:
+        config = presets_experiments(exp, n=50,  b=8, model_preset="NAFNet")
+        config[PRETTY_NAME] = "NAFNet3.4M Light denoise - DL_PRIMITIVES_512 0-50 256x256"
+        config[DATALOADER][NAME] = DATASET_DL_EXTRAPRIMITIVES_DIV2K_512
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(noise_stddev=[0., 50.])
+        config[MODEL][ARCHITECTURE] = dict(
+            width=64,
+            enc_blk_nums=[1, 1, 2],
+            middle_blk_num=1,
+            dec_blk_nums=[1, 1, 1],
+        )
+        config[DATALOADER][SIZE] = (256, 256)
+    elif exp == 3050:
+        config = presets_experiments(exp, n=30,  b=8, model_preset="NAFNet")
+        config[PRETTY_NAME] = "NAFNet41.4M denoise - DL_PRIMITIVES_512 0-50 256x256"
+        config[DATALOADER][NAME] = DATASET_DL_EXTRAPRIMITIVES_DIV2K_512
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(noise_stddev=[0., 50.])
+        config[DATALOADER][SIZE] = (256, 256)
+    # ---------------------------------
+    # DEBLURRING
+    # ---------------------------------
+    elif exp == 5000:
+        config = presets_experiments(exp, n=30,  b=8, model_preset="NAFNet")
+        config[PRETTY_NAME] = "NAFNet deblur - DL_DIV2K_512 256x256"
+        config[DATALOADER][NAME] = DATASET_DL_DIV2K_512
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(
+            noise_stddev=[0., 0.],
+            degradation_blur=DEGRADATION_BLUR_MAT,  # Using .mat kernels
+            augmentation_list=[AUGMENTATION_FLIP]
+        )
+        config[DATALOADER][SIZE] = (256, 256)
+    elif exp == 5001:
+        config = presets_experiments(exp, n=30,  b=8, model_preset="NAFNet")
+        config[PRETTY_NAME] = "NAFNet deblur - DIV2K_512 256x256"
+        config[DATALOADER][NAME] = DATASET_DIV2K
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(
+            noise_stddev=[0., 0.],
+            degradation_blur=DEGRADATION_BLUR_MAT,  # Using .mat kernels
+            augmentation_list=[AUGMENTATION_FLIP]
+        )
+        config[DATALOADER][SIZE] = (256, 256)
+    elif exp == 5002:
+        config = presets_experiments(exp, n=30,  b=8, model_preset="NAFNet")
+        config[PRETTY_NAME] = "NAFNet deblur - DL_DIV2K_512 256x256"
+        config[DATALOADER][NAME] = DATASET_DL_DIV2K_512
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(
+            noise_stddev=[0., 0.],
+            degradation_blur=DEGRADATION_BLUR_MAT,  # Using .mat kernels
+            augmentation_list=[AUGMENTATION_FLIP]
+        )
+        config[DATALOADER][SIZE] = (256, 256)
+    elif exp == 5003:
+        config = presets_experiments(exp, n=30,  b=8, model_preset="NAFNet")
+        config[PRETTY_NAME] = "NAFNet deblur - DIV2K_512 256x256"
+        config[DATALOADER][NAME] = DATASET_DIV2K
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(
+            noise_stddev=[0., 0.],
+            degradation_blur=DEGRADATION_BLUR_MAT,  # Using .mat kernels
+            augmentation_list=[AUGMENTATION_FLIP]
+        )
+        config[DATALOADER][SIZE] = (256, 256)
+    elif exp == 5004:
+        config = presets_experiments(exp, n=30,  b=8, model_preset="NAFNet")
+        config[PRETTY_NAME] = "NAFNet deblur - DIV2K_512 256x256"
+        config[DATALOADER][NAME] = DATASET_DIV2K
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(
+            noise_stddev=[0., 0.],
+            degradation_blur=DEGRADATION_BLUR_MAT,  # Using .mat kernels
+            augmentation_list=[AUGMENTATION_FLIP]
+        )
+        config[DATALOADER][SIZE] = (256, 256)
+    elif exp == 5005:
+        config = presets_experiments(exp, n=30,  b=8, model_preset="UNet")
+        config[PRETTY_NAME] = "UNet deblur - DL_512 256x256"
+        config[DATALOADER][NAME] = DATASET_DL_DIV2K_512
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(
+            noise_stddev=[0., 0.],
+            degradation_blur=DEGRADATION_BLUR_MAT,  # Using .mat kernels
+            augmentation_list=[AUGMENTATION_FLIP]
+        )
+        config[DATALOADER][SIZE] = (256, 256)
+    # elif exp == 6000:  # -> FAILED, no kernels normalization!
+    #     config = presets_experiments(exp, b=32, n=50)
+    #     config[DATALOADER][NAME] = DATASET_DL_DIV2K_512
+    #     config[DATALOADER][CONFIG_DEGRADATION] = dict(
+    #         noise_stddev=[0., 50.],
+    #         degradation_blur=DEGRADATION_BLUR_MAT,  # Deblur = Using .mat kernels
+    #         augmentation_list=[AUGMENTATION_FLIP]
+    #     )
+    #     config[PRETTY_NAME] = "Vanilla deblur DL_DIV2K_512"
+    elif exp == 6002:
+        config = presets_experiments(exp, b=128, n=50)
+        config[DATALOADER][NAME] = DATASET_DL_DIV2K_512
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(
+            noise_stddev=[0., 50.],
+            degradation_blur=DEGRADATION_BLUR_MAT,  # Deblur = Using .mat kernels
+            augmentation_list=[AUGMENTATION_FLIP]
+        )
+        config[PRETTY_NAME] = "Vanilla deblur DL_DIV2K_512"
+    # elif exp == 6001:  # -> FAILED, no kernels normalization!
+    #     config = presets_experiments(exp, b=32, n=50)
+    #     config[DATALOADER][NAME] = DATASET_DIV2K
+    #     config[DATALOADER][CONFIG_DEGRADATION] = dict(
+    #         noise_stddev=[0., 50.],
+    #         degradation_blur=DEGRADATION_BLUR_MAT,  # Deblur = Using .mat kernels
+    #         augmentation_list=[AUGMENTATION_FLIP]
+    #     )
+    #     config[PRETTY_NAME] = "Vanilla delbur DIV2K_512"
+    elif exp == 6003:
+        config = presets_experiments(exp, b=128, n=50)
+        config[DATALOADER][NAME] = DATASET_DIV2K
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(
+            noise_stddev=[0., 50.],
+            degradation_blur=DEGRADATION_BLUR_MAT,  # Deblur = Using .mat kernels
+            augmentation_list=[AUGMENTATION_FLIP]
+        )
+        config[PRETTY_NAME] = "Vanilla delbur DIV2K_512"
+
+    elif exp == 7000:
+        config = presets_experiments(exp, b=16, n=30, model_preset="NAFNet")
+        config[MODEL][ARCHITECTURE] = dict(
+            width=64,
+            enc_blk_nums=[1, 1, 2],
+            middle_blk_num=1,
+            dec_blk_nums=[1, 1, 1],
+        )
+        config[DATALOADER][NAME] = DATASET_DL_DIV2K_512
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(
+            noise_stddev=[0., 50.],
+            degradation_blur=DEGRADATION_BLUR_MAT,  # Deblur = Using .mat kernels
+            augmentation_list=[AUGMENTATION_FLIP]
+        )
+        config[PRETTY_NAME] = "NafNet Light deblur DL"
+        config[DATALOADER][SIZE] = (256, 256)
+    elif exp == 7001:
+        config = presets_experiments(exp, b=16, n=50, model_preset="NAFNet")
+        config[DATALOADER][NAME] = DATASET_DIV2K
+        config[MODEL][ARCHITECTURE] = dict(
+            width=64,
+            enc_blk_nums=[1, 1, 2],
+            middle_blk_num=1,
+            dec_blk_nums=[1, 1, 1],
+        )
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(
+            noise_stddev=[0., 50.],
+            degradation_blur=DEGRADATION_BLUR_MAT,  # Deblur = Using .mat kernels
+            augmentation_list=[AUGMENTATION_FLIP]
+        )
+        config[PRETTY_NAME] = "NafNet Light deblur DIV2K"
+        config[DATALOADER][SIZE] = (256, 256)
+    elif exp == 7002:
+        config = presets_experiments(exp, n=20,  b=8, model_preset="UNet")
+        config[PRETTY_NAME] = "UNET deblur - DIV2K"
+        config[DATALOADER][NAME] = DATASET_DIV2K
+        config[DATALOADER][CONFIG_DEGRADATION] = dict(
+            noise_stddev=[0., 0.],
+            degradation_blur=DEGRADATION_BLUR_MAT,  # Using .mat kernels
+            augmentation_list=[AUGMENTATION_FLIP]
+        )
+        config[DATALOADER][SIZE] = (256, 256)
+    else:
+        raise ValueError(f"Experiment {exp} not found")
+    return config
diff --git a/src/rstor/learning/loss.py b/src/rstor/learning/loss.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc117930726324cddc8ec2c3d7961ff8858d4d1f
--- /dev/null
+++ b/src/rstor/learning/loss.py
@@ -0,0 +1,25 @@
+import torch
+from typing import Optional
+from rstor.properties import LOSS_MSE
+
+
+def compute_loss(
+    predic: torch.Tensor,
+    target: torch.Tensor,
+    mode: Optional[str] = LOSS_MSE
+) -> torch.Tensor:
+    """
+    Compute loss based on the predicted and true values.
+
+    Args:
+        predic (torch.Tensor): [N, C, H, W] predicted values
+        target (torch.Tensor): [N, C, H, W] target values.
+        mode (Optional[str], optional): mode of loss computation.
+
+    Returns:
+        torch.Tensor: The computed loss.
+    """
+    assert mode in [LOSS_MSE], f"Mode {mode} not supported"
+    if mode == LOSS_MSE:
+        loss = torch.nn.functional.mse_loss(predic, target)
+    return loss
diff --git a/src/rstor/learning/metrics.py b/src/rstor/learning/metrics.py
new file mode 100644
index 0000000000000000000000000000000000000000..eff481e46439457d64c24dd80c097b886ddde2e8
--- /dev/null
+++ b/src/rstor/learning/metrics.py
@@ -0,0 +1,140 @@
+import torch
+from rstor.properties import METRIC_PSNR, METRIC_SSIM, METRIC_LPIPS, REDUCTION_AVERAGE, REDUCTION_SKIP, REDUCTION_SUM
+from torchmetrics.image import StructuralSimilarityIndexMeasure as SSIM
+from torchmetrics.image.lpip import LearnedPerceptualImagePatchSimilarity
+from typing import List, Optional
+ALL_METRICS = [METRIC_PSNR, METRIC_SSIM, METRIC_LPIPS]
+
+
+def compute_psnr(
+    predic: torch.Tensor,
+    target: torch.Tensor,
+    clamp_mse=1e-10,
+    reduction: Optional[str] = REDUCTION_AVERAGE
+) -> torch.Tensor:
+    """
+    Compute the average PSNR metric for a batch of predicted and true values.
+
+    Args:
+        predic (torch.Tensor): [N, C, H, W] predicted values.
+        target (torch.Tensor): [N, C, H, W] target values.
+        reduction (str): Reduction method. REDUCTION_AVERAGE/REDUCTION_SKIP/REDUCTION_SUM.
+
+    Returns:
+        torch.Tensor: The average PSNR value for the batch.
+    """
+    with torch.no_grad():
+        mse_per_image = torch.mean((predic - target) ** 2, dim=(-3, -2, -1))
+        mse_per_image = torch.clamp(mse_per_image, min=clamp_mse)
+        psnr_per_image = 10 * torch.log10(1 / mse_per_image)
+        if reduction == REDUCTION_AVERAGE:
+            average_psnr = torch.mean(psnr_per_image)
+        elif reduction == REDUCTION_SUM:
+            average_psnr = torch.sum(psnr_per_image)
+        elif reduction == REDUCTION_SKIP:
+            average_psnr = psnr_per_image
+        else:
+            raise ValueError(f"Unknown reduction {reduction}")
+    return average_psnr
+
+
+def compute_ssim(
+    predic: torch.Tensor,
+    target: torch.Tensor,
+    reduction: Optional[str] = REDUCTION_AVERAGE
+) -> torch.Tensor:
+    """
+    Compute the average SSIM metric for a batch of predicted and true values.
+
+    Args:
+        predic (torch.Tensor): [N, C, H, W] predicted values.
+        target (torch.Tensor): [N, C, H, W] target values.
+        reduction (str): Reduction method. REDUCTION_AVERAGE/REDUCTION_SKIP.
+
+    Returns:
+        torch.Tensor: The average SSIM value for the batch.
+    """
+    with torch.no_grad():
+        reduction_mode = {
+            REDUCTION_SKIP: None,
+            REDUCTION_AVERAGE: "elementwise_mean",
+            REDUCTION_SUM: "sum"
+        }[reduction]
+        ssim = SSIM(data_range=1.0, reduction=reduction_mode).to(predic.device)
+        assert predic.shape == target.shape, f"{predic.shape} != {target.shape}"
+        assert predic.device == target.device, f"{predic.device} != {target.device}"
+        ssim_value = ssim(predic, target)
+    return ssim_value
+
+
+def compute_lpips(
+    predic: torch.Tensor,
+    target: torch.Tensor,
+    reduction: Optional[str] = REDUCTION_AVERAGE,
+) -> torch.Tensor:
+    """
+    Compute the average LPIPS metric for a batch of predicted and true values.
+    https://richzhang.github.io/PerceptualSimilarity/
+
+    Args:
+        predic (torch.Tensor): [N, C, H, W] predicted values.
+        target (torch.Tensor): [N, C, H, W] target values.
+        reduction (str): Reduction method. REDUCTION_AVERAGE/REDUCTION_SKIP.
+
+    Returns:
+        torch.Tensor: The average SSIM value for the batch.
+    """
+    reduction_mode = {
+        REDUCTION_SKIP:  "sum",  # does not really matter
+        REDUCTION_AVERAGE: "mean",
+        REDUCTION_SUM: "sum"
+    }[reduction]
+
+    with torch.no_grad():
+        lpip_metrics = LearnedPerceptualImagePatchSimilarity(
+            reduction=reduction_mode,
+            normalize=True  # If set to True will instead expect input to be in the [0,1] range.
+        ).to(predic.device)
+        assert predic.shape == target.shape, f"{predic.shape} != {target.shape}"
+        assert predic.device == target.device, f"{predic.device} != {target.device}"
+        if reduction == REDUCTION_SKIP:
+            lpip_value = []
+            for idx in range(predic.shape[0]):
+                lpip_value.append(lpip_metrics(
+                    predic[idx, ...].unsqueeze(0).clip(0, 1),
+                    target[idx, ...].unsqueeze(0).clip(0, 1)
+                ))
+            lpip_value = torch.stack(lpip_value)
+        elif reduction in [REDUCTION_SUM, REDUCTION_AVERAGE]:
+            lpip_value = lpip_metrics(predic.clip(0, 1), target.clip(0, 1))
+    return lpip_value
+
+
+def compute_metrics(
+        predic: torch.Tensor,
+        target: torch.Tensor,
+        reduction: Optional[str] = REDUCTION_AVERAGE,
+        chosen_metrics: Optional[List[str]] = ALL_METRICS) -> dict:
+    """
+    Compute the metrics for a batch of predicted and true values.
+
+    Args:
+        predic (torch.Tensor): [N, C, H, W] predicted values.
+        target (torch.Tensor): [N, C, H, W] target values.
+        reduction (str): Reduction method. REDUCTION_AVERAGE/REDUCTION_SKIP/REDUCTION SUM.
+        chosen_metrics (list): List of metrics to compute, default [METRIC_PSNR, METRIC_SSIM]
+
+    Returns:
+        dict: computed metrics.
+    """
+    metrics = {}
+    if METRIC_PSNR in chosen_metrics:
+        average_psnr = compute_psnr(predic, target, reduction=reduction)
+        metrics[METRIC_PSNR] = average_psnr.item() if reduction != REDUCTION_SKIP else average_psnr
+    if METRIC_SSIM in chosen_metrics:
+        ssim_value = compute_ssim(predic, target, reduction=reduction)
+        metrics[METRIC_SSIM] = ssim_value.item() if reduction != REDUCTION_SKIP else ssim_value
+    if METRIC_LPIPS in chosen_metrics:
+        lpip_value = compute_lpips(predic, target, reduction=reduction)
+        metrics[METRIC_LPIPS] = lpip_value.item() if reduction != REDUCTION_SKIP else lpip_value
+    return metrics
diff --git a/src/rstor/properties.py b/src/rstor/properties.py
new file mode 100644
index 0000000000000000000000000000000000000000..60fdfb48b3c12752cff664cd5563cb459a572603
--- /dev/null
+++ b/src/rstor/properties.py
@@ -0,0 +1,67 @@
+import torch
+from pathlib import Path
+RELU = "ReLU"
+LEAKY_RELU = "LeakyReLU"
+SIMPLE_GATE = "simple_gate"
+LOSS = "loss"
+LOSS_MSE = "MSE"
+METRIC_PSNR = "PSNR"
+METRIC_SSIM = "SSIM"
+METRIC_LPIPS = "LPIPS"
+SELECTED_METRICS = "selected_metrics"
+DATALOADER = "data_loader"
+BATCH_SIZE = "batch_size"
+SIZE = "size"
+TRAIN, VALIDATION, TEST = "train", "validation", "test"
+LENGTH = "length"
+ID = "id"
+NAME = "name"
+PRETTY_NAME = "pretty_name"
+NB_EPOCHS = "nb_epochs"
+ARCHITECTURE = "architecture"
+MODEL = "model"
+NAME = "name"
+N_PARAMS = "n_params"
+OPTIMIZER = "optimizer"
+LR = "lr"
+PARAMS = "parameters"
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+SCHEDULER_CONFIGURATION = "scheduler_configuration"
+SCHEDULER = "scheduler"
+REDUCELRONPLATEAU = "ReduceLROnPlateau"
+ARCHITECTURE = "architecture"
+CONFIG_DEAD_LEAVES = "config_dead_leaves"
+CONFIG_DEGRADATION = "config_degradation"
+REDUCTION_SUM = "reduction_sum"
+REDUCTION_AVERAGE = "reduction_average"
+REDUCTION_SKIP = "reduction_skip"
+TRACES_TARGET = "target"
+TRACES_DEGRADED = "degraded"
+TRACES_RESTORED = "restored"
+TRACES_METRICS = "metrics"
+TRACES_ALL = "all"
+
+DEGRADATION_BLUR_NONE = "none"
+DEGRADATION_BLUR_MAT = "mat"
+DEGRADATION_BLUR_GAUSS = "gauss"
+
+
+SAMPLER_SATURATED = "saturated"
+SAMPLER_UNIFORM = "uniform"
+SAMPLER_NATURAL = "natural"
+SAMPLER_DIV2K = "div2k"
+
+DATASET_FOLDER = "__dataset"
+DATASET_PATH = Path(__file__).parent.parent.parent/DATASET_FOLDER
+DATASET_DL_RANDOMRGB_1024 = "deadleaves_randomrgb_1024"
+DATASET_DL_DIV2K_1024 = "deadleaves_div2k_1024"
+DATASET_DL_DIV2K_512 = "deadleaves_div2k_512"
+DATASET_DL_EXTRAPRIMITIVES_DIV2K_512 = "deadleaves_primitives_div2k_512"
+DATASET_SYNTH_LIST = [DATASET_DL_DIV2K_512, DATASET_DL_DIV2K_1024,
+                      DATASET_DL_RANDOMRGB_1024, DATASET_DL_EXTRAPRIMITIVES_DIV2K_512]
+DATASET_BLUR_KERNEL_PATH = DATASET_PATH / "kernels" / "custom_blur_centered.mat"
+AUGMENTATION_FLIP = "flip"
+AUGMENTATION_ROTATE = "rotate"
+
+
+DATASET_DIV2K = "div2k"
diff --git a/src/rstor/synthetic_data/color_sampler.py b/src/rstor/synthetic_data/color_sampler.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a52ca9d0c48f1c2a6815796eac135d9bcb7ce74
--- /dev/null
+++ b/src/rstor/synthetic_data/color_sampler.py
@@ -0,0 +1,73 @@
+import numpy as np
+import cv2
+
+from pathlib import Path
+from rstor.properties import DATASET_PATH
+from typing import List
+
+
+def sample_uniform_rgb(size: int, seed: int = None) -> np.ndarray:
+    """
+    Generate n random RGB values.
+
+    Args:
+        n (int): number of colors to sample
+        seed (int, optional): Seed for the random number generator. Defaults to None.
+
+    Returns:
+        np.ndarray: Random RGB values as a numpy array.
+    """
+    # https://github.com/numpy/numpy/issues/17079
+    # https://numpy.org/devdocs/reference/random/new-or-different.html#new-or-different
+    rng = np.random.default_rng(np.random.SeedSequence(seed))
+
+    random_samples = rng.uniform(size=(size, 3))
+    rgb = random_samples
+
+    # Below old version with sturation
+    # lab = (random_samples + np.array([0., -0.5, -0.5])[None]) * np.array([100., 127 * 2, 127 * 2])[None]
+    # rgb = cv2.cvtColor(lab[None, :].astype(np.float32), cv2.COLOR_Lab2RGB)
+    return rgb.squeeze()
+
+
+def sample_saturated_color(size: int, seed: int = None) -> np.ndarray:
+    """
+    Generate n saturated RGB values.
+
+    Args:
+        n (int): number of colors to sample
+        seed (int, optional): Seed for the random number generator. Defaults to None.
+
+    Returns:
+        np.ndarray: Random RGB values as a numpy array.
+    """
+    # https://github.com/numpy/numpy/issues/17079
+    # https://numpy.org/devdocs/reference/random/new-or-different.html#new-or-different
+    rng = np.random.default_rng(np.random.SeedSequence(seed))
+
+    random_samples = rng.uniform(size=(size, 3))
+
+    lab = (random_samples + np.array([0., -0.5, -0.5])[None]) * np.array([100., 127 * 2, 127 * 2])[None]
+    rgb = cv2.cvtColor(lab[None, :].astype(np.float32), cv2.COLOR_Lab2RGB)
+    return rgb.squeeze()
+
+
+def sample_color_from_images(size: int, seed: int = None, path_to_images: List[Path] = []) -> np.ndarray:
+    print("path : ", path_to_images)
+    assert len(path_to_images) > 0, "Please provide a list of images to sample colors from."
+    rng = np.random.default_rng(np.random.SeedSequence(seed))
+
+    # Randomly pick an image and load it
+    img_id = rng.integers(0, len(path_to_images))
+
+    img = cv2.imread(path_to_images[img_id].as_posix())
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) / 255
+
+    pixels = img.reshape(-1, 3)
+    n_pixels = pixels.shape[0]
+
+    # sample a pixel color for each disc
+    pixel_ids = rng.integers(0, n_pixels, size)
+    colors = pixels[pixel_ids, :]
+
+    return colors
diff --git a/src/rstor/synthetic_data/dead_leaves_cpu.py b/src/rstor/synthetic_data/dead_leaves_cpu.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc77922c8777637bfa49cb928582a6d8943214a8
--- /dev/null
+++ b/src/rstor/synthetic_data/dead_leaves_cpu.py
@@ -0,0 +1,79 @@
+from typing import Tuple, Optional, List
+import numpy as np
+import cv2
+from rstor.synthetic_data.dead_leaves_sampler import define_dead_leaves_chart
+from rstor.properties import SAMPLER_UNIFORM
+from pathlib import Path
+
+
+def cpu_dead_leaves_chart(size: Tuple[int, int] = (100, 100),
+                          number_of_circles: int = -1,
+                          background_color: Optional[Tuple[float, float, float]] = (0.5, 0.5, 0.5),
+                          colored: Optional[bool] = True,
+                          radius_min: Optional[int] = -1,
+                          radius_max: Optional[int] = -1,
+                          radius_alpha: Optional[int] = 3,
+                          seed: int = None,
+                          reverse: Optional[bool] = True,
+                          sampler=SAMPLER_UNIFORM,
+                          natural_image_list: List[Path] = []) -> np.ndarray:
+    """
+    Generation of a deqqad leaves chart by splatting circles on top of each other.
+
+    Args:
+        size (Tuple[int, int], optional): size of the generated chart. Defaults to (100, 100).
+        number_of_circles (int, optional): number of circles to generate.
+        If negative, it is computed based on the size. Defaults to -1.
+        background_color (Optional[Tuple[float, float, float]], optional):
+        background color of the chart. Defaults to gray (0.5, 0.5, 0.5).
+        colored (Optional[bool], optional): Whether to generate colored circles. Defaults to True.
+        radius_min (Optional[int], optional): minimum radius of the circles. Defaults to -1. (=> 1)
+        radius_max (Optional[int], optional): maximum radius of the circles. Defaults to -1. (=> 2000)
+        radius_alpha (Optional[int], optional): standard deviation of the radius of the circles.
+        If negative, it is calculated based on the size. Defaults to -1.
+        seed (int, optional): seed for the random number generator. Defaults to None
+        reverse: (Optional[bool], optional): View circles from the back view
+        by reversing order. Defaults to True.
+        WARNING: This option is extremely slow on CPU.
+
+    Returns:
+        np.ndarray: generated dead leaves chart as a NumPy array.
+    """
+    center_x, center_y, radius, color = define_dead_leaves_chart(
+        size,
+        number_of_circles,
+        colored,
+        radius_min,
+        radius_max,
+        radius_alpha,
+        seed,
+        sampler=sampler,
+        natural_image_list=natural_image_list
+    )
+    if not colored:
+        color = np.concatenate((color, color, color), axis=1)
+
+    if reverse:
+        chart = np.zeros((size[0], size[1], 3), dtype=np.float32)
+        buffer = np.zeros_like(chart)
+        is_not_covered_mask = np.ones((*chart.shape[:2], 1))
+        for i in range(number_of_circles):
+            cv2.circle(buffer, (center_x[i], center_y[i]), radius[i], color[i], -1)
+            chart += buffer * is_not_covered_mask
+            is_not_covered_mask = cv2.circle(is_not_covered_mask, (center_x[i], center_y[i]), radius[i], 0, -1)
+
+            if not np.any(is_not_covered_mask):
+                break
+
+        chart += np.multiply(background_color, np.ones((size[0], size[1], 3), dtype=np.float32)) * is_not_covered_mask
+    else:
+        chart = np.multiply(background_color, np.ones((size[0], size[1], 3), dtype=np.float32))
+        for i in range(number_of_circles):
+            # circle is inplace
+            cv2.circle(chart, (center_x[i], center_y[i]), radius[i], color[i], -1)
+
+    chart = chart.clip(0, 1)
+
+    if not colored:
+        chart = chart[:, :, 0, None]  # return shape [h, w, 1] in gray mode
+    return chart
diff --git a/src/rstor/synthetic_data/dead_leaves_gpu.py b/src/rstor/synthetic_data/dead_leaves_gpu.py
new file mode 100644
index 0000000000000000000000000000000000000000..86500c0802d48a7755c71f61733baed2921da0dc
--- /dev/null
+++ b/src/rstor/synthetic_data/dead_leaves_gpu.py
@@ -0,0 +1,176 @@
+from rstor.utils import DEFAULT_NUMPY_FLOAT_TYPE, THREADS_PER_BLOCK
+from rstor.properties import SAMPLER_UNIFORM
+from typing import Tuple, Optional
+from rstor.synthetic_data.dead_leaves_cpu import define_dead_leaves_chart
+import numpy as np
+from numba import cuda
+import math
+
+
+def gpu_dead_leaves_chart(
+    size: Tuple[int, int] = (100, 100),
+        number_of_circles: int = -1,
+        background_color: Optional[Tuple[float, float, float]] = (0.5, 0.5, 0.5),
+        colored: Optional[bool] = True,
+        radius_min: Optional[int] = -1,
+        radius_max: Optional[int] = -1,
+        radius_alpha: Optional[int] = 3,
+        seed: int = None,
+        reverse=True,
+        sampler=SAMPLER_UNIFORM,
+        natural_image_list=None,
+        circle_primitives: bool = True,
+        anisotropy: float = 1.,
+        angle: float = 0.
+) -> np.ndarray:
+    center_x, center_y, radius, color = define_dead_leaves_chart(
+        size,
+        number_of_circles,
+        colored,
+        radius_min,
+        radius_max,
+        radius_alpha,
+        seed,
+        sampler=sampler,
+        natural_image_list=natural_image_list
+    )
+
+    # Generate on gpu
+    chart = _generate_dead_leaves(
+        size,
+        centers=np.stack((center_x, center_y), axis=-1),
+        radia=radius,
+        colors=color,
+        background=background_color,
+        reverse=reverse,
+        circle_primitives=circle_primitives,
+        anisotropy=anisotropy,
+        angle=angle
+    )
+
+    return chart
+
+
+def _generate_dead_leaves(size, centers, radia, colors, background, reverse, circle_primitives: bool, anisotropy: float = 1., angle: float=0.):
+    assert centers.ndim == 2
+    ny, nx = size
+    nc = colors.shape[-1]
+
+    # Init empty array on GPU
+    generation_ = cuda.device_array((ny, nx, nc), DEFAULT_NUMPY_FLOAT_TYPE)
+    # Move useful array to GPU
+    centers_ = cuda.to_device(centers)
+    radia_ = cuda.to_device(radia)
+    colors_ = cuda.to_device(colors)
+
+    # Dispatch threads
+    threadsperblock = (THREADS_PER_BLOCK, THREADS_PER_BLOCK)
+    blockspergrid_x = math.ceil(nx/threadsperblock[1])
+    blockspergrid_y = math.ceil(ny/threadsperblock[0])
+    blockspergrid = (blockspergrid_x, blockspergrid_y)
+
+    if reverse:
+        cuda_dead_leaves_gen_reversed[blockspergrid, threadsperblock](
+            generation_,
+            centers_,
+            radia_,
+            colors_,
+            background,
+            circle_primitives,
+            anisotropy,
+            np.deg2rad(angle)
+        )
+    else:
+        cuda_dead_leaves_gen[blockspergrid, threadsperblock](
+            generation_,
+            centers_,
+            radia_,
+            colors_,
+            background)
+
+    return generation_
+
+
+@cuda.jit(cache=False)
+def cuda_dead_leaves_gen_reversed(generation, centers, radia, colors, background, circle_primitives: bool, anisotropy: float, angle: float):
+    idx, idy = cuda.grid(2)
+    ny, nx, nc = generation.shape
+
+    n_discs = centers.shape[0]
+
+    # Out of bound threads
+    if idx >= nx or idy >= ny:
+        return
+
+    for disc_id in range(n_discs):
+        dx_ = idx - centers[disc_id, 0]
+        dy_ = idy - centers[disc_id, 1]
+        dx = math.cos(angle)*dx_ + math.sin(angle)*dy_
+        dy = -math.sin(angle)*dx_ + math.cos(angle)*dy_
+        dx = dx * anisotropy
+        dist_sq = dx*dx + dy*dy
+
+        # Naive thread diverging version
+        r = radia[disc_id]
+        r_sq = r*r
+        if circle_primitives:
+            if dist_sq <= r_sq:
+                # Copy back to global memory
+                for c in range(nc):
+                    generation[idy, idx, c] = colors[disc_id, c]
+                return
+        else:
+            if (disc_id % 4) == 0 and dist_sq <= r_sq:
+                # Copy back to global memory
+                alpha = dist_sq/r_sq
+                for c in range(nc):
+                    generation[idy, idx, c] = colors[disc_id, c] * alpha + colors[disc_id, (c+1) % 3] * (1-alpha)
+                return
+            elif (disc_id % 4) == 1 and (abs(dx)+abs(dy)) <= r:
+                # Copy back to global memory
+                alpha = dist_sq/r_sq
+                for c in range(nc):
+                    generation[idy, idx, c] = colors[disc_id, c] * alpha + colors[disc_id, (c+1) % 3] * (1-alpha)
+                return
+            elif (disc_id % 4) == 2 and abs(dx) <= r and abs(dy) <= r:
+                for c in range(nc):
+                    generation[idy, idx, c] = colors[disc_id, c]
+                return
+            elif (disc_id % 200) == 3 and abs(dy) <= r//5:
+                for c in range(nc):
+                    generation[idy, idx, c] = colors[disc_id, c] * alpha + colors[disc_id, (c+1) % 3] * (1-alpha)
+                return
+            elif (disc_id % 200) == 4 and abs(dx) <= r//5:
+                for c in range(nc):
+                    generation[idy, idx, c] = colors[disc_id, c] * alpha + colors[disc_id, (c+1) % 3] * (1-alpha)
+                return
+    for c in range(nc):
+        generation[idy, idx, c] = background[c]
+
+
+@cuda.jit(cache=False)
+def cuda_dead_leaves_gen(generation, centers, radia, colors, background):
+    idx, idy, c = cuda.grid(3)
+    ny, nx, nc = generation.shape
+
+    n_discs = centers.shape[0]
+
+    # Out of bound threads
+    if idx >= nx or idy >= ny:
+        return
+
+    out = background[c]
+    for disc_id in range(n_discs):
+        dx = idx - centers[disc_id, 0]
+        dy = idy - centers[disc_id, 1]
+        dist_sq = dx*dx + dy*dy
+
+        # Naive thread diverging version
+        r = radia[disc_id]
+        r_sq = r*r
+
+        if dist_sq <= r_sq:
+            out = colors[disc_id, c]
+
+    # Copy back to global memory
+    generation[idy, idx, c] = out
diff --git a/src/rstor/synthetic_data/dead_leaves_sampler.py b/src/rstor/synthetic_data/dead_leaves_sampler.py
new file mode 100644
index 0000000000000000000000000000000000000000..b5b7faf903886b818f5e01016612e8116179a7f7
--- /dev/null
+++ b/src/rstor/synthetic_data/dead_leaves_sampler.py
@@ -0,0 +1,74 @@
+from typing import Tuple, Optional, List
+from rstor.properties import SAMPLER_SATURATED, SAMPLER_NATURAL, SAMPLER_UNIFORM
+from rstor.synthetic_data.color_sampler import sample_uniform_rgb, sample_saturated_color, sample_color_from_images
+import numpy as np
+from pathlib import Path
+
+
+def define_dead_leaves_chart(
+    size: Tuple[int, int] = (100, 100),
+    number_of_circles: int = -1,
+    colored: Optional[bool] = True,
+    radius_min: Optional[int] = -1,
+    radius_max: Optional[int] = -1,
+    radius_alpha: Optional[int] = 3,
+    seed: int = None,
+    sampler=SAMPLER_UNIFORM,
+    natural_image_list: Optional[List[Path]] = None
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Defines the geometric and color properties of the primitives in the dead leaves chart to later be sampled.
+
+    Args:
+        size (Tuple[int, int], optional): size of the generated chart. Defaults to (100, 100).
+        number_of_circles (int, optional): number of circles to generate.
+        If negative, it is computed based on the size. Defaults to -1.
+        colored (Optional[bool], optional): Whether to generate colored circles. Defaults to True.
+        radius_min (Optional[int], optional): minimum radius of the circles. Defaults to -1. (=> 1)
+        radius_max (Optional[int], optional): maximum radius of the circles. Defaults to -1. (=> 2000)
+        radius_alpha (Optional[int], optional): standard deviation of the radius of the circles.
+        If negative, it is calculated based on the size. Defaults to -1.
+        seed (int, optional): seed for the random number generator. Defaults to None
+
+    Returns:
+        Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: center_x, center_y, radius, color
+    """
+    rng = np.random.default_rng(np.random.SeedSequence(seed))
+
+    if number_of_circles < 0:
+        number_of_circles = 30 * max(size)
+    if radius_min < 0.:
+        radius_min = 1.
+    if radius_max < 0.:
+        radius_max = 2000.
+
+    # Pick random circle centers and radii
+    center_x = rng.integers(0, size[1], size=number_of_circles)
+    center_y = rng.integers(0, size[0], size=number_of_circles)
+
+    # Sample from a power law distribution for the p(radius=r) = (r.clip(radius_min, radius_max))^(-alpha)
+
+    radius = rng.uniform(
+        low=radius_max ** (1 - radius_alpha),
+        high=radius_min ** (1 - radius_alpha),
+        size=number_of_circles
+    )
+    # Using the change of variables formula for random variables.
+    radius = radius ** (-1/(radius_alpha - 1))
+    radius = radius.round().astype(int)
+
+    # Pick random colors
+    if colored:
+        if sampler == SAMPLER_UNIFORM:
+            color = sample_uniform_rgb(number_of_circles, seed=rng.integers(0, 1e10)).astype(float)
+        elif sampler == SAMPLER_SATURATED:
+            color = sample_saturated_color(number_of_circles, seed=rng.integers(0, 1e10)).astype(float)
+        elif sampler == SAMPLER_NATURAL:
+            assert natural_image_list is not None, "Please provide a list of images to sample colors from."
+            color = sample_color_from_images(number_of_circles, seed=rng.integers(0, 1e10),
+                                             path_to_images=natural_image_list).astype(float)
+        else:
+            raise NotImplementedError(f"Unknown color sampler {sampler}")
+    else:
+        color = rng.uniform(0.25, 0.75, size=(number_of_circles, 1))
+    return center_x, center_y, radius, color
diff --git a/src/rstor/synthetic_data/interactive/interactive_dead_leaves.py b/src/rstor/synthetic_data/interactive/interactive_dead_leaves.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a43ebce65264c2f3f7328bf42b3c64a3e88623e
--- /dev/null
+++ b/src/rstor/synthetic_data/interactive/interactive_dead_leaves.py
@@ -0,0 +1,81 @@
+from rstor.synthetic_data.dead_leaves_cpu import cpu_dead_leaves_chart
+from rstor.synthetic_data.dead_leaves_gpu import gpu_dead_leaves_chart
+from rstor.properties import SAMPLER_UNIFORM, SAMPLER_DIV2K, SAMPLER_NATURAL, SAMPLER_SATURATED, DATASET_PATH
+import sys
+import numpy as np
+from interactive_pipe import interactive_pipeline, interactive
+from typing import Optional
+
+
+def dead_leave_plugin(ds=1):
+    interactive(
+        background_intensity=(0.5, [0., 1.]),
+        number_of_circles=(-1, [-1, 10000]),
+        colored=(True,),
+        radius_alpha=(3., [2., 10.]),
+        seed=(0, [-1, 42]),
+        ds=(ds, [1, 5]),
+        numba_flag=(True,),  # Default CPU to avoid issues by default
+        sampler=(SAMPLER_UNIFORM, [SAMPLER_UNIFORM, SAMPLER_DIV2K, SAMPLER_SATURATED]),
+        circle_primitives=(True,),
+        anisotropy=(1., [0.1, 10.]),
+        angle=(0., [-180., 180.])
+        # ds=(ds, [1, 5])
+    )(generate_deadleave)
+
+
+def generate_deadleave(
+    background_intensity: float = 0.5,
+    number_of_circles: int = -1,
+    colored: Optional[bool] = False,
+    radius_alpha: Optional[int] = 3,
+    seed=0,
+    ds=3,
+    numba_flag=True,
+    sampler=SAMPLER_UNIFORM,
+    circle_primitives=True,
+    anisotropy=1.,
+    angle=0.,
+    global_params={}
+) -> np.ndarray:
+    global_params["ds_factor"] = ds
+    bg_color = (background_intensity, background_intensity, background_intensity)
+    natural_image_list = None
+    if sampler == SAMPLER_DIV2K:
+        sampler = SAMPLER_NATURAL
+        div2k_path = DATASET_PATH / "div2k" / "DIV2K_train_HR" / "DIV2K_train_HR"
+        natural_image_list = sorted([file for file in div2k_path.glob("*.png")])
+    if not numba_flag:
+        chart = cpu_dead_leaves_chart((512*ds, 512*ds), number_of_circles, bg_color, colored,
+                                      radius_alpha=radius_alpha,
+                                      seed=None if seed < 0 else seed,
+                                      sampler=sampler,
+                                      reverse=False,
+                                      natural_image_list=natural_image_list)
+    else:
+        chart = gpu_dead_leaves_chart((512*ds, 512*ds), number_of_circles, bg_color, colored,
+                                      radius_alpha=radius_alpha,
+                                      seed=None if seed < 0 else seed,
+                                      sampler=sampler,
+                                      natural_image_list=natural_image_list,
+                                      circle_primitives=circle_primitives,
+                                      anisotropy=anisotropy,
+                                      angle=angle).copy_to_host()
+    if chart.shape[-1] == 1:
+        chart = chart.repeat(3, axis=-1)
+        # Required to switch from colors to gray scale visualization.
+    return chart
+
+
+def deadleave_pipeline():
+    deadleave_chart = generate_deadleave()
+    return deadleave_chart
+
+
+def main(argv):
+    dead_leave_plugin(ds=1)
+    interactive_pipeline(gui="auto")(deadleave_pipeline)()
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/src/rstor/utils.py b/src/rstor/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..df93a56950b9a01f6518930b639e0e9885a4420e
--- /dev/null
+++ b/src/rstor/utils.py
@@ -0,0 +1,12 @@
+import numpy as np
+import numba
+import torch
+
+THREADS_PER_BLOCK = 32  # 32 or 16
+DEFAULT_NUMPY_FLOAT_TYPE = np.float32
+DEFAULT_CUDA_FLOAT_TYPE = numba.float32
+DEFAULT_TORCH_FLOAT_TYPE = torch.float32
+
+
+DEFAULT_NUMPY_INT_TYPE = np.int32
+DEFAULT_CUDA_INT_TYPE = numba.int32
diff --git a/test/test_dataloader.py b/test/test_dataloader.py
new file mode 100644
index 0000000000000000000000000000000000000000..53ccd466465bd301eb2276dcac8c8744b3af6a66
--- /dev/null
+++ b/test/test_dataloader.py
@@ -0,0 +1,49 @@
+import torch
+from rstor.data.synthetic_dataloader import DeadLeavesDataset
+
+
+def test_dead_leaves_dataset():
+    # Test case 1: Default parameters
+    dataset = DeadLeavesDataset(noise_stddev=(0, 0), ds_factor=1)
+    assert len(dataset) == 1000
+    assert dataset.size == (128, 128)
+    assert dataset.frozen_seed is None
+    assert dataset.config_dead_leaves == {}
+
+    # Test case 2: Custom parameters
+    dataset = DeadLeavesDataset(size=(256, 256), length=500, frozen_seed=42, number_of_circles=5,
+                                background_color=(0.2, 0.4, 0.6), colored=True, radius_min=1, radius_alpha=3,
+                                noise_stddev=(0, 0), ds_factor=1)
+    assert len(dataset) == 500
+    assert dataset.size == (256, 256)
+    assert dataset.frozen_seed == 42
+    assert dataset.config_dead_leaves == {
+        'number_of_circles': 5,
+        'background_color': (0.2, 0.4, 0.6),
+        'colored': True,
+        'radius_min': 1,
+        'radius_alpha': 3
+    }
+
+    # Test case 3: Check item retrieval
+    item, item_tgt = dataset[0]
+    assert isinstance(item, torch.Tensor)
+    assert item.shape == (3, 256, 256)
+
+    # Test case 4: Repeatable results with frozen seed
+    dataset1 = DeadLeavesDataset(frozen_seed=42, noise_stddev=(0, 0), number_of_circles=256)
+    dataset2 = DeadLeavesDataset(frozen_seed=42, noise_stddev=(0, 0), number_of_circles=256)
+    item1, item_tgt1 = dataset1[0]
+    item2, item_tgt2 = dataset2[0]
+    assert torch.all(torch.eq(item1, item2))
+    
+    # Test case 5: Visualize
+    # dataset = DeadLeavesDataset(size=(256, 256), length=500, frozen_seed=43,
+    #                                 background_color=(0.2, 0.4, 0.6), colored=True, radius_min=1, radius_alpha=3,
+    #                                 noise_stddev=(0, 0), ds_factor=1)
+    # item, item_tgt = dataset[0]
+    # import matplotlib.pyplot as plt
+    # plt.figure()
+    # plt.imshow(item.permute(1, 2, 0).detach().cpu())
+    # plt.show()
+    # print("done")
diff --git a/test/test_dataloader_gpu.py b/test/test_dataloader_gpu.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc5dc1ed6347a1439d1874cc0e3320dc51d6a959
--- /dev/null
+++ b/test/test_dataloader_gpu.py
@@ -0,0 +1,56 @@
+import torch
+from rstor.data.synthetic_dataloader import DeadLeavesDatasetGPU
+import numba
+
+
+def test_dead_leaves_dataset_gpu():
+    if not numba.cuda.is_available():
+        return
+
+    # Test case 1: Default parameters
+    dataset = DeadLeavesDatasetGPU(noise_stddev=(0, 0), ds_factor=1)
+    assert len(dataset) == 1000
+    assert dataset.size == (128, 128)
+    assert dataset.frozen_seed is None
+    assert dataset.config_dead_leaves == {}
+
+    # Test case 2: Custom parameters
+    dataset = DeadLeavesDatasetGPU(size=(256, 256), length=500, frozen_seed=42, number_of_circles=5,
+                                   background_color=(0.2, 0.4, 0.6), colored=True, radius_min=1, radius_alpha=3,
+                                   noise_stddev=(0, 0), ds_factor=1)
+    assert len(dataset) == 500
+    assert dataset.size == (256, 256)
+    assert dataset.frozen_seed == 42
+    assert dataset.config_dead_leaves == {
+        'number_of_circles': 5,
+        'background_color': (0.2, 0.4, 0.6),
+        'colored': True,
+        'radius_min': 1,
+        'radius_alpha': 3
+    }
+
+    # Test case 3: Check item retrieval
+    item, item_tgt = dataset[0]
+    assert isinstance(item, torch.Tensor)
+    assert item.shape == (3, 256, 256)
+
+    # Test case 4: Repeatable results with frozen seed
+    dataset1 = DeadLeavesDatasetGPU(frozen_seed=42, noise_stddev=(0, 0), number_of_circles=256)
+    dataset2 = DeadLeavesDatasetGPU(frozen_seed=42, noise_stddev=(0, 0), number_of_circles=256)
+    item1, item_tgt1 = dataset1[0]
+    item2, item_tgt2 = dataset2[0]
+    assert torch.all(torch.eq(item1, item2))
+
+
+
+    # Test case 5: Visualize
+    # dataset = DeadLeavesDatasetGPU(size=(256, 256), length=500, frozen_seed=44, number_of_circles=10_000,
+    #                                 background_color=(0.2, 0.4, 0.6), colored=True, radius_min=1, radius_alpha=3,
+    #                                 noise_stddev=(0, 0), ds_factor=1)
+    # item, item_tgt = dataset[0]
+    # import matplotlib.pyplot as plt
+    # plt.figure()
+    # plt.imshow(item.permute(1, 2, 0).detach().cpu())
+    # plt.show()
+    # print("done")
+
diff --git a/test/test_dataloader_stored.py b/test/test_dataloader_stored.py
new file mode 100644
index 0000000000000000000000000000000000000000..7fbf10001cf002572430cda925aa8605e566dad7
--- /dev/null
+++ b/test/test_dataloader_stored.py
@@ -0,0 +1,67 @@
+import torch
+from rstor.data.stored_images_dataloader import RestorationDataset
+from numba import cuda
+from rstor.properties import DATASET_PATH, AUGMENTATION_FLIP, AUGMENTATION_ROTATE
+
+
+def test_dataloader_stored():
+    if not cuda.is_available():
+        print("cuda unavailable, exiting")
+        return
+
+    # Test case 1: Default parameters
+    dataset = RestorationDataset(noise_stddev=(0, 0),
+                                 images_path=DATASET_PATH/"sample")
+    assert len(dataset) == 2
+    assert dataset.frozen_seed is None
+
+    # Test case 2: Custom parameters
+    dataset = RestorationDataset(images_path=DATASET_PATH/"sample",
+                                 size=(64, 64),
+                                 frozen_seed=42,
+                                 noise_stddev=(0, 0))
+    assert len(dataset) == 2
+    assert dataset.frozen_seed == 42
+
+    # Test case 3: Check item retrieval
+    item, item_tgt = dataset[0]
+    assert isinstance(item, torch.Tensor)
+    assert item.shape == item_tgt.shape
+    assert item.shape == (3, 64, 64)
+
+    # Test case 4: Repeatable results with frozen seed
+    dataset1 = RestorationDataset(images_path=DATASET_PATH/"sample", 
+                                  frozen_seed=42, noise_stddev=(0, 0))
+    dataset2 = RestorationDataset(images_path=DATASET_PATH/"sample",
+                                  frozen_seed=42, noise_stddev=(0, 0))
+    item1, item_tgt1 = dataset1[0]
+    item2, item_tgt2 = dataset2[0]
+    
+    assert torch.all(torch.eq(item1, item2))
+    
+    # Test case 4: Repeatable results with frozen seed and augmentation
+    augmentation_list = [AUGMENTATION_FLIP, AUGMENTATION_ROTATE]
+    dataset1 = RestorationDataset(images_path=DATASET_PATH/"sample", 
+                                  frozen_seed=42, noise_stddev=(0, 0),
+                                  augmentation_list=augmentation_list)
+    dataset2 = RestorationDataset(images_path=DATASET_PATH/"sample",
+                                  frozen_seed=42, noise_stddev=(0, 0),
+                                  augmentation_list=augmentation_list)
+    item1, item_tgt1 = dataset1[0]
+    item2, item_tgt2 = dataset2[0]
+    assert torch.all(torch.eq(item1, item2))
+
+
+
+    # Test case 5: Visualize
+    # dataset = RestorationDataset(images_path=DATASET_PATH/"sample",
+    #                              noise_stddev=(0, 0),
+    #                              augmentation_list=augmentation_list)
+    # item, item_tgt = dataset[0]
+    # import matplotlib.pyplot as plt
+    # plt.figure()
+    # plt.imshow(item.permute(1, 2, 0).detach().cpu())
+    # plt.show()
+    # breakpoint()
+    print("done")
+
diff --git a/test/test_dead_leaves.py b/test/test_dead_leaves.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa614f2acc4e6433c40af8087468fea17ed73452
--- /dev/null
+++ b/test/test_dead_leaves.py
@@ -0,0 +1,44 @@
+import numpy as np
+from rstor.synthetic_data.dead_leaves_cpu import cpu_dead_leaves_chart
+from rstor.properties import SAMPLER_NATURAL, DATASET_PATH
+
+
+def test_dead_leaves_chart():
+    # Test case 1: Default parameters
+    chart = cpu_dead_leaves_chart()
+    assert isinstance(chart, np.ndarray)
+    assert chart.shape == (100, 100, 3)
+
+    # Test case 2: Custom size and number of circles
+    chart = cpu_dead_leaves_chart(size=(200, 150), number_of_circles=10)
+    assert isinstance(chart, np.ndarray)
+    assert chart.shape == (200, 150, 3)
+
+    # Test case 3: Colored circles
+    chart = cpu_dead_leaves_chart(colored=True, number_of_circles=300)
+    assert isinstance(chart, np.ndarray)
+    assert chart.shape == (100, 100, 3)
+
+    # Test case 4: Custom radius mean and stddev
+    chart = cpu_dead_leaves_chart(radius_min=5, radius_alpha=2, number_of_circles=300)
+    assert isinstance(chart, np.ndarray)
+    assert chart.shape == (100, 100, 3)
+
+    # Test case 5: Custom background color
+    chart = cpu_dead_leaves_chart(background_color=(0.2, 0.4, 0.6), number_of_circles=300)
+    assert isinstance(chart, np.ndarray)
+    assert chart.shape == (100, 100, 3)
+
+    # Test case 6: Custom seed
+    chart1 = cpu_dead_leaves_chart(seed=42, number_of_circles=300)
+    chart2 = cpu_dead_leaves_chart(seed=42, number_of_circles=300)
+    assert np.array_equal(chart1, chart2)
+
+
+def test_dead_leaves_color_sampler():
+    img_list = sorted(
+        list((DATASET_PATH / "sample").glob("*.png"))
+    )
+    _gen = cpu_dead_leaves_chart(number_of_circles=300, sampler=SAMPLER_NATURAL, natural_image_list=img_list)
+    # from interactive_pipe.data_objects.image import Image
+    # Image(_gen).show()
diff --git a/test/test_gpu_vs_cpu_dataloader.py b/test/test_gpu_vs_cpu_dataloader.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd68c2e63ac19298298069ecc822a339a52b0317
--- /dev/null
+++ b/test/test_gpu_vs_cpu_dataloader.py
@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Sun Mar  3 20:59:03 2024
+
+@author: jamyl
+"""
+from rstor.data.synthetic_dataloader import DeadLeavesDataset, DeadLeavesDatasetGPU
+from time import perf_counter
+import numba
+
+
+def test_gpu_vs_cpu_dataloader():
+    if not numba.cuda.is_available():
+        return
+
+    n = 10
+    print("\n")
+
+    print("=== Dead leaves with reversing")
+    dataset = DeadLeavesDatasetGPU(number_of_circles=256, reverse=True)
+    t1 = perf_counter()
+    for i in range(n):
+        _ = dataset[i]
+    print(f"Mean time on {n} samples (numba) : {(perf_counter()-t1)/n}")
+
+    dataset = DeadLeavesDataset(number_of_circles=256, reverse=True)
+    t1 = perf_counter()
+    for i in range(n):
+        _ = dataset[i]
+    print(f"Mean time on {n} samples (cv2): {(perf_counter()-t1)/n}")
+
+    print("=== Dead leaves without reversing")
+    dataset = DeadLeavesDatasetGPU(number_of_circles=256, reverse=False)
+    t1 = perf_counter()
+    for i in range(n):
+        _ = dataset[i]
+    print(f"Mean time on {n} samples (numba) : {(perf_counter()-t1)/n}")
+
+    dataset = DeadLeavesDataset(number_of_circles=256, reverse=False)
+    t1 = perf_counter()
+    for i in range(n):
+        _ = dataset[i]
+    print(f"Mean time on {n} samples (cv2): {(perf_counter()-t1)/n}")
diff --git a/test/test_metrics.py b/test/test_metrics.py
new file mode 100644
index 0000000000000000000000000000000000000000..8034bfb662f5983de5484675efb8a52df28dba56
--- /dev/null
+++ b/test/test_metrics.py
@@ -0,0 +1,57 @@
+import torch
+import numpy as np
+from rstor.learning.metrics import compute_psnr, compute_ssim, compute_metrics, compute_lpips
+from rstor.properties import REDUCTION_AVERAGE, REDUCTION_SKIP, REDUCTION_SUM, DEVICE
+from rstor.properties import METRIC_PSNR, METRIC_SSIM, METRIC_LPIPS
+
+
+def test_compute_psnr():
+
+    # Test case 1: Identical values
+    predic = torch.tensor([[[[1.0, 2.0], [3.0, 4.0]]]])
+    target = torch.tensor([[[[1.0, 2.0], [3.0, 4.0]]]])
+    assert torch.isinf(compute_psnr(predic, target, clamp_mse=0)), "Test case 1 failed"
+
+    # Test case 2: Predic and target have different values
+    predic = torch.tensor([[[[0., 0.], [0., 0.]]]])
+    target = torch.tensor([[[[0.25, 0.25], [0.25, 0.25]]]])
+    assert compute_psnr(predic, target).item() == (10. * torch.log10(torch.Tensor([4.**2]))).item()  # 12db
+
+    print("All tests passed.")
+
+
+def test_compute_ssim():
+    x = torch.rand(8, 3, 256, 256)
+    y = torch.rand(8, 3, 256, 256)
+    ssim = compute_ssim(x, y, reduction=REDUCTION_AVERAGE)
+    ssim_per_unit = compute_ssim(x, y, reduction=REDUCTION_SKIP)
+    assert ssim_per_unit.shape == (8,), "SSIM Test case 1 failed"
+    assert ssim_per_unit.mean() == ssim, "SSIM Test case 2 failed"
+
+
+def test_compute_lpips():
+    for i in range(2):
+        x = torch.rand(8, 3, 256, 256).to(DEVICE)
+        y = torch.rand(8, 3, 256, 256).to(DEVICE)
+        lpips = compute_lpips(x, y, reduction=REDUCTION_AVERAGE)
+        lpips_per_unit = compute_lpips(x, y, reduction=REDUCTION_SKIP)
+        assert lpips_per_unit.shape == (8,), "LPIPS Test case 1 failed"
+        assert torch.isclose(lpips_per_unit.mean(), lpips), "LPIPS Test case 2 failed"
+
+
+def test_compute_metrics():
+    x = torch.rand(8, 3, 256, 256)  # negative value ensures that we check clamping for LPIPS
+    y = x.clone() + torch.randn(8, 3, 256, 256) * 0.01
+    metrics = compute_metrics(x, y)
+    print(metrics)
+    metric_per_image = compute_metrics(x, y, reduction=REDUCTION_SKIP)
+
+    metric_sum_reduction = compute_metrics(x, y, reduction=REDUCTION_SUM)
+    assert metric_per_image[METRIC_PSNR].shape == (8,), "Metrics Test case 1 failed"
+    assert metric_per_image[METRIC_SSIM].shape == (8,), "Metrics Test case 2 failed"
+    assert metric_per_image[METRIC_LPIPS].shape == (8,), "Metrics Test case 3 failed"
+    assert np.isclose(metric_per_image[METRIC_PSNR].mean().item(), metrics[METRIC_PSNR]), "Metrics Test case 4 failed"
+    assert np.isclose(metric_per_image[METRIC_PSNR].sum().item(),
+                      metric_sum_reduction[METRIC_PSNR]), "Metrics Test case 5 failed"
+    assert np.isclose(metrics[METRIC_PSNR],
+                      metric_sum_reduction[METRIC_PSNR]/8.), "Metrics Test case 6 failed"
diff --git a/test/test_nafnet.py b/test/test_nafnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..051005b0f01bd7fddc92922246de77a3353ef4fa
--- /dev/null
+++ b/test/test_nafnet.py
@@ -0,0 +1,19 @@
+import torch
+from rstor.architecture.nafnet import NAFNet
+
+
+def test_nafnet():
+    enc_blks = [1, 1]
+    middle_blk_num = 1
+    dec_blks = [1, 2]
+
+    model = NAFNet(
+        img_channel=3,
+        width=2,
+        middle_blk_num=middle_blk_num,
+        enc_blk_nums=enc_blks,
+        dec_blk_nums=dec_blks,
+    )
+    x = torch.rand(2, 3, 128, 128)
+    y = model(x)
+    assert y.shape == (2, 3, 128, 128)
diff --git a/test/test_stacked_convolutions.py b/test/test_stacked_convolutions.py
new file mode 100644
index 0000000000000000000000000000000000000000..1579e2de07182d0610bef4a31f5975434af1feb1
--- /dev/null
+++ b/test/test_stacked_convolutions.py
@@ -0,0 +1,27 @@
+import torch
+from rstor.architecture.stacked_convolutions import StackedConvolutions
+from rstor.properties import RELU
+
+
+def test_stacked_convolutions():
+    # Test case 1: Default parameters
+    model = StackedConvolutions()
+    assert isinstance(model, torch.nn.Module)
+
+    # Test case 2: Number of layers is not even
+    try:
+        model = StackedConvolutions(num_layers=7)
+        assert False, "Expected AssertionError"
+    except AssertionError:
+        pass
+
+    # Test case 3: Custom parameters
+    n, c, h, w = 1, 3, 64, 64
+    model = StackedConvolutions(ch_in=c, ch_out=2, h_dim=32, num_layers=4, k_size=5, activation=RELU, bias=False)
+    assert isinstance(model, torch.nn.Module)
+
+    # Test case 4: Forward pass
+    input_tensor = torch.randn(n, c, h, w)
+    output_tensor = model(input_tensor)
+    assert model.receptive_field() == (25, 25)
+    assert output_tensor.shape == (1, 2, h, w)
diff --git a/test/test_unet.py b/test/test_unet.py
new file mode 100644
index 0000000000000000000000000000000000000000..ce74228895f09438dabfe18d2a175c80f9bec10a
--- /dev/null
+++ b/test/test_unet.py
@@ -0,0 +1,27 @@
+import torch
+from rstor.architecture.nafnet import UNet
+from rstor.properties import LEAKY_RELU
+
+
+def test_unet():
+    enc_blks = [1, 2]
+    middle_blk_num = 2
+    dec_blks = [2, 1]
+
+    model = UNet(
+        img_channel=3,
+        width=2,
+        activation=LEAKY_RELU,
+        # We need leaky relu ...
+        # otherwise it seems like ReLU may block propagation of NaN (with zeros!)
+        # NaN and ReLu do not work correctly for receptive field estimation technique
+        middle_blk_num=middle_blk_num,
+        enc_blk_nums=enc_blks,
+        dec_blk_nums=dec_blks,
+    )
+    rx, ry = model.receptive_field(channels=3)
+    assert rx == ry
+    assert rx == 44, "Receptive field should be {rx} x {ry}"
+    x = torch.rand(2, 3, 128, 128)
+    y = model(x)
+    assert y.shape == (2, 3, 128, 128)