From 530e313b90632818201f99a5e32964fdd9d41a58 Mon Sep 17 00:00:00 2001
From: Joerg Marks <marks@physi.uni-heidelberg.de>
Date: Mon, 3 Apr 2023 12:26:38 +0200
Subject: [PATCH] updates

---
 notebooks/02_fit_exp_fit_iMinuit.ipynb        | 284 ++++++++++
 notebooks/02_fit_histFit.ipynb                | 126 +++++
 notebooks/02_fit_scikitFit.ipynb              | 147 ++++++
 notebooks/03_ml_basics_activation.ipynb       | 148 ++++++
 ...sics_ex_2_display_Cifar10_Greyscale.ipynb} |   0
 .../03_ml_basics_simple_neural_network.ipynb  | 493 ++++++++++++++++++
 ...le_neural_network_exercise_solution.ipynb} |   0
 7 files changed, 1198 insertions(+)
 create mode 100644 notebooks/02_fit_exp_fit_iMinuit.ipynb
 create mode 100644 notebooks/02_fit_histFit.ipynb
 create mode 100644 notebooks/02_fit_scikitFit.ipynb
 create mode 100644 notebooks/03_ml_basics_activation.ipynb
 rename notebooks/{03_ml_basics_ex_1_display_Cifar10_Greyscale.ipynb => 03_ml_basics_ex_2_display_Cifar10_Greyscale.ipynb} (100%)
 create mode 100755 notebooks/03_ml_basics_simple_neural_network.ipynb
 rename notebooks/{simple_neural_network_exercise_solution.ipynb => 03_ml_basics_simple_neural_network_exercise_solution.ipynb} (100%)

diff --git a/notebooks/02_fit_exp_fit_iMinuit.ipynb b/notebooks/02_fit_exp_fit_iMinuit.ipynb
new file mode 100644
index 0000000..9eb6b7d
--- /dev/null
+++ b/notebooks/02_fit_exp_fit_iMinuit.ipynb
@@ -0,0 +1,284 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Example fit for the usage of iminuit"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from matplotlib import pyplot as plt\n",
+    "plt.rcParams[\"font.size\"] = 20\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Data "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x = np.array([0.2,0.4,0.6,0.8,1.,1.2,1.4,1.6,1.8,2.,2.2,2.4,2.6,2.8,3.,3.2,3.4,3.6,3.8,4.],dtype='d')\n",
+    "dy = np.array([0.04,0.021,0.035,0.03,0.029,0.019,0.024,0.018,0.019,0.022,0.02,0.025,0.018,0.024,0.019,0.021,0.03,0.019,0.03,0.024 ], dtype='d')\n",
+    "y = np.array([1.792,1.695,1.541,1.514,1.427,1.399,1.388,1.270,1.262,1.228,1.189,1.182,1.121,1.129,1.124,1.089,1.092,1.084,1.058,1.057 ], dtype='d')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Define fit functions -an exponential"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def xp(a, b , c):\n",
+    "    return a * np.exp(b*x) + c"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "least-squares function: sum of data residuals squared"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def LS(a,b,c):\n",
+    "    return np.sum((y - xp(a,b,c)) ** 2 / dy ** 2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "import Minuit object"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from iminuit import Minuit"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Minuit instance using LS function to minimize"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "LS.errordef = Minuit.LEAST_SQUARES\n",
+    "m = Minuit(LS, a=0.9, b=-0.7 , c=0.95)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Run migrad , parameter c is now fixed"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "m.migrad()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "release fix on \"c\" and minimize again"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "m.fixed[\"c\"] = False\n",
+    "m.migrad()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Get covariance information"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "m.hesse()\n",
+    "m.params\n",
+    "m.covariance"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Copy covariance information to numpy arrays"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Get a 2D contour of the function around the minimum for 2 parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "m.minos()\n",
+    "print (m.merrors['a']) # Print control information of parameter a\n",
+    "m.draw_profile('b', subtract_min=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The Minos algorithm uses the profile likelihood method to compute (generally asymmetric) confidence intervals. This can be plotted"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "m.draw_mncontour('a', 'b')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Access fit results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(m.values,m.errors)\n",
+    "a_fit = m.values[\"a\"]\n",
+    "b_fit = m.values[\"b\"]\n",
+    "c_fit = m.values[\"c\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Prepare data to display fitted function "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_plot = np.linspace( 0.1, 4.5 , 100 )\n",
+    "y_fit =  a_fit * np.exp(b_fit*x_plot) + c_fit "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "plot data and fit results with matplotlib"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure()\n",
+    "plt.errorbar(x, y, dy , fmt=\"o\")\n",
+    "plt.plot(x_plot, y_fit)\n",
+    "plt.title(\"iminuit exponential Fit\")\n",
+    "plt.xlim(-0.1, 4.1)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "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.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/notebooks/02_fit_histFit.ipynb b/notebooks/02_fit_histFit.ipynb
new file mode 100644
index 0000000..b7dac4e
--- /dev/null
+++ b/notebooks/02_fit_histFit.ipynb
@@ -0,0 +1,126 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Test Histogramm Fitting in pyROOT"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import math\n",
+    "#import ROOT\n",
+    "from ROOT import TCanvas, TFile, TProfile, TNtuple, TH1D, TH2D, TF1 \n",
+    "from ROOT import gROOT, gBenchmark, gRandom, gSystem"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "Read data previously used from text file and put it in a numpy array"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = np.genfromtxt('D0Mass.txt', dtype='d')\n",
+    "print(data)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create histogramm and draw"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "d0 = TH1D( 'd0', 'D0 Mass ', 200, 1700. , 2000. )\n",
+    "for x in data :\n",
+    "    d0.Fill(x)\n",
+    "c = TCanvas( 'myC', 'Dynamic Filling Example',700, 500 )\n",
+    "d0.Draw()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To display the notebook draw the canvas."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# %jsroot on\n",
+    "c.Draw()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "perform Fit"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "func = TF1(\"func\", 'gaus', 1840. , 1880.)\n",
+    "myfit = d0.Fit(func,\"S\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "c.Draw()"
+   ]
+  }
+ ],
+ "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.10.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/notebooks/02_fit_scikitFit.ipynb b/notebooks/02_fit_scikitFit.ipynb
new file mode 100644
index 0000000..ccfc503
--- /dev/null
+++ b/notebooks/02_fit_scikitFit.ipynb
@@ -0,0 +1,147 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Fit 3rd order Polynomial to graph data using scikit-learn, more infos\n",
+    "https://www.datatechnotes.com/2018/06/polynomial-regression-fitting-in-python.html"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from matplotlib import pyplot as plt\n",
+    "plt.rcParams[\"font.size\"] = 20\n",
+    "\n",
+    "import numpy as np\n",
+    "\n",
+    "from sklearn.linear_model import LinearRegression\n",
+    "from sklearn.preprocessing import PolynomialFeatures"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], dtype='d')\n",
+    "dx =  np.array([0.1,0.1,0.5,0.1,0.5,0.1,0.5,0.1,0.5,0.1], dtype='d')\n",
+    "y = np.array([1.1 ,2.3 ,2.7 ,3.2 ,3.1 ,2.4 ,1.7 ,1.5 ,1.5  ,1.7 ], dtype='d')\n",
+    "dy = np.array([0.15,0.22,0.29,0.39,0.31,0.21,0.13,0.15,0.19,0.13], dtype='d')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    " building polynomial model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "polyModel = PolynomialFeatures(degree = 3)\n",
+    "xpol = polyModel.fit_transform(x.reshape(-1, 1))\n",
+    "preg = polyModel.fit(xpol,y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Building linear model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "linearModel = LinearRegression(fit_intercept = True)\n",
+    "linearModel.fit(xpol, y[:, np.newaxis])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Plotting\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_plot = np.linspace(0.1,10.1,200)\n",
+    "polyfit = linearModel.predict(preg.fit_transform(x_plot.reshape(-1, 1)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    " plot data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure()\n",
+    "plt.errorbar(x, y, dy , dx, fmt=\"o\")\n",
+    "plt.plot(x_plot, polyfit )\n",
+    "plt.title(\"scikit-learn Fit Test\")\n",
+    "plt.xlim(-0.1, 10.1)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "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.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/notebooks/03_ml_basics_activation.ipynb b/notebooks/03_ml_basics_activation.ipynb
new file mode 100644
index 0000000..9ee5845
--- /dev/null
+++ b/notebooks/03_ml_basics_activation.ipynb
@@ -0,0 +1,148 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "d0ce4228",
+   "metadata": {},
+   "source": [
+    "# plot activation functions\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b3c8093a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Importing the required libraries\n",
+    "import math\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a134fb45",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# The definition of activation functions mathematically\n",
+    "# Sigmoid Function\n",
+    "def sigmoid(x):\n",
+    "    a = []\n",
+    "    for i in x:\n",
+    "        a.append(1/(1+math.exp(-i)))\n",
+    "    return a"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "954c32ed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Hyperbolic Tanjant Function\n",
+    "def tanh(x, derivative=False):\n",
+    "    if (derivative == True):\n",
+    "        return (1 - (x ** 2))\n",
+    "    return np.tanh(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2c0e5136",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ReLU Function\n",
+    "def re(x):\n",
+    "    b = []\n",
+    "    for i in x:\n",
+    "        if i<0:\n",
+    "            b.append(0)\n",
+    "        else:\n",
+    "            b.append(i)\n",
+    "    return b"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f29cac64",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Leaky ReLU Function\n",
+    "def lr(x):\n",
+    "    b = []\n",
+    "    for i in x:\n",
+    "        if i<0:\n",
+    "            b.append(i/10)\n",
+    "        else:\n",
+    "            b.append(i)\n",
+    "    return b\n",
+    "  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1854dc7b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Determining the intervals to be created for the graph\n",
+    "x = np.arange(-3., 3., 0.1)\n",
+    "sig = sigmoid(x)\n",
+    "tanh = tanh(x)\n",
+    "relu = re(x)\n",
+    "leaky_relu = lr(x)\n",
+    "swish = sig*x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9c535ccb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Displaying the functions\n",
+    "line_1, = plt.plot(x,sig, label='Sigmoid')\n",
+    "line_2, = plt.plot(x,tanh, label='Tanh')\n",
+    "line_3, = plt.plot(x,relu, label='ReLU')\n",
+    "line_4, = plt.plot(x,leaky_relu, label='Leaky ReLU')\n",
+    "line_5, = plt.plot(x,swish, label='Swish')\n",
+    "plt.legend(handles=[line_1, line_2, line_3, line_4, line_5])\n",
+    "plt.axhline(y=0, color='k')\n",
+    "plt.axvline(x=0, color='k')\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "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.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/notebooks/03_ml_basics_ex_1_display_Cifar10_Greyscale.ipynb b/notebooks/03_ml_basics_ex_2_display_Cifar10_Greyscale.ipynb
similarity index 100%
rename from notebooks/03_ml_basics_ex_1_display_Cifar10_Greyscale.ipynb
rename to notebooks/03_ml_basics_ex_2_display_Cifar10_Greyscale.ipynb
diff --git a/notebooks/03_ml_basics_simple_neural_network.ipynb b/notebooks/03_ml_basics_simple_neural_network.ipynb
new file mode 100755
index 0000000..8fbd480
--- /dev/null
+++ b/notebooks/03_ml_basics_simple_neural_network.ipynb
@@ -0,0 +1,493 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# A simple neural network with one hidden layer in pure Python\n",
+    "\n",
+    "## Introduction\n",
+    "We consider a simple feed-forward neural network with one hidden layer:"
+   ]
+  },
+  {
+   "attachments": {
+    "48b1ed6e-8e2b-4883-82ac-a2bbed6e2885.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![nn.png](attachment:48b1ed6e-8e2b-4883-82ac-a2bbed6e2885.png)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this example the input vector of the neural network has two features, i.e., the input is a two-dimensional vector:\n",
+    "\n",
+    "$$\n",
+    "\\mathbf x = (x_0, x_1).\n",
+    "$$\n",
+    "\n",
+    "We consider a set of $n$ vectors as training data. The training data can therefore be written as a $n \\times 2$ matrix where each row represents a feature vector:\n",
+    "\n",
+    "$$ \n",
+    "X = \n",
+    "\\begin{pmatrix}\n",
+    "x_{00} & x_{01} \\\\\n",
+    "x_{10} & x_{11} \\\\\n",
+    "\\vdots & \\vdots \\\\\n",
+    "x_{m-1\\,0} & x_{m-1\\,1} \n",
+    "\\end{pmatrix} $$\n",
+    "\n",
+    "The known labels (1 = 'signal', 0 = 'background') are stored in a $n$-dimensional column vector $\\mathbf y$.\n",
+    "\n",
+    "In the following, $n_1$ denotes the number of neurons in the hidden layer. The weights for the connections from the input layer (layer 0) to the hidden layer (layer 0) are given by the following matrix:\n",
+    "\n",
+    "$$\n",
+    "W^{(1)} = \n",
+    "\\begin{pmatrix}\n",
+    "w_{00}^{(1)} \\dots w_{0 \\, n_1-1}^{(1)} \\\\\n",
+    "w_{10}^{(1)} \\dots w_{1 \\, n_1-1}^{(1)} \n",
+    "\\end{pmatrix}\n",
+    "$$\n",
+    "\n",
+    "Each neuron in the hidden layer is assigned a bias $\\mathbf b^{(1)} = (b^{(1)}_0, \\ldots, b^{(1)}_{n_1-1})$. The neuron in the output layer has the bias $\\mathbf b^{(2)}$. With that, the output values of the network for the matrix $X$ of input feature vectors is given by\n",
+    "\n",
+    "$$\n",
+    "\\begin{align}\n",
+    "Z^{(1)} &= X W^{(1)} + \\mathbf b^{(1)} \\\\\n",
+    "A^{(1)} &= \\sigma(Z^{(1)}) \\\\\n",
+    "Z^{(2)} &= A^{(1)} W^{(2)} + \\mathbf b^{(2)} \\\\\n",
+    "A^{(2)} &= \\sigma(Z^{(2)})\n",
+    "\\end{align}\n",
+    "$$\n",
+    "\n",
+    "The loss function for a given set of weights is given by\n",
+    "\n",
+    "$$ L = \\sum_{i=0}^{n-1} (y_\\mathrm{pred} - y_\\mathrm{true})^2 $$\n",
+    "\n",
+    "We can know calculate the gradient of the loss function w.r.t. the wights. With the definition $\\hat L = (y_\\mathrm{pred} - y_\\mathrm{true})^2$, the gradients for the weights from the output layer to the hidden layer are given by: \n",
+    "\n",
+    "$$ \\frac{\\partial \\tilde L}{\\partial w_i^{(2)}} = \\frac{\\partial \\tilde L}{a_k^{(2)}} \\frac{a_k^{(2)}}{\\partial w_i^{(2)}} = \\frac{\\partial \\tilde L}{a_k^{(2)}} \\frac{a_k^{(2)}}{z_k^{(2)}} \\frac{z_k^{(2)}}{\\partial w_i^{(2)}} = 2 (a_k^{(2)} - y_k) a_k^{(2)} (1 - a_k^{(2)}) a_{k,i}^{(1)}$$\n",
+    "\n",
+    "Applying the chain rule further, we also obtain the gradient for the weights from the input layer to the hidden layer read: \n",
+    "\n",
+    "$$ \\frac{\\partial \\tilde L}{\\partial w_{ij}^{(1)}} = \\frac{\\partial \\tilde L}{\\partial a_k^{(2)}} \\frac{\\partial a_k^{(2)}}{\\partial z_k^{(2)}} \\frac{\\partial z_k^{(2)}}{\\partial a_{k,j}^{(1)}} \\frac{\\partial a_{k,j}^{(1)}}{\\partial z_{k,j}^{(1)}} \\frac{\\partial z_{k,j}^{(1)}}{\\partial w_{ij}^{(1)}} $$"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## A simple neural network class"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# A simple feed-forward neutral network with on hidden layer\n",
+    "# see also https://towardsdatascience.com/how-to-build-your-own-neural-network-from-scratch-in-python-68998a08e4f6\n",
+    "\n",
+    "import numpy as np\n",
+    "\n",
+    "class NeuralNetwork:\n",
+    "    def __init__(self, x, y):\n",
+    "        n1 = 3 # number of neurons in the hidden layer\n",
+    "        self.input         = x\n",
+    "        self.weights1      = np.random.rand(self.input.shape[1],n1)\n",
+    "        self.bias1         = np.random.rand(n1)\n",
+    "        self.weights2      = np.random.rand(n1,1)\n",
+    "        self.bias2         = np.random.rand(1)                 \n",
+    "        self.y             = y\n",
+    "        self.output        = np.zeros(y.shape)\n",
+    "        self.learning_rate = 0.01\n",
+    "        self.n_train       = 0\n",
+    "        self.loss_history  = []\n",
+    "\n",
+    "    def sigmoid(self, x):\n",
+    "        return 1/(1+np.exp(-x))\n",
+    "\n",
+    "    def sigmoid_derivative(self, x):\n",
+    "        return x * (1 - x)\n",
+    "\n",
+    "    def feedforward(self):\n",
+    "        self.layer1 = self.sigmoid(self.input @ self.weights1 + self.bias1)\n",
+    "        self.output = self.sigmoid(self.layer1 @ self.weights2 + self.bias2)\n",
+    "\n",
+    "    def backprop(self):\n",
+    "\n",
+    "        # delta1: [m, 1], m = number of training data\n",
+    "        delta1 = 2 * (self.y - self.output) * self.sigmoid_derivative(self.output)\n",
+    "\n",
+    "        # Gradient w.r.t. weights from hidden to output layer: [n1, 1] matrix, n1 = # neurons in hidden layer\n",
+    "        d_weights2 = self.layer1.T @ delta1\n",
+    "        d_bias2    = np.sum(delta1) \n",
+    "    \n",
+    "        # shape of delta2: [m, n1], m = number of training data, n1 = # neurons in hidden layer\n",
+    "        delta2     = (delta1 @ self.weights2.T) * self.sigmoid_derivative(self.layer1)\n",
+    "        d_weights1 = self.input.T @ delta2\n",
+    "        d_bias1    = np.ones(delta2.shape[0]) @ delta2 \n",
+    "        \n",
+    "        # update weights and biases\n",
+    "        self.weights1 += self.learning_rate * d_weights1\n",
+    "        self.weights2 += self.learning_rate * d_weights2\n",
+    "\n",
+    "        self.bias1    += self.learning_rate * d_bias1\n",
+    "        self.bias2    += self.learning_rate * d_bias2\n",
+    "\n",
+    "    def train(self, X, y):\n",
+    "        self.output = np.zeros(y.shape)\n",
+    "        self.input = X\n",
+    "        self.y = y\n",
+    "        self.feedforward()\n",
+    "        self.backprop()\n",
+    "        self.n_train += 1\n",
+    "        if (self.n_train %1000 == 0):\n",
+    "            loss = np.sum((self.y - self.output)**2)\n",
+    "            print(\"loss: \", loss)\n",
+    "            self.loss_history.append(loss)\n",
+    "    \n",
+    "    def predict(self, X):\n",
+    "        self.output = np.zeros(y.shape)\n",
+    "        self.input = X\n",
+    "        self.feedforward()\n",
+    "        return self.output\n",
+    "    \n",
+    "    def loss_history(self):\n",
+    "        return self.loss_history\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create toy data\n",
+    "We create three toy data sets\n",
+    "1. two moon-like distributions\n",
+    "2. circles\n",
+    "3. linearly separable data sets"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html#sphx-glr-auto-examples-classification-plot-classifier-comparison-py\n",
+    "import numpy as np\n",
+    "from sklearn.datasets import make_moons, make_circles, make_classification\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "\n",
+    "X, y = make_classification(\n",
+    "    n_features=2, n_redundant=0, n_informative=2, random_state=1, n_clusters_per_class=1\n",
+    ")\n",
+    "rng = np.random.RandomState(2)\n",
+    "X += 2 * rng.uniform(size=X.shape)\n",
+    "linearly_separable = (X, y)\n",
+    "\n",
+    "datasets = [\n",
+    "    make_moons(n_samples=200, noise=0.1, random_state=0),\n",
+    "    make_circles(n_samples=200, noise=0.1, factor=0.5, random_state=1),\n",
+    "    linearly_separable,\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create training and test data set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# datasets: 0 = moons, 1 = circles, 2 = linearly separable\n",
+    "X, y = datasets[1]\n",
+    "X_train, X_test, y_train, y_test = train_test_split(\n",
+    "    X, y, test_size=0.4, random_state=42\n",
+    ")\n",
+    "\n",
+    "x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5\n",
+    "y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Train the model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loss:  28.591431249971087\n",
+      "loss:  19.174944855091578\n",
+      "loss:  18.300519116661075\n",
+      "loss:  5.44035901972833\n",
+      "loss:  2.2654992441410906\n",
+      "loss:  1.6923656607186892\n",
+      "loss:  1.3715971480249087\n",
+      "loss:  1.1473150221090382\n",
+      "loss:  0.9774346378363713\n",
+      "loss:  0.8457117685917934\n",
+      "loss:  0.7429652120737472\n",
+      "loss:  0.6621808985042399\n",
+      "loss:  0.5977165926831687\n",
+      "loss:  0.545283043346378\n",
+      "loss:  0.5017902977940301\n",
+      "loss:  0.46506515287723293\n",
+      "loss:  0.4335772706016494\n",
+      "loss:  0.40623169342909965\n",
+      "loss:  0.3822273847227754\n",
+      "loss:  0.36096446182458697\n",
+      "loss:  0.3419836665195889\n",
+      "loss:  0.3249263905044797\n",
+      "loss:  0.3095077414631703\n",
+      "loss:  0.29549797484687557\n",
+      "loss:  0.282709394404349\n",
+      "loss:  0.27098690712728085\n",
+      "loss:  0.2602010759266338\n",
+      "loss:  0.2502429170283057\n",
+      "loss:  0.24101994107129043\n",
+      "loss:  0.23245309736167535\n",
+      "loss:  0.2244743850815736\n",
+      "loss:  0.2170249645242441\n",
+      "loss:  0.21005364833790718\n",
+      "loss:  0.2035156851277511\n",
+      "loss:  0.19737177048767093\n",
+      "loss:  0.19158723674048994\n",
+      "loss:  0.18613138439559326\n",
+      "loss:  0.1809769269368725\n",
+      "loss:  0.17609952694233805\n",
+      "loss:  0.17147740633361158\n",
+      "loss:  0.16709101719249247\n",
+      "loss:  0.16292276236867193\n",
+      "loss:  0.15895675725575403\n",
+      "loss:  0.15517862578972155\n",
+      "loss:  0.1515753250400271\n",
+      "loss:  0.1481349938036084\n",
+      "loss:  0.1448468214395504\n",
+      "loss:  0.1417009338445398\n",
+      "loss:  0.13868829400248622\n",
+      "loss:  0.13580061497353096\n",
+      "loss:  0.1330302835389617\n",
+      "loss:  0.1303702930059422\n",
+      "loss:  0.127814183912036\n",
+      "loss:  0.12535599156436183\n",
+      "loss:  0.12299019950967911\n",
+      "loss:  0.1207116981660866\n",
+      "loss:  0.11851574795923153\n",
+      "loss:  0.11639794640004714\n",
+      "loss:  0.11435419862018448\n",
+      "loss:  0.11238069094815246\n",
+      "loss:  0.11047386716576169\n",
+      "loss:  0.10863040713256283\n",
+      "loss:  0.10684720750694056\n",
+      "loss:  0.1051213643275356\n",
+      "loss:  0.10345015724866172\n",
+      "loss:  0.10183103524916717\n",
+      "loss:  0.10026160365640727\n",
+      "loss:  0.09873961234613571\n",
+      "loss:  0.09726294499576621\n",
+      "loss:  0.09582960928281026\n",
+      "loss:  0.09443772793285743\n",
+      "loss:  0.09308553053235864\n",
+      "loss:  0.0917713460310074\n",
+      "loss:  0.09049359586685884\n",
+      "loss:  0.08925078765463015\n",
+      "loss:  0.08804150938406197\n",
+      "loss:  0.08686442408087547\n",
+      "loss:  0.08571826488782217\n",
+      "loss:  0.08460183052776402\n",
+      "loss:  0.08351398111459095\n",
+      "loss:  0.08245363428124586\n",
+      "loss:  0.08141976159718958\n",
+      "loss:  0.08041138525037475\n",
+      "loss:  0.07942757497120295\n",
+      "loss:  0.07846744517812901\n",
+      "loss:  0.07753015232648876\n",
+      "loss:  0.0766148924438704\n",
+      "loss:  0.0757208988368859\n",
+      "loss:  0.07484743995559193\n",
+      "loss:  0.07399381740306453\n",
+      "loss:  0.07315936407873515\n",
+      "loss:  0.07234344244512234\n",
+      "loss:  0.07154544290849069\n",
+      "loss:  0.07076478230479659\n",
+      "loss:  0.07000090248301835\n",
+      "loss:  0.06925326897863726\n",
+      "loss:  0.06852136977065329\n",
+      "loss:  0.06780471411604974\n",
+      "loss:  0.06710283145614956\n",
+      "loss:  0.06641527038972668\n"
+     ]
+    }
+   ],
+   "source": [
+    "y_train = y_train.reshape(-1, 1)\n",
+    "\n",
+    "nn = NeuralNetwork(X_train, y_train)\n",
+    "\n",
+    "for i in range(100000):\n",
+    "    nn.train(X_train, y_train)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Plot the loss vs. the number of epochs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'loss')"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAG2CAYAAABlBWwKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA36ElEQVR4nO3de3hU1b3/8c9Mkpkk5ka4JCAJIlCughQwRqgHjygi3vHUWk4P9qD81KBiesRi1Za2Gi+nlbZS+9QewT6KtipiQYtFEPASQAMRUUQDKKAkKEgCgVxn/f5IZicDAUJmz96Z8H49zzyZ2XvtPd9sq/l07bXX8hhjjAAAAKKQ1+0CAAAA2oogAwAAohZBBgAARC2CDAAAiFoEGQAAELUIMgAAIGoRZAAAQNQiyAAAgKhFkAEAAFGLIAMAAKKWq0HmiSee0NChQ5WSkqKUlBTl5ubqn//8p7W/qqpKeXl56ty5s5KSkjRp0iSVlZW5WDEAAGhPPG6utbR48WLFxMSoX79+Msbo6aef1qOPPqoNGzZo8ODBuuWWW/Tqq69q/vz5Sk1N1fTp0+X1evXOO++4VTIAAGhHXA0yLUlPT9ejjz6qa6+9Vl27dtWCBQt07bXXSpI++eQTDRw4UIWFhTr33HNdrhQAALgt1u0Cgurr6/XCCy+osrJSubm5KioqUm1trcaNG2e1GTBggLKzs48bZKqrq1VdXW19DgQC2rdvnzp37iyPxxPx3wMAAITPGKMDBw6oR48e8nqPPRLG9SDz4YcfKjc3V1VVVUpKStLLL7+sQYMGqbi4WD6fT2lpaSHtMzIyVFpaeszzFRQUaPbs2RGuGgAAOGHnzp3q2bPnMfe7HmT69++v4uJilZeX68UXX9SUKVO0atWqNp9v1qxZys/Ptz6Xl5crOztbO3fuVEpKih0lAwCACKuoqFBWVpaSk5OP2871IOPz+dS3b19J0ogRI/Tee+/pd7/7na677jrV1NRo//79Ib0yZWVlyszMPOb5/H6//H7/UduDT0YBAIDocaJhIe1uHplAIKDq6mqNGDFCcXFxWr58ubVvy5Yt2rFjh3Jzc12sEAAAtBeu9sjMmjVLEyZMUHZ2tg4cOKAFCxZo5cqVev3115WamqqpU6cqPz9f6enpSklJ0W233abc3FyeWAIAAJJcDjJ79uzRf/3Xf2n37t1KTU3V0KFD9frrr+uiiy6SJD322GPyer2aNGmSqqurNX78eP3xj390s2QAANCOtLt5ZOxWUVGh1NRUlZeXM0YGAIAo0dq/3+1ujAwAAEBrEWQAAEDUIsgAAICoRZABAABRiyADAACiFkEGAABELYIMAACIWgQZAAAQtVxfNDJaVVTVqvxQrZLjY5WW6HO7HAAATkn0yLTRrxZ/rO898qaeXbvD7VIAADhlEWTaKNEXI0mqqq13uRIAAE5dBJk2im8MModqCDIAALiFINNGiXENw4sO0yMDAIBrCDJtlOBruHSH6ZEBAMA1BJk2SvA19sgQZAAAcA1Bpo0S4hrHyHBrCQAA1xBk2sh6aokeGQAAXEOQaaOmHpk6lysBAODURZBpo4TGHhnGyAAA4B6CTBsFe2QIMgAAuIcg00bBMTLMIwMAgHsIMm0UH8fMvgAAuI0g00bBHpnquoACAeNyNQAAnJoIMm0UHOwrcXsJAAC3EGTaKD6WIAMAgNsIMm3k9XoUH8d6SwAAuIkgE4ZEHytgAwDgJoJMGBJ4cgkAAFcRZMLA7L4AALiLIBOGpknxWG8JAAA3EGTCEG8tUxBwuRIAAE5NBJkwBHtkDtXQIwMAgBsIMmGwFo7kqSUAAFxBkAkDg30BAHAXQSYMPH4NAIC7CDJhCI6RqeLWEgAAriDIhIEeGQAA3EWQCUMCSxQAAOAqgkwYElg0EgAAVxFkwsCikQAAuIsgE4Z4JsQDAMBVBJkwJFoT4rFEAQAAbiDIhKFpQjx6ZAAAcANBJgxWkGGMDAAAriDIhMFaa4mnlgAAcAVBJgyJrLUEAICrCDJhsGb2ra2XMcblagAAOPUQZMIQHCNjjFRdx5NLAAA4zdUgU1BQoFGjRik5OVndunXTVVddpS1btoS0GTt2rDweT8jr5ptvdqniUMEeGYnbSwAAuMHVILNq1Srl5eVpzZo1WrZsmWpra3XxxRersrIypN1NN92k3bt3W69HHnnEpYpDxcZ45YtpXKaAJ5cAAHBcrJtfvnTp0pDP8+fPV7du3VRUVKTzzz/f2p6YmKjMzEyny2uV+DivauoDrIANAIAL2tUYmfLycklSenp6yPZnn31WXbp00ZAhQzRr1iwdOnTomOeorq5WRUVFyCuSgustVdEjAwCA41ztkWkuEAhoxowZGj16tIYMGWJt/+EPf6hevXqpR48e2rhxo+6++25t2bJFCxcubPE8BQUFmj17tlNlWwN+6ZEBAMB57SbI5OXladOmTXr77bdDtk+bNs16f9ZZZ6l79+668MILtXXrVvXp0+eo88yaNUv5+fnW54qKCmVlZUWsbmtSPHpkAABwXLsIMtOnT9eSJUu0evVq9ezZ87htc3JyJEklJSUtBhm/3y+/3x+ROlvCeksAALjH1SBjjNFtt92ml19+WStXrlTv3r1PeExxcbEkqXv37hGurnUSWW8JAADXuBpk8vLytGDBAr3yyitKTk5WaWmpJCk1NVUJCQnaunWrFixYoEsvvVSdO3fWxo0bdeedd+r888/X0KFD3SzdEh/HGBkAANziapB54oknJDVMetfcvHnzdMMNN8jn8+mNN97QnDlzVFlZqaysLE2aNEn33nuvC9W2jPWWAABwj+u3lo4nKytLq1atcqiatmEFbAAA3NOu5pGJRgmMkQEAwDUEmTAlMEYGAADXEGTCFBwjw8y+AAA4jyATJp5aAgDAPQSZMAXXWmKMDAAAziPIhCnB13AJeWoJAADnEWTClBBHjwwAAG4hyIQpkdWvAQBwDUEmTAk8tQQAgGsIMmFqmkeG1a8BAHAaQSZMCdxaAgDANQSZMDEhHgAA7iHIhCl4a6m23qi2PuByNQAAnFoIMmEK3lqSeAQbAACnEWTC5IvxyutpeM+keAAAOIsgEyaPx9O0TAFBBgAARxFkbMDCkQAAuIMgY4Pgk0uMkQEAwFkEGRsEn1zi1hIAAM4iyNgggR4ZAABcQZCxAcsUAADgDoKMDZjdFwAAdxBkbBDPeksAALiCIGODxDjGyAAA4AaCjA2swb70yAAA4CiCjA0IMgAAuIMgYwPrqSVuLQEA4CiCjA2sp5bokQEAwFEEGRsksNYSAACuIMjYICG4+jW3lgAAcBRBxgastQQAgDsIMjZg9WsAANxBkLFBPGstAQDgCoKMDZrWWgq4XAkAAKcWgowNEnz0yAAA4AaCjA0SWGsJAABXEGRskNDs1lIgYFyuBgCAUwdBxgbBMTKSVFVHrwwAAE4hyNggPrYpyDC7LwAAziHI2MDr9Sg+ruFSMikeAADOIcjYhAG/AAA4jyBjk8Tgekv0yAAA4BiCjE2Ct5YYIwMAgHMIMjYJ9shUcWsJAADHEGRskmCtt0SQAQDAKQQZmySwAjYAAI4jyNgkOCneYdZbAgDAMQQZm3BrCQAA57kaZAoKCjRq1CglJyerW7duuuqqq7Rly5aQNlVVVcrLy1Pnzp2VlJSkSZMmqayszKWKj41bSwAAOM/VILNq1Srl5eVpzZo1WrZsmWpra3XxxRersrLSanPnnXdq8eLFeuGFF7Rq1Sp99dVXuuaaa1ysumXWhHj0yAAA4JhYN7986dKlIZ/nz5+vbt26qaioSOeff77Ky8v1f//3f1qwYIH+/d//XZI0b948DRw4UGvWrNG5557rRtktSqRHBgAAx7WrMTLl5eWSpPT0dElSUVGRamtrNW7cOKvNgAEDlJ2drcLCwhbPUV1drYqKipCXE+J9jJEBAMBp7SbIBAIBzZgxQ6NHj9aQIUMkSaWlpfL5fEpLSwtpm5GRodLS0hbPU1BQoNTUVOuVlZUV6dIlSYmstQQAgOPaTZDJy8vTpk2b9Pzzz4d1nlmzZqm8vNx67dy506YKj88a7EuPDAAAjnF1jEzQ9OnTtWTJEq1evVo9e/a0tmdmZqqmpkb79+8P6ZUpKytTZmZmi+fy+/3y+/2RLvkoCSwaCQCA41ztkTHGaPr06Xr55Ze1YsUK9e7dO2T/iBEjFBcXp+XLl1vbtmzZoh07dig3N9fpco/LmkeGW0sAADjG1R6ZvLw8LViwQK+88oqSk5OtcS+pqalKSEhQamqqpk6dqvz8fKWnpyslJUW33XabcnNz29UTS1LTU0tV9MgAAOAYV4PME088IUkaO3ZsyPZ58+bphhtukCQ99thj8nq9mjRpkqqrqzV+/Hj98Y9/dLjSE4u3emRYogAAAKe4GmSMMSdsEx8fr7lz52ru3LkOVNR2TWstBVyuBACAU0e7eWop2jXN7EuPDAAATiHI2KT5zL6t6WkCAADhI8jYJDizb8BIFVX0ygAA4ASCjE2S/bHq0/U0SdJLRbtcrgYAgFMDQcYmHo9HPx7dMA/OvHe3qz7A7SUAACKNIGOjSd/tqbTEOO3cd1jLPi5zuxwAADo8goyNEnwxmpyTLUl66u3tLlcDAEDHR5Cx2X/lnqG4GI/Wfb5PG3ftd7scAAA6NIKMzTJS4nXZ0B6SpP+jVwYAgIgiyETA1DENg35f3bhbu8sPu1wNAAAdF0EmAoacnqqc3umqCxg9/e4XbpcDAECHRZCJkGCvzHPrdugQyxYAABARBJkIuXBghnp1TlT54VotXP+l2+UAANAhEWQiJMbr0ZVnny5J+nBXucvVAADQMRFkIiglPlaSVFMfcLkSAAA6JoJMBPljGy5vdV29y5UAANAxEWQiyBcMMrX0yAAAEAkEmQjyx8ZI4tYSAACRQpCJID89MgAARBRBJoJ8jJEBACCiCDIRFLy1VF1HjwwAAJFAkIkgf1zD5a0hyAAAEBEEmQhqevyaIAMAQCQQZCKIMTIAAEQWQSaCGCMDAEBkEWQiiFtLAABEFkEmgoK3lmrqAjLGuFwNAAAdD0EmgoI9MhKz+wIAEAkEmQgKjpGRuL0EAEAkEGQiKC7GY71nmQIAAOxHkIkgj8fTbMAvj2ADAGA3gkyE+WOZ3RcAgEghyESYP465ZAAAiBSCTIT5YphLBgCASCHIRBgLRwIAEDkEmQhrWqaAwb4AANiNIBNh1sKRPH4NAIDtCDIRZj21xMy+AADYjiATYcwjAwBA5BBkIszPrSUAACKGIBNhTYN9CTIAANiNIBNhzOwLAEDkEGQizMcYGQAAIoYgE2FNg33pkQEAwG4EmQgLrrXErSUAAOxHkIkwemQAAIgcgkyENS0ayRgZAADsRpCJsOCikfTIAABgP1eDzOrVq3X55ZerR48e8ng8WrRoUcj+G264QR6PJ+R1ySWXuFNsGzGPDAAAkeNqkKmsrNSwYcM0d+7cY7a55JJLtHv3buv13HPPOVhh+Fg0EgCAyIlty0FPP/20unTpookTJ0qSZs6cqT//+c8aNGiQnnvuOfXq1atV55kwYYImTJhw3DZ+v1+ZmZltKbNdYK0lAAAip009Mg8++KASEhIkSYWFhZo7d64eeeQRdenSRXfeeaetBa5cuVLdunVT//79dcstt2jv3r3HbV9dXa2KioqQl5uCt5Z4/BoAAPu1qUdm586d6tu3ryRp0aJFmjRpkqZNm6bRo0dr7NixthV3ySWX6JprrlHv3r21detW3XPPPZowYYIKCwsVExPT4jEFBQWaPXu2bTWEy8fj1wAAREybemSSkpKsnpF//etfuuiiiyRJ8fHxOnz4sG3F/eAHP9AVV1yhs846S1dddZWWLFmi9957TytXrjzmMbNmzVJ5ebn12rlzp231tAXzyAAAEDlt6pG56KKLdOONN2r48OH69NNPdemll0qSPvroI51xxhl21hfizDPPVJcuXVRSUqILL7ywxTZ+v19+vz9iNZyspkUjGSMDAIDd2tQjM3fuXOXm5urrr7/WSy+9pM6dO0uSioqKdP3119taYHO7du3S3r171b1794h9h924tQQAQOS0qUcmLS1Njz/++FHbT3ZsysGDB1VSUmJ93r59u4qLi5Wenq709HTNnj1bkyZNUmZmprZu3aqZM2eqb9++Gj9+fFvKdgXzyAAAEDlt6pFZunSp3n77bevz3LlzdfbZZ+uHP/yhvv3221af5/3339fw4cM1fPhwSVJ+fr6GDx+u+++/XzExMdq4caOuuOIKfec739HUqVM1YsQIvfXWW+3q1tGJBGf25aklAADs16YembvuuksPP/ywJOnDDz/UT37yE+Xn5+vNN99Ufn6+5s2b16rzjB07VsaYY+5//fXX21Jeu8I8MgAARE6bgsz27ds1aNAgSdJLL72kyy67TA8++KDWr19vDfxFg+ZjZIwx8ng8LlcEAEDH0aZbSz6fT4cOHZIkvfHGG7r44oslSenp6a5PQNfeBMfIGCPV1h+79wkAAJy8NvXIjBkzRvn5+Ro9erTWrVunv/3tb5KkTz/9VD179rS1wGgXvLUkSTX1AauHBgAAhK9Nf1Uff/xxxcbG6sUXX9QTTzyh008/XZL0z3/+M+pWp440X0zTJa6uZZwMAAB2alOPTHZ2tpYsWXLU9sceeyzsgjoar9cjX4xXNfUBHsEGAMBmbQoyklRfX69FixZp8+bNkqTBgwfriiuuOOYaSKcyf2xDkOERbAAA7NWmIFNSUqJLL71UX375pfr37y+pYbHGrKwsvfrqq+rTp4+tRUY7X6xXqmZSPAAA7NamMTK33367+vTpo507d2r9+vVav369duzYod69e+v222+3u8aox1wyAABERpt6ZFatWqU1a9YoPT3d2ta5c2c99NBDGj16tG3FdRT+uIbbbdxaAgDAXm3qkfH7/Tpw4MBR2w8ePCifzxd2UR2Nn4UjAQCIiDYFmcsuu0zTpk3T2rVrZYyRMUZr1qzRzTffrCuuuMLuGqOej1tLAABERJuCzO9//3v16dNHubm5io+PV3x8vM477zz17dtXc+bMsbnE6Gf1yNTSIwMAgJ3aNEYmLS1Nr7zyikpKSqzHrwcOHKi+ffvaWlxHEVymoKaeIAMAgJ1aHWTy8/OPu//NN9+03v/2t79te0UdkI8eGQAAIqLVQWbDhg2tasfqzkfj8WsAACKj1UGmeY8LTg5PLQEAEBksxewAH0EGAICIIMg4IDjYlyADAIC9CDIOCN5aYmZfAADsRZBxABPiAQAQGQQZB3BrCQCAyCDIOMAfxzwyAABEAkHGAdYYGWb2BQDAVgQZBzTN7MsYGQAA7ESQcQBjZAAAiAyCjAN4/BoAgMggyDiAx68BAIgMgowDWGsJAIDIIMg4IDhGhltLAADYiyDjABaNBAAgMggyDvAzRgYAgIggyDggPo4eGQAAIoEg4wBfDGNkAACIBIKMA/z0yAAAEBEEGQcEx8jUB4zqWG8JAADbEGQcEHz8WmLhSAAA7ESQcUDw8WtJqq4lyAAAYBeCjANivB7Fej2SGCcDAICdCDIOYeFIAADsR5BxCAtHAgBgP4KMQ4IDfrm1BACAfQgyDmmaS4YeGQAA7EKQcYgvhknxAACwG0HGIczuCwCA/QgyDrHGyDCPDAAAtiHIOMR6/JqZfQEAsA1BxiHW49e1DPYFAMAuBBmH+GMZIwMAgN1cDTKrV6/W5Zdfrh49esjj8WjRokUh+40xuv/++9W9e3clJCRo3Lhx+uyzz9wpNkzBMTLM7AsAgH1cDTKVlZUaNmyY5s6d2+L+Rx55RL///e/1pz/9SWvXrtVpp52m8ePHq6qqyuFKw+ejRwYAANvFuvnlEyZM0IQJE1rcZ4zRnDlzdO+99+rKK6+UJP31r39VRkaGFi1apB/84AdOlho2P0sUAABgu3Y7Rmb79u0qLS3VuHHjrG2pqanKyclRYWHhMY+rrq5WRUVFyKs9YIkCAADs126DTGlpqSQpIyMjZHtGRoa1ryUFBQVKTU21XllZWRGts7V8rH4NAIDt2m2QaatZs2apvLzceu3cudPtkiRxawkAgEhot0EmMzNTklRWVhayvayszNrXEr/fr5SUlJBXe2AtUcDMvgAA2KbdBpnevXsrMzNTy5cvt7ZVVFRo7dq1ys3NdbGytgkuGsnMvgAA2MfVp5YOHjyokpIS6/P27dtVXFys9PR0ZWdna8aMGfr1r3+tfv36qXfv3rrvvvvUo0cPXXXVVe4V3Ub+ONZaAgDAbq4Gmffff18XXHCB9Tk/P1+SNGXKFM2fP18zZ85UZWWlpk2bpv3792vMmDFaunSp4uPj3Sq5zRgjAwCA/VwNMmPHjpUx5pj7PR6PfvnLX+qXv/ylg1VFBotGAgBgv3Y7RqajsXpkuLUEAIBtCDIOYUI8AADsR5BxCGNkAACwH0HGIczsCwCA/QgyDuHWEgAA9iPIOMSa2ZcgAwCAbQgyDrFm9iXIAABgG4KMQ5p6ZBjsCwCAXQgyDgmOkamtNwoEjj0JIAAAaD2CjEOCTy1JzO4LAIBdCDIO8TcLMszuCwCAPQgyDon1euT1NLxnnAwAAPYgyDjE4/EwlwwAADYjyDjIF8tcMgAA2Ikg4yDWWwIAwF4EGQcxuy8AAPYiyDiI2X0BALAXQcZBDPYFAMBeBBkHWbeWahkjAwCAHQgyDrJuLTGzLwAAtiDIOMgf13hriZl9AQCwBUHGQX7mkQEAwFYEGQcxjwwAAPYiyDgoOLMvj18DAGAPgoyDePwaAAB7EWQcxK0lAADsRZBxkJ9bSwAA2Iog4yCeWgIAwF4EGQcxjwwAAPYiyDiImX0BALAXQcZB1lpLDPYFAMAWBBkHWWNkuLUEAIAtCDIO8jHYFwAAWxFkHBScEI/HrwEAsAdBxkFMiAcAgL0IMg5iiQIAAOxFkHEQi0YCAGAvgoyDmNkXAAB7EWQcxDwyAADYiyDjoODMvvTIAABgD4KMg6y1lggyAADYgiDjIH+zwb7GGJerAQAg+hFkHBR8akmiVwYAADsQZBzkbxZkWAEbAIDwEWQcFBzsK7FwJAAAdiDIOMjj8TRbOJJHsAEACBdBxmHxjUGmqpYgAwBAuNp1kPnFL34hj8cT8howYIDbZYUlIyVekrS7vMrlSgAAiH6xbhdwIoMHD9Ybb7xhfY6NbfclH9fpnRL02Z6D+vLbw26XAgBA1Gv3qSA2NlaZmZlul2Gb09MSJElf7ifIAAAQrnZ9a0mSPvvsM/Xo0UNnnnmmJk+erB07drhdUlhO79QYZOiRAQAgbO26RyYnJ0fz589X//79tXv3bs2ePVvf+973tGnTJiUnJ7d4THV1taqrq63PFRUVTpXbKsEemV30yAAAELZ2HWQmTJhgvR86dKhycnLUq1cv/f3vf9fUqVNbPKagoECzZ892qsST1pMeGQAAbNPuby01l5aWpu985zsqKSk5ZptZs2apvLzceu3cudPBCk+sZ6dESVJpRZXqmN0XAICwRFWQOXjwoLZu3aru3bsfs43f71dKSkrIqz3pmuSXL8ar+oBRaQWPYAMAEI52HWT+53/+R6tWrdLnn3+ud999V1dffbViYmJ0/fXXu11am3m9HnVPa5hLhttLAACEp12Pkdm1a5euv/567d27V127dtWYMWO0Zs0ade3a1e3SwnJ6WoK+2HuIR7ABAAhTuw4yzz//vNslRIT15BI9MgAAhKVd31rqqIIDfrm1BABAeAgyLrAmxePWEgAAYSHIuIBlCgAAsAdBxgU9m/XIBALG5WoAAIheBBkXZKbGy+uRauoC+uZg9YkPAAAALSLIuCAuxquMlIa5ZFhzCQCAtiPIuIQ1lwAACB9BxiUM+AUAIHwEGZecTo8MAABhI8i45PS0xknx6JEBAKDNCDIuCfbI7Pr2kMuVAAAQvQgyLmk+2NcY5pIBAKAtCDIuCQ72raypV/nhWperAQAgOhFkXBIfF6MuST5JrIINAEBbEWRcxCPYAACEhyDjoqYBvwQZAADagiDjIqtHhiADAECbEGRc1LNTcC4ZHsEGAKAtCDIuYowMAADhIci4iGUKAAAID0HGRcEg8+2hWlVW17lcDQAA0Ycg46KU+Dglx8dK4vYSAABtQZBxGU8uAQDQdgQZlwWfXNpFjwwAACeNIOOyngz4BQCgzQgyLgveWirZc9DlSgAAiD4EGZeNPKOTJOmNzWV6t+Qbl6sBACC6EGRcNjy7k36Yky1JuuvFjTrIY9gAALQaQaYduOfSgerZKUFf7j+sB17d7HY5AABEDYJMO5Dkj9Wj1w6TJD23bodWf/q1yxUBABAdCDLtRG6fzrrhvDMkSXe/tFHlh2vdLQgAgChAkGlHZl7SX2d0TtTu8ir9asnHbpcDAEC7R5BpRxJ9sfrf/xgmj0d6sWiXHln6iQIB43ZZAAC0WwSZdmbkGem6a3x/SdIfV27V/3umiAUlAQA4BoJMO3Tr2L567Lph8sV6tezjMk164l3t+vaQ22UBANDuEGTaqauH99Tz085VlyS/Pik9oCsff4cJ8wAAOAJBph37bnYn/WP6aA3qnqK9lTX64V/WKm/Ben3JApMAAEgiyLR7PdIS9OItuZqcky2vR3p1425d+JuVmvPGpzpcU+92eQAAuMpjjOnQj8VUVFQoNTVV5eXlSklJcbucsHz0VblmL/5Y67bvkyT1SI3X1O+dqe+P7Knk+DiXqwMAwD6t/ftNkIkyxhi99mGpHnxts3WLKckfq++PzNKPR5+hrPRElysEACB8BJlGHS3IBFXV1uul9bv01NvbtfXrSkmS1yP923e66vJhPXTRoAx6aQAAUYsg06ijBpmgQMBo9Wdf6//e3q63Pmt6qskX69UF/bvqsqE9dH6/rkpNJNQAAKIHQaZRRw8yzZXsOah/fPCVlmz8Stsae2mkhp6as05P1ei+XTSmbxd9t1cnxcfFuFgpAADHR5BpdCoFmSBjjDbvPqAlG7/S6x+VWreegmK9Hg3onqyhPdN0ds80Dc1KVZ+uSYqL4SE2AED7QJBpdCoGmSOVllfpnZJv9E7JN3q75BvtOVB9VJtYr0e9u5ym72Qkq19Gkvp0TVKvzonqlX4at6UAAI4jyDQiyIQyxmjXt4e1cVe5Pti1Xx/s3K9NX5ar8jhz0qQmxCk7PVGnpyWoe1q8uqfGq3tqgrqnxqtbcry6JvuV4ONWFQDAPgSZRgSZEwsEjL4qP6zP9hzUZ2UH9GnZQW3/plJf7D2kbw4e3XvTkmR/rLom+5V+mk/pp/nUOcnX+N6vtIQ4pSU2vFITfEpNiFNKQqz8sYQfAEDLCDKNCDLhOVRTpx37DmnH3kP6av9h7a6o0u79VSotr9LuisP6+kC1qmoDbTp3fJxXKfFxSo6PVXLjzyR/w+u0xp+J/piGn75YJfpiGl8N7xN8MUqIa9gWHxcjf6xXHo/H5isAAHBDa/9+xzpYU5vNnTtXjz76qEpLSzVs2DD94Q9/0DnnnON2WaeERF+sBmSmaEBmy/8jMsboYHWd9hyo1p6Kau2rrNG+ymrtrazRt5U12ltZo/LDtSo/XKv9h2r17aEaHaiqkyRV1QZUVVvd4pidtvB6pPi4hlATH+ttCDdxMYqP88of/BzrlT+28Wdcw3tfrFe+GK98sQ3tmn+Oa/wZ3BYX41VcjMfa3vxzXIxXsTEexXkbtsV4PQQrAIiwdh9k/va3vyk/P19/+tOflJOTozlz5mj8+PHasmWLunXr5nZ5pzyPx9PYmxKnPl2TWnVMfaAh/FQcrlVFVa0qDtepsrpOB6vrdKC6TgeqalVZXafK6nodrK7ToZo6Hayu1+GaOh2qqW98Nbyvqq1XbX1Dp2LAyNrfXsTFeBTrbQg4sV6PYmO8imv82fC5aX+MtyEExVjbPYrxNrSLsT57FONp2O/1NGzzepvaxnjV8LNZmxivrLYxje1jPE0/m28LtvU22+71yGrvbaGNxyOrLk/wOE9jm2bvPcHzNL48jeeJadzn8TSd1+sRIRBAq7T7W0s5OTkaNWqUHn/8cUlSIBBQVlaWbrvtNv30pz894fHcWur4ausDqqqt1+Ga+oZenrrg+3pV1QVUXVuv6rqAqusa2jW8r1dNs201dYGGV33Dz9r6hn219U3b6+qNtb+mLqC6gFFtfaDxZVQfaNf/KkUlb7Nw0xR0moJRMFwFg4/XI3nU9Ln5McHPHoWe0zoueF61cKwaDgy+9zSrwdN4jLfZ+yO/KxjUmu/3Nu4PblPIuZveNz+Xp/l2NYU975FtWjhnS8fLqqfxd5Savt/T9DnkmCO2Sc1/r8bPR1wDHbU/tKbgNh15vPX7hB4X5DlG/c3rVIvbPaG/y3FqaDrDsb9Hx/z+pm1HnudEdYUed+Tv3ey9jviOI/aF/jNpVvBR33FEzceo48jvCH5OS/QpyW9v30iHuLVUU1OjoqIizZo1y9rm9Xo1btw4FRYWulgZ2pPgbR23l2QIBIxqAw2BJxhu6pp9DgafunqjuoBRXbNtAWNU1xiGagNG9Y3H1Qea2tYbNWwPGNXXG9Wbpv2Bxp/1wZdpahNo/BxsVx8wCphgO1nbmrcNNNsebBto3B78DhNsZ5q3afhsGtsF3wdMw3lP9v82Bc8nERKB9uzBq8/SD3OyXfnudh1kvvnmG9XX1ysjIyNke0ZGhj755JMWj6murlZ1ddOYi4qKiojWCAR5vR75vTGy+f+UdCimWbBpHoKsABRQY+Bp2Bb8GdxmhaKAkZGatVPjtoY2xoSeR2oKYcbIahcMWkaNganZtkCzGhq+q3Ffs9/DyCgQCD2+6dxqVk/DcYFA07mOPE/TttDjgr9f8zYyJqRt8zY66tyhx1v/HI78rsbPanYNj97Xwnc0+32an7v5tbBqC/ndm31X43GNhzX7rmbbm31/8JzNPwfb6xjbrbqa13vUtmY1Nj9nszrUrP2xvufoWo7YfoLvDP2elmsMraH5sUder9D6j/z+FveZYx/XvMbmtbg5n2qH+09uQUGBZs+e7XYZAFpg3bKR58SNAaAV2vWc9F26dFFMTIzKyspCtpeVlSkzM7PFY2bNmqXy8nLrtXPnTidKBQAALmjXQcbn82nEiBFavny5tS0QCGj58uXKzc1t8Ri/36+UlJSQFwAA6Jja/a2l/Px8TZkyRSNHjtQ555yjOXPmqLKyUj/+8Y/dLg0AALis3QeZ6667Tl9//bXuv/9+lZaW6uyzz9bSpUuPGgAMAABOPe1+HplwMY8MAADRp7V/v9v1GBkAAIDjIcgAAICoRZABAABRiyADAACiFkEGAABELYIMAACIWgQZAAAQtQgyAAAgahFkAABA1Gr3SxSEKzhxcUVFhcuVAACA1gr+3T7RAgQdPsgcOHBAkpSVleVyJQAA4GQdOHBAqampx9zf4ddaCgQC+uqrr5ScnCyPx2PbeSsqKpSVlaWdO3eyhpMDuN7O4Vo7h2vtHK61c+y61sYYHThwQD169JDXe+yRMB2+R8br9apnz54RO39KSgr/UjiI6+0crrVzuNbO4Vo7x45rfbyemCAG+wIAgKhFkAEAAFGLINNGfr9fP//5z+X3+90u5ZTA9XYO19o5XGvncK2d4/S17vCDfQEAQMdFjwwAAIhaBBkAABC1CDIAACBqEWQAAEDUIsi00dy5c3XGGWcoPj5eOTk5WrdundslRb2CggKNGjVKycnJ6tatm6666ipt2bIlpE1VVZXy8vLUuXNnJSUladKkSSorK3Op4o7joYceksfj0YwZM6xtXGv7fPnll/rP//xPde7cWQkJCTrrrLP0/vvvW/uNMbr//vvVvXt3JSQkaNy4cfrss89crDg61dfX67777lPv3r2VkJCgPn366Fe/+lXIWj1c67ZZvXq1Lr/8cvXo0UMej0eLFi0K2d+a67pv3z5NnjxZKSkpSktL09SpU3Xw4MHwizM4ac8//7zx+XzmqaeeMh999JG56aabTFpamikrK3O7tKg2fvx4M2/ePLNp0yZTXFxsLr30UpOdnW0OHjxotbn55ptNVlaWWb58uXn//ffNueeea8477zwXq45+69atM2eccYYZOnSoueOOO6ztXGt77Nu3z/Tq1cvccMMNZu3atWbbtm3m9ddfNyUlJVabhx56yKSmpppFixaZDz74wFxxxRWmd+/e5vDhwy5WHn0eeOAB07lzZ7NkyRKzfft288ILL5ikpCTzu9/9zmrDtW6b1157zfzsZz8zCxcuNJLMyy+/HLK/Ndf1kksuMcOGDTNr1qwxb731lunbt6+5/vrrw66NINMG55xzjsnLy7M+19fXmx49epiCggIXq+p49uzZYySZVatWGWOM2b9/v4mLizMvvPCC1Wbz5s1GkiksLHSrzKh24MAB069fP7Ns2TLzb//2b1aQ4Vrb5+677zZjxow55v5AIGAyMzPNo48+am3bv3+/8fv95rnnnnOixA5j4sSJ5r//+79Dtl1zzTVm8uTJxhiutV2ODDKtua4ff/yxkWTee+89q80///lP4/F4zJdffhlWPdxaOkk1NTUqKirSuHHjrG1er1fjxo1TYWGhi5V1POXl5ZKk9PR0SVJRUZFqa2tDrv2AAQOUnZ3NtW+jvLw8TZw4MeSaSlxrO/3jH//QyJEj9R//8R/q1q2bhg8frieffNLav337dpWWloZc69TUVOXk5HCtT9J5552n5cuX69NPP5UkffDBB3r77bc1YcIESVzrSGnNdS0sLFRaWppGjhxptRk3bpy8Xq/Wrl0b1vd3+EUj7fbNN9+ovr5eGRkZIdszMjL0ySefuFRVxxMIBDRjxgyNHj1aQ4YMkSSVlpbK5/MpLS0tpG1GRoZKS0tdqDK6Pf/881q/fr3ee++9o/Zxre2zbds2PfHEE8rPz9c999yj9957T7fffrt8Pp+mTJliXc+W/pvCtT45P/3pT1VRUaEBAwYoJiZG9fX1euCBBzR58mRJ4lpHSGuua2lpqbp16xayPzY2Vunp6WFfe4IM2qW8vDxt2rRJb7/9ttuldEg7d+7UHXfcoWXLlik+Pt7tcjq0QCCgkSNH6sEHH5QkDR8+XJs2bdKf/vQnTZkyxeXqOpa///3vevbZZ7VgwQINHjxYxcXFmjFjhnr06MG17sC4tXSSunTpopiYmKOe3igrK1NmZqZLVXUs06dP15IlS/Tmm2+qZ8+e1vbMzEzV1NRo//79Ie259ievqKhIe/bs0Xe/+13FxsYqNjZWq1at0u9//3vFxsYqIyODa22T7t27a9CgQSHbBg4cqB07dkiSdT35b0r47rrrLv30pz/VD37wA5111ln60Y9+pDvvvFMFBQWSuNaR0prrmpmZqT179oTsr6ur0759+8K+9gSZk+Tz+TRixAgtX77c2hYIBLR8+XLl5ua6WFn0M8Zo+vTpevnll7VixQr17t07ZP+IESMUFxcXcu23bNmiHTt2cO1P0oUXXqgPP/xQxcXF1mvkyJGaPHmy9Z5rbY/Ro0cfNY3Ap59+ql69ekmSevfurczMzJBrXVFRobVr13KtT9KhQ4fk9Yb+WYuJiVEgEJDEtY6U1lzX3Nxc7d+/X0VFRVabFStWKBAIKCcnJ7wCwhoqfIp6/vnnjd/vN/Pnzzcff/yxmTZtmklLSzOlpaVulxbVbrnlFpOammpWrlxpdu/ebb0OHTpktbn55ptNdna2WbFihXn//fdNbm6uyc3NdbHqjqP5U0vGcK3tsm7dOhMbG2seeOAB89lnn5lnn33WJCYmmmeeecZq89BDD5m0tDTzyiuvmI0bN5orr7ySR4LbYMqUKeb000+3Hr9euHCh6dKli5k5c6bVhmvdNgcOHDAbNmwwGzZsMJLMb3/7W7NhwwbzxRdfGGNad10vueQSM3z4cLN27Vrz9ttvm379+vH4tZv+8Ic/mOzsbOPz+cw555xj1qxZ43ZJUU9Si6958+ZZbQ4fPmxuvfVW06lTJ5OYmGiuvvpqs3v3bveK7kCODDJca/ssXrzYDBkyxPj9fjNgwADz5z//OWR/IBAw9913n8nIyDB+v99ceOGFZsuWLS5VG70qKirMHXfcYbKzs018fLw588wzzc9+9jNTXV1tteFat82bb77Z4n+fp0yZYoxp3XXdu3evuf76601SUpJJSUkxP/7xj82BAwfCrs1jTLMpDwEAAKIIY2QAAEDUIsgAAICoRZABAABRiyADAACiFkEGAABELYIMAACIWgQZAAAQtQgyANq9zz//XB6PR8XFxW6XAqCdIcgAp5Cvv/5aPp9PlZWVqq2t1WmnnWYtXniquuCCC/SXv/ylxX0LFy7UxRdfrM6dOx8zSFVVVSkvL0+dO3dWUlKSJk2adNTieTt27NDEiROVmJiobt266a677lJdXV1Im5UrV+q73/2u/H6/+vbtq/nz59v1KwIdGkEGOIUUFhZq2LBhOu2007R+/Xqlp6crOzvb7bJcs2/fPr3zzju6/PLLW9xfWVmpMWPG6OGHHz7mOe68804tXrxYL7zwglatWqWvvvpK11xzjbW/vr5eEydOVE1Njd599109/fTTmj9/vu6//36rzfbt2zVx4kRdcMEFKi4u1owZM3TjjTfq9ddft++XBTqqsBc5ABA17r77bms9pf/93/811113XauOe/LJJ82AAQOM3+83/fv3N3PnzrX2bd++3Ugyzz33nMnNzTV+v98MHjzYrFy5MuQcK1euNKNGjTI+n89kZmaau+++29TW1lr76+vrzcMPP2z69OljfD6fycrKMr/+9a9DvuOll14yY8eONQkJCWbo0KHm3XfftY7//PPPzWWXXWbS0tJMYmKiGTRokHn11VeP+3v99a9/NTk5OSf8/YPfv2HDhpDt+/fvN3FxceaFF16wtm3evNlIMoWFhcYYY1577TXj9XpDFpV94oknTEpKirUG0MyZM83gwYNDzn3dddeZ8ePHn7A24FRHkAE6uC+++MKkpqaa1NRUExcXZ+Lj401qaqrx+XzG7/eb1NRUc8sttxzz+GeeecZ0797dvPTSS2bbtm3mpZdeMunp6Wb+/PnGmKY/8j179jQvvvii+fjjj82NN95okpOTzTfffGOMMWbXrl0mMTHR3HrrrWbz5s3m5ZdfNl26dDE///nPre+ZOXOm6dSpk5k/f74pKSkxb731lnnyySdDvmPAgAFmyZIlZsuWLebaa681vXr1ssLQxIkTzUUXXWQ2btxotm7dahYvXmxWrVp13Gtz7bXXmgcffPCE1/BYQWb58uVGkvn2229DtmdnZ5vf/va3xhhj7rvvPjNs2LCQ/du2bTOSzPr1640xxnzve98LWbDTGGOeeuopk5KScsLagFMdQQbo4Gpra8327dvNBx98YOLi4swHH3xgSkpKTFJSklm1apXZvn27+frrr495fJ8+fcyCBQtCtv3qV78yubm5xpimP/IPPfRQyHf27NnTPPzww8YYY+655x7Tv39/EwgErDZz5841SUlJpr6+3lRUVBi/328FlyMFv+Mvf/mLte2jjz4ykszmzZuNMcacddZZ5he/+EWrr0tVVZVJSkoymzZtOmHbYwWZZ5991vh8vqPajxo1ysycOdMYY8xNN91kLr744pD9lZWVRpJ57bXXjDHG9OvX76hA9eqrrxpJ5tChQ63+nYBTUawLd7MAOCg2NlZnnHGG/v73v2vUqFEaOnSo3nnnHWVkZOj8888/7rGVlZXaunWrpk6dqptuusnaXldXp9TU1JC2ubm5Id85cuRIbd68WZK0efNm5ebmyuPxWG1Gjx6tgwcPateuXSotLVV1dbUuvPDC49YzdOhQ63337t0lSXv27NGAAQN0++2365ZbbtG//vUvjRs3TpMmTQppf6QVK1aoW7duGjx48HG/E0D7RpABOrjBgwfriy++UG1trQKBgJKSklRXV6e6ujolJSWpV69e+uijj1o89uDBg5KkJ598Ujk5OSH7YmJibKsxISGhVe3i4uKs98FQFAgEJEk33nijxo8fr1dffVX/+te/VFBQoN/85je67bbbWjzXP/7xD11xxRVh1Z2Zmamamhrt379faWlp1vaysjJlZmZabdatWxdyXPCppuZtjnzSqaysTCkpKa2+NsCpiqeWgA7utddeU3FxsTIzM/XMM8+ouLhYQ4YM0Zw5c1RcXKzXXnvtmMdmZGSoR48e2rZtm/r27Rvy6t27d0jbNWvWWO/r6upUVFSkgQMHSpIGDhyowsJCGWOsNu+8846Sk5PVs2dP9evXTwkJCVq+fHlYv2tWVpZuvvlmLVy4UD/5yU/05JNPttjOGKPFixfryiuvDOv7RowYobi4uJC6t2zZoh07dlg9VLm5ufrwww+1Z88eq82yZcuUkpKiQYMGWW2O/N2XLVsW0ssF4BjcvrcFIPJ2795t/H6/OXz4sKmqqjLx8fHmq6++atWxTz75pElISDC/+93vzJYtW8zGjRvNU089ZX7zm98YY5rGj2RnZ5uFCxeazZs3m2nTppmkpCRr7E1wsG9eXp7ZvHmzWbRo0VGDfX/xi1+YTp06maefftqUlJSYwsJCa0xMS2NUvv32WyPJvPnmm8YYY+644w6zdOlSs23bNlNUVGRycnLM97///RZ/p/fee8906tQp5Kmpluzdu9ds2LDBGq/y/PPPmw0bNpjdu3dbbW6++WaTnZ1tVqxYYd5//32Tm5trjR8yxpi6ujozZMgQc/HFF5vi4mKzdOlS07VrVzNr1iyrzbZt20xiYqK56667zObNm83cuXNNTEyMWbp06Yn/AQGnOIIMcAp47rnnzJgxY4wxxqxevdr07dv3pI5/9tlnzdlnn218Pp/p1KmTOf/8883ChQuNMU0hY8GCBeacc84xPp/PDBo0yKxYsSLkHK15/PrXv/616dWrl4mLizPZ2dnWANjWBJnp06ebPn36GL/fb7p27Wp+9KMfWU9NHenee+81kydPPuHvPW/ePCPpqFfzAHb48GFz6623mk6dOpnExERz9dVXhwQdYxoeDZ8wYYJJSEgwXbp0MT/5yU+OClFvvvmmdY3PPPNMM2/evBPWB8AYjzHN+noB4CR9/vnn6t27tzZs2KCzzz7b7XJaZejQobr33nv1/e9/3+1SAISJMTIATik1NTWaNGmSJkyY4HYpAGzAU0sATik+n08///nP3S4DgE24tQQAAKIWt5YAAEDUIsgAAICoRZABAABRiyADAACiFkEGAABELYIMAACIWgQZAAAQtQgyAAAgahFkAABA1Pr/iW1CZz5WG5EAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "plt.plot(nn.loss_history)\n",
+    "plt.xlabel(\"# epochs / 1000\")\n",
+    "plt.ylabel(\"loss\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.colorbar.Colorbar at 0x12fe75c30>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 900x700 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib.colors import ListedColormap\n",
+    "\n",
+    "cm = plt.cm.RdBu\n",
+    "cm_bright = ListedColormap([\"#FF0000\", \"#0000FF\"])\n",
+    "\n",
+    "xv = np.linspace(x_min, x_max, 10)\n",
+    "yv = np.linspace(y_min, y_max, 10)\n",
+    "Xv, Yv = np.meshgrid(xv, yv)\n",
+    "XYpairs = np.vstack([ Xv.reshape(-1), Yv.reshape(-1)])\n",
+    "zv = nn.predict(XYpairs.T)\n",
+    "Zv = zv.reshape(Xv.shape)\n",
+    "\n",
+    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(9, 7))\n",
+    "ax.set_aspect(1)\n",
+    "cn = ax.contourf(Xv, Yv, Zv, cmap=\"coolwarm_r\", alpha=0.4)\n",
+    "\n",
+    "ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright, edgecolors=\"k\")\n",
+    "\n",
+    "# Plot the testing points\n",
+    "ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.4, edgecolors=\"k\")\n",
+    "\n",
+    "ax.set_xlim(x_min, x_max)\n",
+    "ax.set_ylim(y_min, y_max)\n",
+    "# ax.set_xticks(())\n",
+    "# ax.set_yticks(())\n",
+    "\n",
+    "fig.colorbar(cn)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "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.10.9"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "b0fa6594d8f4cbf19f97940f81e996739fb7646882a419484c72d19e05852a7e"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/notebooks/simple_neural_network_exercise_solution.ipynb b/notebooks/03_ml_basics_simple_neural_network_exercise_solution.ipynb
similarity index 100%
rename from notebooks/simple_neural_network_exercise_solution.ipynb
rename to notebooks/03_ml_basics_simple_neural_network_exercise_solution.ipynb