From a9cc9287498683a8c4e60ab4050ed3e5fcb324c7 Mon Sep 17 00:00:00 2001
From: Dennis Noll <dennis.noll@rwth-aachen.de>
Date: Fri, 5 Aug 2022 12:37:12 +0200
Subject: [PATCH] [exercise] 3/all: init exercises

---
 lecture3/exercise_3_1_regression.ipynb        | 385 +++++++++++
 .../exercise_3_1_regression_solution.ipynb    | 612 ++++++++++++++++++
 lecture3/exercise_3_2_classification.ipynb    | 448 +++++++++++++
 ...exercise_3_2_classification_solution.ipynb | 497 ++++++++++++++
 lecture3/exercise_3_3_classification.ipynb    | 151 +++++
 ...exercise_3_3_classification_solution.ipynb | 431 ++++++++++++
 6 files changed, 2524 insertions(+)
 create mode 100644 lecture3/exercise_3_1_regression.ipynb
 create mode 100644 lecture3/exercise_3_1_regression_solution.ipynb
 create mode 100644 lecture3/exercise_3_2_classification.ipynb
 create mode 100644 lecture3/exercise_3_2_classification_solution.ipynb
 create mode 100644 lecture3/exercise_3_3_classification.ipynb
 create mode 100644 lecture3/exercise_3_3_classification_solution.ipynb

diff --git a/lecture3/exercise_3_1_regression.ipynb b/lecture3/exercise_3_1_regression.ipynb
new file mode 100644
index 0000000..ec8feba
--- /dev/null
+++ b/lecture3/exercise_3_1_regression.ipynb
@@ -0,0 +1,385 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "484cae12",
+   "metadata": {},
+   "source": [
+    "# Regression of a very complex function\n",
+    "In this task you will learn how to perform a regression of a very complex function."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "26b13114",
+   "metadata": {},
+   "source": [
+    "## Imports and Seeding\n",
+    "First we will do the necessary imports:\n",
+    "* `numpy` for general data handling and array manipulation\n",
+    "* `tensorflow` to build and train the regression model\n",
+    "* `matplotlib.pyplot` for plotting"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "1833559e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import tensorflow as tf\n",
+    "from matplotlib import pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "48e0eee1",
+   "metadata": {},
+   "source": [
+    "Then we set a random seed for the `np.random` module. This makes our code reproducible as the random operations will yield the same results in every run through the notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "b3ab0336",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "np.random.seed(42)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9d66dc3c",
+   "metadata": {},
+   "source": [
+    "## Data Creation\n",
+    "First we define the parameters of the data.\n",
+    "* `n_data`: number of data points\n",
+    "* `uncertainty`: the uncertainty that is used"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "cb0f589d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "N = 10 ** 4\n",
+    "uncertainty = 0.0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b89b8f85",
+   "metadata": {},
+   "source": [
+    "We define `some_complicated_function` that we want to regress and model with our neural network."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "f7de78f4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def some_complicated_function(x):\n",
+    "    return (\n",
+    "        (np.abs(x)) ** 0.5\n",
+    "        + 0.1 * x\n",
+    "        + 0.01 * x ** 2\n",
+    "        + 1\n",
+    "        - np.sin(x)\n",
+    "        + 0.5 * np.exp(x / 10.0)\n",
+    "    ) / (0.5 + np.abs(np.cos(x)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b6370006",
+   "metadata": {},
+   "source": [
+    "And now we create the training data according to `some_complicated_function`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "7a21cca8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_lin = np.linspace(-10, 10, 1000)[:, None]\n",
+    "y_lin = some_complicated_function(x_lin)\n",
+    "\n",
+    "x = np.random.uniform(-10, 10, size=(N,1))\n",
+    "y = some_complicated_function(x)\n",
+    "y += np.random.normal(0, uncertainty, size=y.shape[0])[..., None]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5745f7cf",
+   "metadata": {},
+   "source": [
+    "## Data Visualization\n",
+    "Visualize the used function (`some_complicated_function`) andd the created data `(x, y)` in an appropriate way."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "c2066a2e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\nTODO: Visualize, x, y, x_lin, y_lin\\n'"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Visualize, x, y, x_lin, y_lin\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "576b2822",
+   "metadata": {},
+   "source": [
+    "## Model Setup\n",
+    "Now create the model:\n",
+    "- What is a suitable size?\n",
+    "- How many inputs and outputs are needed?\n",
+    "- What are suitable activations? "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "5b91c84a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\nTODO: Create the model\\n'"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Create the model\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "29a3ba47",
+   "metadata": {},
+   "source": [
+    "Now compile the model:\n",
+    "- Which loss function should be used? ([Documentation](https://www.tensorflow.org/api_docs/python/tf/keras/losses))\n",
+    "- Which optimizer should be used?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "3419b16a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\nTODO: Compile the model\\n'"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Compile the model\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1916abda",
+   "metadata": {},
+   "source": [
+    "## Model Training\n",
+    "Now train the model:\n",
+    "* What is a suitable number of epochs?\n",
+    "* What is a suitable size for the batches?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "e862ab76",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\nTODO: Train the model\\n'"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Train the model\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3a0d56fa",
+   "metadata": {},
+   "source": [
+    "## Model Evaluation\n",
+    "Visualize the model prediction alogn with the original function and the training data. What do you observe?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "ad7a746c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\nTODO: what does the model predict for each x value?\\n'"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: what does the model predict for each x value?\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "d8bbf7cc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\nTODO: Plot model prediction along with the original function and the training data\\n'"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Plot model prediction along with the original function and the training data\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "85071641",
+   "metadata": {},
+   "source": [
+    "## Model Improvements\n",
+    "Try to improve your model and its training. You may try the following configurations.\n",
+    "- Different activation functions (ReLU, Sigmoid, Thanh)\n",
+    "- Different learning rates (0.0001, 0.001, 0.01 ,0.1, 1, 10)\n",
+    "\n",
+    "Describe your observations."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c4c1382a",
+   "metadata": {},
+   "source": [
+    "## Further Tasks\n",
+    "Go back to the beginning of the notebook and increase the uncertainty of the data.\n",
+    "Describe your observations."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c069e5c2",
+   "metadata": {},
+   "source": [
+    "## Summary\n",
+    "This concludes our tutorial on the regression of a very complicated function.\n",
+    "\n",
+    "In this tutorial you have learned:\n",
+    "* How to perform a regression with a neural network\n",
+    "* The limits of very simple neural networks\n",
+    "* The limits of very simple optimizers\n",
+    "* How to improve:\n",
+    "    * the network \n",
+    "    * the optimization of the network\n",
+    "* The influence of uncertain data on the model training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "14ca73a2",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/lecture3/exercise_3_1_regression_solution.ipynb b/lecture3/exercise_3_1_regression_solution.ipynb
new file mode 100644
index 0000000..047303c
--- /dev/null
+++ b/lecture3/exercise_3_1_regression_solution.ipynb
@@ -0,0 +1,612 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "484cae12",
+   "metadata": {},
+   "source": [
+    "# Regression of a very complex function\n",
+    "In this task you will learn how to perform a regression of a very complex function."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "26b13114",
+   "metadata": {},
+   "source": [
+    "## Imports and Seeding\n",
+    "First we will do the necessary imports:\n",
+    "* `numpy` for general data handling and array manipulation\n",
+    "* `tensorflow` to build and train the regression model\n",
+    "* `matplotlib.pyplot` for plotting"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "1833559e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import tensorflow as tf\n",
+    "from matplotlib import pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "48e0eee1",
+   "metadata": {},
+   "source": [
+    "Then we set a random seed for the `np.random` module. This makes our code reproducible as the random operations will yield the same results in every run through the notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "b3ab0336",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "np.random.seed(42)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9d66dc3c",
+   "metadata": {},
+   "source": [
+    "## Data Creation\n",
+    "First we define the parameters of the data.\n",
+    "* `n_data`: number of data points\n",
+    "* `uncertainty`: the uncertainty that is used"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "cb0f589d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "N = 10 ** 4\n",
+    "uncertainty = 0.0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b89b8f85",
+   "metadata": {},
+   "source": [
+    "We define `some_complicated_function` that we want to regress and model with our neural network."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "f7de78f4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def some_complicated_function(x):\n",
+    "    return (\n",
+    "        (np.abs(x)) ** 0.5\n",
+    "        + 0.1 * x\n",
+    "        + 0.01 * x ** 2\n",
+    "        + 1\n",
+    "        - np.sin(x)\n",
+    "        + 0.5 * np.exp(x / 10.0)\n",
+    "    ) / (0.5 + np.abs(np.cos(x)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b6370006",
+   "metadata": {},
+   "source": [
+    "And now we create the training data according to `some_complicated_function`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "7a21cca8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_lin = np.linspace(-10, 10, 1000)[:, None]\n",
+    "y_lin = some_complicated_function(x_lin)\n",
+    "\n",
+    "x = np.random.uniform(-10, 10, size=(N,1))\n",
+    "y = some_complicated_function(x)\n",
+    "y += np.random.normal(0, uncertainty, size=y.shape[0])[..., None]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5745f7cf",
+   "metadata": {},
+   "source": [
+    "## Data Visualization\n",
+    "Visualize the used function (`some_complicated_function`) andd the created data `(x, y)` in an appropriate way."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "c2066a2e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x7fd3503afee0>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Visualize, x, y, x_lin, y_lin\n",
+    "\"\"\"\n",
+    "plt.scatter(x, y, label=\"data\", alpha=0.1)\n",
+    "plt.plot(x_lin, y_lin, label=\"Function f(x)\", color=\"red\")\n",
+    "plt.xlabel(\"x\")\n",
+    "plt.ylabel(\"y\")\n",
+    "plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "576b2822",
+   "metadata": {},
+   "source": [
+    "## Model Setup\n",
+    "Now create the model:\n",
+    "- What is a suitable size?\n",
+    "- How many inputs and outputs are needed?\n",
+    "- What are suitable activations? "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "5b91c84a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-08-05 12:03:39.786451: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  SSE4.1 SSE4.2 AVX AVX2 FMA\n",
+      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
+     ]
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Create the model\n",
+    "\"\"\"\n",
+    "model = tf.keras.Sequential(\n",
+    "    layers=[\n",
+    "        tf.keras.Input(shape=(1,)),\n",
+    "        tf.keras.layers.Dense(16, activation=\"relu\"),\n",
+    "        tf.keras.layers.Dense(16, activation=\"relu\"),\n",
+    "        tf.keras.layers.Dense(16, activation=\"relu\"),\n",
+    "        tf.keras.layers.Dense(1),\n",
+    "    ]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "29a3ba47",
+   "metadata": {},
+   "source": [
+    "Now compile the model:\n",
+    "- Which loss function should be used? ([Documentation](https://www.tensorflow.org/api_docs/python/tf/keras/losses))\n",
+    "- Which optimizer should be used?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "3419b16a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Compile the model\n",
+    "\"\"\"\n",
+    "model.compile(loss=\"mse\", optimizer=\"sgd\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1916abda",
+   "metadata": {},
+   "source": [
+    "## Model Training\n",
+    "Now train the model:\n",
+    "* What is a suitable number of epochs?\n",
+    "* What is a suitable size for the batches?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "e862ab76",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-08-05 12:03:40.145120: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:116] None of the MLIR optimization passes are enabled (registered 2)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/100\n",
+      "313/313 [==============================] - 3s 4ms/step - loss: 3.3984\n",
+      "Epoch 2/100\n",
+      "313/313 [==============================] - 1s 3ms/step - loss: 2.5578\n",
+      "Epoch 3/100\n",
+      "313/313 [==============================] - 1s 3ms/step - loss: 2.5399\n",
+      "Epoch 4/100\n",
+      "313/313 [==============================] - 1s 2ms/step - loss: 2.4957\n",
+      "Epoch 5/100\n",
+      "313/313 [==============================] - 1s 3ms/step - loss: 2.3274\n",
+      "Epoch 6/100\n",
+      "313/313 [==============================] - 1s 3ms/step - loss: 2.1456\n",
+      "Epoch 7/100\n",
+      "313/313 [==============================] - 1s 3ms/step - loss: 2.1278\n",
+      "Epoch 8/100\n",
+      "313/313 [==============================] - 1s 3ms/step - loss: 1.9232\n",
+      "Epoch 9/100\n",
+      "313/313 [==============================] - 1s 2ms/step - loss: 1.9760\n",
+      "Epoch 10/100\n",
+      "313/313 [==============================] - 1s 2ms/step - loss: 1.8729\n",
+      "Epoch 11/100\n",
+      "313/313 [==============================] - 1s 4ms/step - loss: 1.7648\n",
+      "Epoch 12/100\n",
+      "313/313 [==============================] - 0s 2ms/step - loss: 1.7690\n",
+      "Epoch 13/100\n",
+      "313/313 [==============================] - 0s 2ms/step - loss: 1.7519\n",
+      "Epoch 14/100\n",
+      "313/313 [==============================] - 0s 2ms/step - loss: 1.6320\n",
+      "Epoch 15/100\n",
+      "313/313 [==============================] - 1s 2ms/step - loss: 1.7010\n",
+      "Epoch 16/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.6759\n",
+      "Epoch 17/100\n",
+      "313/313 [==============================] - 1s 2ms/step - loss: 1.6220\n",
+      "Epoch 18/100\n",
+      "313/313 [==============================] - 1s 4ms/step - loss: 1.5958\n",
+      "Epoch 19/100\n",
+      "313/313 [==============================] - 1s 2ms/step - loss: 1.4919\n",
+      "Epoch 20/100\n",
+      "313/313 [==============================] - 1s 2ms/step - loss: 1.5811\n",
+      "Epoch 21/100\n",
+      "313/313 [==============================] - 1s 2ms/step - loss: 1.5218\n",
+      "Epoch 22/100\n",
+      "313/313 [==============================] - 1s 2ms/step - loss: 1.5173\n",
+      "Epoch 23/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.4912\n",
+      "Epoch 24/100\n",
+      "313/313 [==============================] - 1s 2ms/step - loss: 1.4987\n",
+      "Epoch 25/100\n",
+      "313/313 [==============================] - 1s 2ms/step - loss: 1.6173\n",
+      "Epoch 26/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.4515\n",
+      "Epoch 27/100\n",
+      "313/313 [==============================] - 0s 942us/step - loss: 1.6338\n",
+      "Epoch 28/100\n",
+      "313/313 [==============================] - 0s 986us/step - loss: 1.6017\n",
+      "Epoch 29/100\n",
+      "313/313 [==============================] - 0s 942us/step - loss: 1.6380\n",
+      "Epoch 30/100\n",
+      "313/313 [==============================] - 0s 965us/step - loss: 1.6105\n",
+      "Epoch 31/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.5330\n",
+      "Epoch 32/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.4850\n",
+      "Epoch 33/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.6237\n",
+      "Epoch 34/100\n",
+      "313/313 [==============================] - 1s 4ms/step - loss: 1.5624\n",
+      "Epoch 35/100\n",
+      "313/313 [==============================] - 1s 4ms/step - loss: 1.6068\n",
+      "Epoch 36/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.5679\n",
+      "Epoch 37/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.5057\n",
+      "Epoch 38/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.5352\n",
+      "Epoch 39/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.4374\n",
+      "Epoch 40/100\n",
+      "313/313 [==============================] - 0s 963us/step - loss: 1.4601\n",
+      "Epoch 41/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.4545\n",
+      "Epoch 42/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.3235\n",
+      "Epoch 43/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.3738\n",
+      "Epoch 44/100\n",
+      "313/313 [==============================] - 0s 988us/step - loss: 1.2638\n",
+      "Epoch 45/100\n",
+      "313/313 [==============================] - 0s 953us/step - loss: 1.3944\n",
+      "Epoch 46/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.4198\n",
+      "Epoch 47/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.3505\n",
+      "Epoch 48/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.2997\n",
+      "Epoch 49/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.3908\n",
+      "Epoch 50/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.2984\n",
+      "Epoch 51/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.3460\n",
+      "Epoch 52/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.2285A: 0s - loss: 1.2\n",
+      "Epoch 53/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.2504\n",
+      "Epoch 54/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.2345\n",
+      "Epoch 55/100\n",
+      "313/313 [==============================] - 1s 2ms/step - loss: 1.3697\n",
+      "Epoch 56/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.2797\n",
+      "Epoch 57/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.2825\n",
+      "Epoch 58/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.4122\n",
+      "Epoch 59/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.2927\n",
+      "Epoch 60/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.2715\n",
+      "Epoch 61/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.1922\n",
+      "Epoch 62/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.1647\n",
+      "Epoch 63/100\n",
+      "313/313 [==============================] - 1s 2ms/step - loss: 1.0985\n",
+      "Epoch 64/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.0921\n",
+      "Epoch 65/100\n",
+      "313/313 [==============================] - 1s 4ms/step - loss: 1.3994A: 0s\n",
+      "Epoch 66/100\n",
+      "313/313 [==============================] - 1s 3ms/step - loss: 1.2860\n",
+      "Epoch 67/100\n",
+      "313/313 [==============================] - 1s 2ms/step - loss: 1.1705\n",
+      "Epoch 68/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.1978\n",
+      "Epoch 69/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.1500\n",
+      "Epoch 70/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.1244\n",
+      "Epoch 71/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.1054\n",
+      "Epoch 72/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.1750\n",
+      "Epoch 73/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.0776\n",
+      "Epoch 74/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.0974\n",
+      "Epoch 75/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.0780\n",
+      "Epoch 76/100\n",
+      "313/313 [==============================] - 0s 993us/step - loss: 1.1288\n",
+      "Epoch 77/100\n",
+      "313/313 [==============================] - 0s 944us/step - loss: 1.0981\n",
+      "Epoch 78/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.1474\n",
+      "Epoch 79/100\n",
+      "313/313 [==============================] - 0s 976us/step - loss: 1.1374\n",
+      "Epoch 80/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.1090\n",
+      "Epoch 81/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.0766\n",
+      "Epoch 82/100\n",
+      "313/313 [==============================] - 0s 946us/step - loss: 1.0638\n",
+      "Epoch 83/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.0908\n",
+      "Epoch 84/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.0933\n",
+      "Epoch 85/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.0628\n",
+      "Epoch 86/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.1284\n",
+      "Epoch 87/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 0.9667\n",
+      "Epoch 88/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 0.9885\n",
+      "Epoch 89/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.1622\n",
+      "Epoch 90/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.1594\n",
+      "Epoch 91/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.1145\n",
+      "Epoch 92/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.0588\n",
+      "Epoch 93/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.1608\n",
+      "Epoch 94/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 0.9633\n",
+      "Epoch 95/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 0.9691\n",
+      "Epoch 96/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 0.9562\n",
+      "Epoch 97/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.0622\n",
+      "Epoch 98/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.1901\n",
+      "Epoch 99/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.0907\n",
+      "Epoch 100/100\n",
+      "313/313 [==============================] - 0s 1ms/step - loss: 1.1041\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<tensorflow.python.keras.callbacks.History at 0x7fd3506951f0>"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Train the model\n",
+    "\"\"\"\n",
+    "model.fit(x, y, epochs=100)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3a0d56fa",
+   "metadata": {},
+   "source": [
+    "## Model Evaluation\n",
+    "Visualize the model prediction alogn with the original function and the training data. What do you observe?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "ad7a746c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\"\"\"\n",
+    "TODO: what does the model predict for each x value?\n",
+    "\"\"\"\n",
+    "y_pred = model.predict(x_lin)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "d8bbf7cc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Plot model prediction along with the original function and the training data\n",
+    "\"\"\"\n",
+    "plt.scatter(x, y, label=\"data\", alpha=0.1)\n",
+    "plt.plot(x_lin, y_lin, label=\"Function f(x)\", color=\"red\")\n",
+    "plt.plot(x_lin, y_pred, linestyle=\"--\", label=\"Fit DNN(x)\", color=\"orange\")\n",
+    "plt.xlabel(\"x\")\n",
+    "plt.ylabel(\"y\")\n",
+    "plt.legend()\n",
+    "plt.savefig(\"fit.pdf\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "85071641",
+   "metadata": {},
+   "source": [
+    "## Model Improvements\n",
+    "Try to improve your model and its training. You may try the following configurations.\n",
+    "- Different activation functions (ReLU, Sigmoid, Thanh)\n",
+    "- Different learning rates (0.0001, 0.001, 0.01 ,0.1, 1, 10)\n",
+    "\n",
+    "Describe your observations."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c4c1382a",
+   "metadata": {},
+   "source": [
+    "## Further Tasks\n",
+    "Go back to the beginning of the notebook and increase the uncertainty of the data.\n",
+    "Describe your observations."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c069e5c2",
+   "metadata": {},
+   "source": [
+    "## Summary\n",
+    "This concludes our tutorial on the regression of a very complicated function.\n",
+    "\n",
+    "In this tutorial you have learned:\n",
+    "* How to perform a regression with a neural network\n",
+    "* The limits of very simple neural networks\n",
+    "* The limits of very simple optimizers\n",
+    "* How to improve:\n",
+    "    * the network \n",
+    "    * the optimization of the network\n",
+    "* The influence of uncertain data on the model training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "14ca73a2",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/lecture3/exercise_3_2_classification.ipynb b/lecture3/exercise_3_2_classification.ipynb
new file mode 100644
index 0000000..0d2bf24
--- /dev/null
+++ b/lecture3/exercise_3_2_classification.ipynb
@@ -0,0 +1,448 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "e703cbc8",
+   "metadata": {},
+   "source": [
+    "# Classification between Two Classes\n",
+    "In this exercise, we will learn how to perform a binary classification.\n",
+    "\n",
+    "## Introduction\n",
+    "You are given data from two classes. In each class the data follows a distribution out of one or many gaussian distributions with class dependent parameters. Your task is to build a model which can classify between the two classes."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "07066edc",
+   "metadata": {},
+   "source": [
+    "## Imports and Seeding\n",
+    "First we will do the necessary imports:\n",
+    "* `numpy` for general data handling and array manipulation\n",
+    "* `tensorflow` to build and train the regression model\n",
+    "* `matplotlib.pyplot` for plotting\n",
+    "* `sklearn.utils.shuffle` to randomly shuffle our training dataset\n",
+    "* `cycler.cycler` helps with plotting multiple distributions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "33bfb028",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from matplotlib import pyplot as plt\n",
+    "import tensorflow as tf\n",
+    "from sklearn.utils import shuffle\n",
+    "from cycler import cycler"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b17ea7df",
+   "metadata": {},
+   "source": [
+    "Then we set a random seed for the `np.random` module. This makes our code reproducible as the random operations will yield the same results in every run through the notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "d7118dd4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "np.random.seed(42)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "43930b0d",
+   "metadata": {},
+   "source": [
+    "## Data Creation\n",
+    "First we will create the data.\n",
+    "\n",
+    "To make things a little bit more interesting we have written a small piece of code, which creates `N_DIM` dimensional data following distributions consiting of one or more (`N_PEAK`) different Gaussian functions. Increasing the number of `N_PEAK` will in general make the distributions and thus the task more complex."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "cf21127e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "N_DIMS = 1\n",
+    "N_PEAK = 1\n",
+    "SCALE = 0.1\n",
+    "\n",
+    "centers_class_1 = np.random.uniform(0, 1, size=(N_PEAK, N_DIMS))\n",
+    "centers_class_2 = np.random.uniform(0, 1, size=(N_PEAK, N_DIMS))\n",
+    "\n",
+    "def make_samples(centers, n_samples=1_000):\n",
+    "    output = []\n",
+    "    for i, center in enumerate(centers):\n",
+    "        output.append(np.random.normal(\n",
+    "            loc=center,\n",
+    "            scale=SCALE,\n",
+    "            size=(n_samples // N_PEAK, N_DIMS)\n",
+    "        ))\n",
+    "    return np.concatenate(output)\n",
+    "\n",
+    "class_1 = make_samples(centers_class_1, 100_000)\n",
+    "class_2 = make_samples(centers_class_2, 100_000)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7789856e",
+   "metadata": {},
+   "source": [
+    "## Data Visualization\n",
+    "Visualize the data. When looking at one dimension (`N_DIMS=1`) a single histogram will solve the task. If plotting many dimensions (`N_DIMS>1`) you may want to plot 1-dimensional projections onto each of the axes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "33880fbe",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\nTODO: Visualize the data of the two classes.\\nWou may want to plot all 1-dimensional projections of the `N_DIM` dimensions of our data.\\n'"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Visualize the data of the two classes.\n",
+    "Wou may want to plot all 1-dimensional projections of the `N_DIM` dimensions of our data.\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "42822770",
+   "metadata": {},
+   "source": [
+    "## Data Preparation\n",
+    "Next we prepare the training data.\n",
+    "We built one dataset made out of both classes.\n",
+    "\n",
+    "The `x` values of the training data are given by the distributions themselves\n",
+    "\n",
+    "For the `y` values we use ones for `class_1` and zeros for`class_2`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "0f9b848e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x = np.concatenate((class_1, class_2))\n",
+    "y = np.concatenate((np.ones(len(class_1)), np.zeros(len(class_2))))[..., None]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "130d9122",
+   "metadata": {},
+   "source": [
+    "Next we suffle our dataset. This prevents the case that during training the network only sees one type of events in a particular or even many subsequent batches."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "060541ec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x, y = shuffle(x, y, random_state=0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b6a322e2",
+   "metadata": {},
+   "source": [
+    "## Model Creation\n",
+    "Next we will create the model.\n",
+    "- What is a suitable size?\n",
+    "- How many inputs and outputs does the model need?\n",
+    "- What are suitable activations?\n",
+    "    - Hint: Think about the activation of the last layer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "dd7278fd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\nTODO: Create the model\\n'"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Create the model\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "17270e29",
+   "metadata": {},
+   "source": [
+    "Now compile the model:\n",
+    "- Which loss function should be used? ([Documentation](https://www.tensorflow.org/api_docs/python/tf/keras/losses))\n",
+    "- Which optimizer should be used?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "77b344b7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\nTODO: Compile the model\\n'"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Compile the model\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "baa6a06c",
+   "metadata": {},
+   "source": [
+    "Next we inspect our model. How many parameteres does it have?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "4c364d71",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\nTODO: Use model.summary() to look at number of parameters\\n'"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Use model.summary() to look at number of parameters\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b6da7aab",
+   "metadata": {},
+   "source": [
+    "## Model Training\n",
+    "Now train the model:\n",
+    "* What is a suitable number of epochs?\n",
+    "* What is a suitable size for the batches?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "10f26b8a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\nTODO: Train the model\\n'"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Train the model\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7501eec2",
+   "metadata": {},
+   "source": [
+    "## Model Evaluation\n",
+    "Visualize the model prediction. Describe your observation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "2bcc84f6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\nTODO: Prepare data for the model evaluation/prediction\\n'"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Prepare data for the model evaluation/prediction\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "819684ee",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\nTODO: Perform the model evaluation/prediction\\n'"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Perform the model evaluation/prediction\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "cb0ccba0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\nTODO: Visualize the model evaluation/prediciton\\n'"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Visualize the model evaluation/prediciton\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "42bf1cc0",
+   "metadata": {},
+   "source": [
+    "## Futher Tasks\n",
+    "Now we will make our exercise more difficult:\n",
+    "* Make the functions more complex (N_PEAK) and train the classifier again. Describe your observations.\n",
+    "* Raise the number of dimensions (N_DIM) to 2 (and 10) and train the classifier again. Describe your observations."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "05fcec7d",
+   "metadata": {},
+   "source": [
+    "## Summary\n",
+    "This concludes our tutorial on the Classification between Two Classes.\n",
+    "\n",
+    "In this tutorial you have learned:\n",
+    "* How to visualize n-dimensional data distributions from two classes\n",
+    "* How to prepare the data for a classification\n",
+    "* How to create a neural network for a classification\n",
+    "* Which loss to use for a classification\n",
+    "* How to interpret the output of a classification network\n",
+    "* The strenghts and limits of a simple network and a simple optimizer according to:\n",
+    "    * Number of dimensions\n",
+    "    * Complexity of functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f5d7c7bf",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/lecture3/exercise_3_2_classification_solution.ipynb b/lecture3/exercise_3_2_classification_solution.ipynb
new file mode 100644
index 0000000..b624fd9
--- /dev/null
+++ b/lecture3/exercise_3_2_classification_solution.ipynb
@@ -0,0 +1,497 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "e703cbc8",
+   "metadata": {},
+   "source": [
+    "# Classification between Two Classes\n",
+    "In this exercise, we will learn how to perform a binary classification.\n",
+    "\n",
+    "## Introduction\n",
+    "You are given data from two classes. In each class the data follows a distribution out of one or many gaussian distributions with class dependent parameters. Your task is to build a model which can classify between the two classes."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "07066edc",
+   "metadata": {},
+   "source": [
+    "## Imports and Seeding\n",
+    "First we will do the necessary imports:\n",
+    "* `numpy` for general data handling and array manipulation\n",
+    "* `tensorflow` to build and train the regression model\n",
+    "* `matplotlib.pyplot` for plotting\n",
+    "* `sklearn.utils.shuffle` to randomly shuffle our training dataset\n",
+    "* `cycler.cycler` helps with plotting multiple distributions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "33bfb028",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from matplotlib import pyplot as plt\n",
+    "import tensorflow as tf\n",
+    "from sklearn.utils import shuffle\n",
+    "from cycler import cycler"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b17ea7df",
+   "metadata": {},
+   "source": [
+    "Then we set a random seed for the `np.random` module. This makes our code reproducible as the random operations will yield the same results in every run through the notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "d7118dd4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "np.random.seed(42)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "43930b0d",
+   "metadata": {},
+   "source": [
+    "## Data Creation\n",
+    "First we will create the data.\n",
+    "\n",
+    "To make things a little bit more interesting we have written a small piece of code, which creates `N_DIM` dimensional data following distributions consiting of one or more (`N_PEAK`) different Gaussian functions. Increasing the number of `N_PEAK` will in general make the distributions and thus the task more complex."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "cf21127e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "N_DIMS = 1\n",
+    "N_PEAK = 1\n",
+    "SCALE = 0.1\n",
+    "\n",
+    "centers_class_1 = np.random.uniform(0, 1, size=(N_PEAK, N_DIMS))\n",
+    "centers_class_2 = np.random.uniform(0, 1, size=(N_PEAK, N_DIMS))\n",
+    "\n",
+    "def make_samples(centers, n_samples=1_000):\n",
+    "    output = []\n",
+    "    for i, center in enumerate(centers):\n",
+    "        output.append(np.random.normal(\n",
+    "            loc=center,\n",
+    "            scale=SCALE,\n",
+    "            size=(n_samples // N_PEAK, N_DIMS)\n",
+    "        ))\n",
+    "    return np.concatenate(output)\n",
+    "\n",
+    "class_1 = make_samples(centers_class_1, 100_000)\n",
+    "class_2 = make_samples(centers_class_2, 100_000)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7789856e",
+   "metadata": {},
+   "source": [
+    "## Data Visualization\n",
+    "Visualize the data. When looking at one dimension (`N_DIMS=1`) a single histogram will solve the task. If plotting many dimensions (`N_DIMS>1`) you may want to plot 1-dimensional projections onto each of the axes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "33880fbe",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/dw/z8g0cw_s0nzcv0z1jn7vfgsm0000gn/T/ipykernel_2041/288129882.py:26: UserWarning: Matplotlib is currently using module://matplotlib_inline.backend_inline, which is a non-GUI backend, so cannot show the figure.\n",
+      "  fig.show()\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Visualize the data of the two classes.\n",
+    "Wou may want to plot all 1-dimensional projections of the `N_DIM` dimensions of our data.\n",
+    "\"\"\"\n",
+    "for d0 in range(N_DIMS):\n",
+    "    fig, axs = plt.subplots(figsize=(10,4))\n",
+    "    for opts in cycler(\n",
+    "        x=[class_1, class_2],\n",
+    "        label=[\"Class 1\",\"Class 2\"],\n",
+    "        linestyle=[\"-\", \"--\"],\n",
+    "    ):\n",
+    "        axs.hist(\n",
+    "            opts.pop(\"x\")[:, d0],\n",
+    "            **opts,\n",
+    "            bins=20,\n",
+    "            range=[0, 1],\n",
+    "            density=True,\n",
+    "            histtype=\"step\",\n",
+    "            lw=3,\n",
+    "        )\n",
+    "    axs.legend(loc=0)\n",
+    "    axs.set_title(f\"Dimension {d0}\")\n",
+    "    axs.set_xlabel(rf\"$x_{{{d0}}}$\")\n",
+    "    axs.set_ylabel(f\"Counts (normalized)\")\n",
+    "    fig.show()\n",
+    "    plt.savefig(\"plot.pdf\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "42822770",
+   "metadata": {},
+   "source": [
+    "## Data Preparation\n",
+    "Next we prepare the training data.\n",
+    "We built one dataset made out of both classes.\n",
+    "\n",
+    "The `x` values of the training data are given by the distributions themselves\n",
+    "\n",
+    "For the `y` values we use ones for `class_1` and zeros for`class_2`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "0f9b848e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x = np.concatenate((class_1, class_2))\n",
+    "y = np.concatenate((np.ones(len(class_1)), np.zeros(len(class_2))))[..., None]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "130d9122",
+   "metadata": {},
+   "source": [
+    "Next we suffle our dataset. This prevents the case that during training the network only sees one type of events in a particular or even many subsequent batches."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "060541ec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x, y = shuffle(x, y, random_state=0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b6a322e2",
+   "metadata": {},
+   "source": [
+    "## Model Creation\n",
+    "Next we will create the model.\n",
+    "- What is a suitable size?\n",
+    "- How many inputs and outputs does the model need?\n",
+    "- What are suitable activations?\n",
+    "    - Hint: Think about the activation of the last layer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "dd7278fd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-08-05 12:03:31.241346: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  SSE4.1 SSE4.2 AVX AVX2 FMA\n",
+      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
+     ]
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Create the model\n",
+    "\"\"\"\n",
+    "model = tf.keras.Sequential(\n",
+    "    layers=[\n",
+    "        tf.keras.Input(shape=(N_DIMS,)),\n",
+    "        tf.keras.layers.Dense(256, activation=\"relu\"),\n",
+    "        tf.keras.layers.Dense(256, activation=\"relu\"),\n",
+    "        tf.keras.layers.Dense(256, activation=\"relu\"),\n",
+    "        tf.keras.layers.Dense(1, activation=\"sigmoid\"),\n",
+    "    ]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "17270e29",
+   "metadata": {},
+   "source": [
+    "Now compile the model:\n",
+    "- Which loss function should be used? ([Documentation](https://www.tensorflow.org/api_docs/python/tf/keras/losses))\n",
+    "- Which optimizer should be used?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "77b344b7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Compile the model\n",
+    "\"\"\"\n",
+    "model.compile(optimizer=\"SGD\", loss=\"bce\", metrics=[\"accuracy\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "baa6a06c",
+   "metadata": {},
+   "source": [
+    "Next we inspect our model. How many parameteres does it have?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "4c364d71",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"sequential\"\n",
+      "_________________________________________________________________\n",
+      "Layer (type)                 Output Shape              Param #   \n",
+      "=================================================================\n",
+      "dense (Dense)                (None, 256)               512       \n",
+      "_________________________________________________________________\n",
+      "dense_1 (Dense)              (None, 256)               65792     \n",
+      "_________________________________________________________________\n",
+      "dense_2 (Dense)              (None, 256)               65792     \n",
+      "_________________________________________________________________\n",
+      "dense_3 (Dense)              (None, 1)                 257       \n",
+      "=================================================================\n",
+      "Total params: 132,353\n",
+      "Trainable params: 132,353\n",
+      "Non-trainable params: 0\n",
+      "_________________________________________________________________\n"
+     ]
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Use model.summary() to look at number of parameters\n",
+    "\"\"\"\n",
+    "model.summary()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b6da7aab",
+   "metadata": {},
+   "source": [
+    "## Model Training\n",
+    "Now train the model:\n",
+    "* What is a suitable number of epochs?\n",
+    "* What is a suitable size for the batches?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "10f26b8a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-08-05 12:03:31.387168: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:116] None of the MLIR optimization passes are enabled (registered 2)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "6250/6250 [==============================] - 20s 3ms/step - loss: 0.2305 - accuracy: 0.9128\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<tensorflow.python.keras.callbacks.History at 0x7fe4b1173b50>"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Train the model\n",
+    "\"\"\"\n",
+    "model.fit(x, y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7501eec2",
+   "metadata": {},
+   "source": [
+    "## Model Evaluation\n",
+    "Visualize the model prediction. Describe your observation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "2bcc84f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Prepare data for the model evaluation/prediction\n",
+    "\"\"\"\n",
+    "n = 100\n",
+    "s = np.linspace(0, 1, n)\n",
+    "xy = np.meshgrid(*(N_DIMS * [s]), indexing=\"ij\")\n",
+    "xy = np.concatenate(tuple(x[..., None] for x in xy), axis=-1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "819684ee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Perform the model evaluation/prediction\n",
+    "\"\"\"\n",
+    "xy = xy.reshape(-1, N_DIMS)\n",
+    "y_pred = model.predict(xy)\n",
+    "y_pred = y_pred.reshape(*(n for i in range (N_DIMS)), 1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "cb0ccba0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAebElEQVR4nO3deXgc9Z3n8fdXrcuyLtuSZR0+scHygYktjhCScEwCZpJhkjAJZEKYhCzDTMjmmX32WZjJM5DdTHaS5dkkZCDr8ZCEgZ2Nh03IxGQNhJyEAYNtwDcGxTa2LJ/Ilixbto7+7h/ddtqyjpbdUnVXfV4Petxd9evqT2H5o1JVdZW5OyIikvvygg4gIiKZoUIXEQkJFbqISEio0EVEQkKFLiISEip0EZGQUKFLTjCzZWb2t0HnOMXMpplZp5nFgs4icorpPHQJmpntBGqAXqAP2AI8Bix393iA0QJhZjOA7wOXA7uAu93954GGkpygLXTJFh929zJgOvA14B7gu8FGCswPgNeAScCXgB+aWXWwkSQXqNAlq7h7u7uvBD4B3G5mCwDM7FEz+7vk46vNrMXM/ouZHTCzvWb2x2Z2o5m9aWZtZvY3p5ZpZnlmdq+Z/c7M3jGzJ8xsYnLeDDNzM7vdzHaZ2SEz+1LKay8zs7Vm1mFm+83sG/1el598XmdmK5Pv3Wxm/yFlGV9OvudjZnbUzDabWdNA629mFwKLgfvdvcvdfwRsBD6W2f/TEkYqdMlK7v4K0AK8d5AhU4BioB64D/gn4FPAkuRr7jOzWcmx/xH4Y+D9QB1wGHi43/KuAi4Crku+tjE5/UHgQXcvBy4Anhgkzw+SeeuAm4H/bmbXpcz/I2AFUAmsBB4aZDnzge3ufjRl2vrkdJEhqdAlm7UCEweZ1wN81d17SBRlFYniPerum4HNwMXJsX8OfMndW9z9JPBl4OZTW9dJ/zW5RbyeRIEuSnmf2WZW5e6d7r66fxAzm0riB8I97n7C3V8HHgFuSxn2gruvcvc+4PGU5fdXCrT3m9YOlA0yXuQ0Fbpks3qgbZB57yTLEaAr+ef+lPldJMoREvvlf2xmR8zsCLCVxMHXmpTx+1IeH0957R3AhcAbZrbGzD40QJY6oK3fVvXbyfyDLb+43w+UUzqB8n7TyoGjA4wVOYMKXbKSmV1KohBfyMDidgNL3b0y5avY3fcM90J3f8vdbwUmA18ncYByfL9hrcBEM0vdip4GDLv8AWwGZvVb1qLkdJEhqdAlq5hZeXIreAXwv919YwYWuwz4qplNT75HtZndlGaeT5lZdfL0ySPJyX2pY9x9N/Ai8PdmVmxmF5PYsv+XkQZ19zeB14H7k8v6CIldRz8a6bIkegb6lU8kCE+ZWS8QJ3Ee+jdIFHEmPAgY8DMzqwMOAP8K/CSN194AfMPMSkjsRrnF3U+YWf9xtybztpI46Hq/uz93jnlvAR5NLmcXcLO7HzzHZUmE6INFIiIhoV0uIiIhoUIXEQkJFbqISEio0EVEQiKws1yqqqp8xowZQb29iEhOWrdu3SF3H/BibYEV+owZM1i7dm1Qby8ikpPM7O3B5mmXi4hISKjQRURCQoUuIhISKnQRkZBQoYuIhMSwhW5m30ve5mvTIPPNzL6dvO3WBjNbnPmYIiIynHS20B8lccW5wSwF5iS/7gT+1/nHEhGRkRr2PHR3f97MZgwx5CbgMU9ctnG1mVWaWa27781UyFS7247z4u8OpeRLyZoybrCLSHrKqMFe23/mYNejPOP1g4wfPN/ASz1zfHpZR7quZ752+Pc4n+X3X9bgg9K86mfKZWut32TDMIM8A7NTj438PCPPjIKYkR/LoyCWR2F+HkXJr5LCfMYXxSgrKqB8XD7lxQXk5Z11eVyRrJeJDxbVk7gjzCktyWlnFbqZ3UliK55p06ad05ttaGnnnh9l4p4Hkm3OvsT4mcbqSs+xPGNCSQFVpUXUVY6jtqKYhgklzJ5cypzJpUydWEJMhS9ZKBOFPtB39oD/9Nx9ObAcoKmp6Zz+eV47dzIv3nvtmQFSElhKnMEKwgZ5Yv1W5czlDrKsIbYYB1yuDTbmPJbJ8GU41OtHmmPQZaYTYhS4O+6Jbzr3xO8N8eS0uDu9cSceT/zZ0xenp9fp7uvjRE+ck719dHXH6TzZS+fJXtq7ejh8rJu2490c6DjJ3vYuXtt1mMPHe06/37iCGIumVrBk+gQunTGRK2ZNorggFsi6i6TKRKG3AFNTnjeQuGvLqBhXGGNc4bjRWrzkoFO7V5LPRuU9Ok700Hygk+YDnWxp7eDVXYdZ9pvtPPyr3zG+MMY1cyezdEEtH5hXQ2G+Th6TYGSi0FcCd5vZCuByoH209p+LBKW8uIDF0yaweNqE09OOd/fy8o42frZ5H89t2c9PN+ylpryI26+cwScvm0ZlSWGAiSWKhr0FnZn9ALgaqAL2A/cDBQDuvswSv2c/ROJMmOPAZ9x92KtuNTU1uS7OJWHRF3d++9ZBvvvCDn771iFKCmPcfe1sPnfVLG2xS0aZ2Tp3bxpwXlD3FFWhS1i9sa+Dbz73Js9u3s+cyaV89SMLuWzmxKBjSUgMVejadBDJsLlTyvnH25r47u1NHO/u4+P/+BLf+Nm2QU9VFckUFbrIKLmusYbn/tP7+JMlDXz7l8184QevcaKnL+hYEmKB3eBCJApKCvP5HzdfzKzqUr7+zBvsOdLFI59uYlJpUdDRJIS0hS4yysyMv7j6ApZ9ajFbWju445/XaktdRoUKXWSM3LCglgdveRfrW47wV//6OvG49qlLZqnQRcbQDQum8KUbG3l60z6+9swbQceRkNE+dJExdsdVM9nVdpzlz2/nwpoybl7SEHQkCQltoYuMMTPjvg/N47KZE/lvT23mQMeJoCNJSKjQRQKQH8vjax9dyIneOPev3Bx0HAkJFbpIQGZVl/LF6+bw9KZ9PLNpX9BxJARU6CIBuvN9s2isLee+n2yivatn+BeIDEGFLhKgglgeX//YQg51nuTBn78VdBzJcSp0kYBd3FDJxxY38H9eeZuDR08GHUdymApdJAv8xdUX0N0b57sv7Ag6iuQwFbpIFphVXcqHLq7j8Zd2cvhYd9BxJEep0EWyxOevmc2x7j6+/+LOoKNIjlKhi2SJi6aUcf38Gh799x10nNAZLzJyKnSRLHL3NXPoONHL4y+9HXQUyUEqdJEssrChgisvmMSKNbt0NUYZMRW6SJb5eNNUdrd18crOtqCjSI5RoYtkmevnT6G0KJ8frmsJOorkGBW6SJYZVxjjQxfXsmrjXo6d7A06juQQFbpIFvrYkgaOd/fxtC7aJSOgQhfJQk3TJzB9Ugk/XLc76CiSQ1ToIlnIzLh5cQOrt7exu+140HEkR6jQRbLUR5c0YIYOjkraVOgiWaq+chyXz5zI05v2Bh1FcoQKXSSL/UFjDW/u79RuF0mLCl0ki13XWAPAL7buDziJ5AIVukgWm1k1nlnV4/nFGweCjiI5IK1CN7MbzGybmTWb2b0DzK8ws6fMbL2ZbTazz2Q+qkg0XTd3Mi9vb6NTHzKSYQxb6GYWAx4GlgLzgFvNbF6/YZ8Htrj7IuBq4H+aWWGGs4pE0rVza+jui/PCWweDjiJZLp0t9MuAZnff7u7dwArgpn5jHCgzMwNKgTZAmxMiGdA0YwLlxfn8Yqt2u8jQ0in0eiD142otyWmpHgIagVZgI/BFd49nJKFIxBXE8nj/RZP51bYDuqSuDCmdQrcBpvX/rroeeB2oAy4BHjKz8rMWZHanma01s7UHD+rXR5F0XTd3Moc6u1nfciToKJLF0in0FmBqyvMGElviqT4DPOkJzcAOYG7/Bbn7cndvcvem6urqc80sEjlXX1RNnsEvdbaLDCGdQl8DzDGzmckDnbcAK/uN2QVcB2BmNcBFwPZMBhWJssqSQpZMn8CvtqnQZXDDFrq79wJ3A88CW4En3H2zmd1lZnclh30FuNLMNgK/AO5x90OjFVokit59QRVbWjt0A2kZVH46g9x9FbCq37RlKY9bgQ9mNpqIpLpi5kS+7bB2ZxvXzq0JOo5kIX1SVCRHvGvaBApixsvbda9RGZgKXSRHjCuMsaihkpd3qNBlYCp0kRxy+ayJbNzTrnuNyoBU6CI55LKZk+iLO+vePhx0FMlCKnSRHLJk+gRiecbLO94JOopkIRW6SA4pLcpnQX2FDozKgFToIjnmipkTWd9yhK7uvqCjSJZRoYvkmMtnTaSnz3ltl/ajy5lU6CI5pmnGRMzQ6YtyFhW6SI4pLy5gXm25DozKWVToIjno0hkTWb+7nd4+3XZAfk+FLpKDLplaSVdPH28d6Aw6imQRFbpIDlo0tRKA9buPBJpDsosKXSQHzZhUQnlxvu5gJGdQoYvkIDNj0dRKXt/dHnQUySIqdJEcdcnUSrbt6+B4ty7UJQkqdJEctaihkrjDpj0dQUeRLKFCF8lROjAq/anQRXJUdVkR9ZXjeF0HRiVJhS6Swy6ZWqktdDlNhS6SwxZNraDlcBeHOk8GHUWygApdJIctaqgEYIN2uwgqdJGctqC+gjxD56MLoEIXyWnji/K5sKZM+9EFUKGL5LxFDZWsbzmCuwcdRQKmQhfJcQvqyzlyvIfW9hNBR5GAqdBFcty8ugoANu/RfvSoU6GL5LjG2jLMYHOrLgEQdSp0kRxXUpjPzKrxKnRRoYuEwfy6Cra0apdL1KnQRUJgfl05re0nOHysO+goEqC0Ct3MbjCzbWbWbGb3DjLmajN73cw2m9lvMhtTRIYyv64cgC17tdslyoYtdDOLAQ8DS4F5wK1mNq/fmErgO8Afuft84E8yH1VEBjP/1Jku2u0SaelsoV8GNLv7dnfvBlYAN/Ub80ngSXffBeDuBzIbU0SGMnF8IbUVxTowGnHpFHo9sDvleUtyWqoLgQlm9mszW2dmnx5oQWZ2p5mtNbO1Bw8ePLfEIjKg+XXlKvSIS6fQbYBp/T9jnA8sAf4QuB74WzO78KwXuS939yZ3b6qurh5xWBEZ3Ly6CrYf7KSruy/oKBKQdAq9BZia8rwBaB1gzDPufszdDwHPA4syE1FE0jG/rpy4w9Z92kqPqnQKfQ0wx8xmmlkhcAuwst+YnwDvNbN8MysBLge2ZjaqiAzl9Jku2u0SWfnDDXD3XjO7G3gWiAHfc/fNZnZXcv4yd99qZs8AG4A48Ii7bxrN4CJypvrKcVSMK9B+9AgbttAB3H0VsKrftGX9nj8APJC5aCIyEmbG/LpyfWI0wvRJUZEQmV9XztZ9R+ntiwcdRQKgQhcJkcbacrp74+w4dCzoKBIAFbpIiDTW6hIAUaZCFwmRC6pLKYgZb+w7GnQUCYAKXSRECvPzuKC6lK3aQo8kFbpIyMyrLVehR5QKXSRkGmvL2d9xkjZdGz1yVOgiITO3tgxAW+kRpEIXCZlTZ7qo0KNHhS4SMlWlRVSXFbF1r850iRoVukgINerAaCSp0EVCqHFKGc0HOunRJQAiRYUuEkKNteV098XZflCXAIgSFbpICOnAaDSp0EVCaFb1eApjeSr0iFGhi4RQQSyP2ZNLdZGuiFGhi4RU4kwXnboYJSp0kZBqrC3jUOdJDh49GXQUGSMqdJGQmqcDo5GjQhcJKZ3pEj0qdJGQmjC+kNqKYhV6hKjQRUJMB0ajRYUuEmKNtWU0H+zkRE9f0FFkDKjQRUJsXm0FfXGn+UBn0FFkDKjQRUKsMXmzC33AKBpU6CIhNn3SeMYVxHRgNCJU6CIhFsszLppSxpZWFXoUqNBFQm5eXeJmF+4edBQZZSp0kZBrrC2n40Qvre0ngo4io0yFLhJy85IHRrdqt0voqdBFQu6iKeWY6UyXKEir0M3sBjPbZmbNZnbvEOMuNbM+M7s5cxFF5HyUFuUzfWKJznSJgGEL3cxiwMPAUmAecKuZzRtk3NeBZzMdUkTOT+ISACr0sEtnC/0yoNndt7t7N7ACuGmAcV8AfgQcyGA+EcmAxtpydr5znM6TvUFHkVGUTqHXA7tTnrckp51mZvXAR4BlQy3IzO40s7VmtvbgwYMjzSoi52h+nS6lGwXpFLoNMK3/Ca3fAu5x9yGvAOTuy929yd2bqqur04woIudrQX0FAJv2tAecREZTfhpjWoCpKc8bgNZ+Y5qAFWYGUAXcaGa97v5vmQgpIuenpryY6rIiNqrQQy2dQl8DzDGzmcAe4Bbgk6kD3H3mqcdm9ijwU5W5SHZZWF+hLfSQG3aXi7v3AneTOHtlK/CEu282s7vM7K7RDigimbGgrpzmA510deva6GGVzhY67r4KWNVv2oAHQN39z84/lohk2oL6CuKe+IDRkukTgo4jo0CfFBWJiIUNOjAadip0kYiYUl7MpPGFOjAaYip0kYgwMxbowGioqdBFImRhfQVvHdBNo8NKhS4SIQvqy+mLuz4xGlIqdJEI0SdGw02FLhIh9ZXjmFBSwKY92kIPIxW6SIScOjCqM13CSYUuEjEL6it4c/9RHRgNIRW6SMQsrK+gN+68se9o0FEkw1ToIhFzydRKAF7bdTjYIJJxKnSRiKmrHMeU8mJe3XUk6CiSYSp0kQhaMn0Cr76tLfSwUaGLRNC7plWy50gX+ztOBB1FMkiFLhJBi5OXz9VWerio0EUiaH5dOYWxPF7VgdFQUaGLRFBRfoyFDRU6MBoyKnSRiFo8rZKNe9rp7o0HHUUyRIUuElGLp02guzfO5lZdBiAsVOgiEXXqwOg6HRgNDRW6SETVlBdTXzmO17QfPTRU6CIRtnj6BJ3pEiIqdJEIWzytkr3tJ2g90hV0FMkAFbpIhC1J7kdfs7Mt4CSSCSp0kQibX1dBeXE+Lza/E3QUyQAVukiExfKMKy+o4oXmQ7h70HHkPKnQRSLuPXOq2HOki7ffOR50FDlPKnSRiLtqdhUALzQfCjiJnC8VukjEzZhUQn3lOP5dhZ7zVOgiEWdmvGf2JF783Tv0xbUfPZelVehmdoOZbTOzZjO7d4D5f2pmG5JfL5rZosxHFZHR8p7ZVbR39ei6Ljlu2EI3sxjwMLAUmAfcambz+g3bAbzf3S8GvgIsz3RQERk9V16g/ehhkM4W+mVAs7tvd/duYAVwU+oAd3/R3U99fng10JDZmCIymqrLipg7pUzno+e4dAq9Htid8rwlOW0wdwBPDzTDzO40s7VmtvbgwYPppxSRUfee2VW8srONEz19QUeRc5ROodsA0wY8cmJm15Ao9HsGmu/uy929yd2bqqur008pIqPuqtlVdPfGWbtTF+vKVekUegswNeV5A9Daf5CZXQw8Atzk7vq9TSTHXD5rIsUFeTy3ZV/QUeQcpVPoa4A5ZjbTzAqBW4CVqQPMbBrwJHCbu7+Z+ZgiMtpKCvN5/4XVPLN5H3GdvpiThi10d+8F7gaeBbYCT7j7ZjO7y8zuSg67D5gEfMfMXjeztaOWWERGzY0La9nfcZLXdmu3Sy7KT2eQu68CVvWbtizl8eeAz2U2moiMtWvnTqYwlseqjftYMn1i0HFkhPRJURE5ray4gPfOqeKZTft09cUcpEIXkTMsXVjLniNdbGjRp0ZzjQpdRM7wgcYa8vOMVZv2Bh1FRkiFLiJnqCgp4D2zq3h6o3a75BoVuoicZemCKexqO86WvR1BR5ERUKGLyFk+OH8K+XnGj1/dE3QUGQEVuoicZeL4Qq5fMIX/u66Frm5d2yVXqNBFZEC3XTGd9q4enlp/1pU+JEup0EVkQJfPnMiFNaU8tnqnDo7mCBW6iAzIzLjt3TPYtKeD13cfCTqOpEGFLiKD+si76iktyufxl94OOoqkQYUuIoMqLcrno4vr+emGvbQd6w46jgxDhS4iQ7rtiul098X5l9XaSs92KnQRGdKcmjL+oHEyy5/frq30LKdCF5Fh3XPDXI519/LQL5uDjiJDUKGLyLDm1JTx8aapPL56J7veOR50HBmECl1E0vJXH7iQWJ7xwM+2BR1FBqFCF5G01JQXc8dVM3lqfSsbWo4EHUcGoEIXkbT9+fsvYNL4Qv76yY2c7NU1XrKNCl1E0lZeXMDff3Qhm1s7eOAZ7XrJNip0ERmRD86fwu3vns4jL+zgV9sOBB1HUqjQRWTE/vrGRuZOKeM/P7GeA0dPBB1HklToIjJixQUx/uHWd3Gsu5e7Hl9H58neoCMJKnQROUdzasr45scvYX1LO5/9/hqOd6vUg6ZCF5FztnRhLd/6xCWsfbuNzz66Rnc3CpgKXUTOy4cX1fHNT1zCKzva+NR3X2Zve1fQkSJLhS4i5+2mS+r5h1sX88beDm588Lf88o39QUeKJBW6iGTEH15cy1NfuIopFeP47KNr+fLKzRzW1RnHlApdRDJmVnUpP/7LK7n93dN57KWdvO+BX/GdXzdr3/oYsaBu/trU1ORr164N5L1FZPRt23eUB559g59vPcDE8YV8bHE9n7h0KrMnlwUdLaeZ2Tp3bxpwngpdREbTmp1tfO+FHTy3ZT+9cWdRQwXXzJ3M+y6sZlFDJbE8CzpiTjnvQjezG4AHgRjwiLt/rd98S86/ETgO/Jm7vzrUMlXoItFyqPMkT77awv/buI8NLUdwh7LifBbUVbCwoYL5deXMqiplelUJ5cUFQcfNWudV6GYWA94EPgC0AGuAW919S8qYG4EvkCj0y4EH3f3yoZarQheJrsPHunmh+RCrt7/Dpj3tbN13lO7e+On5E0oKmFIxjpryIiaXFTFhfCGV4wqpLCmgrDif8UX5lBblM64gRnFBjOKCPArz8yiKxSjMzyM/ZuTnGYltzXAZqtDz03j9ZUCzu29PLmwFcBOwJWXMTcBjnvjpsNrMKs2s1t33nmd2EQmhCeML+fCiOj68qA6Anr442w8eY8ehY+x85xi72o5zoOME+ztOsqW1gyPHe+juiw+z1LPF8oxYXqLcTz3OMyPPwE79ye+fA5glv7Dkn79nZr9/njJjsB8bg/1AueXSqXzuvbNGvD7DSafQ64HdKc9bSGyFDzemHjij0M3sTuBOgGnTpo00q4iEVEEsj4umlHHRlIEPmLo7XT19HD7ew7GTvXSe7OXYyV66uvs40RvnRHcfJ/vidPcmvnr74vTEnd6+OH3u9PU5vXHH3Yk7xN2Ju+OnH4M7OE7yP9wdPyMDp5+n7tkYdB/HEDs/qkqLRvB/J33pFPpAP2L6R01nDO6+HFgOiV0uaby3iAhmRklhPiWF6VRWdKVzHnoLMDXleQPQeg5jRERkFKVT6GuAOWY208wKgVuAlf3GrAQ+bQlXAO3afy4iMraG/f3F3XvN7G7gWRKnLX7P3Teb2V3J+cuAVSTOcGkmcdriZ0YvsoiIDCStHVLuvopEaadOW5by2IHPZzaaiIiMhK7lIiISEip0EZGQUKGLiISECl1EJCQCu9qimR0E3j7Hl1cBhzIYJxdonaNB6xwN57PO0929eqAZgRX6+TCztYNdnCastM7RoHWOhtFaZ+1yEREJCRW6iEhI5GqhLw86QAC0ztGgdY6GUVnnnNyHLiIiZ8vVLXQREelHhS4iEhJZXehmdoOZbTOzZjO7d4D5ZmbfTs7fYGaLg8iZSWms858m13WDmb1oZouCyJlJw61zyrhLzazPzG4ey3yjIZ11NrOrzex1M9tsZr8Z64yZlsb3doWZPWVm65PrnNNXbTWz75nZATPbNMj8zPeXu2flF4lL9f4OmAUUAuuBef3G3Ag8TeKOSVcALwedewzW+UpgQvLx0iisc8q4X5K46ufNQeceg7/nShL37Z2WfD456NxjsM5/A3w9+bgaaAMKg85+Huv8PmAxsGmQ+Rnvr2zeQj99c2p37wZO3Zw61embU7v7aqDSzGrHOmgGDbvO7v6iux9OPl1N4u5QuSydv2eALwA/Ag6MZbhRks46fxJ40t13Abh7rq93OuvsQJkl7qxcSqLQe8c2Zua4+/Mk1mEwGe+vbC70wW48PdIxuWSk63MHiZ/wuWzYdTazeuAjwDLCIZ2/5wuBCWb2azNbZ2afHrN0oyOddX4IaCRx+8qNwBfdPT428QKR8f7K5juuZuzm1Dkk7fUxs2tIFPpVo5po9KWzzt8C7nH3vsTGW85LZ53zgSXAdcA44CUzW+3ub452uFGSzjpfD7wOXAtcADxnZr91945RzhaUjPdXNhd6FG9Ondb6mNnFwCPAUnd/Z4yyjZZ01rkJWJEs8yrgRjPrdfd/G5OEmZfu9/Yhdz8GHDOz54FFQK4Wejrr/Bnga57YwdxsZjuAucArYxNxzGW8v7J5l0sUb0497Dqb2TTgSeC2HN5aSzXsOrv7THef4e4zgB8Cf5nDZQ7pfW//BHivmeWbWQlwObB1jHNmUjrrvIvEbySYWQ1wEbB9TFOOrYz3V9ZuoXsEb06d5jrfB0wCvpPcYu31HL5SXZrrHCrprLO7bzWzZ4ANQBx4xN0HPP0tF6T59/wV4FEz20hid8Q97p6zl9U1sx8AVwNVZtYC3A8UwOj1lz76LyISEtm8y0VEREZAhS4iEhIqdBGRkFChi4iEhApdRCQkVOgiIiGhQhcRCYn/D/+DxTrJcyt7AAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Visualize the model evaluation/prediciton\n",
+    "\"\"\"\n",
+    "for i in range(N_DIMS):\n",
+    "    _y_pred = y_pred.mean(axis=tuple(set(range(N_DIMS))-{i}))\n",
+    "    plt.plot(s, _y_pred)\n",
+    "    plt.title(f\"Dimension {i}\")\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "42bf1cc0",
+   "metadata": {},
+   "source": [
+    "## Futher Tasks\n",
+    "Now we will make our exercise more difficult:\n",
+    "* Make the functions more complex (N_PEAK) and train the classifier again. Describe your observations.\n",
+    "* Raise the number of dimensions (N_DIM) to 2 (and 10) and train the classifier again. Describe your observations."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "05fcec7d",
+   "metadata": {},
+   "source": [
+    "## Summary\n",
+    "This concludes our tutorial on the Classification between Two Classes.\n",
+    "\n",
+    "In this tutorial you have learned:\n",
+    "* How to visualize n-dimensional data distributions from two classes\n",
+    "* How to prepare the data for a classification\n",
+    "* How to create a neural network for a classification\n",
+    "* Which loss to use for a classification\n",
+    "* How to interpret the output of a classification network\n",
+    "* The strenghts and limits of a simple network and a simple optimizer according to:\n",
+    "    * Number of dimensions\n",
+    "    * Complexity of functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f5d7c7bf",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/lecture3/exercise_3_3_classification.ipynb b/lecture3/exercise_3_3_classification.ipynb
new file mode 100644
index 0000000..00e5464
--- /dev/null
+++ b/lecture3/exercise_3_3_classification.ipynb
@@ -0,0 +1,151 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "93c2f0ba",
+   "metadata": {},
+   "source": [
+    "# Classification with DNN and Pen&Paper\n",
+    "\n",
+    "In this task we will explore the analytic solution of DNN classifications.\n",
+    "\n",
+    "## Introduction\n",
+    "We will create data from two Gaussian distributions and train a classification between them.\n",
+    "In parallel we will take pen and paper to calculate the solution of the classification.\n",
+    "Then we will compare the results of our network training and our pen&paper calculation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "20329dfd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from matplotlib import pyplot as plt\n",
+    "import tensorflow as tf"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "df4f97e5",
+   "metadata": {},
+   "source": [
+    "## Creating and plotting the data\n",
+    "First we fix the parametrisation of our Gaussian distributions (A and B) and create the data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "6c92b864",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# parametrisation of the underlying probability distributions\n",
+    "loc_a, scale_a = 0, 1.5\n",
+    "loc_b, scale_b = 1, 1.2\n",
+    "\n",
+    "# creating the data\n",
+    "a = np.random.normal(loc=loc_a, scale=scale_a, size=(100000,))\n",
+    "b = np.random.normal(loc=loc_b, scale=scale_b, size=(100000,))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2890ec5b",
+   "metadata": {},
+   "source": [
+    "We bin the data in histograms with equidistant bins, plot the histograms and plot (parts of) the raw data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "f687f21b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x7f9211e57c70>"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# creating the figure\n",
+    "fig, (ax1, ax2) = plt.subplots(nrows=2, ncols=1, sharex='col', gridspec_kw={'height_ratios': [2, 1], \"hspace\": 0})\n",
+    "\n",
+    "# plot histograms\n",
+    "hist_a, bins_a, _ = ax1.hist(a, bins=np.arange(-4, 4.4, 0.4), alpha=0.5, label=\"Distribution A\")\n",
+    "hist_b, bins_b, _ = ax1.hist(b, bins=bins_a, alpha=0.5, label=\"Distribution B\")\n",
+    "\n",
+    "# plot 1000 example points\n",
+    "ax2.plot(a[:1000], np.zeros_like(a)[:1000], linestyle=\"None\", marker=\"|\", alpha=0.1)\n",
+    "ax2.plot(b[:1000], np.zeros_like(b)[:1000], linestyle=\"None\", marker=\"|\", alpha=0.1)\n",
+    "\n",
+    "# styling plot\n",
+    "ax2.axes.get_yaxis().set_visible(False)\n",
+    "ax2.set_xlabel(\"x\")\n",
+    "ax1.set_ylabel(\"Counts [#]\")\n",
+    "ax2.set_xlim([-4, 4])\n",
+    "ax1.legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "77dfd868",
+   "metadata": {},
+   "source": [
+    "## Task\n",
+    "Now it is your turn. The two data distributions is everything you will get to solve this task. Train a classification between the two distributions and compare the output of your network with the pen&paper calculation you performed before. Describe your observation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a7e53779",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/lecture3/exercise_3_3_classification_solution.ipynb b/lecture3/exercise_3_3_classification_solution.ipynb
new file mode 100644
index 0000000..dc82a13
--- /dev/null
+++ b/lecture3/exercise_3_3_classification_solution.ipynb
@@ -0,0 +1,431 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "93c2f0ba",
+   "metadata": {},
+   "source": [
+    "# Classification with DNN and Pen&Paper\n",
+    "\n",
+    "In this task we will explore the analytic solution of DNN classifications.\n",
+    "\n",
+    "## Introduction\n",
+    "We will create data from two Gaussian distributions and train a classification between them.\n",
+    "In parallel we will take pen and paper to calculate the solution of the classification.\n",
+    "Then we will compare the results of our network training and our pen and paper calculation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "20329dfd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from matplotlib import pyplot as plt\n",
+    "import tensorflow as tf"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "df4f97e5",
+   "metadata": {},
+   "source": [
+    "## Creating and plotting the data\n",
+    "First we fix the parametrisation of our Gaussian distributions (A and B) and create the data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "6c92b864",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# parametrisation of the underlying probability distributions\n",
+    "loc_a, scale_a = 0, 1.5\n",
+    "loc_b, scale_b = 1, 1.2\n",
+    "\n",
+    "# creating the data\n",
+    "a = np.random.normal(loc=loc_a, scale=scale_a, size=(100000,))\n",
+    "b = np.random.normal(loc=loc_b, scale=scale_b, size=(100000,))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2890ec5b",
+   "metadata": {},
+   "source": [
+    "We bin the data in histograms with equidistant bins, plot the histograms and plot (parts of) the raw data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "f687f21b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x7f9211e57c70>"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# creating the figure\n",
+    "fig, (ax1, ax2) = plt.subplots(nrows=2, ncols=1, sharex='col', gridspec_kw={'height_ratios': [2, 1], \"hspace\": 0})\n",
+    "\n",
+    "# plot histograms\n",
+    "hist_a, bins_a, _ = ax1.hist(a, bins=np.arange(-4, 4.4, 0.4), alpha=0.5, label=\"Distribution A\")\n",
+    "hist_b, bins_b, _ = ax1.hist(b, bins=bins_a, alpha=0.5, label=\"Distribution B\")\n",
+    "\n",
+    "# plot 1000 example points\n",
+    "ax2.plot(a[:1000], np.zeros_like(a)[:1000], linestyle=\"None\", marker=\"|\", alpha=0.1)\n",
+    "ax2.plot(b[:1000], np.zeros_like(b)[:1000], linestyle=\"None\", marker=\"|\", alpha=0.1)\n",
+    "\n",
+    "# styling plot\n",
+    "ax2.axes.get_yaxis().set_visible(False)\n",
+    "ax2.set_xlabel(\"x\")\n",
+    "ax1.set_ylabel(\"Counts [#]\")\n",
+    "ax2.set_xlim([-4, 4])\n",
+    "ax1.legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d78ecea0",
+   "metadata": {},
+   "source": [
+    "## DNN based Classification\n",
+    "\n",
+    "Now create a DNN model for the classification between Distribution A and Distribution B.\n",
+    "- How many inputs do we have?\n",
+    "- How many outputs do we have?\n",
+    "- How many layers with which activation funcitons do we need?\n",
+    "- Does the network output probabilities or logits?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "7dbbc75c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Create the model\n",
+    "\"\"\"\n",
+    "model = tf.keras.Sequential(\n",
+    "    layers=[\n",
+    "        tf.keras.Input(shape=(1,)),\n",
+    "        tf.keras.layers.Dense(30, activation=\"relu\"),\n",
+    "        tf.keras.layers.Dense(30, activation=\"relu\"),\n",
+    "        tf.keras.layers.Dense(1, activation=\"sigmoid\"),\n",
+    "    ]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3131b396",
+   "metadata": {},
+   "source": [
+    "Now compile the model.\n",
+    "- Which loss function do we want?\n",
+    "- Which optimizer do we want?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "id": "52114d30",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\"\"\"\n",
+    "TODO: Compile the model\n",
+    "optimizer = \"sgd\"\n",
+    "loss = tf.keras.losses.BinaryCrossentropy(from_logits=False)\n",
+    "model.compile(optimizer=optimizer, loss=loss, metrics=[\"accuracy\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "51d8dee9",
+   "metadata": {},
+   "source": [
+    "Look at the model summary to see how many trainable parameters or model has."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "id": "0e8cd8a5",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"sequential_1\"\n",
+      "_________________________________________________________________\n",
+      "Layer (type)                 Output Shape              Param #   \n",
+      "=================================================================\n",
+      "dense_3 (Dense)              (None, 30)                60        \n",
+      "_________________________________________________________________\n",
+      "dense_4 (Dense)              (None, 30)                930       \n",
+      "_________________________________________________________________\n",
+      "dense_5 (Dense)              (None, 1)                 31        \n",
+      "=================================================================\n",
+      "Total params: 1,021\n",
+      "Trainable params: 1,021\n",
+      "Non-trainable params: 0\n",
+      "_________________________________________________________________\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.summary()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "664744b9",
+   "metadata": {},
+   "source": [
+    "Now we prepare the data for the training by interleaving datasets A and B and shuffling the data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "id": "47253403",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# prepare the data for training (interleave+shuffle)\n",
+    "x = np.concatenate([a, b])\n",
+    "y = np.concatenate([np.ones_like(a), np.zeros_like(b)])\n",
+    "p = np.random.permutation(len(x))\n",
+    "x, y = x[p], y[p]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "85757895",
+   "metadata": {},
+   "source": [
+    "Now we fit the model to the training data:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "7013e12d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/5\n",
+      "5000/5000 [==============================] - 7s 1ms/step - loss: 0.6348 - accuracy: 0.6359 - val_loss: 0.6210 - val_accuracy: 0.6504\n",
+      "Epoch 2/5\n",
+      "5000/5000 [==============================] - 5s 1ms/step - loss: 0.6214 - accuracy: 0.6501 - val_loss: 0.6208 - val_accuracy: 0.6507\n",
+      "Epoch 3/5\n",
+      "5000/5000 [==============================] - 6s 1ms/step - loss: 0.6217 - accuracy: 0.6486 - val_loss: 0.6205 - val_accuracy: 0.6509\n",
+      "Epoch 4/5\n",
+      "5000/5000 [==============================] - 6s 1ms/step - loss: 0.6208 - accuracy: 0.6494 - val_loss: 0.6205 - val_accuracy: 0.6510\n",
+      "Epoch 5/5\n",
+      "5000/5000 [==============================] - 6s 1ms/step - loss: 0.6217 - accuracy: 0.6503 - val_loss: 0.6204 - val_accuracy: 0.6508\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<tensorflow.python.keras.callbacks.History at 0x7f9211fa5850>"
+      ]
+     },
+     "execution_count": 50,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# fit the model\n",
+    "model.fit(x=x, y=y, epochs=5, validation_split=0.2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "31e4e01b",
+   "metadata": {},
+   "source": [
+    "## Plotting and Results\n",
+    "In the following cells we will plot the analytic solution, our training solution and the analytic solution using the actual data distributions which were used for the training."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "id": "3056147d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# define x_values for inference and plotting\n",
+    "x_values = np.arange(-4, 4.01, 0.01)[:, None]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "160928b9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# analytic solution\n",
+    "def gaussian(x, loc, scale):\n",
+    "    return 1 / np.sqrt(2 * np.pi * scale ** 2) * np.exp(-((x - loc) ** 2) / (2 * scale ** 2))\n",
+    "\n",
+    "gauss_a = gaussian(x_values, loc=loc_a, scale=scale_a)\n",
+    "gauss_b = gaussian(x_values, loc=loc_b, scale=scale_b)\n",
+    "analytic = gauss_a / (gauss_a + gauss_b)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "id": "7d2b85be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# classic solution by histogram division\n",
+    "hist = hist_a / (hist_a + hist_b)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "id": "eb42db1a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# DNN based classification solution\n",
+    "pred = model.predict(x_values)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "id": "86373833",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x7f9211204e80>"
+      ]
+     },
+     "execution_count": 55,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot all the infered ratios\n",
+    "plt.plot(x_values, analytic, label=\"Analytic\", color=\"black\", linestyle=\"--\")\n",
+    "plt.plot((bins_a[1:]+bins_a[:-1])/2, hist, label=\"Hist\")\n",
+    "plt.plot(x_values, pred, label=\"DNN\", color=\"red\")\n",
+    "plt.xlabel(\"x\")\n",
+    "plt.ylabel(\"Ratio A/(A+B)\")\n",
+    "plt.xlim([-4, 4])\n",
+    "plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0742090c",
+   "metadata": {},
+   "source": [
+    "As you can see, the all three distributions match quite well!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ef7e916c",
+   "metadata": {},
+   "source": [
+    "## Summary\n",
+    "\n",
+    "This concludes our tutorial for today.\n",
+    "\n",
+    "In this tutorial you learned:\n",
+    "- How to train a neural network based classification task\n",
+    "- How to predict the output of the trained network using pen and paper"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b42625de",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
-- 
GitLab