diff --git a/deepof/models.py b/deepof/models.py
index f15f4a9ca9dcc526d15638175e16e6ec4095404b..67d96f99976cc46b41f0de6000854e4c417fbd20 100644
--- a/deepof/models.py
+++ b/deepof/models.py
@@ -542,7 +542,7 @@ class SEQ_2_SEQ_GMVAE:
                     deepof.model_utils.tfd.Independent(
                         deepof.model_utils.tfd.Normal(
                             loc=gauss[1][..., : self.ENCODING, k],
-                            scale=softplus(gauss[1][..., self.ENCODING :, k]),
+                            scale=softplus(gauss[1][..., self.ENCODING:, k]),
                         ),
                         reinterpreted_batch_ndims=1,
                     )
@@ -641,14 +641,8 @@ class SEQ_2_SEQ_GMVAE:
         _x_decoded_mean = TimeDistributed(Dense(input_shape[2]))(_generator)
         generator = Model(g, _x_decoded_mean, name="SEQ_2_SEQ_VGenerator")
 
-        def huber_loss(x_, x_decoded_mean_):  # pragma: no cover
-            """Computes huber loss with a fixed delta"""
-
-            huber = Huber(reduction="sum", delta=self.delta)
-            return input_shape[1:] * huber(x_, x_decoded_mean_)
-
         gmvaep.compile(
-            loss=huber_loss,
+            loss=Huber(reduction="sum", delta=self.delta),
             optimizer=Nadam(lr=self.learn_rate, clipvalue=0.5,),
             metrics=["mae"],
             loss_weights=([1, self.predictor] if self.predictor > 0 else [1]),
diff --git a/deepof/train_model.py b/deepof/train_model.py
index c959cb704cf2b1eed803dd1d03c087468147e715..1cdaafe0ce6580d103f99f43cd20c4381d67b618 100644
--- a/deepof/train_model.py
+++ b/deepof/train_model.py
@@ -13,6 +13,7 @@ from deepof.data import *
 from deepof.models import *
 from deepof.utils import *
 from train_utils import *
+from tensorboard.plugins.hparams import api as hp
 from tensorflow import keras
 
 parser = argparse.ArgumentParser(
@@ -61,14 +62,6 @@ parser.add_argument(
     type=str2bool,
     default=False,
 )
-parser.add_argument(
-    "--hypermodel",
-    "-m",
-    help="Selects which hypermodel to use. It must be one of S2SAE, S2SVAE, S2SVAE-ELBO, S2SVAE-MMD, S2SVAEP, "
-    "S2SVAEP-ELBO and S2SVAEP-MMD. Please refer to the documentation for details on each option.",
-    type=str,
-    default="S2SVAE",
-)
 parser.add_argument(
     "--hyperparameter-tuning",
     "-tune",
@@ -183,7 +176,6 @@ bayopt_trials = args.bayopt
 exclude_bodyparts = tuple(args.exclude_bodyparts.split(","))
 gaussian_filter = args.gaussian_filter
 hparams = args.hyperparameters
-hyp = args.hypermodel
 input_type = args.input_type
 k = args.components
 kl_wu = args.kl_warmup
@@ -270,17 +262,12 @@ input_dict_train = {
 }
 
 print("Preprocessing data...")
-for key, value in input_dict_train.items():
-    input_dict_train[key] = batch_preprocess(value)
-print("Done!")
-
-print("Creating training and validation sets...")
+preprocessed = batch_preprocess(input_dict_train[input_type])
 # Get training and validation sets
-X_train = input_dict_train[input_type][0]
-X_val = input_dict_train[input_type][1]
+X_train = preprocessed[0]
+X_val = preprocessed[1]
 print("Done!")
 
-
 # Proceed with training mode. Fit autoencoder with the same parameters,
 # as many times as specified by runs
 if not tune:
@@ -384,6 +371,8 @@ if not tune:
 else:
     # Runs hyperparameter tuning with the specified parameters and saves the results
 
+    hyp = "S2SGMVAE" if variational else "S2SAE"
+
     run_ID, tensorboard_callback, cp_callback, onecycle = get_callbacks(
         X_train, batch_size, variational, predictor, k, loss, kl_wu, mmd_wu
     )
@@ -420,4 +409,4 @@ else:
 # TODO:
 #    - Investigate how goussian filters affect reproducibility (in a systematic way)
 #    - Investigate how smoothing affects reproducibility (in a systematic way)
-#    - Check if MCDropout effectively enhances reproducibility or not
+#    - Check if MCDropout effectively enhances reproducibility or not
\ No newline at end of file
diff --git a/deepof/train_utils.py b/deepof/train_utils.py
index 8cd5fcb22a293677d1ac53424b49812a65efbae1..8f81a795c0fc86fee6118a648ab88113757dc61f 100644
--- a/deepof/train_utils.py
+++ b/deepof/train_utils.py
@@ -146,10 +146,9 @@ def tune_search(
 
     """
 
-    print(callbacks)
     tensorboard_callback, cp_callback, onecycle = callbacks
 
-    if hypermodel == "S2SAE":
+    if hypermodel == "S2SAE":  # pragma: no cover
         hypermodel = deepof.hypermodels.SEQ_2_SEQ_AE(input_shape=train.shape)
 
     elif hypermodel == "S2SGMVAE":
@@ -179,9 +178,9 @@ def tune_search(
 
     tuner.search(
         train,
-        train,
+        train if predictor == 0 else [train[:-1], train[1:]],
         epochs=n_epochs,
-        validation_data=(test, test),
+        validation_data=(test, test if predictor == 0 else [test[:-1], test[1:]]),
         verbose=1,
         batch_size=256,
         callbacks=[
diff --git a/deepof/utils.py b/deepof/utils.py
index 674f0b83ffaed8c3c03c3bb2db17a82d00f3abfb..f8a6a79def4dfc2fe58c92a4ec697734edc0d928 100644
--- a/deepof/utils.py
+++ b/deepof/utils.py
@@ -80,12 +80,12 @@ def str2bool(v: str) -> bool:
     """
 
     if isinstance(v, bool):
-        return v
+        return v  # pragma: no cover
     if v.lower() in ("yes", "true", "t", "y", "1"):
         return True
     elif v.lower() in ("no", "false", "f", "n", "0"):
         return False
-    else:
+    else:  # pragma: no cover
         raise argparse.ArgumentTypeError("Boolean compatible value expected.")
 
 
diff --git a/examples/main.ipynb b/examples/main.ipynb
index ed63a67acf1bd5043b3c7fc49619a09fa1991c47..53bcee08cac476fb077a856103d3e6a1ebb4365b 100644
--- a/examples/main.ipynb
+++ b/examples/main.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -12,7 +12,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -28,9 +28,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 14.1 s, sys: 2.63 s, total: 16.7 s\n",
+      "Wall time: 4.57 s\n"
+     ]
+    }
+   ],
    "source": [
     "%%time\n",
     "deepof_main = deepof.data.project(path=os.path.join(\"..\",\"..\",\"Desktop\",\"deepof-data\"),\n",
@@ -48,9 +57,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading trajectories...\n",
+      "Smoothing trajectories...\n",
+      "Computing distances...\n",
+      "Computing angles...\n",
+      "Done!\n",
+      "deepof analysis of 109 videos\n",
+      "CPU times: user 35.6 s, sys: 5.4 s, total: 41 s\n",
+      "Wall time: 48.5 s\n"
+     ]
+    }
+   ],
    "source": [
     "%%time\n",
     "deepof_main = deepof_main.run(verbose=True)\n",
@@ -66,7 +90,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -75,9 +99,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 576x396 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "all_quality.boxplot(rot=45)\n",
     "plt.ylim(0.99985, 1.00001)\n",
@@ -86,9 +121,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4cc9aac4313e4cf7924d9f02df0f64bd",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(FloatSlider(value=0.5, description='quality_top', max=1.0, step=0.01), Output()), _dom_c…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "@interact(quality_top=(0., 1., 0.01))\n",
     "def low_quality_tags(quality_top):\n",
@@ -112,11 +162,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "metadata": {
     "scrolled": true
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 3.22 s, sys: 484 ms, total: 3.7 s\n",
+      "Wall time: 4.21 s\n"
+     ]
+    }
+   ],
    "source": [
     "%%time\n",
     "deepof_coords = deepof_main.get_coords(center=\"Center\", polar=False, speed=0, align=\"Spine_1\")"
@@ -131,16 +190,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 320x220 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "heat = deepof_coords.plot_heatmaps(['Nose'], i=0, dpi=40)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -149,9 +219,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a310a99ba0eb454ca7fd164293edb9d1",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(FloatProgress(value=0.0), HTML(value='')))"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
    "source": [
     "# Draft: function to produce a video with the animal in motion using cv2\n",
     "import cv2\n",
@@ -206,9 +298,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train dataset shape:  (133517, 13, 24)\n",
+      "Test dataset shape:  (30003, 13, 24)\n",
+      "CPU times: user 44.8 s, sys: 1.36 s, total: 46.2 s\n",
+      "Wall time: 46.7 s\n"
+     ]
+    }
+   ],
    "source": [
     "%%time\n",
     "deepof_train, deepof_test = deepof_coords.preprocess(window_size=13, window_step=10, conv_filter=None, sigma=55,\n",
@@ -217,28 +320,6 @@
     "print(\"Test dataset shape: \", deepof_test.shape)"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "n = 100\n",
-    "\n",
-    "plt.scatter(deepof_train[:n,10,0], deepof_train[:n,10,1], label='Nose')\n",
-    "plt.scatter(deepof_train[:n,10,2], deepof_train[:n,10,3], label='Right ear')\n",
-    "plt.scatter(deepof_train[:n,10,4], deepof_train[:n,10,5], label='Right hips')\n",
-    "plt.scatter(deepof_train[:n,10,6], deepof_train[:n,10,7], label='Left ear')\n",
-    "plt.scatter(deepof_train[:n,10,8], deepof_train[:n,10,9], label='Left hips')\n",
-    "plt.scatter(deepof_train[:n,10,10], deepof_train[:n,10,11], label='Tail base')\n",
-    "\n",
-    "\n",
-    "plt.xlabel('x')\n",
-    "plt.ylabel('y')\n",
-    "plt.legend()\n",
-    "plt.show()"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -255,7 +336,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -266,11 +347,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
-    "NAME = 'Baseline_AE_512_wu10_slide10_gauss_fullval'\n",
+    "NAME = 'Baseline_AE'\n",
     "log_dir = os.path.abspath(\n",
     "    \"logs/fit/{}_{}\".format(NAME, datetime.now().strftime(\"%Y%m%d-%H%M%S\"))\n",
     ")\n",
@@ -279,7 +360,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -288,7 +369,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -297,18 +378,94 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ae.summary()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"SEQ_2_SEQ_Decoder\"\n",
+      "_________________________________________________________________\n",
+      "Layer (type)                 Output Shape              Param #   \n",
+      "=================================================================\n",
+      "dense_transpose (DenseTransp multiple                  1104      \n",
+      "_________________________________________________________________\n",
+      "batch_normalization_5 (Batch multiple                  256       \n",
+      "_________________________________________________________________\n",
+      "dense_transpose_1 (DenseTran multiple                  8384      \n",
+      "_________________________________________________________________\n",
+      "batch_normalization_6 (Batch multiple                  512       \n",
+      "_________________________________________________________________\n",
+      "dense_transpose_2 (DenseTran multiple                  33152     \n",
+      "_________________________________________________________________\n",
+      "batch_normalization_7 (Batch multiple                  1024      \n",
+      "_________________________________________________________________\n",
+      "repeat_vector (RepeatVector) multiple                  0         \n",
+      "_________________________________________________________________\n",
+      "bidirectional_2 (Bidirection multiple                  1050624   \n",
+      "_________________________________________________________________\n",
+      "batch_normalization_8 (Batch multiple                  2048      \n",
+      "_________________________________________________________________\n",
+      "bidirectional_3 (Bidirection multiple                  1574912   \n",
+      "_________________________________________________________________\n",
+      "time_distributed (TimeDistri multiple                  12312     \n",
+      "=================================================================\n",
+      "Total params: 2,684,328\n",
+      "Trainable params: 2,682,408\n",
+      "Non-trainable params: 1,920\n",
+      "_________________________________________________________________\n"
+     ]
+    }
+   ],
+   "source": [
+    "decoder.summary()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"SEQ_2_SEQ_VGenerator\"\n",
+      "_________________________________________________________________\n",
+      "Layer (type)                 Output Shape              Param #   \n",
+      "=================================================================\n",
+      "input_2 (InputLayer)         [(None, 16)]              0         \n",
+      "_________________________________________________________________\n",
+      "dense_2 (Dense)              (None, 64)                1024      \n",
+      "_________________________________________________________________\n",
+      "batch_normalization (BatchNo (None, 64)                256       \n",
+      "_________________________________________________________________\n",
+      "dense_3 (Dense)              (None, 128)               8192      \n",
+      "_________________________________________________________________\n",
+      "batch_normalization_1 (Batch (None, 128)               512       \n",
+      "_________________________________________________________________\n",
+      "repeat_vector (RepeatVector) (None, 13, 128)           0         \n",
+      "_________________________________________________________________\n",
+      "bidirectional_2 (Bidirection (None, 13, 256)           262144    \n",
+      "_________________________________________________________________\n",
+      "batch_normalization_2 (Batch (None, 13, 256)           1024      \n",
+      "_________________________________________________________________\n",
+      "bidirectional_3 (Bidirection (None, 13, 512)           1048576   \n",
+      "_________________________________________________________________\n",
+      "batch_normalization_3 (Batch (None, 13, 512)           2048      \n",
+      "_________________________________________________________________\n",
+      "time_distributed (TimeDistri (None, 13, 24)            12312     \n",
+      "=================================================================\n",
+      "Total params: 1,336,088\n",
+      "Trainable params: 1,334,168\n",
+      "Non-trainable params: 1,920\n",
+      "_________________________________________________________________\n",
+      "CPU times: user 4.11 s, sys: 102 ms, total: 4.21 s\n",
+      "Wall time: 4.17 s\n"
+     ]
+    }
+   ],
    "source": [
     "%%time\n",
     "\n",
@@ -319,7 +476,7 @@
     "                                                                               kl_warmup_epochs=10,\n",
     "                                                                               mmd_warmup_epochs=10,\n",
     "                                                                               predictor=False).build(deepof_train.shape)\n",
-    "gmvaep.summary()"
+    "generator.summary()"
    ]
   },
   {
diff --git a/tests/test_train_utils.py b/tests/test_train_utils.py
index ef54d85029aa1ed88dbf3d4f5a03b8f37a677a7b..53227237baeb83050ae610dbf98aaacd8ca95a3d 100644
--- a/tests/test_train_utils.py
+++ b/tests/test_train_utils.py
@@ -80,7 +80,7 @@ def test_get_callbacks(
         elements=st.floats(min_value=0.0, max_value=1,),
     ),
     batch_size=st.integers(min_value=128, max_value=512),
-    hypermodel=st.one_of(st.just("S2SAE"), st.just("S2SGMVAE")),
+    hypermodel=st.just("S2SGMVAE"),
     k=st.integers(min_value=1, max_value=10),
     kl_wu=st.integers(min_value=0, max_value=10),
     loss=st.one_of(st.just("ELBO"), st.just("MMD")),