diff --git a/POET_Training.ipynb b/POET_Training.ipynb
index 9bbcbb7..7f292b0 100644
--- a/POET_Training.ipynb
+++ b/POET_Training.ipynb
@@ -27,18 +27,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 47,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2025-01-14 17:26:34.798886: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
-      "2025-01-14 17:26:34.825591: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
-      "To enable the following instructions: SSE4.1 SSE4.2 AVX AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -57,7 +48,9 @@
     "import time\n",
     "import sklearn.model_selection as sk\n",
     "import matplotlib.pyplot as plt\n",
-    "from sklearn.cluster import KMeans"
+    "from sklearn.cluster import KMeans\n",
+    "from imblearn.over_sampling import SMOTE\n",
+    "from collections import Counter"
    ]
   },
   {
@@ -69,7 +62,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 116,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -102,7 +95,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
@@ -188,7 +181,7 @@
     }
    ],
    "source": [
-    "model = keras.Sequential(\n",
+    "model_simple = keras.Sequential(\n",
     "    [\n",
     "        keras.Input(shape = (12,), dtype = \"float32\"),\n",
     "        keras.layers.Dense(units = 128, activation = \"relu\", dtype = \"float32\"),\n",
@@ -197,8 +190,112 @@
     "    ]\n",
     ")\n",
     "\n",
-    "model.compile(optimizer=optimizer, loss = loss)\n",
-    "model.summary()"
+    "model_simple.compile(optimizer=optimizer, loss = loss)\n",
+    "model_simple.summary()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 117,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential_4\"</span>\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[1mModel: \"sequential_4\"\u001b[0m\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃<span style=\"font-weight: bold\"> Layer (type)                    </span>┃<span style=\"font-weight: bold\"> Output Shape           </span>┃<span style=\"font-weight: bold\">       Param # </span>┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ dense_15 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">512</span>)            │         <span style=\"color: #00af00; text-decoration-color: #00af00\">6,656</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_16 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1024</span>)           │       <span style=\"color: #00af00; text-decoration-color: #00af00\">525,312</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_17 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">512</span>)            │       <span style=\"color: #00af00; text-decoration-color: #00af00\">524,800</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_18 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>)             │         <span style=\"color: #00af00; text-decoration-color: #00af00\">6,156</span> │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃\u001b[1m \u001b[0m\u001b[1mLayer (type)                   \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape          \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      Param #\u001b[0m\u001b[1m \u001b[0m┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ dense_15 (\u001b[38;5;33mDense\u001b[0m)                │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m512\u001b[0m)            │         \u001b[38;5;34m6,656\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_16 (\u001b[38;5;33mDense\u001b[0m)                │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1024\u001b[0m)           │       \u001b[38;5;34m525,312\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_17 (\u001b[38;5;33mDense\u001b[0m)                │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m512\u001b[0m)            │       \u001b[38;5;34m524,800\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_18 (\u001b[38;5;33mDense\u001b[0m)                │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m)             │         \u001b[38;5;34m6,156\u001b[0m │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">1,062,924</span> (4.05 MB)\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m1,062,924\u001b[0m (4.05 MB)\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">1,062,924</span> (4.05 MB)\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m1,062,924\u001b[0m (4.05 MB)\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "model_large =   keras.Sequential(\n",
+    "    [keras.layers.Input(shape=(12,), dtype=dtype),\n",
+    "     keras.layers.Dense(512, activation='relu', dtype=dtype),\n",
+    "     keras.layers.Dense(1024, activation='relu', dtype=dtype),\n",
+    "     keras.layers.Dense(512, activation='relu', dtype=dtype),\n",
+    "     keras.layers.Dense(12, dtype=dtype)\n",
+    "     ])\n",
+    "\n",
+    "model_large.compile(optimizer=optimizer, loss = loss)\n",
+    "model_large.summary()\n"
    ]
   },
   {
@@ -210,7 +307,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -234,7 +331,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 55,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -280,7 +377,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": 86,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -304,7 +401,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 50,
+   "execution_count": 87,
    "metadata": {},
    "outputs": [
     {
@@ -319,36 +416,58 @@
    "source": [
     "# widget with slider for the index\n",
     "\n",
-    "class_label = np.array([])\n",
+    "class_label_design = np.array([])\n",
+    "class_label_result = np.array([])\n",
+    "\n",
+    "\n",
     "i = 1000\n",
     "for i in range(0,1001):\n",
-    "    field = np.array(df_design['Barite'][(i*2500):(i*2500+2500)]).reshape(50,50)\n",
-    "    kmeans = KMeans(n_clusters=2, random_state=0).fit(field.reshape(-1,1))\n",
-    "    class_label = np.append(class_label.astype(int), kmeans.labels_)\n",
+    "    field_design = np.array(df_design['Barite'][(i*2500):(i*2500+2500)]).reshape(50,50)\n",
+    "    field_result = np.array(df_results['Barite'][(i*2500):(i*2500+2500)]).reshape(50,50)\n",
+    "    \n",
+    "    kmeans_design = KMeans(n_clusters=2, random_state=0).fit(field_design.reshape(-1,1))\n",
+    "    kmeans_result = KMeans(n_clusters=2, random_state=0).fit(field_result.reshape(-1,1))\n",
+    "    \n",
+    "    class_label_design = np.append(class_label_design.astype(int), kmeans_design.labels_)\n",
+    "    class_label_result = np.append(class_label_result.astype(int), kmeans_result.labels_)\n",
+    "    \n",
     "\n",
     "\n",
-    "class_label = pd.DataFrame(class_label, columns = [\"Class\"])\n",
-    "\n"
+    "class_label_design = pd.DataFrame(class_label_design, columns = [\"Class\"])\n",
+    "class_label_result = pd.DataFrame(class_label_result, columns = [\"Class\"])\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 88,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if(\"Class\" in df_design.columns and \"Class\" in df_results.columns):\n",
+    "    print(\"Class column already exists\")\n",
+    "else:\n",
+    "    df_design = pd.concat([df_design, class_label_design], axis=1)\n",
+    "    df_results = pd.concat([df_results, class_label_design], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 89,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7b603017f510>"
+       "<matplotlib.contour.QuadContourSet at 0x7aa0eb5a9e90>"
       ]
      },
-     "execution_count": 30,
+     "execution_count": 89,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -358,33 +477,336 @@
     }
    ],
    "source": [
-    "i = 1000\n",
-    "plt.imshow(class_label[(i*2500):(i*2500+2500)].reshape(50,50)) "
+    "i=1000\n",
+    "\n",
+    "plt.imshow(np.array(df_results['Barite'][(i*2500):(i*2500+2500)]).reshape(50,50), interpolation='bicubic', origin='lower')\n",
+    "plt.contour(np.array(df_results['Class'][(i*2500):(i*2500+2500)]).reshape(50,50), levels=[0.1], colors='red', origin='lower')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Split into Training and Testing datsets"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 52,
+   "execution_count": 90,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_train, X_test, y_train, y_test = sk.train_test_split(df_design, df_results, test_size = 0.2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Perform SMOT Sampling on dataset to balance classes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 91,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Counter(df_design['Class'])\n",
+    "oversample = SMOTE()\n",
+    "\n",
+    "design_resampled, design_classes_resampled = oversample.fit_resample(X_train.iloc[:, :-1], X_train.iloc[:, -1])\n",
+    "target_resampled, target_classes_resampled = oversample.fit_resample(y_train.iloc[:, :-1], y_train.iloc[:, -1])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 94,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_train = pd.concat([design_resampled, design_classes_resampled], axis=1)\n",
+    "y_train = pd.concat([target_resampled, target_classes_resampled], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Define Scaling and Normalization Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 96,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def log_scale(df_design, df_result, func_dict):\n",
+    "    \n",
+    "    df_design = df_design.copy()\n",
+    "    df_result = df_result.copy()\n",
+    "    \n",
+    "    for key in df_design.keys():\n",
+    "        if key != \"Class\":\n",
+    "            df_design[key] = np.vectorize(func_dict[key])(df_design[key])\n",
+    "            df_result[key] = np.vectorize(func_dict[key])(df_result[key])\n",
+    "        \n",
+    "    return df_design, df_result\n",
+    "\n",
+    "# Get minimum and maximum values for each column\n",
+    "def get_min_max(df_design, df_result):\n",
+    "    \n",
+    "    min_vals_des = df_design.min()\n",
+    "    max_vals_des = df_design.max()\n",
+    "    \n",
+    "    min_vals_res = df_result.min()\n",
+    "    max_vals_res = df_result.max()\n",
+    "\n",
+    "    # minimum of input and output data to get global minimum/maximum\n",
+    "    data_min = np.minimum(min_vals_des, min_vals_res).to_dict()\n",
+    "    data_max = np.maximum(max_vals_des, max_vals_res).to_dict()\n",
+    "\n",
+    "    return data_min, data_max\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_design_log, df_results_log = log_scale(df_design, df_results, func_dict_in)\n",
+    "data_min_log, data_max_log = get_min_max(df_design_log, df_results_log)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 101,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_train_log, y_train_log = log_scale(X_train, y_train, func_dict_in)\n",
+    "X_test_log, y_test_log = log_scale(X_test, y_test, func_dict_in)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 102,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_min_log, train_max_log = get_min_max(X_train_log, y_train_log)\n",
+    "test_min_log, test_max_log = get_min_max(X_test_log, y_test_log)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 100,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def preprocess(data, func_dict, data_min, data_max):\n",
+    "    data = data.copy()\n",
+    "    for key in data.keys():\n",
+    "        if key != \"Class\":\n",
+    "            data[key] = (data[key] - data_min[key]) / (data_max[key] - data_min[key])\n",
+    "\n",
+    "    return data\n",
+    "\n",
+    "def postprocess(data, func_dict, data_min, data_max):\n",
+    "    data = data.copy()\n",
+    "    for key in data.keys():\n",
+    "        if key != \"Class\":\n",
+    "            data[key] = data[key] * (data_max[key] - data_min[key]) + data_min[key]\n",
+    "            data[key] = np.vectorize(func_dict[key])(data[key])\n",
+    "    return data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Preprocess the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pp_design = preprocess(df_design_log, func_dict_in, data_min_log, data_max_log)\n",
+    "pp_results = preprocess(df_results_log, func_dict_in, data_min_log, data_max_log)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 103,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_train_preprocess = preprocess(X_train_log, func_dict_in, train_min_log, train_max_log)\n",
+    "y_train_preprocess = preprocess(y_train_log, func_dict_in, train_min_log, train_max_log)\n",
+    "\n",
+    "X_test_preprocess = preprocess(X_test_log, func_dict_in, test_min_log, test_max_log)\n",
+    "y_test_preprocess = preprocess(y_test_log, func_dict_in, test_min_log, test_max_log)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Sample the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 105,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_train, X_val, y_train, y_val = sk.train_test_split(X_train_preprocess, y_train_preprocess, test_size = 0.1)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Custom Loss function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def custom_loss_H20(df_design_log, df_result_log, data_min_log, data_max_log, func_dict_out, postprocess):\n",
+    "    df_result = postprocess(df_result_log, func_dict_out, data_min_log, data_max_log)    \n",
+    "    return keras.losses.Huber + np.sum(((df_result['H'] / df_result['O']) - 2)**2)\n",
+    "\n",
+    "def loss_wrapper(data_min_log, data_max_log, func_dict_out, postprocess):\n",
+    "    def loss(df_design_log, df_result_log):\n",
+    "        return custom_loss_H20(df_design_log, df_result_log, data_min_log, data_max_log, func_dict_out, postprocess)\n",
+    "    return loss"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 106,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(3559968, 12)"
+      ]
+     },
+     "execution_count": 106,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X_train.iloc[:, :-1].shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Train the model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Class column already exists\n"
+      "Epoch 1/50\n",
+      "\u001b[1m6954/6954\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m91s\u001b[0m 13ms/step - loss: 0.0070 - val_loss: 0.0066\n",
+      "Epoch 2/50\n",
+      "\u001b[1m6954/6954\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m104s\u001b[0m 15ms/step - loss: 0.0066 - val_loss: 0.0066\n",
+      "Epoch 3/50\n",
+      "\u001b[1m1147/6954\u001b[0m \u001b[32m━━━\u001b[0m\u001b[37m━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m2:01\u001b[0m 21ms/step - loss: 0.0066"
      ]
     }
    ],
    "source": [
-    "if(\"Class\" in df_design.columns):\n",
-    "    print(\"Class column already exists\")\n",
-    "else:\n",
-    "    df_design = pd.concat([df_design, class_label], axis=1)"
+    "# measure time\n",
+    "start = time.time()\n",
+    "\n",
+    "history = model_large.fit(X_train.iloc[:, :-1], \n",
+    "            y_train.iloc[:, :-1], \n",
+    "            batch_size = batch_size, \n",
+    "            epochs = epochs, \n",
+    "            validation_data = (X_val.iloc[:,:-1], y_val.iloc[:, :-1])\n",
+    ")\n",
+    "\n",
+    "end = time.time()\n",
+    "\n",
+    "print(\"Training took {} seconds\".format(end - start))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 53,
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(history.history[\"loss\"], \"o-\", label = \"Training Loss\")\n",
+    "plt.xlabel(\"Epoch\")\n",
+    "# plt.yscale('log')\n",
+    "plt.ylabel(\"Loss (Huber)\")\n",
+    "plt.grid('on')\n",
+    "\n",
+    "plt.savefig(\"loss_all.png\", dpi=300)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(history.history[\"loss\"][1:], \"o-\", label = \"Training Loss\")\n",
+    "plt.xlabel(\"Epoch\")\n",
+    "# plt.yscale('log')\n",
+    "plt.ylabel(\"Loss (Huber)\")\n",
+    "plt.grid('on')\n",
+    "plt.savefig(\"loss_1_to_end.png\", dpi=300)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
    "metadata": {},
    "outputs": [
     {
@@ -648,7 +1070,7 @@
        "[2502500 rows x 13 columns]"
       ]
      },
-     "execution_count": 53,
+     "execution_count": 42,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -657,318 +1079,6 @@
     "df_design"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Define Scaling and Normalization Functions"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 58,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def log_scale(df_design, df_result, func_dict):\n",
-    "    \n",
-    "    df_design = df_design.copy()\n",
-    "    df_result = df_result.copy()\n",
-    "    \n",
-    "    for key in df_design.keys():\n",
-    "        if key != \"Class\":\n",
-    "            df_design[key] = np.vectorize(func_dict[key])(df_design[key])\n",
-    "            df_result[key] = np.vectorize(func_dict[key])(df_result[key])\n",
-    "        \n",
-    "    return df_result, df_design\n",
-    "\n",
-    "# Get minimum and maximum values for each column\n",
-    "def get_min_max(df_design, df_result):\n",
-    "    \n",
-    "    min_vals_des = df_design.min()\n",
-    "    max_vals_des = df_design.max()\n",
-    "    \n",
-    "    min_vals_res = df_result.min()\n",
-    "    max_vals_res = df_result.max()\n",
-    "\n",
-    "    # minimum of input and output data to get global minimum/maximum\n",
-    "    data_min = np.minimum(min_vals_des, min_vals_res).to_dict()\n",
-    "    data_max = np.maximum(max_vals_des, max_vals_res).to_dict()\n",
-    "\n",
-    "    return data_min, data_max\n",
-    "\n",
-    "\n",
-    "df_design_log, df_results_log = log_scale(df_design, df_results, func_dict_in)\n",
-    "data_min_log, data_max_log = get_min_max(df_design_log, df_results_log)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 61,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def preprocess(data, func_dict, data_min, data_max):\n",
-    "    data = data.copy()\n",
-    "    for key in data.keys():\n",
-    "        if key != \"Class\":\n",
-    "            data[key] = (data[key] - data_min[key]) / (data_max[key] - data_min[key])\n",
-    "\n",
-    "    return data\n",
-    "\n",
-    "def postprocess(data, func_dict, data_min, data_max):\n",
-    "    data = data.copy()\n",
-    "    for key in data.keys():\n",
-    "        if key != \"Class\":\n",
-    "            data[key] = data[key] * (data_max[key] - data_min[key]) + data_min[key]\n",
-    "            data[key] = np.vectorize(func_dict[key])(data[key])\n",
-    "    return data"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Preprocess the data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 62,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pp_design = preprocess(df_design_log, func_dict_in, data_min_log, data_max_log)\n",
-    "pp_results = preprocess(df_results_log, func_dict_in, data_min_log, data_max_log)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Sample the data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "X_train, X_test, y_train, y_test = sk.train_test_split(pp_design, pp_results, test_size = 0.2)\n",
-    "X_train, X_val, y_train, y_val = sk.train_test_split(X_train, y_train, test_size = 0.1)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Custom Loss function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def custom_loss_H20(df_design_log, df_result_log, data_min_log, data_max_log, func_dict_out, postprocess):\n",
-    "    df_result = postprocess(df_result_log, func_dict_out, data_min_log, data_max_log)    \n",
-    "    return keras.losses.Huber + np.sum(((df_result['H'] / df_result['O']) - 2)**2)\n",
-    "\n",
-    "def loss_wrapper(data_min_log, data_max_log, func_dict_out, postprocess):\n",
-    "    def loss(df_design_log, df_result_log):\n",
-    "        return custom_loss_H20(df_design_log, df_result_log, data_min_log, data_max_log, func_dict_out, postprocess)\n",
-    "    return loss"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Train the model"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Epoch 1/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 2ms/step - loss: 0.0015 - val_loss: 1.2993e-06\n",
-      "Epoch 2/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 1.3182e-06 - val_loss: 1.1714e-06\n",
-      "Epoch 3/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 1.4322e-06 - val_loss: 1.4424e-06\n",
-      "Epoch 4/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 1.1811e-06 - val_loss: 1.1027e-06\n",
-      "Epoch 5/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 1.0509e-06 - val_loss: 1.1202e-06\n",
-      "Epoch 6/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 7.9101e-07 - val_loss: 1.0344e-06\n",
-      "Epoch 7/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 8.5978e-07 - val_loss: 1.0202e-06\n",
-      "Epoch 8/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 7.6363e-07 - val_loss: 1.5508e-06\n",
-      "Epoch 9/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 8.2612e-07 - val_loss: 1.0281e-06\n",
-      "Epoch 10/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 7.8237e-07 - val_loss: 9.6918e-07\n",
-      "Epoch 11/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 7.8727e-07 - val_loss: 9.8902e-07\n",
-      "Epoch 12/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 7.2731e-07 - val_loss: 9.4628e-07\n",
-      "Epoch 13/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 2ms/step - loss: 6.2018e-07 - val_loss: 1.0144e-06\n",
-      "Epoch 14/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 6.0086e-07 - val_loss: 9.9860e-07\n",
-      "Epoch 15/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 6.6483e-07 - val_loss: 9.5001e-07\n",
-      "Epoch 16/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 6.8847e-07 - val_loss: 9.4421e-07\n",
-      "Epoch 17/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 6.6030e-07 - val_loss: 9.3255e-07\n",
-      "Epoch 18/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 6.4765e-07 - val_loss: 9.2782e-07\n",
-      "Epoch 19/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 2ms/step - loss: 7.0107e-07 - val_loss: 9.2918e-07\n",
-      "Epoch 20/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 5.7916e-07 - val_loss: 9.3070e-07\n",
-      "Epoch 21/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 7.1965e-07 - val_loss: 9.3583e-07\n",
-      "Epoch 22/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 6.1729e-07 - val_loss: 9.2800e-07\n",
-      "Epoch 23/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 5.8376e-07 - val_loss: 9.2606e-07\n",
-      "Epoch 24/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 7.1949e-07 - val_loss: 9.2550e-07\n",
-      "Epoch 25/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 7.0228e-07 - val_loss: 9.2386e-07\n",
-      "Epoch 26/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 6.4762e-07 - val_loss: 9.2222e-07\n",
-      "Epoch 27/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 6.3545e-07 - val_loss: 9.2336e-07\n",
-      "Epoch 28/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 6.1678e-07 - val_loss: 9.2510e-07\n",
-      "Epoch 29/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 7.2552e-07 - val_loss: 9.2267e-07\n",
-      "Epoch 30/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 6.7044e-07 - val_loss: 9.2244e-07\n",
-      "Epoch 31/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 6.4412e-07 - val_loss: 9.2193e-07\n",
-      "Epoch 32/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 7.9198e-07 - val_loss: 9.2181e-07\n",
-      "Epoch 33/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 8.8825e-07 - val_loss: 9.2173e-07\n",
-      "Epoch 34/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 6.1502e-07 - val_loss: 9.2309e-07\n",
-      "Epoch 35/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 6.5551e-07 - val_loss: 9.2157e-07\n",
-      "Epoch 36/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 6.3050e-07 - val_loss: 9.2172e-07\n",
-      "Epoch 37/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 6.8292e-07 - val_loss: 9.2127e-07\n",
-      "Epoch 38/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 5.7185e-07 - val_loss: 9.2111e-07\n",
-      "Epoch 39/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 6.1807e-07 - val_loss: 9.2119e-07\n",
-      "Epoch 40/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 5.7785e-07 - val_loss: 9.2112e-07\n",
-      "Epoch 41/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 6.6563e-07 - val_loss: 9.2108e-07\n",
-      "Epoch 42/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 7.1370e-07 - val_loss: 9.2109e-07\n",
-      "Epoch 43/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 7.2470e-07 - val_loss: 9.2105e-07\n",
-      "Epoch 44/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 2ms/step - loss: 7.2408e-07 - val_loss: 9.2102e-07\n",
-      "Epoch 45/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 2ms/step - loss: 6.6530e-07 - val_loss: 9.2098e-07\n",
-      "Epoch 46/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 6.7502e-07 - val_loss: 9.2098e-07\n",
-      "Epoch 47/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 6.3829e-07 - val_loss: 9.2094e-07\n",
-      "Epoch 48/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 5.8739e-07 - val_loss: 9.2096e-07\n",
-      "Epoch 49/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 7.0502e-07 - val_loss: 9.2095e-07\n",
-      "Epoch 50/50\n",
-      "\u001b[1m3520/3520\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 2ms/step - loss: 6.5994e-07 - val_loss: 9.2094e-07\n",
-      "Training took 317.1207675933838 seconds\n"
-     ]
-    }
-   ],
-   "source": [
-    "# measure time\n",
-    "start = time.time()\n",
-    "\n",
-    "history = model.fit(X_train, \n",
-    "            y_train, \n",
-    "            batch_size = batch_size, \n",
-    "            epochs = epochs, \n",
-    "            validation_data = (X_val, y_val)\n",
-    ")\n",
-    "\n",
-    "end = time.time()\n",
-    "\n",
-    "print(\"Training took {} seconds\".format(end - start))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot(history.history[\"loss\"], \"o-\", label = \"Training Loss\")\n",
-    "plt.xlabel(\"Epoch\")\n",
-    "# plt.yscale('log')\n",
-    "plt.ylabel(\"Loss (Huber)\")\n",
-    "plt.grid('on')\n",
-    "\n",
-    "plt.savefig(\"loss_all.png\", dpi=300)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot(history.history[\"loss\"][1:], \"o-\", label = \"Training Loss\")\n",
-    "plt.xlabel(\"Epoch\")\n",
-    "# plt.yscale('log')\n",
-    "plt.ylabel(\"Loss (Huber)\")\n",
-    "plt.grid('on')\n",
-    "plt.savefig(\"loss_1_to_end.png\", dpi=300)\n"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -978,29 +1088,86 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\u001b[1m15641/15641\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 337us/step - loss: 7.0854e-07\n"
+      "\u001b[1m15641/15641\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 336us/step - loss: 6.6414e-07\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "6.561523377968115e-07"
+       "8.585521982240607e-07"
       ]
      },
-     "execution_count": 20,
+     "execution_count": 29,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "model.evaluate(X_test, y_test)"
+    "# test on all test data\n",
+    "model.evaluate(X_test.iloc[:,:-1], y_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[1m15454/15454\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 331us/step - loss: 2.7927e-07\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "3.939527175589319e-07"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# test on non-reactive data\n",
+    "model.evaluate(X_test[X_test['Class'] == 0].iloc[:,:-1], y_test[X_test['Class'] == 0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[1m188/188\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 400us/step - loss: 3.3173e-05\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "3.921399184037e-05"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# test on reactive data\n",
+    "model.evaluate(X_test[X_test['Class'] == 1].iloc[:,:-1], y_test[X_test['Class'] == 1])"
    ]
   },
   {