Pytorch/SelfNormalizingNetworks_CNN_MNIST.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Tutorial on self-normalizing networks on the MNIST data set: convolutional neural networks\n",
    "\n",
    "*Author:* Kajetan Schweighofer, 2021"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [],
   "source": [
    "import os\n",
    "import copy\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import DataLoader, Subset\n",
    "import torchvision\n",
    "from torchvision import transforms\n",
    "\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\""
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [],
   "source": [
    "# load data and preprocess\n",
    "\n",
    "path = os.path.join(\".\", \"dataset\", \"mnist\")\n",
    "os.makedirs(path, exist_ok=True)\n",
    "\n",
    "# convert PIL image to tensor and normalize\n",
    "transform = transform=transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.1307,), (0.3081,))\n",
    "])\n",
    "\n",
    "train = torchvision.datasets.MNIST(path, download=True, train=True, transform=transform)\n",
    "test = torchvision.datasets.MNIST(path, download=True, train=False, transform=transform)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Functions"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Model"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "class CNN(nn.Module):\n",
    "\n",
    "    def __init__(self, out_features: int, p_drop=0.2, use_selu: bool=False):\n",
    "        super(CNN, self).__init__()\n",
    "\n",
    "        activation = nn.SELU() if use_selu else nn.ReLU()\n",
    "        dropout = nn.AlphaDropout(p=p_drop) if use_selu else nn.Dropout(p=p_drop)\n",
    "\n",
    "        self.net = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=1, out_channels=8, kernel_size=5),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            activation,\n",
    "            nn.Conv2d(in_channels=8, out_channels=16, kernel_size=3),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            activation,\n",
    "            nn.Flatten(),\n",
    "            nn.Linear(in_features=16*5*5, out_features=512),\n",
    "            activation,\n",
    "            dropout,\n",
    "            nn.Linear(in_features=512, out_features=out_features)\n",
    "        )\n",
    "\n",
    "        if use_selu:\n",
    "            for param in self.net.parameters():\n",
    "                # biases zero\n",
    "                if len(param.shape) == 1:\n",
    "                    nn.init.constant_(param, 0)\n",
    "                # others using lecun-normal initialization\n",
    "                else:\n",
    "                    nn.init.kaiming_normal_(param, mode='fan_in', nonlinearity='linear')\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.net(x)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Accuracy metric"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [],
   "source": [
    "class Accuracy(nn.Module):\n",
    "\n",
    "    def forward(self, x, y):\n",
    "\n",
    "        y_pred = F.softmax(x, dim=1).argmax(dim=1).cpu().numpy()\n",
    "        y = y.cpu().numpy()\n",
    "\n",
    "        return accuracy_score(y_true=y, y_pred=y_pred)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Training / Evaluation methods"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [],
   "source": [
    "def _forward(network: nn.Module, data: DataLoader, metric: callable):\n",
    "\n",
    "    for x, y in data:\n",
    "        x = x.to(next(network.parameters()).device)\n",
    "\n",
    "        y_hat = network.forward(x).cpu()\n",
    "        loss = metric(y_hat, y)\n",
    "        yield loss\n",
    "\n",
    "@torch.enable_grad()\n",
    "def update(network: nn.Module, data: DataLoader, loss: nn.Module,\n",
    "           opt: torch.optim.Optimizer) -> list:\n",
    "\n",
    "    network.train()\n",
    "\n",
    "    errs = []\n",
    "    for err in _forward(network, data, loss):\n",
    "        errs.append(err.item())\n",
    "        opt.zero_grad()\n",
    "        try:\n",
    "            err.backward()\n",
    "            opt.step()\n",
    "        except:\n",
    "            print('error in update step')\n",
    "    return errs\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluate(network: nn.Module, data: DataLoader, metric: callable) -> float:\n",
    "\n",
    "    network.eval()\n",
    "\n",
    "    performance = []\n",
    "    for p in _forward(network, data, metric):\n",
    "        performance.append(p.item())\n",
    "    return np.mean(performance).item()\n",
    "\n",
    "\n",
    "def fit(network: nn.Module, trainloader: DataLoader, valloader: DataLoader,\n",
    "          testloader: DataLoader, epochs: int, lr: float):\n",
    "    optimizer = torch.optim.SGD(params=network.parameters(), lr=lr)\n",
    "    ce = nn.CrossEntropyLoss()\n",
    "    accuracy = Accuracy()\n",
    "\n",
    "    train_losses, val_losses, accuracies = [], [], []\n",
    "\n",
    "    # performance before training\n",
    "    val_losses.append(evaluate(network=network, data=valloader, metric=ce))\n",
    "\n",
    "    pbar = tqdm(range(epochs))\n",
    "    for ep in pbar:\n",
    "        # update network\n",
    "        tl = update(network=network, data=trainloader, loss=ce, opt=optimizer)\n",
    "        train_losses.extend(tl)\n",
    "        vl = evaluate(network=network, data=valloader, metric=ce)\n",
    "        val_losses.append(vl)\n",
    "        ac = evaluate(network=network, data=valloader, metric=accuracy)\n",
    "\n",
    "        if len(accuracies) == 0 or ac > max(accuracies):\n",
    "            # here we would store the model on disc for early stopping\n",
    "            best_model = copy.deepcopy(network)\n",
    "\n",
    "        accuracies.append(ac)\n",
    "\n",
    "        print(f\"train loss: {round(np.mean(tl), 4):.4f}, \"\n",
    "              f\"val loss: {round(vl, 4):.4f}, \"\n",
    "              f\"accuracy: {round(ac * 100, 2):.2f}%\")\n",
    "\n",
    "        pbar.set_description_str(desc=f\"Epoch {ep+1}\")\n",
    "\n",
    "    # evaluate on best model obtained throughout training\n",
    "    acc = evaluate(network=best_model, data=testloader, metric=accuracy)\n",
    "\n",
    "    print(f\"Final accuracy on testset: {round(acc*100, 2):.2f}%\")\n",
    "\n",
    "    return train_losses, val_losses, accuracies, acc"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Training\n",
    "\n",
    "### Hyperparameters"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [],
   "source": [
    "epochs = 20\n",
    "lr = 1e-3\n",
    "batch_size = 128\n",
    "num_workers = 4\n",
    "p_drop = 0.05"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Create Dataloaders"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [],
   "source": [
    "# obtain validation set (1/6 of train data to be equal to size of test data)\n",
    "rng = np.random.default_rng(seed=42)\n",
    "val_inds = rng.choice(np.arange(len(train)), size=len(train)//6, replace=False)\n",
    "train_inds = np.delete(np.arange(len(train)), val_inds)\n",
    "\n",
    "trainloader = DataLoader(Subset(train, indices=train_inds),\n",
    "                         batch_size=batch_size, drop_last=True, shuffle=True, num_workers=num_workers)\n",
    "valloader = DataLoader(Subset(train, indices=val_inds),\n",
    "                       batch_size=batch_size, drop_last=True, shuffle=True, num_workers=num_workers)\n",
    "testloader = DataLoader(test, batch_size=batch_size, drop_last=False, shuffle=False, num_workers=num_workers)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Train Networks"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 20: 100%|██████████| 20/20 [04:22<00:00, 13.15s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train loss: 2.2593, val loss: 2.2028, accuracy: 36.78%\n",
      "train loss: 2.0980, val loss: 1.9309, accuracy: 66.65%\n",
      "train loss: 1.5814, val loss: 1.1534, accuracy: 80.10%\n",
      "train loss: 0.8626, val loss: 0.6449, accuracy: 84.67%\n",
      "train loss: 0.5706, val loss: 0.4869, accuracy: 87.21%\n",
      "train loss: 0.4660, val loss: 0.4198, accuracy: 88.26%\n",
      "train loss: 0.4124, val loss: 0.3812, accuracy: 89.15%\n",
      "train loss: 0.3770, val loss: 0.3519, accuracy: 89.78%\n",
      "train loss: 0.3513, val loss: 0.3298, accuracy: 90.31%\n",
      "train loss: 0.3306, val loss: 0.3126, accuracy: 90.84%\n",
      "train loss: 0.3115, val loss: 0.2953, accuracy: 91.40%\n",
      "train loss: 0.2950, val loss: 0.2795, accuracy: 91.83%\n",
      "train loss: 0.2811, val loss: 0.2682, accuracy: 92.21%\n",
      "train loss: 0.2687, val loss: 0.2565, accuracy: 92.47%\n",
      "train loss: 0.2557, val loss: 0.2434, accuracy: 92.74%\n",
      "train loss: 0.2444, val loss: 0.2342, accuracy: 92.98%\n",
      "train loss: 0.2355, val loss: 0.2249, accuracy: 93.26%\n",
      "train loss: 0.2248, val loss: 0.2169, accuracy: 93.49%\n",
      "train loss: 0.2162, val loss: 0.2071, accuracy: 93.86%\n",
      "train loss: 0.2084, val loss: 0.2004, accuracy: 93.95%\n",
      "Final accuracy on testset: 94.58%\n"
     ]
    }
   ],
   "source": [
    "# ReLU training\n",
    "\n",
    "# 28x28 = 784 input images for 10 classes\n",
    "network = CNN(out_features=10, p_drop=p_drop, use_selu=False).to(device)\n",
    "rtl, rvl, raccs, racc = fit(network, trainloader, valloader, testloader, epochs, lr)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 20: 100%|██████████| 20/20 [04:12<00:00, 12.63s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train loss: 1.3642, val loss: 0.6689, accuracy: 81.49%\n",
      "train loss: 0.6260, val loss: 0.4438, accuracy: 86.71%\n",
      "train loss: 0.4683, val loss: 0.3639, accuracy: 89.05%\n",
      "train loss: 0.3968, val loss: 0.3208, accuracy: 90.24%\n",
      "train loss: 0.3534, val loss: 0.2910, accuracy: 91.19%\n",
      "train loss: 0.3217, val loss: 0.2698, accuracy: 91.85%\n",
      "train loss: 0.2978, val loss: 0.2519, accuracy: 92.49%\n",
      "train loss: 0.2762, val loss: 0.2374, accuracy: 92.93%\n",
      "train loss: 0.2620, val loss: 0.2243, accuracy: 93.41%\n",
      "train loss: 0.2480, val loss: 0.2138, accuracy: 93.67%\n",
      "train loss: 0.2349, val loss: 0.2032, accuracy: 93.99%\n",
      "train loss: 0.2225, val loss: 0.1936, accuracy: 94.27%\n",
      "train loss: 0.2124, val loss: 0.1872, accuracy: 94.48%\n",
      "train loss: 0.2040, val loss: 0.1786, accuracy: 94.74%\n",
      "train loss: 0.1949, val loss: 0.1718, accuracy: 94.92%\n",
      "train loss: 0.1869, val loss: 0.1650, accuracy: 94.91%\n",
      "train loss: 0.1801, val loss: 0.1598, accuracy: 95.16%\n",
      "train loss: 0.1751, val loss: 0.1545, accuracy: 95.23%\n",
      "train loss: 0.1695, val loss: 0.1494, accuracy: 95.47%\n",
      "train loss: 0.1629, val loss: 0.1448, accuracy: 95.59%\n",
      "Final accuracy on testset: 95.91%\n"
     ]
    }
   ],
   "source": [
    "# SELU training\n",
    "network = CNN(out_features=10, p_drop=p_drop, use_selu=True).to(device)\n",
    "stl, svl, saccs, sacc = fit(network, trainloader, valloader, testloader, epochs, lr)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Plot results"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.plot(np.asarray(range(len(rtl))) / len(trainloader), rtl, alpha=0.4, label=\"ReLU train loss\")\n",
    "plt.plot(np.asarray(range(len(stl))) / len(trainloader), stl, alpha=0.4, label=\"SELU train loss\")\n",
    "plt.plot(range(len(rvl)), rvl, color=\"C0\", label=\"ReLU val loss\")\n",
    "plt.plot(range(len(svl)), svl, color=\"C1\", label=\"SELU val loss\")\n",
    "plt.title(\"Train and Validation loss over Epochs\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"CELoss\")\n",
    "plt.yscale(\"log\")\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEWCAYAAABhffzLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAA+qklEQVR4nO3deXxU1fn48c+Tyb5vLGFfBJQlCRCtYNUoSEHBHcGigrWitbW1359WtG612i9V2/rFtVh3qYi4g1oFUVtFLCAgigpEEEiAbGRfZ87vj3szTPZJyGQyyfN+veZ1l3Pn3ic3k2dOzj33XDHGoJRSqucI8ncASimlOpcmfqWU6mE08SulVA+jiV8ppXoYTfxKKdXDaOJXSqkeRhO/6nJExIjIcfb84yJyuzfbtuM480TkvfbGqVSg0sSvOpyI/EtE7m5i/XkiclBEgr3dlzHmWmPMHzsgpiH2l4T72MaYZcaYace67xaOOVREXCLyqK+OoVR7aOJXvvAMcLmISIP1lwPLjDG1nR+SX1wBFAJzRSSsMw8sIo7OPJ4KLJr4lS+8DiQCp9atEJEEYCbwnIicJCLrReSIiOSIyMMiEtrUjkTkGRG5x2P5Jvs92SLyswbbniMiX4hIsYjsE5G7PIo/tqdHRKRURCaJyAIR+Y/H+yeLyH9FpMieTvYo+1BE/igin4hIiYi8JyLJrZyHK4DbgBpgVoNYzxORLXasu0Vkur0+UUSetn++QhF53V5fL1Z7nWeT2DMi8piIvC0iZcAZrZwPROTHIvKp/XvYZx/jRBE55PmfkYhcJCJbWvlZVQDRxK86nDGmAliBlfjqXAJ8Y4zZCjiB3wLJwCRgCnBda/u1k+ONwFnACGBqg03K7GPGA+cAvxCR8+2y0+xpvDEm2hizvsG+E4HVwBIgCfgrsFpEkjw2+ylwJdAbCLVjaS7WU4EBwHIanAsROQl4DrjJjvU0YI9d/DwQCYyxj/O35o7RhJ8C9wIxwH9o4XyIyCDgHeAhoBeQDmwxxvwXyMc6x3Uus+NS3YQmfuUrzwKzRSTCXr7CXocxZpMx5jNjTK0xZg/wd+B0L/Z5CfC0MWa7MaYMuMuz0BjzoTHmS2OMyxizDXjRy/2ClRh3GmOet+N6EfiG+jX1p40x33l8saW3sL/5wDvGmELgn8AMEeltl10FPGWMed+O9YAx5hsRSQFmANcaYwqNMTXGmI+8jB/gDWPMJ/Y+K1s5H/OANcaYF+3j5Btjtthlz2Il+7ovxJ/YP4PqJjTxK58wxvwHyAXOE5FhwInYyUNERorIKvtCbzHwJ6zaf2v6Afs8lvd6ForIj0RknYjkikgRcK2X+63b994G6/YC/T2WD3rMlwPRTe3I/rKbDSwDsP+7+AGrRg4wENjdxFsHAgX2l0V7eJ6b1s5HczEAvADMEpForC/bfxtjctoZk+qCNPErX3oOq6Z/OfCeMeaQvf4xrNr0CGNMLHAr0PBCcFNysBJWnUENyv8JvAkMNMbEAY977Le1YWizgcEN1g0CDngRV0MXALHAo/aX20GsL5C65p59wPAm3rcPSBSR+CbKyrCagAAQkb5NbNPwZ2zpfDQXA8aYA8B6++e4HG3m6XY08Stfeg6rHf5q7GYeWwxQDJSKyPHAL7zc3wpggYiMFpFI4M4G5TFYNeZKux39px5luYALGNbMvt8GRorIT0UkWETmAKOBVV7G5mk+8BQwDqs5KB04BUgXkXHAk8CVIjJFRIJEpL+IHG/Xqt/B+sJIEJEQEam7NrEVGCMi6SISToNmrma0dD6WAVNF5BL7500SkXSP8ueA39k/w2vtOAeqC9PEr3zGbr//FIjCqnnWuRErCZUATwAvebm/d4AHgQ+AXfbU03XA3SJSAtyB9UVR995yrAufn9i9WE5usO98rF5H/w/r4ubvgJnGmDxvYqsjIv2xLlY/aIw56PHaBLwLzDfGfI51kfhvQBHwEUf/27gcqxfQN8Bh4AY7vu+Au4E1wE6si7etael8/ACcbf+8BcAWIM3jva/ZMb1mX09R3Yjog1iUUk0Rkd3ANcaYNf6ORXUsrfErpRoRkYuwrhk0/K9KdQNe3zqvlOoZRORDrOsblxtjXH4OR/mANvUopVQPo009SinVwwREU09ycrIZMmSIv8NQSqmAsmnTpjxjTK+G6wMi8Q8ZMoSNGzf6OwyllAooItLwbnRAm3qUUqrH0cSvlFI9jCZ+pZTqYTTxK6VUD6OJXymlehhN/Eop1cNo4ldKqR4mIPrxH5Onz2m8bsz5cNLVUF0Oy2Y3Lk//KYyfB2X5sOKKxuUn/gzGXgRF++HVaxqXT/4VjJoBeTvhrRsal592Iww/A3K2wbu3NC6fcgcM+hH8sAHW3t24fPr/Qkoq7F4HHz/QuHzWg5A8Ar59Bz59uHH5hX+HuAGw/RX471ONyy95DqKS4ItlsKWJJ+7NexlCI+HzJ+Cr1xuXX7namn6yBL77V/2ykHC47BVr/qP7IKvBkwUjE2DOC9b8mrtg33/rl8f2g4uesObfWQQHv6xfnjQczl1izb/5a8hv8JCpvuNgxmJr/pWroTi7fvnAE2HqXdb8S5dBeYOHYQ07HU7/nTX/wkVQU1m/fORP4JRfW/P62Wtcrp89a74tn726n6kDdf/Er5RS/mJc4HIBLqgqgbxd4KyGigKoLLbWG2Ntl/cdbH3JKi/cA1WlVlnhHkgY0qFhBcQgbRkZGUbv3FVKtZvLZSVUV639cnrMN7HOOOsv11RCdYmVvKtKrWmj5VKoKj66XFUCzqpjj33eShhxVrveKiKbjDEZDddrjV8p1fGMAWcN1JRDTcXRaa1n05jUmxxdlgbzdWXGaiKrKrETbEkTr6bWF1tJuaMFR0BYDIRFW9PQGIgd4LEcDWGxVtNUcBg4wsARCsGh1nzdtN66MHCE1C8PDu/40Dt8j0qpwONy1k+clcUe80VHyyrtJOpO6BWNk3t1uTVvnJ0UvNgJuO4VC+Fx1rWEuuWwaCuBBgV7vBwNpg3nPZYdYY2TvCNw02fgRu6lOX9f32jdzNQULp80hIpqJwue/rxR+cUTBzA7YyAFZdX84oVNjcovO3kws9L6kX2kgt++tKVR+dWnDmPq6D7szi3l1le/bFR+/Zkj+PGIZL7KLuLut75uVP676aOYODiRTXsLuO/dbxuV3zFrNGP6xfGfnXk89MHORuV/unAcw3tFs+brQzzx76xG5X+bk06/+Aje2prNC581HsPpscsmkhgVyssb97Fy0/5G5c9ceRIRoQ6eX7+HVdtyGpW/dM0kAJZ+vJu1Ow7XKwsPcfDsz04CYMnanXyyq/4jbRMiQ3n88okA/Pndb9i8t/7F1ZS4cB6cOx6AP7z1FV9nF9crH9Yriv+9MBWAW17dRlZu/cfFju4Xy52zxgBww/IvyCmqf3F2wuAEbp5+PADXPr+JwvLqeuWnHJfMr6eMAGD+U59TWVM/uU05oTcLTxsO+Pizl3eEO17+jDBXJeGmgnBjTc89IY60PqEcLsjn3U273OvDTSVhppIxyQ6SQ2soLzlCfkEeka5yIk0ZEaai0bEachKECYshODyWchNGToVQLWFUSRhVkkCV9CVtaApxsXF8X+Riw74KqywonCrCqJYwFpx+PEnR4WzIyuODbw4jWE3NdfX66zKHExPm4D+78li/u+6zcbQ5+tfT0wiLiueNHcW8s7OMComkSsIxYnVQ9N1nz0VKXBUPzh0NdO5nr+5n6kjdPvEr1SXVVpLgzCfSVUqUKSPSVUqkKWPYnhCoCCKipJCfF+0mylVGpCm1pq4ykt6ugLdK6VdbyT+a2u8n1qQ3UNcnqIowKoPCqZJwIorjICYOV0gkB4IHUS6RlAdFUSGRlEsUp6cOY0i/FL4rEp7dVFCvrErCuOPcMYzpF8fm5iodZ4wjrlc0u78+xGtHGlc6Lh2aDvERHC7PZsuexpWOmuMmQlQoOaX72HigcaXDNfQkCHVQvG8PhY7GlQ7lHb24q1R7GQPVZVBR6MXrSP3l2lZq2I5QCI+3mizC7aaLuldYrLUuLBZCo+xX9NH5kCiP9VFWc4XymYpqJwXl1RSUVpNfVkVBWTUFZdXkl1nriitrqHG6qHEaal321Omi1mWorrWmtR7ltU5DjbNuveEf8zM4bWSjIfW9ohd3lWrI5YTSw1Ce10SbdoO27sri+u3cdeUttWM7wiAyESISrFfiUIgYf3Q5PB4i4u2EHu+R1OOsPueqUxhjKK92UlZVS2lVLWVVTntaS1m1ta64opaCsiormdcl9lJrWlHT9GcgOEhIiAolPiKEEEcQIQ4h2BFEcJAQGRpMsEMIDrLWhziCCHYIIUH21N4u2BFE/4SIDv+ZNfGr7qmqFEpyrJtkmpzmQOmhlhN3UIhds/a4YBg/yL5YGHO01l2XyD2TfEQChHT8H6yqr7rWRUllDcWVtRRX1FBcWUOJx3xxRa17XUllDaVVtZRXeyT2Kidl1bV40/ARHhJEUlQYiVGhJEaFclyvaBKjQkmICiXJXpcUHUqivU1seDDi7pXUtWjiV4GlpgJKDlpJ23NachBKsq2EXpJj1cgbCouD2BSISYHhx1vT2BSI6n00iYfHHU30wWEe3QlVR6qqdVJaaSXekqoau5ZdQ2lV3fpaSqpq3fOl9qthYq+scbV4nCCB2IgQYsKDiQkLISrMQWJUKAMTI4kODSYqLJjoMAdRYXXzwfa8wz0fHRZMTHgwkaHdJ112n59EBbbKIrsWfhBKDlnT0sONk3xTCV0cENPXSuS9RsKwTDvB96s/DY3q9B+ruzHGUFXr8qhFWzXp4gpr6l6urF/T9ty2tKqWGqd31xajPZJwdFgwsREh9IuLIDYimJjwEGLDrXWx4VZyr5uPjQgmNjyEyFBHl611+5MmftU5jIHyAijIavpVUdD4PSGREN3HSup9RsPwMyGmD0T3taf2fGQSBOl4g96ornVRUFbNkYpqSu1kXGwnY3didq+vpbTqaNK2tqlpNWmLWAnbnYzDQ+gbG86I3layjg4Pdifyulp1TPjR2nV0WDDR4cFEhjgICtKk7Qua+FXHMQbKcptP7pVFHhsLxA20LniOPs+axva3kny0ndTDYrSppRXVtS4Ky6vJK61yX3C0LkBWuefz68rKqimprG1xf44gcTdtxISHEBMW7E7a0XXrwo/Wto/O160PJio0WBN2F6eJX7WNMVCeb408WLC7wTSr/q3x4rAuhiYOg3EZ1rTulTDYakNXjThdhvyyKnJLPF6lVRwutqa5JVXk2euaS+SOILEuNtoXHMclxFvzUaEkRocSHxHqTtQxHkk7IkSbRnoCTfyqaRVHjib0hknes+YuDiuJJw6HwZOtaeIwqwYfP8gad0S5FVXUcKCwgv2F5WQfqeCwndgPeyT4/NIqXE20pkSHBdMrJoxeMWGckBLLqdGhJEWHeSR4az45OpTY8BCtdatmaeLv6VxOyP0GDmyG7M1w6CvI32XV6t3sZpmk4TButpXck4Zb04TBmtxtxhiOlNew307sB45U2PNHlxvW0IODhORoK5mnxIWTOiDOndx7RYfROzaMXtHhJMeEdqteJcq/9JPUkxhjNcdkf3E00edstQbUAqsLY99UOH4mJB3nkdyH6A1FQI3TxcGiSnKKKskpquDAkQpyjlTWS/Ll1fXvC4gKdTAgIZIBCRGcNDSRAQkR9I+3lvsnRJAYGao1c9XpfJr4ReQ3wNVYYzA9YYx5UEQSgZeAIcAe4BJjTGGzO1HtV5x9NMEf2Gwl/MojVllwuJXkJ1wB/SZA/wlWku+hvWNcLkNeWRU5R+qSeiU5RyrIKaq0EnyR1SzT8Eaf2PBgBiREMjgpilOOS6Z/fIQ70Q9IiCAuIkTbzFWX47PELyJjsZL+SUA18K6IrLbXrTXGLBaRRcAi4GZfxdFjuJxW7f37j2Df51aiLz1olYnD6g45+jwrwfebAL1P6FFNNGVVtWQfsWrp2UeO1tiz7eWDRZVUO+vfDBQeEkS/uAhS4sM5bUQvUuIj6BcXTkp8BP3jw0mJiyAqTP9pVoHHl5/aE4DPjDHlACLyEXABcB6QaW/zLPAhmvjbzhjruarffwRZH8Kefx+96Jo0wno2bF1Nvu+4bj18gNNlOFRc2SixW8vW+qKKmnrvcQQJfWPD6RcfTvrAePqNi6CfncxT4sLpHx9BfKTW1lX35MvEvx24V0SSgArgbGAj0McYkwNgjMkRkd5NvVlEFgILAQYNGuTDMANI0QE70X9kTUvsYWnjBsEJs2BoJgw9zbq5qZuprHGyv7Ccvfnl7Mkv54f8MmtaUM7+wvJGNxXFRYTQz66ZnzgkgX7xRxN6v/gIeseEEezomc1aSvks8RtjdojIn4H3gVJgK9Dy3SP1378UWArWsMw+CbKrKy+wavJ1iT5/l7U+MslK8ENPt2r2CUO7xY1OpVW17M0vY29+uf0qc09ziivrta/HhAUzKCmS0SmxTB/b175oar1S4iOI1iYYpZrl078OY8yTwJMAIvInYD9wSERS7Np+CnC4pX30OOUFsOHv8N07kLMNMNZY64Mnw8QrrUTfe0xAX4Q1xrC/sIKvsovYfqCY7dlFfJVdTG5J/QdTJ0WFMjgpkh8NS2JwUqT9imJwYiSJUaHaDKNUO/m6V09vY8xhERkEXAhMAoYC84HF9vQNX8YQMCqL4bNHYf0j1jjvgydD5i1Wou8/MWAvxLpchr0F5Ww/UGQleDvRHym32twdQcKI3tGcOiKZ43pHMyQpikGJVpKPCQ/Mn1mprs7X/w+/Yrfx1wC/NMYUishiYIWIXAX8AMz2cQxdW3UZfL4UPvk/68lMJ8yCzFutXjgBptbpIiuvzErydoL/OruY0iqrhS/UEcSovjHMGNuXMf3iGNs/juP7xhAeok+IUqoz+bqp59Qm1uUDU3x53IBQUwkbn4L//NUa2GzENDjjVug33t+Rea2ooobNPxSyaU8hG/cWsHVfkftpROEhQZyQEsuFE/oztl8cY/rHMqJ3DKHBgdtEpVR3oVfAOlttNXzxPHz8gPXgkKGnwRnLYNCP/B1Zi4wx7CuoYOPeAjbutZL9d4dLMMZqrhmdEsucEweSOsCqyQ9LjtJeM0p1UZr4O4uzFra9BB8thiM/wMAfwYV/txJ/F1TjdPF1drGV5PcWsHFPIYfti68xYcGMH5zAOakpZAxOIG1gvN7IpFQA0b9WX3O54KtX4cP/tbpjpqTDOX+D46Z0uS6Ye/LKeGXzfjbuKWTLviPuZpv+8RFMGp5ExuAEJg5OZFTfGBw6voxSAUsTv68YA9+sgnV/gsNfQ+/RMGcZHH9Ol0v4R8qr+b+1O3nhs724DO5mm4whCWQMTqRvnA7QplR3oonfF0oOwYtzrcHRko6Di56EMRd2ub73VbVOnl+/lyVrd1JaVcucEwfx27NG0DtGE71S3Zkm/o5WXQb/vATyvoPzHoXUOeDoWqfZGMM72w+y+J1v+KGgnNNH9uLWs09gVN8Yf4emlOoEXSsjBTpnLaz8GRzcBnNfhFHT/R1RI1/8UMi9q3ewcW8ho/rE8NzPTuK0kb38HZZSqhNp4u8oxsC7N8N378I5f+lySX9/YTn3vfstb27NJjk6jP+9cByXZAzUi7RK9UCa+DvKpw/Bf/8Bk38NJ/7c39G4FVfW8Oi63Tz1yfcECVx/5nFcc/pwHcRMqR5M//o7wvZX4f3bYcwFMPUP/o4GsIZPePHzH/jbmp0UlFVz4YT+3PSTUaTEdd9x+ZVS3tHEf6x++AxeuxYGTYLzH/d7zx1jDB98c5g/vb2D3bllnDwskdvOGc3Y/nF+jUsp1XVo4j8WebusbpvxA2HuP/3+QPLqWhe/XbGF1dtyGJYcxRNXZDD1hN46fLFSqh5N/O1VmgvLLrKeZzvvZYhM9Gs4NU4X17+4mX99dYgbp43kmtOHE6Jj5SilmqCJvz2qy62afskhWLAKEof5NZwap4tf/dNK+nfOGs2Vpwz1azxKqa5NE39buZzw6tVwYBPMeQEGZPg1nBqni+v/+QX/+uoQd8zUpK+Uap0m/rb61++tMXimL4YTZvo1lBqni1+/+AXvfnWQ22eO5mc/1qSvlGqdNgK3xWePwYbH4OTr4ORf+DWUGqeL3yz/gne2W0n/Kk36SikvaeL31o634N1b4PiZMO0ev4ZS43Rxw/ItvP3lQW475wRN+kqpNtHE7419/4VXfm499PzCJyDIf8+IrbWT/uovc7jtnBP4+an+vbCslAo8mvhbU5AFL86BmBT46UsQGum3UGqdLn7zkpX0f3+2Jn2lVPto4m9JWT68cDEYF8xbCVHJfgvFnfS35XDr2cdz9Wma9JVS7aO9eppTUwnLfwpF+2H+m5B8nN9CqXW6uMEj6S88bbjfYlFKBT5N/M3Z/Czs+wxmPwODTvZbGLVOF79dsZVV23K4ZYYmfaXUsdPE35wTr4Y+Y2DIj/0WQq3Txf+s2MpbW7NZNON4rjldk75S6tj5tI1fRH4rIl+JyHYReVFEwkUkUUTeF5Gd9jTBlzG0W1CQ35P+/3t5K29uzebm6cdzrSZ9pVQH8VniF5H+wK+BDGPMWMABzAUWAWuNMSOAtfay8uB0Gf7fy1t5Y0s2v5s+il9katJXSnUcX/fqCQYiRCQYiASygfOAZ+3yZ4HzfRxDwLn11S/dSf+6TP9dVFZKdU8+S/zGmAPAA8APQA5QZIx5D+hjjMmxt8kBejf1fhFZKCIbRWRjbm6ur8LscrKPVPDSxn387JShmvSVUj7hy6aeBKza/VCgHxAlIpd5+35jzFJjTIYxJqNXr16+CrPLWb0tB4D5kwf7ORKlVHfly6aeqcD3xphcY0wN8CowGTgkIikA9vSwD2MIOKu+zGFc/zgGJ0X5OxSlVDfly8T/A3CyiESK9ey/KcAO4E1gvr3NfOANH8YQUPYVlLN13xHOSU3xdyhKqW7MZ/34jTEbRGQlsBmoBb4AlgLRwAoRuQrry2G2r2IINKvsZp5zxmniV0r5jk9v4DLG3Anc2WB1FVbtXzWw+sts0gfGMzDRfwPBKaW6Px2krYvYk1fG9gPFzNRmHqWUj2ni7yJWf2k185ytzTxKKR/TxN9FvLU1m4zBCfSLj/B3KEqpbk4Tfxew63Ap3xws0d48SqlOoYm/C1i9LQcRbeZRSnUOTfxdwKpt2Zw4JJE+seH+DkUp1QNo4vezbw+WsPNwKbO0mUcp1Uk08fvZ6m3ZBAlMH6uJXynVOTTx+5ExhlXbcjh5WBK9YsL8HY5SqofQxO9HO3JKyMorY2ZqP3+HopTqQTTx+9Gqbdk4goTpY/v6OxSlVA+iid9P6pp5Jg9PIjEq1N/hKKV6EE38frL9QDE/FJQzS5t5lFKdTBO/n6zalk1wkDBtTB9/h6KU6mE08ftBXTPPqSOSiY/UZh6lVOfSxO8HW/Yd4cCRCu3No5TyC038frBqWw6hjiDO0mYepZQfaOLvZC6X4e0vczhtZC9iw0P8HY5SqgfSxN/JNv9QSE5RpT5pSynlN5r4O9mqbTmEBQcxdbQ28yil/KPVxC8iM0VEvyA6gNNu5jljVG+iw3z6nHullGqWNwl9LrBTRO4TkRN8HVB39t89BRwuqdInbSml/KrVxG+MuQwYD+wGnhaR9SKyUERifB5dN7NqWzYRIQ6mnNDb36EopXowr5pwjDHFwCvAciAFuADYLCLX+zC2bqXW6eLd7Qc584TeRIZqM49Syn+8aeOfJSKvAR8AIcBJxpgZQBpwo4/j6zY2fF9AXmk1M/W5ukopP/Om6jkb+Jsx5mPPlcaYchH5WXNvEpFRwEseq4YBdwDP2euHAHuAS4wxhW0LO/Cs2pZNZKiDM47XZh6llH9509RzJ/B53YKIRIjIEABjzNrm3mSM+dYYk26MSQcmAuXAa8AiYK0xZgSw1l7u1mrsZp6pJ/QhPMTh73CUUj2cN4n/ZcDlsey017XFFGC3MWYvcB7wrL3+WeD8Nu4r4Hy6O5/C8hq9aUsp1SV4k/iDjTHVdQv2fFuHlJwLvGjP9zHG5Nj7ygGabPuwew5tFJGNubm5bTxc17J6WzYxYcGcNrKXv0NRSimvEn+uiJxbtyAi5wF53h5AREKBc2njfwnGmKXGmAxjTEavXoGbMKtrrWaes0ZrM49Sqmvw5uLutcAyEXkYEGAfcEUbjjED2GyMOWQvHxKRFGNMjoikAIfbFHGA+c+uXIora5mZps08SqmuodXEb4zZDZwsItGAGGNK2niMSznazAPwJjAfWGxP32jj/gLKqm05xIYH8+PjAve/FqVU9+LVnUQicg4wBggXEQCMMXd78b5I4CzgGo/Vi4EVInIV8ANWd9FuqbLGyftfHWL62L6EButwR0qprqHVxC8ijwORwBnAP4CL8eje2RJjTDmQ1GBdPlYvn27v4+9yKamqZWaaPmlLKdV1eFMNnWyMuQIoNMb8AZgEDPRtWN3D6i9zSIgMYfLwpNY3VkqpTuJN4q+0p+Ui0g+oAYb6LqTuobLGyZqvrWaeEIc28yilug5v2vjfEpF44H5gM2CAJ3wZVHfw4beHKat26gPVlVJdTouJ334Ay1pjzBHgFRFZBYQbY4o6I7hA9ta2HJKiQvnR0ER/h6KUUvW02AZhjHEBf/FYrtKk37qKaicf7DjMjHF9CdZmHqVUF+NNVnpPRC6Sun6cqlVf5xRTUePk9JE6EqdSquvxpo3/f4AooFZEKrHu3jXGmFifRhbAsnJLATiud7SfI1FKqca8uXNXH7HYRrtzywhxCAMTIvwdilJKNeLNDVynNbW+4YNZ1FFZuaUMSozU9n2lVJfkTVPPTR7z4cBJwCbgTJ9E1A1k5ZUxrJc28yiluiZvmnpmeS6LyEDgPp9FFOBqnS725pcx5QS9sKuU6pra0xaxHxjb0YF0F/sLK6hxGoYna41fKdU1edPG/xDW3bpgfVGkA1t9GFNAy8qzevQM6xXl50iUUqpp3rTxb/SYrwVeNMZ84qN4Al5WbhmAtvErpbosbxL/SqDSGOMEEBGHiETaQy6rBnbnlhEfGUJiVFsfS6yUUp3Dmzb+tYBnh/QIYI1vwgl8WbmlDEvWZh6lVNflTeIPN8aU1i3Y85G+CymwaVdOpVRX503iLxORCXULIjIRqPBdSIGrpLKG3JIqvbCrlOrSvGnjvwF4WUSy7eUUYI7PIgpg7gu72pVTKdWFeXMD139F5HhgFNYAbd8YY2p8HlkAquvKOVxr/EqpLqzVph4R+SUQZYzZboz5EogWket8H1rgycotI0hgUJJeAlFKdV3etPFfbT+BCwBjTCFwtc8iCmBZuWUMTIwkLNjh71CUUqpZ3iT+IM+HsIiIA9BO6k3YrV05lVIBwJvE/y9ghYhMEZEzgReBd3wbVuBxuQx78rUrp1Kq6/Mm8d+MdRPXL4BfAtuof0NXs0QkXkRWisg3IrJDRCaJSKKIvC8iO+1pQvvD7zqyiyqorHFpV06lVJfXauK3H7j+GZAFZABTgB1e7v//gHeNMccDafb7FgFrjTEjsL5QFrUj7i5Hu3IqpQJFs905RWQkMBe4FMgHXgIwxpzhzY5FJBY4DVhgv68aqBaR84BMe7NngQ+x/qsIaHXP2dWunEqprq6lGv83WLX7WcaYHxtjHgKcbdj3MCAXeFpEvhCRf4hIFNDHGJMDYE+bfGKJiCwUkY0isjE3N7cNh/WPrLwyosOC6RUT5u9QlFKqRS0l/ouAg8A6EXlCRKZg3cDlrWBgAvCYMWY8UEYbmnWMMUuNMRnGmIxevXq14bD+kZVbxrBeUXh0gFJKqS6p2cRvjHnNGDMHOB6rOea3QB8ReUxEpnmx7/3AfmPMBnt5JdYXwSERSQGwp4ePIf4uQ0flVEoFCm8u7pYZY5YZY2YCA4AteFFzN8YcBPaJyCh71RTga+BNYL69bj7wRjvi7lLKq2vJLqrUrpxKqYDgzSBtbsaYAuDv9ssb1wPLRCQUq1fQlVhfNitE5CrgB2B2W2Loir7Pq3vqltb4lVJdX5sSf1sZY7ZgdQFtaIovj9vZtCunUiqQeHMDl2pFXeIfqm38SqkAoIm/A2TlldI/PoKIUB2cTSnV9Wni7wB1XTmVUioQaOI/RsYYsnJLGa49epRSAUIT/zE6XFJFWbVTa/xKqYChif8Y7bbH6NEePUqpQKGJ/xi5u3JqjV8pFSA08R+jrNwyIkIc9I0N93coSinlFU38xygrr5ShyVEEBengbEqpwKCJ/xhpV06lVKDRxH8Mqmqd7C8s18HZlFIBRRP/MdibX47L6FO3lFKBRRP/McjSrpxKqQCkif8Y7K4bnE1r/EqpAOLTYZm7u6zcMvrEhhEdpqdRdb6amhr2799PZWWlv0NRfhYeHs6AAQMICQnxanvNWMcgK69Um3mU3+zfv5+YmBiGDBmiz3ruwYwx5Ofns3//foYOHerVe7Spp52swdm0K6fyn8rKSpKSkjTp93AiQlJSUpv+89PE304FZdUUVdRoV07lV5r0FbT9c6CJv52y9Dm7SqkApYm/neq6cg7XNn7VgzkcDtLT0xk7diyzZs3iyJEjLW5/11138cADD9Rbt2DBAlauXFlvXXR0x/xdddR+uhtN/O2UlVtGaHAQ/RMi/B2KUn4TERHBli1b2L59O4mJiTzyyCP+DqlLqa2t9XcITdJePe20O7eMIUmROHRwNtUF/OGtr/g6u7hD9zm6Xyx3zhrj9faTJk1i27ZtAOzevZtf/vKX5ObmEhkZyRNPPMHxxx9/TPHcfPPNDB48mOuuuw6w/nuIiYnhmmuu4bzzzqOwsJCamhruuecezjvvvBb3df7557Nv3z4qKyv5zW9+w8KFCwF49913ufXWW3E6nSQnJ7N27VpKS0u5/vrr2bhxIyLCnXfeyUUXXUR0dDSlpdZ//itXrmTVqlU888wzLFiwgMTERL744gsmTJjAnDlzuOGGG6ioqCAiIoKnn36aUaNG4XQ6ufnmm/nXv/6FiHD11VczevRoHn74YV577TUA3n//fR577DFeffXVYzp3DWnib6esvFJG9o7xdxhKdQlOp5O1a9dy1VVXAbBw4UIef/xxRowYwYYNG7juuuv44IMPjukYc+fO5YYbbnAn/hUrVvDuu+8SHh7Oa6+9RmxsLHl5eZx88smce+65LV7wfOqpp0hMTKSiooITTzyRiy66CJfLxdVXX83HH3/M0KFDKSgoAOCPf/wjcXFxfPnllwAUFha2Gut3333HmjVrcDgcFBcX8/HHHxMcHMyaNWu49dZbeeWVV1i6dCnff/89X3zxBcHBwRQUFJCQkOD+wuzVqxdPP/00V1555TGdt6Zo4m+HGqeLH/LLmT6mr79DUQqgTTXzjlRRUUF6ejp79uxh4sSJnHXWWZSWlvLpp58ye/Zs93ZVVVXN7qOpBN3UuvHjx3P48GGys7PJzc0lISGBQYMGUVNTw6233srHH39MUFAQBw4c4NChQ/Tt2/zf55IlS9y16n379rFz505yc3M57bTT3H3hExMTAVizZg3Lly93vzchIaGVswKzZ8/G4XAAUFRUxPz589m5cyciQk1NjXu/1157LcHBwfWOd/nll/PCCy9w5ZVXsn79ep577rlWj9dWmvjbYV9BObUuo105VY9X18ZfVFTEzJkzeeSRR1iwYAHx8fFs2bLFq30kJSXVq0UXFBSQnJzc5LYXX3wxK1eu5ODBg8ydOxeAZcuWkZuby6ZNmwgJCWHIkCEt9mn/8MMPWbNmDevXrycyMpLMzEwqKysxxjT5hdPces91DY8XFXW0t9/tt9/OGWecwWuvvcaePXvIzMxscb9XXnkls2bNIjw8nNmzZ7u/GDqSTy/uisgeEflSRLaIyEZ7XaKIvC8iO+1p61+fXYw+blGp+uLi4liyZAkPPPAAERERDB06lJdffhmwEtzWrVubfW9mZiYvvfQS1dXVADzzzDOcccYZTW47d+5cli9fzsqVK7n44osBq0bdu3dvQkJCWLduHXv37m0x1qKiIhISEoiMjOSbb77hs88+A6xrFB999BHff/89gLupZ9q0aTz88MPu99d9SfXp04cdO3bgcrnc/z00d7z+/fu7f7Y606ZN4/HHH3dfAK47Xr9+/ejXrx/33HMPCxYsaPFnaa/O6NVzhjEm3RiTYS8vAtYaY0YAa+3lgJKVp105lWpo/PjxpKWlsXz5cpYtW8aTTz5JWloaY8aM4Y033nBvd8899zBgwAD3a+bMmZx66qlMnDiR9PR0PvnkE/785z83eYwxY8ZQUlJC//79SUlJAWDevHls3LiRjIwMli1b1upF5OnTp1NbW0tqaiq33347J598MgC9evVi6dKlXHjhhaSlpTFnzhwAbrvtNgoLCxk7dixpaWmsW7cOgMWLFzNz5kzOPPNMdyxN+d3vfsctt9zCKaecgtPpdK//+c9/zqBBg0hNTSUtLY1//vOf7rJ58+YxcOBARo8e3eLP0l5ijPHJjsGq8QMZxpg8j3XfApnGmBwRSQE+NMaMamk/GRkZZuPGjT6Ls60WvbKN978+xKbbz/J3KKoH27FjByeccIK/w1A+8Ktf/Yrx48e7L5Z7o6nPg4hs8qh0u/m6xm+A90Rkk4gstNf1McbkANjT3k29UUQWishGEdmYm5vr4zDbZnduqTbzKKV8YuLEiWzbto3LLrvMZ8fw9cXdU4wx2SLSG3hfRL7x9o3GmKXAUrBq/L4KsD2ycsuYekIff4ehlOqGNm3a5PNj+LTGb4zJtqeHgdeAk4BDdhMP9vSwL2PoaEXlNeSXVWuNXykVsHyW+EUkSkRi6uaBacB24E1gvr3ZfOCNpvfQNe22L+xqV06lVKDyZVNPH+A1u59qMPBPY8y7IvJfYIWIXAX8AMxuYR9djnblVEoFOp8lfmNMFpDWxPp8YIqvjutrWbmlBAcJgxIj/R2KUkq1i47O2UZZuWUMSowkxKGnTql7772XMWPGkJqaSnp6Ohs2bACsm7JGjRpFeno66enp7putdFjmrkGHbGijrDztyqkUwPr161m1ahWbN28mLCyMvLw89923YA2lkJHRqAt5j1JbW+uTIReOVdeLqAtzugx78svJHNXkrQdK+c87i+Dglx27z77jYMbiZotzcnJITk4mLCwMoNnxdTqKDsvccTTxt8GBwgqqa10MS9Yav1LTpk3j7rvvZuTIkUydOpU5c+Zw+umnu8vnzZtHRIT1oKKzzjqL+++//5iOp8MydxxN/G2gXTlVl9VCzdxXoqOj2bRpE//+979Zt24dc+bMYfHixe6Bxbxt6tFhmXVY5i5Nu3IqVZ/D4SAzM5PMzEzGjRvHs88+2+YRJXVY5voCfljm7iYrt5TY8GCSokL9HYpSfvftt9+yc+dO9/KWLVsYPHhwm/ejwzJ3z2GZu42s3DKG9Ypuse1QqZ6itLSU+fPnM3r0aFJTU/n666+566673OXz5s1zd+ecOnWqe70Oy2zptsMyd5SuMizzj/60hlOOS+avl6T7OxSldFjmbszXwzJrG7+XSqtqOVRcxXC9sKuU8qGJEycSFRXFX/7yF58dQxO/l76vu7CrXTmVUj4U8MMydydZ2pVTKdVNaOL30u7cMkRgcJIOzqaUCmya+L2UlVvKgIQIwkMc/g5FKaWOiSZ+L2XlljEsWZt5lFKBTxO/F1wuw/d5ZXrHrlINOBwO0tPTGTt2LLNmzeLIkSMtbn8swzIfOXKERx99tN2xPvjgg5SXl7f7/d2JJn4vHCyupKLGqRd2lWogIiKCLVu2sH37dhITE3nkkUd8dqzukPjr7tL1N+3O6YW6MXqGa1dO1YXN+fv6RutmpqZw+aQhVFQ7WfD0543KL544gNkZAykoq+YXL9TvRvjSNZPadPxJkyaxbds2AHbv3u0eZTIyMpInnnii1TtqW7No0SJ2795Nenq6e7TP+++/nxUrVlBVVcUFF1zAH/7wB8rKyrjkkkvYv38/TqeT22+/nUOHDpGdnc0ZZ5xBcnKy++7bOnfffTdvvfUWFRUVTJ48mb///e+ICLt27eLaa68lNzcXh8PByy+/zPDhw7nvvvt4/vnnCQoKYsaMGSxevJjMzEweeOABMjIyyMvLIyMjgz179vDMM8+wevVqKisrKSsr480332x2GOnnnnuOBx54ABEhNTWVRx99lNTUVL777jtCQkIoLi4mNTWVnTt3EhIS0u5zqYnfC9qVU6mWOZ1O1q5d677TdOHChTz++OOMGDGCDRs2cN111/HBBx8c0zEWL17M9u3b2bJlCwDvvfceO3fu5PPPP8cYw7nnnsvHH39Mbm4u/fr1Y/Xq1YA1Vk5cXBx//etfWbduXZMDwP3qV7/ijjvuAKzRMVetWsWsWbOYN28eixYt4oILLqCyshKXy8U777zD66+/zoYNG4iMjHSPsdOS9evXs23bNhITE6mtrW1yGOmvv/6ae++9l08++YTk5GQKCgqIiYkhMzOT1atXc/7557N8+XIuuuiiY0r6oInfK1m5ZUSFOugTG+bvUJRqVks19IhQR4vliVGhba7hA1RUVJCens6ePXuYOHEiZ511FqWlpXz66afMnj3bvV1VVVWz+/B2WOaG3nvvPd577z3Gjx8PWGMH7dy5k1NPPZUbb7yRm2++2T0OUGvWrVvHfffdR3l5OQUFBYwZM4bMzEwOHDjABRdcAEB4eDhgDad85ZVXEhlpde2uG065JWeddZZ7O2NMk8NIf/DBB1x88cXuL6a67X/+859z3333cf755/P000/zxBNPtHq81mji98Lu3FKG9orSwdmUaqCujb+oqIiZM2fyyCOPsGDBAuLj490189a0ZVhmT8YYbrnlFq655ppGZZs2beLtt9/mlltuYdq0ae7afFMqKyu57rrr2LhxIwMHDuSuu+5yD9Pc3HGbygXBwcG4XC73Pj15DtPc3DDSze33lFNOYc+ePXz00Uc4nU7Gjh3b7M/iLb246wXtyqlUy+Li4liyZAkPPPAAERERDB06lJdffhmwEuXWrVubfa+3wzLHxMRQUlLiXv7JT37CU0895X784YEDB9wPaomMjOSyyy7jxhtvZPPmzU2+v05dkk5OTqa0tNTdwyg2NpYBAwbw+uuvA9Z/LeXl5UybNo2nnnrKfaG4rqlnyJAh7uEWGvZS8tTcMNJTpkxhxYoV5Ofn19svwBVXXMGll17aYU/j0sTfisoaJ9lFFdqVU6lWjB8/nrS0NJYvX86yZct48sknSUtLY8yYMbzxxhvu7do7LHNSUhKnnHIKY8eO5aabbmLatGn89Kc/ZdKkSYwbN46LL76YkpISvvzyS0466STS09O59957ue222wDrusOMGTMafanEx8dz9dVXM27cOM4//3xOPPFEd9nzzz/PkiVLSE1NZfLkyRw8eJDp06dz7rnnkpGRQXp6urt76o033shjjz3G5MmTycvLa/Y8NTeM9JgxY/j973/P6aefTlpaGv/zP/9T7z2FhYVceuml7fjNNKbDMrdiR04xM/7v3yy5dDznpvXzSwxKNUWHZe45Vq5cyRtvvMHzzz/f7DZdalhmEXEAG4EDxpiZIpIIvAQMAfYAlxhjWn96sZ9k6aicSik/uv7663nnnXd4++23O2yfndHU8xtgh8fyImCtMWYEsNZe7rKycuu6cmriV0p1voceeohdu3YxcuTIDtunTxO/iAwAzgH+4bH6POBZe/5Z4HxfxnCssvLKSIkLJzJUO0AppboHX9f4HwR+B7g81vUxxuQA2NPeTb1RRBaKyEYR2Zibm+vjMJuXlVuqtX2lVLfis8QvIjOBw8aYdj1Oxhiz1BiTYYzJ6NWrVwdH53UM2pVTKdXt+LL94hTgXBE5GwgHYkXkBeCQiKQYY3JEJAU47MMYjkluaRUlVbVa41dKdSs+q/EbY24xxgwwxgwB5gIfGGMuA94E5tubzQfeaGYXfufu0aNj9CjVpHvvvZcxY8aQmppKeno6GzZsAKybskaNGkV6ejrp6elcfPHFgA7L3FX444rlYmCFiFwF/ADMbmV7v9GunEo1b/369axatYrNmzcTFhZGXl6e++5bsIYmyMho1IW83eoS/3XXXdeu9z/44INcdtll7jF2/KG2tpbgYP93FOmUO3eNMR8aY2ba8/nGmCnGmBH2tPWh7fwkK7eUsOAg+sdH+DsUpVr39DmNX5/bA3pVlzdd/sUyq7wsv3FZK3JyckhOTiYszBq8MDk5mX79fHeTo+ewzDfddBMA999/PyeeeCKpqanceeed1o9SVsY555xDWloaY8eO5aWXXmLJkiXuYZmbGg7i7rvv5sQTT2Ts2LEsXLjQPU7Prl27mDp1KmlpaUyYMIHdu3cDcN999zFu3DjS0tJYtMjqkZ6ZmUndjaZ5eXkMGTIEsIagmD17NrNmzWLatGmUlpYyZcoUJkyYwLhx4+rd1fzcc8+RmppKWloal19+OSUlJQwdOpSamhoAiouLGTJkiHu5vfz/1dOFZeWVMTQ5iqAgHZxNqYamTZvG3XffzciRI5k6dSpz5szh9NNPd5fPmzePiAir0lQ3fv6x0GGZdVjmTpGVW8rofrH+DkMp71y5uvmy0MiWy6OSWi5vQnR0NJs2beLf//4369atY86cOSxevJgFCxYA3jf16LDMOixzl1Fd62JfYQUzU3V8HqWa43A4yMzMJDMzk3HjxvHss8+6E7+3dFhmHZa5y/ihoAyny2hXTqWa8e2337Jz50738pYtWxg8eHCb96PDMnf+sMxa42/Gbu3KqVSLSktLuf766zly5AjBwcEcd9xxLF261F3u2cafnJzMmjVrAGtY5gcffNC93f79+9m0aRMTJ07E4XAwfPhwHn/88UbH8xyWecaMGdx///3s2LGDSZOsJ4dFR0fzwgsvsGvXLm666SaCgoIICQnhscceA44Oy5ySklLvmbuewzIPGTKk0bDM11xzDXfccQchISG8/PLLTJ8+nS1btpCRkUFoaChnn302f/rTn7jxxhu55JJLeP755znzzDObPW/z5s1j1qxZ7mGdmxqW2eFwMH78eJ555hn3e2677TYdltnX1u/O58n/fM9f56QRG35sF1KU8gUdlrnnCLhhmQPVpOFJTBqe5O8wlFI9nC+GZdbEr5RSXdhDDz3U4fvUi7tKBbBAaKpVvtfWz4EmfqUCVHh4OPn5+Zr8ezhjDPn5+e77DLyhTT1KBagBAwawf/9+/Pm8CtU1hIeHM2DAAK+318SvVIAKCQlh6NCh/g5DBSBt6lFKqR5GE79SSvUwmviVUqqHCYg7d0UkF9jbzrcnA3kdGE5H0bjaRuNqG42rbbpqXHBssQ02xjR6aHlAJP5jISIbm7pl2d80rrbRuNpG42qbrhoX+CY2bepRSqkeRhO/Ukr1MD0h8S9tfRO/0LjaRuNqG42rbbpqXOCD2Lp9G79SSqn6ekKNXymllAdN/Eop1cN0m8QvItNF5FsR2SUii5ooFxFZYpdvE5EJnRDTQBFZJyI7ROQrEflNE9tkikiRiGyxX80/FbpjY9sjIl/ax2z0eDM/na9RHudhi4gUi8gNDbbplPMlIk+JyGER2e6xLlFE3heRnfY0oZn3tvhZ9EFc94vIN/bv6TURiW/mvS3+zn0Q110icsDjd3V2M+/t7PP1kkdMe0RkSzPv9eX5ajI3dNpnzBgT8C/AAewGhgGhwFZgdINtzgbeAQQ4GdjQCXGlABPs+RjguybiygRW+eGc7QGSWyjv9PPVxO/0INYNKJ1+voDTgAnAdo919wGL7PlFwJ/b81n0QVzTgGB7/s9NxeXN79wHcd0F3OjF77lTz1eD8r8Ad/jhfDWZGzrrM9ZdavwnAbuMMVnGmGpgOXBeg23OA54zls+AeBFJ8WVQxpgcY8xme74E2AH09+UxO1Cnn68GpgC7jTHtvWP7mBhjPgYKGqw+D3jWnn8WOL+Jt3rzWezQuIwx7xljau3FzwDvx+f1YVxe6vTzVUdEBLgEeLGjjuetFnJDp3zGukvi7w/s81jeT+ME6802PiMiQ4DxwIYmiieJyFYReUdExnRSSAZ4T0Q2icjCJsr9er6AuTT/B+mP8wXQxxiTA9YfLtC7iW38fd5+hvWfWlNa+537wq/sJqinmmm28Of5OhU4ZIzZ2Ux5p5yvBrmhUz5j3SXxSxPrGvZT9WYbnxCRaOAV4AZjTHGD4s1YzRlpwEPA650RE3CKMWYCMAP4pYic1qDcn+crFDgXeLmJYn+dL2/587z9HqgFljWzSWu/8472GDAcSAdysJpVGvLb+QIupeXavs/PVyu5odm3NbGuTeesuyT+/cBAj+UBQHY7tulwIhKC9YtdZox5tWG5MabYGFNqz78NhIhIsq/jMsZk29PDwGtY/z568sv5ss0ANhtjDjUs8Nf5sh2qa+6yp4eb2MZfn7P5wExgnrEbghvy4nfeoYwxh4wxTmOMC3iimeP563wFAxcCLzW3ja/PVzO5oVM+Y90l8f8XGCEiQ+3a4lzgzQbbvAlcYfdWORkoqvuXylfsNsQngR3GmL82s01feztE5CSs30m+j+OKEpGYunmsi4PbG2zW6efLQ7M1MX+cLw9vAvPt+fnAG01s481nsUOJyHTgZuBcY0x5M9t48zvv6Lg8rwld0MzxOv182aYC3xhj9jdV6Ovz1UJu6JzPmC+uWPvjhdUL5Tusq92/t9ddC1xrzwvwiF3+JZDRCTH9GOtfsG3AFvt1doO4fgV8hXVl/jNgcifENcw+3lb72F3ifNnHjcRK5HEe6zr9fGF98eQANVg1rKuAJGAtsNOeJtrb9gPebumz6OO4dmG1+dZ9xh5vGFdzv3Mfx/W8/dnZhpWYUrrC+bLXP1P3mfLYtjPPV3O5oVM+Yzpkg1JK9TDdpalHKaWUlzTxK6VUD6OJXymlehhN/Eop1cNo4ldKqR5GE7/q0UTEKfVHBO2w0SFFZIjnqJBKdRXB/g5AKT+rMMak+zsIpTqT1viVaoI9FvufReRz+3WcvX6wiKy1Bx5bKyKD7PV9xBoLf6v9mmzvyiEiT9hjrr8nIhH29r8Wka/t/Sz304+peihN/Kqni2jQ1DPHo6zYGHMS8DDwoL3uYazhqlOxBkNbYq9fAnxkrMHjJmDd7QkwAnjEGDMGOAJcZK9fBIy393Otb340pZqmd+6qHk1ESo0x0U2s3wOcaYzJsgfTOmiMSRKRPKyhB2rs9TnGmGQRyQUGGGOqPPYxBHjfGDPCXr4ZCDHG3CMi7wKlWKOLvm7sgeeU6gxa41eqeaaZ+ea2aUqVx7yTo9fVzsEaC2kisMkeLVKpTqGJX6nmzfGYrrfnP8UaDRFgHvAfe34t8AsAEXGISGxzOxWRIGCgMWYd8DsgHmj0X4dSvqK1DNXTRUj9h22/a4yp69IZJiIbsCpIl9rrfg08JSI3AbnAlfb63wBLReQqrJr9L7BGhWyKA3hBROKwRkH9mzHmSAf9PEq1Stv4lWqC3cafYYzJ83csSnU0bepRSqkeRmv8SinVw2iNXymlehhN/Eop1cNo4ldKqR5GE79SSvUwmviVUqqH+f+iS084KuR4lgAAAABJRU5ErkJggg==\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.plot(range(1, len(raccs)+1), [a*100 for a in raccs], label=\"ReLU val accuracy\")\n",
    "plt.hlines(y=racc*100, xmin=0, xmax=len(raccs), colors=\"C0\", linestyles=\"dashed\", label=\"ReLU test accuracy\")\n",
    "plt.plot(range(1, len(saccs)+1), [a*100 for a in saccs], label=\"SELU val accuracy\")\n",
    "plt.hlines(y=sacc*100, xmin=0, xmax=len(saccs), colors=\"C1\", linestyles=\"dashed\", label=\"SELU test accuracy\")\n",
    "plt.title(\"Validation Accuracy\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "pycharm-91bfdd0f",
   "language": "python",
   "display_name": "PyCharm (SNNs)"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}