Dubey_Suprio_Lab3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Machine Learning LAB 3\n",
    "# IMAGE CLASSIFICATION WITH NEURAL NETWORKS\n",
    "Course 2022/23: P. Zanuttigh, F. Barbato, M. Mel\n",
    "\n",
    "The notebook contains some simple tasks to be performed with **NEURAL NETWORKS (NNs)**. <br>\n",
    "Complete all the **required code sections** and **answer to all the questions**. <br>\n",
    "\n",
    "### IMPORTANT for the evaluation score:\n",
    "1. **Read carefully all cells** and **follow the instructions**\n",
    "2. **Re-run all the code from the beginning** to obtain the results for the final version of your notebook, since this is the way we will do it before evaluating your notebooks.\n",
    "3. Make sure to fill the code in the appropriate places **without modifying the template**, otherwise you risk breaking later cells.\n",
    "4. Please **submit the jupyter notebook file (.ipynb)**, do not submit python scripts (.py) or plain text files. **Make sure that it runs fine with the restat&run all command**.\n",
    "5. **Answer the questions in the appropriate cells**, not in the ones where the question is presented."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Clothes Classification with Neural Networks\n",
    "\n",
    "In this notebook we are going to explore the Neural Networks for image classification. We are going to use [**Fashion MNIST**](https://github.com/zalandoresearch/fashion-mnist), a dataset of small images of clothes and accessories.\n",
    "\n",
    "The dataset labels are the following:\n",
    "\n",
    "| Label | Description |\n",
    "| --- | --- |\n",
    "| 0 | T-shirt/top |\n",
    "| 1 | Trouser |\n",
    "| 2 | Pullover |\n",
    "| 3 | Dress |\n",
    "| 4 | Coat |\n",
    "| 5 | Sandal |\n",
    "| 6 | Shirt |\n",
    "| 7 | Sneaker |\n",
    "| 8 | Bag |\n",
    "| 9 | Ankle boot |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "scikit-learn version:  1.0.2\n"
     ]
    }
   ],
   "source": [
    "# load the required packages and check Scikit-learn version\n",
    "%matplotlib inline  \n",
    "\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "import pandas as pd\n",
    "\n",
    "import sklearn\n",
    "print ('scikit-learn version: ', sklearn.__version__)\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.svm import SVC\n",
    "\n",
    "#from sklearnex import patch_sklearn # if you have an Intel CPU and have installed the Intel MKL \n",
    "#patch_sklearn()                     # library you can uncomment these lines for a speedup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# helper function to load Fashion MNIST dataset from disk\n",
    "def load_mnist(path, kind='train'):\n",
    "    import os\n",
    "    import gzip\n",
    "    import numpy as np\n",
    "    labels_path = os.path.join(path, '%s-labels-idx1-ubyte.gz' % kind)\n",
    "    images_path = os.path.join(path, '%s-images-idx3-ubyte.gz' % kind)\n",
    "    with gzip.open(labels_path, 'rb') as lbpath:\n",
    "        labels = np.frombuffer(lbpath.read(), dtype=np.uint8,offset=8)\n",
    "    with gzip.open(images_path, 'rb') as imgpath:\n",
    "        images = np.frombuffer(imgpath.read(), dtype=np.uint8,offset=16).reshape(len(labels), 784)\n",
    "    return images, labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Place your **name** and **ID number** (matricola) in the cell below. <br>\n",
    "Also recall to **save the file as Surname_Name_LAB3.ipynb**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Student name**: Dubey Suprio<br>\n",
    "**ID Number**: 2013036"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A) Hyperparameter Search"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TO DO A.0:** **Set** the random **seed** using your **ID**. If you need to change it for testing add a constant explicitly, eg.: `ID = 1234567 + 1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "ID = 2013036+10\n",
    "np.random.seed(ID)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before proceding to the training steps, we **load the dataset**. <br>\n",
    "The **split** is **performed after applying a random permutation** to the dataset, such permutation will **depend on the seed** you set above.<br><br>\n",
    "**DO NOT CHANGE THE PRE-WRITTEN CODE UNLESS OTHERWISE SPECIFIED**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of samples in the MNIST dataset: 60000\n"
     ]
    }
   ],
   "source": [
    "# load the MNIST dataset\n",
    "X, y = load_mnist(\"data\")\n",
    "print(\"Number of samples in the MNIST dataset:\", X.shape[0])\n",
    "# rescale the data to [0, 1]\n",
    "X = X / 255.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TO DO A.1:** **Divide** the **data into training and test set** using a **500** samples in the **training set**. <br>\n",
    "Make sure that **each label** is present at **least 10 times** in training frequencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Labels in training dataset:  [0 1 2 3 4 5 6 7 8 9]\n",
      "Frequencies in training dataset:  [48 53 48 48 50 45 52 43 64 49]\n"
     ]
    }
   ],
   "source": [
    "# randomly permute the data and split into training and test taking \n",
    "# the first 500 data samples as training and the rests as test\n",
    "m = X.shape[0]\n",
    "permutation = np.random.permutation(m) # ADD YOUR CODE HERE\n",
    "\n",
    "X = X[permutation]\n",
    "y = y[permutation]\n",
    "\n",
    "m_training = 500# ADD YOUR CODE HERE\n",
    "\n",
    "X_train, X_test = X[:m_training],X[m_training:]# ADD YOUR CODE HERE\n",
    "y_train, y_test = y[:m_training],y[m_training:]# ADD YOUR CODE HERE\n",
    "\n",
    "labels, freqs = np.unique(y_train, return_counts=True) # ADD YOUR CODE HERE\n",
    "print(\"Labels in training dataset: \", labels)\n",
    "print(\"Frequencies in training dataset: \", freqs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function for plotting a image and printing the corresponding label\n",
    "def plot_input(X_matrix, labels, index):\n",
    "    print(\"INPUT:\")\n",
    "    plt.imshow(\n",
    "        X_matrix[index].reshape(28,28),\n",
    "        cmap          = plt.cm.gray_r,\n",
    "        interpolation = \"nearest\"\n",
    "    )\n",
    "    plt.show()\n",
    "    print(\"LABEL: %i\"%labels[index])\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INPUT:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaEAAAGdCAYAAAC7EMwUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAdJklEQVR4nO3df2xV9f3H8delwKWU2zsrtvdWam0czk0Mi/I7/gAXGpuMiGiCmiwlJkYnkJFqnIwsdltCnYvETabL1yxMgkz+8VcmE2ugRcMwyOok4EidxZbRrqNAbynlltLP9w/CzWoB+Rzv7bu3fT6Sm9hzz4vz8XDaF4d775uQc84JAAADY6wXAAAYvSghAIAZSggAYIYSAgCYoYQAAGYoIQCAGUoIAGCGEgIAmBlrvYCv6u/v15EjRxSJRBQKhayXAwDw5JxTV1eXiouLNWbMpe91hl0JHTlyRCUlJdbLAAB8Qy0tLZoyZcol9xl2JRSJRCSdW3x+fr7xagAAvhKJhEpKSlI/zy8lYyX04osv6je/+Y1aW1t144036vnnn9dtt932tbnzfwWXn59PCQFAFrucl1Qy8saELVu2aNWqVVqzZo0aGhp02223qaKiQs3NzZk4HAAgS4UyMUV79uzZuvnmm/XSSy+ltn33u9/V4sWLVVNTc8lsIpFQNBpVZ2cnd0IAkIV8fo6n/U6ot7dXe/fuVXl5+YDt5eXl2rVr16D9k8mkEonEgAcAYHRIewkdPXpUZ8+eVVFR0YDtRUVFamtrG7R/TU2NotFo6sE74wBg9MjYh1W/+oKUc+6CL1KtXr1anZ2dqUdLS0umlgQAGGbS/u64yZMnKycnZ9BdT3t7+6C7I0kKh8MKh8PpXgYAIAuk/U5o/PjxuuWWW1RbWztge21trebNm5fuwwEAslhGPidUVVWlH/3oR5oxY4bmzp2r//u//1Nzc7MeffTRTBwOAJClMlJCS5cuVUdHh375y1+qtbVV06ZN09atW1VaWpqJwwEAslRGPif0TfA5IQDIbqafEwIA4HJRQgAAM5QQAMAMJQQAMEMJAQDMUEIAADOUEADADCUEADBDCQEAzFBCAAAzlBAAwAwlBAAwQwkBAMxQQgAAM5QQAMAMJQQAMEMJAQDMUEIAADOUEADADCUEADBDCQEAzFBCAAAzlBAAwAwlBAAwQwkBAMxQQgAAM5QQAMAMJQQAMEMJAQDMUEIAADOUEADADCUEADBDCQEAzFBCAAAzlBAAwAwlBAAwQwkBAMxQQgAAM5QQAMAMJQQAMEMJAQDMUEIAADOUEADADCUEADBDCQEAzFBCAAAzlBAAwAwlBAAwQwkBAMxQQgAAM5QQAMAMJQQAMEMJAQDMUEIAADOUEADATNpLqLq6WqFQaMAjFoul+zAAgBFgbCZ+0RtvvFHvv/9+6uucnJxMHAYAkOUyUkJjx47l7gcA8LUy8ppQY2OjiouLVVZWpvvvv19ffPHFRfdNJpNKJBIDHgCA0SHtJTR79mxt3LhR27Zt08svv6y2tjbNmzdPHR0dF9y/pqZG0Wg09SgpKUn3kgAAw1TIOecyeYDu7m5dd911evLJJ1VVVTXo+WQyqWQymfo6kUiopKREnZ2dys/Pz+TSAAAZkEgkFI1GL+vneEZeE/pfeXl5uummm9TY2HjB58PhsMLhcKaXAQAYhjL+OaFkMqnPPvtM8Xg804cCAGSZtJfQE088ofr6ejU1Nemjjz7Sfffdp0QiocrKynQfCgCQ5dL+13GHDx/WAw88oKNHj+qqq67SnDlztHv3bpWWlqb7UACALJf2EnrttdfS/UsCAEYoZscBAMxQQgAAM5QQAMAMJQQAMEMJAQDMUEIAADOUEADADCUEADBDCQEAzFBCAAAzlBAAwAwlBAAwk/F/1A74X/39/d6ZMWP4s5Ik/eUvf/HObNy4MdCxIpGIdyY3N9c7c+bMGe/M6dOnvTO9vb3eGUkaP368d+bKK6/0zvT19XlnDh8+7J2RpGg06p3ZsGFDoGNdDr67AQBmKCEAgBlKCABghhICAJihhAAAZighAIAZSggAYIYSAgCYoYQAAGYoIQCAGUoIAGCGEgIAmKGEAABmmKIN/I+hmvL917/+1Tvz0EMPeWdmzZrlnZGk1tZW78yJEye8M0GmRweZoh3k9zWoIMeKxWLemSDnQZJuvfXWQLlM4U4IAGCGEgIAmKGEAABmKCEAgBlKCABghhICAJihhAAAZighAIAZSggAYIYSAgCYoYQAAGYoIQCAGQaYYkgFGfYZhHMuUG6o1ldTU+Od+d73vuedycnJ8c5IUigU8s5MmDAh0LF85ebmemfy8vICHSvIgNXOzk7vTJDfp6Dn+4YbbgiUyxTuhAAAZighAIAZSggAYIYSAgCYoYQAAGYoIQCAGUoIAGCGEgIAmKGEAABmKCEAgBlKCABghhICAJhhgClGpP7+/kC5IIMkz5w54505ceKEd6a0tNQ7c+zYMe+MJJ09e9Y7E2T4a1dXl3cmmUx6Z3p6erwzUrAhoadPn/bOFBQUeGeG+5DeyzW8VgMAGFUoIQCAGe8S2rlzpxYtWqTi4mKFQiG9+eabA553zqm6ulrFxcXKzc3V/PnztX///nStFwAwgniXUHd3t6ZPn67169df8Plnn31W69at0/r167Vnzx7FYjEtXLgw0N/9AgBGNu83JlRUVKiiouKCzznn9Pzzz2vNmjVasmSJJOmVV15RUVGRNm/erEceeeSbrRYAMKKk9TWhpqYmtbW1qby8PLUtHA7rjjvu0K5duy6YSSaTSiQSAx4AgNEhrSXU1tYmSSoqKhqwvaioKPXcV9XU1CgajaYeJSUl6VwSAGAYy8i740Kh0ICvnXODtp23evVqdXZ2ph4tLS2ZWBIAYBhK64dVY7GYpHN3RPF4PLW9vb190N3ReeFwWOFwOJ3LAABkibTeCZWVlSkWi6m2tja1rbe3V/X19Zo3b146DwUAGAG874ROnjypzz//PPV1U1OTPvnkExUUFOiaa67RqlWrtHbtWk2dOlVTp07V2rVrNXHiRD344INpXTgAIPt5l9DHH3+sBQsWpL6uqqqSJFVWVupPf/qTnnzySfX09Oixxx7T8ePHNXv2bL333nuKRCLpWzUAYEQIuaBT8DIkkUgoGo2qs7NT+fn51svBKLNjxw7vzK9//WvvzKlTp7wzEydO9M5c7A1BXyfIEM4gQ1mDvB4cZIDpyZMnvTOS1NnZ6Z0ZO9b/pfYZM2Z4Z1pbW70zkjR37lzvzO9+9zuv/X1+jjM7DgBghhICAJihhAAAZighAIAZSggAYIYSAgCYoYQAAGYoIQCAGUoIAGCGEgIAmKGEAABmKCEAgBlKCABghinaQyTIaQ46AdlX0EsgyPr6+vq8M0GmEm/atMk7I0nr1q3zznzrW9/yzpw9e9Y7k0gkvDPRaNQ7IwWbVN3V1eWdGaprvLe3N1AuyOTyobrGJ0yY4J2Rzv1zPL6am5u99u/q6tJ3vvMdpmgDAIY3SggAYIYSAgCYoYQAAGYoIQCAGUoIAGCGEgIAmKGEAABmKCEAgBlKCABghhICAJihhAAAZvyn5iGQoRrUGGQwZk5OTqBjnTlzxjszbtw478z777/vnfntb3/rnZGkKVOmeGeCDKw8ffq0dybIQN8gg0ilYAM/g/zeDtU1FGTIrBTs+/bo0aPemSDfg5MmTfLOSNIVV1zhndm3b5/X/t3d3Ze9L3dCAAAzlBAAwAwlBAAwQwkBAMxQQgAAM5QQAMAMJQQAMEMJAQDMUEIAADOUEADADCUEADBDCQEAzDDAdBhzznlnggxC9Bk2+L/y8vK8MwcPHvTO/PSnP/XOXHnlld4ZServ7/fOjB3r/20UZPhkkGGfp06d8s5IwYZwjhnj/2faIMNIgwxXPXbsmHdGko4fP+6dKS4u9s5EIhHvTNABpkVFRd6Zjo4Or/19rjvuhAAAZighAIAZSggAYIYSAgCYoYQAAGYoIQCAGUoIAGCGEgIAmKGEAABmKCEAgBlKCABghhICAJhhgOkQ6evrG5LjBBmmGWQQaVBPPfWUd+a6667zzlx77bXeGUn65z//6Z0JhUKBjuUryKBZ38GT5wUZfBrkPOTm5npnenp6vDNBv/+CXHunT5/2zgRZX5Bhu1KwnxGfffaZ1/7JZPKy9+VOCABghhICAJjxLqGdO3dq0aJFKi4uVigU0ptvvjng+WXLlikUCg14zJkzJ13rBQCMIN4l1N3drenTp2v9+vUX3eeuu+5Sa2tr6rF169ZvtEgAwMjk/QpVRUWFKioqLrlPOBxWLBYLvCgAwOiQkdeE6urqVFhYqOuvv14PP/yw2tvbL7pvMplUIpEY8AAAjA5pL6GKigq9+uqr2r59u5577jnt2bNHd95550XfsldTU6NoNJp6lJSUpHtJAIBhKu2fE1q6dGnqv6dNm6YZM2aotLRU77zzjpYsWTJo/9WrV6uqqir1dSKRoIgAYJTI+IdV4/G4SktL1djYeMHnw+GwwuFwppcBABiGMv45oY6ODrW0tCgej2f6UACALON9J3Ty5El9/vnnqa+bmpr0ySefqKCgQAUFBaqurta9996reDyuQ4cO6Wc/+5kmT56se+65J60LBwBkP+8S+vjjj7VgwYLU1+dfz6msrNRLL72kffv2aePGjTpx4oTi8bgWLFigLVu2KBKJpG/VAIARwbuE5s+fL+fcRZ/ftm3bN1rQec65Sx7nQvsHOUYQOTk53pkgQwOHyj/+8Y9AuZqaGu9MeXm5d2b//v3emaamJu+MJB07dsw7c+bMGe9MV1eXdyY/P9878+1vf9s7I0njx4/3zhw5csQ78+WXX3pngryGHI1GvTNSsOvhv//9r3cmyHmYNWuWd0aSJkyY4J3xHRrLAFMAQFaghAAAZighAIAZSggAYIYSAgCYoYQAAGYoIQCAGUoIAGCGEgIAmKGEAABmKCEAgBlKCABghhICAJgZtqOdfadojxkzvPv0xIkT3pmPPvrIO7NlyxbvjO+E3PNeeOEF78xVV13lnamurvbOHD582DsjKdA/OXL06FHvTJAJ7kEmLZ8+fdo7I0l5eXneme9///vemWuvvdY709bWNiTHkaT+/n7vTCKR8M78+9//9s5MnDjROyP5Tbg+z3fydigUuux9h/dPbgDAiEYJAQDMUEIAADOUEADADCUEADBDCQEAzFBCAAAzlBAAwAwlBAAwQwkBAMxQQgAAM5QQAMDMsB1gOmbMGK+hpAcOHPA+xltvveWdkYINADx06JB3pqCgwDvz0EMPeWemTJninZGkTZs2eWf+9a9/eWeOHTvmnWlubvbOSNLx48e9M7m5ud4ZnwGP58ViMe/MpEmTvDNSsAGmQYZwnjp1yjtTWFjonWloaPDOSMEGzQa5HoIMSu3o6PDOSNJ//vOfjB+rt7f3svflTggAYIYSAgCYoYQAAGYoIQCAGUoIAGCGEgIAmKGEAABmKCEAgBlKCABghhICAJihhAAAZighAICZYTvA9MCBA17DF3/yk594HyPI0EAp2IBCn2Gs5yUSCe/MCy+84J0JMkxTCjYUsqioyDszdqz/ZTp+/HjvjCRFo1HvTJDzN2HCBO9MkGGaQYZVSlJjY6N35uqrr/bOXHPNNd6Zo0ePemeCmjhxonemp6fHOxNkkGuQ7wtJKi0t9c6Ew+FAx7oc3AkBAMxQQgAAM5QQAMAMJQQAMEMJAQDMUEIAADOUEADADCUEADBDCQEAzFBCAAAzlBAAwAwlBAAwM2wHmO7fv99reGCQgZVdXV3eGUk6duyYdyYnJyfQsXwFGZ4YdNjnFVdc4Z05fvy4dybIwMqgw2nz8vKG5FhffvmldybI2u677z7vjCRt2rTJOzNr1izvzBtvvOGdefDBB70zQQbnSsEGwJ49e9Y7E2RYcZCMFGx4ru+1d+bMmcvelzshAIAZSggAYMarhGpqajRz5kxFIhEVFhZq8eLFOnjw4IB9nHOqrq5WcXGxcnNzNX/+fO3fvz+tiwYAjAxeJVRfX6/ly5dr9+7dqq2tVV9fn8rLy9Xd3Z3a59lnn9W6deu0fv167dmzR7FYTAsXLgz8+gsAYOTyemPCu+++O+DrDRs2qLCwUHv37tXtt98u55yef/55rVmzRkuWLJEkvfLKKyoqKtLmzZv1yCOPpG/lAICs941eE+rs7JQkFRQUSJKamprU1tam8vLy1D7hcFh33HGHdu3adcFfI5lMKpFIDHgAAEaHwCXknFNVVZVuvfVWTZs2TZLU1tYmafDbIYuKilLPfVVNTY2i0WjqUVJSEnRJAIAsE7iEVqxYoU8//VR//vOfBz0XCoUGfO2cG7TtvNWrV6uzszP1aGlpCbokAECWCfRh1ZUrV+rtt9/Wzp07NWXKlNT2WCwm6dwdUTweT21vb2+/6IfFwuGwwuFwkGUAALKc152Qc04rVqzQ66+/ru3bt6usrGzA82VlZYrFYqqtrU1t6+3tVX19vebNm5eeFQMARgyvO6Hly5dr8+bNeuuttxSJRFKv80SjUeXm5ioUCmnVqlVau3atpk6dqqlTp2rt2rWaOHFioFEbAICRzauEXnrpJUnS/PnzB2zfsGGDli1bJkl68skn1dPTo8cee0zHjx/X7Nmz9d577ykSiaRlwQCAkSPknHPWi/hfiURC0WhUnZ2dys/Pz+ixDh8+HCh34MAB78zf//5378yRI0e8M0GGfQbJSOde6/M1btw470yQP8BceeWV3hkp2FDWmTNnemcWLlzonbn22mu9M8Ndc3Ozd6aystI7c/PNN3tnpHMfIfEVZKBtkCHCkyZN8s5I514i8fWDH/zAa//u7m7de++9l/VznNlxAAAzlBAAwAwlBAAwQwkBAMxQQgAAM5QQAMAMJQQAMEMJAQDMUEIAADOUEADADCUEADBDCQEAzFBCAAAzo3qKNgAg/Xx+jnMnBAAwQwkBAMxQQgAAM5QQAMAMJQQAMEMJAQDMUEIAADOUEADADCUEADBDCQEAzFBCAAAzlBAAwAwlBAAwQwkBAMxQQgAAM5QQAMAMJQQAMEMJAQDMUEIAADOUEADADCUEADBDCQEAzFBCAAAzlBAAwAwlBAAwQwkBAMxQQgAAM5QQAMAMJQQAMEMJAQDMUEIAADOUEADADCUEADBDCQEAzFBCAAAzlBAAwAwlBAAwQwkBAMxQQgAAM5QQAMAMJQQAMONVQjU1NZo5c6YikYgKCwu1ePFiHTx4cMA+y5YtUygUGvCYM2dOWhcNABgZvEqovr5ey5cv1+7du1VbW6u+vj6Vl5eru7t7wH533XWXWltbU4+tW7emddEAgJFhrM/O77777oCvN2zYoMLCQu3du1e33357ans4HFYsFkvPCgEAI9Y3ek2os7NTklRQUDBge11dnQoLC3X99dfr4YcfVnt7+0V/jWQyqUQiMeABABgdQs45FyTonNPdd9+t48eP64MPPkht37JliyZNmqTS0lI1NTXp5z//ufr6+rR3716Fw+FBv051dbV+8YtfDNre2dmp/Pz8IEsDABhKJBKKRqOX9XM8cAktX75c77zzjj788ENNmTLlovu1traqtLRUr732mpYsWTLo+WQyqWQyOWDxJSUllBAAZCmfEvJ6Tei8lStX6u2339bOnTsvWUCSFI/HVVpaqsbGxgs+Hw6HL3iHBAAY+bxKyDmnlStX6o033lBdXZ3Kysq+NtPR0aGWlhbF4/HAiwQAjExeb0xYvny5Nm3apM2bNysSiaitrU1tbW3q6emRJJ08eVJPPPGE/va3v+nQoUOqq6vTokWLNHnyZN1zzz0Z+R8AAGQvr9eEQqHQBbdv2LBBy5YtU09PjxYvXqyGhgadOHFC8XhcCxYs0K9+9SuVlJRc1jF8/i4RADD8ZOw1oa/rq9zcXG3bts3nlwQAjGLMjgMAmKGEAABmKCEAgBlKCABghhICAJihhAAAZighAIAZSggAYIYSAgCYoYQAAGYoIQCAGUoIAGCGEgIAmKGEAABmKCEAgBlKCABghhICAJihhAAAZighAIAZSggAYIYSAgCYoYQAAGYoIQCAGUoIAGCGEgIAmBlrvYCvcs5JkhKJhPFKAABBnP/5ff7n+aUMuxLq6uqSJJWUlBivBADwTXR1dSkajV5yn5C7nKoaQv39/Tpy5IgikYhCodCA5xKJhEpKStTS0qL8/HyjFdrjPJzDeTiH83AO5+Gc4XAenHPq6upScXGxxoy59Ks+w+5OaMyYMZoyZcol98nPzx/VF9l5nIdzOA/ncB7O4TycY30evu4O6DzemAAAMEMJAQDMZFUJhcNhPf300wqHw9ZLMcV5OIfzcA7n4RzOwznZdh6G3RsTAACjR1bdCQEARhZKCABghhICAJihhAAAZrKqhF588UWVlZVpwoQJuuWWW/TBBx9YL2lIVVdXKxQKDXjEYjHrZWXczp07tWjRIhUXFysUCunNN98c8LxzTtXV1SouLlZubq7mz5+v/fv32yw2g77uPCxbtmzQ9TFnzhybxWZITU2NZs6cqUgkosLCQi1evFgHDx4csM9ouB4u5zxky/WQNSW0ZcsWrVq1SmvWrFFDQ4Nuu+02VVRUqLm52XppQ+rGG29Ua2tr6rFv3z7rJWVcd3e3pk+frvXr11/w+WeffVbr1q3T+vXrtWfPHsViMS1cuDA1h3Ck+LrzIEl33XXXgOtj69atQ7jCzKuvr9fy5cu1e/du1dbWqq+vT+Xl5eru7k7tMxquh8s5D1KWXA8uS8yaNcs9+uijA7bdcMMN7qmnnjJa0dB7+umn3fTp062XYUqSe+ONN1Jf9/f3u1gs5p555pnUttOnT7toNOr+8Ic/GKxwaHz1PDjnXGVlpbv77rtN1mOlvb3dSXL19fXOudF7PXz1PDiXPddDVtwJ9fb2au/evSovLx+wvby8XLt27TJalY3GxkYVFxerrKxM999/v7744gvrJZlqampSW1vbgGsjHA7rjjvuGHXXhiTV1dWpsLBQ119/vR5++GG1t7dbLymjOjs7JUkFBQWSRu/18NXzcF42XA9ZUUJHjx7V2bNnVVRUNGB7UVGR2trajFY19GbPnq2NGzdq27Ztevnll9XW1qZ58+apo6PDemlmzv/+j/ZrQ5IqKir06quvavv27Xruuee0Z88e3XnnnUomk9ZLywjnnKqqqnTrrbdq2rRpkkbn9XCh8yBlz/Uw7KZoX8pX/2kH59ygbSNZRUVF6r9vuukmzZ07V9ddd51eeeUVVVVVGa7M3mi/NiRp6dKlqf+eNm2aZsyYodLSUr3zzjtasmSJ4coyY8WKFfr000/14YcfDnpuNF0PFzsP2XI9ZMWd0OTJk5WTkzPoTzLt7e2D/sQzmuTl5emmm25SY2Oj9VLMnH93INfGYPF4XKWlpSPy+li5cqXefvtt7dixY8A//TLaroeLnYcLGa7XQ1aU0Pjx43XLLbeotrZ2wPba2lrNmzfPaFX2ksmkPvvsM8XjceulmCkrK1MsFhtwbfT29qq+vn5UXxuS1NHRoZaWlhF1fTjntGLFCr3++uvavn27ysrKBjw/Wq6HrzsPFzJsrwfDN0V4ee2119y4cePcH//4R3fgwAG3atUql5eX5w4dOmS9tCHz+OOPu7q6OvfFF1+43bt3ux/+8IcuEomM+HPQ1dXlGhoaXENDg5Pk1q1b5xoaGtyXX37pnHPumWeecdFo1L3++utu37597oEHHnDxeNwlEgnjlafXpc5DV1eXe/zxx92uXbtcU1OT27Fjh5s7d667+uqrR9R5+PGPf+yi0airq6tzra2tqcepU6dS+4yG6+HrzkM2XQ9ZU0LOOff73//elZaWuvHjx7ubb755wNsRR4OlS5e6eDzuxo0b54qLi92SJUvc/v37rZeVcTt27HCSBj0qKyudc+felvv000+7WCzmwuGwu/32292+fftsF50BlzoPp06dcuXl5e6qq65y48aNc9dcc42rrKx0zc3N1stOqwv9/0tyGzZsSO0zGq6HrzsP2XQ98E85AADMZMVrQgCAkYkSAgCYoYQAAGYoIQCAGUoIAGCGEgIAmKGEAABmKCEAgBlKCABghhICAJihhAAAZighAICZ/wfJ6G+OcKW5MgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LABEL: 9\n",
      "INPUT:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LABEL: 4\n",
      "INPUT:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LABEL: 5\n"
     ]
    }
   ],
   "source": [
    "# let's try the plotting function\n",
    "plot_input(X_train,y_train,10)\n",
    "plot_input(X_test,y_test,100)\n",
    "plot_input(X_test,y_test,10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TO DO A.2** Now **use a feed-forward Neural Network** for prediction. <br><br>\n",
    "Use the **multi-layer perceptron** classifier, with the following parameters: <br>\n",
    "`max_iter=250, alpha=1e-4, solver='sgd', tol=1e-4, learning_rate_init=.1, random_state=ID` <br>\n",
    "The `random_state` parameter ensures the run is the same even if you run it more than once, while the `alpha` parameter is the regularization term.<br>\n",
    "You might get some **warnings about the convergence**, ignore them (or try to increase the max_iter parameter if you have a powerful computer). <br>\n",
    "\n",
    "Then, using the default activation function, **pick four or five architectures** to consider, with different numbers of hidden layers and different sizes. <br>\n",
    "It is not necessary to create huge neural networks, you can limit to 3 layers and, for each layer, its maximum size can be of 100. <br>\n",
    "Evaluate the architectures you chose using **GridSearchCV with cv=5**. <br>\n",
    "\n",
    "You can reduce the number of iterations if the running time is too long on your computer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RESULTS FOR NN\n",
      "\n",
      "Best parameters set found: {'hidden_layer_sizes': (25,)}\n",
      "Score with best parameters: 0.776\n",
      "\n",
      "Mean scores on the grid: 0           (10,)\n",
      "1           (25,)\n",
      "2           (50,)\n",
      "3        (25, 10)\n",
      "4    (50, 25, 10)\n",
      "Name: param_hidden_layer_sizes, dtype: object 0    0.684\n",
      "1    0.776\n",
      "2    0.774\n",
      "3    0.596\n",
      "4    0.404\n",
      "Name: mean_test_score, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# these are sample values but feel free to change them as you like, try to experiment with different sizes!!\n",
    "parameters = {'hidden_layer_sizes': [(10,), (25,), (50,), (25,10,), (50,25,10) ]}\n",
    "\n",
    "\n",
    "mlp = MLPClassifier(max_iter=10000, alpha=1e-4, solver='sgd', tol=1e-4, learning_rate_init=.1, random_state=ID)# ADD YOUR CODE HERE\n",
    "\n",
    "mlp_arch_CV = GridSearchCV(mlp,parameters,cv=5)# ADD YOUR CODE HERE\n",
    "mlp_arch_CV.fit(X_train, y_train)\n",
    "\n",
    "print ('RESULTS FOR NN\\n')\n",
    "\n",
    "best_parameter_hl = mlp_arch_CV.best_params_\n",
    "\n",
    "print(\"Best parameters set found:\", best_parameter_hl)\n",
    "# ADD YOUR CODE HERE\n",
    "bestparam_score = mlp_arch_CV.best_score_\n",
    "print(\"Score with best parameters:\",bestparam_score)\n",
    "# ADD YOUR CODE HERE\n",
    "score = mlp_arch_CV.cv_results_\n",
    "all_score = pd.DataFrame.from_dict(score)\n",
    "printparam = all_score.iloc[0:5,4]\n",
    "printscore = all_score.iloc[0:5,11]\n",
    "\n",
    "print(\"\\nMean scores on the grid:\",printparam,printscore)\n",
    "\n",
    "# ADD YOUR CODE HERE\n",
    "#{'hidden_layer_sizes': (25,)} = \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TO DO A.3** Now **try different batch sizes**, while keeping the **best NN** architecture you have found above. <br>\n",
    "Remember that the batch size was previously set to the default value, i.e., `min(200, n_samples)`. <br>\n",
    "\n",
    "Recall that a **batch size of 1 corresponds to baseline SGD**, while using all the **400 training samples** (there are 500 samples but in cross validation with 5 folders we use 1/5 of them for validation at each round) corresponds to **standard GD** and using a different mini-batch size lies in the middle between the two extreme cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RESULTS FOR NN\n",
      "\n",
      "Best parameters set found: {'batch_size': 400}\n",
      "Score with best parameters: 0.7699999999999999\n",
      "\n",
      "All scores on the grid:    mean_fit_time  std_fit_time  mean_score_time  std_score_time  \\\n",
      "0       7.176896      1.053676         0.000772        0.000053   \n",
      "1       0.354892      0.164584         0.000720        0.000035   \n",
      "2       0.544161      0.048918         0.000783        0.000058   \n",
      "\n",
      "  param_batch_size               params  split0_test_score  split1_test_score  \\\n",
      "0                1    {'batch_size': 1}               0.08               0.06   \n",
      "1               32   {'batch_size': 32}               0.71               0.79   \n",
      "2              400  {'batch_size': 400}               0.77               0.77   \n",
      "\n",
      "   split2_test_score  split3_test_score  split4_test_score  mean_test_score  \\\n",
      "0               0.11               0.11               0.10            0.092   \n",
      "1               0.60               0.66               0.63            0.678   \n",
      "2               0.81               0.74               0.76            0.770   \n",
      "\n",
      "   std_test_score  rank_test_score  \n",
      "0        0.019391                3  \n",
      "1        0.066753                2  \n",
      "2        0.022804                1  \n"
     ]
    }
   ],
   "source": [
    "# these are sample values corresponding to baseline SGD, a reasonable mini-batch size and standard GD\n",
    "# again feel free to change them as you like, try to experiment with different batch sizes!!\n",
    "parameters = {'batch_size': [1, 32, 400]}\n",
    "\n",
    "# need to specify that you would like to use the standard k-fold split otherwise sklearn create splits of different sizes\n",
    "kf = sklearn.model_selection.KFold(n_splits=5) # ADD YOUR CODE HERE, suggestion: http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.KFold.html\n",
    "\n",
    "best_hidden_layer_sizes = best_parameter_hl.get('hidden_layer_sizes')# ADD YOUR CODE HERE\n",
    "\n",
    "mlp = MLPClassifier(hidden_layer_sizes=best_hidden_layer_sizes,max_iter=10000, alpha=1e-4, solver='sgd', tol=1e-4, learning_rate_init=.1, random_state=ID) # ADD YOUR CODE HERE\n",
    "\n",
    "# recall to use cv=kf to use the k-fold subdivision seen in the lectures\n",
    "mlp_batch_CV = GridSearchCV(mlp,parameters,cv=kf)# ADD YOUR CODE HERE\n",
    "mlp_batch_CV.fit(X_train, y_train)\n",
    "\n",
    "print ('RESULTS FOR NN\\n')\n",
    "\n",
    "best_parameter_batch = mlp_batch_CV.best_params_\n",
    "print(\"Best parameters set found:\",best_parameter_batch)\n",
    "# ADD YOUR CODE HERE\n",
    "\n",
    "\n",
    "bestparam_score = mlp_batch_CV.best_score_\n",
    "print(\"Score with best parameters:\",bestparam_score)\n",
    "# ADD YOUR CODE HERE\n",
    "\n",
    "\n",
    "score = mlp_batch_CV.cv_results_\n",
    "all_score = pd.DataFrame.from_dict(score)\n",
    "print(\"\\nAll scores on the grid:\",all_score)\n",
    "# ADD YOUR CODE HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TO DO A.Q1**\n",
    "\n",
    "- What do you observe for different architectures and batch sizes? <br>\n",
    "- How do the number of layers and their sizes affect the performances? <br>\n",
    "- What do you observe for different batch sizes, in particular what happens to the training convergence for different batch sizes (notice that the algorithm could not converge for some batch sizes)?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "**ANSWER A.Q1**:<br>\n",
    "answer here\n",
    "    \n",
    "- The results for different architectures and batch sizes are printed above. We see that for different hidden\n",
    "    layer number and sizes the score varies, the scores were better for low number of hidden layers. In my case\n",
    "    the best output was for (25,) with a score 0.7699999999999999 for a default \n",
    "    batch size min(200,n_samples).Then for the given best parameter, I tried to train the model for different\n",
    "    batch size . The best output was for  {batch_size': 400} with a mean test score of 0.77.\n",
    " \n",
    "- It is seen that the less number of layers are giving a better score in comparison to that with higher numbers.\n",
    "    From the result above it is difficult to  say if there is any realtion within the size of the hidden layer and\n",
    "    the score as we get the highest score for (25,) then (50,) followed by (10,). So, I think the with less number\n",
    "    of layers the score improves.\n",
    "\n",
    "- It is seen that for different batch sizes the performance varies. The mean test score increases on increasing\n",
    "    the batch size, i.e on increasing the batch size the error decreases also the fit time decreases.\n",
    "    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TO DO A.4** Now **try** to use **different learning rates**, while keeping the **best NN architecture and batch size you have found above.** <br>\n",
    "**Plot the learning curves** (i.e., the variation of the loss over the steps, you can get it from the loss_curve_ object of sklearn) for the different values of the learning rate. <br>\n",
    "You might get warnings about the convergence, this is expected. Ignore them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0.0004: 0.7883697478991597, 0.004: 0.7832941176470588, 0.04: 0.7823529411764706, 0.4: 0.2678655462184874}\n",
      "RESULTS FOR NN\n",
      "\n",
      "Best parameters set found: 0.0004\n",
      "Score with best parameters: 0.7883697478991597\n"
     ]
    }
   ],
   "source": [
    "lr_list = [4*10**exp for exp in range(-4,0)]\n",
    "scores = {}\n",
    "\n",
    "best_hidden_layer_sizes = best_parameter_hl.get('hidden_layer_sizes')# ADD YOUR CODE HERE\n",
    "best_batch_size = best_parameter_batch.get('batch_size') # ADD YOUR CODE HERE\n",
    "\n",
    "for lr in lr_list: \n",
    "    mlp = MLPClassifier(hidden_layer_sizes=best_hidden_layer_sizes,max_iter=10000, alpha=1e-4, solver='sgd', tol=1e-4, learning_rate_init=lr, random_state=ID,batch_size=best_batch_size)# ADD YOUR CODE HERE\n",
    "    mlp.fit(X_train, y_train)\n",
    "    scores[lr] = mlp.score(X_test,y_test)# ADD YOUR CODE HERE, score on the test set\n",
    "    plt.plot(mlp.loss_curve_, label='lr: ' + str(lr))\n",
    "\n",
    "plt.legend(loc = 1)\n",
    "plt.xlabel('Number of iterations')\n",
    "plt.ylabel('Loss')\n",
    "plt.show()\n",
    "print(scores)\n",
    "best_p =max(scores, key=scores.get)\n",
    "print ('RESULTS FOR NN\\n')\n",
    "print(\"Best parameters set found:\",best_p)\n",
    "# ADD YOUR CODE HERE\n",
    "best_s = max(scores.values())\n",
    "print(\"Score with best parameters:\",best_s)\n",
    "# ADD YOUR CODE HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question A.Q2** Comment about the learning curves (i.e. the variation of the loss over the steps). <br>\n",
    "How does the curve changes for different learning rates in terms of stability and speed of convergence ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "**ANSWER A.Q2**:<br>\n",
    "    We see that, when we increase the learning rate it takes less iteration for it to converge, however the score\n",
    "    is better with a lower learning rate and more itterations.\n",
    "    </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TO DO A.5** Now get **training and test error** for a NN with best parameters (architecture, batch size and learning rate)from above. Plot the learning curve also for this case. <br>\n",
    "As before, you might get a convergence warning, you can safely ignore it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "RESULTS FOR BEST NN\n",
      "\n",
      "Best NN training error: 0.056000\n",
      "Best NN test error: 0.211630\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAG0CAYAAADO5AZFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABH/ElEQVR4nO3deXyU5b338e9k3yf7RkISdggQ9k1FlApiVajaWuvjcnxOe7DgctA+blWsnhZta8Xdaq2I+zkFLEcQxbKpoMgmskWEkASSkH1PJtv9/DHJaEwIEGbmTiaf9+s1LzL33DPzm4uRfL2W+7IYhmEIAADAQ3iZXQAAAIAzEW4AAIBHIdwAAACPQrgBAAAehXADAAA8CuEGAAB4FMINAADwKIQbAADgUQg3AADAoxBuAACARzE13CxZskQTJ05UaGioYmNjNW/ePGVmZnb5nE2bNslisXS4HTp0yE1VAwCAnszHzDffvHmzFixYoIkTJ6qpqUkPPPCAZs2apQMHDig4OLjL52ZmZiosLMxxPyYm5ozes6WlRXl5eQoNDZXFYjmn+gEAgHsYhqGqqiolJibKy6vrvhlLT9o4s6ioSLGxsdq8ebOmT5/e6TmbNm3SRRddpLKyMoWHh5/1exw/flzJycnnWCkAADBDbm6ukpKSujzH1J6bH6qoqJAkRUZGnvbcsWPHqr6+XiNGjNBvf/tbXXTRRZ2eZ7PZZLPZHPfbslxubm67nh8AANBzVVZWKjk5WaGhoac9t8eEG8MwtGjRIp1//vkaOXLkKc9LSEjQSy+9pPHjx8tms+n111/XzJkztWnTpk57e5YsWaLf/e53HY6HhYURbgAA6GXOZEpJjxmWWrBggdasWaNPP/30tN1NP3TFFVfIYrFo9erVHR77Yc9NW/KrqKgg3AAA0EtUVlbKarWe0e/vHrEU/LbbbtPq1au1cePGsw42kjRlyhQdPny408f8/f0dvTT01gAA4PlMHZYyDEO33XabVq1apU2bNiktLa1br7N7924lJCQ4uToAANAbmRpuFixYoLfeekv//Oc/FRoaqoKCAkmS1WpVYGCgJOm+++7TiRMntHz5cknS0qVLlZqaqvT0dDU0NOiNN97QihUrtGLFCtM+BwAAp9Pc3KzGxkazy+jR/Pz8TrvM+0yYGm5eeOEFSdKMGTPaHX/11Vd18803S5Ly8/OVk5PjeKyhoUF33323Tpw4ocDAQKWnp2vNmjW67LLL3FU2AABnzDAMFRQUqLy83OxSejwvLy+lpaXJz8/vnF6nx0wodpezmZAEAMC5ys/PV3l5uWJjYxUUFMQFZE+h7SK7vr6+6t+/f4d2Opvf3z1mKTgAAJ6mubnZEWyioqLMLqfHi4mJUV5enpqamuTr69vt1+kRq6UAAPBEbXNsgoKCTK6kd2gbjmpubj6n1yHcAADgYgxFnRlntRPhBgAAeBTCDQAA6GDGjBm68847zS6jWwg3AADAoxBunMQwDJXVNOibk1VmlwIAQJ9GuHGSI0U1Gvvoel39/Fb1sUsHAQA8XFlZmW688UZFREQoKChIc+bMabenY3Z2tq644gpFREQoODhY6enpWrt2reO5119/vWJiYhQYGKjBgwfr1VdfdWm9XOfGSZIi7NtFVNmaVFnXJGtQ99fnAwA8k2EYqms8t2XO3RXo693t1Ug333yzDh8+rNWrVyssLEz33HOPLrvsMh04cEC+vr5asGCBGhoatGXLFgUHB+vAgQMKCQmRJD344IM6cOCAPvjgA0VHR+vbb79VXV2dMz9aB4QbJwnw9VZ0iL+Kq23KLauVNchqdkkAgB6mrrFZIx760JT3PvDIbAX5nf2v/bZQ89lnn2natGmSpDfffFPJycl677339NOf/lQ5OTm6+uqrNWrUKEnSgAEDHM/PycnR2LFjNWHCBElSamrquX+Y02BYyonirf6SpMKqepMrAQDAOQ4ePCgfHx9NnjzZcSwqKkpDhw7VwYMHJUm33367/uu//kvnnXeeFi9erL179zrOvfXWW/XOO+9ozJgx+n//7/9p69atLq+ZnhsnigiyX1mxoo5dXwEAHQX6euvAI7NNe+/uONU8UsMwHMNc//7v/67Zs2drzZo1+uijj7RkyRI98cQTuu222zRnzhxlZ2drzZo1+vjjjzVz5kwtWLBAf/7zn7v9WU6Hnhsnsgba59mU1xJuAAAdWSwWBfn5mHLr7nybESNGqKmpSV988YXjWElJib755hsNHz7ccSw5OVnz58/XypUrddddd+nll192PBYTE6Obb75Zb7zxhpYuXaqXXnqp+414Bui5caLwIMINAMCzDB48WHPnztUvf/lL/fWvf1VoaKjuvfde9evXT3PnzpUk3XnnnZozZ46GDBmisrIybdiwwRF8HnroIY0fP17p6emy2Wx6//3324UiV6DnxonCAxmWAgB4nldffVXjx4/X5ZdfrqlTp8owDK1du9axc3dzc7MWLFig4cOH69JLL9XQoUP1/PPPS7Jvhnnfffdp9OjRmj59ury9vfXOO++4tF56bpzou56bBpMrAQDg3GzatMnxc0REhJYvX37Kc5955plTPvbb3/5Wv/3tb51Z2mnRc+NEjjk39NwAAGAawo0Thbeulipjzg0AAKYh3DhRW89NJT03AACYhnDjRG3hhgnFAACYh3DjRN8PN2yeCQBow++EM+OsdiLcOFFbuGluMVTTYM7GaACAnqNtqXRtba3JlfQODQ321cbe3t27mnIbloI7UYCvl/y8vdTQ3KKKukaF+NO8ANCXeXt7Kzw8XIWFhZKkoKCgbl8p2NO1tLSoqKhIQUFB8vE5t9+f/PZ1IovForBAXxVX21RR26h+4YFmlwQAMFl8fLwkOQIOTs3Ly0v9+/c/5wBIuHGysEAfe7hhUjEAQPb/8U1ISFBsbKwaG/nd0BU/Pz95eZ37jBnCjZOxYgoA0Blvb+9znkuCM8OEYifjWjcAAJiLcONk9NwAAGAuwo2TEW4AADAX4cbJCDcAAJiLcONkhBsAAMxFuHGyMMINAACmItw4GT03AACYi3DjZI6l4PWEGwAAzEC4cTKucwMAgLkIN072/WEptrgHAMD9CDdO1hZuGpsN1TU2m1wNAAB9D+HGyYL8vOXjZd/NlEnFAAC4H+HGySwWCyumAAAwEeHGBRzhppZwAwCAuxFuXIAL+QEAYB7CjQswLAUAgHkINy5AuAEAwDyEGxeICLKHm7LaBpMrAQCg7yHcuEBksL8kqbSGcAMAgLsRblwgMsRPEuEGAAAzEG5cIDKIcAMAgFkINy4QGWwPNyWEGwAA3I5w4wJRrcNSZYQbAADcjnDjAhGtw1LldY1qbmFncAAA3Ilw4wJtS8ENg+XgAAC4G+HGBXy8vRTedq0bhqYAAHArwo2LtK2YYlIxAADuRbhxkbYVU/TcAADgXoQbF2E5OAAA5iDcuEhbuOFCfgAAuBfhxkUINwAAmINw4yKEGwAAzEG4cRHCDQAA5iDcuAgTigEAMAfhxkWiQ/wlSSXVNpMrAQCgbyHcuEhMaGu4qWlQC/tLAQDgNoQbF2kblmpuMdhfCgAANyLcuIivt5djA83iasINAADuQrhxobahqWLm3QAA4DaEGxdqm1RcVEW4AQDAXQg3LtQWbui5AQDAfUwNN0uWLNHEiRMVGhqq2NhYzZs3T5mZmad93ubNmzV+/HgFBARowIABevHFF91Q7dlz9NwQbgAAcBtTw83mzZu1YMECff7551q/fr2ampo0a9Ys1dTUnPI5WVlZuuyyy3TBBRdo9+7duv/++3X77bdrxYoVbqz8zDjm3FQxoRgAAHfxMfPN161b1+7+q6++qtjYWO3cuVPTp0/v9Dkvvvii+vfvr6VLl0qShg8frh07dujPf/6zrr76aleXfFaiQ+zLwem5AQDAfXrUnJuKigpJUmRk5CnP2bZtm2bNmtXu2OzZs7Vjxw41NjZ2ON9ms6mysrLdzV2iHT03hBsAANylx4QbwzC0aNEinX/++Ro5cuQpzysoKFBcXFy7Y3FxcWpqalJxcXGH85csWSKr1eq4JScnO732U4lhQjEAAG7XY8LNwoULtXfvXr399tunPddisbS7bxhGp8cl6b777lNFRYXjlpub65yCzwBbMAAA4H6mzrlpc9ttt2n16tXasmWLkpKSujw3Pj5eBQUF7Y4VFhbKx8dHUVFRHc739/eXv7+/U+s9Uz/cgiEqxJw6AADoS0ztuTEMQwsXLtTKlSu1YcMGpaWlnfY5U6dO1fr169sd++ijjzRhwgT5+vq6qtRuYQsGAADcz9Rws2DBAr3xxht66623FBoaqoKCAhUUFKiurs5xzn333acbb7zRcX/+/PnKzs7WokWLdPDgQf3973/XK6+8orvvvtuMj3BaXMgPAAD3MjXcvPDCC6qoqNCMGTOUkJDguL377ruOc/Lz85WTk+O4n5aWprVr12rTpk0aM2aMHn30UT399NM9bhl4G/aXAgDAvUydc9M2Ebgry5Yt63Dswgsv1K5du1xQkfOxvxQAAO7VY1ZLeSq2YAAAwL0INy4WHWpfMcUWDAAAuAfhxsVi6LkBAMCtCDcuFm8NkCQVVNSd5kwAAOAMhBsXS7AGSpLyy+tNrgQAgL6BcONiieH2npsqW5Oq6jtu7AkAAJyLcONiQX4+sgbar1KcX0HvDQAArka4cYOE1nk3eeXMuwEAwNUIN26QGN4674aeGwAAXI5w4wb03AAA4D6EGzdo67nJY8UUAAAuR7hxg7YVU/lc6wYAAJcj3LhBYuu1bk4wLAUAgMsRbtwgOTJIkn3OTXPL6XdCBwAA3Ue4cYO4sAD5elvU2GyooJJ5NwAAuBLhxg28vSxKirD33uSU1JpcDQAAno1w4yZtQ1O5pYQbAABciXDjJskR9knFuWWEGwAAXIlw4yb9W3tucui5AQDApQg3bkK4AQDAPQg3bvLdnBuudQMAgCsRbtykLdwUV9tU29BkcjUAAHguwo2bWAN9ZQ30lUTvDQAArkS4cSPm3QAA4HqEGzfqH2UPN9klNSZXAgCA5yLcuFFaVLAkKauYcAMAgKsQbtwoNdoebo7RcwMAgMsQbtwoLdo+LHWsmDk3AAC4CuHGjVJbh6XyKupU39hscjUAAHgmwo0bRQb7KdTfR4bBiikAAFyFcONGFovFMe+GScUAALgG4cbNHJOKCTcAALgE4cbN0lqvdcOKKQAAXINw42YMSwEA4FqEGzf7bliKCcUAALgC4cbN2q5SXFBZr7oGloMDAOBshBs3iwj2c+wOnl3K0BQAAM5GuDEBK6YAAHAdwo0J2lZMZTHvBgAApyPcmOC7FVPVJlcCAIDnIdyYII3l4AAAuAzhxgQDY0IkSUeKCDcAADgb4cYEA2LsPTelNQ0qrWkwuRoAADwL4cYEQX4+6hceKEk6WsS8GwAAnIlwY5K23psjhBsAAJyKcGMS5t0AAOAahBuTDIxtDTeF9NwAAOBMhBuTDGRYCgAAlyDcmGRQ67BUTmmtbE1soAkAgLMQbkwSE+qvUH8ftRhSdgnbMAAA4CyEG5NYLBYNYN4NAABOR7gxEfNuAABwPsKNiVgODgCA8xFuTPRduKHnBgAAZyHcmGhQbOuwVGG1DMMwuRoAADwD4cZEKVHB8vW2qKahWcfL6swuBwAAj0C4MZGvt5cGxYZKkg4VVJlcDQAAnoFwY7Lh8a3hJr/S5EoAAPAMhBuTDUug5wYAAGci3JhsWHyYJOlgAT03AAA4A+HGZG09N8eKa1TXwB5TAACcK8KNyWJC/BUV7KcWQzpcyNAUAADninBjMovF4ui9OcikYgAAzhnhpgcY3jbvJp+eGwAAzhXhpgcYltAWbui5AQDgXBFueoD0RHu4OZBXqZYWtmEAAOBcEG56gMGxIfL38VKVrUnHStghHACAc2FquNmyZYuuuOIKJSYmymKx6L333uvy/E2bNslisXS4HTp0yD0Fu4iPt5ej9+brExUmVwMAQO9maripqalRRkaGnn322bN6XmZmpvLz8x23wYMHu6hC9xmdFC5J2nuccAMAwLnwMfPN58yZozlz5pz182JjYxUeHu78gkw0qp9VkvQ14QYAgHPSK+fcjB07VgkJCZo5c6Y2btzY5bk2m02VlZXtbj3RqCR7uNmXV6FmJhUDANBtvSrcJCQk6KWXXtKKFSu0cuVKDR06VDNnztSWLVtO+ZwlS5bIarU6bsnJyW6s+MwNjAlRoK+3ahuadbSo2uxyAADotSyGYfSIbgKLxaJVq1Zp3rx5Z/W8K664QhaLRatXr+70cZvNJpvN5rhfWVmp5ORkVVRUKCws7FxKdrqfvrhVXx4r019+lqGrxiWZXQ4AAD1GZWWlrFbrGf3+7lU9N52ZMmWKDh8+fMrH/f39FRYW1u7WU43qFy6JScUAAJyLXh9udu/erYSEBLPLcIrRrfNuWA4OAED3mbpaqrq6Wt9++63jflZWlvbs2aPIyEj1799f9913n06cOKHly5dLkpYuXarU1FSlp6eroaFBb7zxhlasWKEVK1aY9RGcqm1S8f68CjU1t8jHu9dnTwAA3M7UcLNjxw5ddNFFjvuLFi2SJN10001atmyZ8vPzlZOT43i8oaFBd999t06cOKHAwEClp6drzZo1uuyyy9xeuyukRQUrxN9H1bYmHS6s1vCEnjuEBgBAT9VjJhS7y9lMSDLDL17+XFuPlOj3Pxmp6yenmF0OAAA9Qp+aUOxpJqRGSpJ2HCszuRIAAHonwk0PMzE1QpK0I7vU5EoAAOidCDc9zNj+EfKySLmldTpZWW92OQAA9DqEmx4mxN/HMZGYoSkAAM4e4aYHmpBiH5r68hhDUwAAnC3CTQ/UNql4ZzY9NwAAnC3CTQ80oXVS8YH8StXYmkyuBgCA3oVw0wMlWAPVLzxQzS2G9uSWm10OAAC9SrfCTW5uro4fP+64v337dt1555166aWXnFZYX9e2JHx7FvNuAAA4G90KN7/4xS+0ceNGSVJBQYEuueQSbd++Xffff78eeeQRpxbYV01Ki5IkbTtaYnIlAAD0Lt0KN/v27dOkSZMkSf/93/+tkSNHauvWrXrrrbe0bNkyZ9bXZ503yB5udueUqbaBeTcAAJypboWbxsZG+fv7S5I+/vhjXXnllZKkYcOGKT8/33nV9WH9I4PULzxQjc0GQ1MAAJyFboWb9PR0vfjii/rkk0+0fv16XXrppZKkvLw8RUVFObXAvspisTh6b7YeYWgKAIAz1a1w8/jjj+uvf/2rZsyYoeuuu04ZGRmSpNWrVzuGq3DuzhsULUn69HCxyZUAANB7+HTnSTNmzFBxcbEqKysVERHhOP6rX/1KQUFBTiuur5s20B5uDuRXqrSmQZHBfiZXBABAz9etnpu6ujrZbDZHsMnOztbSpUuVmZmp2NhYpxbYl8WE+mtoXKgkaRtDUwAAnJFuhZu5c+dq+fLlkqTy8nJNnjxZTzzxhObNm6cXXnjBqQX2ddNa5918+i1DUwAAnIluhZtdu3bpggsukCT94x//UFxcnLKzs7V8+XI9/fTTTi2wrzu/dd7N1iOEGwAAzkS3wk1tba1CQ+3DJR999JGuuuoqeXl5acqUKcrOznZqgX3dpLRIeXtZlF1Sq9zSWrPLAQCgx+tWuBk0aJDee+895ebm6sMPP9SsWbMkSYWFhQoLC3NqgX1daICvMpKskui9AQDgTHQr3Dz00EO6++67lZqaqkmTJmnq1KmS7L04Y8eOdWqB+N6S8G+ZVAwAwOl0K9xcc801ysnJ0Y4dO/Thhx86js+cOVNPPvmk04qD3fQhMZKkLd8Uqam5xeRqAADo2bp1nRtJio+PV3x8vI4fPy6LxaJ+/fpxAT8XGZscrvAgX5XXNmpXTrkmpUWaXRIAAD1Wt3puWlpa9Mgjj8hqtSolJUX9+/dXeHi4Hn30UbW00LPgbD7eXprR2nvzr0MnTa4GAICerVvh5oEHHtCzzz6rxx57TLt379auXbv0hz/8Qc8884wefPBBZ9cISTOHx0mSNhwsNLkSAAB6tm4NS7322mv629/+5tgNXJIyMjLUr18//frXv9bvf/97pxUIu+lDYuTtZdHhwmrllNSqfxTbXAAA0Jlu9dyUlpZq2LBhHY4PGzZMpaWl51wUOrIG+mpiqn27iw0MTQEAcErdCjcZGRl69tlnOxx/9tlnNXr06HMuCp2bOcw+NPWvQwxNAQBwKt0alvrjH/+oH//4x/r44481depUWSwWbd26Vbm5uVq7dq2za0Sri4fH6vdrD+qLo6WqtjUpxL/bi90AAPBY3eq5ufDCC/XNN9/oJz/5icrLy1VaWqqrrrpK+/fv16uvvursGtFqYEyI0qKD1dDcos2ZRWaXAwBAj2QxDMNw1ot99dVXGjdunJqbm531kk5XWVkpq9WqioqKXrlVxGMfHNKLm4/ox6MS9Nz148wuBwAAtzib39/d6rmBeS4fnSDJfr2b2oYmk6sBAKDnIdz0MumJYUqJClJ9Y4s2MLEYAIAOCDe9jMVi0Y9H2Xtv1uzNN7kaAAB6nrNabnPVVVd1+Xh5efm51IIz9OPRCXp+0xFtOFSoGluTglk1BQCAw1n9VrRarad9/MYbbzyngnB6IxLClBYdrKziGv3rUKGuzEg0uyQAAHqMswo3LPPuGdqGpp7d+K3e/yqPcAMAwPcw56aX+nHrqqlN3xSpoq7R5GoAAOg5CDe91LD4UA2JC1FDU4vWfs3EYgAA2hBueimLxaKrxiVJklbuOm5yNQAA9ByEm17sJ2P7ycsifXmsTNklNWaXAwBAj0C46cXiwgJ03qBoSdKKXSdMrgYAgJ6BcNPLXTP+u6GplhanbRMGAECvRbjp5WaNiFeIv4+Ol9Xpy2OlZpcDAIDpCDe9XKCfty4bFS9JevfLXJOrAQDAfIQbD3DdpP6SpPe/zld5bYPJ1QAAYC7CjQcYkxyuEQlhamhq0T92siwcANC3EW48gMVi0fVT7L03b32RI8NgYjEAoO8i3HiIuWP6KdjPW0eLa7TtaInZ5QAAYBrCjYcI8ffRvLH9JElvfpFjcjUAAJiHcONBrp+cIkn6cF+BTlbWm1wNAADmINx4kBGJYZqQEqGmFkOvb8s2uxwAAExBuPEw/35BmiTpjS+yVdfQbHI1AAC4H+HGw1wyIl7JkYEqr23UCnYLBwD0QYQbD+PtZdEt59l7b175NEvN7DcFAOhjCDce6GcTkhUe5Kus4hqt+Trf7HIAAHArwo0HCvb3cfTePLfhW3YLBwD0KYQbD3XTtFSF+vso82SV1h88aXY5AAC4DeHGQ1kDfXXjNPt1b57d8C1bMgAA+gzCjQf7v+cPUKCvt74+UaF/HSw0uxwAANyCcOPBIoP9dNO0VEnSnz/KZO4NAKBPINx4uPkXDlCov48OFVTpf/fmmV0OAAAuR7jxcOFBfvrV9AGSpCfXf6PG5haTKwIAwLUIN33ALeenKSrYT8dKavWPnVy1GADg2Qg3fUCwv48WXDRIkvTUx4dV38ieUwAAz0W46SN+Mbm/Eq0BKqisZ8dwAIBHI9z0EQG+3rrjR4MlSc9sOKzSmgaTKwIAwDVMDTdbtmzRFVdcocTERFksFr333nunfc7mzZs1fvx4BQQEaMCAAXrxxRddX6iHuGZ8soYnhKmyvklPfJRpdjkAALiEqeGmpqZGGRkZevbZZ8/o/KysLF122WW64IILtHv3bt1///26/fbbtWLFChdX6hm8vSx6+IoRkqS3tudo34kKkysCAMD5LEYPuS6/xWLRqlWrNG/evFOec88992j16tU6ePCg49j8+fP11Vdfadu2bWf0PpWVlbJaraqoqFBYWNi5lt0rLXxrl97fm6+MJKtW/vo8eXtZzC4JAIAunc3v714152bbtm2aNWtWu2OzZ8/Wjh071NjY2OlzbDabKisr2936uocuH6HQAB99dbxCy7cdM7scAACcqleFm4KCAsXFxbU7FhcXp6amJhUXF3f6nCVLlshqtTpuycnJ7ii1R4sNC9C9c4ZJkv70YaZOlNeZXBEAAM7Tq8KNZB+++r62UbUfHm9z3333qaKiwnHLzc11eY29wXUT+2tCSoRqG5r10Hv72DUcAOAxelW4iY+PV0FBQbtjhYWF8vHxUVRUVKfP8ff3V1hYWLsbJC8vi5ZcNUq+3hb961ChPthXcPonAQDQC/SqcDN16lStX7++3bGPPvpIEyZMkK+vr0lV9V6D40J164UDJUmLV+9XeS3XvgEA9H6mhpvq6mrt2bNHe/bskWRf6r1nzx7l5ORIsg8p3XjjjY7z58+fr+zsbC1atEgHDx7U3//+d73yyiu6++67zSjfI/z6okEaGBOsoiqbHvznfrPLAQDgnJkabnbs2KGxY8dq7NixkqRFixZp7NixeuihhyRJ+fn5jqAjSWlpaVq7dq02bdqkMWPG6NFHH9XTTz+tq6++2pT6PUGAr7f+8rMx8vay6H+/ytPqr/LMLgkAgHPSY65z4y5c56ZzT67/Rk/967Csgb5ad+cFSrAGml0SAAAOHnudG7jOwosHaXSSVRV1jbrjnT1qam4xuyQAALqFcANJkq+3l576+VgF+3lre1apnt7wrdklAQDQLYQbOKRFB+sPV42SZN85fOu3nV8YEQCAnoxwg3bmjumnayckyzCk29/Zo4KKerNLAgDgrBBu0MHDV6ZrWHyoiqttuvXNnbI1NZtdEgAAZ4xwgw4C/bz11xvGKyzAR7tzyvW7/z1gdkkAAJwxwg06lRIVrKeuGyuLRXrrixy9+2XO6Z8EAEAPQLjBKV00NFZ3XTJEkvTb9/Zp25ESkysCAOD0CDfo0q9nDNKPRyWosdnQr17foW9OVpldEgAAXSLcoEteXhY98bMMTUiJUFV9k27++3adrGQFFQCg5yLc4LQCfL318o0TNCAmWHkV9br51S9VVd9odlkAAHSKcIMzEhHsp9f+bZKiQ/x1ML9Sv35zlxrZogEA0AMRbnDGkiOD9PebJyjIz1ufHC7W3f/zlZpb+tS+qwCAXoBwg7MyOilcz/1inHy8LPrnnjz95h8EHABAz0K4wVm7aFisnr5urLy9LFq564TuW7lXLQQcAEAPQbhBt1w2KkFLrx0jL4v03zuO64H3vibgAAB6BMINuu2KjEQ92Rpw3t6eq4dW75NhEHAAAOYi3OCczB3TT3+6JkMWi/TG5zl66J/76cEBAJiKcINzdvX4JD1+9WhZLNLrn2fr9nd2s5M4AMA0hBs4xc8mJGvptWPk623R+3vzdcsyLvQHADAH4QZOM3dMP/395okK9vPWZ9+W6Ocvfa7CKrZqAAC4F+EGTnXB4Bi986upig7x0/68Sl3zwjYdLao2uywAQB9CuIHTjUqyasWt05QSFaSc0lrNffYzrT9w0uyyAAB9BOEGLpESFax/zJ+mSamRqrI16ZfLd+gv679hJRUAwOUIN3CZmFB/vfnLybp5Wqok6el/Hdb/fe1LVdQx0RgA4DqEG7iUr7eXHr4yXX/5WYb8fby0MbNIVz77qTILqswuDQDgoQg3cIurxiVpxa3T1C88UNkltZr33Gd6f2+e2WUBADwQ4QZuM7KfVf972/k6f1C06hqbtfCt3frD2oNqam4xuzQAgAch3MCtIoP9tOzfJuo/LhwgSXppy1Fd+9LnOlZcY3JlAABPQbiB2/l4e+m+OcP13C/GKcTfRzuzyzTnqU/01hc5bLwJADhnhBuY5sejE7Tuzgs0ZUCk6hqbdf+qr3XrG7tUUm0zuzQAQC9GuIGpkiKC9Na/T9H9lw2Tr7dF6/YXaNaTW7RuX4HZpQEAeinCDUzn5WXRr6YP1Kpfn6ehcaEqqWnQ/Dd26s53dquilmviAADODuEGPcbIflatvu083TpjoLws0nt78vSjJzdrzd585uIAAM4Y4QY9ir+Pt+65dJj+ces0DYgJVlGVTQve2qV/W/alcktrzS4PANALEG7QI43rH6G1t1+g22cOlp+3lzZlFumSJzfr+U3fqpHr4gAAukC4QY8V4OutRZcM0Qd3XqCpA6JU39iiP67L1JynPtGnh4vNLg8A0EMRbtDjDYwJ0Vu/nKy//CxDUcF++rawWv/nlS80//WdDFUBADqwGH1spmZlZaWsVqsqKioUFhZmdjk4SxV1jXpy/Td6/fNsNbcY8vfx0n9cOFC3XjhQgX7eZpcHAHCRs/n9TbhBr3SooFKL/7lfX2SVSpISrAG659JhujIjUV5eFpOrAwA4G+GmC4Qbz2EYhtZ+XaA/rD2oE+V1kqThCWG6d84wTR8cLYuFkAMAnoJw0wXCjeepb2zWK59m6cVNR1Rla5IkTRsYpd/MHqqx/SNMrg4A4AyEmy4QbjxXWU2Dntv4rZZvy1ZD63LxS0bE6a5ZQzQsnr9rAOjNCDddINx4vuNltXrq48Naseu4WgzJYpEuH52o2y8epMFxoWaXBwDoBsJNFwg3fce3hdV68uNvtGZvvuPYpenxWnDRII1KsppYGQDgbBFuukC46Xv251XomX99q3X7v9tp/MIhMVp48SBNTI00sTIAwJki3HSBcNN3HT5Zpec3HdHqr/LU3GL/2k9Ki9TCiwbpAlZXAUCPRrjpAuEGOSW1emHzEa3Yedwx8XhEQpj+/YI0XT46UX4+XLgbAHoawk0XCDdoU1BRr5e2HNXb23NU19gsSYoL89dN01J1/aQUWYN8Ta4QANCGcNMFwg1+qLy2QW9+kaPXth5TYZVNkhTo662fTkjSv52XprToYJMrBAAQbrpAuMGpNDS16H+/ytPLnxzVoYIqSfZl5DOGxOj/TEnRjKGx8mZrBwAwBeGmC4QbnI5hGNp6pESvfJqlDYcKHccTrQH6xeT+um5Sf0WF+JtYIQD0PYSbLhBucDayimv01hfZ+p+dx1Ve2yhJ8vPx0qXp8bp2YrKmDohio04AcAPCTRcIN+iO+sZmfbAvX8s+O6avjlc4jidHBuqn45N1zfgkJYYHmlghAHg2wk0XCDc4F4ZhaN+JSr27I0f/3JOnqnr7Rp0Wi3T+oGhdMz5Js9PjFeDrbXKlAOBZCDddINzAWeoamrVuf77e2Z6rL7JKHcfDg3w1NyNRV47pp3H9w7k4IAA4AeGmC4QbuEJOSa3+seu4Vuw8rhPldY7jyZGB+snYJF2ZkaBBsWzaCQDdRbjpAuEGrtTcYuiTw0VavSdPH+4vUE1Ds+OxEQlhujwjQXNGJnDtHAA4S4SbLhBu4C51Dc366ECB/rknT1u+KVJTy3f/qQ2LD9WlI+M1Z2SChsSFMHQFAKdBuOkC4QZmKKtp0Np9+Vq3r0Bbj5Q4Nu6UpAHRwY6gM7JfGEEHADpBuOkC4QZmK69t0PoDJ7VuX4E+OVzs2LxTkvqFB7YGnXiN6x/BNXQAoBXhpguEG/QkVfWN2nCoUB/uL9DGQ0WODTwlKTbUX7PT7UFnUlqkfLzZrRxA30W46QLhBj1VXUOzNn9TpHX78vWvg4WqsjU5HosI8tXM4XG6eFiszh8crbAAdiwH0LcQbrpAuEFvYGtq1tZvS7RuX4E+OlCgstatHyTJx8uiCakRunhYrC4aGqtBsUxIBuD5CDddINygt2lqbtH2Y6XacLBQGzILdbSopt3jSRGBumhorGalx2lyWpT8fBi+AuB5CDddINygt8suqdHGQ4XamFmkbUdL1ND03YTkYD9vTR0YpQuHxGjG0FglRwaZWCkAOA/hpguEG3iS2oYmbTtSoo8PntT6A4Uqrra1e3xAdLDOHxyt8wdFa+rAKIUyVwdAL9Wrws3zzz+vP/3pT8rPz1d6erqWLl2qCy64oNNzN23apIsuuqjD8YMHD2rYsGFn9H6EG3iqlhZDB/IrteVwkTYdKtLOnLJ219Px9rJoTHK4I+iMSQ5ng08AvUavCTfvvvuubrjhBj3//PM677zz9Ne//lV/+9vfdODAAfXv37/D+W3hJjMzs90Hi4mJkbf3mf0jTbhBX1FZ36htR0r06eFiffptsbKK28/V8fP20pjkcE1Ki9SktEiNT4lQsL+PSdUCQNd6TbiZPHmyxo0bpxdeeMFxbPjw4Zo3b56WLFnS4fy2cFNWVqbw8PBuvSfhBn3V8bJaR9D5IqtURVXth7C8vSwa2c+qyWmRmpQaqYmpkbIGMYwFoGc4m9/fpv1vWkNDg3bu3Kl777233fFZs2Zp69atXT537Nixqq+v14gRI/Tb3/6206GqNjabTTbbd/+IV1ZWnlvhQC+VFBGkn0/qr59P6i/DMHSspFbbs0r0RVaptmeV6nhZnb7KLddXueV6actRWSzSsPgwe9hJs4edmFB/sz8GAJyWaeGmuLhYzc3NiouLa3c8Li5OBQUFnT4nISFBL730ksaPHy+bzabXX39dM2fO1KZNmzR9+vROn7NkyRL97ne/c3r9QG9msViUFh2stOhgXTvRPgR8orxO27NKtD2rVF9klepoUY0O5lfqYH6llm09JkkaEBOsyWmRmpwWpUlpkUoMDzTxUwBA50wblsrLy1O/fv20detWTZ061XH897//vV5//XUdOnTojF7niiuukMVi0erVqzt9vLOem+TkZIalgNMoqrLpy2Ol+uKovXcn82SVfvivRVJEoCalRbb27kQpNSqICwoCcIleMSwVHR0tb2/vDr00hYWFHXpzujJlyhS98cYbp3zc399f/v50pQNnKybUX5eNStBloxIk2Tf83HGsTNuP2Xt29p2o0PGyOh0vO6GVu05Isu+H9f2wMzg2hM0/AbidaeHGz89P48eP1/r16/WTn/zEcXz9+vWaO3fuGb/O7t27lZCQ4IoSAXxPeJCffjQiTj8aYf+fjxpbk3Zml2l765ydPbnlKqyy6f29+Xp/b37rc3w1Njlc4/pHaFxKhEb2s8oayCRlAK5l6rrPRYsW6YYbbtCECRM0depUvfTSS8rJydH8+fMlSffdd59OnDih5cuXS5KWLl2q1NRUpaenq6GhQW+88YZWrFihFStWmPkxgD4p2N9H04fEaPqQGElSfWOzvsott4edY6XacaxM5bWN2phZpI2ZRY7nDY4N0YTUCI1JDldGcrgGx4bKm94dAE5kari59tprVVJSokceeUT5+fkaOXKk1q5dq5SUFElSfn6+cnJyHOc3NDTo7rvv1okTJxQYGKj09HStWbNGl112mVkfAUCrAF9vTR4QpckDoiRJjc0t2p9XqV3ZZdqVU6Y9ueU6Xlanw4XVOlxYrbe350qSAn29NbJfmDKSwjU6OVwZSVb1j2TuDoDuM/0Kxe7GdW4A85RU27Qzu0w7c8r0VW659p2oVLWtqcN54UG+Gp1kDzr20GNVbGiACRUD6Cl6zUX8zEC4AXqO5hZDR4uq9dXxCu09br/GzsH8KjU0t3Q4Nz4sQCP7hSk90ar0xDCN7GdVgjWAHh6gjyDcdIFwA/RstqZmZRZU2S8o2Bp6DhdWd1iGLkmRwX5KT7QHnrbgkxIZxAotwAMRbrpAuAF6n2pbkw7mV2rfiQrtz6vU/rxKHT5ZpaaWjv98hfj7aERCmEYkhjn+HBQbwiahQC9HuOkC4QbwDPWNzfrmZJX259lDz768Sh3Kr5StqeOQlreXRQOigzU8IUzDEkI1PCFMw+PDFBfmz7AW0EsQbrpAuAE8V1Nzi44U1WjfiQr71hEF9l6e8trGTs+3BvpqaFyoI/AMiw/V0PhQBfmxOzrQ0xBuukC4AfoWwzB0stKmg/mVOtC6V9ahgiplFdeouZNhLYtFSo0K1ojWsDM4LkSD40KVEhkkH28vEz4BAIlw0yXCDQDJPqx1tKhGhwrsYact9BRV2To938/bSwNi7KFnUFyIhsaFakhcqPqFBzKBGXCDXrG3FACYKcDX2z7pOLH9P5LF1fZenv15lfrmZJW+LazW4ZPVqmts1qGCKh0qqGp3frCftwbFhWpgTLAGxYZoSKx9aIvQA5iHnhsAOI2WFkMnyut0MN8eeDJPVuvwySodKapWY3Pn/4QG+nprYGyw0qJD7HN54kKVGh2s/pFB8vNheAs4WwxLdYFwA8BZGptbdKy4Rt+crNbRomp9W1StzIKuQ4+Pl0Vp0cEaEh+qQTEhGhgbooExwRoQHaJAP5arA6fCsBQAuIGvt5cGx4VqcFxou+ONzS3KKa3VkUJ74DmUbw88WcU1qm1oduyv9UP9wgM1MDZEA6KD7aGn9c/YUJasA2eDnhsAcBPDMFRQWa9DBVX6prWH52hRjb4tqj7lcnVJCvX3UWp0sNKig5UaHawB0fb5PWnRwQr25/9R0TcwLNUFwg2Anqi0pkFHiqr1baF9iOtoUY2OFFUrp7RWnaxYd4gL81dq1HfBJzUqWKnRQUqNCuaqzPAohJsuEG4A9Cb1jc3KKa1VVnGNjhXXKKu4xhF8SmoaunxugjVAKVFB9uATFezo/ekfGUTwQa9DuOkC4QaAp6iobdTR4modK6lRVnGtjhXXKLvEHoAq65tO+TyLRUoIC1D/KHsPT/+oIKVE2kNPYniAIoP9mOODHodw0wXCDQBPZxiGymobdazE3ttzrKS29c8aZRXVqMp26uAj2a/dkxwZpJSoIKVE2UNP/9b7ieGB8uVKzTABq6UAoA+zWCyKDPZTZLCfxvWPaPeYYRgqrWnQsZJa5ZTae3xySmqUXVqrE2V1Kqyyqaah8wsWSvZNSPuFB9oDT1SQUlqDT3JkkJIjgmQN8nXXxwROiXADAH2IxWJRVIi/okL8NT4losPjtqZmHS+rU05JrbJLapRTWqec0hpll9Qqp7RWtib7Mvec0lrp246vHxrgo+SIICVHBrb++d3PSRFBXMsHbkG4AQA4+Pt4a2BMiAbGhHR4rKXFUFG1TdmtwSe3tFbZrUEnt7ROxdU2VdU36UDrJqWdiQ7xU7/wQCVFBCkpIrD1FqR+EYHqFx7I0nY4BXNuAABOUdvQpONldcotrbXf2n4uq9Px0trTzvWRpPAgX/ULD3QEoLbQk9T6Z3iQL5Od+yjm3AAA3C7Iz0dDWndL/yHDMFRR16jjZXU6UV7nCEFtP58oq1VlfZPKaxtVXtuo/Xmd9/yE+PuoX3ig4qwBjtCTYA1QgtX+Z7w1gGXuINwAAFzPYrEoPMhP4UF+GtnP2uk5VfWNOlFepxOtAehEmT34HG/9ubjapmpbkzJPVinzZMfJzm0ig/1aA4899CSGByox3B6GEsMDFRvqLx9WfHk0wg0AoEcIDfDVsHhfDYvvfMihvrHZEXoKKut1vLRWeRX1yq+oU355vfIq6lTf2KLSmgaV1jScsvfH28ui+LCAdoHH3utj/zMuLEBRwX7y8mL4q7ci3AAAeoUA31NPdpa+G/rKbw08eeXfBZ8T5XXKa/25qcWwh6TyOn2psk5fy8fLothQf8VZAxQfZg88cWEBirf6Ky40wHGcCdA9E38rAACP8P2hr+EJnff+NLcYKq62tRv+KmgNQwUV9cqrqFdxtU1NLYbyWu93JdTfR7Fh/oq3fi8AOYJQgOLC/BUTwjCYuxFuAAB9hreXxRFCfniBwzZNzS0qqrapoKJeJyttOllZr4LKep2sqNfJqnrH8Wpbk6psTaoqatKRoppTvqeXRYoO8W/X+xMfFqDY1iAUbw1QXGiAwgJ9WAnmJIQbAAC+x8fbq3X1VWCX51XbmnSyXehpDUKt909W1Kuwyt4LVFhlU2GVTV+fqDjl6wX4ev1gCKztZ3/H8dgwf/n7sBrsdAg3AAB0Q4i/j0K6mAMk2S98WFLT4Ag9BZX1KmztCSqotDl+Lq9tVH1ji30fsJLaLt83MtjPEXpiQ/3bDYfFhvkrJtRf0SH+fXoPMMINAAAu4uVlUUyoPXCcagm8ZF8JVlhpaw09rb1BbT9X2ofBCirr1dD03Wqwg/ldv3dksJ9iQuzvHdtaw/dv9mMBCgvwvOEwwg0AACYL8PVW/yj7ZqSnYhiGymsbHfN+CittKqxq7QVqHRIrqrI5JkS3haCurgkkSX4+Xo4Q1NbrEx3ip9iwAEfPUEyov6KC/XrNBRIJNwAA9AIWi0URwX6KCPY75bWAJPtQWFltg4qqbSqqsqmw0vbdz1U2FVXZQ1BRlU2V9U1qaGpxLI0/nVB/H0WF+CmqNQDFhPorsnWFWmSwn/pFBCo6xF+hAT6KDvF35sc/K4QbAAA8iJfXdzu/D4vv+tz6xmZH6Cmutv9ZUt36c6VNJ6vs84KKq21qbDbsq8NsTaedFxQe5Ks9D81y4qc6O4QbAAD6qABfbyVHBik58tTDYZJ9SKyyvknF1TaVVDc4AlBRlU2ltQ0qq21UaXWDcstqVVHbqLAAXzd9gs4RbgAAQJcsFousgb6yBvpqYMzpzzcMw/VFdaHvrhMDAAAuYfbqK8INAADwKIQbAADgUQg3AADAoxBuAACARyHcAAAAj0K4AQAAHoVwAwAAPArhBgAAeBTCDQAA8CiEGwAA4FEINwAAwKMQbgAAgEch3AAAAI/iY3YB7ta2DXtlZaXJlQAAgDPV9nu77fd4V/pcuKmqqpIkJScnm1wJAAA4W1VVVbJarV2eYzHOJAJ5kJaWFuXl5Sk0NFQWi8Wpr11ZWank5GTl5uYqLCzMqa/dG9EeHdEm7dEeHdEm7dEe7fXl9jAMQ1VVVUpMTJSXV9ezavpcz42Xl5eSkpJc+h5hYWF97kvXFdqjI9qkPdqjI9qkPdqjvb7aHqfrsWnDhGIAAOBRCDcAAMCjEG6cyN/fX4sXL5a/v7/ZpfQItEdHtEl7tEdHtEl7tEd7tMeZ6XMTigEAgGej5wYAAHgUwg0AAPAohBsAAOBRCDcAAMCjEG6c5Pnnn1daWpoCAgI0fvx4ffLJJ2aX5BIPP/ywLBZLu1t8fLzjccMw9PDDDysxMVGBgYGaMWOG9u/f3+41bDabbrvtNkVHRys4OFhXXnmljh8/7u6P0m1btmzRFVdcocTERFksFr333nvtHndWG5SVlemGG26Q1WqV1WrVDTfcoPLychd/urN3uva4+eabO3xnpkyZ0u4cT2qPJUuWaOLEiQoNDVVsbKzmzZunzMzMduf0pe/ImbRHX/uOvPDCCxo9erTjQnxTp07VBx984Hi8L30/XMbAOXvnnXcMX19f4+WXXzYOHDhg3HHHHUZwcLCRnZ1tdmlOt3jxYiM9Pd3Iz8933AoLCx2PP/bYY0ZoaKixYsUK4+uvvzauvfZaIyEhwaisrHScM3/+fKNfv37G+vXrjV27dhkXXXSRkZGRYTQ1NZnxkc7a2rVrjQceeMBYsWKFIclYtWpVu8ed1QaXXnqpMXLkSGPr1q3G1q1bjZEjRxqXX365uz7mGTtde9x0003GpZde2u47U1JS0u4cT2qP2bNnG6+++qqxb98+Y8+ePcaPf/xjo3///kZ1dbXjnL70HTmT9uhr35HVq1cba9asMTIzM43MzEzj/vvvN3x9fY19+/YZhtG3vh+uQrhxgkmTJhnz589vd2zYsGHGvffea1JFrrN48WIjIyOj08daWlqM+Ph447HHHnMcq6+vN6xWq/Hiiy8ahmEY5eXlhq+vr/HOO+84zjlx4oTh5eVlrFu3zqW1u8IPf5k7qw0OHDhgSDI+//xzxznbtm0zJBmHDh1y8afqvlOFm7lz557yOZ7cHoZhGIWFhYYkY/PmzYZh8B35YXsYBt8RwzCMiIgI429/+1uf/344C8NS56ihoUE7d+7UrFmz2h2fNWuWtm7dalJVrnX48GElJiYqLS1NP//5z3X06FFJUlZWlgoKCtq1hb+/vy688EJHW+zcuVONjY3tzklMTNTIkSM9or2c1Qbbtm2T1WrV5MmTHedMmTJFVqu1V7bTpk2bFBsbqyFDhuiXv/ylCgsLHY95entUVFRIkiIjIyXxHflhe7Tpq9+R5uZmvfPOO6qpqdHUqVP7/PfDWQg356i4uFjNzc2Ki4trdzwuLk4FBQUmVeU6kydP1vLly/Xhhx/q5ZdfVkFBgaZNm6aSkhLH5+2qLQoKCuTn56eIiIhTntObOasNCgoKFBsb2+H1Y2Nje107zZkzR2+++aY2bNigJ554Ql9++aUuvvhi2Ww2SZ7dHoZhaNGiRTr//PM1cuRISX37O9JZe0h98zvy9ddfKyQkRP7+/po/f75WrVqlESNG9OnvhzP1uV3BXcVisbS7bxhGh2OeYM6cOY6fR40apalTp2rgwIF67bXXHBMAu9MWntZezmiDzs7vje107bXXOn4eOXKkJkyYoJSUFK1Zs0ZXXXXVKZ/nCe2xcOFC7d27V59++mmHx/rid+RU7dEXvyNDhw7Vnj17VF5erhUrVuimm27S5s2bHY/3xe+HM9Fzc46io6Pl7e3dIQkXFhZ2SN6eKDg4WKNGjdLhw4cdq6a6aov4+Hg1NDSorKzslOf0Zs5qg/j4eJ08ebLD6xcVFfX6dkpISFBKSooOHz4syXPb47bbbtPq1au1ceNGJSUlOY731e/IqdqjM33hO+Ln56dBgwZpwoQJWrJkiTIyMvTUU0/12e+HsxFuzpGfn5/Gjx+v9evXtzu+fv16TZs2zaSq3Mdms+ngwYNKSEhQWlqa4uPj27VFQ0ODNm/e7GiL8ePHy9fXt905+fn52rdvn0e0l7PaYOrUqaqoqND27dsd53zxxReqqKjo9e1UUlKi3NxcJSQkSPK89jAMQwsXLtTKlSu1YcMGpaWltXu8r31HTtcenfH070hnDMOQzWbrc98Pl3Hr9GUP1bYU/JVXXjEOHDhg3HnnnUZwcLBx7Ngxs0tzurvuusvYtGmTcfToUePzzz83Lr/8ciM0NNTxWR977DHDarUaK1euNL7++mvjuuuu63QJY1JSkvHxxx8bu3btMi6++OJetRS8qqrK2L17t7F7925DkvGXv/zF2L17t2Ppv7Pa4NJLLzVGjx5tbNu2zdi2bZsxatSoHrmMs6v2qKqqMu666y5j69atRlZWlrFx40Zj6tSpRr9+/Ty2PW699VbDarUamzZtare0uba21nFOX/qOnK49+uJ35L777jO2bNliZGVlGXv37jXuv/9+w8vLy/joo48Mw+hb3w9XIdw4yXPPPWekpKQYfn5+xrhx49otc/Qkbddb8PX1NRITE42rrrrK2L9/v+PxlpYWY/HixUZ8fLzh7+9vTJ8+3fj666/bvUZdXZ2xcOFCIzIy0ggMDDQuv/xyIycnx90fpds2btxoSOpwu+mmmwzDcF4blJSUGNdff70RGhpqhIaGGtdff71RVlbmpk955rpqj9raWmPWrFlGTEyM4evra/Tv39+46aabOnxWT2qPztpCkvHqq686zulL35HTtUdf/I7ccsstjt8XMTExxsyZMx3BxjD61vfDVSyGYRju6ycCAABwLebcAAAAj0K4AQAAHoVwAwAAPArhBgAAeBTCDQAA8CiEGwAA4FEINwAAwKMQbgCctWPHjslisWjPnj1ml+Jw6NAhTZkyRQEBARozZkyn58yYMUN33nmnW+s6ExaLRe+9957ZZQAeg3AD9EI333yzLBaLHnvssXbH33vvvT6x429nFi9erODgYGVmZupf//pXp+esXLlSjz76qON+amqqli5d6qYKpYcffrjT4JWfn685c+a4rQ7A0xFugF4qICBAjz/+eIedgXuzhoaGbj/3yJEjOv/885WSkqKoqKhOz4mMjFRoaGi33+NUzqVuyb6Ds7+/v5OqAUC4AXqpH/3oR4qPj9eSJUtOeU5nPQVLly5Vamqq4/7NN9+sefPm6Q9/+IPi4uIUHh6u3/3ud2pqatJvfvMbRUZGKikpSX//+987vP6hQ4c0bdo0BQQEKD09XZs2bWr3+IEDB3TZZZcpJCREcXFxuuGGG1RcXOx4fMaMGVq4cKEWLVqk6OhoXXLJJZ1+jpaWFj3yyCNKSkqSv7+/xowZo3Xr1jket1gs2rlzpx555BFZLBY9/PDDnb7O94elZsyYoezsbP3nf/6nLBZLux6vrVu3avr06QoMDFRycrJuv/121dTUOB5PTU3Vf/3Xf+nmm2+W1WrVL3/5S0nSPffcoyFDhigoKEgDBgzQgw8+qMbGRknSsmXL9Lvf/U5fffWV4/2WLVvmqP/7w1Jff/21Lr74YgUGBioqKkq/+tWvVF1d3eHv7M9//rMSEhIUFRWlBQsWON5Lkp5//nkNHjxYAQEBiouL0zXXXNNpmwCeiHAD9FLe3t76wx/+oGeeeUbHjx8/p9fasGGD8vLytGXLFv3lL3/Rww8/rMsvv1wRERH64osvNH/+fM2fP1+5ubntnveb3/xGd911l3bv3q1p06bpyiuvVElJiST7UMuFF16oMWPGaMeOHVq3bp1Onjypn/3sZ+1e47XXXpOPj48+++wz/fWvf+20vqeeekpPPPGE/vznP2vv3r2aPXu2rrzySh0+fNjxXunp6brrrruUn5+vu++++7SfeeXKlUpKStIjjzyi/Px85efnS7IHi9mzZ+uqq67S3r179e677+rTTz/VwoUL2z3/T3/6k0aOHKmdO3fqwQcflCSFhoZq2bJlOnDggJ566im9/PLLevLJJyVJ1157re666y6lp6c73u/aa6/tUFdtba0uvfRSRURE6Msvv9T//M//6OOPP+7w/hs3btSRI0e0ceNGvfbaa1q2bJkjLO3YsUO33367HnnkEWVmZmrdunWaPn36adsE8Bhm79wJ4OzddNNNxty5cw3DMIwpU6YYt9xyi2EYhrFq1Srj+/9ZL1682MjIyGj33CeffNJISUlp91opKSlGc3Oz49jQoUONCy64wHG/qanJCA4ONt5++23DMAwjKyvLkGQ89thjjnMaGxuNpKQk4/HHHzcMwzAefPBBY9asWe3eOzc315BkZGZmGoZhGBdeeKExZsyY037exMRE4/e//327YxMnTjR+/etfO+5nZGQYixcv7vJ1LrzwQuOOO+5w3E9JSTGefPLJdufccMMNxq9+9at2xz755BPDy8vLqKurczxv3rx5p637j3/8ozF+/HjH/c7+PgzDvnP2qlWrDMMwjJdeesmIiIgwqqurHY+vWbPG8PLyMgoKCgzD+O7vrKmpyXHOT3/6U+Paa681DMMwVqxYYYSFhRmVlZWnrRHwRPTcAL3c448/rtdee00HDhzo9mukp6fLy+u7fw7i4uI0atQox31vb29FRUWpsLCw3fOmTp3q+NnHx0cTJkzQwYMHJUk7d+7Uxo0bFRIS4rgNGzZMkn1+TJsJEyZ0WVtlZaXy8vJ03nnntTt+3nnnOd7LmXbu3Klly5a1q3v27NlqaWlRVlZWl3X/4x//0Pnnn6/4+HiFhITowQcfVE5Ozlm9/8GDB5WRkaHg4GDHsfPOO08tLS3KzMx0HEtPT5e3t7fjfkJCguPv55JLLlFKSooGDBigG264QW+++aZqa2vPqg6gNyPcAL3c9OnTNXv2bN1///0dHvPy8pJhGO2OfX9eRhtfX9929y0WS6fHWlpaTltP29yVlpYWXXHFFdqzZ0+72+HDh9sNkXz/l/iZvG4bwzBcsjKspaVF//Ef/9Gu5q+++kqHDx/WwIEDHef9sO7PP/9cP//5zzVnzhy9//772r17tx544IGznmzc1ef6/vGu/n5CQ0O1a9cuvf3220pISNBDDz2kjIwMlZeXn1UtQG/lY3YBAM7dY489pjFjxmjIkCHtjsfExKigoKDdL0xnXpvm888/dwSVpqYm7dy50zE3ZNy4cVqxYoVSU1Pl49P9f2rCwsKUmJioTz/9tF0o2rp1qyZNmnRO9fv5+am5ubndsXHjxmn//v0aNGjQWb3WZ599ppSUFD3wwAOOY9nZ2ad9vx8aMWKEXnvtNdXU1DgC1GeffSYvL68Of79d8fHx0Y9+9CP96Ec/0uLFixUeHq4NGzboqquuOotPBfRO9NwAHmDUqFG6/vrr9cwzz7Q7PmPGDBUVFemPf/yjjhw5oueee04ffPCB0973ueee06pVq3To0CEtWLBAZWVluuWWWyRJCxYsUGlpqa677jpt375dR48e1UcffaRbbrnltL/gf+g3v/mNHn/8cb377rvKzMzUvffeqz179uiOO+44p/pTU1O1ZcsWnThxwrGK65577tG2bdu0YMECR0/T6tWrddttt3X5WoMGDVJOTo7eeecdHTlyRE8//bRWrVrV4f2ysrK0Z88eFRcXy2azdXid66+/XgEBAbrpppu0b98+bdy4UbfddptuuOEGxcXFndHnev/99/X0009rz549ys7O1vLly9XS0qKhQ4eeYcsAvRvhBvAQjz76aIchqOHDh+v555/Xc889p4yMDG3fvv2MVhKdqccee0yPP/64MjIy9Mknn+if//ynoqOjJUmJiYn67LPP1NzcrNmzZ2vkyJG64447ZLVa283vORO333677rrrLt11110aNWqU1q1bp9WrV2vw4MHnVP8jjzyiY8eOaeDAgYqJiZEkjR49Wps3b9bhw4d1wQUXaOzYsXrwwQeVkJDQ5WvNnTtX//mf/6mFCxdqzJgx2rp1q2MVVZurr75al156qS666CLFxMTo7bff7vA6QUFB+vDDD1VaWqqJEyfqmmuu0cyZM/Xss8+e8ecKDw/XypUrdfHFF2v48OF68cUX9fbbbys9Pf2MXwPozSzGD/81BAAA6MXouQEAAB6FcAMAADwK4QYAAHgUwg0AAPAohBsAAOBRCDcAAMCjEG4AAIBHIdwAAACPQrgBAAAehXADAAA8CuEGAAB4FMINAADwKP8fpZSMBdhOjp4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#get training and test error for the best NN model from CV\n",
    "mlp = MLPClassifier(hidden_layer_sizes=best_hidden_layer_sizes,max_iter=10000, alpha=1e-4, solver='sgd', tol=1e-4, learning_rate_init=best_p, random_state=ID,batch_size=best_batch_size)# ADD YOUR CODE HERE\n",
    "mlp_fit = mlp.fit(X_train, y_train)\n",
    "\n",
    "training_error = 1 - mlp_fit.score(X_train,y_train)# ADD YOUR CODE HERE\n",
    "test_error =1 - mlp_fit.score(X_test,y_test) # ADD YOUR CODE HERE\n",
    "\n",
    "print ('\\nRESULTS FOR BEST NN\\n')\n",
    "\n",
    "print (\"Best NN training error: %f\" % training_error)\n",
    "print (\"Best NN test error: %f\" % test_error)\n",
    "\n",
    "plt.plot(mlp.loss_curve_, label=\"loss\")\n",
    "plt.legend(loc = 1)\n",
    "plt.xlabel('Number of iterations')\n",
    "plt.ylabel('Loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## B) More data \n",
    "Now let's do the same but **using 20000** (or less if it takes too long on your machine) **data points for training**. <br>\n",
    "Make sure you are **consistent with the choice of `m_training`** in this and the later cells. <br>\n",
    "Use the **same NN architecture** as before, but you can try more if you like and have a powerful computer!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Labels in training dataset:  [0 1 2 3 4 5 6 7 8 9]\n",
      "Frequencies in training dataset:  [1943 2014 2072 1980 1980 1996 1988 1959 2020 2048]\n"
     ]
    }
   ],
   "source": [
    "X = X[permutation]\n",
    "y = y[permutation]\n",
    "\n",
    "m_training = 20000# ADD YOUR CODE HERE\n",
    "\n",
    "X_train, X_test = X[:m_training],X[m_training:]# ADD YOUR CODE HERE\n",
    "y_train, y_test = y[:m_training],y[m_training:]# ADD YOUR CODE HERE\n",
    "\n",
    "labels, freqs = np.unique(y_train, return_counts=True) \n",
    "print(\"Labels in training dataset: \", labels)\n",
    "print(\"Frequencies in training dataset: \", freqs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TO DO B.1** Train the NNs with the added data points using the optimum parameters found above. <br>\n",
    "Eventually, feel free to try different architectures if you like. <br>\n",
    "We suggest that you use `verbose=True` so have an idea of how long it takes to run 1 iteration (eventually reduce also the number of iterations to 50). <br>\n",
    "This is just for debug purposes, **remember to switch it off** once you found a setup you like. <br>\n",
    "As before, you might get a convergence warning (especially if you reduced the number of iterations), you can safely ignore it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 1, loss = 2.27798304\n",
      "Iteration 2, loss = 2.02634352\n",
      "Iteration 3, loss = 1.84614977\n",
      "Iteration 4, loss = 1.70619821\n",
      "Iteration 5, loss = 1.58073905\n",
      "Iteration 6, loss = 1.47490115\n",
      "Iteration 7, loss = 1.38546206\n",
      "Iteration 8, loss = 1.31030715\n",
      "Iteration 9, loss = 1.24633926\n",
      "Iteration 10, loss = 1.19159188\n",
      "Iteration 11, loss = 1.14399098\n",
      "Iteration 12, loss = 1.10270334\n",
      "Iteration 13, loss = 1.06655720\n",
      "Iteration 14, loss = 1.03464826\n",
      "Iteration 15, loss = 1.00634784\n",
      "Iteration 16, loss = 0.98082114\n",
      "Iteration 17, loss = 0.95799514\n",
      "Iteration 18, loss = 0.93732747\n",
      "Iteration 19, loss = 0.91844948\n",
      "Iteration 20, loss = 0.90098005\n",
      "Iteration 21, loss = 0.88497813\n",
      "Iteration 22, loss = 0.87026906\n",
      "Iteration 23, loss = 0.85658816\n",
      "Iteration 24, loss = 0.84368786\n",
      "Iteration 25, loss = 0.83186940\n",
      "Iteration 26, loss = 0.82054202\n",
      "Iteration 27, loss = 0.81008126\n",
      "Iteration 28, loss = 0.80008846\n",
      "Iteration 29, loss = 0.79082342\n",
      "Iteration 30, loss = 0.78202830\n",
      "Iteration 31, loss = 0.77356898\n",
      "Iteration 32, loss = 0.76554588\n",
      "Iteration 33, loss = 0.75794441\n",
      "Iteration 34, loss = 0.75072253\n",
      "Iteration 35, loss = 0.74367305\n",
      "Iteration 36, loss = 0.73711838\n",
      "Iteration 37, loss = 0.73077332\n",
      "Iteration 38, loss = 0.72474348\n",
      "Iteration 39, loss = 0.71892671\n",
      "Iteration 40, loss = 0.71336921\n",
      "Iteration 41, loss = 0.70779161\n",
      "Iteration 42, loss = 0.70254984\n",
      "Iteration 43, loss = 0.69756739\n",
      "Iteration 44, loss = 0.69268683\n",
      "Iteration 45, loss = 0.68796295\n",
      "Iteration 46, loss = 0.68343233\n",
      "Iteration 47, loss = 0.67919532\n",
      "Iteration 48, loss = 0.67484628\n",
      "Iteration 49, loss = 0.67070983\n",
      "Iteration 50, loss = 0.66686332\n",
      "Iteration 51, loss = 0.66302201\n",
      "Iteration 52, loss = 0.65925878\n",
      "Iteration 53, loss = 0.65555663\n",
      "Iteration 54, loss = 0.65183377\n",
      "Iteration 55, loss = 0.64852403\n",
      "Iteration 56, loss = 0.64528612\n",
      "Iteration 57, loss = 0.64190651\n",
      "Iteration 58, loss = 0.63879676\n",
      "Iteration 59, loss = 0.63559454\n",
      "Iteration 60, loss = 0.63263906\n",
      "Iteration 61, loss = 0.62959348\n",
      "Iteration 62, loss = 0.62674540\n",
      "Iteration 63, loss = 0.62388570\n",
      "Iteration 64, loss = 0.62125568\n",
      "Iteration 65, loss = 0.61849640\n",
      "Iteration 66, loss = 0.61594699\n",
      "Iteration 67, loss = 0.61330738\n",
      "Iteration 68, loss = 0.61092838\n",
      "Iteration 69, loss = 0.60844381\n",
      "Iteration 70, loss = 0.60600660\n",
      "Iteration 71, loss = 0.60372025\n",
      "Iteration 72, loss = 0.60146885\n",
      "Iteration 73, loss = 0.59933375\n",
      "Iteration 74, loss = 0.59694780\n",
      "Iteration 75, loss = 0.59494475\n",
      "Iteration 76, loss = 0.59269023\n",
      "Iteration 77, loss = 0.59059855\n",
      "Iteration 78, loss = 0.58855604\n",
      "Iteration 79, loss = 0.58664080\n",
      "Iteration 80, loss = 0.58474010\n",
      "Iteration 81, loss = 0.58286747\n",
      "Iteration 82, loss = 0.58083434\n",
      "Iteration 83, loss = 0.57898806\n",
      "Iteration 84, loss = 0.57732099\n",
      "Iteration 85, loss = 0.57555319\n",
      "Iteration 86, loss = 0.57384210\n",
      "Iteration 87, loss = 0.57207470\n",
      "Iteration 88, loss = 0.57037526\n",
      "Iteration 89, loss = 0.56873199\n",
      "Iteration 90, loss = 0.56718164\n",
      "Iteration 91, loss = 0.56563833\n",
      "Iteration 92, loss = 0.56395143\n",
      "Iteration 93, loss = 0.56238585\n",
      "Iteration 94, loss = 0.56111663\n",
      "Iteration 95, loss = 0.55948322\n",
      "Iteration 96, loss = 0.55799679\n",
      "Iteration 97, loss = 0.55650200\n",
      "Iteration 98, loss = 0.55512926\n",
      "Iteration 99, loss = 0.55375118\n",
      "Iteration 100, loss = 0.55246087\n",
      "Iteration 101, loss = 0.55096163\n",
      "Iteration 102, loss = 0.54964363\n",
      "Iteration 103, loss = 0.54846459\n",
      "Iteration 104, loss = 0.54719196\n",
      "Iteration 105, loss = 0.54588824\n",
      "Iteration 106, loss = 0.54456884\n",
      "Iteration 107, loss = 0.54333600\n",
      "Iteration 108, loss = 0.54215677\n",
      "Iteration 109, loss = 0.54098976\n",
      "Iteration 110, loss = 0.53974813\n",
      "Iteration 111, loss = 0.53852890\n",
      "Iteration 112, loss = 0.53752424\n",
      "Iteration 113, loss = 0.53641164\n",
      "Iteration 114, loss = 0.53524581\n",
      "Iteration 115, loss = 0.53418664\n",
      "Iteration 116, loss = 0.53314482\n",
      "Iteration 117, loss = 0.53212795\n",
      "Iteration 118, loss = 0.53106509\n",
      "Iteration 119, loss = 0.53017050\n",
      "Iteration 120, loss = 0.52888470\n",
      "Iteration 121, loss = 0.52801021\n",
      "Iteration 122, loss = 0.52686142\n",
      "Iteration 123, loss = 0.52603331\n",
      "Iteration 124, loss = 0.52493101\n",
      "Iteration 125, loss = 0.52439764\n",
      "Iteration 126, loss = 0.52297430\n",
      "Iteration 127, loss = 0.52206462\n",
      "Iteration 128, loss = 0.52120993\n",
      "Iteration 129, loss = 0.52028157\n",
      "Iteration 130, loss = 0.51944068\n",
      "Iteration 131, loss = 0.51856013\n",
      "Iteration 132, loss = 0.51769181\n",
      "Iteration 133, loss = 0.51667118\n",
      "Iteration 134, loss = 0.51604631\n",
      "Iteration 135, loss = 0.51507648\n",
      "Iteration 136, loss = 0.51422496\n",
      "Iteration 137, loss = 0.51357548\n",
      "Iteration 138, loss = 0.51281665\n",
      "Iteration 139, loss = 0.51172504\n",
      "Iteration 140, loss = 0.51087872\n",
      "Iteration 141, loss = 0.51023686\n",
      "Iteration 142, loss = 0.50948132\n",
      "Iteration 143, loss = 0.50882213\n",
      "Iteration 144, loss = 0.50805371\n",
      "Iteration 145, loss = 0.50704427\n",
      "Iteration 146, loss = 0.50640453\n",
      "Iteration 147, loss = 0.50563318\n",
      "Iteration 148, loss = 0.50503922\n",
      "Iteration 149, loss = 0.50418759\n",
      "Iteration 150, loss = 0.50349650\n",
      "Iteration 151, loss = 0.50268824\n",
      "Iteration 152, loss = 0.50204919\n",
      "Iteration 153, loss = 0.50139755\n",
      "Iteration 154, loss = 0.50065942\n",
      "Iteration 155, loss = 0.50004575\n",
      "Iteration 156, loss = 0.49956464\n",
      "Iteration 157, loss = 0.49888494\n",
      "Iteration 158, loss = 0.49803088\n",
      "Iteration 159, loss = 0.49736324\n",
      "Iteration 160, loss = 0.49670531\n",
      "Iteration 161, loss = 0.49607903\n",
      "Iteration 162, loss = 0.49555605\n",
      "Iteration 163, loss = 0.49487626\n",
      "Iteration 164, loss = 0.49423899\n",
      "Iteration 165, loss = 0.49378245\n",
      "Iteration 166, loss = 0.49303788\n",
      "Iteration 167, loss = 0.49239169\n",
      "Iteration 168, loss = 0.49177085\n",
      "Iteration 169, loss = 0.49140692\n",
      "Iteration 170, loss = 0.49069856\n",
      "Iteration 171, loss = 0.48996773\n",
      "Iteration 172, loss = 0.48958882\n",
      "Iteration 173, loss = 0.48899741\n",
      "Iteration 174, loss = 0.48846722\n",
      "Iteration 175, loss = 0.48787491\n",
      "Iteration 176, loss = 0.48733215\n",
      "Iteration 177, loss = 0.48665372\n",
      "Iteration 178, loss = 0.48617391\n",
      "Iteration 179, loss = 0.48559522\n",
      "Iteration 180, loss = 0.48520511\n",
      "Iteration 181, loss = 0.48469060\n",
      "Iteration 182, loss = 0.48399944\n",
      "Iteration 183, loss = 0.48349169\n",
      "Iteration 184, loss = 0.48294276\n",
      "Iteration 185, loss = 0.48248419\n",
      "Iteration 186, loss = 0.48205987\n",
      "Iteration 187, loss = 0.48155401\n",
      "Iteration 188, loss = 0.48105386\n",
      "Iteration 189, loss = 0.48040370\n",
      "Iteration 190, loss = 0.48009250\n",
      "Iteration 191, loss = 0.47951262\n",
      "Iteration 192, loss = 0.47906517\n",
      "Iteration 193, loss = 0.47862638\n",
      "Iteration 194, loss = 0.47817477\n",
      "Iteration 195, loss = 0.47786166\n",
      "Iteration 196, loss = 0.47719721\n",
      "Iteration 197, loss = 0.47668326\n",
      "Iteration 198, loss = 0.47623623\n",
      "Iteration 199, loss = 0.47576873\n",
      "Iteration 200, loss = 0.47532437\n",
      "Iteration 201, loss = 0.47501710\n",
      "Iteration 202, loss = 0.47424553\n",
      "Iteration 203, loss = 0.47416647\n",
      "Iteration 204, loss = 0.47356056\n",
      "Iteration 205, loss = 0.47318703\n",
      "Iteration 206, loss = 0.47276662\n",
      "Iteration 207, loss = 0.47235077\n",
      "Iteration 208, loss = 0.47170285\n",
      "Iteration 209, loss = 0.47143859\n",
      "Iteration 210, loss = 0.47088040\n",
      "Iteration 211, loss = 0.47045709\n",
      "Iteration 212, loss = 0.47002115\n",
      "Iteration 213, loss = 0.46989228\n",
      "Iteration 214, loss = 0.46932338\n",
      "Iteration 215, loss = 0.46889643\n",
      "Iteration 216, loss = 0.46848059\n",
      "Iteration 217, loss = 0.46811491\n",
      "Iteration 218, loss = 0.46780763\n",
      "Iteration 219, loss = 0.46728067\n",
      "Iteration 220, loss = 0.46699024\n",
      "Iteration 221, loss = 0.46648381\n",
      "Iteration 222, loss = 0.46611212\n",
      "Iteration 223, loss = 0.46566246\n",
      "Iteration 224, loss = 0.46536506\n",
      "Iteration 225, loss = 0.46479438\n",
      "Iteration 226, loss = 0.46461893\n",
      "Iteration 227, loss = 0.46422940\n",
      "Iteration 228, loss = 0.46380881\n",
      "Iteration 229, loss = 0.46337170\n",
      "Iteration 230, loss = 0.46313866\n",
      "Iteration 231, loss = 0.46272590\n",
      "Iteration 232, loss = 0.46226930\n",
      "Iteration 233, loss = 0.46188039\n",
      "Iteration 234, loss = 0.46180511\n",
      "Iteration 235, loss = 0.46116117\n",
      "Iteration 236, loss = 0.46091519\n",
      "Iteration 237, loss = 0.46034851\n",
      "Iteration 238, loss = 0.46017551\n",
      "Iteration 239, loss = 0.45975170\n",
      "Iteration 240, loss = 0.45950253\n",
      "Iteration 241, loss = 0.45912072\n",
      "Iteration 242, loss = 0.45865185\n",
      "Iteration 243, loss = 0.45841745\n",
      "Iteration 244, loss = 0.45826429\n",
      "Iteration 245, loss = 0.45779973\n",
      "Iteration 246, loss = 0.45729578\n",
      "Iteration 247, loss = 0.45718218\n",
      "Iteration 248, loss = 0.45681750\n",
      "Iteration 249, loss = 0.45635978\n",
      "Iteration 250, loss = 0.45619670\n",
      "Iteration 251, loss = 0.45576101\n",
      "Iteration 252, loss = 0.45537494\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 253, loss = 0.45518874\n",
      "Iteration 254, loss = 0.45483483\n",
      "Iteration 255, loss = 0.45424901\n",
      "Iteration 256, loss = 0.45431650\n",
      "Iteration 257, loss = 0.45380290\n",
      "Iteration 258, loss = 0.45348679\n",
      "Iteration 259, loss = 0.45323868\n",
      "Iteration 260, loss = 0.45275390\n",
      "Iteration 261, loss = 0.45256205\n",
      "Iteration 262, loss = 0.45219147\n",
      "Iteration 263, loss = 0.45197827\n",
      "Iteration 264, loss = 0.45168485\n",
      "Iteration 265, loss = 0.45130658\n",
      "Iteration 266, loss = 0.45106996\n",
      "Iteration 267, loss = 0.45069604\n",
      "Iteration 268, loss = 0.45049335\n",
      "Iteration 269, loss = 0.45009466\n",
      "Iteration 270, loss = 0.44980950\n",
      "Iteration 271, loss = 0.44955796\n",
      "Iteration 272, loss = 0.44911110\n",
      "Iteration 273, loss = 0.44890239\n",
      "Iteration 274, loss = 0.44854819\n",
      "Iteration 275, loss = 0.44833981\n",
      "Iteration 276, loss = 0.44805190\n",
      "Iteration 277, loss = 0.44770415\n",
      "Iteration 278, loss = 0.44747794\n",
      "Iteration 279, loss = 0.44704586\n",
      "Iteration 280, loss = 0.44695481\n",
      "Iteration 281, loss = 0.44659213\n",
      "Iteration 282, loss = 0.44618593\n",
      "Iteration 283, loss = 0.44605487\n",
      "Iteration 284, loss = 0.44579289\n",
      "Iteration 285, loss = 0.44539183\n",
      "Iteration 286, loss = 0.44522689\n",
      "Iteration 287, loss = 0.44477748\n",
      "Iteration 288, loss = 0.44459882\n",
      "Iteration 289, loss = 0.44433979\n",
      "Iteration 290, loss = 0.44421670\n",
      "Iteration 291, loss = 0.44384318\n",
      "Iteration 292, loss = 0.44361059\n",
      "Iteration 293, loss = 0.44320803\n",
      "Iteration 294, loss = 0.44298655\n",
      "Iteration 295, loss = 0.44267805\n",
      "Iteration 296, loss = 0.44240201\n",
      "Iteration 297, loss = 0.44213576\n",
      "Iteration 298, loss = 0.44176686\n",
      "Iteration 299, loss = 0.44157737\n",
      "Iteration 300, loss = 0.44133479\n",
      "Iteration 301, loss = 0.44127674\n",
      "Iteration 302, loss = 0.44071973\n",
      "Iteration 303, loss = 0.44059370\n",
      "Iteration 304, loss = 0.44024665\n",
      "Iteration 305, loss = 0.43998508\n",
      "Iteration 306, loss = 0.43973959\n",
      "Iteration 307, loss = 0.43948303\n",
      "Iteration 308, loss = 0.43930926\n",
      "Iteration 309, loss = 0.43917886\n",
      "Iteration 310, loss = 0.43875883\n",
      "Iteration 311, loss = 0.43874783\n",
      "Iteration 312, loss = 0.43819504\n",
      "Iteration 313, loss = 0.43817760\n",
      "Iteration 314, loss = 0.43767392\n",
      "Iteration 315, loss = 0.43761488\n",
      "Iteration 316, loss = 0.43739545\n",
      "Iteration 317, loss = 0.43704122\n",
      "Iteration 318, loss = 0.43687654\n",
      "Iteration 319, loss = 0.43673034\n",
      "Iteration 320, loss = 0.43632472\n",
      "Iteration 321, loss = 0.43616000\n",
      "Iteration 322, loss = 0.43588225\n",
      "Iteration 323, loss = 0.43566885\n",
      "Iteration 324, loss = 0.43534831\n",
      "Iteration 325, loss = 0.43531332\n",
      "Iteration 326, loss = 0.43492392\n",
      "Iteration 327, loss = 0.43485469\n",
      "Iteration 328, loss = 0.43446054\n",
      "Iteration 329, loss = 0.43432397\n",
      "Iteration 330, loss = 0.43400096\n",
      "Iteration 331, loss = 0.43398610\n",
      "Iteration 332, loss = 0.43362359\n",
      "Iteration 333, loss = 0.43341307\n",
      "Iteration 334, loss = 0.43319018\n",
      "Iteration 335, loss = 0.43299116\n",
      "Iteration 336, loss = 0.43266266\n",
      "Iteration 337, loss = 0.43255574\n",
      "Iteration 338, loss = 0.43218567\n",
      "Iteration 339, loss = 0.43208639\n",
      "Iteration 340, loss = 0.43187346\n",
      "Iteration 341, loss = 0.43169329\n",
      "Iteration 342, loss = 0.43139225\n",
      "Iteration 343, loss = 0.43130400\n",
      "Iteration 344, loss = 0.43107814\n",
      "Iteration 345, loss = 0.43071042\n",
      "Iteration 346, loss = 0.43058694\n",
      "Iteration 347, loss = 0.43035714\n",
      "Iteration 348, loss = 0.43012047\n",
      "Iteration 349, loss = 0.42991775\n",
      "Iteration 350, loss = 0.42969720\n",
      "Iteration 351, loss = 0.42944403\n",
      "Iteration 352, loss = 0.42928514\n",
      "Iteration 353, loss = 0.42904086\n",
      "Iteration 354, loss = 0.42885945\n",
      "Iteration 355, loss = 0.42872688\n",
      "Iteration 356, loss = 0.42830535\n",
      "Iteration 357, loss = 0.42826111\n",
      "Iteration 358, loss = 0.42792313\n",
      "Iteration 359, loss = 0.42786152\n",
      "Iteration 360, loss = 0.42767830\n",
      "Iteration 361, loss = 0.42737301\n",
      "Iteration 362, loss = 0.42711448\n",
      "Iteration 363, loss = 0.42709099\n",
      "Iteration 364, loss = 0.42677679\n",
      "Iteration 365, loss = 0.42661547\n",
      "Iteration 366, loss = 0.42652625\n",
      "Iteration 367, loss = 0.42611310\n",
      "Iteration 368, loss = 0.42594015\n",
      "Iteration 369, loss = 0.42584980\n",
      "Iteration 370, loss = 0.42557811\n",
      "Iteration 371, loss = 0.42538874\n",
      "Iteration 372, loss = 0.42515161\n",
      "Iteration 373, loss = 0.42487945\n",
      "Iteration 374, loss = 0.42467894\n",
      "Iteration 375, loss = 0.42460320\n",
      "Iteration 376, loss = 0.42427982\n",
      "Iteration 377, loss = 0.42418329\n",
      "Iteration 378, loss = 0.42401999\n",
      "Iteration 379, loss = 0.42384519\n",
      "Iteration 380, loss = 0.42358995\n",
      "Iteration 381, loss = 0.42333840\n",
      "Iteration 382, loss = 0.42326097\n",
      "Iteration 383, loss = 0.42302656\n",
      "Iteration 384, loss = 0.42282824\n",
      "Iteration 385, loss = 0.42264104\n",
      "Iteration 386, loss = 0.42236711\n",
      "Iteration 387, loss = 0.42218187\n",
      "Iteration 388, loss = 0.42213239\n",
      "Iteration 389, loss = 0.42206868\n",
      "Iteration 390, loss = 0.42173597\n",
      "Iteration 391, loss = 0.42157911\n",
      "Iteration 392, loss = 0.42135568\n",
      "Iteration 393, loss = 0.42113402\n",
      "Iteration 394, loss = 0.42094395\n",
      "Iteration 395, loss = 0.42076413\n",
      "Iteration 396, loss = 0.42060843\n",
      "Iteration 397, loss = 0.42042120\n",
      "Iteration 398, loss = 0.42007334\n",
      "Iteration 399, loss = 0.42009052\n",
      "Iteration 400, loss = 0.41980898\n",
      "Iteration 401, loss = 0.41966152\n",
      "Iteration 402, loss = 0.41950913\n",
      "Iteration 403, loss = 0.41925769\n",
      "Iteration 404, loss = 0.41901897\n",
      "Iteration 405, loss = 0.41903962\n",
      "Iteration 406, loss = 0.41877249\n",
      "Iteration 407, loss = 0.41861149\n",
      "Iteration 408, loss = 0.41847336\n",
      "Iteration 409, loss = 0.41834153\n",
      "Iteration 410, loss = 0.41801507\n",
      "Iteration 411, loss = 0.41811353\n",
      "Iteration 412, loss = 0.41770891\n",
      "Iteration 413, loss = 0.41745904\n",
      "Iteration 414, loss = 0.41728175\n",
      "Iteration 415, loss = 0.41731639\n",
      "Iteration 416, loss = 0.41698995\n",
      "Iteration 417, loss = 0.41670191\n",
      "Iteration 418, loss = 0.41653857\n",
      "Iteration 419, loss = 0.41657799\n",
      "Iteration 420, loss = 0.41634621\n",
      "Iteration 421, loss = 0.41620299\n",
      "Iteration 422, loss = 0.41595780\n",
      "Iteration 423, loss = 0.41582645\n",
      "Iteration 424, loss = 0.41583909\n",
      "Iteration 425, loss = 0.41562459\n",
      "Iteration 426, loss = 0.41525375\n",
      "Iteration 427, loss = 0.41507832\n",
      "Iteration 428, loss = 0.41507167\n",
      "Iteration 429, loss = 0.41482695\n",
      "Iteration 430, loss = 0.41472494\n",
      "Iteration 431, loss = 0.41465946\n",
      "Iteration 432, loss = 0.41423821\n",
      "Iteration 433, loss = 0.41413883\n",
      "Iteration 434, loss = 0.41412948\n",
      "Iteration 435, loss = 0.41381216\n",
      "Iteration 436, loss = 0.41353028\n",
      "Iteration 437, loss = 0.41350380\n",
      "Iteration 438, loss = 0.41329170\n",
      "Iteration 439, loss = 0.41312270\n",
      "Iteration 440, loss = 0.41284808\n",
      "Iteration 441, loss = 0.41280991\n",
      "Iteration 442, loss = 0.41286128\n",
      "Iteration 443, loss = 0.41246221\n",
      "Iteration 444, loss = 0.41241530\n",
      "Iteration 445, loss = 0.41209089\n",
      "Iteration 446, loss = 0.41209660\n",
      "Iteration 447, loss = 0.41190714\n",
      "Iteration 448, loss = 0.41170678\n",
      "Iteration 449, loss = 0.41155318\n",
      "Iteration 450, loss = 0.41143985\n",
      "Iteration 451, loss = 0.41124255\n",
      "Iteration 452, loss = 0.41119501\n",
      "Iteration 453, loss = 0.41088101\n",
      "Iteration 454, loss = 0.41075919\n",
      "Iteration 455, loss = 0.41058644\n",
      "Iteration 456, loss = 0.41055718\n",
      "Iteration 457, loss = 0.41032948\n",
      "Iteration 458, loss = 0.41026158\n",
      "Iteration 459, loss = 0.41000391\n",
      "Iteration 460, loss = 0.40984481\n",
      "Iteration 461, loss = 0.40972476\n",
      "Iteration 462, loss = 0.40952208\n",
      "Iteration 463, loss = 0.40952508\n",
      "Iteration 464, loss = 0.40933265\n",
      "Iteration 465, loss = 0.40906805\n",
      "Iteration 466, loss = 0.40901410\n",
      "Iteration 467, loss = 0.40874969\n",
      "Iteration 468, loss = 0.40865199\n",
      "Iteration 469, loss = 0.40849599\n",
      "Iteration 470, loss = 0.40828290\n",
      "Iteration 471, loss = 0.40818986\n",
      "Iteration 472, loss = 0.40799344\n",
      "Iteration 473, loss = 0.40790081\n",
      "Iteration 474, loss = 0.40761695\n",
      "Iteration 475, loss = 0.40763123\n",
      "Iteration 476, loss = 0.40742871\n",
      "Iteration 477, loss = 0.40716137\n",
      "Iteration 478, loss = 0.40717273\n",
      "Iteration 479, loss = 0.40700704\n",
      "Iteration 480, loss = 0.40692157\n",
      "Iteration 481, loss = 0.40670542\n",
      "Iteration 482, loss = 0.40659481\n",
      "Iteration 483, loss = 0.40631303\n",
      "Iteration 484, loss = 0.40610935\n",
      "Iteration 485, loss = 0.40608856\n",
      "Iteration 486, loss = 0.40589119\n",
      "Iteration 487, loss = 0.40576350\n",
      "Iteration 488, loss = 0.40568207\n",
      "Iteration 489, loss = 0.40548787\n",
      "Iteration 490, loss = 0.40548950\n",
      "Iteration 491, loss = 0.40527242\n",
      "Iteration 492, loss = 0.40499387\n",
      "Iteration 493, loss = 0.40487551\n",
      "Iteration 494, loss = 0.40486817\n",
      "Iteration 495, loss = 0.40472800\n",
      "Iteration 496, loss = 0.40433546\n",
      "Iteration 497, loss = 0.40428948\n",
      "Iteration 498, loss = 0.40402209\n",
      "Iteration 499, loss = 0.40408584\n",
      "Iteration 500, loss = 0.40386919\n",
      "Iteration 501, loss = 0.40388924\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 502, loss = 0.40347844\n",
      "Iteration 503, loss = 0.40347876\n",
      "Iteration 504, loss = 0.40324701\n",
      "Iteration 505, loss = 0.40322038\n",
      "Iteration 506, loss = 0.40314400\n",
      "Iteration 507, loss = 0.40291780\n",
      "Iteration 508, loss = 0.40268068\n",
      "Iteration 509, loss = 0.40259450\n",
      "Iteration 510, loss = 0.40247092\n",
      "Iteration 511, loss = 0.40230537\n",
      "Iteration 512, loss = 0.40217338\n",
      "Iteration 513, loss = 0.40228855\n",
      "Iteration 514, loss = 0.40198644\n",
      "Iteration 515, loss = 0.40188900\n",
      "Iteration 516, loss = 0.40168468\n",
      "Iteration 517, loss = 0.40144833\n",
      "Iteration 518, loss = 0.40138357\n",
      "Iteration 519, loss = 0.40149577\n",
      "Iteration 520, loss = 0.40119250\n",
      "Iteration 521, loss = 0.40114563\n",
      "Iteration 522, loss = 0.40088123\n",
      "Iteration 523, loss = 0.40076748\n",
      "Iteration 524, loss = 0.40051988\n",
      "Iteration 525, loss = 0.40032438\n",
      "Iteration 526, loss = 0.40030157\n",
      "Iteration 527, loss = 0.40020014\n",
      "Iteration 528, loss = 0.40002234\n",
      "Iteration 529, loss = 0.39974325\n",
      "Iteration 530, loss = 0.39986529\n",
      "Iteration 531, loss = 0.39959132\n",
      "Iteration 532, loss = 0.39948887\n",
      "Iteration 533, loss = 0.39936396\n",
      "Iteration 534, loss = 0.39906119\n",
      "Iteration 535, loss = 0.39905976\n",
      "Iteration 536, loss = 0.39883670\n",
      "Iteration 537, loss = 0.39875476\n",
      "Iteration 538, loss = 0.39871760\n",
      "Iteration 539, loss = 0.39853551\n",
      "Iteration 540, loss = 0.39841045\n",
      "Iteration 541, loss = 0.39821311\n",
      "Iteration 542, loss = 0.39808261\n",
      "Iteration 543, loss = 0.39803466\n",
      "Iteration 544, loss = 0.39777511\n",
      "Iteration 545, loss = 0.39784670\n",
      "Iteration 546, loss = 0.39750644\n",
      "Iteration 547, loss = 0.39747896\n",
      "Iteration 548, loss = 0.39734171\n",
      "Iteration 549, loss = 0.39746101\n",
      "Iteration 550, loss = 0.39727357\n",
      "Iteration 551, loss = 0.39691441\n",
      "Iteration 552, loss = 0.39697311\n",
      "Iteration 553, loss = 0.39677140\n",
      "Iteration 554, loss = 0.39652118\n",
      "Iteration 555, loss = 0.39649422\n",
      "Iteration 556, loss = 0.39625942\n",
      "Iteration 557, loss = 0.39618153\n",
      "Iteration 558, loss = 0.39606860\n",
      "Iteration 559, loss = 0.39589030\n",
      "Iteration 560, loss = 0.39575013\n",
      "Iteration 561, loss = 0.39570125\n",
      "Iteration 562, loss = 0.39548062\n",
      "Iteration 563, loss = 0.39535461\n",
      "Iteration 564, loss = 0.39527413\n",
      "Iteration 565, loss = 0.39509147\n",
      "Iteration 566, loss = 0.39505802\n",
      "Iteration 567, loss = 0.39496087\n",
      "Iteration 568, loss = 0.39470730\n",
      "Iteration 569, loss = 0.39468361\n",
      "Iteration 570, loss = 0.39453956\n",
      "Iteration 571, loss = 0.39426268\n",
      "Iteration 572, loss = 0.39420188\n",
      "Iteration 573, loss = 0.39410884\n",
      "Iteration 574, loss = 0.39392994\n",
      "Iteration 575, loss = 0.39382232\n",
      "Iteration 576, loss = 0.39374345\n",
      "Iteration 577, loss = 0.39360299\n",
      "Iteration 578, loss = 0.39352124\n",
      "Iteration 579, loss = 0.39336088\n",
      "Iteration 580, loss = 0.39320839\n",
      "Iteration 581, loss = 0.39312212\n",
      "Iteration 582, loss = 0.39297433\n",
      "Iteration 583, loss = 0.39292513\n",
      "Iteration 584, loss = 0.39268751\n",
      "Iteration 585, loss = 0.39248654\n",
      "Iteration 586, loss = 0.39257230\n",
      "Iteration 587, loss = 0.39235810\n",
      "Iteration 588, loss = 0.39222648\n",
      "Iteration 589, loss = 0.39213825\n",
      "Iteration 590, loss = 0.39197839\n",
      "Iteration 591, loss = 0.39178706\n",
      "Iteration 592, loss = 0.39163629\n",
      "Iteration 593, loss = 0.39170599\n",
      "Iteration 594, loss = 0.39136096\n",
      "Iteration 595, loss = 0.39133524\n",
      "Iteration 596, loss = 0.39111615\n",
      "Iteration 597, loss = 0.39109297\n",
      "Iteration 598, loss = 0.39095377\n",
      "Iteration 599, loss = 0.39096382\n",
      "Iteration 600, loss = 0.39068770\n",
      "Iteration 601, loss = 0.39063939\n",
      "Iteration 602, loss = 0.39062872\n",
      "Iteration 603, loss = 0.39063489\n",
      "Iteration 604, loss = 0.39014236\n",
      "Iteration 605, loss = 0.39037485\n",
      "Iteration 606, loss = 0.38987814\n",
      "Iteration 607, loss = 0.39002245\n",
      "Iteration 608, loss = 0.38972307\n",
      "Iteration 609, loss = 0.38944397\n",
      "Iteration 610, loss = 0.38965795\n",
      "Iteration 611, loss = 0.38952557\n",
      "Iteration 612, loss = 0.38919934\n",
      "Iteration 613, loss = 0.38928143\n",
      "Iteration 614, loss = 0.38914805\n",
      "Iteration 615, loss = 0.38903613\n",
      "Iteration 616, loss = 0.38897473\n",
      "Iteration 617, loss = 0.38867048\n",
      "Iteration 618, loss = 0.38846380\n",
      "Iteration 619, loss = 0.38879508\n",
      "Iteration 620, loss = 0.38848109\n",
      "Iteration 621, loss = 0.38815152\n",
      "Iteration 622, loss = 0.38802245\n",
      "Iteration 623, loss = 0.38804448\n",
      "Iteration 624, loss = 0.38785702\n",
      "Iteration 625, loss = 0.38809260\n",
      "Iteration 626, loss = 0.38771487\n",
      "Iteration 627, loss = 0.38782411\n",
      "Iteration 628, loss = 0.38758583\n",
      "Iteration 629, loss = 0.38731540\n",
      "Iteration 630, loss = 0.38710208\n",
      "Iteration 631, loss = 0.38716606\n",
      "Iteration 632, loss = 0.38705820\n",
      "Iteration 633, loss = 0.38699694\n",
      "Iteration 634, loss = 0.38667565\n",
      "Iteration 635, loss = 0.38667610\n",
      "Iteration 636, loss = 0.38654822\n",
      "Iteration 637, loss = 0.38640902\n",
      "Iteration 638, loss = 0.38617036\n",
      "Iteration 639, loss = 0.38620710\n",
      "Iteration 640, loss = 0.38603806\n",
      "Iteration 641, loss = 0.38612246\n",
      "Iteration 642, loss = 0.38567436\n",
      "Iteration 643, loss = 0.38564949\n",
      "Iteration 644, loss = 0.38544528\n",
      "Iteration 645, loss = 0.38549333\n",
      "Iteration 646, loss = 0.38537488\n",
      "Iteration 647, loss = 0.38509269\n",
      "Iteration 648, loss = 0.38527937\n",
      "Iteration 649, loss = 0.38520585\n",
      "Iteration 650, loss = 0.38482246\n",
      "Iteration 651, loss = 0.38486290\n",
      "Iteration 652, loss = 0.38467626\n",
      "Iteration 653, loss = 0.38451994\n",
      "Iteration 654, loss = 0.38441851\n",
      "Iteration 655, loss = 0.38423196\n",
      "Iteration 656, loss = 0.38433675\n",
      "Iteration 657, loss = 0.38413218\n",
      "Iteration 658, loss = 0.38401628\n",
      "Iteration 659, loss = 0.38378357\n",
      "Iteration 660, loss = 0.38370030\n",
      "Iteration 661, loss = 0.38369461\n",
      "Iteration 662, loss = 0.38352256\n",
      "Iteration 663, loss = 0.38339826\n",
      "Iteration 664, loss = 0.38331962\n",
      "Iteration 665, loss = 0.38322869\n",
      "Iteration 666, loss = 0.38300470\n",
      "Iteration 667, loss = 0.38303544\n",
      "Iteration 668, loss = 0.38280904\n",
      "Iteration 669, loss = 0.38274038\n",
      "Iteration 670, loss = 0.38261759\n",
      "Iteration 671, loss = 0.38251740\n",
      "Iteration 672, loss = 0.38245073\n",
      "Iteration 673, loss = 0.38219729\n",
      "Iteration 674, loss = 0.38211089\n",
      "Iteration 675, loss = 0.38219353\n",
      "Iteration 676, loss = 0.38210482\n",
      "Iteration 677, loss = 0.38214969\n",
      "Iteration 678, loss = 0.38197985\n",
      "Iteration 679, loss = 0.38168599\n",
      "Iteration 680, loss = 0.38169572\n",
      "Iteration 681, loss = 0.38166392\n",
      "Iteration 682, loss = 0.38130401\n",
      "Iteration 683, loss = 0.38128784\n",
      "Iteration 684, loss = 0.38121207\n",
      "Iteration 685, loss = 0.38096346\n",
      "Iteration 686, loss = 0.38106171\n",
      "Iteration 687, loss = 0.38086050\n",
      "Iteration 688, loss = 0.38087609\n",
      "Iteration 689, loss = 0.38066101\n",
      "Iteration 690, loss = 0.38047790\n",
      "Iteration 691, loss = 0.38039288\n",
      "Iteration 692, loss = 0.38027575\n",
      "Iteration 693, loss = 0.38026865\n",
      "Iteration 694, loss = 0.38019209\n",
      "Iteration 695, loss = 0.37979020\n",
      "Iteration 696, loss = 0.37986455\n",
      "Iteration 697, loss = 0.37974650\n",
      "Iteration 698, loss = 0.37951375\n",
      "Iteration 699, loss = 0.37933212\n",
      "Iteration 700, loss = 0.37955281\n",
      "Iteration 701, loss = 0.37945667\n",
      "Iteration 702, loss = 0.37933993\n",
      "Iteration 703, loss = 0.37916657\n",
      "Iteration 704, loss = 0.37900993\n",
      "Iteration 705, loss = 0.37895963\n",
      "Iteration 706, loss = 0.37871837\n",
      "Iteration 707, loss = 0.37876105\n",
      "Iteration 708, loss = 0.37864594\n",
      "Iteration 709, loss = 0.37844534\n",
      "Iteration 710, loss = 0.37845524\n",
      "Iteration 711, loss = 0.37834645\n",
      "Iteration 712, loss = 0.37819693\n",
      "Iteration 713, loss = 0.37803070\n",
      "Iteration 714, loss = 0.37791273\n",
      "Iteration 715, loss = 0.37799050\n",
      "Iteration 716, loss = 0.37781289\n",
      "Iteration 717, loss = 0.37774065\n",
      "Iteration 718, loss = 0.37763068\n",
      "Iteration 719, loss = 0.37751292\n",
      "Iteration 720, loss = 0.37728198\n",
      "Iteration 721, loss = 0.37711229\n",
      "Iteration 722, loss = 0.37742217\n",
      "Iteration 723, loss = 0.37699907\n",
      "Iteration 724, loss = 0.37692857\n",
      "Iteration 725, loss = 0.37685597\n",
      "Iteration 726, loss = 0.37668359\n",
      "Iteration 727, loss = 0.37665168\n",
      "Iteration 728, loss = 0.37659600\n",
      "Iteration 729, loss = 0.37649546\n",
      "Iteration 730, loss = 0.37623584\n",
      "Iteration 731, loss = 0.37630755\n",
      "Iteration 732, loss = 0.37627670\n",
      "Iteration 733, loss = 0.37614156\n",
      "Iteration 734, loss = 0.37586442\n",
      "Iteration 735, loss = 0.37592797\n",
      "Iteration 736, loss = 0.37563867\n",
      "Iteration 737, loss = 0.37572094\n",
      "Iteration 738, loss = 0.37557474\n",
      "Iteration 739, loss = 0.37533718\n",
      "Iteration 740, loss = 0.37548220\n",
      "Iteration 741, loss = 0.37523710\n",
      "Iteration 742, loss = 0.37522107\n",
      "Iteration 743, loss = 0.37505026\n",
      "Iteration 744, loss = 0.37486049\n",
      "Iteration 745, loss = 0.37495364\n",
      "Iteration 746, loss = 0.37475218\n",
      "Iteration 747, loss = 0.37462112\n",
      "Iteration 748, loss = 0.37452900\n",
      "Iteration 749, loss = 0.37444169\n",
      "Iteration 750, loss = 0.37450130\n",
      "Iteration 751, loss = 0.37417374\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 752, loss = 0.37405625\n",
      "Iteration 753, loss = 0.37408504\n",
      "Iteration 754, loss = 0.37403410\n",
      "Iteration 755, loss = 0.37392237\n",
      "Iteration 756, loss = 0.37396478\n",
      "Iteration 757, loss = 0.37367225\n",
      "Iteration 758, loss = 0.37356097\n",
      "Iteration 759, loss = 0.37345225\n",
      "Iteration 760, loss = 0.37347284\n",
      "Iteration 761, loss = 0.37326353\n",
      "Iteration 762, loss = 0.37319373\n",
      "Iteration 763, loss = 0.37320158\n",
      "Iteration 764, loss = 0.37290409\n",
      "Iteration 765, loss = 0.37283786\n",
      "Iteration 766, loss = 0.37277427\n",
      "Iteration 767, loss = 0.37263556\n",
      "Iteration 768, loss = 0.37256455\n",
      "Iteration 769, loss = 0.37284859\n",
      "Iteration 770, loss = 0.37247965\n",
      "Iteration 771, loss = 0.37230933\n",
      "Iteration 772, loss = 0.37221162\n",
      "Iteration 773, loss = 0.37212125\n",
      "Iteration 774, loss = 0.37203151\n",
      "Iteration 775, loss = 0.37182771\n",
      "Iteration 776, loss = 0.37186418\n",
      "Iteration 777, loss = 0.37160096\n",
      "Iteration 778, loss = 0.37168491\n",
      "Iteration 779, loss = 0.37155473\n",
      "Iteration 780, loss = 0.37143497\n",
      "Iteration 781, loss = 0.37138241\n",
      "Iteration 782, loss = 0.37151309\n",
      "Iteration 783, loss = 0.37117726\n",
      "Iteration 784, loss = 0.37112906\n",
      "Iteration 785, loss = 0.37092837\n",
      "Iteration 786, loss = 0.37093292\n",
      "Iteration 787, loss = 0.37098342\n",
      "Iteration 788, loss = 0.37058232\n",
      "Iteration 789, loss = 0.37055192\n",
      "Iteration 790, loss = 0.37045183\n",
      "Iteration 791, loss = 0.37046105\n",
      "Iteration 792, loss = 0.37023020\n",
      "Iteration 793, loss = 0.37025324\n",
      "Iteration 794, loss = 0.37015599\n",
      "Iteration 795, loss = 0.37018701\n",
      "Iteration 796, loss = 0.36997149\n",
      "Iteration 797, loss = 0.36991331\n",
      "Iteration 798, loss = 0.36982340\n",
      "Iteration 799, loss = 0.36971813\n",
      "Iteration 800, loss = 0.36960567\n",
      "Iteration 801, loss = 0.36938429\n",
      "Iteration 802, loss = 0.36941676\n",
      "Iteration 803, loss = 0.36924300\n",
      "Iteration 804, loss = 0.36908540\n",
      "Iteration 805, loss = 0.36928657\n",
      "Iteration 806, loss = 0.36899879\n",
      "Iteration 807, loss = 0.36895158\n",
      "Iteration 808, loss = 0.36884086\n",
      "Iteration 809, loss = 0.36874336\n",
      "Iteration 810, loss = 0.36857131\n",
      "Iteration 811, loss = 0.36840021\n",
      "Iteration 812, loss = 0.36836038\n",
      "Iteration 813, loss = 0.36829303\n",
      "Iteration 814, loss = 0.36812472\n",
      "Iteration 815, loss = 0.36812872\n",
      "Iteration 816, loss = 0.36802572\n",
      "Iteration 817, loss = 0.36795075\n",
      "Iteration 818, loss = 0.36791276\n",
      "Iteration 819, loss = 0.36771288\n",
      "Iteration 820, loss = 0.36776391\n",
      "Iteration 821, loss = 0.36771620\n",
      "Iteration 822, loss = 0.36759616\n",
      "Iteration 823, loss = 0.36744230\n",
      "Iteration 824, loss = 0.36735274\n",
      "Iteration 825, loss = 0.36728391\n",
      "Iteration 826, loss = 0.36705310\n",
      "Iteration 827, loss = 0.36732486\n",
      "Iteration 828, loss = 0.36694712\n",
      "Iteration 829, loss = 0.36699540\n",
      "Iteration 830, loss = 0.36696748\n",
      "Iteration 831, loss = 0.36678149\n",
      "Iteration 832, loss = 0.36648671\n",
      "Iteration 833, loss = 0.36647087\n",
      "Iteration 834, loss = 0.36635697\n",
      "Iteration 835, loss = 0.36632539\n",
      "Iteration 836, loss = 0.36632868\n",
      "Iteration 837, loss = 0.36609430\n",
      "Iteration 838, loss = 0.36598369\n",
      "Iteration 839, loss = 0.36591466\n",
      "Iteration 840, loss = 0.36588280\n",
      "Iteration 841, loss = 0.36574889\n",
      "Iteration 842, loss = 0.36564462\n",
      "Iteration 843, loss = 0.36566510\n",
      "Iteration 844, loss = 0.36546009\n",
      "Iteration 845, loss = 0.36532389\n",
      "Iteration 846, loss = 0.36542367\n",
      "Iteration 847, loss = 0.36525047\n",
      "Iteration 848, loss = 0.36536256\n",
      "Iteration 849, loss = 0.36503783\n",
      "Iteration 850, loss = 0.36497830\n",
      "Iteration 851, loss = 0.36483921\n",
      "Iteration 852, loss = 0.36491450\n",
      "Iteration 853, loss = 0.36458496\n",
      "Iteration 854, loss = 0.36469199\n",
      "Iteration 855, loss = 0.36444492\n",
      "Iteration 856, loss = 0.36457681\n",
      "Iteration 857, loss = 0.36438366\n",
      "Iteration 858, loss = 0.36440567\n",
      "Iteration 859, loss = 0.36416744\n",
      "Iteration 860, loss = 0.36425351\n",
      "Iteration 861, loss = 0.36414894\n",
      "Iteration 862, loss = 0.36398787\n",
      "Iteration 863, loss = 0.36382879\n",
      "Iteration 864, loss = 0.36372428\n",
      "Iteration 865, loss = 0.36365436\n",
      "Iteration 866, loss = 0.36345185\n",
      "Iteration 867, loss = 0.36356976\n",
      "Iteration 868, loss = 0.36337037\n",
      "Iteration 869, loss = 0.36325880\n",
      "Iteration 870, loss = 0.36304826\n",
      "Iteration 871, loss = 0.36318099\n",
      "Iteration 872, loss = 0.36291072\n",
      "Iteration 873, loss = 0.36284668\n",
      "Iteration 874, loss = 0.36297742\n",
      "Iteration 875, loss = 0.36293564\n",
      "Iteration 876, loss = 0.36275480\n",
      "Iteration 877, loss = 0.36260818\n",
      "Iteration 878, loss = 0.36281370\n",
      "Iteration 879, loss = 0.36237786\n",
      "Iteration 880, loss = 0.36241360\n",
      "Iteration 881, loss = 0.36223575\n",
      "Iteration 882, loss = 0.36210370\n",
      "Iteration 883, loss = 0.36215331\n",
      "Iteration 884, loss = 0.36211860\n",
      "Iteration 885, loss = 0.36171449\n",
      "Iteration 886, loss = 0.36162291\n",
      "Iteration 887, loss = 0.36185540\n",
      "Iteration 888, loss = 0.36161981\n",
      "Iteration 889, loss = 0.36154327\n",
      "Iteration 890, loss = 0.36147727\n",
      "Iteration 891, loss = 0.36132097\n",
      "Iteration 892, loss = 0.36125944\n",
      "Iteration 893, loss = 0.36128940\n",
      "Iteration 894, loss = 0.36132253\n",
      "Iteration 895, loss = 0.36102735\n",
      "Iteration 896, loss = 0.36109274\n",
      "Iteration 897, loss = 0.36125498\n",
      "Iteration 898, loss = 0.36072301\n",
      "Iteration 899, loss = 0.36070679\n",
      "Iteration 900, loss = 0.36071783\n",
      "Iteration 901, loss = 0.36041767\n",
      "Iteration 902, loss = 0.36030499\n",
      "Iteration 903, loss = 0.36037099\n",
      "Iteration 904, loss = 0.36044765\n",
      "Iteration 905, loss = 0.36016672\n",
      "Iteration 906, loss = 0.36016420\n",
      "Iteration 907, loss = 0.36006578\n",
      "Iteration 908, loss = 0.36000537\n",
      "Iteration 909, loss = 0.35986708\n",
      "Iteration 910, loss = 0.35981257\n",
      "Iteration 911, loss = 0.35974239\n",
      "Iteration 912, loss = 0.35971860\n",
      "Iteration 913, loss = 0.35951537\n",
      "Iteration 914, loss = 0.35953014\n",
      "Iteration 915, loss = 0.35940539\n",
      "Iteration 916, loss = 0.35936138\n",
      "Iteration 917, loss = 0.35923283\n",
      "Iteration 918, loss = 0.35932348\n",
      "Iteration 919, loss = 0.35900438\n",
      "Iteration 920, loss = 0.35898612\n",
      "Iteration 921, loss = 0.35897741\n",
      "Iteration 922, loss = 0.35879320\n",
      "Iteration 923, loss = 0.35862637\n",
      "Iteration 924, loss = 0.35871568\n",
      "Iteration 925, loss = 0.35855082\n",
      "Iteration 926, loss = 0.35841392\n",
      "Iteration 927, loss = 0.35841905\n",
      "Iteration 928, loss = 0.35814380\n",
      "Iteration 929, loss = 0.35819120\n",
      "Iteration 930, loss = 0.35792426\n",
      "Iteration 931, loss = 0.35802107\n",
      "Iteration 932, loss = 0.35786488\n",
      "Iteration 933, loss = 0.35779439\n",
      "Iteration 934, loss = 0.35761898\n",
      "Iteration 935, loss = 0.35768895\n",
      "Iteration 936, loss = 0.35765799\n",
      "Iteration 937, loss = 0.35754362\n",
      "Iteration 938, loss = 0.35724370\n",
      "Iteration 939, loss = 0.35721717\n",
      "Iteration 940, loss = 0.35719154\n",
      "Iteration 941, loss = 0.35717513\n",
      "Iteration 942, loss = 0.35721261\n",
      "Iteration 943, loss = 0.35685681\n",
      "Iteration 944, loss = 0.35704485\n",
      "Iteration 945, loss = 0.35682147\n",
      "Iteration 946, loss = 0.35660087\n",
      "Iteration 947, loss = 0.35694220\n",
      "Iteration 948, loss = 0.35650945\n",
      "Iteration 949, loss = 0.35648503\n",
      "Iteration 950, loss = 0.35638425\n",
      "Iteration 951, loss = 0.35631548\n",
      "Iteration 952, loss = 0.35613277\n",
      "Iteration 953, loss = 0.35610690\n",
      "Iteration 954, loss = 0.35604559\n",
      "Iteration 955, loss = 0.35605693\n",
      "Iteration 956, loss = 0.35593749\n",
      "Iteration 957, loss = 0.35588209\n",
      "Iteration 958, loss = 0.35574384\n",
      "Iteration 959, loss = 0.35580856\n",
      "Iteration 960, loss = 0.35562322\n",
      "Iteration 961, loss = 0.35569639\n",
      "Iteration 962, loss = 0.35545591\n",
      "Iteration 963, loss = 0.35541419\n",
      "Iteration 964, loss = 0.35533381\n",
      "Iteration 965, loss = 0.35527878\n",
      "Iteration 966, loss = 0.35521530\n",
      "Iteration 967, loss = 0.35497622\n",
      "Iteration 968, loss = 0.35508254\n",
      "Iteration 969, loss = 0.35514786\n",
      "Iteration 970, loss = 0.35471124\n",
      "Iteration 971, loss = 0.35477218\n",
      "Iteration 972, loss = 0.35469595\n",
      "Iteration 973, loss = 0.35445134\n",
      "Iteration 974, loss = 0.35453342\n",
      "Iteration 975, loss = 0.35433220\n",
      "Iteration 976, loss = 0.35426967\n",
      "Iteration 977, loss = 0.35428455\n",
      "Iteration 978, loss = 0.35424327\n",
      "Iteration 979, loss = 0.35419979\n",
      "Iteration 980, loss = 0.35395339\n",
      "Iteration 981, loss = 0.35400787\n",
      "Iteration 982, loss = 0.35402121\n",
      "Iteration 983, loss = 0.35362716\n",
      "Iteration 984, loss = 0.35376026\n",
      "Iteration 985, loss = 0.35363818\n",
      "Iteration 986, loss = 0.35346520\n",
      "Iteration 987, loss = 0.35349577\n",
      "Iteration 988, loss = 0.35342739\n",
      "Iteration 989, loss = 0.35339396\n",
      "Iteration 990, loss = 0.35327204\n",
      "Iteration 991, loss = 0.35316975\n",
      "Iteration 992, loss = 0.35293169\n",
      "Iteration 993, loss = 0.35282460\n",
      "Iteration 994, loss = 0.35280769\n",
      "Iteration 995, loss = 0.35273782\n",
      "Iteration 996, loss = 0.35272171\n",
      "Iteration 997, loss = 0.35268086\n",
      "Iteration 998, loss = 0.35266630\n",
      "Iteration 999, loss = 0.35245217\n",
      "Iteration 1000, loss = 0.35239547\n",
      "Iteration 1001, loss = 0.35225890\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 1002, loss = 0.35223363\n",
      "Iteration 1003, loss = 0.35228272\n",
      "Iteration 1004, loss = 0.35224584\n",
      "Iteration 1005, loss = 0.35216736\n",
      "Iteration 1006, loss = 0.35193383\n",
      "Iteration 1007, loss = 0.35179713\n",
      "Iteration 1008, loss = 0.35186178\n",
      "Iteration 1009, loss = 0.35159759\n",
      "Iteration 1010, loss = 0.35161042\n",
      "Iteration 1011, loss = 0.35155232\n",
      "Iteration 1012, loss = 0.35137709\n",
      "Iteration 1013, loss = 0.35141067\n",
      "Iteration 1014, loss = 0.35132983\n",
      "Iteration 1015, loss = 0.35132615\n",
      "Iteration 1016, loss = 0.35115040\n",
      "Iteration 1017, loss = 0.35118262\n",
      "Iteration 1018, loss = 0.35102339\n",
      "Iteration 1019, loss = 0.35097472\n",
      "Iteration 1020, loss = 0.35098329\n",
      "Iteration 1021, loss = 0.35088975\n",
      "Iteration 1022, loss = 0.35068216\n",
      "Iteration 1023, loss = 0.35082507\n",
      "Iteration 1024, loss = 0.35044379\n",
      "Iteration 1025, loss = 0.35102201\n",
      "Iteration 1026, loss = 0.35029332\n",
      "Iteration 1027, loss = 0.35036155\n",
      "Iteration 1028, loss = 0.35022057\n",
      "Iteration 1029, loss = 0.35018274\n",
      "Iteration 1030, loss = 0.35018212\n",
      "Iteration 1031, loss = 0.35005720\n",
      "Iteration 1032, loss = 0.34984813\n",
      "Iteration 1033, loss = 0.34993723\n",
      "Iteration 1034, loss = 0.34979743\n",
      "Iteration 1035, loss = 0.34951131\n",
      "Iteration 1036, loss = 0.34977655\n",
      "Iteration 1037, loss = 0.34946580\n",
      "Iteration 1038, loss = 0.34957553\n",
      "Iteration 1039, loss = 0.34929799\n",
      "Iteration 1040, loss = 0.34933106\n",
      "Iteration 1041, loss = 0.34923019\n",
      "Iteration 1042, loss = 0.34911820\n",
      "Iteration 1043, loss = 0.34906383\n",
      "Iteration 1044, loss = 0.34912324\n",
      "Iteration 1045, loss = 0.34888427\n",
      "Iteration 1046, loss = 0.34880852\n",
      "Iteration 1047, loss = 0.34894173\n",
      "Iteration 1048, loss = 0.34887012\n",
      "Iteration 1049, loss = 0.34869573\n",
      "Iteration 1050, loss = 0.34861483\n",
      "Iteration 1051, loss = 0.34852097\n",
      "Iteration 1052, loss = 0.34823062\n",
      "Iteration 1053, loss = 0.34836934\n",
      "Iteration 1054, loss = 0.34821595\n",
      "Iteration 1055, loss = 0.34829954\n",
      "Iteration 1056, loss = 0.34804373\n",
      "Iteration 1057, loss = 0.34800272\n",
      "Iteration 1058, loss = 0.34788139\n",
      "Iteration 1059, loss = 0.34794702\n",
      "Iteration 1060, loss = 0.34773809\n",
      "Iteration 1061, loss = 0.34761687\n",
      "Iteration 1062, loss = 0.34779870\n",
      "Iteration 1063, loss = 0.34760859\n",
      "Iteration 1064, loss = 0.34753188\n",
      "Iteration 1065, loss = 0.34746209\n",
      "Iteration 1066, loss = 0.34738248\n",
      "Iteration 1067, loss = 0.34714341\n",
      "Iteration 1068, loss = 0.34718839\n",
      "Iteration 1069, loss = 0.34705193\n",
      "Iteration 1070, loss = 0.34711723\n",
      "Iteration 1071, loss = 0.34698071\n",
      "Iteration 1072, loss = 0.34733373\n",
      "Iteration 1073, loss = 0.34681423\n",
      "Iteration 1074, loss = 0.34673068\n",
      "Iteration 1075, loss = 0.34655143\n",
      "Iteration 1076, loss = 0.34665510\n",
      "Iteration 1077, loss = 0.34662213\n",
      "Iteration 1078, loss = 0.34657293\n",
      "Iteration 1079, loss = 0.34650210\n",
      "Iteration 1080, loss = 0.34637106\n",
      "Iteration 1081, loss = 0.34635370\n",
      "Iteration 1082, loss = 0.34620884\n",
      "Iteration 1083, loss = 0.34601065\n",
      "Iteration 1084, loss = 0.34600029\n",
      "Iteration 1085, loss = 0.34574380\n",
      "Iteration 1086, loss = 0.34593485\n",
      "Iteration 1087, loss = 0.34559418\n",
      "Iteration 1088, loss = 0.34599132\n",
      "Iteration 1089, loss = 0.34553994\n",
      "Iteration 1090, loss = 0.34560114\n",
      "Iteration 1091, loss = 0.34556190\n",
      "Iteration 1092, loss = 0.34544859\n",
      "Iteration 1093, loss = 0.34547425\n",
      "Iteration 1094, loss = 0.34532220\n",
      "Iteration 1095, loss = 0.34513734\n",
      "Iteration 1096, loss = 0.34561054\n",
      "Iteration 1097, loss = 0.34512616\n",
      "Iteration 1098, loss = 0.34499962\n",
      "Iteration 1099, loss = 0.34487057\n",
      "Iteration 1100, loss = 0.34499896\n",
      "Iteration 1101, loss = 0.34461250\n",
      "Iteration 1102, loss = 0.34466442\n",
      "Iteration 1103, loss = 0.34467062\n",
      "Iteration 1104, loss = 0.34458324\n",
      "Iteration 1105, loss = 0.34449611\n",
      "Iteration 1106, loss = 0.34436221\n",
      "Iteration 1107, loss = 0.34426902\n",
      "Iteration 1108, loss = 0.34424788\n",
      "Iteration 1109, loss = 0.34422304\n",
      "Iteration 1110, loss = 0.34415879\n",
      "Iteration 1111, loss = 0.34408466\n",
      "Iteration 1112, loss = 0.34395916\n",
      "Iteration 1113, loss = 0.34388210\n",
      "Iteration 1114, loss = 0.34388450\n",
      "Iteration 1115, loss = 0.34372061\n",
      "Iteration 1116, loss = 0.34372454\n",
      "Iteration 1117, loss = 0.34362359\n",
      "Iteration 1118, loss = 0.34356520\n",
      "Iteration 1119, loss = 0.34362944\n",
      "Iteration 1120, loss = 0.34358259\n",
      "Iteration 1121, loss = 0.34345306\n",
      "Iteration 1122, loss = 0.34320067\n",
      "Iteration 1123, loss = 0.34312496\n",
      "Iteration 1124, loss = 0.34319494\n",
      "Iteration 1125, loss = 0.34318271\n",
      "Iteration 1126, loss = 0.34289341\n",
      "Iteration 1127, loss = 0.34313981\n",
      "Iteration 1128, loss = 0.34275417\n",
      "Iteration 1129, loss = 0.34272726\n",
      "Iteration 1130, loss = 0.34265733\n",
      "Iteration 1131, loss = 0.34291302\n",
      "Iteration 1132, loss = 0.34250036\n",
      "Iteration 1133, loss = 0.34237519\n",
      "Iteration 1134, loss = 0.34235225\n",
      "Iteration 1135, loss = 0.34230127\n",
      "Iteration 1136, loss = 0.34236089\n",
      "Iteration 1137, loss = 0.34220156\n",
      "Iteration 1138, loss = 0.34208833\n",
      "Iteration 1139, loss = 0.34191723\n",
      "Iteration 1140, loss = 0.34197913\n",
      "Iteration 1141, loss = 0.34183195\n",
      "Iteration 1142, loss = 0.34198300\n",
      "Iteration 1143, loss = 0.34161112\n",
      "Iteration 1144, loss = 0.34182578\n",
      "Iteration 1145, loss = 0.34166665\n",
      "Iteration 1146, loss = 0.34164807\n",
      "Iteration 1147, loss = 0.34164537\n",
      "Iteration 1148, loss = 0.34142833\n",
      "Iteration 1149, loss = 0.34150419\n",
      "Iteration 1150, loss = 0.34148250\n",
      "Iteration 1151, loss = 0.34110232\n",
      "Iteration 1152, loss = 0.34104966\n",
      "Iteration 1153, loss = 0.34117631\n",
      "Iteration 1154, loss = 0.34097027\n",
      "Iteration 1155, loss = 0.34106887\n",
      "Iteration 1156, loss = 0.34085118\n",
      "Iteration 1157, loss = 0.34072402\n",
      "Iteration 1158, loss = 0.34068280\n",
      "Iteration 1159, loss = 0.34066906\n",
      "Iteration 1160, loss = 0.34068326\n",
      "Iteration 1161, loss = 0.34055823\n",
      "Iteration 1162, loss = 0.34038648\n",
      "Iteration 1163, loss = 0.34036177\n",
      "Iteration 1164, loss = 0.34005840\n",
      "Iteration 1165, loss = 0.34015336\n",
      "Iteration 1166, loss = 0.34004115\n",
      "Iteration 1167, loss = 0.34012133\n",
      "Iteration 1168, loss = 0.33994944\n",
      "Iteration 1169, loss = 0.33994768\n",
      "Iteration 1170, loss = 0.33997654\n",
      "Iteration 1171, loss = 0.33989826\n",
      "Iteration 1172, loss = 0.33983512\n",
      "Iteration 1173, loss = 0.33959145\n",
      "Iteration 1174, loss = 0.33980183\n",
      "Iteration 1175, loss = 0.33962417\n",
      "Iteration 1176, loss = 0.33947608\n",
      "Iteration 1177, loss = 0.33954306\n",
      "Iteration 1178, loss = 0.33927757\n",
      "Iteration 1179, loss = 0.33924578\n",
      "Iteration 1180, loss = 0.33931109\n",
      "Iteration 1181, loss = 0.33904901\n",
      "Iteration 1182, loss = 0.33897639\n",
      "Iteration 1183, loss = 0.33903397\n",
      "Iteration 1184, loss = 0.33889225\n",
      "Iteration 1185, loss = 0.33883988\n",
      "Iteration 1186, loss = 0.33882733\n",
      "Iteration 1187, loss = 0.33854771\n",
      "Iteration 1188, loss = 0.33855573\n",
      "Iteration 1189, loss = 0.33859006\n",
      "Iteration 1190, loss = 0.33872533\n",
      "Iteration 1191, loss = 0.33854612\n",
      "Iteration 1192, loss = 0.33824920\n",
      "Iteration 1193, loss = 0.33823762\n",
      "Iteration 1194, loss = 0.33820488\n",
      "Iteration 1195, loss = 0.33805815\n",
      "Iteration 1196, loss = 0.33828652\n",
      "Iteration 1197, loss = 0.33798535\n",
      "Iteration 1198, loss = 0.33790526\n",
      "Iteration 1199, loss = 0.33792846\n",
      "Iteration 1200, loss = 0.33779562\n",
      "Iteration 1201, loss = 0.33782050\n",
      "Iteration 1202, loss = 0.33759459\n",
      "Iteration 1203, loss = 0.33767707\n",
      "Iteration 1204, loss = 0.33754967\n",
      "Iteration 1205, loss = 0.33747620\n",
      "Iteration 1206, loss = 0.33755300\n",
      "Iteration 1207, loss = 0.33726346\n",
      "Iteration 1208, loss = 0.33730980\n",
      "Iteration 1209, loss = 0.33719084\n",
      "Iteration 1210, loss = 0.33714419\n",
      "Iteration 1211, loss = 0.33705427\n",
      "Iteration 1212, loss = 0.33718815\n",
      "Iteration 1213, loss = 0.33679778\n",
      "Iteration 1214, loss = 0.33687632\n",
      "Iteration 1215, loss = 0.33674630\n",
      "Iteration 1216, loss = 0.33684419\n",
      "Iteration 1217, loss = 0.33647548\n",
      "Iteration 1218, loss = 0.33649164\n",
      "Iteration 1219, loss = 0.33644965\n",
      "Iteration 1220, loss = 0.33636236\n",
      "Iteration 1221, loss = 0.33656917\n",
      "Iteration 1222, loss = 0.33625502\n",
      "Iteration 1223, loss = 0.33623952\n",
      "Iteration 1224, loss = 0.33609452\n",
      "Iteration 1225, loss = 0.33604974\n",
      "Iteration 1226, loss = 0.33599856\n",
      "Iteration 1227, loss = 0.33594655\n",
      "Iteration 1228, loss = 0.33585090\n",
      "Iteration 1229, loss = 0.33574703\n",
      "Iteration 1230, loss = 0.33581312\n",
      "Iteration 1231, loss = 0.33570300\n",
      "Iteration 1232, loss = 0.33563585\n",
      "Iteration 1233, loss = 0.33565132\n",
      "Iteration 1234, loss = 0.33571796\n",
      "Iteration 1235, loss = 0.33569048\n",
      "Iteration 1236, loss = 0.33536835\n",
      "Iteration 1237, loss = 0.33544826\n",
      "Iteration 1238, loss = 0.33514989\n",
      "Iteration 1239, loss = 0.33520939\n",
      "Iteration 1240, loss = 0.33511824\n",
      "Iteration 1241, loss = 0.33490794\n",
      "Iteration 1242, loss = 0.33510866\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 1243, loss = 0.33523810\n",
      "Iteration 1244, loss = 0.33497032\n",
      "Iteration 1245, loss = 0.33474881\n",
      "Iteration 1246, loss = 0.33470118\n",
      "Iteration 1247, loss = 0.33448452\n",
      "Iteration 1248, loss = 0.33442833\n",
      "Iteration 1249, loss = 0.33460654\n",
      "Iteration 1250, loss = 0.33450204\n",
      "Iteration 1251, loss = 0.33430783\n",
      "Iteration 1252, loss = 0.33425671\n",
      "Iteration 1253, loss = 0.33428485\n",
      "Iteration 1254, loss = 0.33439078\n",
      "Iteration 1255, loss = 0.33412973\n",
      "Iteration 1256, loss = 0.33427243\n",
      "Iteration 1257, loss = 0.33383953\n",
      "Iteration 1258, loss = 0.33406965\n",
      "Iteration 1259, loss = 0.33391466\n",
      "Iteration 1260, loss = 0.33389152\n",
      "Iteration 1261, loss = 0.33374779\n",
      "Iteration 1262, loss = 0.33368954\n",
      "Iteration 1263, loss = 0.33364859\n",
      "Iteration 1264, loss = 0.33350678\n",
      "Iteration 1265, loss = 0.33339365\n",
      "Iteration 1266, loss = 0.33354299\n",
      "Iteration 1267, loss = 0.33340207\n",
      "Iteration 1268, loss = 0.33326959\n",
      "Iteration 1269, loss = 0.33312891\n",
      "Iteration 1270, loss = 0.33319248\n",
      "Iteration 1271, loss = 0.33316579\n",
      "Iteration 1272, loss = 0.33291063\n",
      "Iteration 1273, loss = 0.33311712\n",
      "Iteration 1274, loss = 0.33285571\n",
      "Iteration 1275, loss = 0.33278753\n",
      "Iteration 1276, loss = 0.33271335\n",
      "Iteration 1277, loss = 0.33280771\n",
      "Iteration 1278, loss = 0.33251285\n",
      "Iteration 1279, loss = 0.33253937\n",
      "Iteration 1280, loss = 0.33255307\n",
      "Iteration 1281, loss = 0.33251158\n",
      "Iteration 1282, loss = 0.33238833\n",
      "Iteration 1283, loss = 0.33248160\n",
      "Iteration 1284, loss = 0.33219690\n",
      "Iteration 1285, loss = 0.33230632\n",
      "Iteration 1286, loss = 0.33218128\n",
      "Iteration 1287, loss = 0.33199713\n",
      "Iteration 1288, loss = 0.33191633\n",
      "Iteration 1289, loss = 0.33187652\n",
      "Iteration 1290, loss = 0.33179428\n",
      "Iteration 1291, loss = 0.33170563\n",
      "Iteration 1292, loss = 0.33170770\n",
      "Iteration 1293, loss = 0.33172537\n",
      "Iteration 1294, loss = 0.33174348\n",
      "Iteration 1295, loss = 0.33159864\n",
      "Iteration 1296, loss = 0.33147536\n",
      "Iteration 1297, loss = 0.33141307\n",
      "Iteration 1298, loss = 0.33135758\n",
      "Iteration 1299, loss = 0.33122306\n",
      "Iteration 1300, loss = 0.33105522\n",
      "Iteration 1301, loss = 0.33127119\n",
      "Iteration 1302, loss = 0.33102938\n",
      "Iteration 1303, loss = 0.33098657\n",
      "Iteration 1304, loss = 0.33098561\n",
      "Iteration 1305, loss = 0.33097938\n",
      "Iteration 1306, loss = 0.33087572\n",
      "Iteration 1307, loss = 0.33078714\n",
      "Iteration 1308, loss = 0.33074874\n",
      "Iteration 1309, loss = 0.33048521\n",
      "Iteration 1310, loss = 0.33057143\n",
      "Iteration 1311, loss = 0.33034704\n",
      "Iteration 1312, loss = 0.33044092\n",
      "Iteration 1313, loss = 0.33035233\n",
      "Iteration 1314, loss = 0.33029771\n",
      "Iteration 1315, loss = 0.33028230\n",
      "Iteration 1316, loss = 0.33022796\n",
      "Iteration 1317, loss = 0.33004337\n",
      "Iteration 1318, loss = 0.33004665\n",
      "Iteration 1319, loss = 0.33001195\n",
      "Iteration 1320, loss = 0.32995804\n",
      "Iteration 1321, loss = 0.32987056\n",
      "Iteration 1322, loss = 0.32977938\n",
      "Iteration 1323, loss = 0.32968371\n",
      "Iteration 1324, loss = 0.32965855\n",
      "Iteration 1325, loss = 0.32950667\n",
      "Iteration 1326, loss = 0.32955907\n",
      "Iteration 1327, loss = 0.32935054\n",
      "Iteration 1328, loss = 0.32949444\n",
      "Iteration 1329, loss = 0.32919792\n",
      "Iteration 1330, loss = 0.32912859\n",
      "Iteration 1331, loss = 0.32928936\n",
      "Iteration 1332, loss = 0.32919170\n",
      "Iteration 1333, loss = 0.32937357\n",
      "Iteration 1334, loss = 0.32899139\n",
      "Iteration 1335, loss = 0.32890973\n",
      "Iteration 1336, loss = 0.32886487\n",
      "Iteration 1337, loss = 0.32874983\n",
      "Iteration 1338, loss = 0.32876980\n",
      "Iteration 1339, loss = 0.32867652\n",
      "Iteration 1340, loss = 0.32872295\n",
      "Iteration 1341, loss = 0.32855988\n",
      "Iteration 1342, loss = 0.32867202\n",
      "Iteration 1343, loss = 0.32851839\n",
      "Iteration 1344, loss = 0.32838061\n",
      "Iteration 1345, loss = 0.32827332\n",
      "Iteration 1346, loss = 0.32839837\n",
      "Iteration 1347, loss = 0.32814437\n",
      "Iteration 1348, loss = 0.32820153\n",
      "Iteration 1349, loss = 0.32796877\n",
      "Iteration 1350, loss = 0.32810030\n",
      "Iteration 1351, loss = 0.32794337\n",
      "Iteration 1352, loss = 0.32782053\n",
      "Iteration 1353, loss = 0.32788934\n",
      "Iteration 1354, loss = 0.32800149\n",
      "Iteration 1355, loss = 0.32761478\n",
      "Iteration 1356, loss = 0.32766078\n",
      "Iteration 1357, loss = 0.32756618\n",
      "Iteration 1358, loss = 0.32758459\n",
      "Iteration 1359, loss = 0.32741475\n",
      "Iteration 1360, loss = 0.32740003\n",
      "Iteration 1361, loss = 0.32741319\n",
      "Iteration 1362, loss = 0.32727595\n",
      "Iteration 1363, loss = 0.32733474\n",
      "Iteration 1364, loss = 0.32723333\n",
      "Iteration 1365, loss = 0.32724796\n",
      "Iteration 1366, loss = 0.32704189\n",
      "Iteration 1367, loss = 0.32703924\n",
      "Iteration 1368, loss = 0.32706765\n",
      "Iteration 1369, loss = 0.32662097\n",
      "Iteration 1370, loss = 0.32681964\n",
      "Iteration 1371, loss = 0.32673391\n",
      "Iteration 1372, loss = 0.32669122\n",
      "Iteration 1373, loss = 0.32640474\n",
      "Iteration 1374, loss = 0.32654706\n",
      "Iteration 1375, loss = 0.32646884\n",
      "Iteration 1376, loss = 0.32644081\n",
      "Iteration 1377, loss = 0.32632732\n",
      "Iteration 1378, loss = 0.32640895\n",
      "Iteration 1379, loss = 0.32626383\n",
      "Iteration 1380, loss = 0.32612502\n",
      "Iteration 1381, loss = 0.32625250\n",
      "Iteration 1382, loss = 0.32599719\n",
      "Iteration 1383, loss = 0.32601144\n",
      "Iteration 1384, loss = 0.32585863\n",
      "Iteration 1385, loss = 0.32599675\n",
      "Iteration 1386, loss = 0.32572486\n",
      "Iteration 1387, loss = 0.32570299\n",
      "Iteration 1388, loss = 0.32582300\n",
      "Iteration 1389, loss = 0.32564159\n",
      "Iteration 1390, loss = 0.32568588\n",
      "Iteration 1391, loss = 0.32557913\n",
      "Iteration 1392, loss = 0.32548286\n",
      "Iteration 1393, loss = 0.32536102\n",
      "Iteration 1394, loss = 0.32512856\n",
      "Iteration 1395, loss = 0.32509269\n",
      "Iteration 1396, loss = 0.32511112\n",
      "Iteration 1397, loss = 0.32503568\n",
      "Iteration 1398, loss = 0.32497187\n",
      "Iteration 1399, loss = 0.32512240\n",
      "Iteration 1400, loss = 0.32488752\n",
      "Iteration 1401, loss = 0.32478689\n",
      "Iteration 1402, loss = 0.32472679\n",
      "Iteration 1403, loss = 0.32476556\n",
      "Iteration 1404, loss = 0.32464490\n",
      "Iteration 1405, loss = 0.32481306\n",
      "Iteration 1406, loss = 0.32460550\n",
      "Iteration 1407, loss = 0.32438916\n",
      "Iteration 1408, loss = 0.32448696\n",
      "Iteration 1409, loss = 0.32447648\n",
      "Iteration 1410, loss = 0.32436411\n",
      "Iteration 1411, loss = 0.32427736\n",
      "Iteration 1412, loss = 0.32411577\n",
      "Iteration 1413, loss = 0.32424595\n",
      "Iteration 1414, loss = 0.32418814\n",
      "Iteration 1415, loss = 0.32417156\n",
      "Iteration 1416, loss = 0.32396024\n",
      "Iteration 1417, loss = 0.32400315\n",
      "Iteration 1418, loss = 0.32387523\n",
      "Iteration 1419, loss = 0.32359631\n",
      "Iteration 1420, loss = 0.32369115\n",
      "Iteration 1421, loss = 0.32356561\n",
      "Iteration 1422, loss = 0.32359561\n",
      "Iteration 1423, loss = 0.32344801\n",
      "Iteration 1424, loss = 0.32350565\n",
      "Iteration 1425, loss = 0.32334622\n",
      "Iteration 1426, loss = 0.32331187\n",
      "Iteration 1427, loss = 0.32333081\n",
      "Iteration 1428, loss = 0.32305690\n",
      "Iteration 1429, loss = 0.32308021\n",
      "Iteration 1430, loss = 0.32305672\n",
      "Iteration 1431, loss = 0.32316296\n",
      "Iteration 1432, loss = 0.32308439\n",
      "Iteration 1433, loss = 0.32287555\n",
      "Iteration 1434, loss = 0.32282510\n",
      "Iteration 1435, loss = 0.32283809\n",
      "Iteration 1436, loss = 0.32267690\n",
      "Iteration 1437, loss = 0.32267044\n",
      "Iteration 1438, loss = 0.32250889\n",
      "Iteration 1439, loss = 0.32258204\n",
      "Iteration 1440, loss = 0.32245773\n",
      "Iteration 1441, loss = 0.32235658\n",
      "Iteration 1442, loss = 0.32239720\n",
      "Iteration 1443, loss = 0.32241065\n",
      "Iteration 1444, loss = 0.32217000\n",
      "Iteration 1445, loss = 0.32221182\n",
      "Iteration 1446, loss = 0.32219545\n",
      "Iteration 1447, loss = 0.32212065\n",
      "Iteration 1448, loss = 0.32198474\n",
      "Iteration 1449, loss = 0.32184307\n",
      "Iteration 1450, loss = 0.32184504\n",
      "Iteration 1451, loss = 0.32181201\n",
      "Iteration 1452, loss = 0.32173974\n",
      "Iteration 1453, loss = 0.32179891\n",
      "Iteration 1454, loss = 0.32155025\n",
      "Iteration 1455, loss = 0.32162915\n",
      "Iteration 1456, loss = 0.32162786\n",
      "Iteration 1457, loss = 0.32145624\n",
      "Iteration 1458, loss = 0.32140966\n",
      "Iteration 1459, loss = 0.32159873\n",
      "Iteration 1460, loss = 0.32128830\n",
      "Iteration 1461, loss = 0.32127603\n",
      "Iteration 1462, loss = 0.32165104\n",
      "Iteration 1463, loss = 0.32114928\n",
      "Iteration 1464, loss = 0.32099126\n",
      "Iteration 1465, loss = 0.32092175\n",
      "Iteration 1466, loss = 0.32095922\n",
      "Iteration 1467, loss = 0.32080968\n",
      "Iteration 1468, loss = 0.32072880\n",
      "Iteration 1469, loss = 0.32065978\n",
      "Iteration 1470, loss = 0.32073716\n",
      "Iteration 1471, loss = 0.32065058\n",
      "Iteration 1472, loss = 0.32069122\n",
      "Iteration 1473, loss = 0.32052692\n",
      "Iteration 1474, loss = 0.32053064\n",
      "Iteration 1475, loss = 0.32064030\n",
      "Iteration 1476, loss = 0.32042055\n",
      "Iteration 1477, loss = 0.32043025\n",
      "Iteration 1478, loss = 0.32010858\n",
      "Iteration 1479, loss = 0.32005843\n",
      "Iteration 1480, loss = 0.32000202\n",
      "Iteration 1481, loss = 0.31990177\n",
      "Iteration 1482, loss = 0.31981466\n",
      "Iteration 1483, loss = 0.31984437\n",
      "Iteration 1484, loss = 0.31975171\n",
      "Iteration 1485, loss = 0.31969639\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 1486, loss = 0.31969874\n",
      "Iteration 1487, loss = 0.31962702\n",
      "Iteration 1488, loss = 0.31948970\n",
      "Iteration 1489, loss = 0.31949249\n",
      "Iteration 1490, loss = 0.31950030\n",
      "Iteration 1491, loss = 0.31945529\n",
      "Iteration 1492, loss = 0.31941950\n",
      "Iteration 1493, loss = 0.31913089\n",
      "Iteration 1494, loss = 0.31939291\n",
      "Iteration 1495, loss = 0.31926141\n",
      "Iteration 1496, loss = 0.31915005\n",
      "Iteration 1497, loss = 0.31908184\n",
      "Iteration 1498, loss = 0.31896780\n",
      "Iteration 1499, loss = 0.31902443\n",
      "Iteration 1500, loss = 0.31888951\n",
      "Iteration 1501, loss = 0.31874622\n",
      "Iteration 1502, loss = 0.31880963\n",
      "Iteration 1503, loss = 0.31893722\n",
      "Iteration 1504, loss = 0.31859320\n",
      "Iteration 1505, loss = 0.31853475\n",
      "Iteration 1506, loss = 0.31856197\n",
      "Iteration 1507, loss = 0.31845369\n",
      "Iteration 1508, loss = 0.31839829\n",
      "Iteration 1509, loss = 0.31843375\n",
      "Iteration 1510, loss = 0.31830932\n",
      "Iteration 1511, loss = 0.31829777\n",
      "Iteration 1512, loss = 0.31821563\n",
      "Iteration 1513, loss = 0.31824681\n",
      "Iteration 1514, loss = 0.31806731\n",
      "Iteration 1515, loss = 0.31786614\n",
      "Iteration 1516, loss = 0.31804620\n",
      "Iteration 1517, loss = 0.31808983\n",
      "Iteration 1518, loss = 0.31796175\n",
      "Iteration 1519, loss = 0.31783381\n",
      "Iteration 1520, loss = 0.31762453\n",
      "Iteration 1521, loss = 0.31767774\n",
      "Iteration 1522, loss = 0.31752863\n",
      "Iteration 1523, loss = 0.31766393\n",
      "Iteration 1524, loss = 0.31752941\n",
      "Iteration 1525, loss = 0.31767640\n",
      "Iteration 1526, loss = 0.31749515\n",
      "Iteration 1527, loss = 0.31726834\n",
      "Iteration 1528, loss = 0.31745370\n",
      "Iteration 1529, loss = 0.31723333\n",
      "Iteration 1530, loss = 0.31709962\n",
      "Iteration 1531, loss = 0.31707949\n",
      "Iteration 1532, loss = 0.31703606\n",
      "Iteration 1533, loss = 0.31694206\n",
      "Iteration 1534, loss = 0.31691367\n",
      "Iteration 1535, loss = 0.31683696\n",
      "Iteration 1536, loss = 0.31677734\n",
      "Iteration 1537, loss = 0.31683722\n",
      "Iteration 1538, loss = 0.31674113\n",
      "Iteration 1539, loss = 0.31668985\n",
      "Iteration 1540, loss = 0.31660514\n",
      "Iteration 1541, loss = 0.31677750\n",
      "Training loss did not improve more than tol=0.000100 for 10 consecutive epochs. Stopping.\n",
      "\n",
      "RESULTS FOR BEST NN\n",
      "\n",
      "NN training error: 0.107300\n",
      "NN test error: 0.137275\n"
     ]
    }
   ],
   "source": [
    "mlp_large = MLPClassifier(hidden_layer_sizes=best_hidden_layer_sizes,max_iter=1600, alpha=1e-4, solver='sgd', tol=1e-4, learning_rate_init=best_p, random_state=ID,batch_size=best_batch_size,verbose=True)# ADD YOUR CODE HERE\n",
    "mlp_fit = mlp_large.fit(X_train, y_train)\n",
    "\n",
    "print ('\\nRESULTS FOR BEST NN\\n')\n",
    "\n",
    "training_error = 1 - mlp_fit.score(X_train,y_train)# ADD YOUR CODE HERE\n",
    "test_error =1 - mlp_fit.score(X_test,y_test) # ADD YOUR CODE HERE\n",
    "\n",
    "print (\"NN training error: %f\" % training_error)\n",
    "print (\"NN test error: %f\" % test_error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question B.Q1** Compare the train and test error you got with a large number of samples with the best one you obtained with only 500 data points. Comment about the results you obtained."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "**ANSWER B.Q1**:<br>\n",
    "    \n",
    "    RESULTS FOR BEST NN for m_training =20_000\n",
    "\n",
    "    NN training error: 0.107300\n",
    "    NN test error: 0.137275\n",
    "    \n",
    "    RESULTS FOR BEST NN for m_training = 500\n",
    "\n",
    "    Best NN training error: 0.056000\n",
    "    Best NN test error: 0.211630.\n",
    "    We see that in our case the trainig erroe for 500 data points is less than that for 20_000 data\n",
    "    points.However,we see that the the training of more data points helps in reduced test error on the test\n",
    "    samples\n",
    "    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TO DO B.2** Plot an example that was missclassified by NN with m=500 training data points and it is now instead correctly classified by NN with m=20000 training data points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INPUT:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LABEL: 4\n",
      "NN prediction for m=500: 6\n",
      "NN prediction for m=20000: 4\n"
     ]
    }
   ],
   "source": [
    "NN_prediction = mlp.predict(X_test)# ADD YOUR CODE HERE\n",
    "large_NN_prediction =mlp_large.predict(X_test) # ADD YOUR CODE HERE\n",
    "\n",
    "for i, (p, pl, l) in enumerate(zip(NN_prediction, large_NN_prediction, y_test)):\n",
    "    \n",
    "    if p != l and pl == l:\n",
    "        \n",
    "        plot_input(X_test, y_test, i)\n",
    "        print(\"NN prediction for m=500:\", p)\n",
    "        print(\"NN prediction for m=20000:\", pl)\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TO DO B.3** Plot the weigths of the multi-layer perceptron classifier, for the best NN we get with 500 data points and with 20000 data points. <br>\n",
    "Note that the code is provided, you just need to change the `mlp` variable name to the one used before - if you changed it.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weights with 500 data points:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weights with 20000 data points:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"Weights with 500 data points:\")\n",
    "fig, axes = plt.subplots(4, 4)\n",
    "vmin, vmax = mlp.coefs_[0].min(), mlp.coefs_[0].max()\n",
    "for coef, ax in zip(mlp.coefs_[0].T, axes.ravel()):\n",
    "    ax.matshow(coef.reshape(28, 28), cmap=plt.cm.gray, vmin=.5 * vmin,\n",
    "               vmax=.5 * vmax)\n",
    "    ax.set_xticks(())\n",
    "    ax.set_yticks(())\n",
    "\n",
    "plt.show()\n",
    "\n",
    "print(\"Weights with 20000 data points:\")\n",
    "fig, axes = plt.subplots(4, 4)\n",
    "vmin, vmax = mlp_large.coefs_[0].min(), mlp_large.coefs_[0].max()\n",
    "for coef, ax in zip(mlp_large.coefs_[0].T, axes.ravel()):\n",
    "    ax.matshow(coef.reshape(28, 28), cmap=plt.cm.gray, vmin=.5 * vmin,\n",
    "               vmax=.5 * vmax)\n",
    "    ax.set_xticks(())\n",
    "    ax.set_yticks(())\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question B.Q2** Describe what do you observe by looking at the weights"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "**ANSWER B.Q2**:<br>\n",
    "    Just by looking at the weights , I couldnt really differentiate between the 500 data points and 20000\n",
    "    data points. Although the weights with 20000 data points are somewhat more clear than that of 500 but it is\n",
    "    difficult to clearly distinguish between the labels by looking at the outputs.\n",
    "    </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TO DO B.4** Create a SVM classifier with the following parameters: `kernel='rbf', C=10, gamma=0.01`. <br>\n",
    "Fit it on a few data points and compute its training and test scores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RESULTS FOR SVM\n",
      "Training score SVM: 0.9767\n",
      "0.023299999999999987\n",
      "Test score SVM: 0.888625\n",
      "0.111375\n"
     ]
    }
   ],
   "source": [
    "m_training = 20000 # ADD YOUR CODE HERE\n",
    "\n",
    "\n",
    "X_train, X_test = X[:m_training],X[m_training:]# ADD YOUR CODE HERE\n",
    "y_train, y_test = y[:m_training],y[m_training:]# ADD YOUR CODE HERE\n",
    "\n",
    "\n",
    "# best parameters found in the SVM notebook\n",
    "SVM = SVC(kernel='rbf',C=10.,gamma=0.01)# ADD YOUR CODE HERE\n",
    "SVM.fit(X_train, y_train)\n",
    "\n",
    "print ('RESULTS FOR SVM')\n",
    "SVM_training_error = 1- SVM.score(X_train,y_train)# ADD YOUR CODE HERE\n",
    "\n",
    "print(\"Training score SVM:\",SVM.score(X_train,y_train))\n",
    "print(SVM_training_error)\n",
    "\n",
    "SVM_test_error = 1- SVM.score(X_test,y_test)# ADD YOUR CODE HERE\n",
    "print(\"Test score SVM:\",SVM.score(X_test,y_test))\n",
    "print(SVM_test_error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question B.Q3** Compare the results of SVM and of NN. Which one achieves the best performances? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "**ANSWER B.Q3**:<br>\n",
    "    RESULTS FOR SVM\n",
    "    Training error SVM: 0.023299999999999987\n",
    "    Test error SVM: 0.111375<br>\n",
    "    RESULTS FOR BEST NN for m_training =20_000\n",
    "\n",
    "    NN training error: 0.107300\n",
    "    NN test error: 0.137275\n",
    "    On comparing SVM with NN we see that the SVM gives a better performance on the training data with less \n",
    "    error,which is the same on the test set i.e the svm has a better performance.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n"
     ]
    }
   ],
   "source": [
    "print(\"done\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}