02_Multi_Layer_Perceptron.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"center\">\n",
    "<a href=\"https://vbti.nl\"><img src=\"https://docs.google.com/uc?export=download&id=1DdCGllL51O5wBuiI0rwygofKx3YIDPHX\" width=\"400\"></a>\n",
    "</div>\n",
    "\n",
    "\n",
    "\n",
    "# Multi-Layer Perceptron\n",
    "The invention of the **Multi-Layer Perceptron (MLP)** and its update rule (**backpropagation**) are the most important breakthroughs in artificial neural networks from the 80ties and 90ties. As you learned from the previous chapter, a perceptron's primary limitation is that it can only divide a data space linearly. An MLP consists of layers of individual perceptrons. Therefore, MLP can approximate any continuous nonlinear function.\n",
    "\n",
    "## Learning objectives\n",
    "This chapter discusses the fundamentals of MLPs.\n",
    "\n",
    "- Understand the mathematical model of an MLP.\n",
    "- Understand the backpropagation training rule.\n",
    "- Train an MLP on a given dataset (XOR Problem & Circle Problem) and evaluate its performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File: default_setup.py already exists. Skipping download...\n",
      "Loaded numpy 1.19.2 as np.\n",
      "Loaded pandas 1.1.3 as pd\n",
      "Loaded matplotlib.pyplot 3.3.2 as plt\n",
      "Loaded seaborn 0.11.0 as sns\n",
      "Loaded tensorflow as tf 2.1.0.\n",
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "def download_file(url, path):\n",
    "    import os\n",
    "    import requests\n",
    "\n",
    "    if os.path.exists(path):\n",
    "        print('File', path, 'already exists. Skipping download...')\n",
    "        return\n",
    "    \n",
    "    r = requests.get(url, allow_redirects=True)\n",
    "    open(path, 'wb').write(r.content)\n",
    "    print('Downloaded:', path, 'from', url)\n",
    "\n",
    "download_file(\"https://raw.githubusercontent.com/illyakaynov/masterclass-ann-jads-12-feb/master/default_setup.py\",\n",
    "              \"default_setup.py\")\n",
    "download_file(\"https://raw.githubusercontent.com/illyakaynov/masterclass-ann-jads-12-feb/master/support.py\",\n",
    "              \"support.py\")\n",
    "\n",
    "%run default_setup.py\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline\n",
    "\n",
    "np.random.seed(2020)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multi-Layer Perceptron\n",
    "\n",
    "In the previous chapter, you learned about the perceptron. The perceptron is capable of linearly separating data into two classes. However, not all datasets can be linearly separated. We have seen examples of this: the XOR dataset and the circular datasets cannot be solved by a single line. The perceptron can handle these datasets using *feature engineering*, i.e., by adding extra inputs. For the XOR dataset the feature $ x_1 \\cdot x_2 $ turned out to work well, and for the circular dataset the feature $ x_1 ^ 2 + x_2 ^ 2 $ was very useful. Feature engineering is a powerful machine learning technique. Still, it is error-prone, and most of the time requires domain knowledge. If we could learn these features, we would have a much more powerful machine learning model. This appears to be possible by combining several perceptrons in one model. This idea is also inspired by the functioning and structure of the brain. If we look in detail at the brain tissue, it appears that it is made up of layers of neurons.\n",
    "\n",
    "<div align=\"center\">\n",
    "<img src=\"https://drive.google.com/uc?id=1HwhcrIs6iKGd06u5Sa5CgfvWNvUJWQwd\" width=\"800\">\n",
    "</div>\n",
    "\n",
    "## Function approximation\n",
    "\n",
    "One of the early theoretical results of the Multi-Layer Perceptron is that such a network can approximate any function. In other words, an MLP with a single layer is a *universal function approximator*. It was previously thought that single layer MLP is capable of addressing any machine learning problem. Although theoretically, this might be true, a single layer might not be the most efficient way of learning complex functions. Most of the time, accuracy can be improved by adding more layers. By sequentially feeding the output of one layer as input into the other, MLP can learn its own complex features. Moreover, deeper networks have more *capacity*, i.e., it can store more information. Therefore *Deep Neural Networks* can approximate more complex functions at the expense of higher training time.\n",
    "\n",
    "An interpretation of an MLP is that each layer learns a particular set of features. The first layers learn simple features, while the layers further learn more complex features by combining these simple features.\n",
    "\n",
    "## Layers\n",
    "\n",
    "A layer consists of 1 or more perceptrons, usually called *neurons*. All neurons in a specific layer receive as inputs the outputs of the previous layer. To make the notation easier, we can use matrix multiplications. First, we express a *forward path*, i.e., getting output from the network given input. Second, we define a *backward path*, where we will perform gradient descent to optimize against a loss function.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Forward Path\n",
    "Lets have a look at how we can define a forward path for one layer. Since now we several perceptrons working together we can define them in a matrix $W_i$. Each row in this matrix can be thought of as one perceptron. We take an input $X$ multiply it by the weight matrix of the first layer $W_1$, add bias $b_1$ and apply non-linear activation function $f_1$. \n",
    "\n",
    "$$y_0 = f_1(X \\cdot W_1 + b_1)$$\n",
    "\n",
    "Then output of the first layer is fed into the next one. We can define a general rule in the following manner.\n",
    "\n",
    "$$z_i = y_{i-1} \\cdot W_i + b_i$$\n",
    "$$y_i = f_i(z_i)$$\n",
    "\n",
    "In the Python code it is going to look like following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "def layer_forward_path(y_prev, W, b, act_f):\n",
    "    z = np.dot(y_prev, W) + b  \n",
    "    return act_f(z), z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Backwards path\n",
    "In order to update the weights of the network we use *backpropagation*. Here we are working backwards by taking the derivative of the output of the last layer with respect to the weights of the current layer.\n",
    "\n",
    "\n",
    "Compute gradients with respect to activation function:\n",
    "$$dz_{i-1} = dz_i \\cdot f_i^{\\prime}(z_i)$$\n",
    "\n",
    "\n",
    "Compute gradients with respect to weights and biases:\n",
    "$$dW_i = \\frac{\\partial L}{\\partial W_i}= y_{i-1}^T \\cdot dz_i$$\n",
    "$$\n",
    "db_i = \\frac{\\partial L}{\\partial b_i} = dz_i\n",
    "$$\n",
    "\n",
    "\n",
    "Pass gradient further:\n",
    "$$\n",
    "dy_{i-1} = \\frac{\\partial L}{\\partial y_{i-1}} = dz_i \\cdot W_i^T\n",
    "$$\n",
    "\n",
    "\n",
    "Update weights and biases\n",
    "$$W_i = W_i + \\eta \\cdot \\frac{\\partial L}{\\partial W_i} =  W_i + \\eta \\cdot dW_i$$\n",
    "\n",
    "$$b_i = b_i + \\eta \\cdot \\frac{\\partial L}{\\partial b_i} = b_i + \\eta \\cdot db_i$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "def backward_path(layer_input, layer_z, prev_layer_grad, W, b, grad_act_f, lr):\n",
    "    # Compute gradients with respect to activation function\n",
    "    grad_z = prev_layer_grad * grad_act_f(layer_z)\n",
    "    \n",
    "    #Compute gradients with respect to weights and biases\n",
    "    grad_weights = np.dot(layer_input.T, grad_z)\n",
    "    grad_biases = grad_z.mean(axis=0)\n",
    "    \n",
    "    # Pass gradient further\n",
    "    grad_y = np.dot(grad_z, W.T)\n",
    "    \n",
    "    # Update weights\n",
    "    W = W - lr * grad_weights\n",
    "    b = b - lr * grad_biases\n",
    "\n",
    "    return grad_y, grad_z, W, b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Activation function\n",
    "\n",
    "The output of every layer is processed by the activation function. Without an activation function, MLP would only be capable of performing linear transformations. By using non-linear activation functions, we broaden the horizons of problems that can be solved with MLP. The activation function needs to be continuous and differentiable to be suitable for *gradient descent* optimization.\n",
    "\n",
    "Many different activation functions have been developed over time. One of the most used are logistic function or ***sigmoid*** and hyperbolic tangent ***tanh***."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we need to define the loss and activation functions.\n",
    "\n",
    "##### Sigmoid:\n",
    "$$\\sigma(x) = \\frac{1}{1 + e^{-x}}$$\n",
    "\n",
    " $$ \\frac{\\partial}{\\partial x}\\sigma(x) = \\sigma(x) \\cdot (1 - \\sigma(x))$$\n",
    "\n",
    "##### Hyperbolic Tangent: $$tanh(x) = \\frac{e^x - e^{-x}}{e^x + e^{-x}}$$\n",
    "$$\\frac{\\partial}{\\partial x} tanh(x) =  1 - tanh^2(x)$$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(z):\n",
    "    return 1 / (1 + np.exp(-z))\n",
    "\n",
    "def grad_sigmoid(z):\n",
    "    return sigmoid(z) * (1 - sigmoid(z))\n",
    "\n",
    "def tanh(z):\n",
    "    return (np.exp(z) - np.exp(-z)) / (np.exp(z) + np.exp(-z))\n",
    "    \n",
    "def grad_tanh(z):\n",
    "    return (1 - tanh(z)**2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZQAAADDCAYAAAClOedbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAvG0lEQVR4nO3deViU5dcH8O8Aw74qLokamoIooohGKlIuablLqbm+alpaVtpiltQvLdPMsrQ0y6XUzN3U1ErNBTNzN0xcUULcQPYdZs77x3FYZIeZeWbgfK7ruWZlngPMPWfuXUVEBCGEEKKKLJQOQAghRPUgCUUIIYReSEIRQgihF5JQhBBC6IUkFCGEEHohCUVB69evx44dO5QOQ4hqY8eOHVi/fr3SYdRYklAUEhsbi3HjxmHkyJFITk4u8nhERAS6d++ONm3a4ODBg4iPj0f//v2RlZVV6useOnQIb7zxhqHCFsJkJScnY+TIkRg3bhzi4uKKPC5lyvAkoSgkNDQUmZmZSE1Nxccff1zk8UWLFsHT0xM7d+5EYGAgPvvsMwwfPhw2Njalvm5wcDDu3LmDo0ePGip0IUzS7NmzkZqaiszMTISGhhZ5XMqU4UlCUcDdu3exfPlyaLVaaLVafPHFF0hJSSn0nJSUFPj6+qJhw4ZISEjAb7/9hkGDBpXr9YcPH44lS5YYInQhTFJKSgq+/PLLvDK1bNky3L17t8hzpEwZlkpmyisjLCwMwcHBsLW1xd69e9G5c+e8x7p164aYmBgAgIeHB/r374/IyEgsXLgQADBq1CgcO3asyGv+8ccf8PDwQGpqKh577DFs374dTZs2Nc4vJITC/vzzT/To0QOZmZkICwtDUFBQ3mNSpozDSukAaqouXboAANRqdaFkAgCbNm3CSy+9BD8/P0ycOBHjx4/HkCFD8h5ftGgRcnJyAABarRYvvfQSPDw84OHhAQBwdHRE69atERYWJm9+UWN07twZarUamZmZhZIJIGXKWCShmKBatWpBrVbDzs4OLi4uuHDhAh555JG8x11dXfOuz58/HykpKUX6YZo1a4bw8HBjhSyESZMyZRySUExcYmIiNBoN3Nzcijy2d+9erF69GuvWrYOjo2Ohx1xdXfOq+EJUe/fuAZ9+il/S06EBgNdfB95+G6hXr8hTq0OZSk/nXzkxEUhKApKTgZQUIDWVH0tPBzIygMxMPrKzCx85OUBubv6h1QIaTf6h1eYfRIWvq1TA6dPFxyUJxcSpVCoAXA0vKCoqCtOnT8eMGTPg4+NT5Oc0Gg0sLGrGmIuMDCAujo/4eD4SEriwpaUBM2cqHaEwqLVrgUmTgORkBOvuW7AA+PZb4IsvgPHjCz3d1MtURgZw+TJw5QoQGQlcvw7ExAA3bwK3bwN373KSMEWSUEycm5sbrKyskJCQkHdfRkYGXnnlFXTt2rVQO3BBiYmJcHd3N1aYBpGeDvz3HxAdDdy4wcfNm8CtW/kF6+5dThqlkYRSja1bB4waxV+fe/bE4LAwpGZkYHe/fsCOHcCECfyV+vnn837ElMpURgZw/Dhw5Ahw8iRw5gwnkQdyXRE2NkDt2oCbG+DsnH84OPBhZwfY2wO2tnxYW/NhYwOo1XxYWfFhacmXFhZ83dIy/7pKxdcLXlqVkjUkoZg4lUqFFi1a4OLFiwgMDAQAvP/++8jJycEbb7yBuLg46AbqOTk5wdbWFgBw4cIFhISEKBZ3eaWmAhERwKVLfOi+lUVGcrIoD2troE4dLmC6QubmBri6ArVqGTR8oaS9e4GRI/nTd9Ys4L338JuzM1IAYPt2rp1MncpJpUAiULpMXboEbNsG7N7NieTBeZWWloCXFx+PPAI8/DDQqBHQoAHw0EP8Xndw4A93UyMJxQwEBwfjxIkTGD16NABg+/btAIDHH3+80PPmzJmDkJAQpKam4tKlS0UeVxIRcPUqcOoUt7+Gh/Px338l/4xaDTRuzEfDhnzoClX9+tw8Xrcu4ORkmoVLGFBSEjB2LDf4v/UWUMxERkyZwh0L77/PSaVr17yHjF2m4uKAVauA1au5FqKjUgFt2gCdOwOPPgq0bQu0aME1CbNEQjEAyMnJqcznRUdHk7+/P6WkpJTrdTdt2kRjxoypanhVkphItHs3UWgo0ZNPErm6EnFaKXxYWxP5+hI9+yzRO+8QrVhBdPAgUXQ0kUaj6K8gTNm4cfwGCgwkys3Nu9vJyYkKfaxpNERdu/JzBw/Ou9tYZSoigmjsWCIbm/z3vKsr0ciRROvXE8XFVfglTZokFAWVN6EQEU2bNo3WrFlTrucOHjyYjhw5UpXQKiwtjejXX4nefJMoIIDIwqJo8qhfn6hPH04yGzZwYcvJMWqYojo4cIDfUDY2/CYqoEhCISK6do3I0ZF/ZseOvLsNWaauXycaPpxIpeLTqlREvXsTbd5MlJlZ7pcxO5JQFFSRhBIbG0t9+/alzDLejfv376cpU6boI7wyXbtGtHAhUc+ehb+BAURqNVHHjpxgNm/mGocQVabVcq0EIPrggyIPF5tQiIg+/5x/xtc3r0ZjiDKVlUX0v//llwe1mujFF4muXCnXj5s9WXpFQSqVCk5OTsWuNmyqrlwB1q8HNm8uPBZdpQICAoAnn+Sm6k6duONQCL36+Wdg0CDumY6MBB6YK+Ls7IyUlBQU+VjLzAS8vbnTbtUqHhmmZ6dPA6NHA+fO8e3hw4GPP+ZO9ZpCEoqCzCWhxMXx6MxVq3iIo46jI/D000C/fsBTT3EZF8JgNBrAzw84fx5YuBB45ZUiTykxoQDA999zR76nJ3DxIg8P1AMinvLy2ms8YqtZM2D5ciA4uOyfrW4koSjIlBMKEbB/PxeUrVt5di3ASWTgQGDIEK6N3B9RKYThbd0KhITwsL9Ll4odClVqQtFoAF9f4MIF4IcfuDpRRbm5nNe++YZvv/ACz6m0t6/yS5slGTYsCklN5bK2aBF/iQN4QtNTTwH/939A//41t7AIBREB8+bx9TfeqNy4WktLYNo0YNw44NNPudmrCuPN09OBwYOBXbs4nGXLeFpMTSY1FAWZUg3l9m1uRViyhJcsAQAPDx6+P24cT6wSQjGHDwNduvBM1f/+K7GDrtQaCsBtUk2b8pILu3Zxm20lpKcDAwbw3MratXmi4gOLhtdINWOxJ1Gi6Giusnt6AnPmcDLp1AnYsIHXEPrf/ySZCBMwfz5fvvRS1UZ72NhwZwfAtZRKyM7mZt+9e3lybViYJBMdqaEoSMkayu3bPAJl6dL8/pGBA7lFoGNHo4cjRMmuXeM1SNRqrp0Us4KwTpk1FIBn2TdsyO274eHcr1JORNz0u3o1r9Jw4ABQzDqSNZbUUGoY3UoUjzzC/SQ5OdzBHh7OfZ6STITJWbqUP8mHDCk1mZSbi0v+sOEKbus7cyYnEwcHbjGTZFKY1FAUZMwaikYDrFzJSx7ducP39e8PfPQR0Lq1wU8vROVkZnJt4t494K+/gMceK/Xp5aqhADxZpHVrHrYYE8NL9ZZh506gb18epLJ9O9CnT0V+kZpBaig1wNGjQGAgd7DfucNl8vBh7kiUZCJM2oYNnEz8/flNrC++vjxRJDWVqxxluHYtfwTXRx9JMimJJJRqLD4eePFFbsY6eZK/6P30Ey+ZLZ2IwizoJni89JL+l5R++eX8c5RSo9FouIUsMZEn8b79tn7DqE4koVRDRLw8io8PT0xUq4F33uH5XM89J0u9CzNx7hw3czk5AcOG6f/1Bw7k5R3OneNqfAkWLAD+/JO3Tfj+e27yEsWTP001c+sWL3X03HO8QVVwMHD2LI/okrW1hFn57ju+HDnSMG9ea2teiqXguR4QEQHMmMHXly2TDdvKIgmlGlm3DmjVivtGnJ25drJ/v4xEEWYoI4MXjwO4889QdPvNr1vHw4kLIOKt6rOzeXJv796GC6O6kIRSDSQkcIvAsGF8/amnuBY/YYJUz4WZ2ryZOy3at+cOeUNp3pyXx87IAH78sdBDa9cCBw/y7sGVnANZ48jHjZk7eJC3EF23jlsFvv2Wx8fL7HZh1pYt40tdDcKQdDWg5cvz7kpJAd58k69/8ok0dZWXJBQzlZvLy6J07crLpwQG8l7VEyZIp7swc5cv8zcle3vDdMY/aNAgwM0NOHUqb5Of+fN5NYnAQGDMGMOHUF1IQjFDN28C3bsDs2bx7RkzeD2hZs2UjUsIvVixgi+HDi3XhMMqs7XNnzm/fDlu3wY++4xvzp8vzcYVIX8qM7NnD9C2LXDoEA9j3LePJ1qp1UpHJoQe5OTw2FwAeP55451Xd641azDr/VykpfFKEkFBxguhOpCEYia0Wk4cvXoBsbFAjx7cxNW1q9KRCaFHu3ZxW1OLFrzstbH4+QEdOiAqyQXfrbCAhQWvvi0qRjbYMgOJiVwj/+UX7h/53/+A997j/YKEqFZ080HGjzd+Z+D48fjkeC5yNRYYMQJo2dK4p68OZHFIBZVncchz57jP8MoV7jdcu5aHBQtR7dy4ATz8MH9TionhWewVVO7FIYsRczEVTVuokQM1zu38Dy17e1b4NWo6afIyYVu28EKOV65wv8nJk5JMRDW2ciW37eqWRDGy+d84Ihs2eAab0fLAYqOfvzqQGoqCSqqhaLXABx8AH37It0eM4Pklspe7qLa0Wt6k5/p14PffgSefrNTLVLaGkpjIi6empQGn0RZt69zkGpO1daXiqKmkhmJiUlOBZ57hZGJhwcMWV6+WZCKqud9/52Ti6clj4o1s2TJOJt26Edr6anjky7ZtRo/D3ElCMSHXr/PAlp9/BlxdecDLG2/IREVRA+iWqX/xRaNP/MjN5d1LAeD111XAxImFYxLlJk1eCirY5HXoENdM4uIAb2/eEc7LS+kIhTACXWe8hQVfr8I2v5Vp8tqwgedQensD588DFilJQIMGQHo6cPGiFMQKkBqKCVi+nOeVxMVxp/vRo/IeFjXI8uXchxISop894yto8f3+91dfvV85cnHJX/Ll22+NHo85kxqKglQqS6jVC5CT8yoAYMoU7jOR+SWixsjJ4X6Tmzd52Ydu3ar0chWtoURE8HwTR0cOwcnp/gMnTgAdOvBY/Rs3pBOznKSGohAe2LUdOTmvwsqKOwUXLJBkImqYLVv4k9zHR5FlH5Yu5csRIwokE4CXze/QgfeDWLvW6HGZK0koCoiM1K0q0QdAPPbsMe6yRUKYDF1v+OTJRh99kp4O/PADX3/xxWKe8MorfLloUal7zot8klCMLCyMl8T+918AOA8Hh6544gmFgxJCCadP82btzs7A6NFGP/2mTTz/5NFHS9jDa8gQoG5d4J9/uOCKMklCMaLly3mIfVwc8PTTANARFhbXlA5LCGV8+SVfjh3LnRhGplvUuMQ9vGxsgBde4Ou6WEWppFPeCHJzgbfeAr74gm9PmcJbiqrVZa/lJUS1FBMDNGkCaDTApUs8S14Pytspf/06n97Wlhc3dnEp4Ym3bvGQ5txcjlM2HSqV1FAMLCEB6NOHk4lazYupLlgAWMk6z6ImW7iQR3iFhOgtmVSEru8kJKSUZALwpkMjR3IfyuefGyU2cyY1FAM6fx4YMIAXd6xTB9i8GejSJf/x8qw2LES1k5wMNGrEl0ePcqeinpSnhqLVckXj2rVyLhv277+Ary9XZ/77T5GFK82F1FAMZPv2/JWC27QBjh8vnEyEqLGWLuVk0qWLXpNJeR05wsnEw6Oc015atQJ69wYyM/NHpYliSULRM91KwQMGACkpwODBPJDl4YeVjkwIE5CezrN3AWD6dEVC0E0rGT68AvO+3nmHLxcu5KFholiSUPQoIYH3oZ45k4fUz50LrF8PODgoHZkQJmLpUuDuXZ44yEMdjSonB9i4ka8PH16BHwwK4omXSUmcVESxpA9FT06f5sUdr10DatUCfvoJ6Nmz9J+RPhRRo2RkAE2b8rCqHTuAvn31foqy+lB27+bWKx8f7hqp0FzKgweBJ57gpcCvXy+jN79mkhpKFRHxsikdO3IyadeOd1YsK5kIUeMsWsTJpF07HvqogILNXRWemP/440BwMDd56ZrtRCFSQ6mC1FRg0iRgzRq+PX48lxlb2/L9vNRQRI0RH8/DgxMTgd9+M9g3rtJqKBkZPPE9NZUHy1RqtPKRI0DnzrxY5JUrPKxY5JEaSiWdOQMEBHAysbcHVq3iOSblTSZC1Chz5nAy6d690tv7VtVvv3EyCQiowtSXTp14z/v0dO4sFYVIQqkgrZbnNwUG8sTZ1q15petRo5SOTAgTdeVKfkf23LmKbUGq64wfPLiKL/Txx7xxyrJlvM6XyCMJpQKio4FevXhb3uxsbu76+2/u4BNCFIMIeO01LjCjR/PoLgVkZPDcMEAPCcXHhwu/RsOrJEuvQR5JKOVABKxezbWRvXsBd3d+cy5eDNjZKR2dECZsxw5g1y5eUXjePMXC0DV3tWvHA82q7MMPecZ8WJjsl1KAJJQyxMTwJMXRo3kIer9+wLlzfCmEKEVyMn+DB/gDWIHtfXU2beLLKtdOdNzcgE8+4euvv85LiAsZ5VUSrZY72adN43Lh4sKLOo4ZU8kmYI2G33Tx8fyCGRno0bUr7O3ssH3XLu7Zd3bmSSzu7vc3txbCjL3wAhei9u2Bv/4yyoqoxY3yys7m0V1JSdzv2by5nk6m1fIggwMHgOee48lnNZwklGL88w8wcSKXAYBrI4sXAw0blvGDRLyd6ZkzXI2JiACuXuVJULducVIpDysrHo7o6cmr2Pn4cHtb27ZA/fqV/r2EMJrffgOeegqwtuZZvy1bGuW0xSUUXSi+vkB4uJ5PGBkJ+PkBaWnc6//ss3o+gXmRRdQLSEgA3n+fk4dWy5/dX37J1eRiayU5OTyLMSyMF+z6+2+euFWSWrWA2rW5umNvj72HDsHK0hJPdOrEwxCTkoB79ziQ6Gg+HtwpzsODh5h17syL6/n7y1r4wrTcupW/A+PMmUZLJiXZupUvBw0ywIs3bcpNX5MnAxMm8JjkJk0McCLzIDUUcF5YupQXdbx3j1ubXn6Zm30Lra5ABFy8yF95fv8dOHSIe/oKcnXlD/nWrbkgNW/ObzAPD/62VkCJExuzsrjzJjISuHyZ18H/5x+u+Tz4XGdnXg7iySf5a5hsACSUlJsL9OjBy5R0785lpdwrMFbdgzUUjYaL3p07XFFq29YAJyXiuSnbtwMdOgCHDxcp6zVFjU4oRLxHybvv8uc2wJ/NCxdyPgDAH+4HDgC//ALs3MnrqxTk7c1LMnTuzOuvNGtW7k6WCs+U12q5Efivv/hNe+gQj/EvqFkzXiOpb19eJkKtLt9rC6EPU6fybnL16/MXICN3xD+YUP78k9d19PTk72cGmwITH89DyKKigOef574jhebbKIpqIK2WaMcOIn9/Ik4rRM2bE23dyo9RUhLRTz8RDRlC5OSU/ySAyN2daMQIoh9+ILpxo0pxACAnJ6eq/TJRUUTLlxMNHUrk5lY4VldXouHDiTZuJEpJqdp5hCjL4sX8vlOriQ4eVCQEJycnKvix9uabHNLUqUY4+fHjRHZ2fMJ584xwQtNToxKKRkO0eTNRu3b5n7kPPcTlIDvmLtF33xE9/TSRtXXhD+bWrYlmzCA6epQoN1dv8egloRSUk0N0+DDR228T+fgU/h1sbYn69SNauZLo3j39nVMIIv7SYmnJ77Xvv1csjIIJRavlL4oA0YEDRgpg06b8Mqfg30EpNSKhpKURffMNkZdX/v+6Xj2iz9+Pp/T5XxM98QSRhUX+gxYWRMHBRAsWEEVGGiwuvSeUB126xN+UOnYsnFwsLYl69OBMevOm4c4vaoZt24isrPi99cEHioZSMKGcP88h1arF37WM5rPP8j9H1q414omVV60TytWrRG+9xW8o3Wepp0cWLer7K6W361z4Q1at5trJt98S3bljlPgMnlAKionhBPLkk/nfJAEilYoTzrx5nICEqIhVq/KTybRp99uMlVMwocydy2GNHq1AIB9+mJ9UvvlGgQCUUe0SSno6d3/06FE4XwTWv05r602hHBT4MLW3JwoJIVqzhigx0eixGjWhFHTvHlfH+/UjsrEp/Ify8eEms8OH9dq8J6oZrZZo9uz8940JJBOiwglFVzHftEmhYHRJBSB6990aUZ6qRULJySHas4do3DgiZ+cC3QaWWfR/6h/pKB7Nv7N2baL/+z+in3/mtjAFKZZQCkpJ4RI3YgR34hdMLrVr8/0//kgUG6tsnMJ0JCXxFzHd++Tzz5WOKI8uody+zZVvGxuFx6N8+21+c/pTTxHFxSkYjOGZbUJJTyf65Rei8eOJ3N21hT4H2+MYLcLLFI/7H5De3jzc4+BBIzemls4kEkpB2dlE+/YRTZlC1LRp4eSiUhEFBBC98w4/JyND6WiFEv74g6hxY35PODsTbd+udESF6BLK8uUc4tNPKx0REf3+O385040C2rlT6YgMxmzmoRDxFIw9e4Bff8nB/gMqpGflzxBvjkt4DuswDD/Bxy6K54b07s1HpXfTMSyT3rFR9wfftYuPsDCek6NjY8PzboKD+QgMBBwdlYtXGNbt28D06cAPP/DtgABeZdfLS9m4HqCbhzJgAGHbNmDJEl5GSXFRUcCIETwxBgCGDOFthBs1UjYuPTPZhKLVAhcuAIcPaXHol2QcOKJGTIJDoee0w0n0x3aEYCt821lD1aM7z9Lt0sUstk406YTyoPR0nki5dy8fZ88WftzSEmjThpNMYCDPGPbykkUuzV18PPDZZ7wGUVoazwAPDeXkYoKTZjmhZMPePhPp6bx6UZlr8BmLRsMrzL7/Pm/QYmcHvPQSr0Bbt67S0emFSSQUrZYnoJ85moGTe+Jx4jjh2JVaSMq2L/Q8d8SiO/ahp8U+POV3Ew16tOTkERzMS56YGbNKKA+6d48TzKFDXHs5c6bo4pdOTrwMTdu2fOiWo7G3L+YF9a9OnToIDQ3Fa6+9ZpTzVSvnzvHX+++/5y8TANC/P29XaqI1fkCXUIIA7IK/P3DqlNIRFeO//4C33gI2bODbtrbAyJGcXPz9lY2tDN7e3hgyZAg+/PDDYh83akLJzQWirmlx8c84XPg7CRHhufg30hbhd+shVVP0Q6YhotEZfyLI7TyeaJ+Klt3qw6JzR65uG+lDyZDMOqE8KDWV90L+6y/g+HHg2DFej+xBKhWvbebjw4eXF6931qwZ0KCBXms0KpUK7du3x/Hjx/X2mtVaZCSwZQuwfj3/L3V69eKF7h57TLHQyosTyicAJuH990182/dTpzhA3VaSANfyhw4FnnnG5JoTAS5T9evXx61bt4p/XJ8JJT2NEBORjJhzCYiOSEX01SxERQHXb9kiMt4V1zPqIhfFV5Pr4Tb8VWfg734D7b1T8GgXGzR8ohln7Dp19BWiSalWCaU4d+5woTlzhpvIwsO5XyY3t/jn29jwokuensDDDwONG3N7RcOGvMLfQw/xYpgVWCsNAEygEm56iIAbN4AjR7iGuWcP/290XFyAYcN4Fd1WrZSLs4KcnJyRmnoeQEOcOMHfPU3epUvA118Da9ZwE6NO06a86GtwMDcle3oqvj5Y/fr1cefOnRLLVKkJ5c7FRCREpyLhRhoSbmUi/nY27t3Jwb1YQly8CncT1LibYoc76U64neWGZHIuM6CGiIa39TV41bqHlg+noaWvBVoHuaBOYFP+lmqC7bKGUu0TSnGys3klzgsX+Lh0iW9fvQrcvVv2z9va8sKD9erxFw3dUbt2/vYAbm6Aqyt6DxuGIxcuILEmJ5ScHE4c167l/93//ZcT/IN/b2dnHsTyzDNAnz5mub+1g0MXpKeHoUED/rXNan3GrCxg925esXbnTt7GoqDatbkG4+sLtGiRv5J5o0ZGW924f//+2LFjR+USSkX/GdbIQgPVLXjY3ENDpyQ0cs/Aww018HzEEk39HNHk0Tqwa/Ew4OBQ9ovVADUyoZQmNZU/+KKi+NDtCRMTw8etW9wxXEFajQYW5jY4gIj7pLKy+MjM5I7cjAz+G6Sl8d8rOZn30UlM5G+3cXFAbCyPyrp1i2uJJRXxWrV48ESXLrzMdmCg2e+tY2MzG9nZM/DCC7wlhdnSaLjZcf9+rkEeO1b6NsP16nENvn59/oLl7s7/X1dXrm06O/MoTAcHPuzs+LC15cPamv/3ZXzoz5w5Ex988AEyMjJgW8zApxITChGhgeVtOKpS4WSZwod1Chxt0uBgmwYH+3TYOWXC1iUL1rVyoHbPBblbItemZu4DUBmhoaGwsbHBe++9p3QoZsM6KwsOqamwT0uDY2oq7NLSYJ+eDrv7h21mJuzS02GTmQlNfDzUOTlIu3YNnp6eSocOIkJiw4bQZmXBQquFhVYLFRFf3r9tqbvUaKDSQ82KVCqkODkhydUV8bVrI97dHbF16+JuvXpIcnMzs6/wZXvvvV4gao+RIzegRYvLSoejP0RwTkpC3du3UefuXdSKi0Ote/fgkpgIp+RkWOjpvaKxsIDW0pIvLSxAukuVCloLC6SkpyM1Kwu5Z8/Cz8+vyGuUmFCio6PRuHHjKgcphNKOHz+O9u3bKx0GYmNjUacCw0M1ALIAZN6/zLh/pANIA5By/0gCkAggAUAsgDgAdwDcAnAbQAk9VtXQQwBugv9Kte9fVn+WAOoXONwB1AHgBsAVgPP9wwmAw/3D7v5hA8AWgPr+UV5/7NuHbt26FbnfJIYN11TS5GVYoaGhmD17NpKTk+Hk5KR0OOzyZW6CsrDgJgZLSz7U6vxLtZqbIMytmU5hy5bxLrzADhD1Uzoc86PVcp+b7sjN5UOjybu+YtkyzP3kExyIiUGDBg2KvIR5N5gKUYqz9ydfmkwyAbgjVRjEjh26a78AkIRSYRYWPNLSxqbEp5xMScFlAA899FDxL2Gg0IRQnMw/qTkyMnjkM/tFyVCqtb///htA/pD8B0lCEdXWnTt3ULeaLGkhSvfHH5xULCxOg/tRhCGcPHmy1McloYhq7TEzmN0tqk432dzK6ldlA6kB2rVrV+Jj0odiwrKzs/Hhhx/i119/hbW1NcaMGYMJ3OsoymHfvn1o0qSJ0mEIAyMCfrnfymVltQvZ2SU/V8pU1YSFhaFOKSuXSEIxYfPmzcPp06excuVK3L59G9OmTUODBg3Qp08fpUMzC8UNaxTVz6lTwM2bvDpPUtLZUp8rZapqgoKCSn1cmrxMVHp6OjZs2IB3330Xvr6+6NGjB8aPH481a9YoHZoQJkU3uqtv39LnaUqZMjxJKCbqwoULyM7ORkCB1e0CAgIQHh6O3JIWV6zBFi1aBG9v7yLH1q1blQ5NGJiu/6RfGSOFpUxVTGXKlDR5majY2Fi4uLjApsCYcHd3d+Tk5CA+Pl5GLz1g3LhxeO655/JuL168GGFhYejRo4eCUQlD++8/4PRpXp6qe/fSnytlqmIqU6YkoZiojIwMWD+wgqjudnZpvY41lIODAxzuLzp68OBBbNmyBT/99JNpTWoUeqdr7urVq+xNWqVMVUxlypQ0eZkoGxubIm9y3W07M1xW3Fhu3LiBadOm4Z133kHLli2VDkcY2LZtfDlgQNnPlTJVORUpU5JQTFS9evWQnJxcqADExsbC2toaLi4uCkZmurKysvDqq68iKCioUFVdVE9JScCBA7xiSO/eZT9fylTFVbRMSUIxUT4+PlCr1Th9+nTefSdPnkSrVq1gZeZ7VhjKrFmzkJGRgVmzZikdijCCX3/lNQyDgnj7j7JImaq4ipYpSSgmys7ODgMHDsTMmTPxzz//YN++fVixYgVGjx6tdGgmadOmTdi5cyc+/vhjZGRkIDY2FrGxsUhJSVE6NGEgusFG5WnuAqRMVVRlypQsX6+gspavz8jIwAcffIDff/8dDg4OGDduHMaNG2fkKM3DqFGjcOzYsSL3Dxo0CHPnzlUgImFIWVm8MWFKChAZyTvhAoCzszNSUlJK3KJWylT5VaZMSUJRkOyHIkTl7NrF2963aQOcOZN/f1kJRRiWNHkJIczOli18GRKibByiMEkoQgizotHkz44fNEjZWERhklCEEGbl8GEgNhZ45BHA11fpaERBklCEEGZl40a+fOaZ0heDFMYnCUUIYTY0GmDzZr4+eLCysYiiJKEIIczGkSPA7duApydQYNFgYSIkoQghzIauuWvIEGnuMkWSUIQQZkGrleYuUycJRQhhFg4d4q1+mzSR5i5TJQlFCGEW1q7ly2HDpLnLVElCEUKYvKwsYNMmvj58uLKxiJJJQhFCmLzffgMSEgA/P6BVK6WjESWRhCKEMHkFm7uE6ZKEIoQwaYmJ+Vv9ykacpk0SihDCpG3YAGRmAl278oRGYbokoQghTNr33/PlmDFKRiHKQxKKEMJkXbwI/PUX4OjIi0EK0yYJRQhhsnS1kyFDAAcHRUMR5SAJRQhhkrKzgZUr+frYscrGIspHEooQwiRt2wbcucPzTjp3VjoaUR6SUIQQJumbb/hy4kRZasVcSEIRQpicS5eAP/4A7O2BUaOUjkaUlyQUIYTJ+eorvhw2DHBxUTYWUX6SUIQQJiUxEVixgq+/+qqioYgKkoQihDAp330HpKUB3bvzYpDCfEhCEUKYjJwcYNEivj51qrKxiIqThCKEMBnr1gHR0YC3N/D000pHIypKEooQwiRoNMDs2Xz97bcBC/l0MjvyLxNCmIRNm3jtLk9PYORIpaMRlSEJRQihOK02v3YyfTqgVisbj6gcSShCCMWtXQuEhwONGsky9eZMEooQQlGZmUBoKF+fNQuwsVE2HlF5klCEEIpasgSIiuJFIGWZFfMmCUUIoZi7d7lWAgBz5wKWlsrGI6pGEooQQjHTpvFSK716AX36KB2NqCpJKEIIRRw+DPzwA2BtzbPjZYl68ycJRQhhdOnpwPPP8/W33waaN1c2HqEfklCEEEb37ru850nLlnxdVA+SUIQQRrV3L/Dll4CVFbBqFWBrq3REQl8koQghjCYmBhg+nK+/9x4QEKBsPEK/JKEIIYwiKwsYMgSIjQWefBKYMUPpiIS+SUIRQhgcEXfCHzkCeHgAP/4oc06qI0koQgiDmzGDk4iDA7B9O1CnjtIRCUOQhCKEMKiZM4E5c7hGsnEj0K6d0hEJQ7FSOgAhRPVExB3vs2fzZlk//CC7MFZ3klCEEHqXnQ1MmMDDgi0s+HLECKWjEoYmCUUIoVfR0cDQocBffwH29sD69UDfvkpHJYxB+lCEEHpBBGzYALRty8mkYUPg0CFJJjWJJBQhRJVFRgKDBnHNJD6e+0pOn5aJizWNJBQhRKXduQO8+Sbg4wNs2wY4OQFLlwI7dwLu7kpHJ4xN+lCEEBX277/A118DK1fyFr4A77Y4Zw5PXBQ1kyQUIUS53LgBbN3KExT//jv//gEDZF0uwSShCCGKlZgIHD0K7N/PKwSfOpX/mKMjMHo08PLLvAS9EIAkFCFqvPR07lS/fBk4fx4ID+cO9cuXeeSWjr090LMnL/A4YADfFqIgSShCVBM5OZwc0tL4SEkBkpO5ppGYCNy7x8fdu8Dt28DNmzxnJC6u+NeztuZmrKAgoEcPoEsXwM7OmL+RMDeSUIQwomHD+IOfCNBq8y8LHhpN/mVubv5lTk7+kZ3NR1YWH5mZ/LzKsLYGHn6Yt+H18eEmLH9/vrSx0e/vL6o3FVHBSq0wJpVKBScnJyQnJysdijASlcpwr21pyc1Q9vbcx+HoCLi4AM7OgJsbULs2H3XrAvXqAQ0a8Iis+vV5eZTqwNnZGSkpKZCPNWVIDUUII9q0iWsfKhV/iFtY8HVLy/xLC4v8SysrPiwtAbWar1tb83UbG75ua8uHWq30bydqOkkoQhjRM88oHYEQhlNNKrpCCCGUJglFCCGEXkhCEUIIoReSUIQQQuiFdMoryN/fH7Vr11Y6DCGqjcDAQNy7d0/pMGosmYeioKSkJFhZWcHBwUHpUISoFtLS0pCbmwsXFxelQ6mRJKEIIYTQC+lDEUIIoReSUIQQQuiFJJRKunHjBry9vREVFWX0c3fr1g0bN24s9rGoqCh4e3vjxo0bRo5KCMOIiIjAiRMnqvw6o0aNwoIFC/QQkSiJJJRKeuihh3D48GE0bNjQ6OfetGkT+vXrZ/TzCqGEl19+GdeuXVM6DFEOMmy4kiwtLVGnTh1Fzl2rVi1FziuEEKWRGko5/Pjjj+jevTtat26Nfv36Yf/+/UWavBISEjB58mT4+/uje/fu+Omnn+Dt7Q0gv3ls37596NatG/z9/TF37lxcvHgRISEhaNu2LSZOnIj09PS8c27ZsgW9e/eGn58fQkJC8HeBTbwLNnnl5ORg1qxZaN++PR5//HGEhYUZ8S8jhGGNGjUKMTExCA0NxfTp07F//34MGjQIrVu3RkBAAKZMmYLU1FQAwKJFizB16lTMmjULAQEB6Nq1K5YuXVro9WJjYzFhwgS0bt0avXr1kvKibyRK9e+//1KrVq1oz549dOPGDVq8eDH5+fnR+fPnycvLi65fv05ERGPGjKGhQ4fS+fPn6cCBA9S5c2fy8vIiIqLo6Gjy8vKioUOHUkREBP3888/k5eVFPXv2pCNHjtCxY8eoXbt2tGrVKiIi2rx5M7Vp04a2bt1KkZGRNH/+fPLz86OYmBgiIuratStt2LCBiIg+++wz6tq1Kx07doxOnTpFPXv2JC8vL4qOjlbgryWEfiUkJFBwcDCtWLGCIiIiqFWrVrRu3TqKjo6msLAwCgwMpG+//ZaIiBYuXEitWrWijz76iK5evUpLliwhLy8vunz5MhERjRw5klq1akUbNmygqKgoev311+mxxx4jjUaj5K9YrUgNpQwxMTEAAA8PD3h4eODFF1/E119/DXWBzSeuXbuGI0eOYM6cOfDx8cHjjz+OyZMnF3mtSZMmoUWLFhgwYABcXV3Rp08fdOzYER06dMCjjz6KyMhIAMDq1asxYsQIDBw4EE2aNMEbb7yBFi1aYPXq1YVej4iwceNGTJ48GR06dIC/vz+mT59uwL+GEMbl6uoKS0tLODo6wtbWFjNmzMDQoUPRsGFDBAUFoVOnTrhy5Ure852cnDB9+nQ0bdoUEydOhKurK86dO5f3ePfu3TF48GA0btwYEyZMQHx8PGJjY5X41aol6UMpQ1BQEAICAjBw4EB4eXmhW7duePbZZ6EqsPXexYsX4ejoiCZNmuTd17Zt2yKvVbAD38bGBg0aNMi7bWtri+zsbADA1atXMWnSpEI/27Zt27yEo5OQkID4+Hi0aNEi7z5fX9/K/aJCmDhPT09YW1tjyZIluHz5Mi5fvowrV66gT58+ec/x8PCApaVl3m0HBwfk5OTk3W7cuHHedUdHRwBAVlaWEaKvGaSGUgY7Ozt8//33+PHHHxEcHIxff/0VAwcOzGu3BQArK6tybTlqZVU4f1uUsO+qra1tkfs0Gg00JWwaXvDcD55DiOriwoUL6NOnDy5fvoyAgADMnj0bvXv3LvQcdRnbVhZX5spTdkX5SEIpw+nTp7F48WK0b98eb731Fnbv3g13d3ccOnQo7zmPPPII0tLScP369bz7ClazK6pp06Y4e/ZsofvOnj1bqAYEAG5ubnB3d0d4eHjefREREZU+rxCmbNu2bWjXrh0+//xzjBgxAn5+foiKipKEYELk62wZbG1tsXjxYtSuXRtBQUG4cOECbt26BTc3t7znNGnSBEFBQQgNDUVoaCji4+OxcOHCSp9z7NixmD59Opo3b442bdpgy5YtiIiIwMcff1zoeSqVCsOHD8dXX32FRo0awcnJCXPnzq30eYUwRQ4ODoiMjISzszMuXbqEs2fPwsXFBevWrUN4eHihpmOhLEkoZfDx8cGcOXOwZMkSzJ49G3Xr1sXbb7+Njh07FnrenDlz8N5772HIkCGoW7cuQkJCsGzZskqds1evXoiNjcXChQsRGxsLHx8frFy5Es2bNy/y3EmTJiEzMxOvv/46LC0t8fLLL2PWrFmVOq8QpmjEiBH45JNP0KlTJ7Rr1w5jx46FtbU1OnTogMmTJ2P79u1Khyjuk9WG9SAjIwNHjhxBcHBwXhvu7t278emnn+KPP/5QODohhDAO6UPRAxsbG7z77rv46quvEB0djdOnT+Prr79Gr169lA5NCCGMRmooenLixAnMmzcvbwhx//79MXXqVFhbWysdmhBCGIUkFCGEEHohTV5CCCH0QhKKEEIIvZCEIoQQQi8koQghhNALSShCCCH0QhKKEEIIvfh/3PLtWjmKUtQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 504x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from support import plot_activation_function\n",
    "fig, ax = plt.subplots(1,2, figsize=(7, 3))\n",
    "plot_activation_function(sigmoid, grad_sigmoid, name='sigmoid', ax=ax[0], labels=('z', 'f(z)'), xlim=(-4, 4), ylim=(-1.1, 1.1))\n",
    "plot_activation_function(tanh, grad_tanh, name='tanh', ax=ax[1], labels=('z', 'f(z)'), xlim=(-4, 4), ylim=(-1.1, 1.1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loss\n",
    "We perform a forward path by pushing samples through the network. It is just a series of matrix multiplication with some non-linearity function in between. In this way, we get current predictions. Since we have correct answers, we can compare it to the network output and calculate the loss. The neural network is being optimized with respect to the error made on the existing samples. During the training, we adjust the weights with gradient descent to make the loss lower. By reducing the loss, we also hope that the network will get better at a certain task, e.g., classification. The loss functions usually differ per task. For this example we can use *Mean Squared Error*:\n",
    "\n",
    "$$L(y, \\hat y) = \\frac{1}{2} (y - \\hat y) ^ 2$$\n",
    "\n",
    "$$\\frac{\\partial L(y, \\hat y)}{\\partial \\hat y} = (y - \\hat y)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def mse_loss(y, y_pred):\n",
    "    return np.mean((y - y_pred) ** 2) / 2\n",
    "\n",
    "def grad_mse_loss(y, y_pred):\n",
    "    return -np.mean(y - y_pred)\n",
    "\n",
    "# We also define the accuracy function to calculate what fraction of the samples our model \"got right\"\n",
    "def binary_accuracy(y_true, y_pred):\n",
    "    accuracy = np.mean(1 - np.abs(y_pred.flatten() - y_true.flatten()))\n",
    "    return accuracy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training\n",
    "The training consists of *epochs*, the number of full passes through the dataset. First, we define one full *forward path* through all the layers. \n",
    "\n",
    "***We need to return all of the intermediate calculations to compute the gradients during training.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "def mlp_forward_path(X, weights, biases, act_f, train=False):\n",
    "    # forward first layer\n",
    "    y1, z1 = layer_forward_path(X, weights[0], biases[0], act_f=act_f)\n",
    "    # forward second layer\n",
    "    y2, z2 = layer_forward_path(y1, weights[1], biases[1], act_f=act_f)\n",
    "    # forward third layer\n",
    "    y3, z3 = layer_forward_path(y2, weights[2], biases[2], act_f=act_f)\n",
    "    \n",
    "    if train:\n",
    "        return z1, y1, z2, y2, z3, y3\n",
    "    \n",
    "    return y3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can define the back-propagation through all of the layers as well. To optimize the network with **Stochastic Gradient Descent** (SGD), you need to randomly sample *one* datapoint, evaluate the prediction, calculate the loss, and update the weights for all layers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "def mlp_train_epoch(X, y, weigths, biases, act_f, grad_act_f, lr=0.01):\n",
    "    \"\"\"\n",
    "    This function performs one epoch training for Multi Layer Perceptron\n",
    "    Parameters:\n",
    "    ----------\n",
    "        X : numpy.ndarray\n",
    "            a matrix of datapoints [N, k], where N is the number of elemens k is number of features\n",
    "        y : numpy.ndarray\n",
    "            an array of labels\n",
    "        weights : list[numpy.ndarray, ...]\n",
    "            the list of weights [W_0, ..., W_L]\n",
    "        biases : list[numpy.ndarray, ...]\n",
    "            the list of biases [b_0, ..., b_L]\n",
    "        act_f : python function\n",
    "            activation function for hidden layers\n",
    "        grad_act_f: python function\n",
    "            gradient for the activation function\n",
    "        lr: float\n",
    "            learning rate, defines how much the parameters are adjusted during training\n",
    "    Returns:\n",
    "        loss: float\n",
    "            mean loss for an epoch\n",
    "    \"\"\"\n",
    "    # Forward path\n",
    "    loss_epoch = []\n",
    "    \n",
    "    # Create an array of shuffled indices  \n",
    "    idxs = np.random.choice(np.arange(X.shape[0]), size=(X.shape[0], ))\n",
    "    for idx in idxs:\n",
    "        # Sample an element from the dataset  \n",
    "        X_sample, y_sample = X_train[[idx]], y_train[[idx]]\n",
    "        # Forward path  \n",
    "        z1, y1, z2, y2, z3, y3 = mlp_forward_path(X_sample, weigths, biases, act_f, train=True)\n",
    "\n",
    "        # Calculate loss\n",
    "        loss = mse_loss(y_sample, y3)\n",
    "        loss_epoch.append(loss)\n",
    "        \n",
    "        # Calculate gradient of the loss\n",
    "        loss_grad = grad_mse_loss(y_sample, y3)\n",
    "\n",
    "        # Backward path\n",
    "        y2_grad, z2_grad, weights[2], biases[2] = backward_path(layer_input=y2,\n",
    "                                                                layer_z=z3,\n",
    "                                                                prev_layer_grad=loss_grad,\n",
    "                                                                W=weigths[2], b=biases[2],\n",
    "                                                                grad_act_f=grad_act_f,\n",
    "                                                                lr=lr)\n",
    "\n",
    "        y1_grad, z1_grad, weights[1], biases[1] = backward_path(layer_input=y1,\n",
    "                                                                layer_z=z2,\n",
    "                                                                prev_layer_grad=y2_grad,\n",
    "                                                                W=weigths[1], b=biases[1],\n",
    "                                                                grad_act_f=grad_act_f,\n",
    "                                                                lr=lr)\n",
    "\n",
    "        _, _, weights[0], biases[0] = backward_path(layer_input=X_sample, layer_z=z1,\n",
    "                                                                prev_layer_grad=y1_grad,\n",
    "                                                                W=weigths[0], b=biases[0],\n",
    "                                                                grad_act_f=grad_act_f,\n",
    "                                                                lr=lr)\n",
    "    return np.mean(loss_epoch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### XOR dataset\n",
    " Now we will try to solve an XOR dataset with MLP. The architecture of the MLP allows hidden layers to learn representations of the data. We will show how MLP transforms a difficult problem into a linearly separatable one. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No handles with labels found to put in legend.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'Test'}>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from support import make_xor_dataset, plot_dataset_2d\n",
    "\n",
    "X, y = make_xor_dataset(400, r=3.)\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25) \n",
    "\n",
    "fig, ax = plt.subplots(1,2, figsize=(10,5))\n",
    "plot_dataset_2d(X_train, y_train, ax=ax[0], title='Train')\n",
    "plot_dataset_2d(X_test, y_test, ax=ax[1], title='Test')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MLP architecture\n",
    "\n",
    "We are going to build a small network for this problem. It is going to have two hidden layers with a size $4$ and $2$. Usually, in the classification tasks, the output size equals the number of classes. In binary classification, however, we can have one input. If we use a sigmoid function, the outputs values will be in the range [0, 1]. Therefore it can be interpreted as a probability distribution over two classes $p$ for *ones* and $1-p$ for *zeros*. $p$ then can be rounded by the following rule $\\hat y = \\mathbb{1}\\{p \\geq 0.5\\}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"center\">\n",
    "<img src=\"https://i.ibb.co/JR2mBpf/download-2.png\" width=\"600\">\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "pycharm": {
     "is_executing": false
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weights shapes: [(2, 4), (4, 2), (2, 1)]\n",
      "Biases shapes: [(4,), (2,), (1,)]\n"
     ]
    }
   ],
   "source": [
    "# Lets setup the network architecture\n",
    "n_layers = [4, 2, 1] # we don`t need to specify input layer since we are going to infer it from the data\n",
    "\n",
    "# Lists to store our weights and biases\n",
    "weights = []\n",
    "biases = []\n",
    "\n",
    "# Input dimension of the network.\n",
    "input_dim = X.shape[-1]\n",
    "current_input_dim = input_dim\n",
    "\n",
    "for layer_size in n_layers:\n",
    "#   size (shape) of the current layer\n",
    "    size = (current_input_dim, layer_size)\n",
    "    \n",
    "#   Initialize weights randomly\n",
    "    W = np.random.normal(loc=0.0, scale=0.5, size=size)\n",
    "    weights.append(W)\n",
    "#   Initialize biases with zeros\n",
    "    b = np.zeros(layer_size)\n",
    "    biases.append(b)\n",
    "    \n",
    "#   save the size of the previous layer\n",
    "    current_input_dim = layer_size\n",
    "\n",
    "print('Weights shapes:', [x.shape for x in weights])\n",
    "print('Biases shapes:', [x.shape for x in biases])\n",
    "history = {'loss': [], 'acc':[], 'val_acc': []}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "pycharm": {
     "is_executing": false
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "epochs = 200\n",
    "learning_rate = 0.1\n",
    "\n",
    "for epoch in range(epochs):\n",
    "\n",
    "    loss = mlp_train_epoch(X_train, y_train,\n",
    "                                weigths=weights,\n",
    "                                biases=biases,\n",
    "                                act_f=sigmoid,\n",
    "                                grad_act_f=grad_sigmoid,\n",
    "                                lr=learning_rate)\n",
    "    history['loss'].append(loss)\n",
    "\n",
    "    # Compute metrics\n",
    "    y_pred = mlp_forward_path(X_train, act_f=sigmoid, weights=weights, biases=biases)\n",
    "    acc = binary_accuracy(y_train, y_pred)\n",
    "    history['acc'].append(acc)\n",
    "    \n",
    "    # Evaluate test set\n",
    "    val_y_pred = mlp_forward_path(X_test, act_f=sigmoid, weights=weights, biases=biases)\n",
    "    val_acc = binary_accuracy(y_test, np.round(val_y_pred))\n",
    "    history['val_acc'].append(val_acc)\n",
    "    \n",
    "#   Uncomment the following lines to see how the performance of the network at each epoch\n",
    "    # print('MSE train loss: {:.2f}'.format(loss))\n",
    "    # print('Test accuracy: {:.2f}%'.format(100 * binary_accuracy(y_train, y_predicted)))\n",
    "from support import plot_elements\n",
    "plot_elements(history, elems=['loss', 'acc', 'val_acc'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** You can rerun the cell above to train for more epochs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visualization of representations\n",
    "Since we have two nodes in the last hidden layer, we can plot what the neuron in the last layer sees."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAAD5CAYAAACEcub7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAs5ElEQVR4nO3dd3wUdf7H8VeSTSckQEIE6VVIMKEqh+CBKE08FEREgaMKKCDSexEUEI8fxQKcAfQUDeXggh4KRs5Ikw6CdAkEQgpJIA3S5vfHmDLZDWmbnc3m83w89pHsd3dnPzubvDP57Hdm7BRFURBCCGER9noXIIQQFYmErhBCWJCErhBCWJCErhBCWJCErhBCWJBB7wJExbRp0ybGjx/PgQMH8PPzg5hLkBwDWemgKBB7AW6dBIMzHNsA/TbC3QhwrwY/vafeN/A1cHSHg6vUhVZ6BAbvgOrNcp/ozhVY2wnSkqDjZAhbri3E3gDjT4JX7ZK9kPPfwtcDoVFXSI2Hm8e0tz8zDzq+U7Jl56co8PLLsG1b7piTE5w4Ac2bl3rx07ed5usjNzRjzWtUpoaXCz/+Ho29Hfw8tTO1qrgVe9nfnYlk7JfHjcandGvKB99fAKBWFVda163CzpO36NvqUQ5cuUPf1rVYE3rZ6HHTujfl98hEerZ4hDFfHif/HKzZvZrR4lFPnmhQrdi1ljUJXWFxZ86cYezYsaSkpNC9e3fO/fAFHlGHIeEanP4GlCxoOQgCX4WkaGjSDVyrgqMLbB6Qu6Cjn8FfxsHQ7+H4JvB5DO5FQkY6VK0LLp6QcF0NXFAfn891V3/emzKfYydP4+rqSs+ePZk4cSLOzs5FezGetcDOTg3vrEzj2zPTir+CChIcrA1cgAULzBK4AM1rVjYaa+DjzsWoRPX2GpXxcClZZNT0dDUaq1XFlUrOucuLvHufBj6VADh+PYEOjbxxMTgYPS6wtifuzgaOX4+nd0ANOjT05pfLsZr7VHFzpKq7Y4lqLWvSXhAWde/ePXr06EFKSgoAMTExDBw2GiUrA05+pQaXwRWqN4dvXod/j4K4qxAyHq4fNF7gya8gOQrS76tbwV++BJt6qSEceRrcvNVQBLj9Gzz2fM5D0xw9Gf2DPU6u7nz99dcsX76cvXv3smLFiqK/IO/HoPdquH4ImvXW3mbvAA27FHcVmRYdDW++qR1r2xYmTzbP8oFOjX147JFKOde9KznhX9OTi1FJuDs5MO8FPzxdnUq07KaPVGJe7+YY7NX3wsvNkWEd6uPsaE/LOl4AKIqCl6sjb3VpxM34VKp7OBOTeJ+3ujTCxVGNqoY+7szs2QzfSs40q+HB5egkRnSsT2BtdRkezgbm9W5OvWru1Kxs/EfWGtjJzhHCUhRFoVevXuzevRs3NzeSk5Nxd3MlJSWV5a+35J2GV9Q7thwE18Ig/ho07QlJUXDrBHSaAv9bql3oIy2gSn316/VDkHEfwvert72wRv23//Q3sHeeOtaoK7R8HZwqcfRGKn8fP5PDhw/j7u4OQEhICEuWLGH//v1Ff2FZmWob48FdSIiAY0HgUgWeHA21n1DDt3QrznRb4fhx8PMr3bLzibp7nwtRiaRnZlGvmjsJqWncTc2gvrc79b3dS7Xs9IwsrsYmcSc5DQ9nAw72dtSu6kZWlsK1uBScHeyp5+2Owd6OG/GpZGRm4WKw507SA9KzFBSgoU8lqlVyJj4ljdjEVOJTMqnq7kh6Zhbxyek4G+yp6u5EfZ9KhdajF2kvCIs5e/Yse/bsoWfPnrRv357Zs2fz6crl/GPJAhbv/J23Jjji5GAHHr5q4AL4NocL36nfpyVDtUZw588en70BAl6FvfPBpwlc/QmempgbugnXISmKLTd8WLDlUXaueIeGfq25keZB7xf7MW/ePNatW5cTuAB2dnakpRWzJWDvoD4/QK226havnT3Ym+kfyS1bjNsK8+ebPXABfD1d8PUsmy1ER4M9TR8xbmEABLhpt6DzBnztasZhX8XNiSpuJdvq1pts6QqLSkxMxMPDg7CwMDp16oSiKHBtP4nn9+FxeQfEXlSDNOJXdeuxxcsQeUodt7OHJ0aDqxc4V4b0FDi2CRLCoctsOLMFfP3htz8DqvtSaNwVqjVi8ODBGAwGgoKCGDp0KI6Ojqxbt05TW1ZWFgMHDsTLy4tPP/3U4uvGpOhoNVxj8/Qs27SBgwfBINtM5ZGErtCFJnQBbp5QP/1PvQMOTmDnAN9OhPt34dmFELoIHqgf6NB6KCRGwsXd6vXAgZAYBY2fg71zIeMB1GwJnWep7QQ7O8LDw+nduzfPPvssP//8M7t27cLX11dT0+LFiwkODmbr1q00btzYgmvjIV5+GbZuzb1eRm0FYTnyp1JYB3cfuH0Kvp+ptgju34Uuc8G1inp5fTvcvQkOjup9HySC34vgXEndAnb689/W7svUsWoN1dkMf36IVrduXUaPHs3KlSuZO3euJnAVRWHx4sVs3ryZlStXWk/gBgdrAxfKrK0gLEdCV1gHR1fwrKNeQheBuze4VYO/zoSwf8CVvWqAtugPT70NdZ5QH3c/ETLT4X48GFyg/lMFPsX58+dxcHDg8OHDvPbaa4DaUpg1axYhISGsWLGCrl27WuDFFoGp2Qpt2sCUKfrUI8xGQldYB/dq6gdSbUeq4ZpxHypVV3u5V/aq91EUdSZCnfbqlDIAF48/H1/1oYsPDQ1l3759rF27ljFjxrB37166du3KkiVLCAkJYfXq1XTu3LkMX2Axvfmmto/r5AQbNkgf1wbIPF1hHWIuwIXdcD9BnXp1LwLcqsLZ7cb3jThSrEUnJSWxcOFCRo0aRceOHRk+fDgLFy7kyJEjOXvG+fv7ExMTk3PR1ZYtxm2FefPA31+femxUVlYWc+fO5ZVXXmHQoEGEh4drbg8NDaVv37688sorBAcHm+155c+m0F9SNGwZCtFn1esGF6j1BHjWg5qtIPp37f1rBBRr8StWrMBgMDBy5EgAxowZQ0hICNu3q4H+4Ycf8uGHH2oec/bsWQx6bFVGR8PYsdqx1q1h6lTL12Jldpy4yQffX+BWQio1vVyZ0q0pfVo+WuLl7d27l7S0NL755htOnjzJkiVL+OSTTwBIT0/n/fffZ+vWrbi6uvLqq6/SuXNnfHx8Sv06JHSF/u5cyQ1cUFsL1/4HgQPg8QFw7Rd1WhiorYVi7uU1Z84c5syZk3PdxcWF0NBQAN5///1Sl29WptoKGzdW+LbCjhM3mbH9DKnp6q7WNxNSmbH9DECJg/fYsWN07NgRgMDAQH777bec265cuUKdOnXw9PQEoHXr1hw9epQePXqU5mUAErrCGjgUMMk9IRxiL0PfIEiJUe9XI0D9kM0WSVuhQB98fyEncLOlpmfywfcXShy6SUlJVKqUu+eag4MDGRkZGAwGkpKS8PDwyLnN3d2dpKSkkhWfj4Su0J93I2j2N/h9Z+5Yk+5w4wg88QY84qfObrBl0lZ4qFsJqcUaL4pKlSqRnJyccz0rKyunpZT/tuTkZE0Il4Z8kCb0l5UBHSbACx9BqyHqTg2PtIAnx6qtBFsPXIC33tK2FRwdpa2QR00v0z8DBY0XRatWrfj5558BOHnyJE2aNMm5rWHDhoSHh5OQkEBaWhpHjx6lZcuWJX6uvOQdFfqK+l09ktjt0+DkAb3+AXXb/7mrr3m2LKzeli3qJS9pK2hM6dZU09MFcHV0YEq3piVe5rPPPsv+/fsZMGAAiqLw3nvvERISQkpKCq+88grTp09n+PDhKIpC3759jfZgLCnZDVjoImc34M0D4fwu7Y1DdkH9jvoUZmkxMerxcPNu5bZuDYcOyVZuPuaevaAXeVeFvi7vMR6L+6PihG7+2QqOjrITRAH6tHy0XIZsftLTFfp6xMSc28o1LF+HHgpqK7RooU89wiIkdIW+ur2nnlYn2+MDir3zQ7kUE2N8bIVWrWS2QgUg/8MIfXnVgVf/PC+agxN4NwFXz8IfV9699ZYavNmyZys4Wud5vYT5SOgKff2zi3qW30q+8OKn4GL6zAI2ZetW9bCNec2dK22FCkLaC0IfiVHq17sR6tekKPVElHFX9avJEmJijHeCaNUKpk3Tpx5hcRK6Qh8pscZjaclw94bla7EkaStYnVOnTjFo0CCjcTnKmLAtBhMnP7Sz136oZmukrVA6p4Phx4Xqf0eeteCZufB4/1Itcv369fznP//B1VW7Z1tZHmVMtnSFPjIz1K92dtC8D/x1BgwMVj9QS03Qs7KyIW2F0jkdDCHj//xPSFG/hoxXx0uhTp06rF692mg871HGnJycco4yZg4SukIfWX+e5rzfBvXA5S6eEPourO8Cm55XD3ZjS0y1FTZskLZCUf24ENLzHdwmPVUdL4Vu3bqZPG5yWR5lTEJX6MOztvr12i/g3Rj2r1RPtQ5w+wxs7g8J1/Wrz5xMtRXmzIHHH9ennvIo+wPXoo6XkhxlTNgeVy/1683j4OKlnlI9r5Q4iLtm4aLKQGyscVuhZUuYPl2fesorz1rFGy8lOcqYsF2NnlE/QLN3gKw8B6m2s7ONnSRktoJ5PDNX7eHmbTE4uqrjZiRHGRM2K+coYzEX1b5c5RpweG3uHTpOgU6TyvexdLdtg379tGMLF6qtBVF8ZTB7QQ8SukIXOaGrKJAUo+4UcT8BUu6AV13wbQGu5XjvtNhY8PNTzwiRrWVLOHxYtnIrOGkvCP1V8lEvtmTcOG3gGgzSVhCAfJAmhPlt3w5ff60dk9kK4k8SukKYU2wsjBmjHQsMhBkzdClHWB8JXSHMSdoKohASukKYS0FthYAKcFB2UWQSukKYg7QVRBFJ6AphDuPHS1tBFIlMGRP6yN6z6H/LwOMRqPsXqNZI35pK6t//hs2btWOzZ0tbQZgkoSv0cf2w+vWnxepXr7ow+D9QtZ5uJZXInTswerR2LDAQZs7UpRxh/aS9ICwvMRqOrNeOJYRD5EldyikVU7MV5JCN4iEkdIXlZaWpp+bJL//xUq1dQW2FwEBdyhHlg4SusDyPmtD8b9oxByfw9dOnnpK4c8d4tkJAgMxWEIWS0BWWZ28Pjz2vfl+lHtR/GgbvgEfK0bnCxo+HqKjc69mzFZycdCtJlA/yQZrQR/YBbkb+pJ6k0slN33qKY8cO+Oor7disWdJWEEUioSv05VZV7wqKx9RshYAAma0gikzaC0IUh7QVRClJ6ApRVNJWEGYgoStEUUhbQZiJ9HSFvsIPQPIdqFofqjdTT1BpjSZMkLaCMAsJXaGPB4nq1w091K/2BnjlX9C0h341FWTnTvjyS+3YzJnSVhAlIu0FoY+4a9rrWRkQMgHuRepSToHi4uCNN7Rjjz+u9nKFKAEJXWF5WVmQaCJck6Lg/l3L1/MwMltBmJmErrC86LOQGmc8/mgb8Khh+XoKUlBboWVLfeoRNkFCV1hezHm4vFf93rWK+tXXD7ovAVdP/erKKy7OeLaCtBWEGcgHacLynD3gboT6fcAAcHKHpGjwrKVvXXlNmAC3b+ded3CQtoIwCwldYXm+LcDnMeA4HPpEHev7T6hsJa2F//wH/vUv7Zi0FYSZ2CmKouhdhKh4wnZspNOLQ1FObwGvevCIHzi66l2W2lbw89Nu5bZoAUePylauMAvp6QrLu3kCdk9Xv982HMI+gJR4fWvKJm0FUcYkdIVlpaXCvvdzd44AuLgbbh7Vr6ZsBbUVWrXSpx5hkyR0hWU9uAe3jhmPx/9h+VryMrUTRIsW6ul3hDAjCV1hWW5V1bNGGFzU67XaqF/1PlXP229LW0FYhISusCwHR2g3GgIHqtddq0C/DeAboF9NISHwxRfasRkzpK0gyoSErrC86/vhaJD6/aU98O9RcPukPrXExcGoUdqxFi1gzhx96hE2T0JXWFZKHBxYox3LTIfw/frMYDDVVtiwQdoKosxI6ArLsnfI7efmZWcPmWmWraWgtkLr1patQ1QoErrCslw8oeM72jHnylCzFXj4Wq6O+Hjj2Qr+/jJbQZQ5CV1heQ26QKcp6vdthkOnyerxFyzp7bchMs/hJbNnKzg7W7YOUeHIsReE5SVcg58/UL8/H6Ie7KZyTRgZaplDO4aEwOefa8emT5e2grAI2dIVlpf37BBJ0X+O3VLPlVbWCmoryGwFYSESusLyvEwcwtGrHlSqXvbPPXGitBWEriR0heX5NIMOE3Kvu/vAS5+Wfeh++y1s2qQdk7aCsDA5tKPQRdj/9tHpr51Rwg+CZ23wfLRsnzA+Xm0j3LqVO+bvrx6yUbZyhQXJB2lCH/YO6tc6T1rm+SZO1AZu9k4QErjCwqS9IGyfqbbCtGnQpo0+9YgKTUJX2Lb4eONjK/j5wdy5+tQjKjwJXWHb3nnHuK0gsxWEjiR0he369ls1YPOStoLQmYSusE0JCdJWEFZJQlfYJlOzFaStIKyAhK6wPd99J20FYbUkdIVtSUiAkSO1Y9JWEFZEQlfYFpmtIKychK6wHd99p+5lltfUqdJWEFZFQlfYBlOzFZo3h3nzdClHiIJI6Arb8M47cPNm7nVpKwgrJaEryr///td0W6FtW33qEeIhJHRF+WZqtoK0FYQVk9AV5dukSdq2gr29tBWEVZPQFeXXf/8LQUHaMWkrCCsnoSvKp7t3TbcV5s/XpRwhikpCV5RP+Wcr2NvLmSBEuSChK8qf3btNtxXatdOnHiGKQUJX6Cslvnj3L6itILMVRDkhoSssL/kO/L5L/f6zZ+HsDniQXLTHTpoEERG517PbCi4uZi9TiLIgoSss79IPcHCN+v2dS7BlCEQcLvxxu3fDZ59px6ZMkbaCKFckdIVlpd+HI+uNx7O3fAtiqq3QrJnMVhDljoSusCx7A1SuZTzuUePhjzPVVti4UdoKotyR0BWW5WCA9mPB3jF3zMULmnYv+DHffy9tBWEz7BRFUfQuQlQwikLYjg10emk4yrFNUKstVG9m+r5374K/v3Yrt1kzOH5ctnJFuWTQuwBRAdnZgXdj9ftWgx9+38mTZbaCsCnSXhDW6/vv4Z//1I5NngxPPKFPPUKYgYSusE5378KIEdqxxx6DBQv0qUcIM5HQFdbJVFtBZisIGyChK6zPDz9IW0HYLAldYV2krSBsnISusC5TpsCNG7nXZbaCsDESusJ6/PADrM+3i/CkSfDkk/rUI0QZkNAV1uHePdNthYUL9alHiDIioSusw+TJ0lYQFYKErtCftBVEBSKhK/Rlqq3QtKnMVhA2S0JX6MvUbIWNG8HVVbeShChLErpCN10B1q3TDr7zjrQVhE2T0BW6cEhO5rP8g02bltlshbS0NObMmUPbtm3p0KED6/P3kIUogbS0NJ5//nkOHDhQ5MfIoR2FLup//DGac0Vkz1Yoo7bCsmXLOHHiBBs2bOD27dtMnTqVmjVr0qtXrzJ5PmH7Hjx4wKRJk7h06VKxHidbusLy9uyhRkiIduydd6B9+zJ5upSUFIKDg5k5cyb+/v507dqVESNG8K9//atMnk/YvsuXL9O/f3+uX79e7MdK6ArLKmi2QhnuBHH+/HnS0tJo3bp1zljr1q05c+YMGRkZZfa8onzbsmUL/v7+XLlyBYAbN24QGBjIjh07OHr0KB06dOCbb74p9nKlvSAsa8oUyLt1YGdXpm0FgJiYGDw9PXF2ds4Z8/b2Jj09nbi4OKpXr15mzy3Kr5dffpmQkBAWL15MUFAQc+fOpV27dvTp06dUy5XQFZazd6/p2Qpl1FbIlpqaipOTk2Ys+3paWlqZPrco395991169+7NpEmT+O2339i1a1eplyntBWEZ9+7B8OGaoQsA775b5k/t7OxsFK7Z111lPrB4iLp16zJ69Gh27drF22+/ja+vb6mXKaErLGPqVE1bQbGzYyhYZCcIX19f7t27pwnemJgYnJyc8PT0LPPnF+Xb+fPncXBw4PDhw2ZZnoSuKHt798LatZqhm/37c9BCT9+sWTMcHR05ceJEztixY8fw8/PDYJAOmyhYaGgo+/btY+3atYSGhrJ3795SL1NCV5StxESjtgJNmhCefwZDGXJ1daVPnz4sWLCA06dP8+OPPxIUFMTgwYWc/l1UaElJSSxcuJBRo0bRsWNHhg8fzsKFC0lKSirVciV0RdkqYLZCVp6ZBJYwY8YMWrRowZAhQ5g3bx5vvvkmPXv2tGgNonxZsWIFBoOBkSNHAjBmzBgMBgPLly8v1XLtFEVRzFGgEEb27oVnn9WOvfMOfPghYWFhdOrUCfnxExWNbOmKspGYaLwTRJMmsGiRPvUIYSUkdEXZmDoVwsNzr9vZQVCQHLJRVHgSusL8fvwRPv1UO/b229Chgy7lCGFNJHSFeZmardC4sbQVhPiThK4wL1NthQ0bwM1Nv5qEsCISusJ8pK0gRKEkdIV5SFtBiCKR0BXmUdBsBWkrCKEhoStKz1RbYcIEeOopfeoRwopJ6IrSMdVWaNQIFi8u0sOzsmSPNFGxSOiK0pk2rdizFW7Ep7DjxE0AFoac43zkvbKuUgirIaErSi40FD75RDs2fvxD2wqpaZl8sPsCXx5Wg3rjwWv8feOv3IxPKctKhbAaErqiZBITYdgw7VijRvDeew992PW4FP5z6pZm7PbdB1yMKt3h8oQoLyR0RcmYaisUYbaCg70dDvZ2RuOODsZjQtgiCV1RfAW1FTp2LPShdau6MaxDPc2YX43KNPH1MGOBQlgvOZ6uKJ6kJGjRAq5dyx1r1AhOnSrynNyYxPsEbf0v04e9xKYDf/B0Yx/qeruXTb1CWBk5QZQonmnTtIFbgp0gfDxcaFO/CgB9AmtS2dWpkEcIYTukvSCKLjQUPv5YO1bEtkJeZ2/dZecJ9cO0EZuO8tP5aDJlvq6oICR0RdEkJRnvBNGwYaGzFfKLS35AyKlbBB+9AcCv1+IZ8flRjl6LM1elQlg1CV1RNKbaCiU4ZGNEXCo7TminjGVmKZyKSCh9jUKUAxK6onA//WSWtgKAk8GeSi7GHyW4O8nHC6JikNAVD1dQW6GIx1bIr563GyOeqq8Z867kROu6VUpaoRDlioSueLjp0+GPP3KvZ7cV3Es2xcvF0UCXZj5M7f4YADN7NmPj0HY8VqOyOaoVwurJ/3SiYPv2wUcfacfGjStRWyGv6h6utK1XFYBRnRqUallClDeypStMS0oyPrZCCWYrCCG0JHSFaTNmaNsKoO4EUcK2ghBCJaErjO3bB2vWaMfGj4dOnXQpRwhbIqErtJKTpa0gRBmS0BVa+WcrgLQVhDAjCV2R63//M24rjBsnbQUhzEhCV6hMtRUaNID339enHiFslISuUM2YAVevasekrSCE2UnoCrWtsHq1dmzcOHj6aX3qEcKGSehWdNJWEMKiJHQrOmkrCGFREroVmbQVhLA4Cd2KStoKQuhCQreimjlT2gpC6EBCtyL6+WdYtUo79tZb0lYQwgIkdCuagtoKS5boU48QFYyEbkUzcyZcuaId++wzaSsIYSESuhVJQW2Fv/5Vl3KEqIgkdCsKU22F+vVltoIQFiahW1HMmmXcVggKgkqV9KlHiApKQrciCAszbiu8+aa0FYTQgYSurUtJgaFDQVFyx+rXl9kKQuhEQtfWmZqtIG0FIXQjoWvLpK0ghNWR0LVVKSnqbAVpKwhhVSR0bdWsWXD5snbss8+spq2QmZkFQFaWUsg9hbAtErq2KCwMVq7Ujo0dC50761NPPhduJ7IuTD3j8OLvfudqTJLOFQlhORK6tsZUW6FePVi6VLeS8rp9N5Xhm44Qej4KgM9++YPJW06RkJKmc2VCWIaErq0x1VawotkKV2OTiYhP1Ywdv55A+J0UnSoSwrIkdG3JL79YdVsBwMnB+EfOzg6cDHY6VCOE5Uno2gpTO0FYUVshW+PqlXimWXXN2OtP1KG+txzlTFQMBr0LEGYye7ZVz1bI5unmxLt/86dh5g1mfQWfvNaKNvWq4OIoP4qiYpCfdFvwyy/wf/+nHRszBrp00aWcwtT0cqVd/aoAPNOsOk4GB50rEsJypL1Q3hU0W2HZMt1KKsxvN+/yf3suAjBz+xkuRyfqXJEQliOhW97Nng2XLmnHrLCtkC0iPoW/b/iVo+HxAGw9fpN3gk/KlDFRYUjolmf795ertgLAH7HJxCZpA/Z0xD2ux8mUMVExSOiWV6ZmK9Sta3WzFfJzczTu3zrY2+FiYlwIWyShW17NmWPcVggKAg8PfeopokbVPXj+8RqasTFPN6BeNTedKhLCsuwURZEjjpQ3+/dDx47ardzRo+GTT/SrqRii7t3nXzt2M3nIi/x0PoqA2l5UcXPSuywhLEJCt7xJTYWAAO1Wbt26cOaM1W/l5hUWFkanTp2QHz9R0Uh7obwpaLZCOQpcISoyCd3y5MABWLFCOzZ6NDzzjD71lFD4nWS2H48A4MMfLsihHUWFIqFbXqSmmp6tYMU7QZhyLzWd2Tt+Y/Ov1wFYHXqZt746TmziA50rE8IyJHTLizlz4OJF7Vg5bCv8EZtM2KVYzdi5yESuyNauqCAkdMuDAwfgH//Qjr3xRrlrK4A6J9cU+wLGhbA1ErrWzlRboU4d+OAD/WoqhfrV3I3m6T5ZvyqNfKxzt2UhzE2OMmbtbKStkM3dxcCMHs3wTrrKgq/g3b/58XTT6lRxl3m6omKQebrW7MABeOop7VbuG2/Ap5/qV5OZyDxdUVFJe8FaFdRWKGezFUwJv5PMD2dvAxBy6hYxifd1rkgIy5HQtVZz55puK1SurE89ZhKdeJ9xm0+wPuwqAOM2n+CTfVd4kJGpc2VCWIaErjU6eBA+/FA7NmoUdO2qTz1mdCkqidMRd8merGBnB5sOhnNdzgYsKggJXWtjY7MV8svIzOKlVo/Sr01tACZ2bcKzzX3JzJLerqgYJHStzdy5cOGCduyf/yz3bYVsdau5czclneAjNwD4x56LeLoaqOHponNlQliGhK41OXjQeCeIUaPg2Wf1qacMxCWn8eP5aM1Y8NEIbt2VD9NExSChay2y2wpZWbljNtRWyHY3Nd1oTFEgJS1Dh2qEsDwJXWsxb55NtxWyuTs5GLUSmvp64O4k++mIikF+0q3BoUPGsxVGjrSptkK29CyFOb2acb5WIpO+gqAhbYhKvF/gMRmEsDWypau31FT4+9+1bYXatWH5ct1KKku1q7oQm5TGmh+vADBrx29UdXOmjpwjTVQQErp6qyBthWwRcalsPx7B84HqQW/6t6nNJ/suyYHMRYUhoaungtoKzz2nTz0WcDc1nb8+5kNGpjov9356Jn1a1iIuOU3nyoSwDAldvdy/bzxbwYbbCtmquDriYnDg5wsxAOw6fQtHB3u8XOUoY6L8ysjIICoqqkj3ldDVy7x5cP68dmz9epttK2TLUCA5LZM29aoA0DugJldjkkjP+8dHiHJm5cqVPPnkkzx4UPhppyR09XDokPEW7YgR0K2bPvVYUJYC352JZPefRxn79H9XiUi4T2amhK4ovwICArh27RqLFi0q9L4SupZWUFshf2/XRiXeT+dKTLJm7Idzt0nLkGMviPKrZcuWACxfvpzff//9ofeV0LW0CtpWKIydTNMV5Vi1atXw9vbmwYMHDBw4kKyHtcuUAly+fFkB5GLGSztQMtS9XnMu66ygLrnIRS7mu7i5uSnBwcEFRatS4Ol60tLSmDdvHnfu3DF1sxCldu/ePSpX8C18YTvWr18PgKurK7/++iv+/v4m7yfnSBNCiFLKysrCzU3dq3LChAksXbq0wPtK6AohRCldvHiRpk2bUqtWLS5duoSLS8HHh5YP0oQQopSOHz8OwJdffvnQwAUJXSGEKDV3d3fefvttOnXqVOh9JXTNJDw8nMcff5yMDOODce/cuZNXX331oY9XFIUVK1bQvn172rZty9KlS8nMzD1D7okTJ+jfvz8BAQF069aNHTt2aB4fHR1NtxLsXKEoCsOGDWPLli3FfmxRFLReDh06RO/evQkICGDQoEGEh4cXuIzjx4/TtGlTzeVvf/tbzu0JCQmMHz+eVq1a0aVLF/79739rHl/cdXPnzh0mTZrEk08+Sfv27ZkxYwb37t0r8uNLIzw8nICAAA4fPmzy9sOHDxuti+zLkSNHjO4/bNgwpk+fbtYai/PeVRS9e/dmxYoVRbqvhK4ZREZG8sYbb5jcBfDQoUPMmzev0GVs3LiR7du3s3LlStasWcOuXbv47LPPAIiLi2PUqFG0b9+eXbt2MWbMGGbPns3Ro0cBWLZsGd999x2Ojo6sWrWqyAGalZXFokWL2L9/fzFebdEVtF4iIyMZM2YML7zwAtu2bcPb25uxY8cWOLfxypUr+Pv788svv+RcNm7cmHP79OnTSUhIYPPmzYwdO5a5c+fm/LtXknUzadIkoqKi2LBhA+vWrePixYvMmjWr5CuiiBRFYfbs2dy/X/Cpi1q2bKlZD7/88gudO3cmMDAwZ4J+tq1bt5r9vS3ueyeMSeiW0t69e3nppZdwcjI+YMuaNWsYOXIktWvXLnQ5mzZtYvz48bRr144nnniCyZMn8+WXXwJw69YtunbtysSJE6lduzZ9+vShcePGOaHbpUsXTpw4waVLl8jMzKRVq1aFPl9UVBRDhgwhNDS0WNO2Bg0axPbt2wu938PWS3BwMI899hgjR46kUaNGvPfee0RGRnLo0CGTy7p8+TKNGzfGx8cn51KlinrshuvXr/PTTz/x7rvv0rRpU/r168cLL7zAV199BRR/3dy+fZuDBw+ycOFCmjVrRosWLZg1axZ79+4lNTXVLOumIJs3b9b8d2OKk5OTZj389ttv7N+/nw8++ACDIfecBNHR0axYsYIWLVqUuB5TivveCWMSuqUUFhbGxIkTTW4J/frrrwQFBfFcIYdqjIqKIjIykjZt2uSMtW7dmtu3bxMZGYm/vz/vv/8+oG6dhoaG8scff9CuXTsAGjRowNmzZxk3bhwnTpygbt26HDx4kKZNm3Lw4EFAnRP71FNPsWbNGgDOnTtHnTp12LZtGx4eHmZZF3k9bL2cOnWKtm3b5lx3dXXFz8+PEydOmFzW5cuXqV+/vsnbTp06hY+PD3Xr1s0Za926NSdPngSKv24qVarEunXrqFevXs7y7OzsyMrKIi2t7A4/GRkZyZo1a3j33XeL/JjMzEyWL1/O4MGDqVOnjua2+fPnM3DgQM3rMGXQoEEmWxVdunQxef/ivnfCmJyup5QWLFgAYLIH9/nnnwMUuhUQE6Me5rB69eo5Y97e3oC65VWjhnrA7/v379O6dWsyMjIYMGBAzlabm5sbM2fOpHPnzjRo0ACDwUD79u156aWXWLRoETt37mTp0qVUq1aNN954A4DOnTvTuXPn0rz0h3rYeomJidG8VlB3oyzo0HhXrlzB1dWV559/nqSkJDp16sSUKVPw8PAocFm3b6sH1CnuunF0dOTpp5/WLO/zzz+nSZMmeHp6lnh9FGbu3LkMGTJE88ejMHv27CEiIoIRI0Zoxr/77jtu3LjBypUrmTFjxkOXsXr1atLTjU8W6uDgYPL+xX3vhDEJXSuQ3cPL+6949vd5t67s7OwIDg7mypUrLFiwgHr16jF06FBcXFxytkx69uyZc/9p06bRs2dPpk2bxvfff8+WLVtwdHQsdn2ffvopa9euzan15MmTOVtk3377LTVr1izW8lJTU43aDk5OTia3JJOTk4mMjKR58+YsWbKEhIQElixZwqRJk1i3bl2By0pPT0dRlFKvm40bN7J79+6c/np+5lg3O3bsIDo6muHDhxd637y+/vpr+vTpk9NqAYiPj+e9997jo48+KtJ77eXlVaznLM57J0yT0C2ivL9coO7yl7cdUBp5Azb7FyX7h9jV1TXnfs7Ozvj5+eHn58ft27f54osvGDp0aIHL9fLyYtq0aUydOpXhw4fTrFmzEtU3YMAAevToAcDkyZN57rnnclom+bd6isLZ2dnolzQtLc1kALi7u3PkyBHc3d1ztr6WLFlC3759uXXrVoHLcnFxwe4hR9EpyroJCgpi2bJlzJkzh7/85S8ml1PcdTNixAiOHTuWc33Pnj0sXbqUdevWYTAYTM5+MSUuLo7Dhw8zYcIEzfiiRYvo3r07AQEBRVpO/nqy1axZk2+//dZovDjvnTBNQreI8v5yAfj6+ppt2dnLio2Nxd3dHchtOfj4+BAeHs7Nmzc1v/gNGzYkPj6+0GWfP38eBwcHjhw5QlZWFvb2xW/je3l55fxSubi4UK1atWL9G5yfr69vzuvLFhsbS+PGjU3eP/8HfQ0bNgTUXrivry+xsbFGy/Lx8Sm0joetm1WrVvHRRx8xe/ZsXnvttQKXUdx1s3jxYs3shLCwMOLj4xk8eLDmfiNHjmTs2LGMHj3a5HLCwsLw9vYmMDBQM75r1y5cXFzYtm0bkPvH+8yZMyZDNH892fJ+KJdXcd87YUxCt4jy/nKZm6+vLzVr1uTYsWM5v7DHjh2jevXq1KhRgy1btvDhhx/y888/52wVnz17lgYNGjx0uefOneOLL75gzZo1zJgxgy+++IIhQ4aUyWsojoCAgJyZF6D+y3ru3DnGjBljdN/Tp08zZMgQdu/enfPH6dy5czg4OFC3bl28vb2JiooiIiKCWrVqAeq6K2xL72HrZtOmTXz88ccsXLiQV155xVwvGzD+Y12tWjXNjIrMzEx69OjBokWLHjrR/tSpU7Rp08Zoa/6HH37QXF+6dCkODg4FztUt7sZDcd47UYACjz8miuXQoUNKkyZNlPT0dKPbVq1apQwYMEAzlpSUpNy5cyfn+tq1a5UOHTooBw4cUA4fPqx07NhRWbdunaIoipKQkKB06NBBmT59unL16lVlx44dSmBgoLJnz54C68nIyFBefPFFZfr06YqiKEpwcLASGBio3Lx50+i+nTt3fuih6ErD1Hq5ceOG0qJFC+Xjjz9WLl26pEycOFHp1auXkpmZqSiKdt08ePBA6datmzJ8+HDl4sWLyq+//qp0795dmT17ds7yhg0bpgwcOFD5/fffla1btyr+/v7K8ePHC6zpYevm5s2bir+/vzJ//nwlOjpac8nIyCiLVaSRnp6uNGnSRDl06FDOWP6fFUVRlNdff11Zs2ZNocubNGmSMm3aNLPVV9h7JwonU8Z0EhQURL9+/XKuDx8+nOeff57x48czbtw4evXqlfPBiqenJ0FBQURERPDiiy+yatUqZs6cSdeuXQtc/qZNm7hx4wZTpkwBoF+/fjRp0oT58+eX6esqilq1arF69Wp27txJ3759iY2N5eOPP8759z7vunFycmL9+vUYDAZeffVV3nrrLTp06MCcOXNylrds2TI8PDzo378/H330EYsWLTLaUSCvh62b0NBQ0tLS+Oqrr3jqqac0l4iIiDJcKwXL/7MC6r/0evRRC3vvROHkKGNCCGFB8udJCCEsSEJXCCEsSEJXCCEsSEJXCCEsSEJXCCEsSEJXCCEsSEJXCCEsSEJXCCEs6P8BSZQITLlfDlgAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from support import plot_hyperplane\n",
    "\n",
    "# Perform forward path only with two layers \n",
    "y1, z1 = layer_forward_path(X_train, weights[0], biases[0], act_f=sigmoid)\n",
    "y2, z2 = layer_forward_path(y1, weights[1], biases[1], act_f=sigmoid)\n",
    "\n",
    "# Plot the output of second layer \n",
    "ax = sns.scatterplot(\n",
    "    x=y2[:, 0], y=y2[:, 1], hue=y_train)\n",
    "# Plot the weights of the last layer as for the perceptron example\n",
    "plot_hyperplane(ax, w1=weights[2][0].item(),\n",
    "                w2=weights[2][1].item(), b=biases[2].item(),\n",
    "                label=True, xlim=(-1, 1.2), ylim=(0, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As in the case of the perceptron, the last neuron is linearly separating the data. The previous layers just learned how to make the problem simpler. It is easy to see that trained MLP is transforming the data to perform an easy linear separation as the last step."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cirle data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No handles with labels found to put in legend.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'Test'}>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from support import make_circle_dataset\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X, y = make_circle_dataset(400, r=3.)\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25) \n",
    "\n",
    "fig, ax = plt.subplots(1,2, figsize=(10,5))\n",
    "plot_dataset_2d(X_train, y_train, ax=ax[0], title='Train')\n",
    "plot_dataset_2d(X_test, y_test, ax=ax[1], title='Test')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "pycharm": {
     "is_executing": false
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weights shapes: [(2, 4), (4, 2), (2, 1)]\n",
      "Biases shapes: [(4,), (2,), (1,)]\n"
     ]
    }
   ],
   "source": [
    "# Lets setup the network architecture\n",
    "n_layers = [4, 2, 1] # we don`t need to specify input layer since we are going to infer it from the data\n",
    "\n",
    "# Lists to store our weights and biases\n",
    "weights = []\n",
    "biases = []\n",
    "\n",
    "# Input dimension of the network.\n",
    "input_dim = X.shape[-1]\n",
    "current_input_dim = input_dim\n",
    "\n",
    "for layer_size in n_layers:\n",
    "#   size (shape) of the current layer\n",
    "    size = (current_input_dim, layer_size)\n",
    "    \n",
    "#   Initialize weights randomly\n",
    "    W = np.random.normal(loc=0.0, scale=0.5, size=size)\n",
    "    weights.append(W)\n",
    "#   Initialize biases with zeros\n",
    "    b = np.zeros(layer_size)\n",
    "    biases.append(b)\n",
    "    \n",
    "#   save the size of the previous layer\n",
    "    current_input_dim = layer_size\n",
    "\n",
    "print('Weights shapes:', [x.shape for x in weights])\n",
    "print('Biases shapes:', [x.shape for x in biases])\n",
    "history = {'loss': [], 'acc':[], 'val_acc': []}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "epochs = 200\n",
    "learning_rate = 0.1\n",
    "\n",
    "for epoch in range(epochs):\n",
    "\n",
    "    loss = mlp_train_epoch(X_train, y_train,\n",
    "                                weigths=weights,\n",
    "                                biases=biases,\n",
    "                                act_f=sigmoid,\n",
    "                                grad_act_f=grad_sigmoid,\n",
    "                                lr=learning_rate)\n",
    "    history['loss'].append(loss)\n",
    "\n",
    "    # Compute metrics\n",
    "    y_pred = mlp_forward_path(X_train, act_f=sigmoid, weights=weights, biases=biases)\n",
    "    acc = binary_accuracy(y_train, y_pred)\n",
    "    history['acc'].append(acc)\n",
    "    \n",
    "    # Evaluate test set\n",
    "    val_y_pred = mlp_forward_path(X_test, act_f=sigmoid, weights=weights, biases=biases)\n",
    "    val_acc = binary_accuracy(y_test, np.round(val_y_pred))\n",
    "    history['val_acc'].append(val_acc)\n",
    "    \n",
    "#   Uncomment the following lines to see how the performance of the network at each epoch\n",
    "    # print('MSE train loss: {:.2f}'.format(loss))\n",
    "    # print('Test accuracy: {:.2f}%'.format(100 * binary_accuracy(y_train, y_predicted)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "pycharm": {
     "is_executing": false
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_elements(history, elems=['loss', 'acc', 'val_acc'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from support import plot_hyperplane\n",
    "\n",
    "# Perform forward path only with two layers \n",
    "y1, z1 = layer_forward_path(X_train, weights[0], biases[0], act_f=sigmoid)\n",
    "y2, z2 = layer_forward_path(y1, weights[1], biases[1], act_f=sigmoid)\n",
    "\n",
    "# Plot the output of second layer \n",
    "ax = sns.scatterplot(x=y2[:, 0], y=y2[:, 1], hue=y_train)\n",
    "# Plot the weights of the last layer as for the perceptron example\n",
    "plot_hyperplane(ax, w1=weights[2][0].item(),\n",
    "                w2=weights[2][1].item(), b=biases[2].item(),\n",
    "                label=True, xlim=(-1, 1.2), ylim=(-0.1, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Putting Everything together.\n",
    "In this notebook we have shown how to create a Multi-Layer Perceptron with Python and NumPy. In the following cell we have put everything together in a class. The weights and biases are being initialized by a constructor of the class `__init__()`. Now you can add layers manually, specify activation functions for the layers or even define your own loss losses. You can train the model by calling `fit()` method on the data. Go ahead and experiment with it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "def binary_accuracy(y_true, y_pred):\n",
    "    accuracy = np.mean(1 - np.abs(y_pred.flatten() - y_true.flatten()))\n",
    "    return accuracy\n",
    "\n",
    "def mse_loss(y, y_pred):\n",
    "    return np.mean((y - y_pred) ** 2) / 2\n",
    "\n",
    "def grad_mse_loss(y, y_pred):\n",
    "    return -np.mean(y - y_pred)\n",
    "\n",
    "def sigmoid(z):\n",
    "    return 1 / (1 + np.exp(-z))\n",
    "\n",
    "def grad_sigmoid(z):\n",
    "    return sigmoid(z) * (1 - sigmoid(z))\n",
    "\n",
    "def tanh(z):\n",
    "    return (np.exp(z) - np.exp(-z)) / (np.exp(z) + np.exp(-z))\n",
    "    \n",
    "def grad_tanh(z):\n",
    "    return (1 - tanh(z)**2) \n",
    "\n",
    "LOSSES = {\n",
    "    'mse': (mse_loss, grad_mse_loss)\n",
    "}\n",
    "\n",
    "ACTIVATION_FUNCTIONS = {\n",
    "    'sigmoid': (sigmoid, grad_sigmoid),\n",
    "    'tanh': (tanh, grad_tanh)\n",
    "}\n",
    "\n",
    "class Model:\n",
    "    def __init__(self):\n",
    "        self.weights = []\n",
    "        self.biases = []\n",
    "        \n",
    "        self.act_fs = []\n",
    "        self.grad_act_fs = []\n",
    "        self.n_layers = []\n",
    "        \n",
    "        self.loss = None\n",
    "        self.grad_loss = None\n",
    "        \n",
    "        self.learning_rate = 0.01\n",
    "        \n",
    "        self._is_built = False\n",
    "        \n",
    "        self.metrics = {}\n",
    "        \n",
    "        \n",
    "    def add_layer(self, units, act_f='sigmoid'):\n",
    "        \"\"\"\n",
    "        Add a dense layer with a specified number of neurons and activation function\n",
    "        to a model.\n",
    "        \n",
    "        Args:\n",
    "            units (int): Number of neurons in a layer.\n",
    "            act_f (str): Activation function keyword.\n",
    "        Returns None:\n",
    "\n",
    "        \"\"\"\n",
    "        self.n_layers.append(units)\n",
    "        \n",
    "        self.act_fs.append(ACTIVATION_FUNCTIONS[act_f][0])\n",
    "        self.grad_act_fs.append(ACTIVATION_FUNCTIONS[act_f][1])\n",
    "    \n",
    "    def build(self, n_features):\n",
    "        \"\"\"\n",
    "        Initialize weights and biases.\n",
    "        \"\"\"\n",
    "        self.n_features = n_features\n",
    "        \n",
    "        current_input_dim = self.n_features\n",
    "        for units in self.n_layers:\n",
    "            size = (current_input_dim, units)\n",
    "            \n",
    "            self.weights.append(np.random.normal(loc=0.0, scale=0.5, size=size))\n",
    "            self.biases.append(np.zeros(shape=(units,)))\n",
    "            \n",
    "            current_input_dim = units\n",
    "        \n",
    "        self._is_built = True\n",
    "            \n",
    "    def compile(self, loss='mse', learning_rate=0.01):\n",
    "        \"\"\"\n",
    "        Add loss and choose learning rate for Stochastic Gradient Descent optimization\n",
    "        Args:\n",
    "            loss(str): keyword\n",
    "        \"\"\"\n",
    "        self.loss = LOSSES[loss][0]\n",
    "        self.grad_loss = LOSSES[loss][1]\n",
    "        self.learning_rate = learning_rate\n",
    "    \n",
    "    def forward_path(self, x, training=False):\n",
    "        \"\"\"\n",
    "        Perform Model inference on a batch\n",
    "        \n",
    "        Args:\n",
    "            x(numpy.ndarray): input batch as matrix with shape (batch_size, num_features)\n",
    "            training(bool): if True alongside with the predictions a cache current inputs is returned\n",
    "            \n",
    "        Returns:\n",
    "            current_y(numpy.ndarray): output of the last layer\n",
    "            cache(dict): dictionary of inputs of all layers thourgh the network for this batch\n",
    "        \"\"\"\n",
    "        if not self._is_built:\n",
    "            self.build(n_features=x.shape[-1])\n",
    "        \n",
    "        cache = {}\n",
    "        current_input = x\n",
    "        for i in range(len(self.n_layers)):\n",
    "            current_z = np.dot(current_input, self.weights[i]) + self.biases[i]\n",
    "            current_y = self.act_fs[i](current_z)\n",
    "            cache[f'z_{i}'] = current_z\n",
    "            cache[f'y_{i}'] = current_y\n",
    "            current_input = current_y\n",
    "        \n",
    "        if training:\n",
    "            return current_y, cache\n",
    "        return current_y\n",
    "    \n",
    "    def train_on_batch(self, x, y):\n",
    "        \"\"\"\n",
    "        Perform a Stochastic Gradient Descent on a mini-batch of data\n",
    "\n",
    "        Args:\n",
    "            x(numpy.ndarray): input batch as matrix with shape (batch_size, num_features)\n",
    "            y(numpy.ndarray): labels batch as vector with shape (batch_size, )\n",
    "        \"\"\"\n",
    "        y_hat, cache = self.forward_path(x, training=True)\n",
    "        \n",
    "        loss = self.loss(y, y_hat)\n",
    "        grad_loss = self.grad_loss(y, y_hat)\n",
    "        \n",
    "        prev_layer_grad = grad_loss\n",
    "        for i in reversed(range(len(self.n_layers))):\n",
    "            # Compute gradient of the activation function with respect to z value\n",
    "            grad_z = prev_layer_grad * self.grad_act_fs[i](cache[f'z_{i}'])\n",
    "\n",
    "            # compute gradient w.r.t. weights and biases\n",
    "            if i == 0: # The y_0 is actually x\n",
    "                grad_weights = np.dot(x.T, grad_z)\n",
    "            else:\n",
    "                grad_weights = np.dot(cache[f'y_{i-1}'].T, grad_z)\n",
    "                \n",
    "            grad_biases = grad_z.mean(axis=0)\n",
    "\n",
    "            # Pass gradient further\n",
    "            # compute d f / d x = d f / d dense * d dense / d x\n",
    "            # where d dense/ d x = weights transposed\n",
    "            prev_layer_grad = np.dot(grad_z, self.weights[i].T)\n",
    "\n",
    "            # Update weights\n",
    "            self.weights[i] -= self.learning_rate * grad_weights\n",
    "            self.biases[i] -= self.learning_rate * grad_biases\n",
    "        return y_hat, loss\n",
    "    \n",
    "    def fit(self, x, y, validation_split=0.2, epochs=50, batch_size=32, history=None):\n",
    "        \"\"\"\n",
    "        Perform network training by randomly sampling a batch from the data\n",
    "        Args:\n",
    "            x(numpy.ndarray): training set (set_size, num_features)\n",
    "            y(numpy.ndarray): labels(set_size, )\n",
    "            validaton_split: if the validation_data is not provided reserve this fraction\n",
    "                             of training set for the validation\n",
    "        Returns:\n",
    "            history(dict): a dictionary with training parameters recorded on epoch basis\n",
    "            \n",
    "        \"\"\"\n",
    "        if history is None:\n",
    "            history = {metric_name: [] for metric_name in ['loss', 'val_loss', 'acc', 'val_acc']}\n",
    "            \n",
    "        X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=validation_split) \n",
    "        \n",
    "        for epoch in range(epochs):\n",
    "            idxs = np.random.choice(np.arange(X_train.shape[0]), size=(batch_size, ))\n",
    "            batch_losses = []\n",
    "            batch_accs = []\n",
    "            for idx in idxs:\n",
    "        #       Sample a batch from the dataset  \n",
    "                X_batch, y_batch = X_train[[idx]], y_train[[idx]]\n",
    "                y_batch_hat, loss = self.train_on_batch(X_batch, y_batch)\n",
    "                batch_losses.append(loss)\n",
    "                batch_accs.append(binary_accuracy(y_batch_hat, y_batch))\n",
    "            \n",
    "            y_hat = self.forward_path(X_val, training=False)\n",
    "            \n",
    "            history['loss'].append(np.mean(batch_losses))\n",
    "            history['val_loss'].append(self.loss(y_batch, y_hat))\n",
    "            history['acc'].append(np.mean(batch_accs))\n",
    "            history['val_acc'].append(binary_accuracy(y_val, self.forward_path(X_val, training=False)))  \n",
    "        return history\n",
    "           "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from support import plot_elements\n",
    "# Create model\n",
    "model = Model()\n",
    "# Add layers with activation functions\n",
    "model.add_layer(units=4, act_f='tanh')\n",
    "model.add_layer(units=2, act_f='tanh')\n",
    "model.add_layer(units=1, act_f='sigmoid')\n",
    "# Add loss and specify learnin rate\n",
    "model.compile(loss='mse', learning_rate=0.1)\n",
    "# Store the history of training process\n",
    "history = {metric_name: [] for metric_name in ['loss', 'val_loss', 'acc', 'val_acc']}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "history = model.fit(X, y, epochs=200, batch_size=32, validation_split=0.2, history=history)       \n",
    "plot_elements(history, elems=['loss','val_loss', 'acc', 'val_acc'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: you can rerun the previous cell if you think that you need more training epochs. The weights are going to be reinitialized only when you create a new model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Questions (optional):\n",
    "    - Try running the model with different number of nodes and layers, how does the performance change?\n",
    "    - Try different batch sizes. How does batch size affect the training?\n",
    "    - Try changing number of epochs and learning rate. How do they affect training?"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.9"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}