05-model-evaluation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "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": 3,
   "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": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "data, target = sklearn.datasets.fetch_openml('mnist_784', version=1, return_X_y=True)\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": 5,
   "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": 6,
   "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": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, y = sklearn.datasets.fetch_openml('mnist_784', version=1, return_X_y=True)\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": 8,
   "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": 9,
   "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": "iVBORw0KGgoAAAANSUhEUgAAAtAAAAHwCAYAAACPE1g3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdeXhkV33n//e5tUkllXa13PvqXry1sdsLBoxtbGwwmwPDGAiQEEIWGJgkA+RHyITkl40hy4RJZgIBhgBhCctkEgwYY4L3pdsbbne3e3e3elGrtUulUm1n/vjWdZXUUrfUbrW2z+t56lGp6lbdU7dKqk+d+p5znPceERERERGZnGCmGyAiIiIiMpcoQIuIiIiITIECtIiIiIjIFChAi4iIiIhMgQK0iIiIiMgUKECLiIiIiEyBArSIjMs5t9g596BzbsA59+kzbHuzc+7gaa7/mnPuU+e6jbOJc+79zrmflc5HnHODzrkVZ9r2LPf1Y+fcu8729jJ9nHN/7Jz78ky3Q0SmlwK0yALhnDvonLu54vc7nXM9zrlXT3CTXweOAnXe+4+fl0bOE977gve+1nt/6KXe13iBzHv/Wu/9P73U+5b5zTkXdc5559yqmW6LyHyjAC2yADnn3gv8HXC79/6+CTZbCezws2S1JedcdKbbINNLz7GIzBUK0CILjHPuA8BfArd67x+eYJuvAu8CPlEqRbjBOVflnPusc+6Yc+6Ic+6vnHPxCW5/pXPu6VL5xzeAxBna9GvOuV2l7bc75zaXLm93zn3UOfcskC5ddrFz7j7nXK9z7lnn3O0V9/MG59zO0v20O+d+q3T5IufcD0q36XbO3T9BO77gnPvzMZfd5Zz7cOn8J51z+0v3/5xz7k0T3M+onj/nXKtz7vvOuX7n3KPA6jHb/22pvf3Oua3OuevCxwN8DHhX6Xl4onT5g865XyqdD5xz/9U594Jz7oRz7svOubrSdetK7XhP6f47nXO/e5rn4U0Vz9sh59zvj7n+eufco865PufcYefcu0uXJ51zf126TZ9z7n7nXGK80p5SO24onf9j59y3nHPfcM4NAL/onHt5aR+9pdfaZ51zsYrbX+qc+0npeTzunPuYc26pcy7tnGuo2O6a0vWnhPLTvZbDNpfut9M5d9Q5957THLM1zrkHSsfsbqB5zPWvqHg8Tzvnri9d/oul10Llth91zn1vgv38SqldA6XX4J0V173f2d9Pj3Puh8655aWrwtf5c6XXz1snehwiMkXee5100mkBnICDwHeBDmDzJLb/GvCpit//FHgYaAUWAY8Bf1C67mbgYOl8AmgHPgzEgDuBXOV9jdnPO4DDwJWAA9YDy0vXtQNPAMuAaiAOHMBCZay030FgXWn7TuC60vkm4IrS+c8Af1u6TRx49QRtual0nFzp92ZgGGgr/f52YDHW+fDO0r7D694P/Kx0Pgp4YFXp9+8A3wCSwGXAsXDb0vXvLrU3CnwcOAIkStf9MfDlMe18EPil0vkPALuxUJ4C/i/wv0vXrSu14++BKuAKYAS48DSP/5LS49sMnATeULpuNTBQOgZRoAW4vHTd54B7S8cmAryy4vk5OGYf7cANFY8tC7yxtM9q4CrgmtI+1pQe24dK29djr9+PYK+zOuDq0nU/Bn61Yj//A/jrCR7nmV7LeeAPSo/hTcAQVso03n09jr2+EsCNpdfEl0vXLQe6gFtLj++20jFtBmpL266puK+ngLeNs486oC983krH+aLS+bcBzwMbSsfsU8AD470OddJJp3N3mvEG6KSTTufnhAXD/lLACiax/dgA/QLw2orfbwf2ls5XBuibsEDsKrZ9nIkD9L3ABye4rh14T8XvN2LhsvK+vw18snT+KBZkU2Pu50+B7wFrz/CYg9L9hyH8N4Afn2b77VgZDEwQoEshLE8p5Jeu/29UBOgx9+mwoHpx6fczBej7gA9UXHcxFpIDygH6gorrnxwvpE3Qlr8FPlM6//vAt8fZJlLa38XjXDeZAP3TM7Thv4T7xT5obJtgu3cB91Uc/xOUPkCNs+2ZXsuDQKTi+m5gyzj3swb7AJCsuOyfKQfo36P0YWbM6/1dpfPfBD5ROr8RC8lV4+ynDugF7hh7PXAP8N6K36Ol52MpCtA66TRtJ5VwiCwsv4718H7BOefCC0ulC4Ol08cmuO1iLHiEXsDepMdaArR77/2YbSeyHNh3musPj7nvQ+Pcd9iOO7Aew0POuZ85564pXf7npe3udc7tc859dLwdee+LwLewXnGwXuYXB+s5537JOfdM6ev4Xiz0tJym7QBtWMisfByjjkepXGCXc64P6AFqJnG/oSWc+rzEsd7V8HEdr7g+jfV+nqJUPvGzUulCH/ahIGzHRM9TW2l/p3sOT6fyuOCc2+isbOa4c64f+KMxbdg7wf38H2Czs5lPbgM6vfdPTrDtmV7LJ733hYrfJzpmS4Au7316zH2FVgLvCF8vpdfMtaXbAXyd8mvtXcD3vPeZsTvx3veXtvsgcNxZOdD6in38XcX9nwSK2Lc2IjJNFKBFFpYTwGuAVwH/M7zQe/9+b7NG1Hrv/9sEtz2GvVmHVmC9teNtN/bNe9zp3EoOA2tPc31lWD4KLK8M/5Xt8N4/5r1/E/a1/PexHj689/3e+9/y3q8C3gJ83E08+8g3gLc751ZjJQ//B6zWFfhfWK90s/e+AdiF9RifTgcWaJZXXPbi8XDO3Qj8NvBWoAFoxHpAw/s90yDOo5z6vGSxcpap+iZW5rPce18PfKGiHRM9Tx2l/Y133RBWtgK8OEiwecw2Yx/f57Ce/XXe+zrgv06iDZRC7HexIPpu4KvjbVcy2dfymRwDmp1z1WPuK3QY64FuqDjVeO8/U7r+R8BS59ylWED++kQ78t7/0Ht/Mxb+92LHKdzHr4zZR7X3/jHO/NoRkbOkAC2ywHjvj2JlFrc55/56Cjf9BvBfnXMtzrlW7Cv9r42z3YNA4Jz7kLPBdP8BC6IT+QLwMefcy5y5sGIQ1FgPY+UQv+OciznnbgJeD/yzc67aOfdO51yd9z6HlUEUAJxzb3TOrS0F777S5YXxduC931ra5vPAD0q9f2A9kB4Lps45936sB/q0Sm35F+APS228BAt4oVTpMZ3Eyj0+hfVAhzqAVWM+NFT6BvDbzrlVzrkU8CfAN0q96VOVArq99xnn3LVY/Xroa9hr5q2l57XFObe51FP7ZeC/O+cucDYH9iucDfzbBaScc7eWfg/ris/Uhj5gyDm3Cfi1iuv+FVhRem3FnXN1zrmrK67/CvA+rCRjvNdmaLKv5dPy3u8Dfg58qtSe60v7Dn0VuMM5d0vpuFQ55250zi0p3T6Lhf6/wl5fPx1vP87mZH+jcy6JfVgZovz6/Xvg90rHCudcg3PubaX7L2A12Gum+thE5PQUoEUWIO/9YSxEv80592eTvNkfAs8Az2Kh4THglNt670ewUopfxcoRfgELkBO15RvAp7HSiX6sVrlxgm1HsAFnb8YC52eBd3rvd5c2eS/wQumr/1+hHFQ3YOFkEHgI+Bvv/YOneazfwGphX+wR9N7/vLS/x7Gex42lYzAZv1F6TB3AF4H/XXHdD4CfAHso16kfq7j+W1iJRLdz7vFx7vsfSts8AOzHPjh8ZJLtGq+df+ZsRoxPYPW8AHjvD2DH/uNYTfCTwKWlq38L2IkN+OzGas6d974H+E/AP2I9vN1AZTnJeH4Hex4HsF7Wb1W0oQ+4BeutP4ENMKz8JuF+rFzmMe99+2n2ManX8iTdCbwCe2y/R0XPt/f+IPa38PvYB69DpcdX+d77dey19q0xZSOVIsBHsddFF3Ad8KHSPr6NBfBvl173P8cGLYb+APh6qcTjF87yMYrIGOFIcxERkTnP2RSFX/Lef3mm2yIi85cCtIiIzAulspMfYDXcQzPdHhGZv1TCISIic55z7p+wQXkfUXgWkemmHmgRERERkSlQD7SIiIiIyBQoQIuIiIiITEF0phswVS0tLX7VqlUz3QwRERERmeeeeOKJk9771rGXz7kAvWrVKrZt2zbTzRARERGRec4598J4l6uEQ0RERERkChSgRURERESmQAFaRERERGQKFKBFRERERKZAAVpEREREZAoUoEVEREREpkABWkRERERkChSgRURERESmQAFaRERERGQKFKBFRERERKZAAVpEREREZAoUoEVEREREpkABWkRERERkChSgRURERESmQAFaRERERGQKFKBFRERERKZAAVpEREREZlyhUD6fzdpptorOdANEREREZOYMD0M+b+e9h95e6O+386kU1NZCV5cF2lwOTp6EkZHR9xEE0NRk206kWITubruPpiYYHISBgfI+R0agvh4yGTuB/b5pE2zcCPH49Dz+s6EALSIiInKeeQ+HD0NnJzhnQTGRsKCaz1uYPHnSwuZ0Gh6GdHpqt6mvh2Ry9GXZLOzcWQ7iE0kmLQgfPAjV1XZfQQCrVtnv3d3Q1gaNjXaMDh6Exx6DNWsUoEVERETmrbBHNexF9R6Ghiwsd3ZaYM3lytePJxqFlpbT9+ieC01Ntp9EonxZXR00NFiw7+21tjc1WfgNAmvbeIrFMwfoMAQXChCJnLl9mzdbL/V0H4epUoAWERGRWSeTsR7YyrrYycrlrCc3CKyHs7fXelonUihYz+fQ0Nm3t1I+P367w1B8wQXWthUrYOVKu66723pxm5tHh9mZ1tY2+W2DYPK9xJMJz6FUavLbni8K0CIiIgtQGFBP9/V9sQg9PVZO0NRk2/b3j97Ge+jrs5P309vmqQhK0yQUi3a+utp6VCfS2AiLF59+m6nse2w9cFWV9eoGE0zf0NLy0vcr548CtIiIyHngvQXQMGTm89ZLGta/9vWdGmbDQVeDg+e2LQMDdpqMaBRiMdi923oN6+pODZn19VbDOlE4PBvxuIXKs6l7jUSsTcWiHbtUamo9ni/V0JDte7zLw5/d3WfXuz7beG/HuLvbzoevhUOHrNe/pQVaW+11E34gm8rrubbWbq8SDhERkVkulzt9wAyDQLhNXZ3Vh3Z1nTroK5u1nt6TJ89uWq7q6vFD60vR2goXXXTmYOIc1NRYMB4ettKCqYTkfN7CUl3d6NsVCnbsUinbR3+/tSOsrc1kRoesTGb8YzsVYcgrFq03uKVl4lreyaqckSISsV7nri67bCGJRu2xRyKwdy/s2mXna2rgwIFzs4+3v9168GcLBWgREVmQwoFenZ0Whvv6LAil0+XZBJJJC46VwTcMBtlseRBYVVV5VoJw+5oaC1gjIxYgFy+GdevKoS0IyoFgYMDqYZubR7fRudPXwxYK1vaqqtFBuLL04kzO1Bs49oNEGGarq63sIQz24QeFEyfK5RxDQ/YzErHtQ+l0ubTCOXscYVgvFqc+K8RkVFfb8Y1GrV3bt4/fSzwVkYjdZ12dPdcvvGCvg2uvtedkIlVVdrtY7KXtf0YND9uLI5EgVhzBDQ1CPE42qKKjO8aiqn4SLkvWx+gaiDOUi+OiERoKXaQKvbhCqVC8WLSfmYz90VVV2e+FAj5Zw6BL0ZVNUZ9cAcyeA6YALSIio+TzFoTCms3JGh62Hr5ksjyC/1wZGrLQNjbwDA9bW3t7LXQVCnDsmF0WlkxMNHgsfO+G0bW7QWDhJpxGq6pq9CCmcJaBhgYLTt5bD2ouZwFw7DGLRi1oZbPWOzeRZ5+derlCPl9+DNFouZe38vLzyblyr3IQWKgPa6RzOTs2ra12fRi0o1FYvdrC/tBQeaBdc7OVAwwP22NZt25yg8kG+j19HRl80eNdUD4oQUAQDWhodNSmXuKLM5u1xmYy5RdYPG6nWMxeXLt324NubS0Xj4fF4uH5cALmaNROhYJdns2+GCIpFstTdoTF3NXV9sIMfzpn95PPT64QPZOx/UQitt/wtsWi3X5gwD5ZFYvly8Lzlb+PIw4sH/P74pdwqJtKJ77/fRt9OUsoQIuILCCDgxZcOjvt/bNS+L7Z01N+D25rG91zGIbSyjAbvp9WXl85PVcQWLDs67P9t7RYECoU7PdwztuODns/X7zYMkj4Hj84ePrSh0hkdH1rZc9oY6Pta7yygyAoT9dVX2/tCssVwtv39to2lb2J+bwdo5qacq/z0FD5eIblHD09lqdSKTtGIyO2TZhVxh778WqgzyQWs6AZHqvweYhG7fLK5+50CoVTc9fwMPR0FXHdXUSGBylEE6RPDEImwwUrE6Q7h+g7MojL53D5HLHiCKlCL8NHe4gO9JBI9xAf7iWRG6QYryITrSUfr8Ena4ikB1jd004QceRcnGIQoxCNgwtwxQLOF3HFPK5YoGG4n8jIEH04+oIA7xzg7KezJzaIBUSijlzOER3sJZ6b+ECmSydcQDFVR1BdRZDP4go5glwWV8gTra/Bx+MMd/QTtDRTf2ErkeFB6O+n2NNPfjg76nidLo57Tv1A46Nx8jX1BLXVRKuiuEIel89DEFCoa8DHExBYvYwPAorxKD5VBcUiQTZDMDCMO9lPkOnAjWRsL5EoPhKdVI2Nj8UppuohV4RCHiJVxJNR4tUBzjlYtRZfU6qpCT8NhT9L59OuhnSkltpYlmIkxgApyOdxIxl8ZoRCMoWPJ/DZHAPdOQrDWYJinlxdM31BIz0DUfI+gg8ieBdQiCXwQZRILkMxEsW7CLHsELHMALGRAW6MNTGbJuNwfjYNmZ2ELVu2+G3bts10M0REJlQojN/rGc6heq7k8xacJpqCq7JOt1gcPS9tOL3X2PYkk9Zh1tpqtz140Dq/crly3SpYSBwasvsMVxKLRu32laUNYwXBxD2jTU32Hn3smG0Tj9t+Ghst5DY0lINyLleuZa2vt1NDg12eTE5uGrAgGB2Mw3ILKJcfhDWzUD7OuVx5cNtw2tPdkSPnoy8+uEhmiEguQyFWRVDIUewbIN0xAPE4VU1JMif6T/1EEAQse1krm17RRFAVf7HHsTgwxOCOQ2SPd0PEwgZBQKEIHY8coLDvIKliL/FklGh9LbHmFEEijgscLnDWA+scHkcmGzA84kgmHdG+LtzhQ0TS/bjBARgcKvV65gmKeXw8QRBxRHIZfL5IsRQVHJZZw7ILX+TU9BhP4Bsbydc2kq9rhNpaItkMQXqQwsAQ+d5BCvEkkdUriMQCyI5QyJTCqy9aoAoi5HyEkVyE4WiKbLyW7IjHe4/z9oQEvvTJzXsKeU8hVyQe8/hUHfnGVogEuNL2rrStL3qymSLFgodCgWCgD5cdoRCJUwhi5IM4eaJEhgeJFrMUauqoGTpBfb6LkXiKflfHUFDHcCzFSLSWXKSKbKSKaASqIjmKmSwRn6Mq7ulqXEcuWk3N8EkKVTX4VB0jVfVkEvUUookXS1XCkqBMZnTJTSRir+VwVcDK121r60ub2i2btQ+m0xEBKzvlQ+Fjqa2164vF0TXvk/E7v2P/I84359wT3vstp1yuAC0iMnkjI/bGUyhYL2xYP1tXZ28GnZ2jQ1elcGaAyZY2JJPlOWzBAmLYSxl+03umf+FhGYZz1sYwHNfXj54RItTfP7oHengY9uwZv5a2qgoWLbIwGdZyhvupLOEYGbFj0tBg2x48aOE0rB9NJu3Y1dTY4+rvL/dyd3XZbXt77fEWi/YGnE7bfRQK1oZCwX4PnCc60EOkr5vAFwh8AVe0n9FilkgxRy6SIPBF4rkhalyapEsTHUlDOk0snyaRH6Ku2EuyOERQyBH4PJFCjmh+mEQxQ0CRERJECxkS2QFi5CESkItUEWSGGfu+6oAgYsfDOXvcYz+4FAqlTO2tx7KyV388pdxIuu4CBmNNFHN5EtlBqvIDRIq5USHTUbQgiccFFnozsVp661cynGgkV53C19TiIzGKQZRiECFSyBJ1RSK11WTqWslW1RPJj0BNDT5RRTGTxVcnqVuawsVj+GiMYjROrqaBYmKS3d6TFH44OpclQWcSDgy84AJob4f9++3yZNJCXGPj6A9p4awmDQ3lD66Vz99E3wSEf8cD9vlq1P+H8BuL+norcQnD5sCAteelDKh0ztoa/t2Gs5WcbmGXsRIJOx6Dg+XSnUjE/i80NZXb65w9/uFhOy61tWc3KHbTpplZiVABWkQWrPAr97DH9mxH86fTFv4qp55KJOzNtL/fLq+csqnyDSIcsDa2bOJ0BgZs+7CmtrfX3kzDGtOmJjsfDhYLA9rY+wjLGXO5cm9XuLpYqHIA1+BgeWBZWNMbPp66OrssfOyFAvSfzNLfnSeTLhJQtLLMeJGBviKFvCc95Dl2pEjMZ0lGswwMR3GxqI0V6u4jGhSJJWP4nl7yA1YTWhjJU53rp26kk1Smk7pcFynfT0ARF0A8UqS22E8kn2EonyDq88R9hlhumKjLEwk4/ffqpeekWICiL4XcqKOYSJKL1zAQbSAXqyGoikEkSjESIx+vxser8C4gyGbIRavJJ1MUEjVEc8PE8sPEW1K42lqKsQRBbgQfi5OvTpGvqiXTn2Wke4hsVR2F2OgRZkExj+s8ge/pIZofIVYbJ1pTRT6epLh0OUFba6msofSBgCIrXr6UtZenKBTstd3XVw5+470W4nH7gFHIFXGRgCBS3qDy9VT5jUYYtCpfzyMj9jcUDp6Tly4sg57s5S9+4DpLsdhLn4FkoZgoQOvwicisEdaBdnaWp/wKp4mKRu3Nuqdnar0kYPczql7Rnd2bRzQKGzfCkiXlOtlzFSDyeQstldNhhYPRu7vtcff2jn4c+Txs22a9Ue3tFuLHhqaqqnJdclDMkxjpJzLQS4Pro6V6COfsGGez0Oc9DflOlo+8QE2uh1ykit7kUproJhlkyEcSMNBPfriHmpEekiM9VI/0sLRw+ickcBU9XR4iQSm8huex4B4JSvXMUYiGP2MBkbYWohc04+rryzUczkHdGnuAmYztIBxU1dpanm4hLJAOAkv8sZgd5LAwO5ksnxKJUQdwqoPwxgutY032PqdS6hM+xEWL7HR6DjjzhMhhbfd4EgkF53Ntov9HE10+dlaTmTA4eOr/pHMp/IYqnN1l9erp2c/ZUoAWkRlz/LgNVB8ZsVPlPLnRqOWh8J9ooWD/rBsbLfdM5eu/ygUZYrHyfKVTFQ5AHxy0kL99e7lko3JGh1ChYAP2KusXw5kGwqV+R0ZGf12fzZaPQfgYvS9fHhTzJIrDxIsZ4sUMzfkOLoru5pb8blp856jj4vAkcoMkc73U+z4ShaHS5RZaQ0EpuBYKpRrXqji+sZkgM4Q71k8hiJOLJ4nks9ZFuaSRfKqRfGoVNDRQvbiBVHOcqmSA9zA8EpDNB9SmHNGYK6fBMMCGXabel5dmy+Wsez2s54hG7bvepqZzWzg+BdOx2xl6KDIDKkuvKvX02P+M8QwPW+9+5SDTVMr+53V12Z9Q5Z9E+GE7nM6wMsyGC5z09Nj/mESiXG6VTlsbwm+YvC+PlwjP9/efGo5ra6093d2nXxp9Otx55+z64KYALSLTJp0uz/hQ+aYQ/oMOOw5TKctL69aVa3RPt+TtS5XNWnCNRsevqevvtzaPjJSndAsfQzRqWa+7u1zbl8nYDBK5/mFqs900+m6qh7spnuxmUaab1QxRDKJk8lGKBFRHssTJEi1miRZHiBayRH2OaNSTyvWQynUz7JIMR1MUIjFahw9Rn+8m6YYJGL10WRBAkIP44maqVi859ZNFTT3UrygXklb+DKecqNTQYIWfQVDuuk4mJ/2JxQHJ0knkfChNXjHqpTy29CEsu4pEyh9Yp/ohOp8vf5Dt7CzPZDM2ZIalMI8+avvauNH2n07b/5TOztPvp7q6XF9dLNpCJGEADgfPTkU4WC+dhh07ypeHX96EwmkHw9lpli8ffUzD6RoHBuy61taz74yYjLDnOR7XSoQiMs+k0+U3kXDwSziA7vhxKyuA8oIRlWF15Uqbrmz16ulbTGBgwIJtOJ1pT4+1t7JHOFwA4cABu7y/vxz043F7kykWoSrTS2vmMLVBmkRHOxedeJ763EmqhrtJ5bqpy3UT96NLGQIH8QS4eAxXLNigrCjgApumKh4nWpMgqI5bvYJzRBrrCFrXWPfO4KC94y5bZ9/NV87/Gp6ammD9+ukZnh4WRsuClsudOsPLeLJZ+5AZi9nfzu7d534J8vH22dtbnravpcX+xk+csJduTY39PYe9walUuZe1qcmCWTRq7R67rHY8bveZSNj/jv37R28TjZ76Qd/78gItixfb/8WdO+3PNhxkd801tmjOeJ9J4/FTy2fCNUbCQbaVC9vkctb2cO7ysWE2/DcRti0cAJ1IWJsqn9vzvdz5ZCxbNtMtmJgGEYrIlHhvbwhPP336N8faWut5WbZs9IjsqTh+3N4IV62ykP7kkxZ0g8DegBKJ8vy74T//7u5yLXVXV8WdFYsEI8PUF7pp88eJjwyQHihwoi+BO3yItuEDpBggxSAp30+q0EMsNwyFPPEgT5wsgSsPOIs01VFoboPGRhJLmqla0kRiSRO+oYm+SBPFhibaNjXhmhrLnxzOtutLZALptC3OMtG4gMoqmHAaMbC/jb177e/rdF/FF4vlwDlV4XLZ0ykMzmGv8MmT9hhXr7Z2h2uPhJ8vw4G4QVDuRS4Uxl8VMJMpdwjEYnDhheX/ZS0tE39Llk5bO5Yts+snGggoc4MGEYrIWaksYejstB7dgQHrXbn00nK5RTiYJBy71dUF+/ZZL9RYYW/w4GB58a3wTSr8qvHgQQvBhQKc7PQU+wZozh1nRfw42f4Mjw9ajW9tsZ/mYicdxSiuWKSOfqKDvSzK93NV0E/K91GT7yeRHyQS+Bff8HzF16CJBFQva8I1NuCTtRRrminWr6NYlbSFCaJRio3N5JauxCVrqVm9iMaLFk9Y1jDhOC4VwC544aDQiZbYDr9UCALb5tgx2LXL/gahXH0TlkF1dpaXxB7P2K/7E7Y2B8PD9rOl5fRfXjhnwbG+/syPrTLMptM22HYufFb0fuIKpXDcw9gSkdNJJu0DfkjheX7S0yqygIWrY4X1yE1N9sZ66BA8/3x5Cd1wvt22tvLqZuEcyKHKN6HKVdmyWdtPMmkhIJwporra3lhG+jI0FLtpKHTherqpTndRl3tS+CUAACAASURBVD3JluJx6kc6SPZ3UN1/nCqfIR4vvSE7a9eLg+xcUJr31pGtShG01RNpqqeQbCBfu5JCdYp8MsVIMkW+pp5cy2Kq2upoao3SmBwhvrxtZmbol1kjDJrhSoxjg2flUuLhHNVjv/KfjPFW/BsrnCs6LCVKJstfZff02Lcwzlmovewy2LBh4oAbzpQQ9iSHj62x0Sp/JrPgzNlobp6e+50Opyvvn0pwloVFAVpkHgtXqQtXVAtXyAt7k8f72jebtW0vuMB6kIaG7E03ErEawD177A24ra08qKZyUY/qeIGBwz00FLppi56krvsg1cPdxIICjYPt1OdOElAknumnOt1FopCmWJqP13vAWYlENtXMcP0FFDatIbXhOpJrLiDX1EZ3rI1YYy0rVpR6dmpqRr9b693uJRsZseciHh+9cmDloc1k7DUU1k+Gi6RMpbdt7ACmsNIlnJlk7EqAoXjcPu9UzlddX2+9t2NnMAiFZT2DgxYew7rYMFiGNbKnk0yW63vXrDm7RR3CWRPGKy0fu0x6ImHf8CxefPYv69ra2Tf4SmQ+UIAWmWdGRmDrVuulGq+20TkLECtXWujI5SxUhIswHDpktztyBB54wM6HQSqTgZF0gQuzzxFPP0VboZO6XDc1I93UFbqpGuoilu6zkBEDnM3tSzRKrhgw0ryEYvMifBCQr15KV6qZbG0T2VQzhYZmalc0EVnUTD7VCLEYra2wdOnoHqLW83UgZ7FwmekwZE6lNzRcBGOiRRj6+8uvm0jEasvDQZeNjRaQh4bGr38PF904U7AMR/OP/QBXW1vu4Z0O4SIy+/eXB7aGq0OuWVOeWzcsQ6oUrrp2PqxZc372IyJnTwFaZA4bHLQaycoe5eFhC8Vr11rvFVhoamoq1xjn8/DTn8ITT1hoDpdwDRfxaG6GKj9MUMyz3PVwfc+PWNv/FG2D+0jmem01OMAnkxQamynUN1FoWEXQ/DKqljYTtDThG5uguZnqDSugsZFs1vZ/PpfjnQ3C4zre0rVhkMxm7bg3NNjzcfSona+psTD5/POjVzAcGjr7VcjCFeeqqsa/fvny8tRU4UqIK1fadT095VKeSy4pr7hYOcPJyZPj9wCPtXLl6Pls83kL9s6VZxOYKMym06OXBA7blsmUZ00YT3V1ecrpcO5rEZGzoQAtMsd4D4cP23yehw7ZZeGo8Lo6C6nr11sAO3DAZq44dsxuEwbl4WHIZoosr+lmSf0Q10X2srL2EPVNaZYXXqC1ZzfVXe0ELy765qzQcsOrbEfr1tlcTFOY1f5svu6eTYpFm7FgbE9vVZUd64EBu76yVObEiXJPbfjVf6VwpcVQZblEpepqK6kJLV5cDpZVVXZ+ssd3umo6U6nRA6emU01N+cNhaCplCtM1baKILBwK0CKzSOVAvLHnn3zSpo4LR4WHy+nm8/aV9I9+VK7j9N6Cci4HdfEMF0d2cX3/4yxynTT4HhoKXazM7aUmMwxd5aWAXRBYzcSVG+DCN5RXhbvhhsmsETynjB157/3opcTD08BAeZaRyay8FYmUw/KiRdZTm0iMX5sbzlpQXV2eQzeVsim4+vvL3wi8lBpYERE59xSgRWZQb68F40ymPOco2M8jRyw0hQsBdHRY4PLegtXwsN1+aNCzqHicK4OnWJM8Tq0bpGGwneb0YVpH2qn2w0SikKwNCBobrJC1sRHWvNGSWk2NTbS8Zo0lvTlYY5HLnTpYMlyqdmxozWTKNcNhuUomM3pxFbAQ3NJiJQ29vVa2sH796NKHcNBXT499mAmn9DvbQ7huXfl8dfXZ3YeIiEw/BWiRaXbsmPVqNjdb0Dp+3Hob29ut5zgatY7edNp6lp980no+83kLaOHS0YlEebW/2mw31wz9jFdl72XtyHOk3KBl334s+S1bYslv+Rbb8YoVcPXVc2I4frha1tipvvr7y7MmVDpyxMpTxlNXd2ppQywGF11kxzMcUBdWpYRL2b7UICwiIvObArTINEinLTgfOGC1ygMD1hsazozhfXke4/p6613OZCwsNzXB9dfb1/bOWfiuS+a5sG8bq448REvHczR0bicWLRKsXAFX3WojBi+/fHrXxZ5G2awNPuvosIVXKgfMnUkyaQ89mSyvfBaNWnCe63XXIiIyOylAi5wjvb02e8KBA/DQQ9bTPDxsvZmplF2/aJGVAgwMWC9rWA5w0UVw+WZP9XA3656/i0X7HqF21zHc4AA+k8GFy5YlErY+9hvfBzffbMF5FnWTem89urW19tjCWSYqa4rHTn8WTskWamuzFQ7HzrwQTvc8thZ4Ic7sISIiM0sBWuQshYP5XngBtm+3UoLnnrPlq8GC4AUXWJ3tyIj1jK5ZY2F6cBAWBx1cEXmG5J6nqd/1NMGP9pcLdjdsgIsvgvp6XHW1pdGNG+Haa2ddt+rAgAXjEyesJKVy1olisTxrRSRix2DJklPvo77ePmi0tEw8vZqIiMhsoQAtMknd3fDoo1Ze8MMfWlhcsqTcyxoutPCyl8FVV1kWPnQIKBRIZTpZ4o6x5KH7ael4jpbhwyTTnTiw0WKXXgrXvdMS5DXXWM/yLNPeDrt2WSAOlwSurFMOAis72bLFet7T6fLCGq2tNm5RM0mIiMh8oAAtchreW3Dcvh3uusvqmk+etE7gSy6xsoxoFF71KguJF15ovc47vrODJQcf5bqR52ne/zjxkYEXV+Tj4oth6VWluo3L7UbnaUWHcH5isJKIsaUPIyPWcxwEdj4atZ+PPGI968mk5f2aGhuXGC52sWiRBWQtTCEiIguBArTIONJp2LYNdu60kNzdbTNhbNhgPay33ALLltkAwXAluaFj/Qz/2+Pkn/0BN79wP3V1ECxZDK+70dJ2S4t1T6dS097+yh7g+nqrx9661cJ/OItFuPhKc7NtG9YnRyJWRjE0VF50w3t73Js3KySLiIgoQMuC191tvaydnTYDxM6dFow7Oiw8JhIWIGMx63ldurjIwX/dTk/H8+TjNSweeIHlRx6l/ugOIs7jU3UkPv6bBHe+fVqnjRsZgT17rJwin7dwnMnY+coFP8LV7erq4LLL7Kf35aWXn3/eepbb2qxzPAzfTU32wWBkxILzFBYdFBERmdcUoGXByGQscKbT5WWQd++Ggwft+nzeBgH+/Oe2bUuLBeaqKitRuHRRB9cf/ifavvkjYgPdOCAShUg0sB7m//CrNsjv4ounvZt2xw4rqygULNhHIhZ4GxosMDc1WXYvFOwDQiJhTVTvsYiIyEunAC0LwqFD8JOfWEgOe2TBShyam622+e67rRd36VK4/XbLwqtWeqpPHoYHHoDPfc7qOF71KptC7vLLy2n8PJRlgLX74YctQC9fbmujNDefl12LiIhIiQK0zEu5nIXhnh4rQXjySRvktnmzBehk0nqaH3vMgvPx49bb/K53wbuv2U39o3fDZ56CvXstJINNrfHJT1rCngH9/XDffRb2L7/cmqP5j0VERM4/BWiZV/bsgWeesbKFSk1NNgfzv/+79eIePWq9uH19NhXdzTcWuHPJ/TTc/S348jar77joInjDG2yWjJe9DFauPG+JNZ220pFwXul83h5TJAI33WTLTouIiMjMUICWeaG3Fx580IJxSwtceaVVVRw6ZD3RJ07AU09Z73NHhy1+0tQEb7+lh9sy/8Liu75DcKLDip0//GG4447zVpZRqViEe+6x9oWlJosWWT3zmjW2lkoyed6bJSIiIhUUoGXOO3jQ6pvD+Zg3brSyje98xwJ1c3O5nGNwEBa1FPn/bt/OdUe/Q/y791i9x9VXw0f/C1x//YyMtEunbb7pPXtsRcPLLrMBgEuWwOrV5705IiIichoK0DKndXfDT39qvc633mq9tt/+to356+uzKoyDB63X+fIlJ3hd7h9Y9fS9uPv7rSv3jjvgbW+z7t3zKFwGvLPTyjQOHrTfYzF45Sut3SIiIjI7KUDLnJPJ2PRz+/dDV5dN0fba19r8xX/5l1b+sGoVvO51NvCu77l23jnyVdZ+/9+Ix7wl7auvhle/2kYOTrNi0doctvvwYSs5CZfBDqeYW7/eBjpqYKCIiMjspgAtc0p7O9x7r5VoLFpkUy43NcFnPgP3328h+jWvsRKIwW272PjIP7K+/V6StRF4y+3wvvdZXcR5aGdnp7Vn714Lz2A95EuXWllGuDDLqlVWfiIiIiJzg962ZU7o7rZSh127rJf2ttsslD7zDHzqU9bTvHYtvOnKI1yy7/9S9w+P03B4O1XNNUR+9Rfhne+0Oo9pNDRkU8zt22e94GC9yStX2rLfkYjN3axBgCIiInPbtAZo59xtwN8AEeAL3vs/H3N9I/AlYC2QAd7nvd8+nW2SuSWbhccftynnIhHrva2thb/4C5tVY2jIVt/7s984xKv2fIng6z+w1HrxxfCLH4Zf+IVpW047n7cSks5O63E+fLi85Pc111gTgsBOIiIiMn9MW4B2zkWAvwNuAdqBrc65f/Xe76jY7BPA0977O5xzG0vbv2a62iRzR6Fgvco//rH9bG62ILp9O2zdajNqXHghbHlZgTtOfI6m//FlS6533gnvec+09Tb39tqMH3191sZQTY0tbrJmjfWQKzSLiIjMX9PZA301sNd7vx/AOfdN4M1AZYC+CPgzAO/9LufcKudcm/e+YxrbJbNYTw889JBNP5fN2qm11Xqgu7rKgwZ/443tvKXwXSI/echGE77pTfChD1lB9DQ5fNjqr4PABv1FoxbsW1vPy1hEERERmSWmM0AvBQ5X/N4OXDNmm2eAXwAedM5dDawElgEK0AtIPm/lGHv22DzNIyNWCtHVZb25zzxj8yQnErB+VZZfLH6F1d/6km106aXwp39q03BMk1wOnn0WnnjC8vmtt05bVYiIiIjMAdMZoMebjMuP+f3Pgb9xzj0NPAs8BeRPuSPnPgB8AGDFihXnuJlyvuXzNhiwqsqC8fbtFpybm62euKPDwvKqVTZwsKMD1rf1cUvsZ1zy2D9S230IbrkFfvu3rfv3HPLeepo7Omz6uZ4eGxiYy1l5xg03aMYMERGRhW46o0A7sLzi92XA0coNvPf9wC8DOOcccKB0Ysx2nwc+D7Bly5axIVzmkHwefvQjK9GA8oIivb3Wwzs8bLPMBYEtkLKk2M7vFv436+/7ATGfsyktPvVZuO66c9qu4WEL9Tt3Wph3zk51dTa7x8aNNm2eiIiIyHQG6K3Ahc651cAR4E7gnZUbOOcagLT3Pgu8H7i/FKplHioUbFDg0aNw1VVw4AA8/LD1OsdiNmvFxRdDPA5HH9zP64v/wuV7/plILAJvfTO85S2wYcM5W2lkcNBWADx2zKadKxYtvF97rfV+ayCgiIiIjGfaArT3Pu+c+xBwNzaN3Ze898855369dP3fA5uArzjnCtjgwl+ZrvbIzMrnbfaKxx6z0o1/+AebXaO1Fd7wBiuNOPZcN13/+H2WP/dDXta7h1R9QPCG2+GDHzyns2p4b3XVTzxhoT6ZtOC+aZNNiSciIiJyOs77uVURsWXLFr9t27aZboacQS5nZRG5HJw4YYME9++3WTXyeatxvu02eNnLIB4pcOyTf0fwra9THctT+/JLCW671eqcm5vPabu8hwcesHKN1attvua6unO6CxEREZknnHNPeO+3jL1cw6HknCoW4fnnrac5m7XLurttwZNk0soiVqyw8LxqFfDCC2T+8NNEf/o4fde/iUV/+B7c6lXT0rZMxkpG9u614H7VVdOyGxEREZnnFKDlnEiny4Pwhoaslnj9ehgYsB7fcKDg6tVww2XdrPrOl2DXLgpPPcPgUJzn3vJJrv3zt+Cqzn3bDhyA3but1jmfhy1b4Iorzv1+REREZGFQgJaXbMcO69ktFmHZMnjFK6x3OZ+H733PpoVbs8ZC66sat5P4/Y+ROdlL/9JN7Lv4l9l75Z3c+NYmqqYhPO/eDT/7GaRS1qbNm21uaREREZGzpQAtL8muXfDgg1aW8fKXQ329XZ5O24wbjz9uAwVf+UqoffJ+hj/8u3QmW3nsrV9mYPF6li2DN1Xc7lwYGrKZPfbssd7npUutZCQSOXf7EBERkYVLAVrOWk+Phefly228XxhQOzvh61+3ALtkCax1+/Gf+CKpHfcwvHoTmT/577zmwkYaG89dqE2nYds2OHTIzoPN9rF5M1x5pcKziIiInDsK0HLWHnzQ5m++8cZyQD1xAr76VauFvvZaaD25k6u/8GtUV0PsV9/Jov/8ARtNeA5kszYg8NgxKxPJ561UZNEi6/VuaVFwFhERkXNPAVrOys6dFlyvv54Xa5e9h+9/3+qOb7zBc8XQA6T+8Y+oaqun4XtfPGdL+RUKNi3ez39uobm21kpIrrhC8ziLiIjI9FOAlik7cQIeeshqizdssMsKBfjKV2z57cvXp7n1ro/jH34Ev2IFjV//m7MOz9ksdHXZwL+qKmhvt57v/n7rbd682XqbRURERM4XBWiZkkIB7rnHen1vvrm8qvaPfmQDBi9a0svb7v0IxUM7OfC2j3Lln7wVqs7uZdbdDXffbVPhVaqvh9tvtwAvIiIicr4pQMuUHDhgs1y8/vW2miBYr/M3vgEbY/t4+32/RU3uJIOf+guueOf1RGOTu1/v7X7D8/v321Lb8TjcdJMNDMzloLraer1V2ywiIiIzRQFapmTHDlv6Ouz97e+Hb38bLk7s5Zce/lV8LEHVl/6B1msvnvR9FovW03z48OjLV6606e9qas7hAxARERF5iRSgZdJ6euD4cbjmmnLpxte+BrHOo/zSng+Ri1ZT/dUvkNq8ZEr3+9hjFp4vv7w8H3QqZVPgiYiIiMw2CtAyaU89BUFQHjh4zz2w7cfd/Jedv4l3WY5/6gtcPcnwfPw4ZDK2EMuhQ3DJJXD11dPYeBEREZFzRAFaJuXoUZtz+YorbDaMrVvhC383wq9t/TANiZPs+E//i1e+Zc2k7uuZZ6zXGSAatfmiL710GhsvIiIicg4pQMsZ5fM2dVwqZWUWJ0/C5z4Ht2z/azYndlH7+b/i5psnl4APHbLwvGaN3VdtbXkeaREREZG5QAFazui++6C312beyGTgS1+C5KM/5fbh79D40XcT3Hz9pO6nt9dm7GhpgRtusN5nERERkbkmmOkGyOz23HOwb5/VJ1dVwRe/CE9+/yi/2fVHtLz6YoIP/uak7ufkSfjxj62G+rWvVXgWERGRuUsxRiaUz8OTT9psGBdfDJ//PDz6YJ4PHf0ES5dA7C/+DGJnnuj53nsthMdicNttVrYhIiIiMlcpQMuEdu2C4WG45Rabru7BB+ENh/4nF/nt1H7605OaZ27HDgvPl19up3j8PDRcREREZBopQMu4Rkbg6adh0SIb9HfvvXBF5mFe2/EVku99K+7m15z29idO2GqCO3bAsmWaok5ERETmDwVoOUU2C3fdZQMGq6qs53lN1VHesfWTxDZdSNUnfvu0tx8chO9/35bkbmuzAYMiIiIi84UCtJzi3nuhuxvWr4cnnoCEy/Iftn6MRLRI3ec+A4nEaW//yCP28+1vt6nvREREROYTBWh5UaEA3/ymDRxcuxb27LF5m6+/79Nc0LeL2Gf/imDFsglvv3OnLbZy7BhcdZXCs4iIiMxPmsZOXvTYYzbVXCQC9fW2+uDSrf/CtSf+L6kPv4+GN0083/OhQ/DAA1Y7vXkzXHbZeWy4iIiIyHmkHmgBIJ2Gr38dmpvhXe+y0o3qAzv4jy/8N1puv4bYf/71CW+bydhiK01NcMcdFsBFRERE5iv1QAtg09T198OrXmU90U2RPt76+MepXdFE7NN/YiugjCObhR/8wH7edJPCs4iIiMx/6oEWnn3WBv41NkJnJyxbUmTLVz+JT58k9qUvQkPDuLfzHn70Ixtw+NrXWg+0iIiIyHynAL2AtbfD9u1Wu3zsGFx0EWzelGXLzz5D37ZH2Hfn73HV1RdNePsdO+D4cbjxRlix4jw2XERERGQGKUAvULkc/PSnNuhvxw5Ytw7e87pO2v78t8g9u4udV72Xlve8ZcLbp9OwdastknLhheex4SIiIiIzTAF6gdq5EwYGrPwilYIP3nGUtt/7DXx3D9ve8Zc8v+jVXL124ts/+CDk8/CKV5y/NouIiIjMBgrQC1A+b8t0d3RAVxfceEUfGz77QTKdA2x9z/9iZ3Ax118Hsdj4t3/+eTh4EK691qa7ExEREVlIFKAXoAcftEVSYjFY3JrnNXd/jK69x7nvHZ+jJ3Ixr7gONm4c/7YdHfDQQ7BkCVx66fltt4iIiMhsoAC9wGzfbr3PYJNrrL3rf1K18wl2v/uPuPYDl9HWNnHP88mTNmVdTY1NWefc+Wu3iIiIyGyhAL2ApNPw+OMwNGSzZviHHubSp7/C4Bt/gev++PWnDcS5HPzkJ5BIwBveAMnk+Wu3iIiIyGyihVQWkCefhJ4eqK2Fgc4MV9/zJwRr17D6b3/njL3JjzxiC63ceKP1QIuIiIgsVOqBXiD6+mzmjWLRQvTyH/8TbXTQ9tnP46oSE96uULCa51274PLLYfHi89hoERERkVlIAXqBeOopWznw+HHIHTnBew59mdSbbyLYcsWEt3n6aauZTqfhiivgyivPY4NFREREZikF6AWgv99m3aivhxPHCvzas5+ksQFqf+8jE95m/36rl166FG64wRZMEREREREF6AXh6achCGwg4JZnv8TavieJ/tUfWToeR7Foqww2NsLrX6/ZNkREREQqaRDhPNfXZwufbNwID98zxI3tXyV/w82k3v76U7YtFmHfPvj3f7fbXXONwrOIiIjIWOqBnue2boVoFCIRaHn032hKpFn6ifeest3Jk3DffbYyYTQKmzbZVHciIiIiMpoC9Dx28qTVMl95JXz320Vu6/oWyVdehrto06jtOjvhrrssON98M6xerZ5nERERkYkoQM9ju3ZZKK6uhoEfPsjK4DCp9//6qG0GB211wUQC3vhGmyNaRERERCamGuh5qli03ueVK+Hzn/O8/ugXaLpkCbHbXjNqu61bIZ+H229XeBYRERGZDAXoeerIEchk7PzwvQ9zSbCD1Ed+xbqkS7q6bHq7Sy6BuroZaqiIiIjIHKMAPU/t2wexmJVnvKnzi6Q2LLFu5grbtlnpxuWXz1AjRUREROYgBeh5aGjIAnQ2C4NP7uYS/3Ni775zVO9zby+88IL1PicmXslbRERERMZQgJ6HnnjClu3u6oKXH/0uVXVxav7jG0Zts327La5y0UUz1EgRERGROUoBep7p6bGFU9avh/bdaa7t/SGD194yqsg5nYbdu+HCC22GDhERERGZPAXoeaRYhJ/9DOJx+33t3rupdWnyb37ri9tkMlYX7T1s3jwz7RQRERGZyxSg55Enn7RFUa6/Hp55Bq46/D2Gl66l4VWXvrjNvffaMt233goNDTPYWBEREZE5SgF6nshmLTSvWwctLXDivp2sSO/k2HVvpXWRLSt4/LhNb3f11bBs2Qw3WERERGSOUoCeJw4ehELBZtW46y64ZPf3iFQnqL7jdQSlZ/nJJ63medOm096ViIiIiJyGAvQ8sXcvpFK2muAjd/expfOHdFx+K+telgKstKO9HS67bNRsdiIiIiIyRQrQ88DwsJVmrF0L99wDl+74FjXRDN2v/0UaG22bn//cBhdq2joRERGRl0YBeh7Yu9dm1VizBrbeP8wrDn+LExuuZ+0tawAYHIT9+2HjRludUERERETOngL0HFcoWO/yBRfY6oJtj/0rNYU+Ol//XtZYfmb7dvt5ySUz104RERGR+UIBeo7bvduW7r7iCnjg3/Ncu/dr9K7YzMb/uBnnLGA//zysXm310SIiIiLy0mg42Rw1MABbt8KhQ7BokQ0gzHz/JzSOHKPzbR/lsqW23aFDMDJi5RsiIiIi8tIpQM9RW7fa1HXLl8OVV8Ljj8OmrV9hsHUN69/3yhe3e/55SCZh6dKZa6uIiIjIfKISjjmoUIAXXrBFU265BWpq4Il/3seSod3k3/I2mlvtaU2n4fBhWL8enJvhRouIiIjME+qBnoOOHIFczuqaAbZtg+Yn7yFRHdDwtpsB6O+Hu++26zdsmKGGioiIiMxD6oGeg/bvtzmdw7KMRx72bD7xYwYuvJKmdU0A/PCH1gP9+tdDff0MNlZERERknlGAnmOKRSvfWLkSggCyWeh+bA8XZA/RcdktNDTAyZPQ1wfXXqvaZxEREZFzTQF6jjl61GbVCMs3nn4a1r9wD7F4QPYVNxIE1kPtnIVsERERETm3FKDnmAMHIBqFZcvs98cetfKNrjVXUb+q8cVtli6FqqoZbKiIiIjIPKUAPYd4b1PXrVhhIXpoCPoe28Wi3BGOXPxaWluhu9vKN8IeahERERE5txSg55Djx2F4mBeX6H7oIVi5+x7iVRGObriR1lZbtjsIYNWqGW2qiIiIyLylAD2HvPACRCK2eEpnJ/yf7xa5suceBi6+hlhzHcWiLZxy0UVQXT3TrRURERGZnxSg55Djx6G11co3/u3fYPXh+1kZO8bzF76RtWttPuhoFK64YqZbKiIiIjJ/KUDPEYWCTU/X1gb79llP82tPfJVC2xLa199EW5vVR192mQYPioiIiEwnBeg54uRJmwN60aLSyoPHtrO67xn2Xf0OUg0ROjtt6rpNm2a6pSIiIiLzmwL0HHHihP2MRKCjA65u/x5BbZKnVryZ1autR3rVKkgmZ7SZIiIiIvOeAvQc0dEBtbXQ2wt9nVnWtf87fVfcSD6eJB6HTMYGD4qIiIjI9FKAniM6Oqz++ehRaDvwKMnCAPvXvZbmZujpsVk3liyZ6VaKiIiIzH8K0HPA8LAtmtLSAu3tcOGBH0OqjucbrmbNGjhyxFYedG6mWyoiIiIy/ylAzwF9ffbTe+hsH2Hd0fvovvwmfCRGU5MFuYIz4QAAIABJREFU7HBpbxERERGZXtMaoJ1ztznnnnfO7XXO/e4419c75/7NOfeMc+4559wvT2d75qreXvs5OAjJ57aSZJhjF72G5ubydUuXzlz7RERERBaSaQvQzrkI8HfA64CLgHc458YOc/sgsMN7vxm4AfhL51x8uto0V/X12fLcHR2w6tD9xOqT7Km7kuXLrXyjsRFqama6lSIiIiILw3T2QF8N7PXe7/feZ4FvAm8es40HUs45B9QC3UB+Gts0J/X12fR0O7YX2XjyAYZf9nLyQZzFi+HYMfU+i4iIiJxP0xmglwKHK35vL11W6W+BTcBR4FngI9774jS2aU7q67OVCCN7dtGY76Tr4lcTi9my3YWCZt8QEREROZ+mM0CPNyeEH/P7rcDTwBLgcuBvnXN1p9yRcx9wzm1zzm3r7Ow89y2dxbyH/n6rf166736qkwE7m17BkiUQHoq2tplto4iIiMhCMp0Buh1YXvH7MqynudIvA9/zZi9wANg49o6895/33m/x3m9pbW2dtgbPRoOD1st89Chs6n2Y/MZL6C7Us3w5HD8OdXU2B7SIiIiInB/TGaC3Ahc651aXBgbeCfzrmG0OAa8BcM61ARuA/dPYpjmnr8+mqRs+1svS/p0MXnYdYNPWHT8OF1wwww0UERERWWCi03XH3vu8c+5DwN1ABPiS9/4559yvl67/e+D/B77snHsWK/n4uPf+5HS1aS7q67OVBhcfeoxklWf7kuuoq7PSjkxGAVpERETkfJu2AA3gvf8B8IMxl/19xfmjwGunsw1zXV8fnDwJV558mGhLPXsiG1lf6n0GBWgRERGR800rEc5yPT3Q211kQ/cjDG++lnwxYPly2LcPamuhoWGmWygiIiKysChAz3KHDkFj30Hq8t30XHgNQWDBub0dNp4y3FJEREREppsC9CxWKMDhw7Cs6xmqquBgw+UsWgR794JzCtAiIiIiM0EBehYbGLD653Xpn+OaGjnMchYtguefh1WrbHVCERERETm/FKBnsRMnwgD9DMMXXkbRO4LAZt9Yv36mWyciIiKyMClAz2L790Okr5tFmUMMrt2Mc7awSixm80CLiIiIyPmnAD2L7d8PK/ufJZGAIy2baW62wYMrVkAkMtOtExEREVmYFKBnsUOHYEPmGSKJGPsTm4jFrHxj9eqZbpmIiIjIwqUAPUtlMnD0KKwffoaBZZvIuTjZLESjsHz5TLdOREREZOFSgJ6lXngBhvuyrEjv5HjbZqJR6O6GDRusBlpEREREZoYC9Cy1cye09ewiTpajLZdRLNrcz5s3z3TLRERERBY2BehZatcuWDf0DIGDziWbGR62qetqa2e6ZSIiIiILmwL0LDQ0BEeOwIXpZ+hJLYemJhIJWLduplsmIiIiIgrQs1B7O3R3eVb1/5yORZdRX2/lG4sWzXTLREREREQBehbatQuqOg9Tk+1meP1mIhFoabEZOERERERkZilAz0J79sCqridwDupvupLubrjggplulYiIiIiAAvSsUyhYgF7X9wS5umaq1q+gUFCAFhEREZktFKBnme5uONLu2Ti4jb61V1L0DoC2thlumIiIiIgACtCzTns7JLsO01g8yfAlW+juhro6SCZnumUiIiIiAgrQs87+/bCubxtBAG7LFo4ehWXLZrpVIiIiIhJSgJ5ldu+G9UNP8f/au/fgyNK7vOPfn+73y4w0I81td/CuyS6+xdnYBCfEmIDXF1gISXmdCw4h5ZjCgSQFxKQgIVUUxSVJUQQHZwEHAwbHCRgWx9i4CNi5ULBrsjbeXewdr3fnvpJm1FJ3q9W6vfmje2LVWJrpHvXRabW+n6ou9TnqbT3z1qmZZ4/eft/qyFE2Zk+zvm6BliRJaicW6DaytQVf/CLcVf08S7P3sb4RRMCJE3knkyRJ0g0W6DZSKEBhfp0T1edYPX0vy8swPQ19fXknkyRJ0g0W6DZy+TIMzT1HT2zCPfdw7ZrTNyRJktqNBbqNfPGLcGz5HF3dsHr6XlKC2dm8U0mSJGk7C3QbuXABTqw8Q/T2sDJ1BqhN4ZAkSVL7sEC3iZRqd6BPVs5RnDrLBj1MTDj/WZIkqd1YoNvE0lJtF8Iz1XOUT9xLuQzHjuWdSpIkSTezQLeJhQVYW1hmcn2OzbP3UKlYoCVJktqRBbpNzM3B+Pw5ImD9zD2A858lSZLaUU/eAVRz4QIcL56juxtKM/fQneDo0bxTSZIk6WYW6DZx4QLMlM6xNjjG6ug0k93Q5e8HJEmS2o4VrQ0Ui7C4CLPlcxSP38PaejAxkXcqSZIk7cQC3QYWFmBpcYtT1XNsnb2HUgkLtCRJUpuyQLeBhQVIV64yuLXC1lfUPkA4Pp5zKEmSJO3IAt0GFha+tAJH11feC3gHWpIkqV1ZoNvAlSswtfgMXd2wefeLAO9AS5IktSsLdM7K5doOhMdL5yiNnWC1a4iREehxfRRJkqS2ZIHO2eIiVCowvfI81dmzLC1591mSJKmd3bZAR8Q7I2JyP8IcRktLUFxOHFu9QNfdZygUnP8sSZLUzhq5Az0DPBYRH4yIByMisg51mCwvw/qVBQaoEHedZn3dO9CSJEnt7LYFOqX0Q8C9wC8C/wB4JiJ+LCJelHG2Q2F5GfrnLhABceYM4B1oSZKkdtbQHOiUUgKu1h8bwCTw3yLiJzPMdigUCjB87TwRkE7XCvSRIzmHkiRJ0q5uu9ZDRHwP8DZgAfgF4PtTSusR0QU8A/xAthE7V0q1NaCPlM5DTy8rYzMMFGBoKO9kkiRJ2k0ji6VNAX8zpfT89pMppa2IeHM2sQ6HchlKJThTvsDK5EmuF7q8+yxJktTmGpnC8RHg+o2DiBiNiFcDpJSezirYYbC8DKurMF05z/rsGRYXnb4hSZLU7hop0D8HlLYdl+vntEfLy1Ba3uJY9QJbJ2srcFigJUmS2lsjBTrqHyIEalM3aGzqh25jeRnWL8/TxxobJ2sfIJx0xW1JkqS21kiBfjYivicieuuP7wWezTrYYbC0BEMLtRU41o+fBizQkiRJ7a6RAv0O4GuAS8BF4NXA27MMdVgUizBaqK0BXT1+hpER6OvLO5UkSZJu5bZTMVJKc8DD+5Dl0CkUYLJ4nq2ePoqDxzgylnciSZIk3U4j60APAN8JfBUwcON8SukfZpir462t1aZwnF45z/LYKQrLXZy5O+9UkiRJup1GpnD8CjADvB74BHAKKGYZ6jAolaBahaMrFygeOcPWlitwSJIkHQSNFOh7Uko/DJRTSu8D3gS8NNtYna9YhGpli6nqRSpHax8gtEBLkiS1v0YK9Hr9ayEiXgKMA3dnluiQKBYhXX2Bnq11VqdP09UFExN5p5IkSdLtNLKe8yMRMQn8EPAoMAL8cKapDoFSCXquXCC6oDh5hvFx6Grkf2ckSZKUq1sW6IjoApZTSovAJ4Gv2JdUh0CxCCPXa2tAFyfPcMbpG5IkSQfCLe951ncdfOc+ZTlUamtAn2ejq5/q6JTznyVJkg6IRiYNfDwivi8iTkfEkRuPzJN1uIUFOFK6wMLQaYZGutyBUJIk6YBoZA70jfWev3vbuYTTOe7YjTWg71s5z/zYi+jtdQUOSZKkg6KRnQjP7keQw6RUgtXyJkdWL/HsmdfS0wOjo3mnkiRJUiMa2Ynw23c6n1L65dbHORyKReiau0r31gbFyTOcOgIReaeSJElSIxqZwvGXtz0fAL4e+FPAAn2HymXouXweAooTp53/LEmSdIA0MoXjn2w/johxatt76w6VStA3dwGAyvQZ5z9LkiQdIHeydccKcG+rgxwmpRKMLZ6n2j1E3+xRC7QkSdIB0sgc6N+htuoG1Ar3/cAHswzV6a5dg8nSea4NnmJ4JCzQkiRJB0gjc6D/7bbnG8DzKaWLGeU5FObn4SUrF7g68ZVMTMDgYN6JJEmS1KhGCvR54EpKaRUgIgYj4u6U0nOZJutQKcH1uQ2OVi/xubFvYHY670SSJElqRiNzoP8rsLXteLN+TnegUoF06TKRtihOnGZiIu9EkiRJakYjBbonpbR246D+vC+7SJ2tXIbeFy4SQGXqNGNjeSeSJElSMxop0PMR8c03DiLiIWAhu0idrVSCnvkrAGweP+EdaEmSpAOmkTnQ7wDeHxE/Wz++COy4O6Fur1SCgcUrbHV10318ivHxvBNJkiSpGY1spPIF4KsjYgSIlFIx+1ida2kJxspXKPQdZ2iki9HRvBNJkiSpGbedwhERPxYREymlUkqpGBGTEfGj+xGuE83NwZHqFRYHZpmehq472cpGkiRJuWmkvr0hpVS4cZBSWgTemF2kzrawAEfWrrI4MMvUVN5pJEmS1KxGCnR3RPTfOIiIQaD/Fq/XLVy7us74+jzFkVnnP0uSJB1AjXyI8FeB34+I/1w//g7gfdlF6lyrq7B2cY4gsTJugZYkSTqIbnsHOqX0k8CPAvcB9wMfBe5q5M0j4sGI+FxEnIuId+3w/e+PiCfqj89GxGZEHGnyz3BgFApfWsKuOjljgZYkSTqAGv0I21VquxF+G/D1wNO3+w8ioht4N/AGasX7rRFx//bXpJR+KqX0ipTSK4AfBD6RUrreRP4DpVCA3oVagd6YnnUTFUmSpANo1ykcEfFi4GHgrcA14L9QW8bu6xp871cB51JKz9bf7wPAQ8BTu7z+rcCvN/jeB1KhAAOFq0QAx48zPJx3IkmSJDXrVneg/5za3eZvSin91ZTSfwA2m3jvk8CFbccX6+e+TEQMAQ8Cv9HE+x84c3MwUbnCUs8UR2b6XMJOkiTpALpVhfs2alM3/iAifj4ivh6IJt57p9emXV77TcD/3m36RkS8PSIej4jH5+fnm4jQXq5ehcnqVRb7Z5iezjuNJEmS7sSuBTql9KGU0luAvwD8IfDPgOMR8XMR8Y0NvPdF4PS241PA5V1e+zC3mL6RUnokpfRASumB6QPaPDc26mtAr17mWv8JC7QkSdIB1cgqHOWU0vtTSm+mVoKfAL5sRY0dPAbcGxFnI6KPWkl+9OYXRcQ48NeB324q+QGzvAxrq1tMVq9QGD7pChySJEkHVFOzcFNK11NK/yml9LoGXrsBvBP4GLVVOz6YUnoyIt4REe/Y9tJvBX4vpVRuJstBUyhAzL1AbG1SnjjJ6GjeiSRJknQnGtlI5Y6llD4CfOSmc++56fiXgF/KMkc7qFSgd/4SAaweOWGBliRJOqBcB2KfVCowsHCJBKwdO8XISN6JJEmSdCcs0PtkZQWGC5fYoouYOW6BliRJOqAs0PukVIKx0iUW+2Y4eqzbNaAlSZIOKGvcPrl2DY6sXGJh4BRHj+adRpIkSXfKAr1PCgU4snqJa4MnXQNakiTpALNA75PiCyuMrC2yOHiSY8fyTiNJkqQ7ZYHeBxsbkC5dJgGVyRNuoiJJknSAWaD3wcoK9M1fggTVKXchlCRJOsgs0PugUoG+pTkA1o/OMDaWcyBJkiTdMQv0PqhUYGB5ni266J+ZpL8/70SSJEm6UxbofVCpwGB5gULPFEenHXJJkqSDzDa3D4pFGF6ZZ6lvyiXsJEmSDjgL9D5YXITxtXkKvdMuYSdJknTAWaD3weIijK3NU+yfZmYm7zSSJEnaCwv0PiheW2N4Y4nS0DRTU3mnkSRJ0l5YoPfB2uUFUoLqyJRL2EmSJB1wFuh9UL20AAk2JqcZHMw7jSRJkvbCAp2x9XWIhXkAuo5NEZFzIEmSJO2JBTpjKyvQtzRPAvpOuoadJEnSQWeBzli5XCvQm9HDxF3jeceRJEnSHlmgM7ayAgPFeQrdU8yedLglSZIOOhtdxhYXYbiyQKF3mtnZvNNIkiRpryzQGbt+Hcaq8yz3TXH8eN5pJEmStFcW6IwtLsLY+jWKg9NMTuadRpIkSXtlgc7Y8sIaQ5vLrA4dZXg47zSSJEnaKwt0xtauXicl2Jw4SpejLUmSdOBZ6TK2OXeNlKD72NG8o0iSJKkFLNAZWl2FuH4NgN4ZC7QkSVInsEBnqFyGrusLBNB/cirvOJIkSWoBC3SGymXoLlyDgJHTLsEhSZLUCSzQGVpZgd7idcrdY0yf6M07jiRJklrAAp2hlRUYWLlGocdNVCRJkjqFBTpDS0swVl1guecoU06BliRJ6ggW6AwtLcHo+jXKA0cZGMg7jSRJklrBAp2hpUJifOMalSELtCRJUqewQGdo5VqFvs1VqiNH6e/PO40kSZJawQKdoa25BVKC9fEpenryTiNJkqRWsEBnJCVYu3qdBMSUuxBKkiR1Cgt0RlZXgWvXCNzGW5IkqZNYoDNSqUBXfRfCgRNH8o4jSZKkFrFAZ6RSgZ5iAYDRU+M5p5EkSVKrWKAzUqlA/8oi5e4xpo535x1HkiRJLWKBzsjqKvRXFlnunuSIMzgkSZI6hgU6IysrMFRdpNw7yeBg3mkkSZLUKhbojCwtwcj6Iiv9k+5CKEmS1EEs0BlZWoLRjQKrgxZoSZKkTmKBzshyYYuRzQJrQxMWaEmSpA5igc7I6nyRSFusjXgHWpIkqZNYoDOyemUREmyOWqAlSZI6iQU6A1tbsD63CEAcmaSnJ+dAkiRJahkLdAbW1oDFRQjomZ7MO44kSZJayAKdgdVV6Kpv4z0wM5FzGkmSJLWSBToDa2vQV1okgJFTFmhJkqROYoHOwOoq9K8sUukaZny6L+84kiRJaiELdAbW1mCgskixd5LR0bzTSJIkqZUs0BmoVGCoukipd5LBwbzTSJIkqZUs0BkolWB4fZFKv2tAS5IkdRoLdAaWlmB0o0B1cIL+/rzTSJIkqZUs0BlYXkqMbhaoDnkHWpIkqdNYoDOwdLVCT1pnfXjCAi1JktRhLNAZqL5QIAFbYxZoSZKkTmOBzkDlSm0XwjTuHGhJkqROY4HOwMZCgaB2B7rPfVQkSZI6igU6A1vXCxDQd8xtvCVJkjqNBbrFNjagt7QIwMCMBVqSJKnTWKBbrFqF/kqBFF0MHx/JO44kSZJazALdYtUq9K8WKHVPMDYeeceRJElSi1mgW2x5GYbWCpR6JxgezjuNJEmSWs0C3WLLyzCyXmCld4LBwbzTSJIkqdUs0C1WKMDweoFKvwVakiSpE1mgW6xYhJGNAtUhC7QkSVInskC3WHFpi+HNJTZH3MZbkiSpE1mgW6x4pUQXW6yPTDI0lHcaSZIktZoFusVWrxYA2PAOtCRJUkeyQLfY6tUCQa1A9/fnnUaSJEmtZoFusY2F2h3o3ukJwn1UJEmSOo4FutUKBQjoPz6RdxJJkiRlwALdYl3LtTvQwyct0JIkSZ0o0wIdEQ9GxOci4lxEvGuX17w2Ip6IiCcj4hNZ5slatQr9lQLr0cfEjJ8glCRJ6kQ9Wb1xRHQD7wa+AbgIPBYRj6aUntr2mgngPwIPppTOR8SxrPLsh0IBhtYKlLonmJh0ArQkSVInyvIO9KuAcymlZ1NKa8AHgIdues3fAX4zpXQeIKU0l2GezC0t1Qp0udddCCVJkjpVlgX6JHBh2/HF+rntXgxMRsQfRsSnIuLbd3qjiHh7RDweEY/Pz89nFHfvlpZgeL1Apd8CLUmS1KmyLNA7zWFINx33AH8JeBPweuCHI+LFX/YfpfRISumBlNID09PTrU/aIjcK9OqABVqSJKlTZVmgLwKntx2fAi7v8JqPppTKKaUF4JPAyzPMlKliEUY2C6wNWaAlSZI6VZYF+jHg3og4GxF9wMPAoze95reBvxYRPRExBLwaeDrDTJlaXtxkZGuZjRELtCRJUqfKbBWOlNJGRLwT+BjQDbw3pfRkRLyj/v33pJSejoiPAp8BtoBfSCl9NqtMWStfXoJU28Z7wFXsJEmSOlJmBRogpfQR4CM3nXvPTcc/BfxUljn2y8rl2i6ETEzQk+nISpIkKS/uRNhC1RdquxB2H3UXQkmSpE5lgW6hzWsFAug/boGWJEnqVBboFllbg55SbQrH4KwFWpIkqVNZoFukUoG+ldoUjpFTFmhJkqROZYFukUoF+isFVruGGDnSl3ccSZIkZcQC3SIrKzBQLVDumWB0NO80kiRJyooFukXKZRiqFljpcw1oSZKkTmaBbpGlJRheL1AZsEBLkiR1Mgt0iywvw+hmgaoFWpIkqaNZoFtkaaleoAct0JIkSZ3MAt0iS/NrDKQV1oYs0JIkSZ3MAt0ilSu1NaA3Ryfo7885jCRJkjJjgW6R6gu1Ap0mJojIOYwkSZIyY4FugfV1oFAr0D1H3YVQkiSpk1mgW6BSga7lAgH0HbNAS5IkdTILdAusrEBvuXYH2gItSZLU2SzQLVCpQN9KAQKGT4znHUeSJEkZskC3QKUCfZUCpa4xJqe6844jSZKkDFmgW6BSgYFKgWL3BDMzeaeRJElSlizQLbC6CoPVAuWeCcadwSFJktTRLNAtUKnA0HqBct8Eo6N5p5EkSVKWLNAtUCrByEaBSt8EQ0N5p5EkSVKWLNAtUComRjYKrA+7C6EkSVKns0C3wMr1VXq31tgYcQ1oSZKkTmeBboHNawUSwIQFWpIkqdNZoPeoWoW0WIAEPVMWaEmSpE5ngd6j1VXYuu423pIkSYeFBXqPKpUvFeiRUxZoSZKkTmeB3qPVVYjCIgSM32WBliRJ6nQW6D1aXYXuYoFEFyMzI3nHkSRJUsYs0Hu0ugr9lQLFngmGRx1OSZKkTmfj26NKBQaqBUo9E4x4A1qSJKnjWaD3aHUVhtcs0JIkSYeFBXqPVldhaL3ASu8EQ0N5p5EkSVLWLNB7VC7DyHqBSv8E/f15p5EkSVLWLNB7VFxOjGzWCnRvb95pJEmSlDUL9B5V5kt0pS3Whyfo6ck7jSRJkrJmgd6D9XXYWCiQgDTuJiqSJEmHgQV6D8pliKXaNt4xaYGWJEk6DCzQe/D/C3SC3mkLtCRJ0mFggd6Dchm6lmt3oPuPW6AlSZIOAwv0HqysQFexAAFDJyzQkiRJh4EFeg/KZehfKbBBL6PHBvOOI0mSpH1ggd6Dchn6KwWK3RMcnYq840iSJGkfWKD3oFyGgdUCxZ4JxsfzTiNJkqT9YIHeg3IZBqoFyj0TjI3lnUaSJEn7wQJ9h7a2ah8iHForUOr1DrQkSdJhYYG+Q5UKVKswvF6g0jfBoJ8hlCRJOhQs0HeoXIa1yibDG8tUBycYGMg7kSRJkvaDBfoOlcvQc30OUqIydpwuR1KSJOlQsPbdoXIZeheukBKsT83mHUeSJEn7xAJ9h4rFeoEG0owFWpIk6bCwQN+hCxdgtHwFgL4zMzmnkSRJ0n6xQN+BpSUoFGCseJlC9xTTJ/vyjiRJkqR9YoG+A88/X/s6uHSVa/2zHD2abx5JkiTtHwv0HXj+eRgbg+GlyywOzDI5mXciSZIk7RcLdJNWVuDqVRgZ2mJ05SrF4Vmmp/NOJUmSpP1igW7Sk09CSjBaXaBrc4PS2AmncEiSJB0iFugmbGzAU0/B3XfD2vmrbCXYmJ5leDjvZJIkSdovFugmPPMMVKvwspfB6rOXwQItSZJ06Figm/CFL8DkJMzMwPr5K0TA1rEZenryTiZJkqT9YoFu0Npa7cODZ87U5kD3XniWQv8xRqYH844mSZKkfWSBbtDly7C1VSvQ8/MwvfA0l8bu48iRvJNJkiRpP1mgG3T+PPT1wfHj8PxTZabKz3N5/H5X4JAkSTpkLNANunABTp6Eri4o/PHnICWuTt7H1FTeySRJkrSfLNANWFyEchlOn64db3zmKQiYO+oUDkmSpMPG9SMaMDkJDz8MAwNQKED/s09RGJgljkwyOpp3OkmSJO0n70A3aGwMVlfhwx+G6fmneeHIfQwP4xrQkiRJh4wFukHFYq089y5f4/j6BS6N38/IiAVakiTpsLFAN6BUqpXn9XV4A7/L1hY8PfN1jIzUpnVIkiTp8LBAN6CnB0ZH4Y1vhK3f+e9cPfoS5ofu4uxZiMg7nSRJkvaTBboBAwPw5jfD8KXPs/H0Mzx735vo6YF77sk7mSRJkvabBboJc4/8FlvdPVx56TcyPAynTuWdSJIkSfvNAt2ouTmGP/5bLL/mjVxYHmdiAqan8w4lSZKk/WaBblD53b9E2tik+JZ/xPx8bfqG858lSZIOHzdSacTVq6QPfYjnX/EQ5eETVKvw0pfmHUqSJEl5sEA3YmSEz3/127j+mm/h4hdgaAjuuivvUJIkScpDplM4IuLBiPhcRJyLiHft8P3XRsRSRDxRf/yrLPPcqRIjPP7AOzj2shmefRaOHKk9JEmSdPhkdgc6IrqBdwPfAFwEHouIR1NKT9300v+ZUnpzVjlaob8fXvc62NqC5WV4yUuguzvvVJIkScpDlnegXwWcSyk9m1JaAz4APJThz8tMb2/tQ4NXrtR2JXzxi/NOJEmSpLxkWaBPAhe2HV+sn7vZX4mIT0fE70bEV2WYZ08+/3l44gk4dgxmZ/NOI0mSpLxk+SHCnRZ5Szcd/ylwV0qpFBFvBH4LuPfL3iji7cDbAc6cOdPqnLd1/Tp88pO1Dw+ePev6z5IkSYdZlnegLwKntx2fAi5vf0FKaTmlVKo//wjQGxFTN79RSumRlNIDKaUHpnNor5OT8PKX1+4+9/bWjiVJknQ4ZVmgHwPujYizEdEHPAw8uv0FETETUduOJCJeVc9zLcNMd6RSgQsX4IUX4NWvhi63n5EkSTq0MpvCkVLaiIh3Ah8DuoH3ppSejIh31L//HuBvAd8VERtABXg4pXTzNI/cdXXVVuB4/etd/1mSJOmwizbsq7f0wAMPpMcff3zff25Kbt0tSZJ0mETEp1JKD9x83skIDbI8S5IkCSzQkiRJUlMs0JIkSVITLNCSJElSEyzQkiRJUhMs0JIkSVITLNCSJElSEyzQkiRJUhMs0JIkSVITLNCSJElSEyzQkiRJUhMs0JIkSVITLNCSJElSEyzQkiRJUhMs0JIkSVITLNCSJEkHwVlhAAAGo0lEQVRSEyzQkiRJUhMs0JIkSVITIqWUd4amRMQ88HxOP34KWMjpZx9EjldzHK/mOF7Nc8ya43g1x/FqnmPWnDzG666U0vTNJw9cgc5TRDyeUnog7xwHhePVHMerOY5X8xyz5jhezXG8mueYNaedxsspHJIkSVITLNCSJElSEyzQzXkk7wAHjOPVHMerOY5X8xyz5jhezXG8mueYNadtxss50JIkSVITvAMtSZIkNcEC3YCIeDAiPhcR5yLiXXnnaUcR8VxE/FlEPBERj9fPHYmIj0fEM/Wvk3nnzFNEvDci5iLis9vO7TpGEfGD9WvucxHx+nxS52eX8fqRiLhUv86eiIg3bvveYR+v0xHxBxHxdEQ8GRHfWz/vNbaDW4yX19gOImIgIv4kIj5dH69/Uz/v9bWLW4yZ19gtRER3RPzfiPhw/bg9r7GUko9bPIBu4AvAVwB9wKeB+/PO1W4P4Dlg6qZzPwm8q/78XcBP5J0z5zH6WuCVwGdvN0bA/fVrrR84W78Gu/P+M7TBeP0I8H07vNbxglnglfXno8Dn6+PiNdbceHmN7TxeAYzUn/cCfwx8tdfXHY2Z19itx+2fA78GfLh+3JbXmHegb+9VwLmU0rMppTXgA8BDOWc6KB4C3ld//j7gW3LMkruU0ieB6zed3m2MHgI+kFKqppS+CJyjdi0eGruM124cr5SupJT+tP68CDwNnMRrbEe3GK/dHPbxSimlUv2wt/5IeH3t6hZjtptDP2YRcQp4E/AL20635TVmgb69k8CFbccXufVfsodVAn4vIj4VEW+vnzueUroCtX+sgGO5pWtfu42R193u3hkRn6lP8bjxqzzHa5uIuBv4i9TueHmN3cZN4wVeYzuq/2r9CWAO+HhKyevrNnYZM/Aa281PAz8AbG0715bXmAX69mKHcy5d8uVek1J6JfAG4Lsj4mvzDnTAed3t7OeAFwGvAK4A/65+3vGqi4gR4DeAf5pSWr7VS3c4d+jGbIfx8hrbRUppM6X0CuAU8KqIeMktXn7oxwt2HTOvsR1ExJuBuZTSpxr9T3Y4t2/jZYG+vYvA6W3Hp4DLOWVpWymly/Wvc8CHqP0a5YWImAWof53LL2Hb2m2MvO52kFJ6of4P0hbw83zp13WOFxARvdTK4PtTSr9ZP+01toudxstr7PZSSgXgD4EH8fpqyPYx8xrb1WuAb46I56hNl31dRPwqbXqNWaBv7zHg3og4GxF9wMPAozlnaisRMRwRozeeA98IfJbaOL2t/rK3Ab+dT8K2ttsYPQo8HBH9EXEWuBf4kxzytZUbf4nWfSu16wwcLyIigF8Enk4p/ftt3/Ia28Fu4+U1trOImI6IifrzQeBvAH+O19eudhszr7GdpZR+MKV0KqV0N7Wu9T9SSn+PNr3GevbrBx1UKaWNiHgn8DFqK3K8N6X0ZM6x2s1x4EO1f4/oAX4tpfTRiHgM+GBEfCdwHvjbOWbMXUT8OvBaYCoiLgL/GvhxdhijlNKTEfFB4ClgA/julNJmLsFzsst4vTYiXkHt13TPAf8YHK+61wB/H/iz+pxLgH+J19hudhuvt3qN7WgWeF9EdFO7+fbBlNKHI+KP8PrazW5j9iteY01py7/D3IlQkiRJaoJTOCRJkqQmWKAlSZKkJligJUmSpCZYoCVJkqQmWKAlSZKkJligJekAiYjNiHhi2+NdLXzvuyPis7d/pSQdbq4DLUkHS6W+NbAkKSfegZakDhARz0XET0TEn9Qf99TP3xURvx8Rn6l/PVM/fzwiPhQRn64/vqb+Vt0R8fMR8WRE/F59BzVJ0jYWaEk6WAZvmsLxlm3fW04pvQr4WeCn6+d+FvjllNLLgPcDP1M//zPAJ1JKLwdeCdzYYfVe4N0ppa8CCsC3ZfznkaQDx50IJekAiYhSSmlkh/PPAa9LKT0bEb3A1ZTS0YhYAGZTSuv181dSSlMRMQ+cSilVt73H3cDHU0r31o//BdCbUvrR7P9kknRweAdakjpH2uX5bq/ZSXXb8038rIwkfRkLtCR1jrds+/pH9ef/B3i4/vzvAv+r/vz3ge8CiIjuiBjbr5CSdNB5Z0GSDpbBiHhi2/FHU0o3lrLrj4g/pnZz5K31c98DvDcivh+YB76jfv57gUci4jup3Wn+LuBK5uklqQM4B1qSOkB9DvQDKaWFvLNIUqdzCockSZLUBO9AS5IkSU3wDrQkSZLUBAu0JEmS1AQLtCRJktQEC7QkSZLUBAu0JEmS1AQLtCRJktSE/wewxxcj3y6fygAAAABJRU5ErkJggg==\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": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, y = sklearn.datasets.fetch_openml('mnist_784', version=1, return_X_y=True)\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": 11,
   "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": 12,
   "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": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100% (1000 of 1000) |####################| Elapsed Time: 0:00:58 Time:  0:00:58\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": 14,
   "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.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}