diff --git a/Code/python/notebooks/03_visualize_hyperparameters.ipynb b/Code/python/notebooks/03_visualize_hyperparameters.ipynb
new file mode 100644
index 0000000..ea8b8a7
--- /dev/null
+++ b/Code/python/notebooks/03_visualize_hyperparameters.ipynb
@@ -0,0 +1,699 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "516828d8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "6fe4652f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.microsoft.datawrangler.viewer.v0+json": {
+       "columns": [
+        {
+         "name": "index",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "Model",
+         "rawType": "object",
+         "type": "string"
+        },
+        {
+         "name": "Hidden Size",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "RNN Size",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "Step",
+         "rawType": "int64",
+         "type": "integer"
+        },
+        {
+         "name": "Final Loss",
+         "rawType": "float64",
+         "type": "float"
+        }
+       ],
+       "ref": "91e8d91c-ce50-41a4-92f3-32a97cfef9fc",
+       "rows": [
+        [
+         "0",
+         "RNN",
+         "16",
+         "32",
+         "1",
+         "372.1873533829399"
+        ],
+        [
+         "1",
+         "RNN",
+         "16",
+         "64",
+         "1",
+         "371.67606353759766"
+        ],
+        [
+         "2",
+         "RNN",
+         "16",
+         "128",
+         "1",
+         "328.19922903309697"
+        ],
+        [
+         "3",
+         "RNN",
+         "32",
+         "32",
+         "1",
+         "376.71770842179006"
+        ],
+        [
+         "4",
+         "RNN",
+         "32",
+         "64",
+         "1",
+         "369.6340640524159"
+        ],
+        [
+         "5",
+         "RNN",
+         "32",
+         "128",
+         "1",
+         "281.8589802617612"
+        ],
+        [
+         "6",
+         "RNN",
+         "64",
+         "32",
+         "1",
+         "378.7512518841288"
+        ],
+        [
+         "7",
+         "RNN",
+         "64",
+         "64",
+         "1",
+         "405.0867309570313"
+        ],
+        [
+         "8",
+         "RNN",
+         "64",
+         "128",
+         "1",
+         "1088.4633191979449"
+        ],
+        [
+         "9",
+         "LSTM",
+         "16",
+         "32",
+         "1",
+         "152.01849580847698"
+        ],
+        [
+         "10",
+         "LSTM",
+         "16",
+         "64",
+         "1",
+         "152.46532937754756"
+        ],
+        [
+         "11",
+         "LSTM",
+         "16",
+         "128",
+         "1",
+         "39.81503051260243"
+        ],
+        [
+         "12",
+         "LSTM",
+         "32",
+         "32",
+         "1",
+         "45.500295265861176"
+        ],
+        [
+         "13",
+         "LSTM",
+         "32",
+         "64",
+         "1",
+         "51.218478575996734"
+        ],
+        [
+         "14",
+         "LSTM",
+         "32",
+         "128",
+         "1",
+         "32.29804623645285"
+        ],
+        [
+         "15",
+         "LSTM",
+         "64",
+         "32",
+         "1",
+         "105.44863045733908"
+        ],
+        [
+         "16",
+         "LSTM",
+         "64",
+         "64",
+         "1",
+         "62.87264318051545"
+        ],
+        [
+         "17",
+         "LSTM",
+         "64",
+         "128",
+         "1",
+         "170.77305080579674"
+        ],
+        [
+         "18",
+         "GRU",
+         "16",
+         "32",
+         "1",
+         "23.525951261105742"
+        ],
+        [
+         "19",
+         "GRU",
+         "16",
+         "64",
+         "1",
+         "20.953380501788597"
+        ],
+        [
+         "20",
+         "GRU",
+         "16",
+         "128",
+         "1",
+         "50.10249718375828"
+        ],
+        [
+         "21",
+         "GRU",
+         "32",
+         "32",
+         "1",
+         "149.08109225397524"
+        ],
+        [
+         "22",
+         "GRU",
+         "32",
+         "64",
+         "1",
+         "40.437404922817066"
+        ],
+        [
+         "23",
+         "GRU",
+         "32",
+         "128",
+         "1",
+         "34.31250389762547"
+        ],
+        [
+         "24",
+         "GRU",
+         "64",
+         "32",
+         "1",
+         "154.5310813240383"
+        ],
+        [
+         "25",
+         "GRU",
+         "64",
+         "64",
+         "1",
+         "47.95653426128885"
+        ],
+        [
+         "26",
+         "GRU",
+         "64",
+         "128",
+         "1",
+         "263.4846937760063"
+        ],
+        [
+         "27",
+         "RNN",
+         "16",
+         "32",
+         "5",
+         "326.2015085634978"
+        ],
+        [
+         "28",
+         "RNN",
+         "16",
+         "64",
+         "5",
+         "384.77328723409903"
+        ],
+        [
+         "29",
+         "RNN",
+         "16",
+         "128",
+         "5",
+         "1099.3475819463315"
+        ],
+        [
+         "30",
+         "RNN",
+         "32",
+         "32",
+         "5",
+         "246.47076250159225"
+        ],
+        [
+         "31",
+         "RNN",
+         "32",
+         "64",
+         "5",
+         "329.85308439835256"
+        ],
+        [
+         "32",
+         "RNN",
+         "32",
+         "128",
+         "5",
+         "1098.7943765391474"
+        ],
+        [
+         "33",
+         "RNN",
+         "64",
+         "32",
+         "5",
+         "477.369012583857"
+        ],
+        [
+         "34",
+         "RNN",
+         "64",
+         "64",
+         "5",
+         "365.6013999607252"
+        ],
+        [
+         "35",
+         "RNN",
+         "64",
+         "128",
+         "5",
+         "413.95318603515625"
+        ],
+        [
+         "36",
+         "LSTM",
+         "16",
+         "32",
+         "5",
+         "24.514795303344727"
+        ],
+        [
+         "37",
+         "LSTM",
+         "16",
+         "64",
+         "5",
+         "24.9299375285273"
+        ],
+        [
+         "38",
+         "LSTM",
+         "16",
+         "128",
+         "5",
+         "34.382882035296895"
+        ],
+        [
+         "39",
+         "LSTM",
+         "32",
+         "32",
+         "5",
+         "171.14435179337212"
+        ],
+        [
+         "40",
+         "LSTM",
+         "32",
+         "64",
+         "5",
+         "185.21222504325536"
+        ],
+        [
+         "41",
+         "LSTM",
+         "32",
+         "128",
+         "5",
+         "24.800554503565248"
+        ],
+        [
+         "42",
+         "LSTM",
+         "64",
+         "32",
+         "5",
+         "183.13448831309444"
+        ],
+        [
+         "43",
+         "LSTM",
+         "64",
+         "64",
+         "5",
+         "37.47129328354545"
+        ],
+        [
+         "44",
+         "LSTM",
+         "64",
+         "128",
+         "5",
+         "51.097612007804535"
+        ],
+        [
+         "45",
+         "GRU",
+         "16",
+         "32",
+         "5",
+         "30.631973432457965"
+        ],
+        [
+         "46",
+         "GRU",
+         "16",
+         "64",
+         "5",
+         "30.393669625987176"
+        ],
+        [
+         "47",
+         "GRU",
+         "16",
+         "128",
+         "5",
+         "55.05557930987814"
+        ],
+        [
+         "48",
+         "GRU",
+         "32",
+         "32",
+         "5",
+         "54.14869615306025"
+        ],
+        [
+         "49",
+         "GRU",
+         "32",
+         "64",
+         "5",
+         "167.3384770932405"
+        ]
+       ],
+       "shape": {
+        "columns": 5,
+        "rows": 108
+       }
+      },
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Model</th>\n",
+       "      <th>Hidden Size</th>\n",
+       "      <th>RNN Size</th>\n",
+       "      <th>Step</th>\n",
+       "      <th>Final Loss</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>RNN</td>\n",
+       "      <td>16</td>\n",
+       "      <td>32</td>\n",
+       "      <td>1</td>\n",
+       "      <td>372.187353</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>RNN</td>\n",
+       "      <td>16</td>\n",
+       "      <td>64</td>\n",
+       "      <td>1</td>\n",
+       "      <td>371.676064</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>RNN</td>\n",
+       "      <td>16</td>\n",
+       "      <td>128</td>\n",
+       "      <td>1</td>\n",
+       "      <td>328.199229</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>RNN</td>\n",
+       "      <td>32</td>\n",
+       "      <td>32</td>\n",
+       "      <td>1</td>\n",
+       "      <td>376.717708</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>RNN</td>\n",
+       "      <td>32</td>\n",
+       "      <td>64</td>\n",
+       "      <td>1</td>\n",
+       "      <td>369.634064</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>103</th>\n",
+       "      <td>GRU</td>\n",
+       "      <td>32</td>\n",
+       "      <td>64</td>\n",
+       "      <td>30</td>\n",
+       "      <td>37.214055</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>104</th>\n",
+       "      <td>GRU</td>\n",
+       "      <td>32</td>\n",
+       "      <td>128</td>\n",
+       "      <td>30</td>\n",
+       "      <td>38.621485</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>105</th>\n",
+       "      <td>GRU</td>\n",
+       "      <td>64</td>\n",
+       "      <td>32</td>\n",
+       "      <td>30</td>\n",
+       "      <td>120.508296</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>106</th>\n",
+       "      <td>GRU</td>\n",
+       "      <td>64</td>\n",
+       "      <td>64</td>\n",
+       "      <td>30</td>\n",
+       "      <td>75.707219</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>107</th>\n",
+       "      <td>GRU</td>\n",
+       "      <td>64</td>\n",
+       "      <td>128</td>\n",
+       "      <td>30</td>\n",
+       "      <td>189.147097</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>108 rows × 5 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "    Model  Hidden Size  RNN Size  Step  Final Loss\n",
+       "0     RNN           16        32     1  372.187353\n",
+       "1     RNN           16        64     1  371.676064\n",
+       "2     RNN           16       128     1  328.199229\n",
+       "3     RNN           32        32     1  376.717708\n",
+       "4     RNN           32        64     1  369.634064\n",
+       "..    ...          ...       ...   ...         ...\n",
+       "103   GRU           32        64    30   37.214055\n",
+       "104   GRU           32       128    30   38.621485\n",
+       "105   GRU           64        32    30  120.508296\n",
+       "106   GRU           64        64    30   75.707219\n",
+       "107   GRU           64       128    30  189.147097\n",
+       "\n",
+       "[108 rows x 5 columns]"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df = pd.read_csv(\"hyperparameter_scan_results.csv\")\n",
+    "df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "2fe2d178",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 17 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from matplotlib.colors import Normalize, LogNorm\n",
+    "\n",
+    "fig, axs = plt.subplots(4, 4, figsize=(10, 10), constrained_layout=True)\n",
+    "hyperparameters = [\"Model\", \"Hidden Size\", \"RNN Size\", \"Step\"]\n",
+    "score_column = \"Final Loss\" # Validation Loss\n",
+    "\n",
+    "cmap = plt.get_cmap('viridis')\n",
+    "cnorm = LogNorm(vmin=df[score_column].min(), vmax=300)\n",
+    "\n",
+    "for i, hp1 in enumerate(hyperparameters):\n",
+    "    for j, hp2 in enumerate(hyperparameters):\n",
+    "        if i != j:\n",
+    "            values = df.pivot_table(index=hp1, columns=hp2, values=score_column, aggfunc='min')\n",
+    "            im = axs[i, j].imshow(values, aspect='auto', origin='lower', cmap=cmap, norm=cnorm)\n",
+    "            axs[i, j].set_xlabel(hp2)\n",
+    "            axs[i, j].set_ylabel(hp1)\n",
+    "            axs[i, j].set_xticks(np.arange(len(values.columns)))\n",
+    "            axs[i, j].set_xticklabels(values.columns.astype(str), rotation=45)\n",
+    "            axs[i, j].set_yticks(np.arange(len(values.index)))\n",
+    "            axs[i, j].set_yticklabels(values.index.astype(str))\n",
+    "            #axs[i, j].set_title(f'{hp1} vs {hp2}')\n",
+    "        else:\n",
+    "            values = df.groupby(hp1)[score_column].min()\n",
+    "            max_values = df.groupby(hp1)[score_column].max()\n",
+    "            axs[i, j].bar(values.index.astype(str), values.values)\n",
+    "            #axs[i, j].plot(max_values.index.astype(str), max_values.values, ls='--')\n",
+    "            #axs[i, j].set_yscale('log')\n",
+    "            axs[i, j].set_xlabel(hp1)\n",
+    "            axs[i, j].set_ylabel(score_column)\n",
+    "            #axs[i, j].set_title(f'{hp1}')\n",
+    "            axs[i, j].tick_params(axis='x', rotation=45)\n",
+    "\n",
+    "\n",
+    "#fig.subplots_adjust(right=0.88)   # tighten/loosen as needed\n",
+    "cbar = fig.colorbar(im, ax=axs, orientation='vertical', fraction=0.02, pad=0.04)\n",
+    "cbar.set_label(score_column)\n",
+    "#fig.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "495393a7",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "adsbpy",
+   "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.13.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Code/python/notebooks/hyperparameter_scan.py b/Code/python/notebooks/hyperparameter_scan.py
index fca78fd..875a4f2 100644
--- a/Code/python/notebooks/hyperparameter_scan.py
+++ b/Code/python/notebooks/hyperparameter_scan.py
@@ -1,90 +1,285 @@
 import torch
-from aiRNN import dataloader, models, losses
 import pathlib
 import pandas as pd
+from aiRNN import dataloader, models, losses
 
-file_list = pathlib.Path("../../cpp/known_routes_and_aircraft.csv")
-base_path = file_list.parent
-file_list = file_list.read_text().splitlines()
-file_list = [(base_path / f).resolve() for f in file_list if (base_path / f).exists()]
+MODE = 1
+DEVICE = "cuda"
 
-if not pathlib.Path("dataset.pt").exists():
-  dataset = dataloader.EvenlySpacedDataset(
-      filepaths=file_list,
-      n_input=30*15, # 15 minutes input
-      n_output=30*5,  # 5 minutes output
-      n_windows_per_file=7,
-      step=1,
-      feature_columns=("lat", "lon", "alt", "ias"),
-      context_columns=("last_lat", "last_lon", "last_alt", "last_ias", "last_timestamp"),
-      time_columns=("timestamp", "dt"),
-      target_columns=("lat", "lon", "alt"),
-      device="cuda",
-  )
-  dataset.save_entire_dataset("dataset.pt")
 
-results = []
-for step in [1, 5, 10, 30]:
-    dataset = dataloader.SaveDataset(torch.load("dataset.pt"), device="cuda", step=step)
-    dataset_length = len(dataset)
-    dataset, val_dataset = torch.utils.data.random_split(
+# ------------------------------------------------------------
+# Dataset creation
+# ------------------------------------------------------------
+
+def load_file_list(path: pathlib.Path):
+    base = path.parent
+    return [
+        (base / f).resolve()
+        for f in path.read_text().splitlines()
+        if (base / f).exists()
+    ]
+
+
+def ensure_dataset(path, **kwargs):
+    if not pathlib.Path(path).exists():
+        ds = dataloader.EvenlySpacedDataset(**kwargs, device=DEVICE)
+        ds.save_entire_dataset(path)
+
+
+file_list_path = pathlib.Path("../../cpp/known_routes_and_aircraft.csv")
+file_list = load_file_list(file_list_path)
+
+ensure_dataset(
+    "dataset.pt",
+    filepaths=file_list,
+    n_input=30 * 15,
+    n_output=30 * 5,
+    n_windows_per_file=7,
+    step=1,
+    feature_columns=("lat", "lon", "alt", "ias"),
+    context_columns=("last_lat", "last_lon", "last_alt", "last_ias", "last_timestamp"),
+    time_columns=("timestamp", "dt"),
+    target_columns=("lat", "lon", "alt"),
+)
+
+ensure_dataset(
+    "long_dataset.pt",
+    filepaths=file_list,
+    n_input=30 * 60,
+    n_output=30 * 60,
+    n_windows_per_file=5,
+    step=1,
+    feature_columns=("lat", "lon", "alt", "ias"),
+    context_columns=("last_lat", "last_lon", "last_alt", "last_ias", "last_timestamp"),
+    time_columns=("timestamp", "dt"),
+    target_columns=("lat", "lon", "alt"),
+)
+
+
+# ------------------------------------------------------------
+# Training utilities
+# ------------------------------------------------------------
+
+def split_dataset(dataset, frac=0.8, seed=42):
+    n = len(dataset)
+    train_n = int(frac * n)
+    return torch.utils.data.random_split(
         dataset,
-        [int(0.8 * dataset_length), dataset_length - int(0.8 * dataset_length)],
-        generator=torch.Generator().manual_seed(42)
+        [train_n, n - train_n],
+        generator=torch.Generator().manual_seed(seed),
     )
-    print(f"Starting hyperparameter scan for step={step}")
-    for base_name, base_model in [
-        ("RNN", models.ThreeInputRNN),
-        ("LSTM", models.ThreeInputLSTM),
-        ("GRU", models.ThreeInputGRU),
-    ]:
-        for hidden_size in [16, 32, 64]:
-            for rnn_size in [32, 64, 128]:
-                model = base_model(
+
+
+def train_one_model(model, dataset, val_dataset, warm_up_steps, pred_steps, epochs=100, altitude_weight=1e-3):
+    optimizer = torch.optim.Adam(model.parameters(), lr=1e-2)
+    scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=5, factor=0.5)
+    criterion = losses.HaversineAltitudeLoss(alt_const=altitude_weight)
+
+    for epoch in range(epochs):
+        batch_losses = []
+        loader = torch.utils.data.DataLoader(dataset, batch_size=256, shuffle=True, collate_fn=dataloader.collate_to_cuda(DEVICE), num_workers=4)
+
+        for X_f, X_t, y, X_c in loader:
+            optimizer.zero_grad()
+            y_pred, _ = model(X_t, X_f, X_c, warm_up_steps, pred_steps)
+            loss = criterion(y_pred, y)
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+            optimizer.step()
+            batch_losses.append(loss.item())
+
+        mean_loss = sum(batch_losses) / len(batch_losses)
+        scheduler.step(mean_loss)
+        print(f"Epoch {epoch}: loss={mean_loss}, lr={optimizer.param_groups[0]['lr']}")
+
+    # Validation
+    with torch.no_grad():
+        val_losses = []
+        val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=256, collate_fn=dataloader.collate_to_cuda(DEVICE), num_workers=4)
+        for X_f, X_t, y, X_c in val_loader:
+            y_pred, _ = model(X_t, X_f, X_c, warm_up_steps, pred_steps)
+            val_losses.append(criterion(y_pred, y).item())
+        val_loss = sum(val_losses) / len(val_losses)
+        print(f"Validation loss: {val_loss}")
+
+    return val_loss
+
+
+def save_results(results, preliminary=False):
+    if MODE == 1:
+        cols = ["Model", "Hidden Size", "RNN Size", "Step", "Final Loss"]
+    elif MODE == 2:
+        cols = ["Model", "Hidden Layers", "RNN Layers", "Dropout", "Final Loss"]
+    elif MODE == 3:
+        cols = ["Model", "Warm-up Steps", "Prediction Steps", "Altitude Weight", "Final Loss"]
+    else:
+        raise ValueError("Invalid MODE")
+
+    df = pd.DataFrame(results, columns=cols)
+    suffix = "_preliminary" if preliminary else ""
+    df.to_csv(f"hyperparameter_scan_results_mode{MODE}{suffix}.csv", index=False)
+
+
+# ------------------------------------------------------------
+# MODE 1 sweep
+# ------------------------------------------------------------
+
+def run_mode_1():
+    results = []
+
+    for step in [1, 5, 10, 30]:
+        base_ds = dataloader.SaveDataset(torch.load("dataset.pt"), step=step)
+        train_ds, val_ds = split_dataset(base_ds)
+
+        print(f"Starting hyperparameter scan for step={step}")
+
+        for name, cls in [("RNN", models.ThreeInputRNN),
+                          ("LSTM", models.ThreeInputLSTM),
+                          ("GRU", models.ThreeInputGRU)]:
+
+            for hidden_size in [16, 32, 64]:
+                for rnn_size in [32, 64, 128]:
+
+                    model = cls(
+                        time_in=2,
+                        feat_in=4,
+                        context_in=5,
+                        hidden_size=hidden_size,
+                        rnn_size=rnn_size,
+                        out_size=3,
+                        device=DEVICE,
+                    )
+
+                    warm = 450 // step
+                    pred = 150 // step
+
+                    print(f"Training {name} hs={hidden_size} rs={rnn_size}")
+
+                    loss = train_one_model(model, train_ds, val_ds, warm, pred)
+                    torch.save(model.state_dict(), f"{name}_hs{hidden_size}_rs{rnn_size}_step{step}.pt")
+
+                    results.append((name, hidden_size, rnn_size, step, loss))
+                    save_results(results, preliminary=True)
+
+    return results
+
+
+# ------------------------------------------------------------
+# MODE 2 sweep
+# ------------------------------------------------------------
+
+def run_mode_2():
+    results = []
+
+    step = 1
+    base_ds = dataloader.SaveDataset(torch.load("dataset.pt"), step=step)
+    train_ds, val_ds = split_dataset(base_ds)
+
+    base_name = "GRU"
+    cls = models.ThreeInputGRU
+    hidden_size = 32
+    rnn_size = 64
+
+    for hl in [0, 1, 2, 4]:
+        for rl in [2, 3, 4, 5]:
+            for dropout in [0.0, 0.1, 0.2, 0.3]:
+
+                model = cls(
                     time_in=2,
                     feat_in=4,
                     context_in=5,
                     hidden_size=hidden_size,
                     rnn_size=rnn_size,
                     out_size=3,
-                    device="cuda",
+                    hidden_layers=hl,
+                    rnn_layers=rl,
+                    rnn_dropout=dropout,
+                    device=DEVICE,
                 )
-                print(f"Training {base_name} with hidden_size={hidden_size}, rnn_size={rnn_size}")
-                optimizer = torch.optim.Adam(model.parameters(), lr=1e-2)
-                scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=5, factor=0.5)
-                criterion = losses.HaversineAltitudeLoss(alt_const=1e-3)
-                loss = -1.0
-                for epoch in range(100):
-                    loss_history = []
-                    for X_f, X_t, y, X_c in torch.utils.data.DataLoader(dataset, batch_size=256, shuffle=True):
-                        optimizer.zero_grad()
-                        warm_up_steps = 450 // step
-                        pred_steps = 150 // step
-                        y_pred, _ = model(X_t, X_f, X_c, warm_up_steps, pred_steps)
-                        loss = criterion(y_pred, y)
-                        loss.backward()
-                        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
-                        optimizer.step()
-                        loss_history.append(loss.item())
-                    loss = sum(loss_history) / len(loss_history)
-                    scheduler.step(loss)
-                    print(f"Epoch {epoch}: loss={loss}, lr={optimizer.param_groups[0]['lr']}")
-                with torch.no_grad():
-                    val_loss_history = []
-                    for X_f, X_t, y, X_c in torch.utils.data.DataLoader(val_dataset, batch_size=256):
-                        warm_up_steps = 450 // step
-                        pred_steps = 150 // step
-                        y_pred, _ = model(X_t, X_f, X_c, warm_up_steps, pred_steps)
-                        v_loss = criterion(y_pred, y)
-                        val_loss_history.append(v_loss.item())
-                    loss = sum(val_loss_history) / len(val_loss_history)
-                    print(f"Validation loss: {loss}")
-                torch.save(model.state_dict(), f"{base_name}_hs{hidden_size}_rs{rnn_size}_step{step}.pt")
-                results.append((base_name, hidden_size, rnn_size, step, loss))
 
-for r in results:
-    print(f"Model: {r[0]}, hidden_size={r[1]}, rnn_size={r[2]}, step={r[3]} => final loss={r[4]}")
+                warm = 450 // step
+                pred = 150 // step
 
-# Save results to CSV
-df = pd.DataFrame(results, columns=["Model", "Hidden Size", "RNN Size", "Step", "Final Loss"])
-df.to_csv("hyperparameter_scan_results.csv", index=False)
\ No newline at end of file
+                print(f"Training {base_name} hl={hl} rl={rl} do={dropout}")
+
+                loss = train_one_model(model, train_ds, val_ds, warm, pred)
+                torch.save(model.state_dict(), f"{base_name}_hl{hl}_rl{rl}_do{int(dropout*10)}.pt")
+
+                results.append((base_name, hl, rl, dropout, loss))
+                save_results(results, preliminary=True)
+
+    return results
+
+
+# ------------------------------------------------------------
+# MODE 3 sweep
+# ------------------------------------------------------------
+
+def run_mode_3():
+    results = []
+
+    step = 1
+    base_name = "GRU"
+    cls = models.ThreeInputGRU
+    hidden_size = 32
+    rnn_size = 64
+    hidden_layers = 1
+    rnn_layers = 3
+    rnn_dropout = 0.1
+
+    for warm in [300, 600, 900, 1800]:
+        for pred in [150, 300, 600, 900, 1800]:
+            start = 30 * 60 - warm
+            end = 30 * 60 - pred
+
+            base_ds = dataloader.SaveDataset(
+                torch.load("long_dataset.pt"),
+                step=step,
+                start_offset=start,
+                end_offset=end,
+            )
+
+            train_ds, val_ds = split_dataset(base_ds)
+
+            for altitude_weight in [1e-5, 1e-4, 1e-3]:
+
+
+
+                model = cls(
+                    time_in=2,
+                    feat_in=4,
+                    context_in=5,
+                    hidden_size=hidden_size,
+                    rnn_size=rnn_size,
+                    out_size=3,
+                    hidden_layers=hidden_layers,
+                    rnn_layers=rnn_layers,
+                    rnn_dropout=rnn_dropout,
+                    device=DEVICE,
+                )
+
+                print(f"Training {base_name} warm={warm} pred={pred} altitude_weight={altitude_weight}")
+
+                loss = train_one_model(model, train_ds, val_ds, warm // step, pred // step, altitude_weight=altitude_weight)
+                torch.save(model.state_dict(), f"{base_name}_wu{warm}_ps{pred}_aw{altitude_weight}.pt")
+
+                results.append((base_name, warm, pred, altitude_weight, loss))
+                save_results(results, preliminary=True)
+
+    return results
+
+
+# ------------------------------------------------------------
+# Dispatch
+# ------------------------------------------------------------
+
+if MODE == 1:
+    results = run_mode_1()
+elif MODE == 2:
+    results = run_mode_2()
+elif MODE == 3:
+    results = run_mode_3()
+else:
+    raise ValueError("Invalid MODE.")
+
+save_results(results)
diff --git a/Code/python/notebooks/hyperparameter_scan_results.csv b/Code/python/notebooks/hyperparameter_scan_results.csv
new file mode 100644
index 0000000..45b10cc
--- /dev/null
+++ b/Code/python/notebooks/hyperparameter_scan_results.csv
@@ -0,0 +1,109 @@
+Model,Hidden Size,RNN Size,Step,Final Loss
+RNN,16,32,1,372.1873533829399
+RNN,16,64,1,371.67606353759766
+RNN,16,128,1,328.19922903309697
+RNN,32,32,1,376.71770842179006
+RNN,32,64,1,369.6340640524159
+RNN,32,128,1,281.8589802617612
+RNN,64,32,1,378.75125188412875
+RNN,64,64,1,405.08673095703125
+RNN,64,128,1,1088.4633191979449
+LSTM,16,32,1,152.01849580847698
+LSTM,16,64,1,152.46532937754756
+LSTM,16,128,1,39.81503051260243
+LSTM,32,32,1,45.500295265861176
+LSTM,32,64,1,51.218478575996734
+LSTM,32,128,1,32.29804623645285
+LSTM,64,32,1,105.44863045733908
+LSTM,64,64,1,62.87264318051545
+LSTM,64,128,1,170.77305080579674
+GRU,16,32,1,23.525951261105746
+GRU,16,64,1,20.953380501788594
+GRU,16,128,1,50.10249718375828
+GRU,32,32,1,149.08109225397524
+GRU,32,64,1,40.437404922817066
+GRU,32,128,1,34.31250389762547
+GRU,64,32,1,154.5310813240383
+GRU,64,64,1,47.95653426128885
+GRU,64,128,1,263.4846937760063
+RNN,16,32,5,326.2015085634978
+RNN,16,64,5,384.77328723409903
+RNN,16,128,5,1099.3475819463315
+RNN,32,32,5,246.47076250159222
+RNN,32,64,5,329.85308439835256
+RNN,32,128,5,1098.7943765391474
+RNN,64,32,5,477.369012583857
+RNN,64,64,5,365.6013999607252
+RNN,64,128,5,413.95318603515625
+LSTM,16,32,5,24.514795303344727
+LSTM,16,64,5,24.9299375285273
+LSTM,16,128,5,34.382882035296895
+LSTM,32,32,5,171.14435179337212
+LSTM,32,64,5,185.21222504325536
+LSTM,32,128,5,24.800554503565248
+LSTM,64,32,5,183.13448831309444
+LSTM,64,64,5,37.47129328354545
+LSTM,64,128,5,51.097612007804535
+GRU,16,32,5,30.631973432457965
+GRU,16,64,5,30.393669625987176
+GRU,16,128,5,55.05557930987814
+GRU,32,32,5,54.14869615306025
+GRU,32,64,5,167.3384770932405
+GRU,32,128,5,50.49319474593453
+GRU,64,32,5,170.90516430398694
+GRU,64,64,5,153.55044091266134
+GRU,64,128,5,53.40392129317574
+RNN,16,32,10,285.0945102857507
+RNN,16,64,10,361.18107339610225
+RNN,16,128,10,320.00166884712553
+RNN,32,32,10,359.23063095756197
+RNN,32,64,10,351.7510011092476
+RNN,32,128,10,126.81333442356275
+RNN,64,32,10,336.1739501953125
+RNN,64,64,10,342.61622918170434
+RNN,64,128,10,208.79256007982337
+LSTM,16,32,10,47.18654777692712
+LSTM,16,64,10,35.0142301061879
+LSTM,16,128,10,31.15265079166578
+LSTM,32,32,10,57.50707398290219
+LSTM,32,64,10,21.263865159905475
+LSTM,32,128,10,39.93263937079388
+LSTM,64,32,10,57.33804578366487
+LSTM,64,64,10,52.7249521587206
+LSTM,64,128,10,59.768143446549125
+GRU,16,32,10,28.489941555520762
+GRU,16,64,10,25.493946241295856
+GRU,16,128,10,35.874996682871945
+GRU,32,32,10,39.71779649154
+GRU,32,64,10,33.58222509467083
+GRU,32,128,10,36.87489372750987
+GRU,64,32,10,55.22760449285092
+GRU,64,64,10,168.17254008417544
+GRU,64,128,10,76.96743749535602
+RNN,16,32,30,245.38945504893428
+RNN,16,64,30,303.7835593845533
+RNN,16,128,30,1168.2417987325916
+RNN,32,32,30,221.63304668924084
+RNN,32,64,30,274.024205746858
+RNN,32,128,30,1167.9884391452956
+RNN,64,32,30,316.6191160782524
+RNN,64,64,30,252.00204235574475
+RNN,64,128,30,1168.0314676036005
+LSTM,16,32,30,46.3279622119406
+LSTM,16,64,30,32.77271196116572
+LSTM,16,128,30,1168.1180778171706
+LSTM,32,32,30,192.53192719169286
+LSTM,32,64,30,40.278250404026195
+LSTM,32,128,30,35.424202234848686
+LSTM,64,32,30,51.08382113083549
+LSTM,64,64,30,186.7356419770614
+LSTM,64,128,30,177.50895442133364
+GRU,16,32,30,35.31677892933721
+GRU,16,64,30,34.573822394661285
+GRU,16,128,30,55.778304846390434
+GRU,32,32,30,65.31020172782566
+GRU,32,64,30,37.21405522719674
+GRU,32,128,30,38.621485295503035
+GRU,64,32,30,120.50829563970152
+GRU,64,64,30,75.70721891651984
+GRU,64,128,30,189.14709671683934
diff --git a/Code/python/src/aiRNN/dataloader.py b/Code/python/src/aiRNN/dataloader.py
index c94aa66..02da58c 100644
--- a/Code/python/src/aiRNN/dataloader.py
+++ b/Code/python/src/aiRNN/dataloader.py
@@ -126,31 +126,53 @@ class BaseDataset(Dataset):
         torch.save(data_dict, filepath)
 
 class SaveDataset(Dataset):
-    def __init__(self, data_dict, device="cpu", step=1):
+    def __init__(self, data_dict, step=1, start_offset=0, end_offset=0):
         super().__init__()
-        self.X_feat = data_dict["X_feat"].to(device)
-        self.X_time = data_dict["X_time"].to(device)
-        self.Y_out = data_dict["Y_out"].to(device)
         self.step = step
-        self.device = device
-        if "X_context" in data_dict:
-            self.X_context = data_dict["X_context"].to(device)
-        else:
-            self.X_context = None
+        self.start_offset = start_offset // step
+        self.end_offset = end_offset // step
+
+        # Keep everything **on CPU**
+        self.X_feat = data_dict["X_feat"]
+        self.X_time = data_dict["X_time"]
+        self.Y_out = data_dict["Y_out"]
+        self.X_context = data_dict.get("X_context", None)
+
+        # Precompute slice indices (avoids Python overhead in worker processes)
+        max_len = self.X_time.shape[1]
+        t0 = self.start_offset
+        t1 = max_len - self.end_offset
+        self.idx_feat = torch.arange(t0, self.X_feat.shape[1], self.step)
+        self.idx_time = torch.arange(t0, t1, self.step)
+        self.idx_out = torch.arange(0, self.Y_out.shape[1] - self.end_offset, self.step)
 
     def __len__(self):
         return self.X_feat.shape[0]
 
     def __getitem__(self, idx):
-        X_f = self.X_feat[idx,::self.step]
-        X_t = self.X_time[idx,::self.step]
-        Y = self.Y_out[idx,::self.step]
-        if self.X_context is not None:
-            X_c = self.X_context[idx]
-        else:
-            X_c = None
+        X_f = self.X_feat[idx].index_select(0, self.idx_feat)
+        X_t = self.X_time[idx].index_select(0, self.idx_time)
+        Y   = self.Y_out[idx].index_select(0, self.idx_out)
+        X_c = self.X_context[idx] if self.X_context is not None else None
         return X_f, X_t, Y, X_c
 
+def collate_to_cuda(device):
+    def _collate(batch):
+        Xf, Xt, Y, Xc = zip(*batch)
+
+        Xf = torch.stack(Xf).to(device)
+        Xt = torch.stack(Xt).to(device)
+        Y  = torch.stack(Y).to(device)
+
+        if Xc[0] is not None:
+            Xc = torch.stack(Xc).to(device)
+        else:
+            Xc = None
+
+        return Xf, Xt, Y, Xc
+    return _collate
+
+
 class EvenlySpacedDataset(BaseDataset):
     def __init__(
         self,
diff --git a/Code/python/src/aiRNN/models.py b/Code/python/src/aiRNN/models.py
index 15b472d..d7061df 100644
--- a/Code/python/src/aiRNN/models.py
+++ b/Code/python/src/aiRNN/models.py
@@ -4,16 +4,24 @@ import torch.nn as nn
 
 class BaseRNN(nn.Module):
     def __init__(self, time_in, feat_in, context_in, hidden_size,
-                 rnn_size, out_size, rnn_type="RNN", device="cpu"):
+                 rnn_size, out_size, hidden_layers=1, rnn_layers=3, rnn_dropout=0.0, rnn_type="RNN", device="cpu"):
         super().__init__()
 
-        base_unit = lambda in_size, out_size: nn.Sequential(
-            nn.Linear(in_size, out_size, device=device),
-            nn.GELU(),
-            nn.Linear(out_size, out_size, device=device),
-            nn.GELU(),
-            nn.LayerNorm(out_size, device=device)
-        )
+        def base_unit(in_size, out_size):
+            layers = []
+
+            # First projection
+            layers.append(nn.Linear(in_size, out_size, device=device))
+            layers.append(nn.GELU())
+
+            # Hidden repeated blocks: (Linear → GELU) * hidden_layers
+            for _ in range(hidden_layers):
+                layers.append(nn.Linear(out_size, out_size, device=device))
+                layers.append(nn.GELU())
+
+            # Final normalization
+            layers.append(nn.LayerNorm(out_size, device=device))
+            return nn.Sequential(*layers)
 
         self.time_proj = base_unit(time_in, hidden_size)
         self.feat_proj = base_unit(feat_in, hidden_size)
@@ -25,24 +33,27 @@ class BaseRNN(nn.Module):
             self.rnn = nn.RNN(
                 input_size=hidden_size*3,
                 hidden_size=rnn_size,
-                num_layers=3,
+                num_layers=rnn_layers,
                 batch_first=True,
+                dropout=rnn_dropout,
                 device=device
             )
         elif rnn_type == "LSTM":
             self.rnn = nn.LSTM(
                 input_size=hidden_size*3,
                 hidden_size=rnn_size,
-                num_layers=3,
+                num_layers=rnn_layers,
                 batch_first=True,
+                dropout=rnn_dropout,
                 device=device
             )
         elif rnn_type == "GRU":
             self.rnn = nn.GRU(
                 input_size=hidden_size*3,
                 hidden_size=rnn_size,
-                num_layers=3,
+                num_layers=rnn_layers,
                 batch_first=True,
+                dropout=rnn_dropout,
                 device=device
             )
         else:
@@ -101,8 +112,8 @@ class TwoInputRNN(BaseRNN):
     After init_steps, only time inputs are provided and the model predicts a sequence.
     Predictions can be compared to targets with a specified `offset`.
     """
-    def __init__(self, time_in, feat_in, hidden_size, rnn_size, out_size, device="cpu"):
-        super().__init__(time_in, feat_in, context_in=None, hidden_size=hidden_size, rnn_size=rnn_size, out_size=out_size, device=device)
+    def __init__(self, time_in, feat_in, hidden_size, rnn_size, out_size, hidden_layers=1, rnn_layers=3, rnn_dropout=0.0, device="cpu"):
+        super().__init__(time_in, feat_in, context_in=None, hidden_size=hidden_size, rnn_size=rnn_size, out_size=out_size, hidden_layers=hidden_layers, rnn_layers=rnn_layers, rnn_dropout=rnn_dropout, device=device)
 
 class ThreeInputRNN(BaseRNN):
     """
@@ -113,8 +124,8 @@ class ThreeInputRNN(BaseRNN):
     After init_steps, only time and context inputs are provided and the model predicts a sequence.
     Predictions can be compared to targets with a specified `offset`.
     """
-    def __init__(self, time_in, feat_in, context_in, hidden_size, rnn_size, out_size, device="cpu"):
-        super().__init__(time_in, feat_in, context_in=context_in, hidden_size=hidden_size, rnn_size=rnn_size, out_size=out_size, device=device)
+    def __init__(self, time_in, feat_in, context_in, hidden_size, rnn_size, out_size, hidden_layers=1, rnn_layers=3, rnn_dropout=0.0, device="cpu"):
+        super().__init__(time_in, feat_in, context_in=context_in, hidden_size=hidden_size, rnn_size=rnn_size, out_size=out_size, hidden_layers=hidden_layers, rnn_layers=rnn_layers, rnn_dropout=rnn_dropout, device=device)
 
 class TwoInputLSTM(BaseRNN):
     """
@@ -124,8 +135,8 @@ class TwoInputLSTM(BaseRNN):
     After init_steps, only time inputs are provided and the model predicts a sequence.
     Predictions can be compared to targets with a specified `offset`.
     """
-    def __init__(self, time_in, feat_in, hidden_size, rnn_size, out_size, device="cpu"):
-        super().__init__(time_in, feat_in, context_in=None, hidden_size=hidden_size, rnn_size=rnn_size, out_size=out_size, rnn_type="LSTM", device=device)
+    def __init__(self, time_in, feat_in, hidden_size, rnn_size, out_size, hidden_layers=1, rnn_layers=3, rnn_dropout=0.0, device="cpu"):
+        super().__init__(time_in, feat_in, context_in=None, hidden_size=hidden_size, rnn_size=rnn_size, out_size=out_size, hidden_layers=hidden_layers, rnn_layers=rnn_layers, rnn_dropout=rnn_dropout, rnn_type="LSTM", device=device)
 
 class ThreeInputLSTM(BaseRNN):
     """
@@ -136,8 +147,8 @@ class ThreeInputLSTM(BaseRNN):
     After init_steps, only time and context inputs are provided and the model predicts a sequence.
     Predictions can be compared to targets with a specified `offset`.
     """
-    def __init__(self, time_in, feat_in, context_in, hidden_size, rnn_size, out_size, device="cpu"):
-        super().__init__(time_in, feat_in, context_in=context_in, hidden_size=hidden_size, rnn_size=rnn_size, out_size=out_size, rnn_type="LSTM", device=device)
+    def __init__(self, time_in, feat_in, context_in, hidden_size, rnn_size, out_size, hidden_layers=1, rnn_layers=3, rnn_dropout=0.0, device="cpu"):
+        super().__init__(time_in, feat_in, context_in=context_in, hidden_size=hidden_size, rnn_size=rnn_size, out_size=out_size, hidden_layers=hidden_layers, rnn_layers=rnn_layers, rnn_dropout=rnn_dropout, rnn_type="LSTM", device=device)
 
 class TwoInputGRU(BaseRNN):
     """
@@ -147,8 +158,8 @@ class TwoInputGRU(BaseRNN):
     After init_steps, only time inputs are provided and the model predicts a sequence.
     Predictions can be compared to targets with a specified `offset`.
     """
-    def __init__(self, time_in, feat_in, hidden_size, rnn_size, out_size, device="cpu"):
-        super().__init__(time_in, feat_in, context_in=None, hidden_size=hidden_size, rnn_size=rnn_size, out_size=out_size, rnn_type="GRU", device=device)
+    def __init__(self, time_in, feat_in, hidden_size, rnn_size, out_size, hidden_layers=1, rnn_layers=3, rnn_dropout=0.0, device="cpu"):
+        super().__init__(time_in, feat_in, context_in=None, hidden_size=hidden_size, rnn_size=rnn_size, out_size=out_size, hidden_layers=hidden_layers, rnn_layers=rnn_layers, rnn_dropout=rnn_dropout, rnn_type="GRU", device=device)
 
 class ThreeInputGRU(BaseRNN):
     """
@@ -159,5 +170,9 @@ class ThreeInputGRU(BaseRNN):
     After init_steps, only time and context inputs are provided and the model predicts a sequence.
     Predictions can be compared to targets with a specified `offset`.
     """
-    def __init__(self, time_in, feat_in, context_in, hidden_size, rnn_size, out_size, device="cpu"):
-        super().__init__(time_in, feat_in, context_in=context_in, hidden_size=hidden_size, rnn_size=rnn_size, out_size=out_size, rnn_type="GRU", device=device)
\ No newline at end of file
+    def __init__(self, time_in, feat_in, context_in, hidden_size, rnn_size, out_size, hidden_layers=1, rnn_layers=3, rnn_dropout=0.0, device="cpu"):
+        super().__init__(time_in, feat_in, context_in=context_in, hidden_size=hidden_size, rnn_size=rnn_size, out_size=out_size, hidden_layers=hidden_layers, rnn_layers=rnn_layers, rnn_dropout=rnn_dropout, rnn_type="GRU", device=device)
+
+
+OptimalRNN_cuda = ThreeInputGRU(time_in=2, feat_in=4, context_in=5, hidden_size=32, rnn_size=64, out_size=3, device="cuda")
+OptimalRNN_cpu = ThreeInputGRU(time_in=2, feat_in=4, context_in=5, hidden_size=32, rnn_size=64, out_size=3, device="cpu")
\ No newline at end of file