diff --git a/ml4cc/config/datasets/CEPC.yaml b/ml4cc/config/datasets/CEPC.yaml
index 235add7..15df382 100644
--- a/ml4cc/config/datasets/CEPC.yaml
+++ b/ml4cc/config/datasets/CEPC.yaml
@@ -1,6 +1,6 @@
 name: CEPC
 input_dim: 3000
-max_peak_cands: 1580
+max_peak_cands: 1600
 branches: null
 tree_path: sim
 particle_types:
diff --git a/ml4cc/config/datasets/FCC.yaml b/ml4cc/config/datasets/FCC.yaml
index 9dcab32..8ff5b39 100644
--- a/ml4cc/config/datasets/FCC.yaml
+++ b/ml4cc/config/datasets/FCC.yaml
@@ -1,6 +1,6 @@
 name: FCC
 input_dim: 1200
-max_peak_cands: 645
+max_peak_cands: 700
 branches: null
 tree_path: sim
 particle_types:
diff --git a/ml4cc/config/evaluation/evaluation.yaml b/ml4cc/config/evaluation/evaluation.yaml
index 2702376..3eff838 100644
--- a/ml4cc/config/evaluation/evaluation.yaml
+++ b/ml4cc/config/evaluation/evaluation.yaml
@@ -2,4 +2,4 @@ dataset:
   num_evaluation_waveforms: 1000
   results_output_dir: ${training.results_dir}/data
 training:
-  eval_all_always: false
+  eval_all: ${training.eval_all}
diff --git a/ml4cc/config/models/one_step/models/transformer.yaml b/ml4cc/config/models/one_step/models/transformer.yaml
index f2b64eb..383f66b 100644
--- a/ml4cc/config/models/one_step/models/transformer.yaml
+++ b/ml4cc/config/models/one_step/models/transformer.yaml
@@ -1,13 +1,13 @@
 _target_: ml4cc.models.transformer.TransformerModule
 name: transformer
 hyperparameters:
-    input_dim: ${dataset.input_dim} # Actually this should be 1 or 15.
-    d_model: 128 #512
+    input_dim: 15 #${dataset.input_dim} # Actually this should be 1 or 15.
+    d_model: 128 # 512
     num_heads: 8
-    num_layers: 2 #3
-    hidden_dim: 248 #2048
+    num_layers: 2 # 3
+    hidden_dim: 256 # 2048
     num_classes: 1
-    max_len: ${dataset.input_dim}
+    max_len: ${dataset.input_dim} # Maybe ${dataset.max_peak_cands}
     lr: 1e-6
 checkpoint:
     model: null
diff --git a/ml4cc/config/models/two_step/clusterization/DNN.yaml b/ml4cc/config/models/two_step/clusterization/DNN.yaml
index 98de2ed..d2fb5d0 100644
--- a/ml4cc/config/models/two_step/clusterization/DNN.yaml
+++ b/ml4cc/config/models/two_step/clusterization/DNN.yaml
@@ -1,7 +1,7 @@
 _target_: ml4cc.models.simpler_models.DNNModule
 name: DNN
 hyperparameters:
-    n_features: 1650
+    n_features: ${dataset.max_peak_cands}
     linear_layer_1:
         out_features: 32
     linear_layer_2:
diff --git a/ml4cc/config/models/two_step/two_step.yaml b/ml4cc/config/models/two_step/two_step.yaml
index 921fbf5..5bb4e67 100644
--- a/ml4cc/config/models/two_step/two_step.yaml
+++ b/ml4cc/config/models/two_step/two_step.yaml
@@ -1,4 +1,4 @@
 defaults:
   - _self_
   - peak_finding@peak_finding.model: LSTM
-  - clusterization@clusterization.model: CNN
\ No newline at end of file
+  - clusterization@clusterization.model: CNN
diff --git a/ml4cc/config/models/two_step_minimal/models/LSTM.yaml b/ml4cc/config/models/two_step_minimal/models/LSTM.yaml
index 6ec37db..07bc8e2 100644
--- a/ml4cc/config/models/two_step_minimal/models/LSTM.yaml
+++ b/ml4cc/config/models/two_step_minimal/models/LSTM.yaml
@@ -5,7 +5,7 @@ hyperparameters:
     num_features: 15
     lstm_hidden_dim: 32
     num_lstm_layers: 1
-    regression: true
+    regression: false
 
 checkpoint:
     model: null
diff --git a/ml4cc/config/training.yaml b/ml4cc/config/training.yaml
index 0673132..0c93cbe 100644
--- a/ml4cc/config/training.yaml
+++ b/ml4cc/config/training.yaml
@@ -7,7 +7,7 @@ training:
     models_dir: ${training.output_dir_}/models
     log_dir: ${training.output_dir_}/logs
     predictions_dir: ${training.output_dir_}/predictions
-    results_dir: ${training.output_dir}/results
+    results_dir: ${training.output_dir_}/results
     dataloader:
         batch_sizes:
             one_step: 128
diff --git a/ml4cc/models/LSTM.py b/ml4cc/models/LSTM.py
index 6b26cbe..b4e995c 100644
--- a/ml4cc/models/LSTM.py
+++ b/ml4cc/models/LSTM.py
@@ -3,29 +3,30 @@
 import torch.optim as optim
 import torch.nn.functional as F
 from torch.optim.lr_scheduler import ReduceLROnPlateau
+from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence
 
 
 # TODO: Is this implemented like in their paper? In their paper they have
 # multiple LSTMs.
 class LSTM(torch.nn.Module):
-    def __init__(self, num_features, lstm_hidden_dim: int = 32, num_lstm_layers: int = 1, regression: bool = False):
+    def __init__(self, num_features, lstm_hidden_dim: int = 32, num_lstm_layers: int = 1):
         super().__init__()
-        self.regression = regression
         self.lstm = torch.nn.LSTM(
             input_size=num_features, num_layers=num_lstm_layers, hidden_size=lstm_hidden_dim, batch_first=True
         )
         self.fc3 = torch.nn.Linear(lstm_hidden_dim, 32)
         self.fc4 = torch.nn.Linear(32, 1)
 
-    def forward(self, x):
-        ula, (h, _) = self.lstm(x)
-        out = h[-1] if self.regression else ula
-        # If we would like to have a prediction for each point in wf, then we
-        # would use ula instead of out here
-        out = F.relu(self.fc3(out))
+    def forward(self, x, mask):
+        lengths = mask.sum(dim=1)
+        packed_x = pack_padded_sequence(x, lengths.cpu(), batch_first=True, enforce_sorted=False)
+        ula, (h, _) = self.lstm(packed_x)
+        # Unpack sequence to apply linear layer to each timestep
+        padded_out, _ = pad_packed_sequence(ula, batch_first=True)
+        out = F.relu(self.fc3(padded_out))
         out = self.fc4(out)
-        clf = out if self.regression else F.sigmoid(out)
-        return clf
+        out = torch.sigmoid(out)  # use torch.sigmoid, not F.sigmoid (deprecated)
+        return out
 
 
 class LSTMModule(L.LightningModule):
@@ -37,7 +38,6 @@ def __init__(self, name: str, hyperparameters: dict, checkpoint: dict = None):
             num_features=self.hyperparameters["num_features"],
             lstm_hidden_dim=self.hyperparameters["lstm_hidden_dim"],
             num_lstm_layers=self.hyperparameters["num_lstm_layers"],
-            regression=self.hyperparameters.get("regression", False),
         )
 
     def training_step(self, batch, batch_idx):
@@ -51,8 +51,9 @@ def training_step(self, batch, batch_idx):
 
     def validation_step(self, batch, batch_idx):
         predicted_labels, target = self.forward(batch)
-        masked_target = target[target != -1]
-        masked_predicted_labels = predicted_labels[target != -1]
+        target_mask = (target != -1) & (target != -999)
+        masked_target = target[target_mask]
+        masked_predicted_labels = predicted_labels[target_mask]
         loss = F.binary_cross_entropy(masked_predicted_labels, masked_target)
         self.log("val_loss", loss)
         return loss
@@ -76,6 +77,6 @@ def test_step(self, batch, batch_idx):
         return predicted_labels
 
     def forward(self, batch):
-        waveform, target = batch
-        predicted_labels = self.lstm(waveform).squeeze(dim=-1)
+        waveform, target, mask = batch
+        predicted_labels = self.lstm(waveform, mask).squeeze(dim=-1)
         return predicted_labels, target
diff --git a/ml4cc/models/simpler_models.py b/ml4cc/models/simpler_models.py
index 2642204..dc91b35 100644
--- a/ml4cc/models/simpler_models.py
+++ b/ml4cc/models/simpler_models.py
@@ -66,7 +66,7 @@ def __init__(self, hyperparameters):
         self.flatten = nn.Flatten()
         self.fc1 = nn.Linear(
             # Compute flattened input size manually
-            in_features=6560,
+            in_features=2752,
             out_features=hyperparameters.linear_layer_1.out_features,
         )
         self.output = nn.Linear(
@@ -121,7 +121,7 @@ def forward(self, x, mask):
         lengths = mask.sum(dim=1)
         # Pack the padded sequence
         packed_x = pack_padded_sequence(x, lengths.cpu(), batch_first=True, enforce_sorted=False)
-        ula, (h, _) = self.lstm(x)
+        ula, (h, _) = self.lstm(packed_x)
         # Output and hidden state
         out = h[-1]  # Take the last output for prediction
         x = self.fc1(out)
diff --git a/ml4cc/models/transformer.py b/ml4cc/models/transformer.py
index 2d8929d..d190765 100644
--- a/ml4cc/models/transformer.py
+++ b/ml4cc/models/transformer.py
@@ -23,7 +23,7 @@ def forward(self, x):
 class WaveFormTransformer(nn.Module):
     def __init__(
         self,
-        input_dim: int,  # 1024 or 3000
+        input_dim: int,  # 1 or 15
         d_model: int,  # 512
         num_heads: int,  # 16
         num_layers: int,  # 3
@@ -37,20 +37,24 @@ def __init__(
         self.positional_encoding = PositionalEncoding(d_model, max_len)
 
         encoder_layer = nn.TransformerEncoderLayer(
-            d_model=d_model, nhead=num_heads, dim_feedforward=hidden_dim, dropout=dropout
+            d_model=d_model, nhead=num_heads, dim_feedforward=hidden_dim, dropout=dropout, batch_first=True
         )
         self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
 
         self.peak_finding_classifier = nn.Linear(d_model, num_classes)
         self.layernorm = nn.LayerNorm(d_model)
 
-    def forward(self, x):
+    def forward(self, x, mask):
         mean = x.mean(dim=1, keepdim=True)
         std = x.std(dim=1, keepdim=True)
+        if mask is not None:
+            # Make sure mask is bool and of shape [batch_size, seq_len]
+            # Transformer expects True where the token is **ignored**
+            mask = mask.bool()
         x = (x - mean) / (std + 1e-6)
         x = self.input_projection(x)
         x = self.positional_encoding(x)
-        x = self.transformer_encoder(x)
+        x = self.transformer_encoder(x, src_key_padding_mask=mask)
         # x = self.layernorm(x)
         # Shape: [batch_size, seq_length, num_classes]
         x = self.peak_finding_classifier(x)
@@ -107,10 +111,8 @@ def test_step(self, batch, batch_idx):
         return predicted_labels
 
     def forward(self, batch):
-        waveform, target = batch
-        predicted_labels = self.transformer(waveform).squeeze()
-        print("PREDICTED:", predicted_labels)
-        print("TARGET:", target)
+        waveform, target, mask = batch
+        predicted_labels = self.transformer(waveform, mask).squeeze()
         return predicted_labels, target
 
     def on_after_backward(self):
diff --git a/ml4cc/notebooks/Compare_algorithms.ipynb b/ml4cc/notebooks/Compare_algorithms.ipynb
new file mode 100644
index 0000000..320e70e
--- /dev/null
+++ b/ml4cc/notebooks/Compare_algorithms.ipynb
@@ -0,0 +1,198 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a4276c20-c0ef-4ba2-8533-c2f94f726e54",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import json\n",
+    "from hydra import compose, initialize\n",
+    "from omegaconf import OmegaConf, DictConfig\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "from ml4cc.tools.evaluation import general as g\n",
+    "from ml4cc.tools.visualization import losses as l\n",
+    "from ml4cc.tools.visualization import regression as rv\n",
+    "from ml4cc.tools.visualization import classification as cv\n",
+    "\n",
+    "with initialize(version_base=None, config_path=\"../config\", job_name=\"test_app\"):\n",
+    "    cfg = compose(config_name=\"main\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "92770d27-1beb-4ac6-8f19-c36d6a242148",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "CLASSIFICATION_TRAININGS = {\n",
+    "    \"two_step_minimal\": \"/home/laurits/ml4cc/training-outputs/20250622_FCC_twostep_minimal/two_step_minimal/\",\n",
+    "    \"two_step_pf\": \"/home/laurits/ml4cc/training-outputs/20250620_FCC_twostep_masked/two_step_pf/\",\n",
+    "    # \"two_step_pf_masked\": \"/home/laurits/ml4cc/training-outputs/20250620_FCC_twostep_masked/two_step_pf/\",\n",
+    "    # \"two_step_pf\": \"/home/laurits/ml4cc/training-outputs/20250618_FCC_twostep/two_step_pf/\"\n",
+    "}\n",
+    "\n",
+    "REGRESSION_TRAININGS = {\n",
+    "    \"one_step\": \"/home/laurits/ml4cc/training-outputs/20250622_FCC_onestep/one_step/\",\n",
+    "    \"two_step_minimal\": \"/home/laurits/ml4cc/training-outputs/20250622_FCC_twostep_minimal/two_step_minimal/\",\n",
+    "    \"two_step_DNN\": \"/home/laurits/ml4cc/training-outputs/20250630_FCC_twostep_clusterization_DNN/two_step_cl\",\n",
+    "    \"two_step_RNN\": \"/home/laurits/ml4cc/training-outputs/20250630_FCC_twostep_clusterization_RNN/two_step_cl\",\n",
+    "    \"two_step_CNN\": \"/home/laurits/ml4cc/training-outputs/20250630_FCC_twostep_clusterization_CNN/two_step_cl\",\n",
+    "    # Should add here also the clusterization trainings\n",
+    "}\n",
+    "\n",
+    "NAME_MAPPING = {\n",
+    "    \"two_step_minimal\": r\"$LSTM_{primary}$\",\n",
+    "    \"two_step_pf\": r\"$LSTM^{PF}_{both}$\",\n",
+    "    \"one_step\": r\"$TransformerEncoder^{one-step}$\",\n",
+    "    \"two_step_DNN\": r\"$LSTM^{PF} + DNN^{CL}$\",\n",
+    "    \"two_step_RNN\": r\"$LSTM^{PF} + RNN^{CL}$\",\n",
+    "    \"two_step_CNN\": r\"$LSTM^{PF} + CNN^{CL}$\",\n",
+    "}\n",
+    "    \n",
+    "RESULTS_DIR = \"/home/laurits/tmp/results\"\n",
+    "os.makedirs(RESULTS_DIR, exist_ok=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "740a88ea-3619-471a-85b1-fb536473dffd",
+   "metadata": {},
+   "source": [
+    "# Classification"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "d6e0fd68-840e-479a-b9a2-b6cec1de40dd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Comparing ROC, AUC, etc.\n",
+    "\n",
+    "loss_results = {}\n",
+    "for algo, training_dir in CLASSIFICATION_TRAININGS.items():\n",
+    "    metrics_path = os.path.join(training_dir, \"logs/metrics.csv\")\n",
+    "    losses = g.filter_losses(metrics_path=metrics_path)\n",
+    "    loss_results[algo] = losses\n",
+    "losses_output_path = os.path.join(RESULTS_DIR, \"BCE_losses.png\")\n",
+    "lp = l.LossesMultiPlot(loss_name=\"BCE\", plot_train_losses=True, x_max=-1, name_mapping=NAME_MAPPING)\n",
+    "lp.plot_algorithms(results=loss_results, output_path=losses_output_path)\n",
+    "\n",
+    "\n",
+    "all_results = {}\n",
+    "loss_results_cls = {}\n",
+    "for algo, training_dir in CLASSIFICATION_TRAININGS.items():\n",
+    "    results_path = os.path.join(training_dir, \"results/results.json\")\n",
+    "    metrics_path = os.path.join(training_dir, \"logs/metrics.csv\")\n",
+    "    all_results[algo] = {}\n",
+    "    best_loss = np.min(g.filter_losses(metrics_path)[\"val_loss\"])\n",
+    "    loss_results_cls[algo] = {\"best_losses\": [best_loss]}\n",
+    "    with open(results_path, 'rt') as in_file:\n",
+    "        results = json.load(in_file)\n",
+    "        for pid in results.keys():\n",
+    "            all_results[algo][pid] = results[pid][\"global\"]\n",
+    "\n",
+    "lsp = l.LossesStackPlot(loss_name=\"BCE\", name_mapping=NAME_MAPPING)\n",
+    "lsp_output_path = os.path.join(RESULTS_DIR, \"cls_loss_stack.png\")\n",
+    "lsp.plot_algorithms(loss_results_cls, lsp_output_path)\n",
+    "\n",
+    "lsp2 = l.LossesStackPlot2(loss_name=\"BCE\", name_mapping=NAME_MAPPING)\n",
+    "lsp_output_path2 = os.path.join(RESULTS_DIR, \"cls_loss_stack2.png\")\n",
+    "lsp2.plot_algorithms(loss_results_cls, lsp_output_path2)\n",
+    "\n",
+    "asp = cv.AUCStackPlot(name_mapping=NAME_MAPPING)\n",
+    "asp_output_path = os.path.join(RESULTS_DIR, \"AUC_stack.png\")\n",
+    "asp.plot_algorithms(all_results, asp_output_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2d75cac-5cab-4a41-8ab5-33e26f369fce",
+   "metadata": {},
+   "source": [
+    "# Regression"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "d774531b-7939-44f1-a3c7-3c36fa0e6174",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loss_results = {}\n",
+    "for algo, training_dir in REGRESSION_TRAININGS.items():\n",
+    "    if not algo == \"two_step_minimal\":\n",
+    "        metrics_path = os.path.join(training_dir, \"logs/metrics.csv\")\n",
+    "        losses = g.filter_losses(metrics_path=metrics_path)\n",
+    "        loss_results[algo] = losses\n",
+    "lp = l.LossesMultiPlot(loss_name=\"MSE\", plot_train_losses=True, x_max=-1, name_mapping=NAME_MAPPING)\n",
+    "losses_output_path = os.path.join(RESULTS_DIR, \"MSE_losses.png\")\n",
+    "lp.plot_algorithms(results=loss_results, output_path=losses_output_path)\n",
+    "\n",
+    "# Comparing the resolution\n",
+    "all_results = {}\n",
+    "loss_results_reg = {}\n",
+    "for algo, training_dir in REGRESSION_TRAININGS.items():\n",
+    "    results_path = os.path.join(training_dir, \"results/results.json\")\n",
+    "    metrics_path = os.path.join(training_dir, \"logs/metrics.csv\")\n",
+    "    all_results[algo] = {}\n",
+    "    if not algo == \"two_step_minimal\":\n",
+    "        best_loss = np.min(g.filter_losses(metrics_path)[\"val_loss\"])\n",
+    "        loss_results_reg[algo] = {\"best_losses\": [best_loss]}\n",
+    "    with open(results_path, 'rt') as in_file:\n",
+    "        results = json.load(in_file)\n",
+    "        for pid in results.keys():\n",
+    "            all_results[algo][pid] = results[pid][\"global\"]\n",
+    "\n",
+    "rsp = rv.RegressionStackPlot(name_mapping=NAME_MAPPING)\n",
+    "rsp_output_path = os.path.join(RESULTS_DIR, \"resolution_stack.png\")\n",
+    "rsp.plot_algorithms(all_results, rsp_output_path)\n",
+    "\n",
+    "lsp = l.LossesStackPlot(loss_name=\"MSE\", name_mapping=NAME_MAPPING)\n",
+    "lsp_output_path = os.path.join(RESULTS_DIR, \"regression_loss_stack.png\")\n",
+    "lsp.plot_algorithms(loss_results_reg, lsp_output_path)\n",
+    "\n",
+    "lsp2 = l.LossesStackPlot2(loss_name=\"MSE\", name_mapping=NAME_MAPPING)\n",
+    "lsp2_output_path = os.path.join(RESULTS_DIR, \"regression_loss_stack2.png\")\n",
+    "lsp2.plot_algorithms(loss_results_reg, lsp2_output_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a6ee7cb1-a8ea-4a22-a867-12765e67fb0a",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/ml4cc/notebooks/Losses_eval.ipynb b/ml4cc/notebooks/Losses_eval.ipynb
deleted file mode 100644
index ef98a48..0000000
--- a/ml4cc/notebooks/Losses_eval.ipynb
+++ /dev/null
@@ -1,143 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "25cfb393-219c-4845-8df7-942cf2f39b4f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "import mplhep as hep\n",
-    "hep.style.use(hep.styles.CMS)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "c2230112-a866-4b29-85e2-bd3b94cd2469",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# d = pd.read_csv('/home/laurits/ml4cc/training-outputs/20250103_FCC_350_epoch/logs/peakFinding/version_0/metrics.csv')\n",
-    "d = pd.read_csv('/home/laurits/ml4cc/training-outputs/20250109_CEPC_150_epoch/logs/peakFinding/version_0/metrics.csv')\n",
-    "# d = pd.read_csv('/home/laurits/ml4cc/training-outputs/20250102_CEPC_peakFinding//logs/peakFinding/version_0/metrics.csv')\n",
-    "d2 = pd.read_csv('/home/laurits/ml4cc/training-outputs/20250103_FCC_350_epoch/logs/peakFinding/version_0/metrics.csv')\n",
-    "# /home/laurits/ml4cc/training-outputs/20250109_CEPC_150_epoch/logs"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "b54ca8b9-919e-403f-a07d-59c7976065a7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "val_loss = np.array(d['val_loss'])\n",
-    "val_loss2 = np.array(d2['val_loss'])\n",
-    "# train_loss = np.array(d['train_loss'])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "be008804-c6a7-4e43-8473-25492a5f1a73",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "val_loss = val_loss[~np.isnan(val_loss)]\n",
-    "val_loss2 = val_loss2[~np.isnan(val_loss2)]\n",
-    "# train_loss = train_loss[~np.isnan(train_loss)]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "6042fbdd-2377-4272-822f-d405122e4bf6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "min_idx = np.argmin(val_loss)\n",
-    "min_loss = val_loss[min_idx]\n",
-    "min_epoch = np.arange(len(val_loss))[min_idx]\n",
-    "\n",
-    "min_idx2 = np.argmin(val_loss2)\n",
-    "min_loss2 = val_loss2[min_idx2]\n",
-    "min_epoch2 = np.arange(len(val_loss2))[min_idx2]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "b927c011-1d25-4c81-8814-fa80066ec28e",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(0.0, 350.0)"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1000x1000 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# plt.scatter(np.arange(len(val_loss)), val_loss, label=\"val_loss [Adam]\", color='blue')\n",
-    "# plt.plot(train_loss, label=\"train_loss [Adam]\", ls=\"--\", color='r')\n",
-    "plt.plot(val_loss, label=\"val_loss [AdamW]\", ls=\"--\", color='b')\n",
-    "plt.plot(val_loss2, label=\"val_loss2 [AdamW]\", ls=\"--\", color='r')\n",
-    "plt.scatter(min_epoch2, min_loss2, color='r')\n",
-    "plt.scatter(min_epoch, min_loss, color='b')\n",
-    "plt.legend()\n",
-    "plt.yscale('log')\n",
-    "plt.grid()\n",
-    "plt.ylabel('MSE loss [a.u.]')\n",
-    "plt.xlabel('epoch')\n",
-    "plt.xlim(0, 350)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e19f6b0c-dbb7-4894-b052-b33097d25063",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "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.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/ml4cc/notebooks/clusterization_eval.ipynb b/ml4cc/notebooks/clusterization_eval.ipynb
deleted file mode 100644
index 5b42f2a..0000000
--- a/ml4cc/notebooks/clusterization_eval.ipynb
+++ /dev/null
@@ -1,93 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "852fff3d-c892-47d4-879f-6be783d02aa8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import hydra\n",
-    "with initialize(version_base=None, config_path=\"../config\", job_name=\"test_app\"):\n",
-    "    cfg = compose(config_name=\"training\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "65addf8b-859b-416f-8095-ebc4ebfafb4b",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f58ece5a-87d4-4e3a-b888-cce844b089cf",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# CEPC: Evaluate clusterization for different particle types"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ff5462b9-92dd-4b4a-b3f3-82ad34ab85f2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "CEPC_model_path = \"foobar\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "29270167-4eb3-46e5-b7b9-c603e2b85dfd",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "54ef3c06-40cd-435e-b068-16755c8968dc",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# FCC: Evaluate clusterization for different energies/pT\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b7541a14-2b95-4b7b-b0c3-e2db92e5ba77",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "FCC_model_path = \"foobar\"\n"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "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.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/ml4cc/notebooks/peakFinding_eval.ipynb b/ml4cc/notebooks/peakFinding_eval.ipynb
deleted file mode 100644
index 9d4234f..0000000
--- a/ml4cc/notebooks/peakFinding_eval.ipynb
+++ /dev/null
@@ -1,628 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "54ef3c06-40cd-435e-b068-16755c8968dc",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/opt/conda/lib/python3.11/site-packages/onnxscript/converter.py:820: FutureWarning: 'onnxscript.values.Op.param_schemas' is deprecated in version 0.1 and will be removed in the future. Please use '.op_signature' instead.\n",
-      "  param_schemas = callee.param_schemas()\n",
-      "/opt/conda/lib/python3.11/site-packages/onnxscript/converter.py:820: FutureWarning: 'onnxscript.values.OnnxFunction.param_schemas' is deprecated in version 0.1 and will be removed in the future. Please use '.op_signature' instead.\n",
-      "  param_schemas = callee.param_schemas()\n"
-     ]
-    }
-   ],
-   "source": [
-    "# imports\n",
-    "import os\n",
-    "import hydra\n",
-    "from hydra import compose, initialize\n",
-    "from omegaconf import OmegaConf\n",
-    "from torch.utils.data import DataLoader\n",
-    "from ml4cc.models import LSTM\n",
-    "from ml4cc.tools.evaluation import peakFinding as pf\n",
-    "from ml4cc.data.FCC import dataloader as fdl\n",
-    "from ml4cc.data.CEPC import dataloader as cdl"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "56a3a365-15d7-4167-8e54-f7b1f7274b5a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "with initialize(version_base=None, config_path=\"../config\", job_name=\"test_app\"):\n",
-    "    cfg = compose(config_name=\"training\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "63184a9f-96ce-47a3-81da-bf0d015b6e18",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "32734da5-8a56-47b6-97d0-84fd273691e7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# FCC eval:\n",
-    "FCC_RESULT_OUTPUT_DIR = \"/home/laurits/tmp/20250107_FCC_peakFinding_350_epoch/\"\n",
-    "os.makedirs(FCC_RESULT_OUTPUT_DIR, exist_ok=True)\n",
-    "FCC_BEST_MODEL_PATH = \"/home/laurits/ml4cc/training-outputs/20250103_FCC_350_epoch/models/peakFinding-epoch=218-val_loss=0.02.ckpt\"\n",
-    "FCC_METRICS_PATH = \"/home/laurits/ml4cc/training-outputs/20250103_FCC_350_epoch/logs/peakFinding/version_0/metrics.csv\"\n",
-    "\n",
-    "model = LSTM.LSTMModule.load_from_checkpoint(FCC_BEST_MODEL_PATH, weights_only=True)\n",
-    "model.eval()\n",
-    "\n",
-    "FCC_ENERGIES = [2, 4, 6, 8, 10, 165, 180]\n",
-    "FCC_BASE_TEST_DIR = \"/scratch/persistent/laurits/ml4cc/FCC/preprocessed_data/test/\"\n",
-    "\n",
-    "for energy in FCC_ENERGIES:\n",
-    "    data_path = os.path.join(FCC_BASE_TEST_DIR, f\"{energy}_1.parquet\")\n",
-    "    test_dataset = fdl.IterableFCCDataset(\n",
-    "        data_path=data_path,\n",
-    "        cfg=cfg,\n",
-    "        dataset_type=\"test\",\n",
-    "    )\n",
-    "    output_dir = os.path.join(FCC_RESULT_OUTPUT_DIR, str(energy))\n",
-    "    os.makedirs(output_dir, exist_ok=True)\n",
-    "    test_loader = DataLoader(test_dataset, batch_size=80)\n",
-    "    pf.evaluate_training(\n",
-    "        model=model,\n",
-    "        dataloader=test_loader,\n",
-    "        metrics_path=FCC_METRICS_PATH,\n",
-    "        cfg=cfg,\n",
-    "        output_dir=output_dir\n",
-    "    )"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "84aef805-691d-4637-bcd2-dc57d2749c47",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import awkward as ak\n",
-    "import matplotlib\n",
-    "import boost_histogram as bh\n",
-    "import matplotlib.pyplot as plt\n",
-    "import numpy as np\n",
-    "import mplhep as hep"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "e8d772de-9b29-4887-8f31-a1c8d594f576",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def to_bh(data, bins, cumulative=False):\n",
-    "    h1 = bh.Histogram(bh.axis.Variable(bins))\n",
-    "    h1.fill(data)\n",
-    "    if cumulative:\n",
-    "        h1[:] = np.sum(h1.values()) - np.cumsum(h1)\n",
-    "    return h1\n",
-    "\n",
-    "def plot_histograms(num_true_peaks, num_pred_peaks, output_path):\n",
-    "    bins = np.linspace(0, 40, 20)\n",
-    "    plt.hist(num_true_peaks, bins=bins, histtype='step', hatch='//', label='true')\n",
-    "    plt.hist(num_pred_peaks, bins=bins, histtype='step', hatch='\\\\', label='pred')\n",
-    "    plt.legend()\n",
-    "    plt.grid()\n",
-    "    plt.ylabel('Number entrier / bin')\n",
-    "    plt.xlabel('Number peaks')\n",
-    "    plt.savefig(output_path, bbox_inches='tight')\n",
-    "    plt.close('all')\n",
-    "\n",
-    "def plot_ratios(ratios, output_path):\n",
-    "    bins = np.linspace(0.5, 1.5, 15)\n",
-    "    hep.histplot(to_bh(ratios, bins=bins), density=True)\n",
-    "    plt.grid()\n",
-    "    plt.ylabel('Number entrier / bin')\n",
-    "    plt.xlabel('#predicted peaks / #generated peaks')\n",
-    "    plt.savefig(output_path, bbox_inches='tight')\n",
-    "    plt.close('all')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "06b59a43-e320-4d10-940f-680c3a63f231",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Count the number of true and detected primary clusters after the peak finding\n",
-    "for energy in FCC_ENERGIES:\n",
-    "    pred_path = os.path.join(FCC_RESULT_OUTPUT_DIR, str(energy), \"predictions.parquet\")\n",
-    "    data = ak.from_parquet(pred_path)\n",
-    "    pred = data.detected_peaks\n",
-    "    true = data.target\n",
-    "    num_true_peaks = ak.sum(true == 1, axis=-1)\n",
-    "    num_pred_peaks = ak.sum(pred == 1, axis=-1)\n",
-    "    ratios = num_pred_peaks / num_true_peaks\n",
-    "    histo_output_path = os.path.join(FCC_RESULT_OUTPUT_DIR, str(energy), \"pred_true_distributions.png\")\n",
-    "    plot_histograms(num_true_peaks, num_pred_peaks, histo_output_path)\n",
-    "    ratio_output_path = os.path.join(FCC_RESULT_OUTPUT_DIR, str(energy), \"pred_true_ratio_distribution.png\")\n",
-    "    plot_ratios(ratios, ratio_output_path)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "62c4e24e-217d-45c7-b357-b74e1d5afbc5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "results_auc = {\n",
-    "    2: 0.9876,\n",
-    "    4: 0.9889,\n",
-    "    6: 0.9886,\n",
-    "    8: 0.9891,\n",
-    "    10: 0.9890,\n",
-    "    165: 0.9889,\n",
-    "    180: 0.9888\n",
-    "}\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "5ba5f47a-cafc-402a-a219-9805b006cafc",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "import mplhep as hep\n",
-    "hep.style.use(hep.styles.CMS)\n",
-    "\n",
-    "def plot_performances(performances: dict, mean: int = None):\n",
-    "    if mean is None:\n",
-    "        mean = np.mean(list(performances.values()))\n",
-    "    fig, ax = plt.subplots()\n",
-    "    labels = [f\"{i} GeV\" for i in list(performances.keys())]\n",
-    "    x_values = np.arange(len(performances.values()))\n",
-    "    auc_values = np.array(list(performances.values()))\n",
-    "\n",
-    "    ax.set_xticks(np.arange(len(performances.values())))\n",
-    "    ax.set_xticklabels(labels)\n",
-    "    plt.xticks(rotation=90)\n",
-    "    \n",
-    "    lower_than_average_mask = auc_values < mean\n",
-    "    for value, loc in zip(auc_values[lower_than_average_mask], x_values[lower_than_average_mask]):\n",
-    "        plt.vlines(loc, ymin=value, ymax=mean, color='red', ls='--')\n",
-    "    for value, loc in zip(auc_values[~lower_than_average_mask], x_values[~lower_than_average_mask]):\n",
-    "        plt.vlines(loc, ymin=mean, ymax=value, color='green', ls='--')\n",
-    "    plt.scatter(x_values[lower_than_average_mask], auc_values[lower_than_average_mask], color='red', s=80)\n",
-    "    plt.scatter(x_values[~lower_than_average_mask], auc_values[~lower_than_average_mask], color='green', s=80)\n",
-    "    plt.axhline(mean, xmin=0, xmax=len(results_auc.values()), ls='--', color='k')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8c053615-9534-4d0f-ae05-1f08fb413900",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "plot_performances(results_auc)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "daeca816-3127-4bba-9251-272c713a3201",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Evaluate best model before training end\n",
-    "test_data_path = os.path.join(FCC_BASE_TEST_DIR, \"*\")\n",
-    "full_test_dataset = fdl.IterableFCCDataset(\n",
-    "    data_path=test_data_path,\n",
-    "    cfg=cfg,\n",
-    "    dataset_type=\"test\",\n",
-    ")\n",
-    "os.makedirs('/home/laurits/tmp/full_test_eval', exist_ok=True)\n",
-    "full_test_loader = DataLoader(full_test_dataset, batch_size=80)\n",
-    "pf.evaluate_training(\n",
-    "    model=model,\n",
-    "    dataloader=full_test_loader,\n",
-    "    metrics_path=FCC_METRICS_PATH,\n",
-    "    cfg=cfg,\n",
-    "    output_dir='/home/laurits/tmp/full_test_eval'\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3fb19906-3127-4326-a291-1e9246015237",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Load predictions\n",
-    "full_test_pred_data = ak.from_parquet(\"/home/laurits/tmp/full_test_eval/predictions.parquet\")\n",
-    "predicted_peak_count = ak.sum(full_test_pred_data.detected_peaks == 1, axis=-1)\n",
-    "true_peak_count = ak.sum(full_test_pred_data.target == 1, axis=-1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b14eee55-bb34-4fec-beab-908e2ebafe6d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "bins = np.linspace(0, 25, num=25)\n",
-    "plt.hist(predicted_peak_count, bins=bins, histtype='step', label=\"Pred count\")\n",
-    "plt.hist(true_peak_count, bins=bins, histtype='step', label=\"True count\")\n",
-    "plt.legend()\n",
-    "plt.xlabel(\"Number of primary peaks\")\n",
-    "plt.ylabel(\"Count /bin\")\n",
-    "plt.grid()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e0f77ade-f766-4300-8485-86f9926db24c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Calculate resolutions\n",
-    "ratios = predicted_peak_count / true_peak_count\n",
-    "\n",
-    "ratio_bins = np.linspace(0.5, 1.5, num=16)\n",
-    "n = plt.hist(ratios, bins=ratio_bins, density=True, histtype='step')[0]\n",
-    "plt.xlabel(\"#predicted / #true\")\n",
-    "plt.ylabel(\"Count /bin\")\n",
-    "plt.grid()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "5c050ed9-6097-4e8d-bc71-77cf1ebc40f4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def IQR(ratios: np.array) -> np.array:\n",
-    "    return np.quantile(ratios, 0.75) - np.quantile(ratios, 0.25)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c23f127a-b616-4581-bf4c-5c5a7ff6e62b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "median = np.median(ratios)\n",
-    "IQR_ = IQR(ratios)\n",
-    "weighted_IQR = IQR_ / median\n",
-    "\n",
-    "print(f\"IQR: {IQR_:.3f} \\t Median: {median:.3f} \\t Resolution: {weighted_IQR:.3f}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "332a1b79-6886-4b82-95b4-76f9ee8781c0",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "There are 500,000 waveforms in the test dataset.\n",
-      "Each waveform will be split into sliding windows of size 15\n",
-      "Prediction progress for TEST dataset\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 500000/500000 [6:02:08<00:00, 23.01it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Saving 500000 processed entries to /home/laurits/tmp/20250117_CEPC_peakFinding/predictions.parquet\n"
-     ]
-    }
-   ],
-   "source": [
-    "# # CEPC eval:\n",
-    "CEPC_RESULT_OUTPUT_DIR = \"/home/laurits/tmp/20250117_CEPC_peakFinding/\"\n",
-    "os.makedirs(CEPC_RESULT_OUTPUT_DIR, exist_ok=True)\n",
-    "CEPC_BEST_MODEL_PATH = \"/home/laurits/ml4cc/training-outputs/20250109_CEPC_150_epoch/models/peakFinding-epoch=76-val_loss=0.02.ckpt\"\n",
-    "CEPC_METRICS_PATH = \"/home/laurits/ml4cc/training-outputs/20250109_CEPC_150_epoch/logs/peakFinding/version_0/metrics.csv\"\n",
-    "\n",
-    "model = LSTM.LSTMModule.load_from_checkpoint(CEPC_BEST_MODEL_PATH, weights_only=True)\n",
-    "model.eval()\n",
-    "\n",
-    "CEPC_BASE_TEST_DIR = \"/scratch/persistent/laurits/ml4cc/CEPC/preprocessed_data/peakFinding/test/\"\n",
-    "\n",
-    "data_path = os.path.join(CEPC_BASE_TEST_DIR, \"*\")\n",
-    "dataset = cdl.CEPCDataset(data_path=data_path)\n",
-    "test_dataset = cdl.IterableCEPCDataset(\n",
-    "    dataset=dataset,\n",
-    "    cfg=cfg,\n",
-    "    dataset_type=\"test\",\n",
-    ")\n",
-    "test_loader = DataLoader(test_dataset, batch_size=200)\n",
-    "pf.evaluate_training(\n",
-    "    model=model,\n",
-    "    dataloader=test_loader,\n",
-    "    metrics_path=CEPC_METRICS_PATH,\n",
-    "    cfg=cfg,\n",
-    "    output_dir=CEPC_RESULT_OUTPUT_DIR\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "cf6d12e9-9188-4dde-be4b-7c1350fbcccd",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "cepc_pred_path = os.path.join(CEPC_RESULT_OUTPUT_DIR, \"predictions.parquet\")\n",
-    "cepc_data = ak.from_parquet(cepc_pred_path)\n",
-    "cepc_pred = cepc_data.detected_peaks\n",
-    "cepc_true = cepc_data.target\n",
-    "cepc_true_peaks = ak.sum(cepc_true == 1, axis=-1)\n",
-    "cepc_num_pred_peaks = ak.sum(cepc_pred == 1, axis=-1)\n",
-    "cepc_ratios = cepc_num_pred_peaks / cepc_true_peaks\n",
-    "cepc_histo_output_path = os.path.join(CEPC_RESULT_OUTPUT_DIR, \"true_pred_distributions.png\")\n",
-    "plot_histograms(cepc_true_peaks, cepc_num_pred_peaks, cepc_histo_output_path)\n",
-    "ratio_output_path = os.path.join(CEPC_RESULT_OUTPUT_DIR, \"true_pred_ratio_distribution.png\")\n",
-    "plot_ratios(cepc_ratios, ratio_output_path)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "37cc74d9-9c87-4160-ac1e-dc6a826b58c9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Load predictions\n",
-    "cepc_full_test_pred_data = ak.from_parquet(\"/home/laurits/tmp/20250113_CEPC_peakFinding/predictions.parquet\")\n",
-    "cepc_predicted_peak_count = ak.sum(cepc_full_test_pred_data.detected_peaks == 1, axis=-1)\n",
-    "cepc_true_peak_count = ak.sum(cepc_full_test_pred_data.target == 1, axis=-1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "56dc931b-63fc-4010-afcf-8123b1a21d92",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1000x1000 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "bins = np.linspace(5, 50, num=45)\n",
-    "plt.hist(cepc_predicted_peak_count, bins=bins, histtype='step', label=\"Pred count\")\n",
-    "plt.hist(cepc_true_peak_count, bins=bins, histtype='step', label=\"True count\")\n",
-    "plt.legend()\n",
-    "plt.xlabel(\"Number of primary peaks\")\n",
-    "plt.ylabel(\"Count /bin\")\n",
-    "plt.grid()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "64afaf11-4a4c-4e86-811b-4deb60486893",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1000x1000 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Calculate resolutions\n",
-    "cepc_ratios = cepc_predicted_peak_count / cepc_true_peak_count\n",
-    "\n",
-    "ratio_bins = np.linspace(0.5, 1.5, num=16)\n",
-    "n = plt.hist(cepc_ratios, bins=ratio_bins, histtype='step', density=True)[0]\n",
-    "plt.xlabel(\"#predicted / #true\")\n",
-    "plt.ylabel(\"Count /bin\")\n",
-    "plt.grid()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "59bba157-2b11-474d-9dca-56d9653bf328",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "IQR: 0.151 \t Median: 0.966 \t Resolution: 0.156\n"
-     ]
-    }
-   ],
-   "source": [
-    "cepc_median = np.median(cepc_ratios)\n",
-    "cepc_IQR_ = IQR(cepc_ratios)\n",
-    "cepc_weighted_IQR = cepc_IQR_ / cepc_median\n",
-    "\n",
-    "print(f\"IQR: {cepc_IQR_:.3f} \\t Median: {cepc_median:.3f} \\t Resolution: {cepc_weighted_IQR:.3f}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6152fd96-1014-4ec8-88eb-a33fad0e6482",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from ml4cc.tools.visualization.waveform import plot_waveform\n",
-    "from ml4cc.tools.data import io"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3e6b01a4-6014-4aee-bf8e-e910a7d6a847",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "root_data = io.load_root_file(\"/scratch/persistent/laurits/ml4cc/CEPC/data/peakFinding/train/signal_noise05_PFtrain_0.root\")\n",
-    "data = ak.from_parquet('/home/laurits/ml4cc/training-outputs/20250103_FCC_350_epoch/predictions.parquet')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f838e360-ab16-43bf-9d1c-e1c5773db833",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "i=2\n",
-    "pred = data.detected_peaks[i]\n",
-    "target = data.target[i]\n",
-    "wf = data.waveform[i]\n",
-    "x_peaks_true = np.arange(len(target))[target == 1]\n",
-    "x_peaks_pred = np.arange(len(pred))[target == 1]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d4ada426-66da-448d-a58a-90e446033012",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "fig, ax = plot_waveform(wf)\n",
-    "for i, peak in enumerate(x_peaks_true):\n",
-    "    if i == 0:\n",
-    "        label = \"True peak\"\n",
-    "    else:\n",
-    "        label = \"\"\n",
-    "    ax.axvline(peak, ls=\"-\", color='k', label=label)\n",
-    "for i, peak in enumerate(x_peaks_pred):\n",
-    "    if i == 0:\n",
-    "        label = 'Pred peak'\n",
-    "    else:\n",
-    "        label = \"\"\n",
-    "    ax.axvline(peak, ls=\"--\", color='r', label=label)\n",
-    "plt.legend()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "1a11f419-8c1e-4715-95e9-b32b62d665c7",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ccb10e0a-cb6c-456c-84ae-3e3d118ad4cf",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "root_data.fields"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "7c7a0f52-1035-4143-9a64-8827daaef37d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "wf_i = root_data.wf_i[0]\n",
-    "tag = root_data.tag[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f08b5f2a-53da-4078-821f-9ee5ec50ed13",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "tag[tag == 2]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cea83905-7397-4a9c-a94b-d71974b93339",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "plot_waveform(wf_i)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "948f8870-b98d-4456-b63a-011ada1660dc",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "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.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/ml4cc/scripts/train.py b/ml4cc/scripts/train.py
index d507d9c..4036d1e 100644
--- a/ml4cc/scripts/train.py
+++ b/ml4cc/scripts/train.py
@@ -158,11 +158,15 @@ def get_FCC_evaluation_scenarios(cfg: DictConfig) -> list:
     return evaluation_scenarios
 
 
-def save_predictions(input_path: str, all_predictions: ak.Array, cfg: DictConfig, scenario: str):
+def save_predictions(input_path: str, all_predictions: ak.Array, all_targets: ak.Array, cfg: DictConfig, scenario: str):
+    additional_dirs = ["two_step_pf", "two_step_cl"]
     if not scenario == "two_step_cl":
         predictions_dir = cfg.training.predictions_dir
-        base_scenario = "two_step" if "two_step" in scenario else scenario
-        additional_dir_level = scenario if base_scenario == "two_step" else ""
+        print("prediction_dir:", predictions_dir)
+        base_scenario = (
+            "two_step" if "two_step" in scenario else "two_step"
+        )  # Temporary, as atm also one-step-windowed uses two-step ntuples
+        additional_dir_level = scenario if scenario in additional_dirs else ""
         base_dir = cfg.dataset.data_dir
         original_dir = os.path.join(base_dir, base_scenario)
         predictions_dir = os.path.join(predictions_dir, additional_dir_level)
@@ -175,6 +179,7 @@ def save_predictions(input_path: str, all_predictions: ak.Array, cfg: DictConfig
     input_data = ak.from_parquet(input_path)
     output_data = ak.copy(input_data)
     output_data["pred"] = ak.Array(all_predictions)  # pylint: disable=E1137
+    output_data["pad_targets"] = ak.Array(all_targets)  # pylint: disable=E1137
     print(f"Saving predictions to {output_path}")
     os.makedirs(os.path.dirname(output_path), exist_ok=True)
     ak.to_parquet(output_data, output_path, row_group_size=cfg.preprocessing.row_group_size)
@@ -182,8 +187,11 @@ def save_predictions(input_path: str, all_predictions: ak.Array, cfg: DictConfig
 
 def create_prediction_files(file_list: list, iterable_dataset: IterableDataset, model, cfg: DictConfig, scenario: str):
     num_files = 2 if cfg.training.debug_run else None
+    print("Creating prediction files")
+    print("file list", file_list)
     with torch.no_grad():
         for path in file_list[:num_files]:
+            print("Processing path: ", path)
             dataset = dl.RowGroupDataset(path)
             iterable_dataset_ = iterable_dataset(dataset, device=DEVICE, cfg=cfg)
             dataloader = DataLoader(
@@ -193,25 +201,30 @@ def create_prediction_files(file_list: list, iterable_dataset: IterableDataset,
                 # prefetch_factor=cfg.training.dataloader.prefetch_factor,
             )
             all_predictions = []
+            all_targets = []
             for i, batch in enumerate(dataloader):
-                predictions, _ = model(batch)
+                predictions, targets = model(batch)
 
                 all_predictions.append(predictions.detach().cpu().numpy())
+                all_targets.append(targets.detach().cpu().numpy())
             all_predictions = ak.concatenate(all_predictions, axis=0)
-            save_predictions(input_path=path, all_predictions=all_predictions, cfg=cfg, scenario=scenario)
+            all_targets = ak.concatenate(all_targets, axis=0)
+            save_predictions(
+                input_path=path, all_predictions=all_predictions, all_targets=all_targets, cfg=cfg, scenario=scenario
+            )
 
 
 def evaluate_one_step(cfg: DictConfig, model, metrics_path: str) -> list:
     model.to(DEVICE)
     model.eval()
     dir_ = "*" if cfg.evaluation.training.eval_all else "test"
-    wcp_path = os.path.join(cfg.dataset.data_dir, "one_step", dir_, "*")
+    wcp_path = os.path.join(cfg.dataset.data_dir, "two_step", dir_, "*")
     file_list = glob.glob(wcp_path)
     # iterable_dataset = dl.OneStepIterableDataset
     iterable_dataset = dl.OneStepWindowedIterableDataset
 
     # Create prediction files
-    create_prediction_files(file_list, iterable_dataset=iterable_dataset, model=model, cfg=cfg, scenario="one_step")
+    # create_prediction_files(file_list, iterable_dataset=iterable_dataset, model=model, cfg=cfg, scenario="one_step")
 
     # Evaluate training
     ose.evaluate_training(cfg=cfg, metrics_path=metrics_path)
@@ -233,8 +246,8 @@ def evaluate_two_step_peak_finding(cfg: DictConfig, model, metrics_path: str) ->
 def evaluate_two_step_clusterization(cfg: DictConfig, model, metrics_path: str) -> list:
     model.to(DEVICE)
     model.eval()
-    dir_ = "*" if cfg.evaluation.training.eval_all_always else "test"
-    wcp_path = os.path.join(cfg.training.output_dir, "two_step", "predictions", "two_step_pf", dir_, "*")
+    dir_ = "*" if cfg.evaluation.training.eval_all else "test"
+    wcp_path = os.path.join(cfg.training.output_dir, "two_step_pf", "predictions", dir_, "*")
     file_list = glob.glob(wcp_path)
     iterable_dataset = dl.TwoStepClusterizationIterableDataset
 
@@ -253,7 +266,7 @@ def evaluate_two_step_minimal(cfg: DictConfig, model, metrics_path: str) -> list
     iterable_dataset = dl.TwoStepMinimalIterableDataset
 
     # Create prediction files
-    create_prediction_files(file_list, iterable_dataset=iterable_dataset, model=model, cfg=cfg, scenario="two_step_min")
+    # create_prediction_files(file_list, iterable_dataset=iterable_dataset, model=model, cfg=cfg, scenario="two_step_minimal")
 
     # Evaluate training
     tsme.evaluate_training(cfg=cfg, metrics_path=metrics_path)
@@ -268,7 +281,7 @@ def main(cfg: DictConfig):
         print("Training one-step model.")
         model, best_model_path, metrics_path = train_one_step(cfg, data_type="")
         if cfg.training.model_evaluation:
-            checkpoint = torch.load(best_model_path, weights=False)
+            checkpoint = torch.load(best_model_path)  # , weights=False)
             model.load_state_dict(checkpoint["state_dict"])
             model.eval()
             evaluate_one_step(cfg, model, metrics_path)
@@ -280,15 +293,16 @@ def main(cfg: DictConfig):
             model.eval()
             evaluate_two_step_peak_finding(cfg, model, metrics_path)
     elif training_type == "two_step_cl":
+        model, best_model_path, metrics_path = train_two_step_clusterization(cfg, data_type="")
         if cfg.training.model_evaluation:
-            model, best_model_path, metrics_path = train_two_step_clusterization(cfg, data_type="")
+            checkpoint = torch.load(best_model_path)  # , weights=False)
             model.load_state_dict(checkpoint["state_dict"])
             model.eval()
             evaluate_two_step_clusterization(cfg, model, metrics_path)
     elif training_type == "two_step_minimal":
         model, best_model_path, metrics_path = train_two_step_minimal(cfg, data_type="")
         if cfg.training.model_evaluation:
-            checkpoint = torch.load(best_model_path, weights=False)
+            checkpoint = torch.load(best_model_path)  # , weights=False)
             model.load_state_dict(checkpoint["state_dict"])
             model.eval()
             evaluate_two_step_minimal(cfg, model, metrics_path)
diff --git a/ml4cc/scripts/train_all_scenarios.sh b/ml4cc/scripts/train_all_scenarios.sh
index dacd3c3..28720a9 100644
--- a/ml4cc/scripts/train_all_scenarios.sh
+++ b/ml4cc/scripts/train_all_scenarios.sh
@@ -6,28 +6,30 @@ PROGNAME=$0
 # Parse user options.
 usage() {
   cat << EOF >&2
-Usage: bash enreg/scripts/$PROGNAME [-o] [-s] [-p] [-m] [-c]
+Usage: bash enreg/scripts/$PROGNAME [-o] [-s] [-d] [-e] [-m] [-c]
   -o : This is used to specify the output directory.
-  -s : Training scenario [Options: one_step, two_step, two_step_minimal, all]
+  -s : Training scenario [Options: one_step, two_step_pf, two_step_cl, two_step_minimal, all]
   -d : Dataset to train on [Options: CEPC, FCC, all]
+  -e : Evaluation run [Default: False]
   -m : [OPTIONAL] Use this flag to run the training on 'manivald'. By default it is run on LUMI
   -c : [Only if two_step training scenario] Clusterization model to be used in training [Options: CNN, DNN, RNN, (DGCNN), all]
 EOF
   exit 1
 }
 
-
+EVALUATION=False
 RUN_ON_LUMI=true
 TRAIN_TWO_STEP=false
 TRAIN_TWO_STEP_MINIMAL=false
 TRAIN_ONE_STEP=false
 CLUSTERIZATION_MODEL=DNN
 HOST=lumi
-while getopts 'o:s:d:mc:' OPTION; do
+while getopts 'o:s:d:emc:' OPTION; do
   case $OPTION in
     o) BASE_DIR=$OPTARG ;;
     s) TRAINING_SCENARIO=$OPTARG ;;
     d) TRAINING_DATASET=$OPTARG ;;
+    e) EVALUATION=True ;;
     m)
         RUN_ON_LUMI=false
         HOST=manivald
@@ -46,6 +48,7 @@ echo Output will be saved into: $BASE_DIR
 echo Training scenario: $TRAINING_SCENARIO
 echo Training dataset: $TRAINING_DATASET
 echo Running on: $HOST
+echo Evaluation: $EVALUATION
 
 if  [ "$RUN_ON_LUMI" = true ] ; then
     TRAINING_SCRIPT=ml4cc/scripts/submit-gpu-lumi.sh
@@ -63,5 +66,7 @@ if [ "$TRAINING_SCENARIO" = "all" ] ; then
     echo Currently only single training scenario is supported
 fi
 
+# Apparently Hydra fails to set multilevel config in-place. This is just a workaround to load the correct config.
+sed -i "/clusterization@clusterization.model/ s/: .*/: $CLUSTERIZATION_MODEL/" ml4cc/config/models/two_step/two_step.yaml
 
-sbatch $TRAINING_SCRIPT python3 ml4cc/scripts/train.py training.output_dir=$BASE_DIR datasets@dataset=$TRAINING_DATASET environment@host=$HOST training.type=two_step_pf training.model_evaluation=False # models.two_step.clusterization@clusterization.model=$CLUSTERIZATION_MODEL
+sbatch $TRAINING_SCRIPT python3 ml4cc/scripts/train.py training.output_dir=$BASE_DIR datasets@dataset=$TRAINING_DATASET environment@host=$HOST training.type=$TRAINING_SCENARIO training.model_evaluation=$EVALUATION
diff --git a/ml4cc/tools/__init__.py b/ml4cc/tools/__init__.py
index 6ef160d..c93c462 100644
--- a/ml4cc/tools/__init__.py
+++ b/ml4cc/tools/__init__.py
@@ -2,3 +2,4 @@
 from . import data
 from . import callbacks
 from . import evaluation
+from . import losses
diff --git a/ml4cc/tools/data/dataloaders.py b/ml4cc/tools/data/dataloaders.py
index 9a9ce81..6c4c277 100644
--- a/ml4cc/tools/data/dataloaders.py
+++ b/ml4cc/tools/data/dataloaders.py
@@ -338,8 +338,7 @@ def build_tensors(self, data: ak.Array):
             targets : torch.Tensor
                 The target values of the data
         """
-        targets = np.array(data.target == 1, dtype=int)
-        targets = np.sum(targets, axis=-1)
+        targets = ak.sum(data.target == 1, axis=-1)
         mask = ak.ones_like(targets)
         targets = torch.tensor(targets, dtype=torch.float32)
         waveform = torch.tensor(ak.Array(data.waveform), dtype=torch.float32)
@@ -367,12 +366,14 @@ def build_tensors(self, data: ak.Array):
         padded_windows = ak.fill_none(ak.pad_none(waveforms, 15, axis=-1), 0)  # All windows are padded to 15 size
         zero_window = [0] * 15
         none_padded_waveforms = ak.pad_none(padded_windows, self.cfg.dataset.max_peak_cands, axis=-2)
-        padded_waveforms = ak.fill_none(none_padded_waveforms, zero_window, axis=-2)
+        mask = ak.ones_like(data.target)
+        mask = ak.pad_none(mask, self.cfg.dataset.max_peak_cands, axis=-1)
+        mask = ak.fill_none(mask, 0, axis=-1)
+        padded_waveforms = ak.Array(ak.fill_none(none_padded_waveforms, zero_window, axis=-2))
 
         targets = np.sum(data.target == 1, axis=-1)
-        mask = ak.ones_like(targets)
         targets = torch.tensor(targets, dtype=torch.float32)
-        waveform = torch.tensor(ak.Array(padded_waveforms), dtype=torch.float32)
+        waveform = torch.tensor(padded_waveforms, dtype=torch.float32)
         mask = torch.tensor(mask, dtype=torch.bool)
         return waveform, targets, mask
 
diff --git a/ml4cc/tools/evaluation/classification.py b/ml4cc/tools/evaluation/classification.py
index 95caeed..37e2804 100644
--- a/ml4cc/tools/evaluation/classification.py
+++ b/ml4cc/tools/evaluation/classification.py
@@ -66,7 +66,7 @@ def calculate_metrics(
         dict: Contains ROC results and the chosen threshold.
     """
     print("Calculating metrics...")
-    roc_results = thresholded_roc_curve(truth, predictions)
+    roc_results = thresholded_roc_curve(truth, predictions, signal=signal)
     update = {}
     if at_fakerate != -1:
         fr_threshold, idx = get_metric_cut(roc_results, at_fakerate=at_fakerate)
@@ -107,7 +107,7 @@ def get_per_energy_metrics(
             all_results[pid][energy] = calculate_metrics(
                 truth=true, predictions=pred, at_fakerate=at_fakerate, at_efficiency=at_efficiency, signal=signal
             )
-    all_results["global"] = calculate_global_metrics(all_results)
+        all_results[pid]["global"] = calculate_global_metrics(all_results[pid])
     return all_results
 
 
@@ -160,7 +160,7 @@ def calculate_global_roc(all_rocs: list) -> dict:
     return global_roc
 
 
-def calculate_global_metrics(all_single_results: dict) -> dict:
+def calculate_global_metrics(pid_results: dict) -> dict:
     """
     Calculate global metrics across all energies.
 
@@ -172,21 +172,20 @@ def calculate_global_metrics(all_single_results: dict) -> dict:
     """
     print("Calculating global metrics...")
     all_results = {}
-    for pid, pid_results in all_single_results.items():
-        all_pred = []
-        all_true = []
-        all_rocs = []
-        all_aucs = []
-        all_results[pid] = {"FPRs": [], "TPRs": [], "energies": []}
-        for energy, energy_results in pid_results.items():
-            all_pred.extend(energy_results["pred"])
-            all_true.extend(energy_results["true"])
-            all_rocs.append({"FPR": energy_results["FPR"], "TPR": energy_results["TPR"]})
-            all_results[pid]["FPRs"].append(energy_results["FPR"][energy_results["eff_cut_idx"]])
-            all_results[pid]["TPRs"].append(energy_results["TPR"][energy_results["fr_cut_idx"]])
-            all_aucs.append(energy_results["AUC"])
-            all_results[pid]["energies"].append(energy)
-        all_results[pid]["avg_auc"] = roc_auc_score(all_true, all_pred)
-        all_results[pid]["global_auc"] = calculate_global_auc(all_aucs)
-        all_results[pid]["global_roc"] = calculate_global_roc(all_rocs)
+    all_pred = []
+    all_true = []
+    all_rocs = []
+    all_aucs = []
+    all_results = {"FPRs": [], "TPRs": [], "energies": []}
+    for energy, energy_results in pid_results.items():
+        all_pred.extend(energy_results["pred"])
+        all_true.extend(energy_results["true"])
+        all_rocs.append({"FPR": energy_results["FPR"], "TPR": energy_results["TPR"]})
+        all_results["FPRs"].append(energy_results["FPR"][energy_results["eff_cut_idx"]])
+        all_results["TPRs"].append(energy_results["TPR"][energy_results["fr_cut_idx"]])
+        all_aucs.append(energy_results["AUC"])
+        all_results["energies"].append(energy)
+    all_results["AUC_mean"] = roc_auc_score(all_true, all_pred)
+    all_results["AUC"] = calculate_global_auc(all_aucs)
+    all_results["ROC"] = calculate_global_roc(all_rocs)
     return all_results
diff --git a/ml4cc/tools/evaluation/general.py b/ml4cc/tools/evaluation/general.py
index a4b9d5f..f4cc896 100644
--- a/ml4cc/tools/evaluation/general.py
+++ b/ml4cc/tools/evaluation/general.py
@@ -1,22 +1,64 @@
 import os
 import glob
+import json
 import warnings
 import numpy as np
 import pandas as pd
 import awkward as ak
 from omegaconf import DictConfig
+from ml4cc.tools.visualization import losses as l
+
+
+class NumpyEncoder(json.JSONEncoder):
+    """Custom encoder for numpy data types"""
+
+    def default(self, obj):
+        if isinstance(
+            obj,
+            (
+                np.int_,
+                np.intc,
+                np.intp,
+                np.int8,
+                np.int16,
+                np.int32,
+                np.int64,
+                np.uint8,
+                np.uint16,
+                np.uint32,
+                np.uint64,
+            ),
+        ):
+            return int(obj)
+        elif isinstance(obj, (np.float_, np.float16, np.float32, np.float64)):
+            return float(obj)
+        elif isinstance(obj, (np.complex_, np.complex64, np.complex128)):
+            return {"real": obj.real, "imag": obj.imag}
+        elif isinstance(obj, np.ndarray) or isinstance(obj, ak.Array):
+            return obj.tolist()
+        elif isinstance(obj, (np.bool_)):
+            return bool(obj)
+        elif isinstance(obj, (np.void)):
+            return None
+        return json.JSONEncoder.default(self, obj)
 
 
 def filter_losses(metrics_path: str):
-    metrics_data = pd.read_csv(metrics_path)
-    val_loss = np.array(metrics_data["val_loss"])
-    # train_loss = np.array(metrics_data['train_loss'])
-    val_loss = val_loss[~np.isnan(val_loss)]
-    # train_loss = train_loss[~np.isnan(train_loss)]
-    return val_loss  # , train_loss
+    data = pd.read_csv(metrics_path)
+    last_epoch = int(max(data["epoch"].dropna()))
+    epoch_last_train_losses = []
+    all_epoch_train_losses = []
+    for idx_epoch in range(last_epoch + 1):
+        epoch_train_losses = np.array(data.loc[data["epoch"] == idx_epoch, "train_loss"])
+        epoch_train_losses = epoch_train_losses[~np.isnan(epoch_train_losses)]
+        all_epoch_train_losses.append(epoch_train_losses)
+        epoch_last_train_losses.append(epoch_train_losses[-1])
+    val_losses = np.array(data["val_loss"])
+    val_losses = val_losses[~np.isnan(val_losses)]
+    return {"val_loss": val_losses, "train_loss": epoch_last_train_losses, "all_train_losses": all_epoch_train_losses}
 
 
-def collect_all_results(predictions_dir: str, cfg: DictConfig) -> dict:
+def collect_all_results(predictions_dir: str, cfg: DictConfig, target: str = "target") -> dict:
     """
     Collect all results from the predictions directory.
 
@@ -43,9 +85,19 @@ def collect_all_results(predictions_dir: str, cfg: DictConfig) -> dict:
             pid_energy_pred = []
             for pid_energy_file in pid_energy_files:
                 data = ak.from_parquet(pid_energy_file)
-                pid_energy_true.append(data["target"])
+                pid_energy_true.append(data[target])
                 pid_energy_pred.append(data["pred"])
             pid_energy_pred = ak.concatenate(pid_energy_pred, axis=0)
             pid_energy_true = ak.concatenate(pid_energy_true, axis=0)
             results[pid][energy] = {"true": pid_energy_true, "pred": pid_energy_pred}
     return results
+
+
+def evaluate_losses(metrics_path: str, model_name: str = "", loss_name: str = "BCE", results_dir: str = ""):
+    # Visualize losses for the training.
+    losses = filter_losses(metrics_path=metrics_path)
+    losses_output_path = os.path.join(results_dir, "losses.png")
+
+    lp = l.LossesMultiPlot(loss_name=loss_name, plot_train_losses=True)
+    loss_results = {model_name: losses}
+    lp.plot_algorithms(results=loss_results, output_path=losses_output_path)
diff --git a/ml4cc/tools/evaluation/one_step.py b/ml4cc/tools/evaluation/one_step.py
index c7ff743..da78de5 100644
--- a/ml4cc/tools/evaluation/one_step.py
+++ b/ml4cc/tools/evaluation/one_step.py
@@ -1,34 +1,39 @@
 import os
-import glob
-import awkward as ak
-from ml4cc.tools.data import io
-from ml4cc.tools.visualization import losses as l
-from ml4cc.tools.visualization import regression as r
+import json
+from ml4cc.tools.evaluation import regression as r
 from ml4cc.tools.evaluation import general as g
+from ml4cc.tools.visualization import regression as vr
+from ml4cc.tools.evaluation.general import NumpyEncoder
 
 
 def evaluate_training(cfg, metrics_path):
     results_dir = cfg.training.results_dir
     os.makedirs(results_dir, exist_ok=True)
     predictions_dir = cfg.training.predictions_dir
-    test_dir = os.path.join(predictions_dir, "test")
-    test_wcp = glob.glob(os.path.join(test_dir, "*"))
-    all_true = []
-    all_preds = []
-    for path in test_wcp:
-        data = ak.from_parquet(path)
-        all_true.append(ak.sum(data.target, axis=-1))
-        all_preds.append(data.pred)
-
-    truth = ak.flatten(all_true, axis=None)
-    preds = ak.flatten(all_preds, axis=None)
-
-    resolution_output_path = os.path.join(results_dir, "resolution.pdf")
-    r.evaluate_resolution(truth, preds, output_path=resolution_output_path)
-
-    distribution_output_path = os.path.join(results_dir, "true_pred_distributions.pdf")
-    r.plot_true_pred_distributions(truth, preds, output_path=distribution_output_path)
-
-    val_loss = g.filter_losses(metrics_path)
-    losses_output_path = os.path.join(cfg.training.output_dir, "losses.png")
-    l.plot_loss_evolution(val_loss=val_loss, train_loss=None, output_path=losses_output_path)
+
+    g.evaluate_losses(metrics_path, model_name=cfg.models.one_step.model.name, loss_name="MSE")
+
+    # 1. Collect results
+    if not os.path.exists(predictions_dir):
+        raise FileNotFoundError(f"Prediction directory {predictions_dir} does not exist.")
+    raw_results = g.collect_all_results(predictions_dir=predictions_dir, cfg=cfg)
+
+    # Evaluate model performance.
+    # 2. Prepare results
+    results = r.get_per_energy_metrics(results=raw_results)
+
+    results_json_path = os.path.join(results_dir, "results.json")
+    with open(results_json_path, "wt") as out_file:
+        json.dump(results, out_file, indent=4, cls=NumpyEncoder)
+
+    for pid in cfg.dataset.particle_types:
+        pid_results = results[pid]
+        multi_resolution_output_path = os.path.join(results_dir, f"{pid}_multi_resolution.png")
+        mrp = vr.MultiResolutionPlot(n_energies=len(cfg.dataset.particle_energies), ncols=3)
+        mrp.plot_all_resolutions(pid_results, output_path=multi_resolution_output_path)
+
+    for pid in cfg.dataset.particle_types:
+        pid_results = results[pid]
+        multi_comparison_output_path = os.path.join(results_dir, f"{pid}_multi_comparison.png")
+        mcp = vr.MultiComparisonPlot(n_energies=len(cfg.dataset.particle_energies), ncols=3)
+        mcp.plot_all_comparisons(pid_results, output_path=multi_comparison_output_path)
diff --git a/ml4cc/tools/evaluation/regression.py b/ml4cc/tools/evaluation/regression.py
index a1ca5dd..e38ec92 100644
--- a/ml4cc/tools/evaluation/regression.py
+++ b/ml4cc/tools/evaluation/regression.py
@@ -8,22 +8,33 @@ def calculate_resolution(truth: np.array, preds: np.array) -> np.array:
     iqr = np.quantile(ratios, 0.75) - np.quantile(ratios, 0.25)
     median = np.quantile(ratios, 0.5)
     resolution = iqr / median
-    return resolution, ratios
+    return resolution, median, ratios
 
 
 def collect_resolution_results(results: dict) -> dict:
     """Collects the resolution results from different energies"""
-    true = ak.sum(results["true"] == 1, axis=-1)
-    pred = results["pred"]
-    resolution, ratios = calculate_resolution(true, pred)
-    resolution_results = {"resolution": resolution, "ratios": ratios, "true": true, "pred": pred}
+    resolution, median, ratios = calculate_resolution(results["true"], results["pred"])
+    resolution_results = {
+        "resolution": resolution,
+        "median": median,
+        "ratios": ratios,
+        "true": results["true"],
+        "pred": results["pred"],
+    }
     return resolution_results
 
 
 def get_per_energy_metrics(results):
     per_energy_metrics = {}
     for pid, pid_results in results.items():
+        all_pred = []
+        all_true = []
         per_energy_metrics[pid] = {}
         for energy, energy_results in pid_results.items():
-            per_energy_metrics[pid][energy] = collect_resolution_results(energy_results)
+            res = {"pred": energy_results["pred"], "true": ak.sum(energy_results["true"] == 1, axis=-1)}
+            all_pred.append(res["pred"])
+            all_true.append(res["true"])
+            per_energy_metrics[pid][energy] = collect_resolution_results(res)
+        results_all = {"true": ak.concatenate(all_true, axis=-1), "pred": ak.concatenate(all_pred, axis=-1)}
+        per_energy_metrics[pid]["global"] = collect_resolution_results(results_all)
     return per_energy_metrics
diff --git a/ml4cc/tools/evaluation/two_step.py b/ml4cc/tools/evaluation/two_step.py
index 67e69e8..14266ca 100644
--- a/ml4cc/tools/evaluation/two_step.py
+++ b/ml4cc/tools/evaluation/two_step.py
@@ -1,42 +1,30 @@
 import os
+import json
 from omegaconf import DictConfig
 import ml4cc.tools.evaluation.general as g
 import ml4cc.tools.evaluation.classification as c
 import ml4cc.tools.evaluation.regression as r
-from ml4cc.tools.visualization import losses as l
 from ml4cc.tools.visualization import classification as vc
 from ml4cc.tools.visualization import regression as vr
+from ml4cc.tools.evaluation.general import NumpyEncoder
 
 
 def evaluate_training(cfg: DictConfig, metrics_path: str, stage: str):
     if stage == "peak_finding":
-        results_dir = os.path.join(cfg.training.results_dir, "two_step_pf")
+        results_dir = os.path.join(cfg.training.results_dir)
         evaluate_peak_finding(cfg, metrics_path, results_dir=results_dir)
-    elif stage == "classification":
-        results_dir = os.path.join(cfg.training.results_dir, "two_step_cl")
-        evaluate_classification(cfg, metrics_path, results_dir=results_dir)
+    elif stage == "clusterization":
+        results_dir = os.path.join(cfg.training.results_dir)
+        evaluate_clusterization(cfg, metrics_path, results_dir=results_dir)
     else:
         raise ValueError(f"Incorrect evaluation stage: {stage}")
 
 
-def evaluate_losses(
-    cfg: DictConfig, metrics_path: str, model_name: str = "", loss_name: str = "BCE", results_dir: str = ""
-):
-    # Visualize losses for the training.
-    losses = g.filter_losses(metrics_path=metrics_path)
-    losses_output_path = os.path.join(results_dir, "losses.png")
-
-    lp = l.LossesMultiPlot(loss_name=loss_name)
-    loss_results = {model_name: {"val_loss": losses}}
-    lp.plot_algorithms(results=loss_results, output_path=losses_output_path)
-
-
 def evaluate_peak_finding(cfg: DictConfig, metrics_path: str, results_dir: str):
     # 0. Visualize losses for the training.
     os.makedirs(results_dir, exist_ok=True)
 
-    evaluate_losses(
-        cfg,
+    g.evaluate_losses(
         metrics_path,
         model_name=cfg.models.two_step.peak_finding.model.name,
         loss_name="BCE",
@@ -47,11 +35,15 @@ def evaluate_peak_finding(cfg: DictConfig, metrics_path: str, results_dir: str):
     prediction_dir = os.path.join(cfg.training.predictions_dir, "two_step_pf")
     if not os.path.exists(prediction_dir):
         raise FileNotFoundError(f"Prediction directory {prediction_dir} does not exist.")
-    raw_results = g.collect_all_results(predictions_dir=prediction_dir, cfg=cfg)
+    raw_results = g.collect_all_results(predictions_dir=prediction_dir, cfg=cfg, target="pad_targets")
 
     # 2. Prepare results
     results = c.get_per_energy_metrics(results=raw_results, at_fakerate=0.01, at_efficiency=0.9, signal="both")
 
+    results_json_path = os.path.join(results_dir, "results.json")
+    with open(results_json_path, "wt") as out_file:
+        json.dump(results, out_file, indent=4, cls=NumpyEncoder)
+
     # 3. Visualize results
     for pid in cfg.dataset.particle_types:
         pid_results = results[pid]
@@ -65,36 +57,42 @@ def evaluate_peak_finding(cfg: DictConfig, metrics_path: str, results_dir: str):
 
     fr_output_path = os.path.join(results_dir, "fake_rate.png")
     frp = vc.EffFakePlot(eff_fake="fake_rate")
-    frp.plot_energies(results["global"], output_path=fr_output_path)
+    frp.plot_energies(results, output_path=fr_output_path)
 
     eff_output_path = os.path.join(results_dir, "efficiency.png")
     efp = vc.EffFakePlot(eff_fake="efficiency")
-    efp.plot_energies(results["global"], output_path=eff_output_path)
+    efp.plot_energies(results, output_path=eff_output_path)
 
     for pid in cfg.dataset.particle_types:
-        pid_results = results[pid]
+        energies = [key for key in results[pid].keys() if key != "global"]
+        pid_results = {key: results[pid][key] for key in energies}
         multiroc_output_path = os.path.join(results_dir, f"{pid}_multi_roc.png")
         mroc = vc.MultiROCPlot(pid=pid, n_energies=len(cfg.dataset.particle_energies), ncols=3)
         mroc.plot_curves(pid_results, output_path=multiroc_output_path)
 
     global_roc_output_path = os.path.join(results_dir, "global_roc.png")
     grp = vc.GlobalROCPlot()
-    grp.plot_all_curves(results["global"], output_path=global_roc_output_path)
+    grp.plot_all_curves(results, output_path=global_roc_output_path)
 
 
-def evaluate_classification(cfg: DictConfig, metrics_path: str, results_dir: str):
+def evaluate_clusterization(cfg: DictConfig, metrics_path: str, results_dir: str):
+    os.makedirs(results_dir, exist_ok=True)
     # Visualize losses for the training.
-    evaluate_losses(cfg, metrics_path, model_name=cfg.models.clusterization.model_name, loss_name="MSE")
+    g.evaluate_losses(metrics_path, model_name=cfg.models.two_step.clusterization.model.name, loss_name="MSE")
 
     # 1. Collect results
-    prediction_dir = os.path.join(cfg.training.predictions_dir, "two_step_cl")
+    prediction_dir = os.path.join(cfg.training.predictions_dir)
     if not os.path.exists(prediction_dir):
         raise FileNotFoundError(f"Prediction directory {prediction_dir} does not exist.")
     raw_results = g.collect_all_results(predictions_dir=prediction_dir, cfg=cfg)
 
     # Evaluate model performance.
     # 2. Prepare results
-    results = r.get_per_energy_metrics(results=raw_results, at_fakerate=0.01, at_efficiency=0.9, signal="both")
+    results = r.get_per_energy_metrics(results=raw_results)
+
+    results_json_path = os.path.join(results_dir, "results.json")
+    with open(results_json_path, "wt") as out_file:
+        json.dump(results, out_file, indent=4, cls=NumpyEncoder)
 
     for pid in cfg.dataset.particle_types:
         pid_results = results[pid]
diff --git a/ml4cc/tools/evaluation/two_step_minimal.py b/ml4cc/tools/evaluation/two_step_minimal.py
index 3eabbb4..1da303a 100644
--- a/ml4cc/tools/evaluation/two_step_minimal.py
+++ b/ml4cc/tools/evaluation/two_step_minimal.py
@@ -1,5 +1,120 @@
+import os
+import json
+import awkward as ak
 from omegaconf import DictConfig
+import ml4cc.tools.evaluation.general as g
+import ml4cc.tools.evaluation.classification as c
+import ml4cc.tools.evaluation.regression as r
+from ml4cc.tools.visualization import classification as vc
+from ml4cc.tools.visualization import regression as vr
+from ml4cc.tools.evaluation.general import NumpyEncoder
+
+
+def prepare_regression_results(raw_results):
+    res_results = {}
+    for pid, pid_results in raw_results.items():
+        res_results[pid] = {}
+        all_true = []
+        all_pred = []
+        for energy, energy_results in pid_results.items():
+            pred = ak.sum(energy_results["pred"] > 0.5, axis=-1)
+            true = ak.sum(energy_results["true"] == 1, axis=-1)
+            resolution, median, ratios = r.calculate_resolution(true, pred)
+            res_results[pid][energy] = {
+                "pred": pred,
+                "true": true,
+                "ratios": ratios,
+                "resolution": resolution,
+                "median": median,
+            }
+            all_true.append(true)
+            all_pred.append(pred)
+        results_all = {"true": ak.concatenate(all_true, axis=-1), "pred": ak.concatenate(all_pred, axis=-1)}
+        res_results[pid]["global"] = r.collect_resolution_results(results_all)
+    return res_results
 
 
 def evaluate_training(cfg: DictConfig, metrics_path: str):
-    pass
+    results_dir = os.path.join(cfg.training.results_dir)
+    os.makedirs(results_dir, exist_ok=True)
+    g.evaluate_losses(
+        metrics_path,
+        model_name=cfg.models.two_step.peak_finding.model.name,
+        loss_name="BCE",
+        results_dir=results_dir,
+    )
+
+    # 1. Collect results
+    prediction_dir = os.path.join(cfg.training.predictions_dir)
+    if not os.path.exists(prediction_dir):
+        raise FileNotFoundError(f"Prediction directory {prediction_dir} does not exist.")
+    raw_results = g.collect_all_results(predictions_dir=prediction_dir, cfg=cfg, target="pad_targets")
+
+    # 2. Prepare results
+    cls_results = c.get_per_energy_metrics(results=raw_results, at_fakerate=0.01, at_efficiency=0.9, signal="primary")
+
+    results_json_path = os.path.join(results_dir, "results_pf.json")
+    with open(results_json_path, "wt") as out_file:
+        json.dump(cls_results, out_file, indent=4, cls=NumpyEncoder)
+
+    # 3. Visualize results
+    for pid in cfg.dataset.particle_types:
+        pid_results = cls_results[pid]
+        csp_output_path = os.path.join(results_dir, "classifier_scores.png")
+        csp = vc.ClassifierScorePlot(n_energies=len(cfg.dataset.particle_energies))
+        csp.plot_all_comparisons(results=pid_results, output_path=csp_output_path)
+
+    asp_output_path = os.path.join(results_dir, "AUC_stack.png")
+    ewa = vc.EnergyWiseAUC(pids=cfg.dataset.particle_types)
+    ewa.plot_energies(cls_results, output_path=asp_output_path)
+
+    fr_output_path = os.path.join(results_dir, "fake_rate.png")
+    frp = vc.EffFakePlot(eff_fake="fake_rate")
+    frp.plot_energies(cls_results, output_path=fr_output_path)
+
+    eff_output_path = os.path.join(results_dir, "efficiency.png")
+    efp = vc.EffFakePlot(eff_fake="efficiency")
+    efp.plot_energies(cls_results, output_path=eff_output_path)
+
+    for pid in cfg.dataset.particle_types:
+        energies = [key for key in cls_results[pid].keys() if key != "global"]
+        pid_results = {key: cls_results[pid][key] for key in energies}
+        multiroc_output_path = os.path.join(results_dir, f"{pid}_multi_roc.png")
+        mroc = vc.MultiROCPlot(pid=pid, n_energies=len(cfg.dataset.particle_energies), ncols=3)
+        mroc.plot_curves(pid_results, output_path=multiroc_output_path)
+
+    global_roc_output_path = os.path.join(results_dir, "global_roc.png")
+    grp = vc.GlobalROCPlot()
+    grp.plot_all_curves(cls_results, output_path=global_roc_output_path)
+
+    # Prepare raw results for regression
+    res_results = prepare_regression_results(raw_results)
+    results_json_path = os.path.join(results_dir, "results_cl.json")
+    with open(results_json_path, "wt") as out_file:
+        json.dump(res_results, out_file, indent=4, cls=NumpyEncoder)
+
+    for pid in cfg.dataset.particle_types:
+        pid_results = res_results[pid]
+        multi_resolution_output_path = os.path.join(results_dir, f"{pid}_multi_resolution.png")
+        mrp = vr.MultiResolutionPlot(n_energies=len(cfg.dataset.particle_energies), ncols=3)
+        mrp.plot_all_resolutions(pid_results, output_path=multi_resolution_output_path)
+
+    for pid in cfg.dataset.particle_types:
+        pid_results = res_results[pid]
+        multi_comparison_output_path = os.path.join(results_dir, f"{pid}_multi_comparison.png")
+        mcp = vr.MultiComparisonPlot(n_energies=len(cfg.dataset.particle_energies), ncols=3)
+        mcp.plot_all_comparisons(pid_results, output_path=multi_comparison_output_path)
+
+    # Merge the two results to one results.json
+    all_results = {}
+    for pid in cfg.dataset.particle_types:
+        all_results[pid] = {
+            "global": {
+                "resolution": res_results[pid]["global"]["resolution"],
+                "median": res_results[pid]["global"]["median"],
+                "AUC": cls_results[pid]["global"]["AUC"],
+            }
+        }
+    all_results_json_path = os.path.join(results_dir, "results.json")
+    with open(all_results_json_path, "wt") as out_file:
+        json.dump(all_results, out_file, indent=4, cls=NumpyEncoder)
diff --git a/ml4cc/tools/losses/focal_loss.py b/ml4cc/tools/losses/focal_loss.py
new file mode 100644
index 0000000..fff6a97
--- /dev/null
+++ b/ml4cc/tools/losses/focal_loss.py
@@ -0,0 +1,24 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class FocalLoss(nn.CrossEntropyLoss):
+    """Focal loss for classification tasks on imbalanced datasets,
+    cf. https://arxiv.org/abs/1708.02002
+    NB.: Code downloaded from https://gist.github.com/f1recracker/0f564fd48f15a58f4b92b3eb3879149b"""
+
+    def __init__(self, gamma, alpha=None, ignore_index=-100, reduction="none"):
+        super().__init__(weight=alpha, ignore_index=ignore_index, reduction="none")
+        self.reduction = reduction
+        self.gamma = gamma
+
+    def forward(self, input_, target):
+        cross_entropy = super().forward(input_, target)
+        # Temporarily mask out ignore index to '0' for valid gather-indices input.
+        # This won't contribute final loss as the cross_entropy contribution
+        # for these would be zero.
+        target = target * (target != self.ignore_index).long()
+        input_prob = torch.gather(F.softmax(input_, 1), 1, target.unsqueeze(1))
+        loss = torch.pow(1 - input_prob, self.gamma) * cross_entropy
+        return torch.mean(loss) if self.reduction == "mean" else torch.sum(loss) if self.reduction == "sum" else loss
diff --git a/ml4cc/tools/visualization/classification.py b/ml4cc/tools/visualization/classification.py
index 4df2174..3f013de 100644
--- a/ml4cc/tools/visualization/classification.py
+++ b/ml4cc/tools/visualization/classification.py
@@ -22,13 +22,13 @@ def _add_curve(self, fpr: np.array, avg_tpr: np.array, std_tpr: np.array, label:
 
     def plot_all_curves(self, results: dict, output_path: str = "") -> None:
         for pid, pid_result in results.items():
-            mean_auc = pid_result["global_auc"]["mean"]
-            std_auc = pid_result["global_auc"]["std"]
+            mean_auc = pid_result["global"]["AUC"]["mean"]
+            std_auc = pid_result["global"]["AUC"]["std"]
             label = f"{pid}: AUC={mean_auc:.3f} ± {std_auc:.3f}"
             self._add_curve(
-                pid_result["global_roc"]["FPRs"],
-                pid_result["global_roc"]["avg_TPRs"],
-                pid_result["global_roc"]["std_TPRs"],
+                pid_result["global"]["ROC"]["FPRs"],
+                pid_result["global"]["ROC"]["avg_TPRs"],
+                pid_result["global"]["ROC"]["std_TPRs"],
                 label=label,
             )
 
@@ -37,6 +37,8 @@ def plot_all_curves(self, results: dict, output_path: str = "") -> None:
         self.ax.legend()
         self.ax.set_xlim(0, 1)
         self.ax.set_ylim(0, 1)
+        # self.ax.set_yscale("log")
+        # self.ax.set_xscale("log")
         if output_path != "":
             plt.savefig(output_path, bbox_inches="tight")
             plt.close("all")
@@ -60,6 +62,8 @@ def _add_curve(
         ax.plot(fpr, tpr)
         ax.text(0.1, 0.8, f"AUC={auc:.3f}", fontsize=10)
         ax.set_title(label, fontsize=14)
+        # ax.set_yscale("log")
+        # ax.set_xscale("log")
         if print_legend:
             ax.legend(loc="upper right", fontsize=10)
 
@@ -88,7 +92,7 @@ def __init__(
         n_energies: int = 7,  # 7 for FCC, 6 for CEPC
         figsize: tuple = (9, 9),
         x_min: float = 0,
-        x_max: float = 50,
+        x_max: float = 1,
         num_bins: int = 25,
         ncols: int = 3,
     ):
@@ -123,12 +127,15 @@ def _add_histogram(self, ax, preds: np.array, true: np.array, energy: str, print
             hatch="\\\\",
             label="Background",
         )
-        ax.set_title(f"{energy} GeV")
+        ax.set_title(f"{energy} GeV", fontsize=16)
+        ax.set_yscale("log")
         if print_legend:
             ax.legend(loc="upper right", fontsize=10)
 
     def plot_all_comparisons(self, results: dict, output_path: str = "") -> None:
         for idx, (energy, result) in enumerate(results.items()):
+            if energy == "global":
+                continue
             ax = self.axis.flatten()[idx]
             self._add_histogram(
                 ax=ax, preds=result["pred"], true=result["true"], energy=energy, print_legend=idx == self.ncols
@@ -136,8 +143,8 @@ def plot_all_comparisons(self, results: dict, output_path: str = "") -> None:
         for ax in self.axis.flat:
             ax.label_outer()
 
-        self.fig.text(0.04, 0.5, "Number of entries", va="center", rotation="vertical", fontsize=12)
-        self.fig.text(0.5, 0.02, r"$\mathcal{D}_p$", ha="center", fontsize=12)
+        self.fig.text(0.04, 0.5, "Number of entries", va="center", rotation="vertical", fontsize=16)
+        self.fig.text(0.5, 0.02, r"$\mathcal{D}_p$", ha="center", fontsize=16)
 
         if output_path != "":
             plt.savefig(output_path, bbox_inches="tight")
@@ -159,26 +166,27 @@ def __init__(
         self.name_mapping = name_mapping
         self.marker_mapping = marker_mapping
         self.fig, self.ax = plt.subplots(figsize=(8, 8))
+        self.pid_marker_mapping = {"muon": "^", "K": "s", "pi": "o"}
 
     def _add_line(self, results: dict, algorithm: str, y: int):
-        self.ax.errorbar(
-            np.mean(results["AUCs"]),
-            y,
-            xerr=np.std(results["AUCs"]),
-            label=self.name_mapping.get(algorithm, algorithm),
-            color=self.color_mapping.get(algorithm, None),
-            marker=self.marker_mapping.get(algorithm, "o"),
-            ls="",
-            ms=10,
-            capsize=5,
-        )
+        for pid, pid_results in results.items():
+            self.ax.errorbar(
+                pid_results["AUC"]["mean"],
+                y,
+                xerr=pid_results["AUC"]["std"],
+                label=self.name_mapping.get(algorithm, algorithm),
+                color=self.color_mapping.get(algorithm, None),
+                marker=self.pid_marker_mapping.get(pid, "o"),
+                ls="",
+                ms=10,
+                capsize=5,
+            )
 
     def plot_algorithms(self, results: dict, output_path: str = ""):
         yticklabels = []
         for idx, (algorithm, result) in enumerate(results.items()):
-            yticklabels.append(algorithm)
+            yticklabels.append(self.name_mapping.get(algorithm, algorithm))
             self._add_line(result, algorithm=algorithm, y=idx)
-        self.ax.axvline(1, color="k", ls="--")
         self.ax.set_xlabel(f"AUC score")
         self.ax.set_yticks(np.arange(len(yticklabels)))
         self.ax.set_yticklabels(yticklabels)
@@ -199,12 +207,23 @@ def __init__(self, pids: list = None):
 
     def plot_energies(self, results: dict, output_path: str = ""):
         for pid in self.pids:
-            pid_results = results[pid]
-            energies = list(pid_results.keys())
-            aucs = [value["AUC"] for value in pid_results.values()]
-            self.ax.plot(energies, aucs, label=pid, ls="--", marker="o")
+            energies = np.array([key for key in results[pid].keys() if key != "global"])
+            pid_results = {key: results[pid][key] for key in energies}
+            aucs = np.array([value["AUC"] for value in pid_results.values()])
+
+            # Calculate mean AUC:
+            mean_auc = np.mean(aucs)
+            lower_than_average_mask = aucs < mean_auc
+            for value, loc in zip(aucs[lower_than_average_mask], energies[lower_than_average_mask]):
+                self.ax.vlines(loc, ymin=value, ymax=mean_auc, color="red", ls="--")
+            for value, loc in zip(aucs[~lower_than_average_mask], energies[~lower_than_average_mask]):
+                self.ax.vlines(loc, ymin=mean_auc, ymax=value, color="green", ls="--")
+            self.ax.scatter(energies[lower_than_average_mask], aucs[lower_than_average_mask], color="red", s=80)
+            self.ax.scatter(energies[~lower_than_average_mask], aucs[~lower_than_average_mask], color="green", s=80)
+            self.ax.axhline(mean_auc, xmin=0, xmax=len(energies), ls="--", color="k")
         self.ax.set_ylabel(f"AUC score")
         self.ax.set_xlabel("Energy [GeV]")
+        self.ax.set_xscale("log")
         self.fig.legend()
         if output_path != "":
             plt.savefig(output_path, bbox_inches="tight")
@@ -232,10 +251,11 @@ def _add_line(self, result: dict, pid: str = ""):
 
     def plot_energies(self, results: dict, output_path: str = ""):
         for pid, pid_result in results.items():
-            self._add_line(pid_result, pid=pid)
+            self._add_line(pid_result["global"], pid=pid)
         self.ax.set_xlabel("Energy [GeV]")
         ylabel = "Efficiency" if self.eff_fake == "efficiency" else "Fake rate"
         self.ax.set_ylabel(ylabel)
+        self.ax.set_xscale("log")
         self.ax.legend()
         if output_path != "":
             plt.savefig(output_path, bbox_inches="tight")
diff --git a/ml4cc/tools/visualization/losses.py b/ml4cc/tools/visualization/losses.py
index a0d3f61..fa8a374 100644
--- a/ml4cc/tools/visualization/losses.py
+++ b/ml4cc/tools/visualization/losses.py
@@ -23,16 +23,16 @@ def __init__(
 
     def _add_line(self, results: dict, algorithm: str):
         """Adds a line to the plot."""
-        if self.plot_train_losses:
-            self.ax.plot(
-                results["train_loss"], ls="--", color=self.color_mapping.get(algorithm, None)
-            )  # Train loss always with dashed line
         self.ax.plot(
             results["val_loss"],
             label=self.name_mapping.get(algorithm, algorithm),
             ls="-",
             color=self.color_mapping.get(algorithm, None),
         )  # Val loss always with solid line
+        if self.plot_train_losses:
+            self.ax.plot(
+                results["train_loss"], ls="--", color=self.color_mapping.get(algorithm, self.ax.lines[-1].get_color())
+            )  # Train loss always with dashed line
         self.ax.legend()
 
     def plot_algorithms(self, results: dict, output_path: str = ""):
@@ -41,7 +41,7 @@ def plot_algorithms(self, results: dict, output_path: str = ""):
         self.ax.set_yscale("log")
         self.ax.set_ylabel(f"{self.loss_name} loss [a.u.]")
         self.ax.set_xlabel("epoch")
-        self.ax.set_xlim(0, self.x_max if self.x_max > 0 else 100)
+        self.ax.set_xlim(0, self.x_max if self.x_max > 0 else None)
         if output_path != "":
             plt.savefig(output_path, bbox_inches="tight")
             plt.close("all")
@@ -80,9 +80,64 @@ def _add_line(self, results: dict, algorithm: str, y: int):
     def plot_algorithms(self, results: dict, output_path: str = ""):
         yticklabels = []
         for idx, (algorithm, result) in enumerate(results.items()):
-            yticklabels.append(algorithm)
+            yticklabels.append(self.name_mapping.get(algorithm, algorithm))
             self._add_line(result, algorithm=algorithm, y=idx)
-        self.ax.axvline(1, color="k", ls="--")
+        self.ax.set_xlabel(f"{self.loss_name} loss [a.u.]")
+        self.ax.set_yticks(np.arange(len(yticklabels)))
+        self.ax.set_yticklabels(yticklabels)
+        if output_path != "":
+            plt.savefig(output_path, bbox_inches="tight")
+            plt.close("all")
+        else:
+            plt.show()
+            plt.close("all")
+
+
+class LossesStackPlot2:
+    def __init__(
+        self,
+        loss_name: str = "MSE",
+        baseline_algo: str = None,
+        color_mapping: dict = {},
+        name_mapping: dict = {},
+        marker_mapping: dict = {},
+    ):
+        """Plots losses relative to one indicated by the 'baseline_algo'.
+        If not set, uses the worst performing algo"""
+        self.loss_name = loss_name
+        self.color_mapping = color_mapping
+        self.baseline_algo = baseline_algo
+        self.name_mapping = name_mapping
+        self.marker_mapping = marker_mapping
+        self.fig, self.ax = plt.subplots(figsize=(8, 8))
+
+    def _add_line(self, results: dict, algorithm: str, y: int, baseline_value):
+        self.ax.errorbar(
+            results["mean"] / baseline_value,
+            y,
+            xerr=results["err"] / baseline_value,
+            label=self.name_mapping.get(algorithm, algorithm),
+            color=self.color_mapping.get(algorithm, None),
+            marker=self.marker_mapping.get(algorithm, "o"),
+            ls="",
+            ms=10,
+            capsize=5,
+        )
+
+    def plot_algorithms(self, results: dict, output_path: str = ""):
+        yticklabels = []
+        processed_results = {}
+        for idx, (algorithm, result) in enumerate(results.items()):
+            yticklabels.append(self.name_mapping.get(algorithm, algorithm))
+            processed_results[algorithm] = {
+                "mean": np.mean(result["best_losses"]),
+                "err": np.std(result["best_losses"]),
+            }
+        max_mean = np.max([result["mean"] for _, result in processed_results.items()])
+        baseline_value = processed_results[algorithm]["mean"] if self.baseline_algo is not None else max_mean
+        for idx, (algorithm, result) in enumerate(processed_results.items()):
+            self._add_line(result, algorithm=algorithm, y=idx, baseline_value=baseline_value)
+        self.ax.axvline(1, ls="--", color="k")
         self.ax.set_xlabel(f"{self.loss_name} loss [a.u.]")
         self.ax.set_yticks(np.arange(len(yticklabels)))
         self.ax.set_yticklabels(yticklabels)
diff --git a/ml4cc/tools/visualization/regression.py b/ml4cc/tools/visualization/regression.py
index 0704248..720328f 100644
--- a/ml4cc/tools/visualization/regression.py
+++ b/ml4cc/tools/visualization/regression.py
@@ -29,7 +29,7 @@ def _add_histogram(self, ax, ratios: np.array, resolution: float, energy: str):
         bins = np.linspace(self.x_min, self.x_max, self.num_bins)
         hep.histplot(to_bh(ratios, bins=bins), ax=ax, density=True)
         ax.axvline(x=1, ls="--", color="k")
-        ax.set_title(f"{energy} GeV")
+        ax.set_title(f"{energy} GeV", fontsize=16)
         ax.text(0.95, 0.95, f"IQR={resolution:.2f}", ha="right", va="top", transform=ax.transAxes, fontsize=10)
 
     def plot_all_resolutions(self, results: dict, output_path: str = "") -> None:
@@ -39,8 +39,8 @@ def plot_all_resolutions(self, results: dict, output_path: str = "") -> None:
         for ax in self.axis.flat:
             ax.label_outer()
 
-        self.fig.text(0.04, 0.5, "Number of entries", va="center", rotation="vertical", fontsize=12)
-        self.fig.text(0.5, 0.02, r"$n_{cls}^{true}/n_{cls}^{pred}$", ha="center", fontsize=12)
+        self.fig.text(0.04, 0.5, "Number of entries", va="center", rotation="vertical", fontsize=16)
+        self.fig.text(0.5, 0.02, r"$n_{cls}^{true}/n_{cls}^{pred}$", ha="center", fontsize=16)
 
         if output_path != "":
             plt.savefig(output_path, bbox_inches="tight")
@@ -82,7 +82,7 @@ def _add_histograms(self, ax, true: np.array, pred: float, energy: str, print_le
             hatch="\\\\",
             label="Reconstructed",
         )
-        ax.set_title(f"{energy} GeV")
+        ax.set_title(f"{energy} GeV", fontsize=16)
         if print_legend:
             ax.legend(loc="upper right", fontsize=10)
 
@@ -95,8 +95,8 @@ def plot_all_comparisons(self, results: dict, output_path: str = "") -> None:
         for ax in self.axis.flat:
             ax.label_outer()
 
-        self.fig.text(0.04, 0.5, "Number of entries", va="center", rotation="vertical", fontsize=12)
-        self.fig.text(0.5, 0.02, "Number of primary clusters", ha="center", fontsize=12)
+        self.fig.text(0.04, 0.5, "Number of entries", va="center", rotation="vertical", fontsize=16)
+        self.fig.text(0.5, 0.02, "Number of primary clusters", ha="center", fontsize=16)
 
         if output_path != "":
             plt.savefig(output_path, bbox_inches="tight")
@@ -113,31 +113,31 @@ def __init__(
         normalize_by_median: bool = True,
         color_mapping: dict = {},
         name_mapping: dict = {},
-        marker_mapping: dict = {},
     ):
         self.normalize_by_median = normalize_by_median
         self.color_mapping = color_mapping
         self.name_mapping = name_mapping
-        self.marker_mapping = marker_mapping
         self.fig, self.ax = plt.subplots(figsize=(8, 8))
+        self.pid_marker_mapping = {"muon": "^", "K": "s", "pi": "o"}
 
     def _add_line(self, results: dict, algorithm: str, y: int):
-        self.ax.errorbar(
-            results["median"],
-            y,
-            xerr=results["IQR"],
-            label=self.name_mapping.get(algorithm, algorithm),
-            color=self.color_mapping.get(algorithm, None),
-            marker=self.marker_mapping.get(algorithm, "o"),
-            ls="",
-            ms=10,
-            capsize=5,
-        )
+        for pid, pid_results in results.items():
+            self.ax.errorbar(
+                pid_results["median"],
+                y,
+                xerr=pid_results["resolution"],
+                label=self.name_mapping.get(algorithm, algorithm),
+                color=self.color_mapping.get(algorithm, None),
+                marker=self.pid_marker_mapping.get(pid, "o"),
+                ls="",
+                ms=10,
+                capsize=5,
+            )
 
     def plot_algorithms(self, results: dict, output_path: str = ""):
         yticklabels = []
         for idx, (algorithm, result) in enumerate(results.items()):
-            yticklabels.append(algorithm)
+            yticklabels.append(self.name_mapping.get(algorithm, algorithm))
             self._add_line(result, algorithm=algorithm, y=idx)
         self.ax.axvline(1, color="k", ls="--")
         self.ax.set_xlabel("Response")