05-model-evaluation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%config IPCompleter.greedy=True\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import sklearn.preprocessing, sklearn.datasets, sklearn.model_selection\n",
    "import timeit\n",
    "from progressbar import progressbar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, we have talked just about the models. I have shown you some plots and I tried to explain some phenomena on them. The results have usually seemed to be right, however, I never talked about the evaluation of the models. How to recognize, if the models are learning and performing well. I would like to correct this in this notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss and metric\n",
    "\n",
    "First of all, let's talk about losses and metrices. Loss is the function, that the learning algorithm directly optimize. So far we used mean squared error loss (MSE), that is in the form $\\frac{1}{n} \\sum_{i=0}^{n} \\left( t_i - f(\\pmb{x_i}) \\right)^2$. As $n$ is the constant (we have finite set of examples), optimizing it is the same as optimizing $\\frac{1}{2} \\sum_{i=0}^{n} \\left( t_i - f(\\pmb{x_i}) \\right)^2$. We computed gradient of this value and optimize it directly. Before moving on, let's remind us the `Neuron` class from the last notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Neuron:\n",
    "    def __init__(self, epochs=100, random_state=None, learning_rate=0.001, batch_size=16):\n",
    "        # use epochs instead of iterations\n",
    "        self.epochs = epochs\n",
    "        self.converged = False\n",
    "        self._rand = np.random.RandomState(random_state)\n",
    "        self._weights = None\n",
    "        self._learning_rate = learning_rate\n",
    "        self._batch_size = batch_size\n",
    "        pass\n",
    "    \n",
    "    def _activation(self, vals):  # activation function\n",
    "        return 1 / (1 + np.exp(-vals))\n",
    "    \n",
    "    def fit(self, X, y, Xtest=None, ytest=None):\n",
    "        # Initialize the weights\n",
    "        self.converged = False\n",
    "        self._weights = self._rand.uniform(-2, 2, X.shape[1])\n",
    "        n_data = len(X)\n",
    "        # store gradients and losses\n",
    "        losses = np.zeros((self.epochs,))\n",
    "        gradients = np.zeros((self.epochs, int(np.ceil(X.shape[0] / self._batch_size))))\n",
    "        accuracies = np.zeros((self.epochs,))\n",
    "        # Learning\n",
    "        for epoch in range(self.epochs):\n",
    "            # shuffle the data\n",
    "            permutation = self._rand.permutation(n_data)\n",
    "            # for each batch\n",
    "            for batch_start in range(0, n_data, self._batch_size):\n",
    "                # get batch\n",
    "                batch_data = X[permutation[batch_start:batch_start+self._batch_size]]\n",
    "                batch_target = y[permutation[batch_start:batch_start+self._batch_size]]\n",
    "                # predict the data\n",
    "                prediction = self.predict(batch_data)\n",
    "                # table of gradient for each weights and gradient in the shape (samples,weights)\n",
    "                gradient = np.reshape(-(batch_target - prediction) * (prediction * (1 - prediction)), newshape=(-1,1)) * batch_data\n",
    "                # sum gradient over the samples\n",
    "                op_gradient = self._learning_rate * np.sum(gradient, axis=0)\n",
    "                # store losses and gradients\n",
    "                losses[epoch] += np.sum((batch_target - prediction) ** 2, axis=0)\n",
    "                gradients[epoch, int(batch_start / self._batch_size)] = op_gradient @ op_gradient\n",
    "                # update the weights\n",
    "                self._weights = self._weights - op_gradient\n",
    "                \n",
    "            # compute accuracy on the test set\n",
    "            if Xtest is not None and ytest is not None:\n",
    "                test_prediction = np.where(self.predict(Xtest) < 0.5, 0, 1) \n",
    "                accuracies[epoch] = np.sum(test_prediction == ytest) / len(ytest)\n",
    "                \n",
    "        return losses / X.shape[0], gradients, accuracies\n",
    "    \n",
    "    def predict(self, X):\n",
    "            return self._activation(X @ self._weights)\n",
    "    \n",
    "    def __call__(self, X):\n",
    "        return self.predict(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `fit` method returns losses, gradients, and accuracies over the epochs. As we can see from the code, we compute the gradient for each example and update weights. In the end, the method returns `losses / X.shape[0]`, that is the mean loss over the whole dataset.\n",
    "\n",
    "There is one important point to understand here - loss is independent between the examples. As the loss is the value, that is directly optimized, it should always decrease. If we had only a single example and use this algorithm, it needs to decrease every step (unless the loss is zero). However, as optimizing loss for one example can increase the loss of other examples (and loss is independent for each example), the loss of the whole dataset (mean of losses for each example) can increase.\n",
    "\n",
    "How can we make sure this doesn't happen? We may optimize the dataset loss instead of loss per each example - that is exactly what the batch gradient descent does! Although it still computes the loss for each example, there is only one update, that takes into account all the examples. As such, it optimizes the dataset loss and the loss never increases (as you can see at the end of the previous notebook). As you may guess, using minibatch gradient descent we try to use this property using fewer examples.\n",
    "\n",
    "Through the following notebooks, we are going to see a few more losses. Their usage depends on the task we are doing - for regression tasks (we try to predict continuous value like age, weights, and so on) we use MSE loss. For classification tasks (we try to predict in which class the example is from) we usually use cross-entropy loss function. Note that we were doing just classification so far, and we still used MSE loss. It was good enough for our purposes, but we will talk about cross-entropy soon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's talk about metrics. Metric, unlike loss, is not directly optimized during training. A decrease in loss should result in better metrics. In the last notebook, we have seen accuracy - how many examples are classified correctly. I will use accuracy to demonstrate some interesting aspects.\n",
    "\n",
    "Unlike loss, the metric doesn't need to decrease. Especially for accuracy, the better the model, the higher accuracy you will get. The accuracy should make more sense for you are as a programmer (or as a data scientist) rather than for a computer. It may decrease, increase, oscillate around some value, and so on. It's up to you to interpret it.\n",
    "\n",
    "Secondly, the metric is not independent between examples. Compute accuracy for a subset of the dataset doesn't make much sense. Although we may think about accuracy as the mean of values $0$ (when the prediction was wrong) and $1$ (when the prediction was correct), it doesn't need to be this way. You may see some matrices on the [tensorflow documentation page](https://www.tensorflow.org/api_docs/python/tf/keras/metrics). There are metrics like false positive, hinge, recall, and so on. The important fact is that metric, unlike loss, is some value that is aggregated over the whole dataset, rather than computed independently for each example.\n",
    "\n",
    "And lastly, the metric is optimized indirectly. In our example, we predicted class $0$ if the value was $<0.5$ and $1$ otherwise. Take for example, that our model returned $0.7$ and we corrected it, so it returns $0.6$ (it is the class $0$). In this case, the loss decreased, but the accuracy remained the same, as the prediction is still class $1$, although it has a lower probability. This should demonstrate to you, that not only loss but why the metrics are important as well. Usually, when you have a task in hand, you are not interested in the model loss, but rather in some of it's metrics. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train set, development set, and test set\n",
    "\n",
    "We know what to measure, but we still don't know how to measure it. When we use the whole dataset for training, we don't know the real performance of the model. The problem is overfitting or underfitting, terms that I will explain in a moment. Our goal is not to get the best score on the dataset we use for training, but rather the best score on unseen data - something called **generalization error**. You may imagine it as if the model has a memory - the weights of the neuron can be used as some kind of memory. If the model can remember all the training examples and their respective target value, the error on the training set would be zero. However, when we pass examples that we didn't use for training, the prediction can be completely wrong. The problem is that the model is too much aligned with the training data and do not generalize well.\n",
    "\n",
    "So how to get the real performance of the model? Just use the unseen data to evaluate the performance of the model. Split the dataset into **training set** and **test set**, train the model on the training set and evaluate it on the test set. The ratio is usually something between $0.7:0.3$ to $0.8:0.2$. That is exactly what I did in the previous notebooks if you read the code carefully. I used [`train_test_split`](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html) function from `sklearn.model_selection` namespace. You pass there array you wanna split and ratio."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "data, target = sklearn.datasets.fetch_openml('mnist_784', version=1, return_X_y=True, as_frame=False)\n",
    "train_data, test_data, train_target, test_target = sklearn.model_selection.train_test_split(data, target, test_size=0.25, random_state=47)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "52500 17500\n",
      "52500 17500\n"
     ]
    }
   ],
   "source": [
    "print(len(train_data), len(test_data))\n",
    "print(len(train_target), len(test_target))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have train data and test data and we may measure the performance of the model. There is however one drawback - the model has some parameters, that we need to set up. For us, this can be learning rate, batch size, or number of epochs. These are not parameters that are learned during training but we need to set them up in advance - they are called **hyperparameters**. No one is so skilled that he could guess the parameters correctly, there is usually some experimenting and searching for those parameters. We may use the test set and pick up the combination of hyperparameters, that have the lowest test error. But that brings us back where we were before - how to measure the real performance of the model. We used the test set to set up hyperparameters, so obviously, it's the best model that performs on the test set. But what about unseen data, is it still the case?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What seems to be a good idea is split data into three parts - **training set** that we use for training and we use it to set up trainable parameters (like weights). Then we use **development set** for hyperparameter search - based on the performance on the development set we pick up the best model. Finally, we use **test set** to evaluate the performance of the model on unseen data.\n",
    "\n",
    "This approach has one drawback - we reduced the amount of training data significantly. From the whole dataset, we use only a fraction for the training - usually something between 60% and 70%. Still, it seems this approach has the best performance estimation so far. In a moment I will talk about *K-fold cross validation*, that doesn't use the validation set per se, but is computably much more intensive.\n",
    "\n",
    "There is no build-in function to split data into training, validation, and test set. However, we may use `train_test_split` twice. FOr example to split data in ratio $0.6:0.2:0.2$ we may use the following code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42000 14000 14000\n",
      "42000 14000 14000\n"
     ]
    }
   ],
   "source": [
    "train_data, devtest_data, train_target, devtest_target = sklearn.model_selection.train_test_split(data, target, test_size=0.4, random_state=47)\n",
    "dev_data, test_data, dev_target, test_target = sklearn.model_selection.train_test_split(devtest_data, devtest_target, test_size=0.5, random_state=47)\n",
    "print(len(train_data), len(dev_data), len(test_data))\n",
    "print(len(train_target), len(dev_target), len(test_target))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Underfitting, overfitting and model capacity\n",
    "\n",
    "Now, when we know how to measure the performance of the model, we may talk about underfitting and overfitting. There is something that we call **model capacity** - that is how much the model can remember. If the task at hand is something complicated, we need a model with higher capacity, as it needs to remember more about the problem itself. That is at least from the generic point of view. I will show an example in a minute.\n",
    "\n",
    "When we have a task at hand, how do we know if the model has the correct capacity? And how we even recognize, that we capacity is the right one? We may see two phenomena - underfitting and overfitting. **Underfitting** is the case, when the capacity is too small and the model can't fully learn the problem in hand (or doesn't learn it yet). In this case, the validation error is usually lower than the training error, but the training error is not decreasing any more. The opposite problem is **overfitting** - the capacity of the model is too high and during training, the model is aligned too much to the example data. This is the case when the training error is decreasing whereas the validation error is increasing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The traditional data scientists are using the following picture to demonstrate this phenomenon.\n",
    "\n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/1/1f/Overfitting_svg.svg\" alt=\"Overfitting demonstration\" width=\"600\"/>\n",
    "\n",
    "On the left from the exclamation mark, the model is underfitting, because it still didn't learn enough to predict correctly. On the right side, the model is already overfitting and the development error is increasing. The exclamation mark is at the place, where the development error is the lowest. That is the point during training, from which we should take the model.\n",
    "\n",
    "This approach works better when traditional models are used. In neural networks we have a number of tools on how to decrease or increase the capacity of the model - there are called regularization techniques and we will talk about them extensively later on. I believe it is better to align the model capacity with the problem in hand and properly train the model rather than using snapshot somewhere from the beginning of the training."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is usually one more example, that demonstrates the underfitting and overfitting. Let's say we have some data points and we want to separate them.\n",
    "\n",
    "<img src=\"https://raw.githubusercontent.com/alexeygrigorev/wiki-figures/master/legacy/overfit-dataset.png\" alt=\"Dataset\" width=\"300\"/>\n",
    "\n",
    "We may use different models - linear, quadratic, or polynomial of a higher order. What would be the best separation line?\n",
    "\n",
    "<img src=\"https://raw.githubusercontent.com/alexeygrigorev/wiki-figures/master/ufrt/kddm/overfitting-logreg-ex.png\" alt=\"Dataset separation\" width=\"900\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first model, the linear one, couldn't properly separate the data. The model is underfitting because it doesn't have enough capacity to solve the problem at hand. The quadratic model, the second, separates the data nicely, although there are some red crosses outliers. That is OK, the generalization error itself as probably the best we can get. Finally, the last model is overfitting - it tries too much to predict all the examples correctly and in the end, it remembered that the two outliers (the red crosses) are in the correct class. It was able to learn it as it has enough capacity to remember these two examples directly. As a result, the model is overfitting and the generalization error is probably worse than in the middle case."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As I already said, we will talk about regularization - that is reducing the capacity of the model later on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# K-fold cross-validation\n",
    "\n",
    "There is one approach, that we may use when there is not enough data. We split the data into subsets of the same size (we usually use from 5 to 7 subsets) called folds and always use one fold as a validation set. That mean we will train the model five times if we split data into 5 subsets - also called 5-fold cross-validation. Each model will use different fold as a validation set - that means the first model will use the first fold as a validation set and the rest folds as training sets, the second model will use the second fold as a validation set and rest of them (including the first one) as a training set and so on. We get losses and metrics from each model and average them to get the real score of the model.\n",
    "\n",
    "For k-fold we may use [`sklearn.model_selection.KFold`](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.KFold.html) class from `sklearn` library. Let's demonstrate it. Firstly, I will download the data and preprocess them the same way as in the previous notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, y = sklearn.datasets.fetch_openml('mnist_784', version=1, return_X_y=True, as_frame=False)\n",
    "y = y.astype(int)\n",
    "one_or_seven_indices = np.logical_or(y == 4, y == 9)\n",
    "data = X[one_or_seven_indices].reshape(-1, 784)\n",
    "data[data < 128] = 0\n",
    "data[data > 0] = 1\n",
    "data = np.hstack([data, np.ones((data.shape[0],1))])\n",
    "target = y[one_or_seven_indices].reshape(-1)\n",
    "target[target==4] = 0\n",
    "target[target==9] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's use k-fold cross-validation to obtain the scores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import KFold\n",
    "\n",
    "losses = []\n",
    "accuracies = []\n",
    "\n",
    "for train_indices, test_indices in KFold(n_splits=5, random_state=47, shuffle=True).split(data):\n",
    "    train_data, train_target = data[train_indices], target[train_indices]\n",
    "    test_data, test_target = data[test_indices], target[test_indices]\n",
    "    model = Neuron(epochs=400, random_state=47, learning_rate=0.001, batch_size=64)\n",
    "    loss, _, acc = model.fit(train_data, train_target, test_data, test_target)\n",
    "    losses.append(loss)\n",
    "    accuracies.append(acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have list of losses and accuracies between the folds. Finally, let's plot them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12,8))\n",
    "for l in losses:\n",
    "    plt.plot(l, alpha=0.4, color='blue')\n",
    "plt.plot(np.mean(losses, axis=0), alpha=0.8, color='red')\n",
    "plt.yscale('log')\n",
    "ticks = [0.028, 0.04, 0.056, 0.08, 0.112, 0.16, 0.225, 0.32, 0.45, 0.64]\n",
    "plt.yticks(ticks=ticks, labels=ticks)\n",
    "plt.title('K-fold cross validation loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Loss')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "plt.figure(figsize=(12,8))\n",
    "for a in accuracies:\n",
    "    plt.plot(a, alpha=0.4, color='blue')\n",
    "plt.plot(np.mean(accuracies, axis=0), alpha=0.8, color='red')\n",
    "plt.title('K-fold cross validation accuracy on dev set')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you may see, although some of the runs were better and some worse, by using the mean of all the folds we get quite a good picture of the performance of the algorithm. What is best, we used all the data. We may use K-fold cross-validation to search for hyperparameters and when we found them, we may use all the data to train the model. That means we still need a test set!! By using K-fold cross-validation, we get rid only of the development set, but the final evaluation of the model must be done on data, that the model has never seen in any way (including the indirect one, that we used for hyperparameter search).\n",
    "\n",
    "So that is K-fold cross-validation. As you may guess, there is a huge drawback - we need to train the model five times. This is reasonable in traditional data science, where models don't learn for so long. However, when we will be talking about some of the bigger neural networks, they are usually trained hours, days, some of them even weeks. Train these models multiple times, especially during hyperparameter search, when we need to test some amount of hyperparameter combinations is not reasonable. Because of this, K-fold cross-validation is not usually done with neural networks. I thought it may be good you know about it, in case you don't have much data, but in most of the cases, using the train, dev, and test set is the way to go."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Refactoring\n",
    "\n",
    "Before we move on to the next notebook, let's refactor our class a little bit. When we have our train and test data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, y = sklearn.datasets.fetch_openml('mnist_784', version=1, return_X_y=True, as_frame=False)\n",
    "y = y.astype(int)\n",
    "one_or_seven_indices = np.logical_or(y == 4, y == 9)\n",
    "data = X[one_or_seven_indices].reshape(-1, 784)\n",
    "data[data < 128] = 0\n",
    "data[data > 0] = 1\n",
    "data = np.hstack([data, np.ones((data.shape[0],1))])\n",
    "target = y[one_or_seven_indices].reshape(-1)\n",
    "target[target==4] = 0\n",
    "target[target==9] = 1\n",
    "train_data, test_data, train_target, test_target = sklearn.model_selection.train_test_split(data, target, test_size=0.3, random_state=47)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use separate classes for losses and metrics. We will use this to use different losses or matrices in the following notebooks. The loss will have a method to compute it (`__call__` method) and a method that computes the gradient (`gradient` method). These methods will receive only target values and predicted values as parameters. \n",
    "\n",
    "The metrics are designed the same, but we need to allow them to accumulate the metric over the whole dataset. We will use `__call__` method to update the metric and `summary` method that should return the final metric after the epoch.\n",
    "\n",
    "You can see an example of `MSELoss` and `AccuracyMetric` classes bellow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MSELoss:\n",
    "    def __call__(self, target, predicted):\n",
    "        return np.sum((target - predicted) ** 2, axis=0)\n",
    "    def gradient(self, target, predicted):\n",
    "        return -(target - predicted)\n",
    "\n",
    "class AccuracyMetric:\n",
    "    def __init__(self, name=None):\n",
    "        self.name = name or \"accuracy\"\n",
    "        self.correct = 0\n",
    "        self.num = 0\n",
    "    def __call__(self, target, predicted):\n",
    "        self.correct += np.sum((predicted >= 0.5) & (target == 1)) + np.sum((predicted < 0.5) & (target == 0))\n",
    "        self.num += len(target)\n",
    "    def summary(self):\n",
    "        acc = self.correct / self.num\n",
    "        self.correct = 0\n",
    "        self.num = 0\n",
    "        return acc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let's refactor our `Neuron` class. We pass loss and metrics list as parameters to the constructor. We will calculate loss and metrics for both train and test set (when provided) and return them from the `fit` method in a dictionary. Moreover, I will allow logging progress of the training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Neuron:\n",
    "    def __init__(self, loss, metrices=[], epochs=100, random_state=None, learning_rate=0.001, batch_size=16):\n",
    "        self.epochs = epochs\n",
    "        self.loss = loss\n",
    "        self.metrices = metrices\n",
    "        self._rand = np.random.RandomState(random_state)\n",
    "        self._weights = None\n",
    "        self._learning_rate = learning_rate\n",
    "        self._batch_size = batch_size\n",
    "        pass\n",
    "    \n",
    "    def _activation(self, vals):  # activation function\n",
    "        return 1 / (1 + np.exp(-vals))\n",
    "    \n",
    "    def fit(self, X, y, Xtest=None, ytest=None, progress=False):\n",
    "        # Initialize the weights\n",
    "        self._weights = self._rand.uniform(-2, 2, X.shape[1])\n",
    "        # get how many data we have\n",
    "        n_train_data = len(X)\n",
    "        n_test_data = 1 if ytest is None else len(ytest)\n",
    "        # store gradients and losses\n",
    "        train_losses = np.zeros((self.epochs,))\n",
    "        test_losses = np.zeros((self.epochs,))\n",
    "        train_metrices = np.zeros((len(self.metrices), self.epochs))\n",
    "        test_metrices = np.zeros((len(self.metrices), self.epochs))\n",
    "        # decide whatever to log progress\n",
    "        epoch_counter = progressbar(range(self.epochs)) if progress else range(self.epochs)\n",
    "        # Learning\n",
    "        for epoch in epoch_counter:\n",
    "            # shuffle the data\n",
    "            permutation = self._rand.permutation(n_train_data)\n",
    "            # for each batch\n",
    "            for batch_start in range(0, n_train_data, self._batch_size):\n",
    "                # get batch\n",
    "                batch_data = X[permutation[batch_start:batch_start+self._batch_size]]\n",
    "                batch_target = y[permutation[batch_start:batch_start+self._batch_size]]\n",
    "                # predict the data\n",
    "                prediction = self.predict(batch_data)\n",
    "                # table of gradient for each weights and gradient in the shape (samples,weights)\n",
    "                gradient = np.reshape(self.loss.gradient(batch_target, prediction) * (prediction * (1 - prediction)), newshape=(-1,1)) * batch_data\n",
    "                # sum gradient over the samples\n",
    "                op_gradient = self._learning_rate * np.sum(gradient, axis=0)\n",
    "                # store loss\n",
    "                train_losses[epoch] += self.loss(batch_target, prediction)\n",
    "                # update the weights\n",
    "                self._weights = self._weights - op_gradient\n",
    "                # transform probs to predictions\n",
    "                prediction[prediction < 0.5] = 0\n",
    "                prediction[prediction >= 0.5] = 1\n",
    "                # compute the metrices\n",
    "                for metric in self.metrices:\n",
    "                    metric(batch_target, prediction)\n",
    "            # store train metrices\n",
    "            for num_metric, metric in enumerate(self.metrices):\n",
    "                train_metrices[num_metric, epoch] = metric.summary()\n",
    "                \n",
    "            # evaluate on the test set\n",
    "            if Xtest is not None and ytest is not None:\n",
    "                # for each batch\n",
    "                for batch_start in range(0, n_test_data, self._batch_size):\n",
    "                    # get batch\n",
    "                    batch_data = Xtest[batch_start:batch_start+self._batch_size]\n",
    "                    batch_target = ytest[batch_start:batch_start+self._batch_size]\n",
    "                    # predict the data\n",
    "                    prediction = self.predict(batch_data)\n",
    "                    # store loss\n",
    "                    test_losses[epoch] += self.loss(batch_target, prediction)\n",
    "                    # transform probs to predictions\n",
    "                    prediction[prediction < 0.5] = 0\n",
    "                    prediction[prediction >= 0.5] = 1\n",
    "                    # compute the metrices\n",
    "                    for metric in self.metrices:\n",
    "                        metric(batch_target, prediction)\n",
    "                # store test metrices\n",
    "                for num_metric, metric in enumerate(self.metrices):\n",
    "                    test_metrices[num_metric, epoch] = metric.summary()\n",
    "          \n",
    "        results = {\n",
    "            \"train_loss\": train_losses / n_train_data, \n",
    "            \"test_loss\": test_losses / n_test_data,      \n",
    "        }\n",
    "        results.update({f\"train_{metric.name}\": train_metrices[num_metric] for num_metric in range(len(self.metrices))})\n",
    "        results.update({f\"test_{metric.name}\": test_metrices[num_metric] for num_metric in range(len(self.metrices))})\n",
    "        return results\n",
    "    \n",
    "    def predict(self, X):\n",
    "        return self._activation(X @ self._weights)\n",
    "        \n",
    "    def predict_classes(self, X):\n",
    "        prediction = self.predict(X)\n",
    "        prediction[prediction < 0.5] = 0\n",
    "        prediction[prediction >= 0.5] = 1\n",
    "    \n",
    "    def __call__(self, X):\n",
    "        return self.predict(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try to use the modified class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100% (1000 of 1000) |####################| Elapsed Time: 0:00:52 Time:  0:00:52\n"
     ]
    }
   ],
   "source": [
    "model = Neuron(loss=MSELoss(), metrices=[AccuracyMetric()], epochs=1000, random_state=47, learning_rate=0.001, batch_size=64)\n",
    "results = model.fit(train_data, train_target, test_data, test_target, progress=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let's plot the reults."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12,8))\n",
    "plt.plot(results['train_loss'], label=\"Train loss\")\n",
    "plt.plot(results['test_loss'], label=\"Test loss\")\n",
    "plt.yscale('log')\n",
    "ticks = [0.028, 0.04, 0.056, 0.08, 0.112, 0.16, 0.225, 0.32, 0.45, 0.64]\n",
    "plt.yticks(ticks=ticks, labels=ticks)\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "plt.figure(figsize=(12,8))\n",
    "plt.plot(results['train_accuracy'], label=\"Train accuracy\")\n",
    "plt.plot(results['test_accuracy'], label=\"Test accuracy\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What we may see? The method is not overfitting, as the test loss is not increasing. However, the test loss and test accuracy is worse compare to training ones. We should probably increase the capacity of the model and use regularization, which doesn't degrade its' capacity. I will show you how to do it later on."
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}