Image Classifier Project.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Developing an AI application\n",
    "\n",
    "Going forward, AI algorithms will be incorporated into more and more everyday applications. For example, you might want to include an image classifier in a smart phone app. To do this, you'd use a deep learning model trained on hundreds of thousands of images as part of the overall application architecture. A large part of software development in the future will be using these types of models as common parts of applications. \n",
    "\n",
    "In this project, you'll train an image classifier to recognize different species of flowers. You can imagine using something like this in a phone app that tells you the name of the flower your camera is looking at. In practice you'd train this classifier, then export it for use in your application. We'll be using [this dataset](http://www.robots.ox.ac.uk/~vgg/data/flowers/102/index.html) of 102 flower categories, you can see a few examples below. \n",
    "\n",
    "<img src='assets/Flowers.png' width=500px>\n",
    "\n",
    "The project is broken down into multiple steps:\n",
    "\n",
    "* Load and preprocess the image dataset\n",
    "* Train the image classifier on your dataset\n",
    "* Use the trained classifier to predict image content\n",
    "\n",
    "We'll lead you through each part which you'll implement in Python.\n",
    "\n",
    "When you've completed this project, you'll have an application that can be trained on any set of labeled images. Here your network will be learning about flowers and end up as a command line application. But, what you do with your new skills depends on your imagination and effort in building a dataset. For example, imagine an app where you take a picture of a car, it tells you what the make and model is, then looks up information about it. Go build your own dataset and make something new.\n",
    "\n",
    "First up is importing the packages you'll need. It's good practice to keep all the imports at the beginning of your code. As you work through this notebook and find you need to import a package, make sure to add the import up here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set environment\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "plt.ion()\n",
    "import seaborn as sns\n",
    "\n",
    "# progress bar for jupyter notebook \n",
    "from tqdm import tqdm_notebook as tqdm \n",
    "\n",
    "# keep workspace running\n",
    "from workspace_utils import active_session\n",
    "\n",
    "# set dependencies\n",
    "# basics\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import time\n",
    "import os\n",
    "import copy\n",
    "import warnings\n",
    "warnings.simplefilter('ignore')\n",
    "from collections import OrderedDict\n",
    "\n",
    "# pytorch\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torch.optim import lr_scheduler\n",
    "import torchvision\n",
    "from torchvision import datasets, models, transforms\n",
    "\n",
    "# image processing\n",
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load the data\n",
    "\n",
    "Here you'll use `torchvision` to load the data ([documentation](http://pytorch.org/docs/0.3.0/torchvision/index.html)). The data should be included alongside this notebook, otherwise you can [download it here](https://s3.amazonaws.com/content.udacity-data.com/nd089/flower_data.tar.gz). The dataset is split into three parts, training, validation, and testing. For the training, you'll want to apply transformations such as random scaling, cropping, and flipping. This will help the network generalize leading to better performance. You'll also need to make sure the input data is resized to 224x224 pixels as required by the pre-trained networks.\n",
    "\n",
    "The validation and testing sets are used to measure the model's performance on data it hasn't seen yet. For this you don't want any scaling or rotation transformations, but you'll need to resize then crop the images to the appropriate size.\n",
    "\n",
    "The pre-trained networks you'll use were trained on the ImageNet dataset where each color channel was normalized separately. For all three sets you'll need to normalize the means and standard deviations of the images to what the network expects. For the means, it's `[0.485, 0.456, 0.406]` and for the standard deviations `[0.229, 0.224, 0.225]`, calculated from the ImageNet images.  These values will shift each color channel to be centered at 0 and range from -1 to 1.\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dependencies\n",
    "This section includes also dependencies necessary for initializing two models __vgg__ and __resnet__ which I have selected for screening. Code can be extended for other models. It is necessary to include dependences here, as some of the models use diffrent size of the inputs where image processing / transforms are dependent on. \n",
    "\n",
    "Section includes following class and methods:\n",
    "- `Fc_Network` class: builds fully connected classifier for transfer learning\n",
    "- `freeze_model_params` method: freeze model parameters for feature extraction type of transfer learning\n",
    "- `initialize_model method`: initialize selected model for transfer learning\n",
    "- `NormalizeInverse` class: invert normalization of image tensor\n",
    "- `explore_images` method: show arbitrary number of images with labels\n",
    "\n",
    "Code was adapted using following resources: \n",
    "- [Udacity: Deep learning with PyTorch](https://github.com/udacity/deep-learning-v2-pytorch/blob/master/intro-to-pytorch/fc_model.py)\n",
    "- [PyTorch: Transfer learning tutorial](https://pytorch.org/tutorials/beginner/transfer_learning_tutorial.html)\n",
    "- [PyTorch: Finetuning Torchvision models](https://pytorch.org/tutorials/beginner/finetuning_torchvision_models_tutorial.html)\n",
    "- [Josh Bernhard: Deep Learning with PyTorch](https://medium.com/@josh_2774/deep-learning-with-pytorch-9574e74d17ad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FcNetwork(nn.Module):\n",
    "    '''\n",
    "    Builds a feedforward network with arbitrary hidden layers\n",
    "    with ReLU activation function and drop out\n",
    "\n",
    "    Note: Forward method returns logits (raw outputs)\n",
    "\n",
    "    Args:\n",
    "        input_size: integer, size of the input layer\n",
    "        output_size: integer, size of the output layer\n",
    "        hidden_layers: list of integers, the sizes of the hidden layers\n",
    "    '''\n",
    "    def __init__(self, input_size, output_size, hidden_layers=None, drop_p=0.5):\n",
    "\n",
    "        super().__init__()\n",
    "\n",
    "        # drop out probability attribute\n",
    "\n",
    "        # if hidden leayers are not requested\n",
    "        if (hidden_layers == None) or (hidden_layers == []):\n",
    "            self.drop_p = None\n",
    "            self.hidden_layers = None\n",
    "            self.output = nn.Linear(input_size, output_size)\n",
    "        else:\n",
    "            # hidden layers requested\n",
    "            # attribute drop out probability\n",
    "            self.drop_p = drop_p\n",
    "\n",
    "            # 1st hidden layer\n",
    "            self.hidden_layers = nn.ModuleList([nn.Linear(input_size, hidden_layers[0])])\n",
    "\n",
    "            # add a variable number of  more hidden layers\n",
    "            layer_sizes = zip(hidden_layers[:-1], hidden_layers[1:])\n",
    "            self.hidden_layers.extend([nn.Linear(in_features, out_features)\n",
    "                                      for in_features, out_features in layer_sizes])\n",
    "\n",
    "            # regularization\n",
    "            self.dropout = nn.Dropout(p=self.drop_p)\n",
    "\n",
    "            # output of the network\n",
    "            self.output = nn.Linear(hidden_layers[-1], output_size)\n",
    "\n",
    "    def forward(self, x):\n",
    "        '''\n",
    "        Forward pass trough network ,returns the ouput logits (raw outputs)\n",
    "        '''\n",
    "        # forward input trough hidden layers if they exists\n",
    "        if not (self.hidden_layers == None):\n",
    "            for layer in self.hidden_layers:\n",
    "                x = layer(x)\n",
    "                x = F.relu(x)\n",
    "                x = self.dropout(x)\n",
    "\n",
    "        # forward input trough last layer\n",
    "        output = self.output(x)\n",
    "\n",
    "        return output\n",
    "\n",
    "    def layer_sizes(self):\n",
    "        '''\n",
    "        Returns model architecture as list of layer sizes in string format.\n",
    "        Example of layer with 25k inputs, 2048 nodes of 1st hidden layer,\n",
    "        1024 of sencond, 512 of third and 102 outputs is equal to string\n",
    "        [25000, 2048, 1024, 512, 102]\n",
    "\n",
    "        Returns:\n",
    "            architecture: string as list of neural network layer layer_sizes\n",
    "        '''\n",
    "\n",
    "        layer_sizes = []\n",
    "        #  no hidden layers defined\n",
    "        if self.hidden_layers == None:\n",
    "            # gent # of inputs to output layer\n",
    "            layer_sizes.append(self.output.in_features)\n",
    "        #  hidden leayers defined\n",
    "        else:\n",
    "            # inputs to first hidden layer\n",
    "            layer_sizes.append(self.hidden_layers[0].in_features)\n",
    "            # cycle over hidden layers\n",
    "            for hidden_layer in self.hidden_layers:\n",
    "                # get hidden layer nodes\n",
    "                layer_sizes.append(hidden_layer.out_features)\n",
    "\n",
    "        # add # of outputs | classes | nodes of output layer\n",
    "        layer_sizes.append(self.output.out_features)\n",
    "\n",
    "        return str(layer_sizes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def freeze_model_params(model, feature_extract=True):\n",
    "    '''\n",
    "    Freeze model parameters for feature extraction type of transfer learning\n",
    "    \n",
    "    Args:\n",
    "        model: neural network model of nn.Module class or its child\n",
    "        feature_extract: transfer learning type feature extraction ro\n",
    "                         tunning, deafult: feature_extract=True\n",
    "    '''\n",
    "    if feature_extract:\n",
    "        for param in model.parameters():\n",
    "            param.requires_grad = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_model(model_name, num_classes, feature_extract=True, \n",
    "                     pretrained=True, hidden_layers=None, drop_p=0.2, model_id=None, class_to_idx=None):\n",
    "    '''\n",
    "    Initialize selected model for transfer learning\n",
    "    \n",
    "    note: following list of models is supported [vgg, resnet] \n",
    "          and can be further extended\n",
    "    \n",
    "    Args:\n",
    "        model_name: name of the model\n",
    "        num_classes: number of classes in the output of designed network\n",
    "        \n",
    "        feature_extract: transfer learning type feature extraction or\n",
    "                         tunning, default: feature_extract=True\n",
    "                         \n",
    "        pretrained: network weight initialization: pretrained or \n",
    "                    not pretrained, dafault: use_pretrained=True\n",
    "                    \n",
    "        hidden_layers: classifier architecture need to be fully connected network (n+2 layers)\n",
    "                              with drop out, defined as list of sizes of hidden layers:\n",
    "                              [num_hidden_layer_1, num_hidden_layer_2, ..., num_hidden_layer_n]\n",
    "                              example: [2048, 1024, 512]\n",
    "                              \n",
    "                              Note: input layer is defined by model name and output by num_classes\n",
    "        \n",
    "        drop_p: drop out probability\n",
    "        \n",
    "    Returns:\n",
    "        model: model adapted for transfer learning with initialized weights\n",
    "        input_size: required input_size of the model\n",
    "    '''\n",
    "    \n",
    "    # initialize returns\n",
    "    model = None\n",
    "    input_size = 0\n",
    "    if model_id == None: model_id = model_name\n",
    "    \n",
    "    if 'vgg' in model_name:\n",
    "        # initialize model\n",
    "        model = models.vgg11_bn(pretrained=pretrained)\n",
    "\n",
    "        # freeze model parameters in case of transfer learning type: feature extraction\n",
    "        freeze_model_params(model, feature_extract)\n",
    "\n",
    "        # get number of input nodes of the classifier laeyer to replace\n",
    "        in_features = model.classifier[0].in_features\n",
    "        \n",
    "        # rebuild model and remove last layer of the classifier\n",
    "        model.classifier = FcNetwork(in_features, num_classes, hidden_layers, drop_p=drop_p)\n",
    "         \n",
    "        # create attribute model name & id\n",
    "        model.name = model_name\n",
    "        model.id = model_id\n",
    "        \n",
    "        # create attribute storking mappings of class codes to indexes\n",
    "        model.class_to_idx = class_to_idx\n",
    "        \n",
    "        # define number of inputs the model was trained on\n",
    "        input_size = 224\n",
    "    \n",
    "    elif 'resnet' in model_name:\n",
    "        model = models.resnet50(pretrained=pretrained)\n",
    "        freeze_model_params(model, feature_extract) \n",
    "        in_features = model.fc.in_features\n",
    "        model.fc = FcNetwork(in_features, num_classes, hidden_layers, drop_p=drop_p)\n",
    "        model.name = model_name\n",
    "        model.id = model_id\n",
    "        model.class_to_idx = class_to_idx\n",
    "        input_size = 224\n",
    "    \n",
    "    else:\n",
    "        print('Invalid model name.')\n",
    "    \n",
    "    return model, input_size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NormalizeInverse(transforms.Normalize):\n",
    "    \"\"\"Reconstruct the normalized image by inverting normalization which was\n",
    "    given by mean: ``(M1,...,Mn)`` and std: ``(S1,..,Sn)`` for ``n`` channels.\n",
    "    This transform will invert each normalized channel of the input ``torch.*Tensor``\n",
    "    created by normalize transformation as ex. below:\n",
    "    ``input[channel] = (input[channel] - mean[channel]) / std[channel]``\n",
    "\n",
    "    .. note::\n",
    "        This transform acts out of place, i.e., it does not mutates the input tensor.\n",
    "\n",
    "    Args:\n",
    "        transform: instance of transform used to normalize image tensor\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, transform):\n",
    "        assert isinstance(transform, transforms.Normalize), \\\n",
    "        'transform need to be torchvision.transfroms.transforms.Normalize object'\n",
    "        mean = torch.tensor(transform.mean)\n",
    "        std = torch.tensor(transform.std)\n",
    "        std_inv = (1 / (std + 1e-7))\n",
    "        mean_inv = (-mean * std_inv)\n",
    "\n",
    "        super().__init__(mean=mean_inv, std=std_inv)\n",
    "\n",
    "    def __call__(self, tensor):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            tensor (Tensor): Normalized Tensor image of size (C, H, W) to be inverted.\n",
    "\n",
    "        Returns:\n",
    "            Tensor: Reconstructed Tensor image.\n",
    "        \"\"\"\n",
    "        return super().__call__(tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def explore_images(image, transform, title=None):\n",
    "    '''\n",
    "    Print reconstructed normalized images\n",
    "\n",
    "    Args:\n",
    "        image: Normalized tensor image of size (C, H, W)\n",
    "        transform - instance of transformation used to normalize image\n",
    "    '''\n",
    "\n",
    "    # reconstruct image\n",
    "    normalize_inv = NormalizeInverse(transform)\n",
    "    image = normalize_inv(image)\n",
    "\n",
    "    # transpose image from (C,L,W) to (L,W,C) and clip it for float RGB values <0,1>\n",
    "    image = image.numpy().transpose((1, 2, 0))\n",
    "    image = np.clip(image, 0, 1)\n",
    "\n",
    "    # print image\n",
    "    plt.imshow(image)\n",
    "    if title is not None:\n",
    "        plt.title(title)\n",
    "    plt.pause(0.001) # pause a bit so that plots are updated"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initializing network architectures for screening"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# INTIALIZE NETWORK ARCHITECTURES\n",
    "# select models\n",
    "net_names = ['vgg19_bn', 'resnet50']\n",
    "\n",
    "# number of classes\n",
    "num_classes = 102\n",
    "\n",
    "# type of transfer learning: feature extraction or tunning\n",
    "feature_extract = True\n",
    "\n",
    "# architecture of new classifier: just hidden layers sizes in the list\n",
    "hidden_layers = []\n",
    "\n",
    "# initialization of weights of the model: pre-trained or random\n",
    "pretrained = True\n",
    "\n",
    "# drop out probability\n",
    "drop_p = 0.5\n",
    "\n",
    "# initialize selected models for transfer learning\n",
    "nets = {net_name: initialize_model(net_name, num_classes, feature_extract, \n",
    "                                     pretrained, hidden_layers, drop_p)\n",
    "         for net_name in net_names}\n",
    "\n",
    "# input size to determine image preprocessing\n",
    "input_sizes = {net: nets[net][1] for net in nets}\n",
    "nets = {net: nets[net][0] for net in nets}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Image processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# IMAGE PROCESSING\n",
    "# datasets phases\n",
    "phases = ['train', 'valid', 'test']\n",
    "\n",
    "# data directories\n",
    "data_dir = 'flowers'\n",
    "\n",
    "# batch size for training\n",
    "batch_size = 32\n",
    "\n",
    "# image standardization\n",
    "avgs, stdevs = [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]\n",
    "\n",
    "# image resize\n",
    "resize = 256\n",
    "\n",
    "# image rotation\n",
    "rot = 30\n",
    "\n",
    "# input size\n",
    "# image processing for the training, validation, and testing for all models\n",
    "data_transforms = {net: {\n",
    "    phases[0]: transforms.Compose([\n",
    "        transforms.RandomRotation(rot),\n",
    "        transforms.RandomResizedCrop(input_sizes[net]),\n",
    "        transforms.RandomHorizontalFlip(),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize(avgs, stdevs)\n",
    "    ]),\n",
    "    phases[1]: transforms.Compose([\n",
    "        transforms.Resize(resize),\n",
    "        transforms.CenterCrop(input_sizes[net]),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize(avgs, stdevs)\n",
    "    ]),\n",
    "    phases[2]: transforms.Compose([\n",
    "        transforms.Resize(resize),\n",
    "        transforms.CenterCrop(input_sizes[net]),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize(avgs, stdevs)\n",
    "    ])}\n",
    "                   for net in nets\n",
    "                  }\n",
    "\n",
    "# load the datasets with ImageFolder\n",
    "image_datasets = {net: {\n",
    "    phase: datasets.ImageFolder(\n",
    "        os.path.join(data_dir, phase),data_transforms[net][phase]) \n",
    "    for phase in phases}\n",
    "                  for net in nets\n",
    "                 }\n",
    "\n",
    "# define the dataloaders\n",
    "dataloaders = {net: {\n",
    "    phase: torch.utils.data.DataLoader(\n",
    "        image_datasets[net][phase], batch_size=batch_size, shuffle=True)\n",
    "    for phase in phases}\n",
    "               for net in nets\n",
    "              }\n",
    "\n",
    "# explore datasets sizes\n",
    "dataset_sizes = {net: {\n",
    "    phase: len(image_datasets[net][phase]) for phase in phases}\n",
    "                 for net in nets\n",
    "                }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exploring Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Label mapping\n",
    "\n",
    "You'll also need to load in a mapping from category label to category name. You can find this in the file `cat_to_name.json`. It's a JSON object which you can read in with the [`json module`](https://docs.python.org/2/library/json.html). This will give you a dictionary mapping the integer encoded categories to the actual names of the flowers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "with open('cat_to_name.json', 'r') as f:\n",
    "    class_to_name = json.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'vgg19_bn': {'train': 6552, 'valid': 818, 'test': 819}, 'resnet50': {'train': 6552, 'valid': 818, 'test': 819}}\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f9465dcf8d0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# EXPLORING DATA\n",
    "# Data shape\n",
    "print(dataset_sizes)\n",
    "\n",
    "# explore dataset images\n",
    "# get a batch of training images\n",
    "images, categories = next(iter(dataloaders[net_names[0]][phases[0]]))\n",
    "\n",
    "# Make a grid of first n_images selected images in batch\n",
    "n_images = 4\n",
    "image_grid = torchvision.utils.make_grid(images[:n_images, :])\n",
    "\n",
    "# denormalize and print images\n",
    "explore_images(image_grid, transform=data_transforms[net_names[0]][phases[0]].transforms[-1],\n",
    "      title=[class_to_name[str(category)] for category in categories[:n_images].tolist()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Building and training the classifier\n",
    "\n",
    "Now that the data is ready, it's time to build and train the classifier. As usual, you should use one of the pretrained models from `torchvision.models` to get the image features. Build and train a new feed-forward classifier using those features.\n",
    "\n",
    "We're going to leave this part up to you. Refer to [the rubric](https://review.udacity.com/#!/rubrics/1663/view) for guidance on successfully completing this section. Things you'll need to do:\n",
    "\n",
    "* Load a [pre-trained network](http://pytorch.org/docs/master/torchvision/models.html) (If you need a starting point, the VGG networks work great and are straightforward to use)\n",
    "* Define a new, untrained feed-forward network as a classifier, using ReLU activations and dropout\n",
    "* Train the classifier layers using backpropagation using the pre-trained network to get the features\n",
    "* Track the loss and accuracy on the validation set to determine the best hyperparameters\n",
    "\n",
    "We've left a cell open for you below, but use as many as you need. Our advice is to break the problem up into smaller parts you can run separately. Check that each part is doing what you expect, then move on to the next. You'll likely find that as you work through each part, you'll need to go back and modify your previous code. This is totally normal!\n",
    "\n",
    "When training make sure you're updating only the weights of the feed-forward network. You should be able to get the validation accuracy above 70% if you build everything right. Make sure to try different hyperparameters (learning rate, units in the classifier, epochs, etc) to find the best model. Save those hyperparameters to use as default values in the next part of the project.\n",
    "\n",
    "One last important tip if you're using the workspace to run your code: To avoid having your workspace disconnect during the long-running tasks in this notebook, please read in the earlier page in this lesson called Intro to\n",
    "GPU Workspaces about Keeping Your Session Active. You'll want to include code from the workspace_utils.py module.\n",
    "\n",
    "**Note for Workspace users:** If your network is over 1 GB when saved as a checkpoint, there might be issues with saving backups in your workspace. Typically this happens with wide dense layers after the convolutional layers. If your saved checkpoint is larger than 1 GB (you can open a terminal and check with `ls -lh`), you should reduce the size of your hidden layers and train again."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dependencies\n",
    "This section includes also `save_model` method as it is needed to store model inmediately after trainin is finished in active session context manager to prevent lossing training data.\n",
    "\n",
    "Dependencies icludes following methods\n",
    "- `trian_model` method: trains neural network model\n",
    "- `params_to_update` method: returns generator of parameters to update during learning\n",
    "- `save_model` method: saves naural network model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model, dataloaders, criterion, optimizer, phases=['train', 'valid'], \n",
    "                scheduler=None, num_epochs=15, batch_ratio=1):\n",
    "    '''\n",
    "    Train neural network with arbitrary architecture, loss function, optimization algorithm, \n",
    "    adaptive learning rate and returns model with best accuracy\n",
    "    \n",
    "    Args:\n",
    "        model: model with arbitrary architecture of torch.nn module\n",
    "        dataloaders: dictionary of data loaders per learning phase,\n",
    "                     dataloader interates in batches trough data in each phase\n",
    "        criterion: loss fuction of torch.nn module\n",
    "        optimizer: optimization algorithm of torch.optim module\n",
    "        phases: list of learning phases one or some of ['train', 'valid']\n",
    "        sheduler: adpative learning rate sheduler of torch.optim module\n",
    "        num_epochs: number of epochs to train model on, default is 15\n",
    "        batch_ratio: iterates over bath_ration % of batches in dataset\n",
    "        \n",
    "    Returns:\n",
    "        model with updated weights corresponding to highest accuracy\n",
    "    '''\n",
    "\n",
    "    # debugging on batch results will be printed\n",
    "    debug_mode = False\n",
    "    \n",
    "    # frequency of printing results every x batch\n",
    "    print_every = 1\n",
    "    \n",
    "    # track training time\n",
    "    since = time.time()\n",
    "    \n",
    "    # track model settings and performance of each epoch\n",
    "    # list of setting and performance items\n",
    "    items = ['model_id', 'model', 'modification', 'learning rate', 'epoch', 'phase', 'acc', 'loss', 'time']\n",
    "    \n",
    "    # number of performance items \n",
    "    num_results = 3\n",
    "    \n",
    "    # create empty multi-column data frame to track history\n",
    "    col_hierarchy = pd.MultiIndex.from_tuples(\n",
    "        [('settings' if time_idx < (len(items) - num_results) else 'performance', item)\n",
    "         for time_idx, item in enumerate(items)])\n",
    "    \n",
    "    history = pd.DataFrame(columns=col_hierarchy)\n",
    "    \n",
    "    # store best model weights\n",
    "    best_model_wts = copy.deepcopy(model.state_dict())\n",
    "    \n",
    "    # initiate accuracy tracking\n",
    "    best_acc = 0.0\n",
    "    \n",
    "    # print model name\n",
    "    print_model = 'model: {} ---> id: {}'.format(model.name, model.id)\n",
    "    print(print_model)\n",
    "    print('*' * len(print_model))\n",
    "    \n",
    "    # model training and validation\n",
    "    for epoch in tqdm(range(num_epochs)):\n",
    "        # track epoch running time\n",
    "        epoch_since = time.time()\n",
    "\n",
    "        # notify user on running epoch\n",
    "        print_epoch = 'epoch {}/{}'.format(epoch + 1, num_epochs)\n",
    "        print(print_epoch)\n",
    "        print('-' * len(print_epoch))\n",
    "\n",
    "        # Cycles trough epoch training and validation phase\n",
    "        for phase in phases:\n",
    "            # monitor phase time\n",
    "            phase_since = time.time()\n",
    "            \n",
    "            if phase == 'train':\n",
    "                # update learning rate if using sheduler\n",
    "                if not (scheduler == None):\n",
    "                    scheduler.step()\n",
    "                model.train()    # set model in training mode              \n",
    "            else:\n",
    "                model.eval()    # set model in evaluation mode\n",
    "\n",
    "            # reset loss, corrects and running time from previous epoch\n",
    "            running_loss = 0.0\n",
    "            running_corrects = 0\n",
    "            running_time = 0\n",
    "            \n",
    "            # reset running number of samples \n",
    "            running_size = 0\n",
    "\n",
    "            # iterate over n batches in dataset\n",
    "            num_batches = max(1, int(len(dataloaders[phase]) * batch_ratio))\n",
    "            for batch, (inputs, labels) in zip(range(num_batches), dataloaders[phase]):\n",
    "                \n",
    "                # trace batch time in debug mode\n",
    "                if debug_mode: batch_since = time.time()\n",
    "                    \n",
    "                # update number of samples\n",
    "                # import ipdb; ipdb.set_trace()\n",
    "                running_size += inputs.size(0)\n",
    "                \n",
    "                # transfer data to gpu if enabled\n",
    "                inputs, labels = inputs.to(device), labels.to(device)\n",
    "\n",
    "                # zero the parameter gradients from previous batch\n",
    "                optimizer.zero_grad()\n",
    "\n",
    "                # track operations on model parameters to calculate gradient \n",
    "                # only for training phase\n",
    "                with torch.set_grad_enabled(phase == 'train'):\n",
    "                    # calculate model output\n",
    "                    outputs = model(inputs)\n",
    "\n",
    "                    # calculate loss\n",
    "                    loss = criterion(outputs, labels)\n",
    "\n",
    "                    # calculate top k prediction\n",
    "                    _, preds = outputs.topk(1, dim=1)\n",
    "\n",
    "                    # backward step, calculate and update weights in training phase\n",
    "                    if phase == 'train':\n",
    "                        loss.backward()\n",
    "                        optimizer.step()\n",
    "\n",
    "                # accumulate loss, number of correct clasifications and running time \n",
    "                # in batch and phase\n",
    "                running_loss += loss.item() * inputs.size(0)\n",
    "                running_corrects += torch.sum(preds == labels.view(preds.shape))\n",
    "                \n",
    "                # with debug on, print batch results\n",
    "                if debug_mode and (phase == 'train') and ((batch + 1) % print_every == 0) :\n",
    "                    # calculate batch time\n",
    "                    batch_time = time.time() - batch_since\n",
    "                    \n",
    "                    # calculate average running batch loss and accuracy for phase\n",
    "                    batch_loss = loss.item()\n",
    "                    batch_acc = torch.sum(preds == labels.view(preds.shape)).double() / inputs.size(0)\n",
    "                    \n",
    "                    # print batch results per phase\n",
    "                    print('{} batch {:3}/{:3} loss: {:.4f} Acc: {:.4f} Time:{:.0f}s'\n",
    "                         .format(phase, batch+1, len(dataloaders[phase]),\n",
    "                                batch_loss, batch_acc, batch_time))\n",
    "\n",
    "            # calculate epoch loss and accuracy for phase\n",
    "            epoch_phase_loss = running_loss / running_size\n",
    "            epoch_phase_acc = (running_corrects.double() / running_size).item()\n",
    "            epoch_phase_time = time.time() - phase_since\n",
    "\n",
    "\n",
    "            # print epoch results per phase\n",
    "            print('{} loss: {:.4f} acc: {:.4f} time: {:.0f}m {:.0f}s'\n",
    "                  .format(phase, epoch_phase_loss, epoch_phase_acc,\n",
    "                         epoch_phase_time // 60, epoch_phase_time % 60))\n",
    "\n",
    "            # store model settings and epoch performance\n",
    "            # learning rate\n",
    "            if scheduler == None : \n",
    "                lr = optimizer.param_groups[0]['lr']\n",
    "            else: \n",
    "                lr = str(type(scheduler)).split('.')[-1].rstrip(\"'>\")\n",
    "            \n",
    "            # consolidate settings & performance\n",
    "            epoch_phase_result = [model.id, model.name, list(model.children())[-1].layer_sizes(), lr,\n",
    "                                  int(epoch+1), phase, epoch_phase_acc, epoch_phase_loss, epoch_phase_time]\n",
    "            epoch_phase_result = pd.DataFrame([epoch_phase_result], columns = col_hierarchy)\n",
    "            \n",
    "            # append settings & epoch results to dataframe\n",
    "            history = history.append(epoch_phase_result, ignore_index=True)\n",
    "\n",
    "            # store weights if validation accuracy is best\n",
    "            if phase == 'valid' and epoch_phase_acc > best_acc:\n",
    "                best_acc = epoch_phase_acc\n",
    "                best_model_wts = copy.deepcopy(model.state_dict())\n",
    "\n",
    "        # ad space after epoch results\n",
    "        print()\n",
    "        \n",
    "    # record and print training time\n",
    "    time_elapsed = time.time() - since\n",
    "    print('Training complete in {:.0f}m {:.0f}s'.format(\n",
    "        time_elapsed // 60, time_elapsed % 60))        \n",
    "        \n",
    "    # print best validation accuracy  \n",
    "    print('Best val Acc: {:.4f}'.format(best_acc))\n",
    "    print('\\n\\n')\n",
    "    return model, history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def params_to_update(model_params):\n",
    "    '''\n",
    "    Returns model parameters which will be tuned during training\n",
    "    \n",
    "    Arg:\n",
    "        model_params: neural network model parameters as generator\n",
    "                      Note: use nn.Module.parameters()\n",
    "    Returns: \n",
    "        generator of parameters to be updated during training\n",
    "    '''\n",
    "    \n",
    "    for param in model_params:\n",
    "        if param.requires_grad == True:\n",
    "            yield param"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_model(model, optimizer=None, scheduler=None, train_history=None, path='checkpoint.pth'):\n",
    "    '''\n",
    "    Save pytorch model for inference and/or resuming training. \n",
    "\n",
    "    Args:\n",
    "        model: any instance of pytorch.models where last layer is adapted\n",
    "               using FcNetwork class\n",
    "\n",
    "        optimizer: any optimization algorithm of pytorch.optim class,\n",
    "                   use only for resuming training purpose, default None\n",
    "        sheduler: any learning rate sheduler nn.optim.lr_sheduler class\n",
    "                  us enly for resuming training purpose if it was used, \n",
    "                  defulat None\n",
    "        train_history: any other training history it need to be saved\n",
    "        path: path and file name, default 'checkpoint.pth'\n",
    "\n",
    "    Returns:\n",
    "        saved model file on defined path location               \n",
    "    '''\n",
    "    # reference to classifier (last) module of the model\n",
    "    classifier = list(model.children())[-1]\n",
    "    \n",
    "    # save best model\n",
    "    torch.save({'model':\n",
    "                {'id': model.id,\n",
    "                 'name': model.name,\n",
    "                 'num_classes': classifier.output.out_features,\n",
    "                 'feature_extract': ~np.all([param.requires_grad for param in model.parameters()]),\n",
    "                 'hidden_layers': None if classifier.hidden_layers == None else\n",
    "                                  [layer.out_features for layer in classifier.hidden_layers],\n",
    "                 'dropout_prob': classifier.drop_p,\n",
    "                 'state_dict': model.state_dict(),\n",
    "                 'class_to_idx': model.class_to_idx\n",
    "                },\n",
    "                'optimizer': None if optimizer == None else{\n",
    "                    'state_dict': optimizer.state_dict()},\n",
    "                'lr_scheduler': None if scheduler == None else {\n",
    "                    'step_size': scheduler.step_size,\n",
    "                    'state_dict': scheduler.state_dict()},\n",
    "                'train_history': train_history\n",
    "               },\n",
    "               path\n",
    "              )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Screening neural network models\n",
    "I have decided to screen two models `vgg19_bn` and `resnet50` as feature extractors and modify their classifier to flower classification problem of 102 classes. Training is done on 30% of training and validation data to save time and resources. The full scale training and hyper-parameter tuning will be done on selected screened model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use gpu for training if enabled\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# MODEL SCREENING\n",
    "# ----------------\n",
    "\n",
    "# TRAINING PRERQUISITES\n",
    "# number of epochs\n",
    "num_epochs = 10\n",
    "\n",
    "# define start learning rate\n",
    "start_lr = 0.001\n",
    "\n",
    "# define loss fuction\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "# get learning parameters and define optimization algorithm\n",
    "optimizers = {net: optim.Adam(params_to_update(nets[net].parameters()), lr=start_lr)\n",
    "              for net in nets}\n",
    "\n",
    "# learning rate adaptation\n",
    "lr_adapt = False     # flag to turn on flexible lr\n",
    "end_lr = 0.00001     # learning rate of last epoch\n",
    "step_size = 1        # nummber of epochs to decay learning rate by gamma\n",
    "\n",
    "# lr decay parameter end_lr = start_lr*gamma**(epochs/step_size)\n",
    "gamma = (end_lr / start_lr) ** (step_size / num_epochs)    \n",
    "\n",
    "# initialize shedulers\n",
    "lr_schedulers = {\n",
    "    net: lr_scheduler.StepLR(optimizers[net], step_size=1, gamma=gamma) if lr_adapt else None\n",
    "    for net in nets}\n",
    "\n",
    "# train all models on x % of data\n",
    "batch_ratio = 0.3    # 30% of data\n",
    "\n",
    "# move the networks to gpu if enabled\n",
    "for net in nets:\n",
    "    net = nets[net].to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model: vgg19_bn ---> id: vgg19_bn\n",
      "*********************************\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a772e12d4e5044f2b5e4ed04ca57fa5c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/html": [
       "<p>Failed to display Jupyter Widget of type <code>HBox</code>.</p>\n",
       "<p>\n",
       "  If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n",
       "  that the widgets JavaScript is still loading. If this message persists, it\n",
       "  likely means that the widgets JavaScript library is either not installed or\n",
       "  not enabled. See the <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n",
       "  Widgets Documentation</a> for setup instructions.\n",
       "</p>\n",
       "<p>\n",
       "  If you're reading this message in another frontend (for example, a static\n",
       "  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n",
       "  it may mean that your frontend doesn't currently support widgets.\n",
       "</p>\n"
      ],
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=10), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 1/10\n",
      "----------\n",
      "train loss: 3.2125 acc: 0.3443 time: 0m 35s\n",
      "valid loss: 1.3359 acc: 0.7009 time: 0m 4s\n",
      "\n",
      "epoch 2/10\n",
      "----------\n",
      "train loss: 1.4347 acc: 0.6455 time: 0m 34s\n",
      "valid loss: 0.6799 acc: 0.7946 time: 0m 4s\n",
      "\n",
      "epoch 3/10\n",
      "----------\n",
      "train loss: 1.1291 acc: 0.7100 time: 0m 34s\n",
      "valid loss: 0.5638 acc: 0.8393 time: 0m 4s\n",
      "\n",
      "epoch 4/10\n",
      "----------\n",
      "train loss: 0.8856 acc: 0.7700 time: 0m 33s\n",
      "valid loss: 0.6005 acc: 0.8616 time: 0m 4s\n",
      "\n",
      "epoch 5/10\n",
      "----------\n",
      "train loss: 0.7893 acc: 0.7869 time: 0m 33s\n",
      "valid loss: 0.3423 acc: 0.8929 time: 0m 4s\n",
      "\n",
      "epoch 6/10\n",
      "----------\n",
      "train loss: 0.8243 acc: 0.7889 time: 0m 32s\n",
      "valid loss: 0.5340 acc: 0.8750 time: 0m 4s\n",
      "\n",
      "epoch 7/10\n",
      "----------\n",
      "train loss: 0.8189 acc: 0.7894 time: 0m 32s\n",
      "valid loss: 0.4094 acc: 0.8750 time: 0m 4s\n",
      "\n",
      "epoch 8/10\n",
      "----------\n",
      "train loss: 0.7085 acc: 0.8186 time: 0m 32s\n",
      "valid loss: 0.5593 acc: 0.8839 time: 0m 4s\n",
      "\n",
      "epoch 9/10\n",
      "----------\n",
      "train loss: 0.6532 acc: 0.8330 time: 0m 32s\n",
      "valid loss: 0.3512 acc: 0.8839 time: 0m 4s\n",
      "\n",
      "epoch 10/10\n",
      "-----------\n",
      "train loss: 0.7755 acc: 0.8033 time: 0m 32s\n",
      "valid loss: 0.4301 acc: 0.8705 time: 0m 4s\n",
      "\n",
      "\n",
      "Training complete in 6m 7s\n",
      "Best val Acc: 0.8929\n",
      "\n",
      "\n",
      "\n",
      "model: resnet50 ---> id: resnet50\n",
      "*********************************\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "54572c50df6648b0814b1089d7171a94",
       "version_major": 2,
       "version_minor": 0
      },
      "text/html": [
       "<p>Failed to display Jupyter Widget of type <code>HBox</code>.</p>\n",
       "<p>\n",
       "  If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n",
       "  that the widgets JavaScript is still loading. If this message persists, it\n",
       "  likely means that the widgets JavaScript library is either not installed or\n",
       "  not enabled. See the <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n",
       "  Widgets Documentation</a> for setup instructions.\n",
       "</p>\n",
       "<p>\n",
       "  If you're reading this message in another frontend (for example, a static\n",
       "  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n",
       "  it may mean that your frontend doesn't currently support widgets.\n",
       "</p>\n"
      ],
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=10), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 1/10\n",
      "----------\n",
      "train loss: 3.9693 acc: 0.2264 time: 0m 32s\n",
      "valid loss: 2.4442 acc: 0.5848 time: 0m 4s\n",
      "\n",
      "epoch 2/10\n",
      "----------\n",
      "train loss: 2.3110 acc: 0.5528 time: 0m 32s\n",
      "valid loss: 1.4527 acc: 0.7232 time: 0m 4s\n",
      "\n",
      "epoch 3/10\n",
      "----------\n",
      "train loss: 1.5911 acc: 0.6885 time: 0m 32s\n",
      "valid loss: 1.0011 acc: 0.8036 time: 0m 4s\n",
      "\n",
      "epoch 4/10\n",
      "----------\n",
      "train loss: 1.2376 acc: 0.7572 time: 0m 32s\n",
      "valid loss: 0.7555 acc: 0.8348 time: 0m 4s\n",
      "\n",
      "epoch 5/10\n",
      "----------\n",
      "train loss: 1.0138 acc: 0.7910 time: 0m 32s\n",
      "valid loss: 0.7040 acc: 0.8259 time: 0m 4s\n",
      "\n",
      "epoch 6/10\n",
      "----------\n",
      "train loss: 0.9312 acc: 0.7869 time: 0m 33s\n",
      "valid loss: 0.5364 acc: 0.8884 time: 0m 4s\n",
      "\n",
      "epoch 7/10\n",
      "----------\n",
      "train loss: 0.8188 acc: 0.8258 time: 0m 33s\n",
      "valid loss: 0.4823 acc: 0.8973 time: 0m 4s\n",
      "\n",
      "epoch 8/10\n",
      "----------\n",
      "train loss: 0.7738 acc: 0.8274 time: 0m 33s\n",
      "valid loss: 0.4943 acc: 0.8750 time: 0m 4s\n",
      "\n",
      "epoch 9/10\n",
      "----------\n",
      "train loss: 0.7128 acc: 0.8289 time: 0m 33s\n",
      "valid loss: 0.4328 acc: 0.8839 time: 0m 4s\n",
      "\n",
      "epoch 10/10\n",
      "-----------\n",
      "train loss: 0.7096 acc: 0.8330 time: 0m 32s\n",
      "valid loss: 0.4204 acc: 0.8839 time: 0m 4s\n",
      "\n",
      "\n",
      "Training complete in 5m 59s\n",
      "Best val Acc: 0.8973\n",
      "\n",
      "\n",
      "\n",
      "Model: resnet50 with id: resnet50 saved to checkpoint.pth.\n"
     ]
    }
   ],
   "source": [
    "# RUN TRAINING\n",
    "# keep workspace active\n",
    "with active_session():\n",
    "    trained_nets = {net: train_model(model=nets[net], dataloaders = dataloaders[net], \n",
    "                                            criterion=criterion, optimizer=optimizers[net], \n",
    "                                            scheduler=lr_schedulers[net], num_epochs=num_epochs, batch_ratio = batch_ratio)\n",
    "                    for net in nets}\n",
    "\n",
    "    # extract training output\n",
    "    # models\n",
    "    nets = {net: trained_nets[net][0] for net in nets}\n",
    "\n",
    "    # training history\n",
    "    hists = {net: trained_nets[net][1] for net in nets}\n",
    "    results = pd.DataFrame([])\n",
    "\n",
    "    # merge models training history\n",
    "    for hist in hists:\n",
    "        results = results.append(hists[hist], ignore_index=True)\n",
    "\n",
    "    # SAVE SELECTED SCREENED MODEL\n",
    "    # select best model after screening\n",
    "    # indentify index of model with highest validation accuracy\n",
    "    best_scr_model_idx = results[results[('settings', 'phase')] == 'valid'][('performance', 'acc')].idxmax()\n",
    "    best_scr_model_name = results.iloc[best_scr_model_idx][('settings', 'model')]\n",
    "    best_scr_model = nets[best_scr_model_name]\n",
    "\n",
    "    # save model\n",
    "    path = 'checkpoint_ipynb.pth'\n",
    "    save_model(best_scr_model, optimizers[best_scr_model_name], \n",
    "               lr_schedulers[best_scr_model_name], hists[best_scr_model_name], path=path)\n",
    "\n",
    "    print('Model: {} with id: {} saved to {}.'\n",
    "          .format(best_scr_model.name, best_scr_model.id, path))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f946555cc50>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th colspan=\"6\" halign=\"left\">settings</th>\n",
       "      <th colspan=\"3\" halign=\"left\">performance</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>model_id</th>\n",
       "      <th>model</th>\n",
       "      <th>modification</th>\n",
       "      <th>learning rate</th>\n",
       "      <th>epoch</th>\n",
       "      <th>phase</th>\n",
       "      <th>acc</th>\n",
       "      <th>loss</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>33</th>\n",
       "      <td>resnet50</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>7</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.897321</td>\n",
       "      <td>0.482325</td>\n",
       "      <td>3.723569</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>[25088, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>5</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.892857</td>\n",
       "      <td>0.342283</td>\n",
       "      <td>3.783678</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>31</th>\n",
       "      <td>resnet50</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>6</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.888393</td>\n",
       "      <td>0.536432</td>\n",
       "      <td>3.665525</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>[25088, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>8</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.883929</td>\n",
       "      <td>0.559298</td>\n",
       "      <td>3.748363</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>[25088, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>9</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.883929</td>\n",
       "      <td>0.351197</td>\n",
       "      <td>3.749164</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>37</th>\n",
       "      <td>resnet50</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>9</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.883929</td>\n",
       "      <td>0.432817</td>\n",
       "      <td>3.778286</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>39</th>\n",
       "      <td>resnet50</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>10</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.883929</td>\n",
       "      <td>0.420413</td>\n",
       "      <td>3.703529</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>[25088, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>6</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.875000</td>\n",
       "      <td>0.534018</td>\n",
       "      <td>3.764481</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>[25088, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>7</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.875000</td>\n",
       "      <td>0.409373</td>\n",
       "      <td>3.719020</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35</th>\n",
       "      <td>resnet50</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>8</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.875000</td>\n",
       "      <td>0.494273</td>\n",
       "      <td>3.734125</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>[25088, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>10</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.870536</td>\n",
       "      <td>0.430141</td>\n",
       "      <td>3.596467</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>[25088, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>4</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.861607</td>\n",
       "      <td>0.600466</td>\n",
       "      <td>3.946275</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>[25088, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>3</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.839286</td>\n",
       "      <td>0.563759</td>\n",
       "      <td>3.910540</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>27</th>\n",
       "      <td>resnet50</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>4</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.834821</td>\n",
       "      <td>0.755453</td>\n",
       "      <td>3.755396</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>resnet50</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>5</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.825893</td>\n",
       "      <td>0.703971</td>\n",
       "      <td>3.765746</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>resnet50</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>3</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.803571</td>\n",
       "      <td>1.001087</td>\n",
       "      <td>3.727074</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>[25088, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>2</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.794643</td>\n",
       "      <td>0.679851</td>\n",
       "      <td>4.034048</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>resnet50</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>2</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.723214</td>\n",
       "      <td>1.452731</td>\n",
       "      <td>3.747528</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>[25088, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>1</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.700893</td>\n",
       "      <td>1.335907</td>\n",
       "      <td>4.112132</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>resnet50</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>1</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.584821</td>\n",
       "      <td>2.444222</td>\n",
       "      <td>3.768661</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>[25088, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>9</td>\n",
       "      <td>train</td>\n",
       "      <td>0.832992</td>\n",
       "      <td>0.653214</td>\n",
       "      <td>31.818843</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>38</th>\n",
       "      <td>resnet50</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>10</td>\n",
       "      <td>train</td>\n",
       "      <td>0.832992</td>\n",
       "      <td>0.709636</td>\n",
       "      <td>31.811088</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>resnet50</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>9</td>\n",
       "      <td>train</td>\n",
       "      <td>0.828893</td>\n",
       "      <td>0.712841</td>\n",
       "      <td>32.515746</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>34</th>\n",
       "      <td>resnet50</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>8</td>\n",
       "      <td>train</td>\n",
       "      <td>0.827357</td>\n",
       "      <td>0.773838</td>\n",
       "      <td>32.522347</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>32</th>\n",
       "      <td>resnet50</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>7</td>\n",
       "      <td>train</td>\n",
       "      <td>0.825820</td>\n",
       "      <td>0.818847</td>\n",
       "      <td>32.728990</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>[25088, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>8</td>\n",
       "      <td>train</td>\n",
       "      <td>0.818648</td>\n",
       "      <td>0.708491</td>\n",
       "      <td>32.020655</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>[25088, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>10</td>\n",
       "      <td>train</td>\n",
       "      <td>0.803279</td>\n",
       "      <td>0.775542</td>\n",
       "      <td>31.603678</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>resnet50</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>5</td>\n",
       "      <td>train</td>\n",
       "      <td>0.790984</td>\n",
       "      <td>1.013771</td>\n",
       "      <td>31.705526</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>[25088, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>7</td>\n",
       "      <td>train</td>\n",
       "      <td>0.789447</td>\n",
       "      <td>0.818887</td>\n",
       "      <td>32.391350</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>[25088, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>6</td>\n",
       "      <td>train</td>\n",
       "      <td>0.788934</td>\n",
       "      <td>0.824332</td>\n",
       "      <td>32.285948</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>[25088, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>5</td>\n",
       "      <td>train</td>\n",
       "      <td>0.786885</td>\n",
       "      <td>0.789305</td>\n",
       "      <td>32.649554</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>30</th>\n",
       "      <td>resnet50</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>6</td>\n",
       "      <td>train</td>\n",
       "      <td>0.786885</td>\n",
       "      <td>0.931194</td>\n",
       "      <td>32.646976</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>[25088, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>4</td>\n",
       "      <td>train</td>\n",
       "      <td>0.769980</td>\n",
       "      <td>0.885573</td>\n",
       "      <td>32.800032</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>resnet50</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>4</td>\n",
       "      <td>train</td>\n",
       "      <td>0.757172</td>\n",
       "      <td>1.237630</td>\n",
       "      <td>31.995297</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>[25088, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>3</td>\n",
       "      <td>train</td>\n",
       "      <td>0.710041</td>\n",
       "      <td>1.129055</td>\n",
       "      <td>33.526131</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>resnet50</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>3</td>\n",
       "      <td>train</td>\n",
       "      <td>0.688525</td>\n",
       "      <td>1.591076</td>\n",
       "      <td>31.790914</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>[25088, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>2</td>\n",
       "      <td>train</td>\n",
       "      <td>0.645492</td>\n",
       "      <td>1.434746</td>\n",
       "      <td>34.313171</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>resnet50</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>2</td>\n",
       "      <td>train</td>\n",
       "      <td>0.552766</td>\n",
       "      <td>2.310980</td>\n",
       "      <td>31.876109</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>vgg19_bn</td>\n",
       "      <td>[25088, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>1</td>\n",
       "      <td>train</td>\n",
       "      <td>0.344262</td>\n",
       "      <td>3.212470</td>\n",
       "      <td>35.474383</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>resnet50</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>1</td>\n",
       "      <td>train</td>\n",
       "      <td>0.226434</td>\n",
       "      <td>3.969340</td>\n",
       "      <td>31.833773</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    settings                                                    performance  \\\n",
       "    model_id     model  modification learning rate epoch  phase         acc   \n",
       "33  resnet50  resnet50   [2048, 102]         0.001     7  valid    0.897321   \n",
       "9   vgg19_bn  vgg19_bn  [25088, 102]         0.001     5  valid    0.892857   \n",
       "31  resnet50  resnet50   [2048, 102]         0.001     6  valid    0.888393   \n",
       "15  vgg19_bn  vgg19_bn  [25088, 102]         0.001     8  valid    0.883929   \n",
       "17  vgg19_bn  vgg19_bn  [25088, 102]         0.001     9  valid    0.883929   \n",
       "37  resnet50  resnet50   [2048, 102]         0.001     9  valid    0.883929   \n",
       "39  resnet50  resnet50   [2048, 102]         0.001    10  valid    0.883929   \n",
       "11  vgg19_bn  vgg19_bn  [25088, 102]         0.001     6  valid    0.875000   \n",
       "13  vgg19_bn  vgg19_bn  [25088, 102]         0.001     7  valid    0.875000   \n",
       "35  resnet50  resnet50   [2048, 102]         0.001     8  valid    0.875000   \n",
       "19  vgg19_bn  vgg19_bn  [25088, 102]         0.001    10  valid    0.870536   \n",
       "7   vgg19_bn  vgg19_bn  [25088, 102]         0.001     4  valid    0.861607   \n",
       "5   vgg19_bn  vgg19_bn  [25088, 102]         0.001     3  valid    0.839286   \n",
       "27  resnet50  resnet50   [2048, 102]         0.001     4  valid    0.834821   \n",
       "29  resnet50  resnet50   [2048, 102]         0.001     5  valid    0.825893   \n",
       "25  resnet50  resnet50   [2048, 102]         0.001     3  valid    0.803571   \n",
       "3   vgg19_bn  vgg19_bn  [25088, 102]         0.001     2  valid    0.794643   \n",
       "23  resnet50  resnet50   [2048, 102]         0.001     2  valid    0.723214   \n",
       "1   vgg19_bn  vgg19_bn  [25088, 102]         0.001     1  valid    0.700893   \n",
       "21  resnet50  resnet50   [2048, 102]         0.001     1  valid    0.584821   \n",
       "16  vgg19_bn  vgg19_bn  [25088, 102]         0.001     9  train    0.832992   \n",
       "38  resnet50  resnet50   [2048, 102]         0.001    10  train    0.832992   \n",
       "36  resnet50  resnet50   [2048, 102]         0.001     9  train    0.828893   \n",
       "34  resnet50  resnet50   [2048, 102]         0.001     8  train    0.827357   \n",
       "32  resnet50  resnet50   [2048, 102]         0.001     7  train    0.825820   \n",
       "14  vgg19_bn  vgg19_bn  [25088, 102]         0.001     8  train    0.818648   \n",
       "18  vgg19_bn  vgg19_bn  [25088, 102]         0.001    10  train    0.803279   \n",
       "28  resnet50  resnet50   [2048, 102]         0.001     5  train    0.790984   \n",
       "12  vgg19_bn  vgg19_bn  [25088, 102]         0.001     7  train    0.789447   \n",
       "10  vgg19_bn  vgg19_bn  [25088, 102]         0.001     6  train    0.788934   \n",
       "8   vgg19_bn  vgg19_bn  [25088, 102]         0.001     5  train    0.786885   \n",
       "30  resnet50  resnet50   [2048, 102]         0.001     6  train    0.786885   \n",
       "6   vgg19_bn  vgg19_bn  [25088, 102]         0.001     4  train    0.769980   \n",
       "26  resnet50  resnet50   [2048, 102]         0.001     4  train    0.757172   \n",
       "4   vgg19_bn  vgg19_bn  [25088, 102]         0.001     3  train    0.710041   \n",
       "24  resnet50  resnet50   [2048, 102]         0.001     3  train    0.688525   \n",
       "2   vgg19_bn  vgg19_bn  [25088, 102]         0.001     2  train    0.645492   \n",
       "22  resnet50  resnet50   [2048, 102]         0.001     2  train    0.552766   \n",
       "0   vgg19_bn  vgg19_bn  [25088, 102]         0.001     1  train    0.344262   \n",
       "20  resnet50  resnet50   [2048, 102]         0.001     1  train    0.226434   \n",
       "\n",
       "                         \n",
       "        loss       time  \n",
       "33  0.482325   3.723569  \n",
       "9   0.342283   3.783678  \n",
       "31  0.536432   3.665525  \n",
       "15  0.559298   3.748363  \n",
       "17  0.351197   3.749164  \n",
       "37  0.432817   3.778286  \n",
       "39  0.420413   3.703529  \n",
       "11  0.534018   3.764481  \n",
       "13  0.409373   3.719020  \n",
       "35  0.494273   3.734125  \n",
       "19  0.430141   3.596467  \n",
       "7   0.600466   3.946275  \n",
       "5   0.563759   3.910540  \n",
       "27  0.755453   3.755396  \n",
       "29  0.703971   3.765746  \n",
       "25  1.001087   3.727074  \n",
       "3   0.679851   4.034048  \n",
       "23  1.452731   3.747528  \n",
       "1   1.335907   4.112132  \n",
       "21  2.444222   3.768661  \n",
       "16  0.653214  31.818843  \n",
       "38  0.709636  31.811088  \n",
       "36  0.712841  32.515746  \n",
       "34  0.773838  32.522347  \n",
       "32  0.818847  32.728990  \n",
       "14  0.708491  32.020655  \n",
       "18  0.775542  31.603678  \n",
       "28  1.013771  31.705526  \n",
       "12  0.818887  32.391350  \n",
       "10  0.824332  32.285948  \n",
       "8   0.789305  32.649554  \n",
       "30  0.931194  32.646976  \n",
       "6   0.885573  32.800032  \n",
       "26  1.237630  31.995297  \n",
       "4   1.129055  33.526131  \n",
       "24  1.591076  31.790914  \n",
       "2   1.434746  34.313171  \n",
       "22  2.310980  31.876109  \n",
       "0   3.212470  35.474383  \n",
       "20  3.969340  31.833773  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# PRINT TRAINING OVERVIEW\n",
    "# stack results for easy printing    \n",
    "stacked_results = pd.melt(results, id_vars=[*results['settings'].columns],\n",
    "                          var_name='param', value_name='param_value', col_level=1)\n",
    "\n",
    "# print results charts\n",
    "g = sns.FacetGrid(stacked_results, col='param', row='phase', hue='model_id', \n",
    "                  sharex=True, sharey=False)\n",
    "g.map(plt.plot, 'epoch', 'param_value', linestyle='-', marker='o')\n",
    "plt.subplots_adjust(top=0.9)\n",
    "plt.suptitle('Model Screening Results')\n",
    "plt.legend(bbox_to_anchor=(1.04,0), loc='lower left', borderaxespad=0);\n",
    "plt.show()\n",
    "\n",
    "# print results table sorted by validation accuracy\n",
    "display(results.sort_values([('settings', 'phase'),('performance', 'acc')], axis=0, ascending=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tunning hyper-parameters of screened model\n",
    "Model `resenet50` learns slower than model 'vgg19_bn' till epoch 6, but reaches in average higher accuracy from epoch 6 onward. It also reached highest validation accuracy and in average lower prediction time, which can be benefitial in production environment. This model will be further used for tuning using whole training and validation dataset.\n",
    "\n",
    "The number of hidden layers in classifier and learning rate will be further tunned with following grid:\n",
    "\n",
    "| Run \t| Model \t| Hidden Layers \t| Learning Rate \t|\n",
    "|-----\t|-------\t|---------------\t|---------------\t|\n",
    "| 1   \t| TBD   \t| None          \t| 0.001         \t|\n",
    "| 2   \t| TBD   \t| None          \t| StepLR        \t|\n",
    "| 3   \t| TBD   \t| [1024, 512]      \t| 0.001         \t|\n",
    "| 4   \t| TBD   \t| [1024, 512]      \t| StepLR        \t|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dependences\n",
    "This section includes `load_model` method which enables to load selected prescreened model and find out model name to build on further training and tuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_model(path='checkpoint.pth', mode='valid', device='cpu', pretrained=True):\n",
    "    '''\n",
    "        Load Model for inference or further training\n",
    "        \n",
    "        Args:\n",
    "            mode: load mode: inference = 'valid', default: training = 'train'\n",
    "            device: device to load model to: 'gpu' or 'cpu', default: 'cpu'\n",
    "            pretrained: True if we want to keep trained parameters, False to\n",
    "                        initialize them randomly\n",
    "        \n",
    "        Returns:\n",
    "            model: intialized model of class torch.models\n",
    "            optimizer: initialized optimizer used for tranining\n",
    "            sheduler: initialized learning rate sheduler if it was used for training\n",
    "            history: history of the last training\n",
    "        \n",
    "        Note: last tree items are only returned in traning mode\n",
    "    '''\n",
    "    \n",
    "    # load checkpoint\n",
    "    checkpoint = torch.load(path, map_location=device)\n",
    "    \n",
    "    # initialize model\n",
    "    model, _ = initialize_model(\n",
    "        checkpoint['model']['name'],\n",
    "        checkpoint['model']['num_classes'],\n",
    "        checkpoint['model']['feature_extract'],\n",
    "        pretrained,\n",
    "        checkpoint['model']['hidden_layers'],\n",
    "        checkpoint['model']['dropout_prob'],\n",
    "        checkpoint['model']['id'])\n",
    "    \n",
    "    # restore model parameters\n",
    "    model.load_state_dict(checkpoint['model']['state_dict'])\n",
    "    \n",
    "    # restore mapping of class codes to idexes\n",
    "    model.class_to_idx = checkpoint['model']['class_to_idx']\n",
    "    \n",
    "    # initialize optimizer\n",
    "    if mode == 'valid' or checkpoint['optimizer'] == None: \n",
    "        optimizer = None\n",
    "    else:\n",
    "        optimizer = optim.Adam(params_to_update(model.parameters()))\n",
    "        # restore optimizer parameters\n",
    "        optimizer.load_state_dict(checkpoint['optimizer']['state_dict'])\n",
    "    \n",
    "    # initialize lr scheduler\n",
    "    if mode == 'valid' or checkpoint['lr_scheduler'] == None:\n",
    "        scheduler = None\n",
    "    else:\n",
    "        scheduler =  lr_scheduler.StepLR(optimizer, checkpoint['lr_scheduler']['step_size'])\n",
    "        # restore scheduler parameters\n",
    "        scheduler.load_state_dict(checkpoint['lr_scheduler']['state_dict'])\n",
    "    \n",
    "    # restore train_history\n",
    "    if mode == 'valid': train_history = None\n",
    "    else: train_history = checkpoint['train_history']\n",
    "    \n",
    "    # set model to training or inference mode\n",
    "    model.train() if mode == 'train' else model.eval()\n",
    "    \n",
    "    return model, optimizer, scheduler, train_history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# FINETUNE HYPERPARAMETERS\n",
    "# ------------------------\n",
    "\n",
    "# INTITIALIZE MODELS, \n",
    "# Get best screened model name\n",
    "# load checkpoint\n",
    "path = 'checkpoint_ipynb.pth'\n",
    "checkpoint = torch.load(path)\n",
    "scr_model_name = checkpoint['model']['name']\n",
    "\n",
    "# define hyperparameters grid\n",
    "hidden_layers_lst = [None, [1024, 512], None, [1024, 512]]\n",
    "lr_lst = [0.001, 0.001, 'StepLR','StepLR']\n",
    "\n",
    "# define model names\n",
    "net_names = ['arch={}|lr={}'.format(str(hidden_layers), lr) \n",
    "             for hidden_layers, lr in zip(hidden_layers_lst, lr_lst)]\n",
    "\n",
    "# define drop out probability\n",
    "drop_p = drop_p\n",
    "\n",
    "# initialize models for transfer learning\n",
    "nets = {net_name: initialize_model(scr_model_name, num_classes, feature_extract, \n",
    "                                     pretrained, hidden_layers, drop_p, net_name)\n",
    "         for net_name, hidden_layers, in zip(net_names, hidden_layers_lst)}\n",
    "nets = {net: nets[net][0] for net in nets}\n",
    "\n",
    "\n",
    "# INTIALIZE OPTIMIZERS\n",
    "# start_lr\n",
    "start_lr = lr_lst[0]\n",
    "\n",
    "# get learning parameters and define optimization algorithm\n",
    "optimizers = {net: optim.Adam(params_to_update(nets[net].parameters()), lr=start_lr)\n",
    "              for net in nets}\n",
    "\n",
    "# INITIALIZE LR SHEDULERS\n",
    "# number of epochs\n",
    "num_epochs = num_epochs\n",
    "\n",
    "end_lr = end_lr     # learning rate of last epoch\n",
    "gamma = (start_lr - end_lr) / num_epochs # lr decay parameter\n",
    "\n",
    "lr_schedulers = {\n",
    "    net: lr_scheduler.StepLR(optimizers[net], step_size=1, gamma=gamma) if lr == 'StepLR' else None \n",
    "    for net, lr in zip(nets, lr_lst)}\n",
    "\n",
    "# DEFINE LOSS FUNCTION\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "# train all models on x % of data\n",
    "batch_ratio = 1    # 100% of data\n",
    "\n",
    "# move the networks to gpu if enabled\n",
    "for net in nets:\n",
    "    net = nets[net].to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model: resnet50 ---> id: arch=None|lr=0.001\n",
      "*******************************************\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "44ed8c8386dd47f5b5804141a34dfc23",
       "version_major": 2,
       "version_minor": 0
      },
      "text/html": [
       "<p>Failed to display Jupyter Widget of type <code>HBox</code>.</p>\n",
       "<p>\n",
       "  If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n",
       "  that the widgets JavaScript is still loading. If this message persists, it\n",
       "  likely means that the widgets JavaScript library is either not installed or\n",
       "  not enabled. See the <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n",
       "  Widgets Documentation</a> for setup instructions.\n",
       "</p>\n",
       "<p>\n",
       "  If you're reading this message in another frontend (for example, a static\n",
       "  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n",
       "  it may mean that your frontend doesn't currently support widgets.\n",
       "</p>\n"
      ],
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=10), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 1/10\n",
      "----------\n",
      "\n",
      "train loss: 2.5600 acc: 0.4853 time: 1m 45s\n",
      "valid loss: 0.8743 acc: 0.8350 time: 0m 13s\n",
      "\n",
      "epoch 2/10\n",
      "----------\n",
      "train loss: 1.0236 acc: 0.7865 time: 1m 48s\n",
      "valid loss: 0.4866 acc: 0.9059 time: 0m 13s\n",
      "\n",
      "epoch 3/10\n",
      "----------\n",
      "train loss: 0.7435 acc: 0.8281 time: 1m 49s\n",
      "valid loss: 0.4001 acc: 0.9083 time: 0m 13s\n",
      "\n",
      "epoch 4/10\n",
      "----------\n",
      "train loss: 0.6153 acc: 0.8532 time: 1m 45s\n",
      "valid loss: 0.3597 acc: 0.9120 time: 0m 14s\n",
      "\n",
      "epoch 5/10\n",
      "----------\n",
      "train loss: 0.5682 acc: 0.8578 time: 1m 45s\n",
      "valid loss: 0.3228 acc: 0.9193 time: 0m 14s\n",
      "\n",
      "epoch 6/10\n",
      "----------\n",
      "train loss: 0.5303 acc: 0.8623 time: 1m 48s\n",
      "valid loss: 0.2857 acc: 0.9291 time: 0m 14s\n",
      "\n",
      "epoch 7/10\n",
      "----------\n",
      "train loss: 0.4635 acc: 0.8782 time: 1m 48s\n",
      "valid loss: 0.2930 acc: 0.9218 time: 0m 13s\n",
      "\n",
      "epoch 8/10\n",
      "----------\n",
      "train loss: 0.4384 acc: 0.8822 time: 1m 45s\n",
      "valid loss: 0.3151 acc: 0.9205 time: 0m 14s\n",
      "\n",
      "epoch 9/10\n",
      "----------\n",
      "train loss: 0.4293 acc: 0.8878 time: 1m 48s\n",
      "valid loss: 0.2890 acc: 0.9181 time: 0m 14s\n",
      "\n",
      "epoch 10/10\n",
      "-----------\n",
      "train loss: 0.4104 acc: 0.8869 time: 1m 45s\n",
      "valid loss: 0.2618 acc: 0.9340 time: 0m 14s\n",
      "\n",
      "\n",
      "Training complete in 20m 2s\n",
      "Best val Acc: 0.9340\n",
      "\n",
      "\n",
      "\n",
      "model: resnet50 ---> id: arch=[1024, 512]|lr=0.001\n",
      "**************************************************\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "67abe55ffb824ccbb3fa032ca5c6bd06",
       "version_major": 2,
       "version_minor": 0
      },
      "text/html": [
       "<p>Failed to display Jupyter Widget of type <code>HBox</code>.</p>\n",
       "<p>\n",
       "  If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n",
       "  that the widgets JavaScript is still loading. If this message persists, it\n",
       "  likely means that the widgets JavaScript library is either not installed or\n",
       "  not enabled. See the <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n",
       "  Widgets Documentation</a> for setup instructions.\n",
       "</p>\n",
       "<p>\n",
       "  If you're reading this message in another frontend (for example, a static\n",
       "  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n",
       "  it may mean that your frontend doesn't currently support widgets.\n",
       "</p>\n"
      ],
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=10), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 1/10\n",
      "----------\n",
      "train loss: 4.2868 acc: 0.0777 time: 1m 48s\n",
      "valid loss: 3.1719 acc: 0.2616 time: 0m 13s\n",
      "\n",
      "epoch 2/10\n",
      "----------\n",
      "train loss: 3.0997 acc: 0.2392 time: 1m 48s\n",
      "valid loss: 1.8516 acc: 0.5000 time: 0m 14s\n",
      "\n",
      "epoch 3/10\n",
      "----------\n",
      "train loss: 2.5452 acc: 0.3339 time: 1m 49s\n",
      "valid loss: 1.5314 acc: 0.5917 time: 0m 13s\n",
      "\n",
      "epoch 4/10\n",
      "----------\n",
      "train loss: 2.2947 acc: 0.3771 time: 1m 48s\n",
      "valid loss: 1.2252 acc: 0.6638 time: 0m 14s\n",
      "\n",
      "epoch 5/10\n",
      "----------\n",
      "train loss: 2.1480 acc: 0.4222 time: 1m 48s\n",
      "valid loss: 1.1398 acc: 0.7017 time: 0m 13s\n",
      "\n",
      "epoch 6/10\n",
      "----------\n",
      "train loss: 2.0858 acc: 0.4396 time: 1m 48s\n",
      "valid loss: 1.0285 acc: 0.7225 time: 0m 14s\n",
      "\n",
      "epoch 7/10\n",
      "----------\n",
      "train loss: 1.9776 acc: 0.4620 time: 1m 48s\n",
      "valid loss: 0.9560 acc: 0.7567 time: 0m 13s\n",
      "\n",
      "epoch 8/10\n",
      "----------\n",
      "train loss: 1.9276 acc: 0.4788 time: 1m 49s\n",
      "valid loss: 0.9122 acc: 0.7555 time: 0m 14s\n",
      "\n",
      "epoch 9/10\n",
      "----------\n",
      "train loss: 1.8829 acc: 0.4872 time: 1m 48s\n",
      "valid loss: 0.8551 acc: 0.7763 time: 0m 14s\n",
      "\n",
      "epoch 10/10\n",
      "-----------\n",
      "train loss: 1.8212 acc: 0.5017 time: 1m 49s\n",
      "valid loss: 0.7999 acc: 0.7922 time: 0m 13s\n",
      "\n",
      "\n",
      "Training complete in 20m 19s\n",
      "Best val Acc: 0.7922\n",
      "\n",
      "\n",
      "\n",
      "model: resnet50 ---> id: arch=None|lr=StepLR\n",
      "********************************************\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "034eef407a77426d9b77595eece52e05",
       "version_major": 2,
       "version_minor": 0
      },
      "text/html": [
       "<p>Failed to display Jupyter Widget of type <code>HBox</code>.</p>\n",
       "<p>\n",
       "  If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n",
       "  that the widgets JavaScript is still loading. If this message persists, it\n",
       "  likely means that the widgets JavaScript library is either not installed or\n",
       "  not enabled. See the <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n",
       "  Widgets Documentation</a> for setup instructions.\n",
       "</p>\n",
       "<p>\n",
       "  If you're reading this message in another frontend (for example, a static\n",
       "  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n",
       "  it may mean that your frontend doesn't currently support widgets.\n",
       "</p>\n"
      ],
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=10), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 1/10\n",
      "----------\n",
      "train loss: 2.5819 acc: 0.4773 time: 1m 48s\n",
      "valid loss: 0.8227 acc: 0.8350 time: 0m 13s\n",
      "\n",
      "epoch 2/10\n",
      "----------\n",
      "train loss: 1.1946 acc: 0.7753 time: 1m 46s\n",
      "valid loss: 0.8369 acc: 0.8337 time: 0m 13s\n",
      "\n",
      "epoch 3/10\n",
      "----------\n",
      "train loss: 1.1981 acc: 0.7705 time: 1m 48s\n",
      "valid loss: 0.8368 acc: 0.8423 time: 0m 13s\n",
      "\n",
      "epoch 4/10\n",
      "----------\n",
      "train loss: 1.1991 acc: 0.7686 time: 1m 49s\n",
      "valid loss: 0.8326 acc: 0.8325 time: 0m 13s\n",
      "\n",
      "epoch 5/10\n",
      "----------\n",
      "train loss: 1.1858 acc: 0.7785 time: 1m 45s\n",
      "valid loss: 0.8357 acc: 0.8313 time: 0m 14s\n",
      "\n",
      "epoch 6/10\n",
      "----------\n",
      "train loss: 1.2081 acc: 0.7705 time: 1m 48s\n",
      "valid loss: 0.8469 acc: 0.8399 time: 0m 13s\n",
      "\n",
      "epoch 7/10\n",
      "----------\n",
      "train loss: 1.2039 acc: 0.7759 time: 1m 45s\n",
      "valid loss: 0.8416 acc: 0.8350 time: 0m 14s\n",
      "\n",
      "epoch 8/10\n",
      "----------\n",
      "train loss: 1.1844 acc: 0.7785 time: 1m 48s\n",
      "valid loss: 0.8359 acc: 0.8337 time: 0m 13s\n",
      "\n",
      "epoch 9/10\n",
      "----------\n",
      "train loss: 1.1793 acc: 0.7734 time: 1m 45s\n",
      "valid loss: 0.8387 acc: 0.8350 time: 0m 13s\n",
      "\n",
      "epoch 10/10\n",
      "-----------\n",
      "train loss: 1.1959 acc: 0.7697 time: 1m 48s\n",
      "valid loss: 0.8479 acc: 0.8313 time: 0m 13s\n",
      "\n",
      "\n",
      "Training complete in 20m 7s\n",
      "Best val Acc: 0.8423\n",
      "\n",
      "\n",
      "\n",
      "model: resnet50 ---> id: arch=[1024, 512]|lr=StepLR\n",
      "***************************************************\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dc6e1638ba2148a0ab0f2bfe6bf89503",
       "version_major": 2,
       "version_minor": 0
      },
      "text/html": [
       "<p>Failed to display Jupyter Widget of type <code>HBox</code>.</p>\n",
       "<p>\n",
       "  If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n",
       "  that the widgets JavaScript is still loading. If this message persists, it\n",
       "  likely means that the widgets JavaScript library is either not installed or\n",
       "  not enabled. See the <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n",
       "  Widgets Documentation</a> for setup instructions.\n",
       "</p>\n",
       "<p>\n",
       "  If you're reading this message in another frontend (for example, a static\n",
       "  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n",
       "  it may mean that your frontend doesn't currently support widgets.\n",
       "</p>\n"
      ],
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=10), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 1/10\n",
      "----------\n",
      "train loss: 4.2376 acc: 0.0839 time: 1m 48s\n",
      "valid loss: 3.1838 acc: 0.2200 time: 0m 13s\n",
      "\n",
      "epoch 2/10\n",
      "----------\n",
      "train loss: 3.5838 acc: 0.1589 time: 1m 48s\n",
      "valid loss: 3.1691 acc: 0.2262 time: 0m 14s\n",
      "\n",
      "epoch 3/10\n",
      "----------\n",
      "train loss: 3.5620 acc: 0.1564 time: 1m 48s\n",
      "valid loss: 3.1753 acc: 0.2200 time: 0m 14s\n",
      "\n",
      "epoch 4/10\n",
      "----------\n",
      "train loss: 3.5898 acc: 0.1549 time: 1m 49s\n",
      "valid loss: 3.1906 acc: 0.2176 time: 0m 13s\n",
      "\n",
      "epoch 5/10\n",
      "----------\n",
      "train loss: 3.5898 acc: 0.1499 time: 1m 48s\n",
      "valid loss: 3.1726 acc: 0.2225 time: 0m 14s\n",
      "\n",
      "epoch 6/10\n",
      "----------\n",
      "train loss: 3.5727 acc: 0.1571 time: 1m 49s\n",
      "valid loss: 3.1801 acc: 0.2176 time: 0m 14s\n",
      "\n",
      "epoch 7/10\n",
      "----------\n",
      "train loss: 3.5891 acc: 0.1517 time: 1m 48s\n",
      "valid loss: 3.1796 acc: 0.2262 time: 0m 14s\n",
      "\n",
      "epoch 8/10\n",
      "----------\n",
      "train loss: 3.5633 acc: 0.1567 time: 1m 49s\n",
      "valid loss: 3.1763 acc: 0.2200 time: 0m 13s\n",
      "\n",
      "epoch 9/10\n",
      "----------\n",
      "train loss: 3.5931 acc: 0.1531 time: 1m 48s\n",
      "valid loss: 3.1749 acc: 0.2176 time: 0m 13s\n",
      "\n",
      "epoch 10/10\n",
      "-----------\n",
      "train loss: 3.5744 acc: 0.1600 time: 1m 49s\n",
      "valid loss: 3.1813 acc: 0.2249 time: 0m 14s\n",
      "\n",
      "\n",
      "Training complete in 20m 19s\n",
      "Best val Acc: 0.2262\n",
      "\n",
      "\n",
      "\n",
      "Model: resnet50 with id: arch=[1024, 512]|lr=0.001 saved to checkpoint.pth.\n"
     ]
    }
   ],
   "source": [
    "# TRAIN MODELS\n",
    "# keep workspace active\n",
    "with active_session():\n",
    "    trained_nets = {net: train_model(model=nets[net], dataloaders = dataloaders[scr_model_name], \n",
    "                                            criterion=criterion, optimizer=optimizers[net], \n",
    "                                            scheduler=lr_schedulers[net], num_epochs=num_epochs, batch_ratio = batch_ratio)\n",
    "                    for net in nets}\n",
    "\n",
    "    # extract training output\n",
    "    # models\n",
    "    nets = {net: trained_nets[net][0] for net in nets}\n",
    "    # training history\n",
    "    hists = {net: trained_nets[net][1] for net in nets}\n",
    "    results = pd.DataFrame([])\n",
    "\n",
    "    # merge models training history\n",
    "    for hist in hists:\n",
    "        results = results.append(hists[hist], ignore_index=True)\n",
    "\n",
    "    # SAVE BEST MODEL\n",
    "    # indentify index of model with highest validation accuracy\n",
    "    best_model_idx = results[results[('settings', 'phase')] == 'valid'][('performance', 'acc')].idxmax()\n",
    "    best_model_name = results.iloc[best_model_idx][('settings', 'model_id')]\n",
    "    best_model = nets[best_model_name]\n",
    "\n",
    "    # update attribute to store mappings of class codes to indexes\n",
    "    best_model.class_to_idx = image_datasets[best_model.name]['train'].class_to_idx\n",
    "\n",
    "    # save model\n",
    "    save_model(best_model, optimizers[best_model_name], \n",
    "               lr_schedulers[best_model_name], hists[best_model_name], path=path)\n",
    "\n",
    "    print('Model: {} with id: {} saved to {}.'\n",
    "          .format(best_model.name, best_model.id, path))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f945c2507b8>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th colspan=\"6\" halign=\"left\">settings</th>\n",
       "      <th colspan=\"3\" halign=\"left\">performance</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>model_id</th>\n",
       "      <th>model</th>\n",
       "      <th>modification</th>\n",
       "      <th>learning rate</th>\n",
       "      <th>epoch</th>\n",
       "      <th>phase</th>\n",
       "      <th>acc</th>\n",
       "      <th>loss</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>arch=None|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>10</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.933985</td>\n",
       "      <td>0.261804</td>\n",
       "      <td>13.656644</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>arch=None|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>6</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.929095</td>\n",
       "      <td>0.285723</td>\n",
       "      <td>13.800460</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>arch=None|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>7</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.921760</td>\n",
       "      <td>0.292961</td>\n",
       "      <td>13.392904</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>arch=None|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>8</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.920538</td>\n",
       "      <td>0.315115</td>\n",
       "      <td>13.731087</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>arch=None|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>5</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.919315</td>\n",
       "      <td>0.322798</td>\n",
       "      <td>13.501520</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>arch=None|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>9</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.918093</td>\n",
       "      <td>0.289028</td>\n",
       "      <td>13.507438</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>arch=None|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>4</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.911980</td>\n",
       "      <td>0.359675</td>\n",
       "      <td>13.746825</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>arch=None|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>3</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.908313</td>\n",
       "      <td>0.400145</td>\n",
       "      <td>13.481784</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>arch=None|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>2</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.905868</td>\n",
       "      <td>0.486639</td>\n",
       "      <td>13.477805</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>45</th>\n",
       "      <td>arch=None|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>3</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.842298</td>\n",
       "      <td>0.836796</td>\n",
       "      <td>13.479210</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>51</th>\n",
       "      <td>arch=None|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>6</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.839853</td>\n",
       "      <td>0.846947</td>\n",
       "      <td>13.421992</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>arch=None|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>1</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.834963</td>\n",
       "      <td>0.874264</td>\n",
       "      <td>13.445291</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41</th>\n",
       "      <td>arch=None|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>1</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.834963</td>\n",
       "      <td>0.822715</td>\n",
       "      <td>13.477031</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>53</th>\n",
       "      <td>arch=None|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>7</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.834963</td>\n",
       "      <td>0.841630</td>\n",
       "      <td>13.501390</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>57</th>\n",
       "      <td>arch=None|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>9</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.834963</td>\n",
       "      <td>0.838716</td>\n",
       "      <td>13.466829</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>43</th>\n",
       "      <td>arch=None|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>2</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.833741</td>\n",
       "      <td>0.836915</td>\n",
       "      <td>13.468124</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>55</th>\n",
       "      <td>arch=None|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>8</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.833741</td>\n",
       "      <td>0.835885</td>\n",
       "      <td>13.437315</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>47</th>\n",
       "      <td>arch=None|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>4</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.832518</td>\n",
       "      <td>0.832636</td>\n",
       "      <td>13.454525</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49</th>\n",
       "      <td>arch=None|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>5</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.831296</td>\n",
       "      <td>0.835672</td>\n",
       "      <td>13.560962</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>59</th>\n",
       "      <td>arch=None|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>10</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.831296</td>\n",
       "      <td>0.847889</td>\n",
       "      <td>13.494737</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>39</th>\n",
       "      <td>arch=[1024, 512]|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>10</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.792176</td>\n",
       "      <td>0.799946</td>\n",
       "      <td>13.399705</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>37</th>\n",
       "      <td>arch=[1024, 512]|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>9</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.776284</td>\n",
       "      <td>0.855053</td>\n",
       "      <td>13.506951</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>33</th>\n",
       "      <td>arch=[1024, 512]|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>7</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.756724</td>\n",
       "      <td>0.955983</td>\n",
       "      <td>13.477567</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35</th>\n",
       "      <td>arch=[1024, 512]|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>8</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.755501</td>\n",
       "      <td>0.912198</td>\n",
       "      <td>13.544653</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>31</th>\n",
       "      <td>arch=[1024, 512]|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>6</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.722494</td>\n",
       "      <td>1.028542</td>\n",
       "      <td>13.654442</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>arch=[1024, 512]|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>5</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.701711</td>\n",
       "      <td>1.139837</td>\n",
       "      <td>13.436735</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>27</th>\n",
       "      <td>arch=[1024, 512]|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>4</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.663814</td>\n",
       "      <td>1.225167</td>\n",
       "      <td>13.781057</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>arch=[1024, 512]|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>3</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.591687</td>\n",
       "      <td>1.531359</td>\n",
       "      <td>13.482663</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>arch=[1024, 512]|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>2</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.500000</td>\n",
       "      <td>1.851584</td>\n",
       "      <td>13.735985</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>arch=[1024, 512]|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>1</td>\n",
       "      <td>valid</td>\n",
       "      <td>0.261614</td>\n",
       "      <td>3.171927</td>\n",
       "      <td>13.466045</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>54</th>\n",
       "      <td>arch=None|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>8</td>\n",
       "      <td>train</td>\n",
       "      <td>0.778541</td>\n",
       "      <td>1.184412</td>\n",
       "      <td>108.397259</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>52</th>\n",
       "      <td>arch=None|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>7</td>\n",
       "      <td>train</td>\n",
       "      <td>0.775946</td>\n",
       "      <td>1.203901</td>\n",
       "      <td>104.903072</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>42</th>\n",
       "      <td>arch=None|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>2</td>\n",
       "      <td>train</td>\n",
       "      <td>0.775336</td>\n",
       "      <td>1.194573</td>\n",
       "      <td>105.940652</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>56</th>\n",
       "      <td>arch=None|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>9</td>\n",
       "      <td>train</td>\n",
       "      <td>0.773352</td>\n",
       "      <td>1.179286</td>\n",
       "      <td>105.346926</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>44</th>\n",
       "      <td>arch=None|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>3</td>\n",
       "      <td>train</td>\n",
       "      <td>0.770452</td>\n",
       "      <td>1.198138</td>\n",
       "      <td>107.972830</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50</th>\n",
       "      <td>arch=None|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>6</td>\n",
       "      <td>train</td>\n",
       "      <td>0.770452</td>\n",
       "      <td>1.208063</td>\n",
       "      <td>108.394089</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>58</th>\n",
       "      <td>arch=None|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>10</td>\n",
       "      <td>train</td>\n",
       "      <td>0.769689</td>\n",
       "      <td>1.195935</td>\n",
       "      <td>108.388680</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>46</th>\n",
       "      <td>arch=None|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>4</td>\n",
       "      <td>train</td>\n",
       "      <td>0.768620</td>\n",
       "      <td>1.199052</td>\n",
       "      <td>108.519903</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>38</th>\n",
       "      <td>arch=[1024, 512]|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>10</td>\n",
       "      <td>train</td>\n",
       "      <td>0.501679</td>\n",
       "      <td>1.821183</td>\n",
       "      <td>109.043147</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>arch=[1024, 512]|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>9</td>\n",
       "      <td>train</td>\n",
       "      <td>0.487179</td>\n",
       "      <td>1.882912</td>\n",
       "      <td>107.995956</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>arch=None|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>1</td>\n",
       "      <td>train</td>\n",
       "      <td>0.485348</td>\n",
       "      <td>2.560046</td>\n",
       "      <td>104.795594</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>34</th>\n",
       "      <td>arch=[1024, 512]|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>8</td>\n",
       "      <td>train</td>\n",
       "      <td>0.478785</td>\n",
       "      <td>1.927600</td>\n",
       "      <td>108.839860</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>40</th>\n",
       "      <td>arch=None|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>1</td>\n",
       "      <td>train</td>\n",
       "      <td>0.477259</td>\n",
       "      <td>2.581922</td>\n",
       "      <td>108.477318</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>32</th>\n",
       "      <td>arch=[1024, 512]|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>7</td>\n",
       "      <td>train</td>\n",
       "      <td>0.461996</td>\n",
       "      <td>1.977608</td>\n",
       "      <td>108.489356</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>30</th>\n",
       "      <td>arch=[1024, 512]|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>6</td>\n",
       "      <td>train</td>\n",
       "      <td>0.439560</td>\n",
       "      <td>2.085815</td>\n",
       "      <td>108.242555</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>arch=[1024, 512]|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>5</td>\n",
       "      <td>train</td>\n",
       "      <td>0.422161</td>\n",
       "      <td>2.147980</td>\n",
       "      <td>107.617417</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>arch=[1024, 512]|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>4</td>\n",
       "      <td>train</td>\n",
       "      <td>0.377137</td>\n",
       "      <td>2.294684</td>\n",
       "      <td>108.381610</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>arch=[1024, 512]|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>3</td>\n",
       "      <td>train</td>\n",
       "      <td>0.333944</td>\n",
       "      <td>2.545223</td>\n",
       "      <td>108.756228</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>arch=[1024, 512]|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>2</td>\n",
       "      <td>train</td>\n",
       "      <td>0.239164</td>\n",
       "      <td>3.099711</td>\n",
       "      <td>108.021468</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>78</th>\n",
       "      <td>arch=[1024, 512]|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>10</td>\n",
       "      <td>train</td>\n",
       "      <td>0.159951</td>\n",
       "      <td>3.574424</td>\n",
       "      <td>108.774837</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>62</th>\n",
       "      <td>arch=[1024, 512]|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>2</td>\n",
       "      <td>train</td>\n",
       "      <td>0.158883</td>\n",
       "      <td>3.583809</td>\n",
       "      <td>107.993297</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>70</th>\n",
       "      <td>arch=[1024, 512]|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>6</td>\n",
       "      <td>train</td>\n",
       "      <td>0.157051</td>\n",
       "      <td>3.572736</td>\n",
       "      <td>108.835072</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>74</th>\n",
       "      <td>arch=[1024, 512]|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>8</td>\n",
       "      <td>train</td>\n",
       "      <td>0.156746</td>\n",
       "      <td>3.563334</td>\n",
       "      <td>108.871015</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>64</th>\n",
       "      <td>arch=[1024, 512]|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>3</td>\n",
       "      <td>train</td>\n",
       "      <td>0.156441</td>\n",
       "      <td>3.561994</td>\n",
       "      <td>108.113918</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>66</th>\n",
       "      <td>arch=[1024, 512]|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>4</td>\n",
       "      <td>train</td>\n",
       "      <td>0.154915</td>\n",
       "      <td>3.589823</td>\n",
       "      <td>108.821310</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>76</th>\n",
       "      <td>arch=[1024, 512]|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>9</td>\n",
       "      <td>train</td>\n",
       "      <td>0.153083</td>\n",
       "      <td>3.593057</td>\n",
       "      <td>107.968659</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>72</th>\n",
       "      <td>arch=[1024, 512]|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>7</td>\n",
       "      <td>train</td>\n",
       "      <td>0.151709</td>\n",
       "      <td>3.589089</td>\n",
       "      <td>108.011274</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>68</th>\n",
       "      <td>arch=[1024, 512]|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>5</td>\n",
       "      <td>train</td>\n",
       "      <td>0.149878</td>\n",
       "      <td>3.589842</td>\n",
       "      <td>107.777207</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>60</th>\n",
       "      <td>arch=[1024, 512]|lr=StepLR</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>StepLR</td>\n",
       "      <td>1</td>\n",
       "      <td>train</td>\n",
       "      <td>0.083944</td>\n",
       "      <td>4.237645</td>\n",
       "      <td>108.386830</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>arch=[1024, 512]|lr=0.001</td>\n",
       "      <td>resnet50</td>\n",
       "      <td>[2048, 1024, 512, 102]</td>\n",
       "      <td>0.001</td>\n",
       "      <td>1</td>\n",
       "      <td>train</td>\n",
       "      <td>0.077686</td>\n",
       "      <td>4.286843</td>\n",
       "      <td>107.721375</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>80 rows × 9 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                      settings                                    \\\n",
       "                      model_id     model            modification   \n",
       "19          arch=None|lr=0.001  resnet50             [2048, 102]   \n",
       "11          arch=None|lr=0.001  resnet50             [2048, 102]   \n",
       "13          arch=None|lr=0.001  resnet50             [2048, 102]   \n",
       "15          arch=None|lr=0.001  resnet50             [2048, 102]   \n",
       "9           arch=None|lr=0.001  resnet50             [2048, 102]   \n",
       "17          arch=None|lr=0.001  resnet50             [2048, 102]   \n",
       "7           arch=None|lr=0.001  resnet50             [2048, 102]   \n",
       "5           arch=None|lr=0.001  resnet50             [2048, 102]   \n",
       "3           arch=None|lr=0.001  resnet50             [2048, 102]   \n",
       "45         arch=None|lr=StepLR  resnet50             [2048, 102]   \n",
       "51         arch=None|lr=StepLR  resnet50             [2048, 102]   \n",
       "1           arch=None|lr=0.001  resnet50             [2048, 102]   \n",
       "41         arch=None|lr=StepLR  resnet50             [2048, 102]   \n",
       "53         arch=None|lr=StepLR  resnet50             [2048, 102]   \n",
       "57         arch=None|lr=StepLR  resnet50             [2048, 102]   \n",
       "43         arch=None|lr=StepLR  resnet50             [2048, 102]   \n",
       "55         arch=None|lr=StepLR  resnet50             [2048, 102]   \n",
       "47         arch=None|lr=StepLR  resnet50             [2048, 102]   \n",
       "49         arch=None|lr=StepLR  resnet50             [2048, 102]   \n",
       "59         arch=None|lr=StepLR  resnet50             [2048, 102]   \n",
       "39   arch=[1024, 512]|lr=0.001  resnet50  [2048, 1024, 512, 102]   \n",
       "37   arch=[1024, 512]|lr=0.001  resnet50  [2048, 1024, 512, 102]   \n",
       "33   arch=[1024, 512]|lr=0.001  resnet50  [2048, 1024, 512, 102]   \n",
       "35   arch=[1024, 512]|lr=0.001  resnet50  [2048, 1024, 512, 102]   \n",
       "31   arch=[1024, 512]|lr=0.001  resnet50  [2048, 1024, 512, 102]   \n",
       "29   arch=[1024, 512]|lr=0.001  resnet50  [2048, 1024, 512, 102]   \n",
       "27   arch=[1024, 512]|lr=0.001  resnet50  [2048, 1024, 512, 102]   \n",
       "25   arch=[1024, 512]|lr=0.001  resnet50  [2048, 1024, 512, 102]   \n",
       "23   arch=[1024, 512]|lr=0.001  resnet50  [2048, 1024, 512, 102]   \n",
       "21   arch=[1024, 512]|lr=0.001  resnet50  [2048, 1024, 512, 102]   \n",
       "..                         ...       ...                     ...   \n",
       "54         arch=None|lr=StepLR  resnet50             [2048, 102]   \n",
       "52         arch=None|lr=StepLR  resnet50             [2048, 102]   \n",
       "42         arch=None|lr=StepLR  resnet50             [2048, 102]   \n",
       "56         arch=None|lr=StepLR  resnet50             [2048, 102]   \n",
       "44         arch=None|lr=StepLR  resnet50             [2048, 102]   \n",
       "50         arch=None|lr=StepLR  resnet50             [2048, 102]   \n",
       "58         arch=None|lr=StepLR  resnet50             [2048, 102]   \n",
       "46         arch=None|lr=StepLR  resnet50             [2048, 102]   \n",
       "38   arch=[1024, 512]|lr=0.001  resnet50  [2048, 1024, 512, 102]   \n",
       "36   arch=[1024, 512]|lr=0.001  resnet50  [2048, 1024, 512, 102]   \n",
       "0           arch=None|lr=0.001  resnet50             [2048, 102]   \n",
       "34   arch=[1024, 512]|lr=0.001  resnet50  [2048, 1024, 512, 102]   \n",
       "40         arch=None|lr=StepLR  resnet50             [2048, 102]   \n",
       "32   arch=[1024, 512]|lr=0.001  resnet50  [2048, 1024, 512, 102]   \n",
       "30   arch=[1024, 512]|lr=0.001  resnet50  [2048, 1024, 512, 102]   \n",
       "28   arch=[1024, 512]|lr=0.001  resnet50  [2048, 1024, 512, 102]   \n",
       "26   arch=[1024, 512]|lr=0.001  resnet50  [2048, 1024, 512, 102]   \n",
       "24   arch=[1024, 512]|lr=0.001  resnet50  [2048, 1024, 512, 102]   \n",
       "22   arch=[1024, 512]|lr=0.001  resnet50  [2048, 1024, 512, 102]   \n",
       "78  arch=[1024, 512]|lr=StepLR  resnet50  [2048, 1024, 512, 102]   \n",
       "62  arch=[1024, 512]|lr=StepLR  resnet50  [2048, 1024, 512, 102]   \n",
       "70  arch=[1024, 512]|lr=StepLR  resnet50  [2048, 1024, 512, 102]   \n",
       "74  arch=[1024, 512]|lr=StepLR  resnet50  [2048, 1024, 512, 102]   \n",
       "64  arch=[1024, 512]|lr=StepLR  resnet50  [2048, 1024, 512, 102]   \n",
       "66  arch=[1024, 512]|lr=StepLR  resnet50  [2048, 1024, 512, 102]   \n",
       "76  arch=[1024, 512]|lr=StepLR  resnet50  [2048, 1024, 512, 102]   \n",
       "72  arch=[1024, 512]|lr=StepLR  resnet50  [2048, 1024, 512, 102]   \n",
       "68  arch=[1024, 512]|lr=StepLR  resnet50  [2048, 1024, 512, 102]   \n",
       "60  arch=[1024, 512]|lr=StepLR  resnet50  [2048, 1024, 512, 102]   \n",
       "20   arch=[1024, 512]|lr=0.001  resnet50  [2048, 1024, 512, 102]   \n",
       "\n",
       "                              performance                        \n",
       "   learning rate epoch  phase         acc      loss        time  \n",
       "19         0.001    10  valid    0.933985  0.261804   13.656644  \n",
       "11         0.001     6  valid    0.929095  0.285723   13.800460  \n",
       "13         0.001     7  valid    0.921760  0.292961   13.392904  \n",
       "15         0.001     8  valid    0.920538  0.315115   13.731087  \n",
       "9          0.001     5  valid    0.919315  0.322798   13.501520  \n",
       "17         0.001     9  valid    0.918093  0.289028   13.507438  \n",
       "7          0.001     4  valid    0.911980  0.359675   13.746825  \n",
       "5          0.001     3  valid    0.908313  0.400145   13.481784  \n",
       "3          0.001     2  valid    0.905868  0.486639   13.477805  \n",
       "45        StepLR     3  valid    0.842298  0.836796   13.479210  \n",
       "51        StepLR     6  valid    0.839853  0.846947   13.421992  \n",
       "1          0.001     1  valid    0.834963  0.874264   13.445291  \n",
       "41        StepLR     1  valid    0.834963  0.822715   13.477031  \n",
       "53        StepLR     7  valid    0.834963  0.841630   13.501390  \n",
       "57        StepLR     9  valid    0.834963  0.838716   13.466829  \n",
       "43        StepLR     2  valid    0.833741  0.836915   13.468124  \n",
       "55        StepLR     8  valid    0.833741  0.835885   13.437315  \n",
       "47        StepLR     4  valid    0.832518  0.832636   13.454525  \n",
       "49        StepLR     5  valid    0.831296  0.835672   13.560962  \n",
       "59        StepLR    10  valid    0.831296  0.847889   13.494737  \n",
       "39         0.001    10  valid    0.792176  0.799946   13.399705  \n",
       "37         0.001     9  valid    0.776284  0.855053   13.506951  \n",
       "33         0.001     7  valid    0.756724  0.955983   13.477567  \n",
       "35         0.001     8  valid    0.755501  0.912198   13.544653  \n",
       "31         0.001     6  valid    0.722494  1.028542   13.654442  \n",
       "29         0.001     5  valid    0.701711  1.139837   13.436735  \n",
       "27         0.001     4  valid    0.663814  1.225167   13.781057  \n",
       "25         0.001     3  valid    0.591687  1.531359   13.482663  \n",
       "23         0.001     2  valid    0.500000  1.851584   13.735985  \n",
       "21         0.001     1  valid    0.261614  3.171927   13.466045  \n",
       "..           ...   ...    ...         ...       ...         ...  \n",
       "54        StepLR     8  train    0.778541  1.184412  108.397259  \n",
       "52        StepLR     7  train    0.775946  1.203901  104.903072  \n",
       "42        StepLR     2  train    0.775336  1.194573  105.940652  \n",
       "56        StepLR     9  train    0.773352  1.179286  105.346926  \n",
       "44        StepLR     3  train    0.770452  1.198138  107.972830  \n",
       "50        StepLR     6  train    0.770452  1.208063  108.394089  \n",
       "58        StepLR    10  train    0.769689  1.195935  108.388680  \n",
       "46        StepLR     4  train    0.768620  1.199052  108.519903  \n",
       "38         0.001    10  train    0.501679  1.821183  109.043147  \n",
       "36         0.001     9  train    0.487179  1.882912  107.995956  \n",
       "0          0.001     1  train    0.485348  2.560046  104.795594  \n",
       "34         0.001     8  train    0.478785  1.927600  108.839860  \n",
       "40        StepLR     1  train    0.477259  2.581922  108.477318  \n",
       "32         0.001     7  train    0.461996  1.977608  108.489356  \n",
       "30         0.001     6  train    0.439560  2.085815  108.242555  \n",
       "28         0.001     5  train    0.422161  2.147980  107.617417  \n",
       "26         0.001     4  train    0.377137  2.294684  108.381610  \n",
       "24         0.001     3  train    0.333944  2.545223  108.756228  \n",
       "22         0.001     2  train    0.239164  3.099711  108.021468  \n",
       "78        StepLR    10  train    0.159951  3.574424  108.774837  \n",
       "62        StepLR     2  train    0.158883  3.583809  107.993297  \n",
       "70        StepLR     6  train    0.157051  3.572736  108.835072  \n",
       "74        StepLR     8  train    0.156746  3.563334  108.871015  \n",
       "64        StepLR     3  train    0.156441  3.561994  108.113918  \n",
       "66        StepLR     4  train    0.154915  3.589823  108.821310  \n",
       "76        StepLR     9  train    0.153083  3.593057  107.968659  \n",
       "72        StepLR     7  train    0.151709  3.589089  108.011274  \n",
       "68        StepLR     5  train    0.149878  3.589842  107.777207  \n",
       "60        StepLR     1  train    0.083944  4.237645  108.386830  \n",
       "20         0.001     1  train    0.077686  4.286843  107.721375  \n",
       "\n",
       "[80 rows x 9 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# PRINT TRAINING OVERVIEW\n",
    "# stack results for easy printing    \n",
    "stacked_results = pd.melt(results, id_vars=[*results['settings'].columns],\n",
    "                          var_name='param', value_name='param_value', col_level=1)\n",
    "\n",
    "# print results charts\n",
    "g = sns.FacetGrid(stacked_results, col='param', row='phase', hue='model_id', \n",
    "                  sharex=True, sharey=False)\n",
    "g.map(plt.plot, 'epoch', 'param_value', linestyle='-', marker='o')\n",
    "plt.subplots_adjust(top=0.9)\n",
    "plt.suptitle('Model Screening Results')\n",
    "plt.legend(bbox_to_anchor=(1.04,0), loc='lower left', borderaxespad=0);\n",
    "plt.show()\n",
    "\n",
    "# print results table sorted by validation accuracy\n",
    "display(results.sort_values([('settings', 'phase'),('performance', 'acc')], axis=0, ascending=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Conculsions\n",
    "\n",
    "Number of layers and learning rate play significant role in network learning. Model with classifier with none hidden layers is performing best, learns fastest with learning rate 0.001 and reached highest validation accuracy 93.3%. \n",
    "\n",
    "It seems that learning rate decay has not been designed well. It slows down learning and model with hidden layers [1024, 512] does not learn at all. Generaly models with hidden layers learns much slower than models with none hidden layers.\n",
    "\n",
    "Drop out with probability of 50% seems to work well as there are no overfitting problems.\n",
    "\n",
    "further steps to impove learning speed:\n",
    "- redesing learning rate decay, increase learning rate interval for model with hidden layers ex: <0.003, 0.001>\n",
    "- redesign learing rate decay, increase laerning rate interval for model with none hidden layers ex: <0.002, 0.0001>\n",
    "- change architecture of hidden layers from [1024, 512] to [1024]\n",
    "\n",
    "__Note__: I will not continue fine-tuning as already validation accuracy of best model is sufficient.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing your network\n",
    "\n",
    "It's good practice to test your trained network on test data, images the network has never seen either in training or validation. This will give you a good estimate for the model's performance on completely new images. Run the test images through the network and measure the accuracy, the same way you did validation. You should be able to reach around 70% accuracy on the test set if the model has been trained well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_model(model, dataloader, batch_ratio=1):\n",
    "    ''' \n",
    "    Evaluate accuracy of the model on test dataset\n",
    "    \n",
    "    Arg:\n",
    "        model: neural network model nn.Module\n",
    "        dataloader: dataloader for batching test dataset\n",
    "        batch_ratio: iterates over bath_ratio % of batches in test dataset\n",
    "    \n",
    "    Acc: model accuracy\n",
    "    '''\n",
    "    \n",
    "    # set model to evaluation mode\n",
    "    model.eval()\n",
    "    \n",
    "    # initiate running correct classifications\n",
    "    running_corrects = 0\n",
    "    \n",
    "    # initiate running number of samples\n",
    "    running_size = 0\n",
    "    # import ipdb; ipdb.set_trace()\n",
    "    # iterate over n batches in test dataset\n",
    "    num_batches = max(1, int(len(dataloader) * batch_ratio))\n",
    "    for batch, (inputs, labels) in zip(range(num_batches), dataloader):   \n",
    "        \n",
    "        # update number of samples\n",
    "        running_size += inputs.size(0)\n",
    "        \n",
    "        # transfer data to gpu if enabled\n",
    "        inputs, labels = inputs.to(device), labels.to(device)\n",
    "        \n",
    "        # turn off gradient tracking to speed up prediction\n",
    "        with torch.set_grad_enabled(False):    \n",
    "            # calculate raw outputs\n",
    "            outputs = model(inputs)\n",
    "            \n",
    "            # calculate top k prediction\n",
    "            _, preds = outputs.topk(1, dim=1)\n",
    "        \n",
    "        # accumulate correct classifications\n",
    "        running_corrects += torch.sum(preds == labels.view(preds.shape))\n",
    "\n",
    "    # calculate accuracy of the model\n",
    "    return (running_corrects.double() / running_size).item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model: resnet50 ---> id: arch=None|lr=0.001\n",
      "*******************************************\n",
      "test acc: 0.9219\n"
     ]
    }
   ],
   "source": [
    "# MODEL VALIDATION on the test dataset\n",
    "# load model\n",
    "model, _, _, _, = load_model(path=path, mode='valid')\n",
    "\n",
    "# test best model on x % of data\n",
    "batch_ratio = batch_ratio    # x% of data\n",
    "\n",
    "# move the networks to gpu if enabled\n",
    "model.to(device)\n",
    "\n",
    "# test model\n",
    "print_model = 'model: {} ---> id: {}'.format(model.name, model.id)\n",
    "print(print_model)\n",
    "print('*' * len(print_model))\n",
    "print('test acc: {:.4f}'\n",
    "      .format(test_model(model, dataloaders[model.name]['test'], batch_ratio)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save the checkpoint\n",
    "\n",
    "Now that your network is trained, save the model so you can load it later for making predictions. You probably want to save other things such as the mapping of classes to indices which you get from one of the image datasets: `image_datasets['train'].class_to_idx`. You can attach this to the model as an attribute which makes inference easier later on.\n",
    "\n",
    "```model.class_to_idx = image_datasets['train'].class_to_idx```\n",
    "\n",
    "Remember that you'll want to completely rebuild the model later so you can use it for inference. Make sure to include any information you need in the checkpoint. If you want to load the model and keep training, you'll want to save the number of epochs as well as the optimizer state, `optimizer.state_dict`. You'll likely want to use this trained model in the next part of the project, so best to save it now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save the checkpoint \n",
    "# already done in tunning hyper-parameters of screened model section"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading the checkpoint\n",
    "\n",
    "At this point it's good to write a function that can load a checkpoint and rebuild the model. That way you can come back to this project and keep working on it without having to retrain the network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write a function that loads a checkpoint and rebuilds the model\n",
    "# already done in tunning hyper-parameters of screened model section"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inference for classification\n",
    "\n",
    "Now you'll write a function to use a trained network for inference. That is, you'll pass an image into the network and predict the class of the flower in the image. Write a function called `predict` that takes an image and a model, then returns the top $K$ most likely classes along with the probabilities. It should look like \n",
    "\n",
    "```python\n",
    "probs, classes = predict(image_path, model)\n",
    "print(probs)\n",
    "print(classes)\n",
    "> [ 0.01558163  0.01541934  0.01452626  0.01443549  0.01407339]\n",
    "> ['70', '3', '45', '62', '55']\n",
    "```\n",
    "\n",
    "First you'll need to handle processing the input image such that it can be used in your network. \n",
    "\n",
    "## Image Preprocessing\n",
    "\n",
    "You'll want to use `PIL` to load the image ([documentation](https://pillow.readthedocs.io/en/latest/reference/Image.html)). It's best to write a function that preprocesses the image so it can be used as input for the model. This function should process the images in the same manner used for training. \n",
    "\n",
    "First, resize the images where the shortest side is 256 pixels, keeping the aspect ratio. This can be done with the [`thumbnail`](http://pillow.readthedocs.io/en/3.1.x/reference/Image.html#PIL.Image.Image.thumbnail) or [`resize`](http://pillow.readthedocs.io/en/3.1.x/reference/Image.html#PIL.Image.Image.thumbnail) methods. Then you'll need to crop out the center 224x224 portion of the image.\n",
    "\n",
    "Color channels of images are typically encoded as integers 0-255, but the model expected floats 0-1. You'll need to convert the values. It's easiest with a Numpy array, which you can get from a PIL image like so `np_image = np.array(pil_image)`.\n",
    "\n",
    "As before, the network expects the images to be normalized in a specific way. For the means, it's `[0.485, 0.456, 0.406]` and for the standard deviations `[0.229, 0.224, 0.225]`. You'll want to subtract the means from each color channel, then divide by the standard deviation. \n",
    "\n",
    "And finally, PyTorch expects the color channel to be the first dimension but it's the third dimension in the PIL image and Numpy array. You can reorder dimensions using [`ndarray.transpose`](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.ndarray.transpose.html). The color channel needs to be first and retain the order of the other two dimensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_image(image_path, avgs=[0.485, 0.456, 0.406], stdevs=[0.229, 0.224, 0.225], \n",
    "                  resize=256, crop = 224):\n",
    "    ''' \n",
    "    Scales (normalizes & standardizes), resize and crops a PIL image for a PyTorch model\n",
    "        \n",
    "    Args:\n",
    "        image_path: path to image file including name\n",
    "        resize: number of pixels of shorter size after image resizing\n",
    "        avgs: array-like object - averages per each image channel to standardize to\n",
    "        stdev: array-like object - standard deviations per each image channel to standardize to\n",
    "        crop: crop size to center cropg\n",
    "    \n",
    "    Returns: \n",
    "        image: processed image as numpy array of shape (Channels, Width, Height)\n",
    "    '''\n",
    "    \n",
    "    # Process a PIL image for use in a PyTorch model\n",
    "    # open the image\n",
    "    img_PIL = Image.open(image_path)\n",
    "\n",
    "    # RESIZE IMAGE to keep shorter size 256pxl while keeping aspect ratio\n",
    "    # get image size\n",
    "    size = np.array(img_PIL.size)\n",
    "    \n",
    "    # calculate aspect ratio\n",
    "    min_size, max_size = size.argmin(), size.argmax()\n",
    "    asp_ratio = size[min_size] / size[max_size]\n",
    "    \n",
    "    # resize image\n",
    "    size[min_size] = int(resize)\n",
    "    size[max_size] = int(resize) / asp_ratio\n",
    "    img_PIL = img_PIL.resize(tuple(size))\n",
    "    \n",
    "    # CENTER CROP IMAGE to size 224x224    \n",
    "    # crop margins\n",
    "    left = int((img_PIL.width - int(crop)) / 2)\n",
    "    lower = int((img_PIL.height - int(crop)) / 2)\n",
    "    right= left + int(crop)\n",
    "    upper = lower + int(crop)\n",
    "    \n",
    "    # crop image\n",
    "    img_PIL = img_PIL.crop((left, lower, right, upper))\n",
    "    \n",
    "    # SCALE IMAGE\n",
    "    # normalize to range 0-1\n",
    "    min_range = 0\n",
    "    max_range = 255\n",
    "    img = np.array(img_PIL)\n",
    "    img = (img - min_range) / (max_range - min_range)\n",
    "    \n",
    "    # standardize\n",
    "    img = (img - np.array(avgs)) / np.array(stdevs)\n",
    "    \n",
    "    # RESHAPE IMAGE\n",
    "    # move channels to first dimension to complay with pytorch \n",
    "    img = img.transpose((2, 0, 1))\n",
    "    \n",
    "    return img"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To check your work, the function below converts a PyTorch tensor and displays it in the notebook. If your `process_image` function works, running the output through this function should return the original image (except for the cropped out portions)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "def imshow(image, ax=None, title=None):\n",
    "    \"\"\"Imshow for Tensor.\"\"\"\n",
    "    if ax is None:\n",
    "        fig, ax = plt.subplots()\n",
    "    \n",
    "    if title:\n",
    "        plt.title(title)\n",
    "    \n",
    "    # PyTorch tensors assume the color channel is the first dimension\n",
    "    # but matplotlib assumes is the third dimension\n",
    "    image = image.transpose((1, 2, 0))\n",
    "    \n",
    "    # Undo preprocessing\n",
    "    mean = np.array([0.485, 0.456, 0.406])\n",
    "    std = np.array([0.229, 0.224, 0.225])\n",
    "    image = std * image + mean\n",
    "    \n",
    "    # Image needs to be clipped between 0 and 1 or it looks like noise when displayed\n",
    "    image = np.clip(image, 0, 1)\n",
    "    \n",
    "    ax.imshow(image)\n",
    "    \n",
    "    return ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f9466ebfe48>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# test image processing\n",
    "image_path = 'flowers/test/1/image_06764.jpg'\n",
    "imshow(process_image(image_path));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class Prediction\n",
    "\n",
    "Once you can get images in the correct format, it's time to write a function for making predictions with your model. A common practice is to predict the top 5 or so (usually called top-$K$) most probable classes. You'll want to calculate the class probabilities then find the $K$ largest values.\n",
    "\n",
    "To get the top $K$ largest values in a tensor use [`x.topk(k)`](http://pytorch.org/docs/master/torch.html#torch.topk). This method returns both the highest `k` probabilities and the indices of those probabilities corresponding to the classes. You need to convert from these indices to the actual class labels using `class_to_idx` which hopefully you added to the model or from an `ImageFolder` you used to load the data ([see here](#Save-the-checkpoint)). Make sure to invert the dictionary so you get a mapping from index to class as well.\n",
    "\n",
    "Again, this method should take a path to an image and a model checkpoint, then return the probabilities and classes.\n",
    "\n",
    "```python\n",
    "probs, classes = predict(image_path, model)\n",
    "print(probs)\n",
    "print(classes)\n",
    "> [ 0.01558163  0.01541934  0.01452626  0.01443549  0.01407339]\n",
    "> ['70', '3', '45', '62', '55']\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(image_path, model, topk=5):\n",
    "    ''' \n",
    "    Predict the class (or classes) of an image using a trained deep learning model.\n",
    "    \n",
    "    Args:\n",
    "        image_path: tensor image of shape (1, C, H, W) or path to the image which class need to be predicted\n",
    "        model: neural network model of type nn.Module\n",
    "        topk: number of top k predictions, integer\n",
    "        \n",
    "    Returns:\n",
    "        top_pbs: list of top k probabilities\n",
    "        top_cls: list of top k classes\n",
    "        top_nms: list of top k classes names\n",
    "    '''\n",
    "    \n",
    "    # IMAGE PROCESSING\n",
    "    # scale, resize and crop image, return numpy array\n",
    "    if isinstance(image_path, str): \n",
    "        img = process_image(image_path)\n",
    "\n",
    "        # transform image to tensor of shape (batch_size, channel, width, height)\n",
    "        img = (torch.from_numpy(img)      # create tensor from numpy\n",
    "               .type(torch.FloatTensor)   # recast tensor to float dtype\n",
    "               .unsqueeze(0))              # add 1 dimension left for batches\n",
    "    else: \n",
    "        img = image_path\n",
    "\n",
    "    # PREDICTION\n",
    "    # set model to evaluation mode\n",
    "    model.eval()\n",
    "    \n",
    "    # turn off gradient tracking to speed up prediction\n",
    "    with torch.set_grad_enabled(False):\n",
    "        # calculate raw outputs\n",
    "        logits = model(img.to(device))\n",
    "        \n",
    "        # calculate probabilities\n",
    "        pbs = nn.Softmax(dim=1)(logits)\n",
    "        \n",
    "        # select top k probabilities and classes indexes\n",
    "        top_pbs, top_idx = pbs.topk(topk)\n",
    "        \n",
    "        # transform probabilities and classes idexes to list\n",
    "        top_pbs = top_pbs.cpu().detach().numpy().tolist()[0]\n",
    "        top_idx = top_idx.cpu().detach().numpy().tolist()[0]\n",
    "    \n",
    "    # RETURN probabilities, classes and classes names as list\n",
    "    idx_to_class = dict(map(reversed, model.class_to_idx.items()))\n",
    "    top_cls = [idx_to_class[idx] for idx in top_idx]\n",
    "    top_nms = [class_to_name[top_cl] for top_cl in top_cls]\n",
    "        \n",
    "    return top_pbs, top_cls, top_nms    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([0.9663892984390259,\n",
       "  0.027299558743834496,\n",
       "  0.001492737210355699,\n",
       "  0.0014003303367644548,\n",
       "  0.0011252566473558545],\n",
       " ['1', '98', '19', '76', '51'],\n",
       " ['pink primrose',\n",
       "  'mexican petunia',\n",
       "  'balloon flower',\n",
       "  'morning glory',\n",
       "  'petunia'])"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test predict function\n",
    "predict(image_path, model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sanity Checking\n",
    "\n",
    "Now that you can use a trained model for predictions, check to make sure it makes sense. Even if the testing accuracy is high, it's always good to check that there aren't obvious bugs. Use `matplotlib` to plot the probabilities for the top 5 classes as a bar graph, along with the input image. It should look like this:\n",
    "\n",
    "<img src='assets/inference_example.png' width=300px>\n",
    "\n",
    "You can convert from the class integer encoding to actual flower names with the `cat_to_name.json` file (should have been loaded earlier in the notebook). To show a PyTorch tensor as an image, use the `imshow` function defined above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Display an image along with the top k classes\n",
    "def show_predict(image_path, model, topk=5):\n",
    "    ''' \n",
    "   Print image with predicted class and bar chart with topk probabilities\n",
    "    \n",
    "    Args:\n",
    "        image_path: tuple of (tensor img of shape (1, C, W, H), img label) or path to the image which class need to be predicted\n",
    "        model: neural network model of type nn.Module\n",
    "        topk: number of top k predictions, integer\n",
    "    '''\n",
    "\n",
    "    # process image\n",
    "    if isinstance(image_path, str): \n",
    "        \n",
    "        # predict top k probabilities, classes and classes names\n",
    "        top_pbs, top_cls, top_nms = predict(image_path, model, topk=topk)\n",
    "        img = process_image(image_path)\n",
    "        img_class_num = image_path.split('/')[-2]\n",
    "    else: \n",
    "        img, img_class_idx = image_path\n",
    "        top_pbs, top_cls, top_nms = predict(img, model, topk=topk)\n",
    "        class_idx_to_class_num = dict(map(reversed, model.class_to_idx.items()))\n",
    "        img_class_num = class_idx_to_class_num[img_class_idx.item()]\n",
    "        img = img.squeeze(0).detach().numpy()\n",
    "        \n",
    "    # set up figure to plot image and bar chart\n",
    "    plt.figure(figsize=(11,3))\n",
    "    \n",
    "    # get image title\n",
    "    img_class_name = class_to_name[img_class_num]\n",
    "    \n",
    "    # plot image\n",
    "    imshow(img, ax=plt.subplot(1, 2, 1), title=img_class_name)\n",
    "    \n",
    "    # plot bar chart\n",
    "    plt.subplot(1, 2, 2)\n",
    "    sns.barplot(x=top_pbs, y=top_nms, color=sns.color_palette()[0])\n",
    "    plt.title('Predicted Probabilities')\n",
    "    \n",
    "    # show plot\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlcAAADSCAYAAABn2eXGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJzsvXm4JOlV3vk754uIzHtvLV3V1d3qvbWCBDKLFpCFQCADYhEwHlvsWGDQ8MyM9cCwPjNeAIPtwcYGhsf2CA8IBJphm8EDlgdkMEIIYyQhCyOBkJAatbrVa1XXcu/NjPi+c+aP80Vm3urq7pKqChXqeLvzqbyZkZFfRubNeO973vMecXcmTJgwYcKECRMmXB7oR3sBEyZMmDBhwoQJH0uYyNWECRMmTJgwYcJlxESuJkyYMGHChAkTLiMmcjVhwoQJEyZMmHAZMZGrCRMmTJgwYcKEy4iJXE2YMGHChAkTJlxGTOTqKoWIfI+I/Ey9foeIuIg09ecbROS3ReSsiPzQ5rYTJkyY8NHGBb6z/r2I/K2/gOf9C/suFJE7ReSvfYSP/S0R+cZHue82ETknIun8bUXkq0Xk1x9jvy8SkXd/JGuacHkxkau/nHgl8CBwxN2/7aO9mAkTJvzlQyUH+/VEfp+I/KSIHLoSz+XuX+DuP3WRa/qICMtF7PvFImL19Z4VkXeLyNdfiee6FLj7B9z9kLuXC9z3s+7+eePPlcA+beP+N7n7x/1FrXXCo2MiV385cTvwLr9KEmDHv7AmTJjwlw4vc/dDwKcCzwP+7vkbSOBj5VxxT329R4DvAn5cRJ51/kaj4jZhwkeKj5VfmKsKIvL1IvIrGz+/V0R+fuPnu0Tkk0XkR+r1MyLyNhF50UXs+zXA3wK+s/4F9oi/8kTkS0TknSLycJWUn/nhrKte/3gReYOInKx/4b18cw0i8q9E5PUisgt89od7jCZMmHD1wN3vBv498ImwKkX9gIi8GdgDniIiR0Xk/xCRD4nI3SLy/RulqyQi/0xEHhSR9wFftLn/88tgIvJNIvLHVUF6l4h8qoi8FrgN+JX63fadddtPF5Hfrd9n7xCRF2/s58ki8sa6nzcAJy7y9bq7/zJwCnjWRhnzb4vIB4DfrPu/4HfpBp5X13+qKn/z+rhjIvKrIvJAve9XReSW8x77VBH5fRE5LSL/VkSO18ceKKmedxxfISK/U6//dr35HfV4fXlV5z64sf1NIvJLdR3vF5FXbdz3fBF5az3/3Cci//xijt2Ei8NErq4M3gi8SERURG4EWuCFACLyFOAQ8IfAW4BPBo4DrwN+YfzlfDS4+yuAnwV+sErH/2HzfhF5BvB/At8CXAe8nviy6i52XSKyA7yhrul64CuBfykin7DxVF8F/ABwGPidD/sITZgw4aqBiNwKfCHw9o2bv5awIBwG/hz4KSADTwM+Bfg8YCRM3wR8cb39ucDfeIzn+pvA9wBfRyhIXwI85O5fC3yAqqa5+w+KyM3AvwO+n/ie/Hbgl0Tkurq71wFvI0jVPyT+8LyY16si8t8A1wD/deOuzwKeCXz+43yXjvhq4POBpwLPYK38KfCTRJXhNmAf+LHzlvF1wDcANxHH9UcvZu0j3P0z69VPqsfr585/jcCvAO8AbgZeAnyLiHx+3eRHgB9x9yN1/T/PhMuGiVxdAbj7+4CzBHH6LODXgLtF5OPrz29yd3P3n3H3h9w9u/sPATPgUuvlXw78O3d/g7sPwD8DtoC/erHrIr4k73T3n6xr+wPglzj4hflv3f3N9XUsLnHNEyZM+Ojgl0XkYeIPpDcC/2jjvte4+zvdPRPE5guAb3H3XXe/H/gXwFfUbV8O/LC73+XuJ4F//BjP+Y3EH4dvqQrSe939zx9l268BXu/ur6/fNW8A3gp8oYjcRpQy/567L939twky8Vi4qb7eB4F/AHytu28awL+nvr59HuO7dGP7H9t4zT9A/CFK/V7/JXffc/ez9b7POm8tr3X3P3L3XeDvAS+Xy2uxeB5wnbt/n7v39fv/x1m/ZwPwNBE54e7n3P33LuNzP+Ex1ZWvHN4IvJj4K++NwMPEL9cL6s+IyLcRXzQ3AU78FXdRsvZj4Cbir0wA3N1E5C7iL5eLWhfx19an1S+hEQ3w2o2f77rEdU6YMOGjjy87X/3ewObv+O2E0v0hERlv041tbjpv+0cjSwC3An92keu7HfibIvKyjdta4D/W5zxVycnm8976GPu7x93PL89tYvM1PN536fnb/3l9DCKyTZDPlwLH6v2HRSRtGNXPf2zLpX//b+J21mRyRALeVK//beD7gD8RkfcD3+vuv3oZn/8JjYlcXTm8EXgZ8GTir8GHCQn5BcCPSfirvouQat9Zf3FPAfIo+7tY3AM8e/xB4pvwVuDui1lX3eYu4I3u/rmP8TxXhZl+woQJVwybv+N3AUvgRFWyzseHOEhqbnuM/d5FlKEe7znHbV/r7t90/oYicjtwTER2NgjWbRfYx4eDzcc+3ncpPPI131OvfxtRhfg0d79Xwsv6dg5+v5//2IFQ1B6LHH44uAt4v7s//UJ3uvt7gK+s5cO/DvyiiFx7Hlmd8BFiKgteObyRMHpvufsHib8WXgpcS/ySHSbq7A8AjYj8fUK5ulT8PPBFIvISEWmJX/Il8LsXuS6AXwWeISJfKyJtvTzvAmbOCRMmPAHg7h8Cfh34IRE5Uj1LTxWRsdT188CrROQWETkGfPdj7O7fAN8uIs+RwNMqUQK4D3jKxrY/A7xMRD5fwjQ/r6btW2op8a3A94pIJyKfQfzheLnweN+lAP9Dfc3Hgf8ZGH1Phwmf1cP1vn9wgf1/jYg8q6pc3wf84oXiFx4H5x+vTfw+cEZEvktEturx+0QReR6AiHyNiFxXrSCjuvXhPv+ER8FErq4Q3P1PgXNUCdbdzwDvA95cf4F+jejO+VNCEl5wGUpt1T/wNcD/RvwV9DLCINpf5LqoHoHPI2rz9wD3Av8r4QmbMGHCExNfB3TAu4guu18Ebqz3/TjxnfYO4A+A//vRduLuv0B4kF5HeEB/mfB0QXi1/q5Ed963u/tdwJcSxOUB4jvyO1ifu74K+DTgJEFgfvpyvNC6zsf8Lq14HUE631cv319v/2HCn/Ug8HvA/3eBp3gt8Bri+3UOvOoC2zwevgf4qXq8Xr55R/0+fxnhsX1/Xcu/AY7WTV4KvFNEzhHm9q+Y/LOXD3KVRCVNmDBhwoQJEyZ8TGBSriZMmDBhwoQJEy4jJnI1YcKECRMmTJhwGXHFyJWIvFQi2fu9IvJY5sYJEyZMmDBhwoSPGVwRz1UNQvtT4HOBDxJJ5F/p7u+67E82YcKECRMmTJhwFeFKKVfPB97r7u+rnRX/F9HxMWHChAkTJkyY8DGNKxUiejMHYwU+SLTLriAiryTmVtE26TnXXnuo3g6iggigwmoWuwgiAvH/wZQ48Y1kNgd33A3cKcWw4rg5ZSiU4pjB0Bvugjs4jtQ9yGovjqiQktBuNWgSUtsgWtdX1wqOyPizkERjnb6xnAJuYAaWwc3IxTAzzArDkDFzzOGAklivX0hb9PO2UYn1NBLrUIWkiqigoqjW44eMC1+9WAdwwevr9nqfu2NY3P6oa6mvf+O9YXyezQesXpvj7rgR70mx1c/jtqt9jMtlXLas1ob7xjF4lNt88/XV58BZ72SN8achG9nsUoNcJ3yUceLECb/jjjs+2suYMGHCxxje9ra3Peju1z3edleKXF3o5HTgvOzurwZeDXDj9df4N37Ni+M0rkaaQZop7axBdwRNkFKimbdBspKCeD35ZsBAHFVD3MB7bOgp/cDu6QWLvYHluZ5THzrH3u7A3rnC/ff09Etnb5kopYBDq2k8n1MAaYz5jnLLM4+xfazj2K3XMDvc0W11tK2Q1EkK221Ll5RZ23Ko20ZJaEmUoeC9sDilLPecfg/2z2SWiyUnT55hd2+Xc7tneOCBk5zb7xl66Idcjw+YRZ6bFcNVMTM26ANWjILiwFYyugTXbCnbbWLeJa453DGbzZjNZmxtbdE2LRKsC1HFZM0zhqIUnIKTk2PqLK1nvywxN4obpRKskXq4GyLQtonUpCBwKSEprcnNBrHMfYGSGfrMsDfQ72fOnFqQh0LuDS/BqVRBG0VSoukSkoJkS1I8GQiYBYF290qQg7S6+QFC6walgA0FWxYo40fnkSO8ROD99z78iNsn/OXDHXfcwVvf+taP9jImTJjwMQYReazRTitcKXL1QQ5G+N/CeizABRBqhojgLgy5REysONo6mqAkwbSAgDYCOgokhaBCjmhBcJKUAyfeeAZC3lEQdZoGPENSi5Oy+0qNEkBpwJSyKJRzPWUGeX+fZuZ4I0jbBhEQoRVhromZJhoS6gkpLRTFslAWjvUOJrhnijtmRrES6pVvSjaPcoTM6iYS6lJV3FDBUVbCjwgmKXiNp3pRjERBEZcgFw4ugleFqniswyX2a24UM8yI9QL4xgJlVMxkpSqOM8esBMERB4oEETKwKk/loTAMhX4wylDIfcGLYMVDqZRRwVxfYoe2fnoBUDYDjVfvt1scn/FSPN7jSqwwcAxRXYl447GdMGHChAkTLhVXily9BXi6iDyZmMP0FUSS7gXhhBIhCo5gJVEc+jxAbtBGSclJfUbESS1RClQQtTjBigEFcaPRqucUZ7mEYQlDFrIpuUAxoVUFNeaiFHHQQloRKzB1xCH10N99lm7RkbeVXJaU5RJtjtJ0ia3UckxbutSRaJmVLSgN/W4i7/Ys9zNlHygJilPKQC49wzBQcqlq1KVBsFoGjFJgm6r80yQ8KZ4SpbIWAdQFGUuiHuRpqOswoC+F7IVl7ilWSVatvfko7Wnc1jSJpFF2hCj1ucexc5fgvUYQHiuUnNnf61nuDQwLI+8ZJRuOQkqgBdfYPyK4JpwSb4ooXOTxCuXPoUAZCMUKIaGgtZK4qo7KWhGUiWB9LOCPP/gQz/mOyxbWPWHChI9BvO2fft0V2/cVIVfunkXkfyTGISTgJ9z9nY/zmGqHibO3WTih8tKQAVISGgTUUIuS4Eiu1mfwULHUBxQnmTP0hWFw8uChlOR1mSqqkKXWkMKvtCoWSZS8ZiTY7xnOwXCup2kzg0C5Zps2QfKGFqFBSdKQaCiWGPYK/Z5R+rWK4yU8VmZD9VsZl9qtKZWUJoFGodUQ6JIShCTFxdUwCSIhHuzCzDEc87iMlTyzWga0ghWr74WviIdVdStKsWsPl4+eJxsVJInrtn4OMyPnTM5GztUHZVWuSlTvVlXQxPFRkxPqe3xx8Oq7i/0H6UuMZV/BqvJ2vlo1UasJEyZMmHCpuFLKFe7+euD1F7cx1YCu1TwdEpIDli3UKRMMQVLYrEQMUQ9yJZvkyrFiYAXMyYswjPd9Jg85DO3ZoVic+EtZlcmicFbJSb20JLwUfBf8YcMaw1OGvYyqoo3BzFBTks5Q6yg99LsZWypiCpSqEo3kal2GMxMERVGkzsx0D8u+MP67eagOkjHBwnIG4afS8KgF8VRkrLPVy1g69NFYDivy4w4mXomVUUrcp1YYoJYgR6N5HP8kiopslOHGKxIstr6G1fNkxwew7NhgeD0+sfZxmQLquBouayO9VIIntcnV3WpZ8zyPuofCRVEohhSQajDzjc2mMuCECRMmTLgSuGLk6sODV1O5gQaJWpmttQpLBfIQOoZhqBgiHsSqkivzAVwoOWOWsWyUvqeU8PX0u9DvF/rdgWGRKX1BPa2Unk4LQlyfJSOhKIWkQimF/t5dUumYDy3MC9qDDB5m89SQ2o7FXubs6SV5P4E1FC9k8yBUZvRDIQ9gJVShUFbCXq1Wqn9p1QRYS3W+olgXErpEoWmUlBJtm5Am0XYtbdORtAkyElLQaqfudb8e6xpKwdzJbvReyFbIQ6GUJW4Z0zA/uQrSJpRMEgkflQEiYXh3SF6C4ADFJYibGWVRGBbGsHCsBxvGDr6qF6qFetUoNAYa7zWqtYwnVcSy+jKqwX6laEmUJTP4oEQNWFHbOG4Sr/uRipUEwZswYcKECRMuEVcJuYpS1Oh4clk3mx1IJqjm61wK4lEycs/EaTZM7OKODX0lL85yb0nJA0MPyzOFfjHQ7/b4Mvw4rZQaoRBltep5p9U45Qv1NpFgeIuC7zm+C6aCaYJZi3fKMheWex4eIk/VZ+Sr0pi74SUu0co2ttIFewySFwRSHLLX+IbHOG6xPiVpIqmgqtUDdfCyiYhYCNO6ua+IXnGjlELxguGUHB6pYiU+KdX3lAiik1Kqx4XVvhSwUU5CovRp1cBfwl9VcgniW2xFaFzDNyY1yiIUt01a+Ugc+GxUf9XYIYgVfCRVHg0BmrQes4NEamwWmDBhwoQJEy4HrgpytS4nAW6YVeWqdoStN4SxvFVyqXlRpfprShjbreBDDoJjzt6ZgaHv6ZfGmZNLfChQnM4aFCFJCXIikMRW5cBGILlFwU7CZ6QpkbLgi5FcBfGxWYPlhCcjLw3PjnlB0DDp12610WMVhu9SL5lEoWChktWqW4hB9aSvPCrDGg34o/qmY5SBHuzgu9BBH0t4tpE7ZSWUrOJjLhg4WpsDVw7wyPrS2rLpq3QszgvcAKj79/CcFYuKbalkCPDqbxtLg67VDyWPJIUXKuWt4hds4zISvHrcRjJ1ocdPitWECRMmTLicuCrI1VgWdANUKJXMIIJbw3hSHwmXm6wiAHKBPGSGYWC5WNAPPXkxREkrO4tzPTkXpAgMCSkJ9VIJlNNKJonSqDAXJ20Y2dMGYXGFpkl0zZyZzGmHFt9NDDlxdsg0Wz3aGq5jMGmJAE4HH0qoQ0PGS4FSkNIjuUdtoKtxEilBUwpOqFa9CDkpQymUmnM1ciV3UI01dglmbWLeJromMUsNXdOEsqS6Ilijed7cViXB0Vhvg9XA1ULOmd4y+8tFxETUcFSloJoqMQvFp+RcPVLVCaUSBvKxQcHqe5sLy70l/SJjQ8EHUFcsVWLV6Mp8zyp+4SAZ8ipljvzNSsFq5AYmUL1cnoEsK2FwtHEd+MTZI6MYJkyYMGHChMuBq4RcEZ4rjZyrIr4mVyszdiVc1f8UXX5GKVEWHKGkKGk5ZHOKJ7x6ehIFUQuflQ/RoKbQiNFKIomtFKBQsKoXShQEuibRNomUlCSJRluSNuAJG6L7TrsgfTY6gSoJsbIuCUbmUsGthOG6lvPASLWUlcKhHiqWh8tIdIwiWGdMqXoErDYR5JlSXV9KK+XqfPXKq9I0Zmz5Ksm+RNmurjPnjJOqv3zMqyqE5ldfp3sQXahmcznwfqz8VsWimaBEWTCUJV2pVas8KyUM+WuR7IAY5hFS9UiYhyKWDS+OlDRmy66wSuFXnUqBEyZMmDDhiuHqIFce/h5qqGXGV4b2kmxFDlZkwX09PqZIlK4K5GE8gUeZSxxUEi41fFQKEafptDgtYb5WNEp0kbZUCZUj4ohkREGbjqYRmk5pW2WWhFYddUMSmFiNYYq6nrmuQi1DGeqx3GPDPpaXYD0NBdEMecm8Rg6UFkptZpzlwmDGQKEXJQN7JIJOGkmduSS2UmKrbdjqGtpZQ+oaUttWtWkdGlr1K4pXdayO4cmlsFwM5Oz02dkfYCiZDFhTkBQdiDRA4zSdktqWUkmcSSWH7uSR0QghM2ZHilCWRr9fsIWiOTxV3hm59VWJURtWo4+MaC5AFZF63cO87uKQI1IilTZiNTL4ckBM8TFXFqKEuTLAV4IqhZTG4uuECRMmTJhweXFVkCv3KPGM5KoQOUcRrhDG6E2CBaF0hUn6vJTz0QVfFZOIeCDG4mxiJbaM8/dG8vbI9Y1p4WOJTSXm9YmswzPHEpgo61iDMs7Rq34rGx3XEXaaKhFpUvUXSZSqkhul+ohEFE81Id2gSbUkaNCmRKuhWjVNS2oSTdNU5eqgmf2C6pVHF+N4HEsx8mAM/ZJl6Sk6gCpqoQaOQemsItSpx6Nar6CGh45vavVZ5ULO1TRffHX8pXrDkCjPbY4klGo0u+D74eEDG7sex7E3o3es1pfXn4dxn49SBjzf2zVhwoQJEyZcCq6Ks4rXzjQrpXqv4sSMew2xHE/+cck5r8zh431eCZaNxvjRa4PWF7l+qXF7nM21DjYWTZWMPNKfI6KopEqm4jKW8lbdbvgBY74VqyGWtRvPMm5hYlezGnSaUSm0ibg00GqhUaepXqouwawRWo3rDdBKdDPOktC242UkVomkDWn1etYlwtXxrusc/ValFEptDhhKps+FXMpqW/MS+VyVGI5kaiRWbBBfHXMkLNS3Uup7m/NqLE5sbFWV0mrAH/mab4y+eeTHU1wRUpT7HChRBgx/lWFePz/nP26DWJ1PNEXWlwmPDhH5LRF5br1+p4icqNdfJSJ/LCI/KyKvEJEf++iudMKECRM+urgqlCvcKf2wynTKuk4B78fZdRc40boZQ87h6bHqZbJQSrCC59q5V+yAEXo08iRR0qhc6ahc6Sp6YSRnSbX6mWrkQUpVuVqvw1WRShKd8EmNBnIvA1iG0pPKgpT36ejJ9CQvSFNq+c7rPD8nC2QRijm9GZ1CH7mnMVRahHkLzUzp5i1dl2g7peu6te9KD5IqqblUcZOsiGoeBpa5Z9kP9IPH2BspNAhmA62G09wto01HaiQuCSRV/5fGMTWTmMlYDIboOFzu9/R7PdYDOcqnnkBSITUpiJRIdAlWeWxctpV1hEKsWmrJN1o1x1iH6HIMpUw2ibQ8kqRtdh1OqtVlwX8PfIG7v19EXvEX8YQi0njksEyYMGHCVYer4szisDrRl/Ey1MuGWuUbBGpUWzaJVdkov42lIjdblwg31K7Hx0bsQE0hl2psf7QXMY5csTpfzzbKbpgFObGMeqaRQqLQSKkKldMqtOqhVqnRqVeVKpSsRmBWFasuKbOkdE0ipSA7TUobytqYFyUHOgZXy7V1t2BZHc+yGthcY6pISWvaQiE1QtvIqoyqoxEq5stU1WhkgDU4dSgxnDmXauKvKpJGB+Y4KDv8baOquFaXRPXAEOaVSX0sB65mFwJeOwCRlbK2vr7h2ZM18QUO7v8JABH5ThF5Vb3+L0TkN+v1l4jIz4jIvxKRt4rIO0Xkex9nX/8aeArw/4rIt5533+0i8hsi8of139tEJInI+yRwjYiYiHxm3f5NIvI0EdkRkZ8QkbeIyNtF5Evr/a8QkV8QkV8Bfv0KHJoJEyZMuCy4apSrVecaoUCYBFnJVjARkmqkhB94mB8gWTkPkMeOPK9+K1+V57wGj1LjBR4L6xP9eHJe+63WHXibpTY/kKru9TZqFIGVjJcMNiCekZpp5QqtVtO5euRoAbl6ipQw61vlwVkSXpW8rVpPlE6r76ohNU2EiI4mc9ZEJRSb9do2y6q5+qJyYcVwRpO5CtXPVbsS07p2OnYKmq89XOumgghUDb8VtVQbSmHUAsvaZ7Xp2xo5rMRqrazJsJCCWI3p9jWKYez+G5UqidbSqoqN9218fsTqe/qYH4OPVfw28G3AjwLPBWYi0gKfAbwJ+AV3PykiCfgNEfkr7v6HF9qRu3+ziLwU+Gx3f/A85erHgJ92958SkW8AftTdv0xE/hR4FvBk4G3Ai0TkPwO3uPt7ReQfAb/p7t8gItcAvy8i/6Hu8wXAX3H3k+evRUReCbwSoDt87SUdoAkTJky4FFwV5ModhuU4b8/oKbgYBeipfflSwqRdZYvxnFiqMmXFsL5QMvQZyqpUVJO6CQ9QQ4xSiYYyiU63ap4fM+IFVoN9iwDS4Ckxa4TSzMjNjBytbQjR1u+k0fINhIFezGr6ecZKhjKgXmg85hnGhJhEQ4l8LXcslegWLKBJGIoyeIk6mgkdCVRIrZLmQmpBWqXrZqSmQVqHNAANie1VyvzgGSMiELwqVNky2XsGW7LrxuA94pmmHAJNyPw02xzmzM4+L9kpfFw+xLUn5/zZ1i5/1CR2dYeC0RXYbwZOdj26TMx2GzDFB2E4J5RFg/d1rE9yrHMkFUShNFajLgRNunpfbZwX6bpyzVmJfC7xOjqyhpGGeqUREVEbFVN9l41EqZllDWUdstr4AdI1Nj7oE4NsvQ14jogcBpbAHxAk60XAq4CXV6LSADcSROiC5Opx8ALgr9frrwV+sF5/E/CZBLn6x8A3AW8E3lLv/zzgS0Tk2+vPc+C2ev0NFyJWAO7+auDVADtPevITRIecMGHC1YirglzhRM4SVktThfgvvEdsKC9jB5lWeaisSn0lxrUUCeVkzD1aqRswRiR5pAZECnlN9haFNJrhx5JXLSWZalSeqsxSd4V5+KQie0rw85QsO1CmLNWEHzWssfQlGilcjVBH3shK+lJXtJ7wW+9RUVoBSy2aLEp2qUNlTitbJBKtg3oQh6SLiJVwp1BQrWU5U7AGGebIMpGWHbPhXnxoKWWHsnUGugzcDD5w23LJN5WEnj7FfQ88xJFD15K3Wu5pjPt2GvoE28uOnd3E0uBcTWS3EmZ+LPzrXr1UKgR5U8OqTHXBlPSx/AerKIYYKRTv6zjeZvyIjHsQCHWMMdM0dtK0MbpHNdL4I6ZhfFQQrCcCt3L3QUTuBL4e+F2COH028FRgH/h24HnufkpEXkOQm8vy1PXfNwHfDNwE/H3gO4AXE4oaxFv437r7uzcfLCKfBuxeprVMmDBhwhXDVUGuHKeUITrWLLOwULGyeVWOQvUY6ndz09SONKSmdHsdhWOUDKUfPVaEqd02nytOzD3Rrr8sERpaHNyFVL0/mSA/SRJKg0rHIG2oKC601WMlVg3UXr1G4/OMJbc8UHKPlQG3DGPHYB08nYjuv0ikKiRTzGGQ9WzBRhNJ+rAyNQnThHQN0iVkBtoOzLb2Sap0KWYMoolGZkiNdFC3IFky0DenGMpA8V3ce9x70vIowpIy67HuCDtdzyc/7W5uv/UoTzqUuPXanr3jOxzJN/Lu/+k9/I1rj9McLrzpjsLbDjvv3jrE9u4cKYaW/YhcGAy1QitOajSip1IMZ3YF0YSLr0qvB2BQJzev46hKBLV6ARtWqRbxeHStRLEmTSLGPDltEuaN0tSAWJECoqiU9VM6VRl9QuC3CRL1DcB/Bf45oWgdIQg8mPbIAAAgAElEQVTMaRG5AfgC4Lc+wuf4XeArCNXqq4Hfqbf/Z+Cngfe5+0JE/gvw3wFfXO//NeDviMjfcXcXkU9x97d/hGuYMGHChL9wXBXkKlAHCVcT9OBQrFRylRiFDRFjIJSQdVTD2kgeioZVz08lWDUaQFRw8Xq+VgYguVBciaa3EqnsCm4x8sVMSSjqSjHFayjnGEs5BnTG9doduOFnWpnZa1zEmMyuEupVknFAdAl/VYoaZar+KCXI39I6TBNFW0gd2nS4QpIdGpnTyCxiGhBaV9waGu1IohQzxON5KAOaBygLCguKKFlh0fVkDE9wVHqefHzg277qWm5qdrB2oJy9i/2yT/NgYusk3Nue5oYbD/HUXGiWwrIs2TOh11RT6zPFPVQqt2qyBxfFlLXPCrtAN194udYG8zjO0aDA2kNfDPE6L4dRGQui5ZVRq0SERZucWbJKrCAlBymrrsHR4P4E8mC9CfhfgP/k7rsisgDe5O7vEJG3A+8E3ge8+RKe41XAT4jIdwAPEEoZ7r4UkbuA39tYy1cSJA/gHwI/DPyhhGHwTtbEa8KECROuelwd5Koal0ffi5VCHnOSAKTUQcS1o6x2jPnoaRpn5plhpnjxleIRLfujolEVpkqwBCiEUuQSI15GZQsNv1UKPSm205hzGOGmHKhXjSkCvrGWUiLfKZeMlQFKxslBNsRqFETsIh5vmKeNjrl1qcs1gTY0KRLYRZ3UQOsdXd7icIYuGdtJaFVo2oLZQyQS0grZlcFgL2d8mUh9x35/CIYOy1uU2b2odRyWbZ7/9LN88UuO8rRrziK7D7JwozlpHD/bkt9zjv2tBHM4evgIux+4k0+87igPPeka3qoDe24kE4oBxVAiWNUBkkVTgoA9ItT0PGLjABrhr068QS4rkrW6H33EiJyxthcZX9DqQJeURn01mDuprTpB4y2LGuMThVy5+28A7cbPz9i4/opHecyLN67f8SjXXwO8pl6/E/icR9nXizauvw543cbP+4SSdf5jVvueMGHChKsZVwe5SkIz64K02MCyLwwGuaxPuiu1A1tlKo1DgWG04xjmuZaLqueG2mGmMSNQkChDUjAHsTC0u4QHa/Q/ZYWU4kTcmJBIFG2QpJgKvTkqYWO3Ok5n7F70mlcV5KrH84APAz70aC5Rg9RC2OBBGMLJ5b4iC6NqpbWMteU9icLRGWzPC8evPcwttx3j1hvg6M4pjh0dmM8N7U9H3tayoBnIVg9eh25tYwn2euf0Ysab3+X8l/ec5s4P7XFID3HTzft80Uudlzzfkf5+yjmQ3ujPbtP/nPPw/T2HdoS78lm27lSWd/8Zt94xY+u9D/H8W7bw247yjkPKfWWIvK+c6USQJoEqyyShXBHk1AiD+5iyLht5VqtOwFr6wzWywippdgsyrJKqkmjrfFKgbVo0JbpU2O4KXSN0TXzgVZ1oeBxjJuKT4m5PFEP7hAkTJky4grg6yJVAntfQTEnQNNjC8Ux4moQgNVIoxElYiiCWRlEKCMVJ6pyY9TnSYjAwMAaJOkYhFKJxhp2RUE9kqdYpi9EyyRIz7SjaYTRka3BLpDpDEEINCeFDEI9CU7HIdbICeVAka8y/G0J1Kz4nacG0IOY0CMkSew1kClmgdaEtyvawhTZw/ZGOFz5jh+PHOg7fukN66i5peIim34PUo3OwrR5PUPZB9xQtDT5EBIVuz7BkzNqBm+bX8LJPejq3HJvxc7/5Tj7987Z47qce5ZYbDN1bwL7DriAPHaX7UMeHHnqAI1stLZnrSkd7vXLLEZg/DHvLhp27T/KcW3Z4yu3HePW7P8Buc4jSdBzXhymSWGqobUipJb/orXSVGuiuByIXXMfaay3bmeEloSVCRJMVIDxTMiqfhGeqEaPVUKcaCSIFhHKldTB3qt2Cvs7RWn9QJkyYMGHChI8cVwm5ElKXSIQHqum6CBQtBR9qvQ2jaCU+bqhppLBv1oMsTrIHq0sHNljfboAK2S3UFDG0jlUJL5SQXarSFb6esSPQqYTAxkSrUo3unDdapmCesbIE73EbEI84hkSPEybvQRPFiET1odAJNF5ITWFr1vHkJx/lxM4RTuwkbpmdQjjD8tR9zLqEsIt4xlNBu4S3irRCmwrqAj1R/krgba6p6onU98x2HuRJNzvPfGbiy77wKIkz6LCEPY2esTPCcKpneeosJ26Zs9Vfw73vO8PR7cSxQ8K14jycDW+VfG6fU++9ixuefR2z/YIWR22GSkfWRGkSyoDFoKBV/MWBj4GOsRZjbpUiY37YxiVG4IweqXi3Q+2LPLQo+0FSp9Hw2qU6Ymf8N8rMY8QDjwgWnTBhwoQJEz5SXBXkSlVIhzq6vkDXMDdBOkUXA/unDPcqPRhgCR8M0zECYR3eqR+GYSZsNs5SWxTBzVGrJ12UuRQQp6lnZFchm9GYoa6PSHkfzGrcQMzhG4Y+ZiCWBcvhbMzWyz3JM8kLJkta72iHGZ2DypLU7vNZH38zt9x4jO0jiW52ErE9Un6QdO5upM/kBw1NW+gAPNCTTnTQKYvSo9sJbYFUVSEvlD6TJEWCPYVmfgjtC3l7Dz3+fp6W4KmfrvDw3TFYelngIWCvo9yjsCwc2Z5x38OFd7/tXvTcnOtPDHCq5ezZga0jyg2f8zTe/54/57mHn8Sf/dGDzJeZ6zqnT0JpdshNLcW51fJnlPGiAUAZaZZtkGUzBy9ITqFGmoYSaI64rQZmbwaBqiTaJgjUfFSo1Jh30SXYNUZSRxWamjyPr9Uz9zSVBSdMmDBhwiXjqiBXKDSzFkRiLMxMSR5des1MyX2cdL3IKuXbrUBN7x6H8vqGanW+CjGSqRGS4l+TtA4PTWGHqlU+RFNNE5fRT13J3CMjFyLLKcpvm0OmbXBsaCimWBFk2CcBJodxV1KB244It990LU+6vuNJ151D012ghYYeJNMk4FiUGWXWYEsgJewhx486dFaN+OFk0qTRGphAZ6CtMOxCahOQ8XYgp8IstYAh/YCXLXxwhv2M9kJaFpqssDzMybsK733LWbaHxKxZ0PSJmQvME/vbPVun72Jv27knn+T9y8SzPufZHLn+Nh56YI83/fqbaTTaAoqPx2yDFD8KmYkk9kjbp6qUq9E3G8d+cxhz0sixSmKkFKqVqpK0bChW0FQlK/xWslLG3M/X0iZMmDBhwoQPH1cFuRIRdN7Uso3QzpUiimvCFg0iMaA3l/DZCBY28kuo4viYHLpZKhwVsromhPVcvrH8tBp9s7mvsXQV8wRLsdU8RMuFoa+DnDO0GdrqO7pmrjzlpqN8zidcw5GtPdp2Fz12BtcBo9AvoG0Stg92pENb8EOQ8hYMCRbn8LM9cm2zJpXG6ri4EsJQSxAtUSz3WBNNAb4QGDqkB9sL8ipDQpeJtJixe0/Ph975MPe/19nJ1zOXh2nJtD0cbuHsLLN3a8cxYHbsEPtPu4OjT72Rm1/4iSgzfv8/vRNaEMKM7zJbBXquD549kgi7reYFbkYvSLwBq8drHaI9KlBxf/iukoxlQFvNFhzjLwSvOWManaPV2+U8oaIYJkyYMGHCFcJVQa5QodvuSG2imRWKG7psyH2mdSVvKf2icPbULuSCDVp79AiV5mJgYBvKhJqCWsQ2sBZQFIkxO01Cm4Q0CU1xkSatBiKPZcEV0arRA0MeyHmg75csl0ss79MPZ8AdLT3PvO0Qn/L0p/OpT88kPUsjD5HmH8DaKKM1JU740iTm14aCszjVU05Ds5NINy5ZLBfgSrtUTi8KO/sJSYqWxOA1tmIItUc7AXU0xfqQRGoTqRg80FOyIt4gZ3tYQJvnPPx7M+596z7pTw6BFq7Vc2x39yJDoi3bdOzz8C3QPuUWtt9+Px8sxvw13wpHD3Hd2SX93R/kgfv/jD/8rd+lNMcoLEm+jxRFz3NajcQ0VLd6KM1X7YRewEsBFxra9SzCjWPvNWtMRWiUaERIA03t9mwTVcUiQjVUaBI1dFRDkXwsGW3ChAkTJkz4MHB1kCuBNAupwZPTbreQBG0lBgUmw9VoFi3DIka4aElRBvR1uvdoXpfa9SUEoXLzekpPrAzvDhRf+bQcX8c9OFEjrBfVRFKlkQj31HoRt1UIZS+Qk9HkJcoSfIEzkG2f1CtbInz8Hcf40i84wfHDHfP5nyBpH3QPbwt5gFKUbidM9KU4tA1eoLumo6dw9uySE2ULfCBT4DA0BXwP5JBRNGMtSGnx3lAztIQSNMZsihplUbBdJ50TGAy3Hl2A7nbk++Y88B/PUh5IdE0ieYk8rex0lmjbLfav2Uc/7jj3fvBBshnn/uqTOXpim2XaYbdPDMMx7nzgLs7sO40sSTjuDaYWlVkdg68MiZyFIMu17JcKkJsa0TDmnynupUaLRQlQdWPkjUBqHFGJYc1a/VPqIIaP9USND4Z4Cq1KAKLj0O0iifqEqx7PvOVa3vpPv+6jvYwJEyY8QXFVkCtRaLc7UjZSKWhK9MtM7jPJoVk0DPMWo2W527P78D7ee1UrNkt7a+XhQJmMUDeKRUlx1WlGRACMI5sVoFXQmoulkJKSkoQB2muQae0ZjKCseKbWFjReOO0dSxJ56Bn2FxyVjm/95qdw240nSXY/rd4P8z1knvBU8Bpm2RYlDYLMQbQjDc7eAwsUmM+2mB1LdEc69k/1zA/PSMnofZ/tnYbFyYH5TovbEGrPAHm30B3uIHkEmBKDoG1Z4AFo92bInYl8BvZPZe6/d2D5UA8nl8zuF2ZSkEMPoDmRrVCsIUvHvu1z5HlPYveDJzm16LjvW76S5sSS48uHkOYoTXeY4dCC99zzAD0JlVxDWjd8avX9qI2W48hAzBw1icaAAm7VWzfGa0ioTEI0HqjESGcNtoSmUB0RWw17hhqLQahXQsxrdF8lbSEaTROiT4zZghMmTJgw4cri6iBXIqRWouRWwC3oi4hg81w3UtpFmMfTMlHE8ByhnWMz/vm6g9f/6g7CYkWcfJ1RL6m3AWgJf45Ck6BthabV2rZfO8rOf47qF2rrqJvBlYIwW57h1q3Ci55zMzcd20WGXdK2Mcwzg2wzT3tIKhGh0AJFSG3Ck2KloK2ydTgx7Ds+9CCh5g2lILtLZke6IJeEguM9yJBivM5gDMtCdzjhxci906WG0hc8Q2MtLBL5Pjj9gX2GU7BVDiFneoazmS4l2sawlPEh03qoYSLQbAt5K3FyCd2zn83dN9zMcf8gQ1to245mEBaLPfYX+ysK6+KbvQTV0F6T8Vfv1RhjEcqURQcDZiXiMUavm8T7NXYJ6hi3Onqo4EDHn0o0KVAT//F4f02DZIvY5LOaMGHChAmXFVcPueoSUhzJUo3lcSItfVNJkNDOM05Ls0xgkH0Iz45JGM+J20fKNPqkBaklonG3itZX7qQYaOMew1RG4SqFaqUqq9l3a4+P1041WfmvDK2amNHYkmcdGnjxs27nxh1462v/CES45jbl4788sWgzTenDWN0IZexkS46rMZSMFKPRRLcllLPhR5KU2DnU0e/3lL4PPxWGJpBBkJxiH72jtaPSKJhJ5FxZvGJvDKzn7OmC9XB0e04+1TGc20cKdF2DpgJWmGnM8xMVUmvkuXOq7zn75OvwT3oG1x+/hUP7S87OEluiJJzd/bPsL/dBtI4mqrlWPvrUxkww3yBVDrVzb2XKv0DDQgxofqTxXNDV9ptELuLMEuaF2g8RDRI1xFRWhC4aGqakqwkTJkyYcKm4JHIlIncCZwn7cXb354rIceDngDuIgasvd/dTj7Mf2q2GYo7lgiRIXUKXcbKTriHNBoobaS4M3lDmHf1ew97pfci+6iiL4c/lQHioqKIJmq5ASoga2kXpryBE6AN0Er6qNiUOzxrmXUvTJrquIVXvVcw3fGTH4CAtWY0mn6EbznJbanj/G97CPbsDaR+6JvHg2zve/mDi2V+2zezpZ6ObLymG1UDUjNAxnzeUobA4V2gbpT2csKL0uz0tLfOdOYvFgvmsi/JWKfgyoV1H0kJZGPP5DC/7FGC2k7BFeJtQGHKhFGd+omF2dAvfg727TtLg+A6k7X261NL5HN9bkEQhLbGtQrmm4fSRbeaf87mc3TnOHX4SP3ED3hzm4f4UxfZ44NR97O6dA0kxokhi4M3YT+AW7MltLAdGJIKZIuPQ7TLWCx9pM7+g0CQEgTJQMUot2aailDoiZ9kPNE08n1oTgao198pdsOKrOZUTJkyYMGHCR4rLoVx9trs/uPHzdwO/4e7/RES+u/78XY+1AwGkUbRU43JDZF+5086aFVFqZz2O0c1biiuWoWl7zGNUzuZ5cTSai2q06zeGdhKKlSZ0ltAUJ14luspmhOW9bRJd09E0DU2jB8jU+dfXz+cxI9CXiAr37XbM5ARnOM2wveBYCyeuhetu71kgHA42gNcSpQJigjEgEhED88PQ7xeariWVhs6E/lQoVl3XYdnjtSmUvpB6Y6CQSmQvmEE7T2uPPlFyTYtKLrZmSGpY7i9wEqkr6Bx2jic6Ndgb8HlCuy2MPdiB+c0zulvvoNs6RlMKw/VLdreOcHxxmN7vZ9fOsLt3jiHneC8ZBaXamTeWAleZV+vL+DMbcRKrhV8M6n5WcQ/uWDRLVs+dIxm0gVLrv4rVpH0wSxf5RBMmTJgwYcKj40qUBb8UeHG9/lPAb/E45AqJ9vkorYWUIcWhTTQzX4WDDvMWEPqtAXWgGP1uIpdQYmJ0Cjg6shVoCpYgtUKaJ5oap6DzhKpgqqhAI0IHJFEaTbTNHE0tKQUJU4ntkoyDcA6+AEdxE8yN/QLvOm20y479dISFLPn0TzjMp3zhzdz4lPfAbFkfJdG1lgA8lCwxzKMkJ21i3rb0ewMtQpolZKYMudB2W+SH9khHOpJAvwdstZHzNE/hH9MoJUJejYeJpHNDZ4q1mdQrZKOZK+220+0I7XFwCnoNpNTigyH7c3Z1j+6GOYef/Fx6mZGX95K2TiCN0i8GLGeGvGSx15MzlSSViK2ofqji4X1ylyhZ6mhod7CB1Q0WJcLNQl18DoKkrQ99dcWT6n5iTFKuHYbJDSt1e0lkDLdIbMcF87TO2fJ0cN8TJkyYMGHCR4BLJVcO/LqIOPC/u/urgRvc/UMA7v4hEbn+Qg8UkVcCrwQ4cmKbJIqK4SmhnUa6eQqVSJswluMwtANmRknG0ChDX+hTTy+FYUxyr1lI0ioyN1IHqVXarY62a9CUSF0lWp1EtpUIrSQUoVGl0y0abWhUaUk0CA3hKdJ4cRs9h2DuZHPMGiwLi+Z+Dt/s/LUXHueFn3GIw92CxDvxwbG+wa8ZUx8ypZrotRFowhMkKDYUrARJYlkoQ097XYssBD+7hLNG3w8080Ocvu8cnYIecnS7p5jRbCWK9mgCXyhCw9BnusMdfiZM80v2WM6N7RdDO+8QIC/6CO1MCX94QXmo5czRge1PPM5Dh25geRz2OUU51GGlpaFwtnmYnDNH54e4796H2VsYwgCSgQSeMO+xksiuuMTzd20KxakMDHs91pdKzBLigmpaeaPUZaWEuUd8glRyDFYN8opTKK5RJsZppYzyaE1Hg0UZSK6Rwr/BlKd+wQkTJkyYcKm4VHL1Qne/pxKoN4jIn1zsAysRezXATU857iqGaaRvj4UsEScZuMctTVPw1oMg5YyXRDdv8GJYhj71MWImJSR5EJYUZcFUQ0G1DXLVzhpSkyJfSyq5IpFEqnrVktAgfZpiCLIR8/BGAzZS61CGM+AMiCWkFI7MzvKCT7meF7/gWuZ2H2nXgA6hR7VESbCmQIxajBXwJtYtZtBECUtnMc7GFrBc9LTa0B3q2CsDw8nCkR0jLaGc7WkOQe6NZqfDvV93RBZBhgYfCu6OWktxIydDToDeCmih7DnpdIIBypmC7DlFClvP3GJ53TXk2TPo0xKTQmp36MkMLKAVKJEsf/rMWXJ2kngoaDHwB5wYkK0gSWgajfdDwnvV45QGhlRYDqFmRXRGjcGwhGuJUqrXLDMZy7OKUFbUyCLeCnGwNOpR0VUIinmsS3xdQo4P5iX8NkyYMGHChAlcIrly93vqv/eLyP8DPB+4T0RurKrVjcD9F7MvESFVc5DL2J3npGYdd9DMFDcldTEEMJmRZokmK6UXpAEvNYNKIwO0aWsieduQ5i3aNrRtIs3auL0L9SOJ0JAi5VuUJrUkhIQGsXKQEqNS1AXLjmKReOUG5LiYkhyedsuM537yUba7ffzsTfgw/P/svWmsZOl53/d7nvc959Ry916nZ7pnhuSQQ4qrREmWLMmipThS7ERGgjhRAkQyBAhBgOST4RhQkAD+4gD5EAQQIOVDBCUxDMgQYMSwLQMWJUKxdpEUSYnkzGjWnqX3u9St7Zz3fZ58eE/d7hmORFJNRZ3g/IFi1a1bt6q6Tg3PH8/y++N5gY/uIZPUt+g4m7fagCOgZzw9cJYPwZBxRRgBdxOrdUJNabbH5MMlNs8wU5aWGO0HvI4I49JalNIuDVmRVaKykseoNLTdArZgciHg+5n1MqGdoB5g7bB0JEaqy87yygEnzZN006fRag+3Y6QKdKzI2pG6jGvCDU4XiwJv7RcFzspNG7J6cKo6ECqoa+lBrhVRISWo1oaak9pMWnU9iqHqYRsOD5D2Qc4QDKVguQG7blp9929uMA79m8A2Nn4wVIMGDRo06FuoP7e5EpEpoO4+62//DeAfAv8c+Angf+yv/69v7Pk23ATBzYhBMBUyhkkxSp76nMFc0QYgZJpWCaFBg7BYLsiUk6UGkFgQD6GJxKYiTCpCFYlNTRxVhKiERqlCQEWpRVGK0Wq0KiRwF6JBcIGUCRaQDNL1Yc3ZMMloBjUhewss+Hd/5GNcvnQb7CV0mqANSCus20yIkTDLSFUjAWzVoiGAljkkqeh/LggGy45WZQtycj7g0Vjf7Kh8QpMCt15c8sYN8Kly7uozXHn2g7TbAQtOs72FWmL12r8hzG5R14G0Ctw7OWX3/WPCDnhsYVkTgLzIdEeZSCDsNyyqBs4nPn+0ZP/pi+heQuuIZifrIcvuDoSG1SpRExhN9rl15w4SxiUUWUIxoLaZVHMm40AzFmID1bQmhMIgy11DyqXyVu20pFXL+ljIKy+Mrk56b6Rfg2JQKUgKrPwuEO7DRTdtwQ1s1iDHpjwP8vYg7qEtOGjQoEGDHlIPU7m6BPyzfmMuAv/E3f+1iPw+8E9F5KeA14D/+Bt7ukJJh02bR8rgeCiVIiRg0bCghZoeBauUEJUcHAlKrAO5M3IqGXqqSqzKbFWsIlpFQhXRWNqEVR0ITf840b4NKP0pV8t1H6+zeUdqgqjjD0TnJKfMB1nAPGG+YrVelWzEoHhn2GlGOggGljKMHWJbKmghkLsMqsgokNuMjOhxEU6QstEmgCdDq8CoqTk+WrBaBm4v4Y2Zs3Nwnk9+6j9ELp/HI0QmODW0K2b2hzQcU1lmfdxiEfQALLRoA/leoj02bOVMdprCGIsJDsbkrUusXr/DvPsKsryNhdcgBKCi04yvKrwNEBqW8/kZXkF7PlipWvUmRkFiPwPXCPWkQmPhiZlByELoHBFoa3ArkT62hvak5331//s1rCspFPoerVoWBoT7xspLJqUJ0Jsvf7DKNWjQoEGDBn0L9Oc2V+7+EvCxd7n/LvBD3+zz3R8k9rIx2FcbagkEhJSMXCsqAVzQdYUGJa4NNKEqtMsaIbOeGVErYghQB2yiyAimo2KqYqOMprFUkCahmDVVosYyPC1CRVUW0Qw0OeKOZEXMoStzQJ7K9ptHpSOzNseTQp7ys//bn3Dt4i4feuIqf/P7Z2h1gomjeYLqDM8BzYLPErbOSB3KpW0JteKLTNpWbASMK+KqQki0si7ZgWmXL/3mbU464akf/GG+91N/G1m8CaMF8+NjqskEW9yGFkK3Yvfqd2PVX+Ho6A6j9KscXCyfsR0H7K1ESA3jUcK1Y20JnzZU77nIH34Zvvy519i+JnR6C7EVvrpMNxIIDbVtEfKalkAbprzy8i3OMpA9YLkG6XBJZCvk+9AE4qSmmdZMDrao6poQA+6QUiKnxMlUiauGMFnjS7BlZtUsYQF0Dub9nJyirohYP9hetgdFck8adfIZ1sH6FnAs26b9963kDZY9xAHXPmjQoEGDHlaPBKH9G6kcqJZKiGomxjLE7hGqKkLlUJU5nlQLXZVK5nI/d6UqqAqoIFHKYHsMaB2JVTwzV1WIfb0DgodiqLxvOZmUqJQkaAWeAHckSH9y3mACCoxy0cJXX3yT6y/BYwdP8IFnDtjeOYV2jeguEldlligWmGayhK1KlqLWGRkJOi3vpU09eoJMlQRbCbPjlpun8N7veob3/fB3clgl2tmcfHxMMwlIbpHlETkJrkp98Di6fcDoYI7d+m18NWO5WqNJqEYKnvF1MYtxDHou8spN5/NffgOvnUYjx6sldRwTKiel0m7LocXJ4BXtesFXvvxl3CBoMcQi9sAxlNKKDQHtERdSRbSuqKqCkQg5knNmbErQFm2FrEbWTG5z2QVcl4gf7RMEpUyl91WqsmQgWphVG25++ZYpKlLm2c6+cnI2D6aDsRo0aNCgQd8CPRrm6s/yVuLFGCElmNdKm88yfVuwtAe90lKVqimZfVKQDEEDMfQhzFH74faANFUxV3UkhkDQTSupnGTDZpOsj8UJTh+FY3gqJs1xJANRUBNiv3VooaKTEVorp0n45V+5zd+YH/BXv3OL0fgmcIBpi1gGdbQO1Eohy3fa5+AZcVcJBJpAvy1opXIzF+ZHHbvXLvP4xz9I2Iu0s1OOZvfYmxp11bE8OWV1+GoJTB5tcfGx98P2FfLqTWZHS1xWbO0K1U4NKN1qRXYIsSJe6LAm8fu/dZulOnEEc/NCdndo9P58ek4Lkq8R3eHO7bd4/bXXC8PKy2KBP5hjI36/TSfgImSBLE4nTgyxtHepGGe3ZPgAACAASURBVJmgQaEF00QSIXcViBFjYL1Yod5vVRKKv+0N1duMkhfEB3CGYbj/vesho5s/krftDQ4aNGjQoEF/Lj0a5gon5fyu5HOwsyy5QkuHlMsavqpjkwoVQR1GWzVRWyRJCT8OMJZMhRA1UgctRioqsSozWrHpjdWmcnUWudJPXnnZ1lNzpKPgEaoyhJVW/U7fJqnFpGw0eqTrtuks01VrThd73PiXHb/2f9/lZ/7BHuPxIWpl/ogYycuMWiBQw6rGvQNdY1UH6w6bQK4zlQY012AjpM7sfHSLpd/i8Ku/z7mL38aVDz3Lzds3efX1N7j25LN89jf/LdGOeP+HP8YFz8xf/mP+6DP/io/uhkJun2ZylWAsVKOKOkW8g4UJtxYNf3izhakTLLNjNVvalM8hz6hcsfaE1jJE59bdjk//+nPceCPjvtVvUHIGdgXrmVRCGNVQR7wKZ5UrCQHX3hHjNJOKZhwJ6qSl0q0V6o48BtYGswCtw8p7fGhvjrVsH5p7QTn0G4Jlii6D9LXJvsqlUnheKlIc+FC9GjRo0KBBD6lHwlwVKGSP5JS3b29tJP08TTkHKhpKSy4EwaPidQFSaiVYrVhXprhGFMp3ZU40iL2nUbyvejxACtBSuRIvVZXNL9TLNhsmPULBC+yzFsQUKsAiZEOjECpBKoU+Iy/HxGka8+rxhMN7lxidv4mGU9BQQoYtolJDBz7vSjWrKqwpaQEStoA1CVbl8xgfNOw2K0K8xemt19jf20cWiQtXHyOFxP6lyzz9wU9w++U/oh5fQJox4/OJp54+x/rWKWGUiXs1MgpQZdwUiQliR1o9znMvrliI4yujBupFpmoSMCtEeTe86whVhdQ1X3numDfeaDHbpkyMl4G1M7yEw9m2nvZJ1aHUCh+8bNBhpSwl1ONYWotidJ1ALiYodAVEWmILrZDukXdt7Z3VozbGCggbI6UPmKrBWD20ROQfAr/h7r/6LXiuzwB/z93/4KHf2KBBgwb9v6hHwlxtQuHevTtYGlAl068/H6ogVk7EWimhMzwqoY7QKeNIIXS7lbxAL+Eo0Xtz1V/OeN/SXygndNHCTtrcXVJpvP+0HDEtsE8DrZwQQxma9gqtW4JBjJDMIAeSt6QIxhZ/+NmWrY9tsXf5eDN7jdLgay28qmVC677ltiovbiYlHsicHIAGds6N2K22IRuro8Ry9mXS4ja72yMe26nwbsaVi1fw43vs7F/Fpwdo1+F1ZrwNYSfQbmsJyQ6gXYNxiolz+40RX/zSPea5pcrF8C5OO4IusCQo6+KNHNpcQx7zJy/eI9kulicEWT5w7MDd+iibYqqk/4zpq0wbYxVUe86ZYy5kKxT3SMQwQlcwGC5GWAkQsa4n5vf8sa9VMXqbbUSgbzPTH2tFQ3gnimvQn0MiEtz9v//Lfh+DBg0a9JetR8NcObj1bcEHw5BFyKqbTX6oYpm4Tka0fjC9EYyAUVpylivSOEJIkCCIFRSoG7WuUdmQjOq+VST9WLRisjFxfWWlL14ldXDBK1hRIeZMbUUlic6NpA316TE1HUdbE4ILo85YVSNSnCJ3T0gZFiL8439znde+EPm7Pz5mpBnRSE5TELBuTngpY55pJ079vgk+y+RlZnngTC9uU++NoaLMbHEdCIy3A6cvvsj66EWuv/wcrQhPvOdjjLcfZ/vqNjK6i1//dV7+3d8jH77K5e8YwzbIfgnFVgekxtptbFXxr37lFd56HTwesApHdG2Hrcb4LNCOEmHvlFYdHUE+t82bb8DRzUBtK0wznYa+egXmWgj73rdWEVwMVUUK0AsXwQXMu97oGoIR1AtJXZw6BjqJ5CpjrVFrJC+MYEruHNpMbo3oATUlkMnFcYHJWTjz/S9XaTcHEQJeqpZD5epPlYg8Bfxr4HeBTwDPA/8F8GXgFyicu58VkR8B/oW7/7KIvAL8E+BTlPruTwP/CHgf8D+5+8+LyA9SqlN/q3+dnwX+wN1/8R2v/3PAdwJj4Jfd/X/4C/znDho0aNBD6ZEwVw+2BTf609uDpdpQNgGdEMq8lIWAxEiKCQkKodC3RUt8jagSMDbpc/2z9RWsP10i/cSzg7iylTJijmoiKjRBmc6MJRXzkdKlQBh3VCthlKCNsJ44OYGp0G5PeI4Zp29GmvM11jjr0DKSMfEwYeuENkKlEZZO7jIdMN7ZJox6MGfrlFqcFZjpSmjuwSSN+ZN7hyy8ZbV9gXScaNwYVRWvvvh57r7xIk9dneB1C3WZcRJCCXP2GgmBWAt/88fey1e+esKvf/42s+NAbhXfXtIZeAdhXlFXmSjG8c3AC19eoOliqSbGBHSckdAfKAq6ZdzzGfdKpMxgiYConxkrsL7a5T1ctuTYhKhIE0hmWOWEWrC6mKNsjqTCH6M/zt/w988LamPQ19UHgJ9y998UkV8A/qv+/pW7fx9Ab64e1HV3/x4R+Z+BXwT+KqVb/8fAz38Tr/0z7n5PRALwaRH5qLt/8WH+MYMGDRr0F6VHwlzB15or6I2N+1k1S3qaZ5m5KkSsHAQPfSsvKhIVrcLZFplhKBnteVm4I96v57+zI/gury/9BuAmkGZihrixioIlozahurHgdHaP+mCbybghNQGbONoJdaTM9eRAozUy3mUWlcVRZmerJskJulPjx3O4vYQoSFMTg+JJMQ9sPb0Hk/IebdVjB4hoApLBibN44RQWS5585gqH+ZD17ddYrU/Ynu7RHZ1w+8XnuXwNpudWMGrxUJEzqCgBwZKU3J3c8vTTE648scel98z5/d9SnvvqcUFP5IpOjLkLyaHKgZdfXXLzBmQr5tWx+3kyZcq/HEJzzEt+It5DWqU3ybr5rDdJiP3z9DN2IiUYW4NCVEKleGV4AqucM2ppB2Z2PybnmzRYg76urrv7b/a3/zHw3/S3f+nP+Jt/3l9/Cdhy9xkwE5GViOx9E6/9d/qw9wg8BnwIeJu5ejAM/tq1a9/EUw8aNGjQt1aPjrnivrl5W3vmwdvuiPScJCsD61Ip7opbwJqIWSA3fcNPM4YXThV2BgXFQK1k7omV+S3Xt7+XzWD0pvq1IQi0BDozzBpGLnDccnW8z1N+QDB48a0b3M13yHFF7WO6DkwDUYAukfKYuDfljWDInRlXmgqev023hqqqS97dXAnLYjGaS2O6MQRLSBegC3gGkuPr0vySLjAabZPWCV0f8djFGt8RXn/+De698hI74zHf9R0H2MEM2SnBxZIzVYq9MUkIp4ivC5B1dZNRB5986pRPPDVhvXqcn//529w9hVZr6u01pnu8esN48cWK5A1dPUe0LdWrXLGJo/bsxWtZb4bbTPAC8qy0IlZCjBCCky0Bua9apf5YGE6fkegtopkwgtwarqA5kVuDkEmdIa44ZTZLtX8PvcnaDLOb9fwy9zNTdbZQ8S34Lv//WO90oJuf53/G36z7a3vg9ubnSAnlfOC/PkbvfAIReRr4e8B3uvuhiPziuz3uwTD4T37yk4NbHjRo0F+aHglz9Q3/v2C/wbepchQqdxn69h4YWuCh5XciGbNNt0kL/sCtkLo35qpvCfkDw9AO73qWFRFSJZCcgxVMFka9dsa1kKuKGJz3s0VW59aNV4nzFd06ctMXhcc1d+and7C9wPGzu1zdUXQFchd0WuOxRk8zipBxZiyZ7EsBl4pDzv1QdkC8vA8045UwenKEJ8F9DXTYuuOJa/usR0tWx3Mkj5FTpVt0NHsRgtPpGq0yGmqUFsjlNVYNtjJiUFBD0z1+/D/d4/UbietvtNy8N+GtYzi5vmbS7tMRISiWpzgd4u39z8wLjgFX3AoeoVQMpd++tPubetIfH3LfHqTMRml/rNTJVqpaEkAqI8dEtkyu+oUDo1TL+pBtyGeD7ptAcChD9ngYKlbfnK6JyPe4+28DPw78W8r81cPoVeBDItJQDNMP9c/7oHYoBu5YRC4BPwp85iFfd9CgQYP+wvRImKtNdt/XfVz/YJFCABcBCX3+Xx3IMWCVYhEIQALzXFb1syA5Q1YkGd4lwKArMSkS9H5sy4OvB4ATEWoRmjxnZ93y+Bdep7kzZ3+0TXX+AnffusfhV6/D8TH7H7nE3vd/hNdeP6S93nHy3E0SS6ZdYO+e0x0a0p2y9W0X6Bzi9l4xh8uE3Eh0KthuzfZ7zqFbjqyOsZWjVURCIHvGLJcYmRxwWng84znDbUVWAU4NaZxaMlVlLH7vNtmcybkR3eMJHRl6IOgk43GJp1xapQJ0LZrLKqPmFTWBy5O7XHqv8u3vFURrUggsVwd87vPCV1++yyuzCV/8ozssfMoy0C+A9uHWvukH9i1Y80LY9/v09n4/kkJltd5klc9+s+0nAiFCEkcaI1YBt0hunRwhrw3zTM59O/lsGbQ0Cq2vhm1k6qjlswxEkQ1CYtCfoq8APyEi/yvwAvBzwH/9ME/o7tdF5J9SWnwvAJ9/l8d8QUQ+T5nTegn4zXc+ZtCgQYMeJT0S5grveUMbN3M2C+1oP3NVEk76nh5WzJMpGjLBBFcjVbnMBsXYn6SLuXILiGWqnMECmPcVrQDelWqKgVkkSEA0IrSMcoVrhHjCtcWaS3eX7B/Omcw7wi2D9QQ5BX/+Nc7llss24XajbF17muWVxzh3rKjcol5kxqEmZGcdOkII3LlbMz9p2RlnkmQstISFs5421M/U8CT41hqxgFumrSGGjPbGSuvAqko0IaPJ8bUh69LeMjGyZ8QCnQkSGiZaYacL1BLhXI2HwPzuKXGe0WmgmkLqegZY1UIFKYBmRz1BF5EcEQ94qnFtGLnzA+9v+cTTl/jvfukmi+isUyAYxQB66FEWK1yVEGbUEhhzDtUFSQTttgrZnrI4YFI2BDEt34uy7XDWNi68/A4RR9WJlfWzYtA2mdyPfNkqlnJmX72CQABUMiJGZ2VHNGoZkJceKDo0Bv9Mmbv/l++476kHf3D3n3zg9lMP3P5FykD7u/3u7wN//50v5u4/+G7PO2jQoEGPuh4JcyX0XKkz/JC+87dvqyqcjWH1MSdnf9cPtrv00M9NAcOsIBzMSsUk50IO7+8T6weiN6UOd5IIhqAubFnH+dMTLt26y+hwxXitkBvaBNEqYpuQfgtxezRmd3ufHEeoK6NQM6kmKM58MSN1iSpn7nWZF19rGT8xYa8q80O2hHi5pnnPFn7hlLxa4qkiqxOjFHBqNqoKjFygqQHA8KXjqXTTevg42dYQYzGPMSBByW2LdQ3ewbgDZo4cJfRioApCThmLZcicsMF+lq1CL1naBA1AhYrRtUu+8twJzz8ntGEXcwNpyTgwJlLj1lKJ8b6LkSeuHHBnfkTsAtYakielPejSz7Xdx2EUX61lY9AdlYh7mZ9D+61NkfIZBJDYV7Z6X4VBdsOtN+Y9AF7ECQKG4ZbLgx8094MGDRo0aNBD6JEwVwiEEHuTJAS9f5bb4Im039xzL3tkbAyYlpaeVJGqqsgx04UAMeAh9OYJcMhtV8yWCNZ2G4jV/aH1nM4yCTuvWBNpSFye3eLi6y/xoYML5GXkjZtv8fiH3wvLjJxmvO1YnJ4U/tZR4NbvfInmwifpjpYsV4lRs8PO3h4uNzjhkJaO45z5tVdqvnrP+U8uTgmnU9J2y/a/05LHt9BVJrphIdFNA1VlSLiPGAhKP8TtpASVC54L3osOQg5oHZCYcW2xZkJuJqzvtegXOsaPRxg5Pmroxg3dcwtUMlorjAIehRhqshRkg285OgFGhk2WNHKM55av3LnM//lbtznlKvhNNLS0XhO0Jrqwr6c0csqP/uAVfurH7kA+Zt5BPIjMJfKPfnVGDlNCrPr2XCiGquebeV/VNDPEAkEDLpGUBSST6kyQGiFTjY3cF7vW80TuK2isAiAkUYLmkjVZdQVDIWWuLPS0/8Fgvbvc/RXgw3/Z72PQoEGD/r+gR8JcnUXavEu2YJB3PragETIGfdiubwJ3+4qHBC3GKkipTnnZDvOUIQS8y3jKuCjSGa4KKaG5g36zMGhAcsKkI1rLZFSTpeXk3gn3jhc8cTGSD1dwuiAr1E1AslCvYHbjmK0FnB/v0o1a9g/2uPTY48wWC27Njsg96mlFzbQ5z43livEC4hi2aUnHHTFD2A54nQk0aHBQY53XVFWP3spAErQr/CkolRoVcAK+BsiIQ6BGqLEQmB0dE6bCqRnjC4Fquk8QJS1nmEOmAw1IBKFGoyA7CiFDWNGyJGrGc+D3P9vy5t2M1XfQnBAbE8MWUaBx2AvHfPfHdvn3//rjSPcmq8OWrf0JqVuzXdeETWSNOyqhHE91AlrgolbwCioFNtozQfGQKcgsL3GEChK9VNsC5GB0wcnSt1G9R9FjpTIaFI1aYowCD2D7h5mrQYMGDRr0cHokzBVAoS3Bpg240YZ39Keqn4bvl8/6oaFS7XDtCxG5sJZy24IIJlqMliieDcnWt5EyZMfEiaZlo03KTFNolTvrFXZagdfk7ZL9pzUQazQrJiuqDp5oLvD873yJ3aee5Orjl1nOXmS+nDGbn7LOmURm5QEd1Ry87z0s84zTG7eIzHnsMMJihLcCV2vQlmrelNmx4EBLMie4EFKNtsXz2LoFc1IoH4uR0Ny3zlqQriVZxrcqdp+6jFpg+dlXqY5bRvNTwl5EfVTyEaVs0sk6lhZcApZlDosqF7iBKd5e5nO/fY+82IJK0LwHjGmqQCUwDR3vuwg/9F07bPFqMXkBPCcC0K5yT8gv7Uylh17hPfyq4Cikx75azpiV5qEWelk5nptB+ABEw6OTNNNJJm82SR2qOvRVTqCR/vHgleC9KRvyBQcNGjRo0MPqkTFXpS3YT908cH4rG15fa66cYqZEC7G9hAFLDxgNWCyVihgCeZ3IbUsKsQyuZ4emKXmBbX2GYtDWSzXDA6lZEkSpXajfWNM81/Haq6fw0pJrn3gKLBKrCeSWN//4BkmNphqx5xc5ffmEN19+gzs3T9h/z3leevULHM+hyzW5bugynIQ9PvbBS9SXIi9dfh9P719k/NKr3P6V59mJ21gek0PELswY3WtJXSJOoJkGujaXTchFLqPaI/AGGAv1ZUWmEWscDQKLGj8x2rcWSAfj8YjZlxfMX+t4fHERzZk0nzFbdMRxoDrfII9tQ2eoTfHt23izRkZWlgCyE1RoKyXZPT7xkcz4zTXLWyNCkwnVKaEK1N6wZZkf/vATXJEjdkIgdQ2RMcoC6zLL+YzJ6Ao0IzTo/Rl2ETQo7l5akl7YVJkWJWCutCakbKW06aVt6CGT1bDgeA1lECuXLVAHH4FUQqiUOKoJIRB6MKmrQOxnrwYNGjRo0KCH0KNhrs4GjRXVUsnAHSn4SLzfEytIogJ+VCmgUBchC2igsKDC/UUzkRIETAZrwWPhJ5lm3DowR6wpA+2uJVqGwl6aLoW2cToFe+EOW4eRb3vqCV5Jxzz/het84BM1O5czVXXM4Sk0WztsxQq215wcz1kvjaOvvsrduzeY5gpddiwsc2cMs+AYLdXOFquQeGp/yt07M7r4JCmd0Gwblc7wlwPhzpQ2rJhrZufpMW1oSa8E4u0amoyNWrRW1qeBroatT9WkScK3M7UFgoDkQLVXgyVsbtz7nZZxqrExtCGzMqNqA3acSW92xOsG20p6z5LFuKXaM6oLCrXhdakahSQE1vxn/9GIG8dTfubnj5mly1iokJioTdn1Nfv1ku1LI2w3A89iR0vC8nk0R6o2MhKlk4zHTOMN4oqpkfr2XLYyRKU9eNS0KwsKFsAqurVgplhWDCOHRBtSMVLSM9E26KwqE6pAVUNoCrg0BNDQD9EPM1eDBg0aNOhboEfCXLk7yTIxCIFCYN/wkDYnO+dradqGk1Qxsb49VCodFgMeAxYjSQKdCOtk+CIjkvGgmCUcIegKLWdYVEurMCO0rvja2c+wf+uUl15Y8N6fuMwzH93Hfm3B+fo8fvs23HNaa+nWHfWk4tXpkq2Pf4QnJ/vMju9x+NZ1qJwXbl3nHol21TKaZ05kwc03Tphs7RGrPd48OeblGyesV/Bkcj7x9CX8s6+Q3rrLfmXIRdBJxL7dadYTbnxhSf5sZnvLkWmmmoCeg/hXAtE6fBUQMdZxxlxh9845Vl/MHH7umEuvBURb8uQ2OlK2tyJptMXp9Ih75zKfvjUjSuDvfm9gZ1uhDmX4XQXLjqRQ0Npdx1SNpw9afvI/2OI3Pn+DxTH8wPdf4NkPbnFQrzh/MGYRAhZgqz0m7kdWryuWJqw5oG4g10pbBaJH1EC0cK7MNuue0kfmyBmI1BLl0mVy7grfigTR0BHUCVIUYiPkKiCmJaS5EogQxuV7FmIsxH8tGZUyVK4GDRo0aNBD6pEwV+DF7GgZmtpgGeQMc9TXrsz7KJNCPRK3fjZHsM0sFUbBgxYqVqfCOiitlOqHbgalVZAouHa4GuWsvskxFFoENSN3jp+r2bLM4d23eOwjj7P3kS1O3rhBTaa9A6uQGVliNV+x/fGn2f7g+7n+5owlFcsw4tbqLvNVi6jTpsxpgDYkXr7zGtuP73Dj5i1S1xGBO17x0r05bXvKNW8gwN7+mLADs+MVYzMISy48XXPrj5yuE+Yzx3PH2jOXbjfESYPvOV21xlaBybHgf5hJv7OkuhW495iz9VhN2yRAaAKMG2P76h5ytebo927zoQ9dRs69hTUdLhBGgZxzb34iWC4zUqZo6Pj+Tx5w+XJkdifxsWdrqtENKhZo2KfWXXJnhMUcayPdqqMa1wQVRrEjhUgnDaaKSCqsq1y+F+5eWn7m5JwLYD9T2FfZyDmTLYOX2By0VKOskgJsVygI/1CqkxvIbFWG2j0IUoU+DFyHytWgQYMGDXpoPRLmyt1xMu6CueBe9WPt2lPDe9q2guCY9RuAUowYUgyTiZAREkoWxURZKrQqpFgqOTFYv1XmSHA0WAlLLoRJNvNdbuAxcFpn7j65xXgsfEDG+NERF89P8Zswf+OYk7szGgWv4U5oeerD7+VVFtwbBW4t5yQz3jw+IgWIVcQiLOrAxYt71HXNnfUd7ty5Tr0wfD7H5h02HnN32XK4PMIkc71r2UtbyK0VP7CeEFgTLwQu/bWLxeD0sW3rMOfOKzP2YgFzqmfi7RH+Clz/3WPs0GE38Nh//hjNBUijJZojsq6R+QKaSLM14bs+XvOJ744w6bDgmJaWWqkfSiHBe+5n3QASjb/Bh6416BMjdH6MHGVsCX6SiGFGJGDLFrcVIw3EkEkcsV8X0GmnY7I4IqnPFpQzyrtZMVs55xJrs7mYIWIEoWyPaukBSwCtyvapB0c3M/JeqlbEALVAKGHfBOkXIRjM1aBBgwYNemg9IubK6Lp1n/UHVWgQqRCJBJGzluD9HLieqE3ZCkMdFyOrkjXQaSQFo4uJxWhEEiU3AYIRJ4E4CdTbGW1AJ1NCHfEoSPCzihlaNghPVfiDD1/g5cN9Xv/dt7h2MqWrEqtX71KfwmkzYXn+mJyXHGXYXtzm9jxRt1s8e2GbG7NbnPvxv87JtQlL63jzX36BK1uPcVqtcZw6KC+99BXOVyPONSO0WbEIDddPE/cUqvNjbBUIb62oXjMWvs0H3vMYuzvG7sdHdNNjqE9ougVTg+oww+1juAncAksVJiNufF/N1e97kvPv2aXuXgLtqAwkZXydWHUzyJGGlk997xIZvYhXscwkUQKwCX17tsq4OVIXDpdqJpIgJywtSF/NrF6HyXiL8FhG6rtgRooVedTRTGqsvct0cswPXBnzxZuZV1YNd5saZ4XniOeIeeF4uRckQ84ZkmOdkdYdOXeoJbInIOHStwaDEZuqICQs9BG/ZUZLFTREqBQ7wzEUBEQBYA3uatCgQYMGPZweEXNV2oImWqCP1lcVSnggZ+T03mSJliHlEt5chuCzStkYFOs3CaW0mepi0HIVyLEljBXGgtYQohFiREMoKAYpryFADkLlQp2FZVVxa7dhdXWfNw8jfm5CGCk7NuJkUhFlhfiItmr46uMVpz5Fugmz2Zx7ccqVb3uMZdVy9NJtrk32GIUGOSpbbWFccS8FbqcFO+f2eXF9SLsScghs721ROTx57ilWqxlHt+/y6d895nPPH/PeqzU/8uxlZBSxeotqWgEZFktUarLBarulPghU5+FjF/eodiFxSKcQbERYR+gUT0bT1tAs8Z0Z7R5Ql6ibmPuOacyFIp/7xqxu0gAzTibkgKeGtArYcsakAR0tYbdgJARIcQUTSDljIRKqwF5Y8vj2FodZObSMSy4tvLPvxaZypaSU8NbJbeozbrwQ4a2g402dDVNegyGEAl7v57U0RhAhxJ5z1V+IvaMeBtoHDRo0aNC3QI+EucKdlErmWzl5369SCRuuo5STukhpG/WLgCoBI4IYWSuSOikIKQg5ClYrpo6YEOoATYBGi3loAjTg6vTIJEAKLwstLTBRDFhVQvzgZaytWAZjrDvMpWJdC1WdkDwi6YjTUSBrTWRMTGP0QxNmccELv/VF/I0179n/KPN2hSwOqeuIpcyknnByesTzN29z86RlIUa9W3O+3mK6hqlWzBYrcmusZMzRySl3Xjol37nNdMtoxolnLm+xux3YrjK2SBCF6XfswflEGi0ZVWvIM9QC6xxwj7iPytJAThCW6KhFp45X4KJU0C8AOBL7LJyckUrJZFQgrIq9Ui3B2KGFrCA74JrQOpAR0FLtqutIt0p4I2iEpnGuauBk2fJSW7OQSETAygxVGV53LBf8hCQrAdxWUPTuTgZMDHXrj5shUOKCNBPKkUQ1I1IRgqKxmHOiFyCpaPkeDOZq0KBBgwY9pB4Jc+XmtG0CFHWljS3EQu6OWqJLgELvdsdFSWcxMAFTQyTiMZLqTB4HsiSSSIkUzOWkG+qaUAXCKBJ3xmhUtJGzlf2zbUQRxMr8lqmgGIKwaIzlaIWKFiMFBTIaDauXiLSMqalyS2MZyaVicvO32A5McQAAIABJREFUn2f6Wsel0TUaGq5d3OL1UNG2a9p2zc3XbjIdbzFbzllEwZsRl69e40PnH6dZddw5ucfh4iaxqqnJJJx1greOdvGFUk0cdmZcfRoufm+NLTLLl5ZoE/BpIFb9J6iGJKgPBU9KTitc1sRRRi+0Jd5mHKglg7eIxFKxEkAqRI0QQwF+1oCCJvDUk/G1RTJUuyWuyJ0+n9ChgiYKagreoaNRqbqFzL6s+OjlKb/9yopZGCMSIK3J7uTOsFRm4MiO5DJVZ77EfEXnLS4Zw0pUkhfEaAjFLQeUUApVBAmohpJRWJUNQREpxrDsMfQLE4MGDRo0aNCfX4+GuQJyTuRcTJFZwixgOUCI71pMEC+nwc3JUfvKkyh4BK/Kyr40ViJTHKgEKpCmbwWFB96Dv/OkKu9+8dI4dDccL4RxC4Ukr8YoRZh1vPCFF1gdLWhPM9tz4erBZfbPnWckwnbl7Gztc3J0xMnsiBGB87sHvHrjFKsyW+Mtnjp3FU6M6XjCLN7kYDqmPcksgRiFOKohKK2N6Tpn/8maKx8W0t51wg6MlzWpFWKuC7/JA2QlrTL5qCOslVhBHnWs85zppIaQcbreTG1qhf3AvJd2axli76OHeOCqDz52A6nvt2iJDm5oBRICvjI0VUiKkGs0ZMgrRiGx7S2nKZCsIVsBh7qVg+cGbhnHzi7FtmWg3xR84Bi6GyKhdJg3w+qbHEot7cBNzNLGXOswbzVo0KBBg74FeiTMFe73zZUGspX1+gL7tD4z8J0nPun/tD+hiiNqZSg9OpJB+5aRbGLjgqONoE1pAZk6+sAJ+e2vsTFU/ZnZ+xOxS9lYxBAUc4gpUhGppObk+WPu/MlbnL5wB+ky62Vmtmg5nB6z/mDF+688xvF8TZ5Nufv6DUaVcmE8hcWSpssEoE6ZnRaOXrtJfW6K+oKDWGNbgZeP7pEbZe+JXd66fZeQdhhpxRNPXuVgb4l2Y5gbdEq3MHQRwSJCTbdKLGYrJotScWrbJVkXNBfBpUMKreCB2k0xVGXdrldvQIyNmdX7m3YorhltHti+i1bQCVWZnfME3goa6BGxLRI6Aiv2yRyvhVONJFeKw+pbxCX/BusH2M0zJiX2JpNxzw98nQwzJUjf5tMyUyWhv7CpVj5oqvxdvmODBg0aNGjQN6+va65E5BeAvwXccvcP9/cdAL8EPAW8Avwddz+Ucnb6X4B/D1gAP+nun/t6r+E4Ka0RKWanq8aFyg1EKaBH7U/wItKv4G84V46IoZIJ0YhmNJUg4sRa0KagG1wMUSVGCCFTOFmF7l2QDu80cJv7z9LvcOvREA4WDcyovKbKDfGWcu+5u2wdjnl/fhbZbVmt58zrJffsddbdii989nOcnr6P/djy7OX3s70jrFZzXrv1Kp10WFTO7Yz49g98AJvfYuf92+QqcvrHLeqQU0ccJcY7HeeunLL3RKJZzmnWxt6qwl/uOLpzzGjVUOmU0ZPnyPNMPl6zuHEb753TerFgHo4YP1MxfbzGR0sk9J+vBaSjrwhRqntuxaSKFktrXipRm6pWgOyFPWYi6Biylm3MFDNE0HENbYHDrg+XyLpFpoFmew/IaD7hO8+fI7y54IWVsfbdsunnhdGPZaxbk3xNyh2dL8m0lKTGQt4vWwnlfZ7hHBAyGSHj/Vapi2/81v2WYP9NHOzVoEGDBg16WOnXfwi/CPzIO+77B8Cn3f0Z4NP9zwA/CjzTX34a+Llv9I1sYJDlkrCcSjXLrd8Ys7fhGDZdIHcvVQwvbSIVJ6pTqRBViAFipL+WUs1wQz2j3huvr2kJbqpYcmasNpUy6StYpQ1YDFm3TJzePWVXp2zFLfa397n6zNPsXDnHdG/KuWbMfqg4HyfcePUGJ8dr3lrcYHR5ip5rmI8yN/Oa19tTvFGO22PW45Y/XrzEc6sbtNWU0yDcyy1BjGt7Ne/bDjxbd3z0gvHdz4yZ5lPWd28ymgSqHSVsG106plsdY8tT8vECmS+Q2YIYBG+c5rLgo1QCmfulgT7cBrVQjFa5uxgWKyHapSWn5bjkTeWwVKs0aKlSVSCNQHDiKJQ2LAGRSBPH1Bqpq4BT9ePmiYNGuThpGMvm4PaE9twff6wEWHsuhq+/bDYE3378SlWR/mg5ZbPQS5YO0l8KONbuXwYNGjRo0KCH1NetXLn7b4jIU++4+8eAH+xv/+/AZ4D/tr////DiVn5HRPZE5DF3f+vrvY6mAoA0Ml1qMYVkRsiR7EqwQKzK201dKidKd3JaYtaBt2BrRFokLBE61LsyV+T9ubqnsyOQNq0hEt4PX5UOZChg0s3vFbSvbAWNJBoEqH2Fe8Uo7fFs+yx7T53SPDNjcWeLKo/Js8SVcJV9q7h1/XVm88w0ZA7H8Nz12/zWK69wbqtiZ9Tx177nHJPxOU6OnS+9+Aa7551nPvlJXvkXnyHN5nT7meU8k7s1H9mq+NS3XeHSVePCx7bg5pL2lVPWs5uMRg0pBE7zkslYYLVCtOP0GKJvwXLBaCSsrtTsPTkm752Cel9/CgQCljOK47mv9FiJnBE36Ci4gjagBOgyskjkkePbGe0J6ilDqCKEgPiaMMq4zZF2H3wfi7eR0RoZZyRvk20HvGFrfIP3Xak5sil3byaSd3RdS0rlurWWjgU5rGjTgmR91YpSYAtiZ2NX5mUejgQBIYQeyi6Okovjls3Qe+zbjrxbRvigQYMGDRr0TenPO3N1aWOY3P0tEbnY3/84cP2Bx73e3/d1zZV7wg3MAim3SCq2J4UOPL6tupQtk3PGzEi5I3uHe+EtOQXpoKFUP/Ts+RX3zeZhT38XOdsYe6c2bUJ58LYI4o7iRBcqKppOsDtLdDJhkRZce0yZ3Z5xujTC6phx4xwtF8zaOR6c5XyMtBMaUc5PJjxzxfnbP7RLs33KPC956vNbHHdzXv7SZziQXcbNNrTCNK7wyQ0+/MEjrly5x9Z2gvUu7VGLrQoKIXsmVEpTQacrxqNItzR8lVl1S/YOIqfrNftXtpCm6z+fUpvL/WwbPc6AXD4lHNwE60obcNMutOwECqZCQ4F8ChAqxdzQEAp+SiPe5bLNaaMyAlUbWgeQQDb6IO7Sbm2qmkkT++0/749vInsuZko6smey+zvqVXq/0gVgdjbMbl7MoVlGvXzly9ag9hE+nJmrwVsNGjRo0KCH1bd6oP3dRlbe9XwlIj9NaR0y2Q1YCZNDkuC5wUPhKplZAYsCiYSIkFLqW4XlhGu9wTJrMWtB09mgekm1kTNz5b5JgpYeQNq3/e4n3/T/EOmjBksID/1sdBBH3ImuVBZo7y4YL4z5XWe0tc35Dy5Y3DykOxrTROPF115E6kzjiSwtlSXGRJrtCdf2pnzHtT1Gh6+i3T0OLm3xAx8fc+c4UueW9EJiW2vm7f/D3rvGyJZf132/vff/nKrqvo+5M5wXh0MOSZMRSb1FKkokJZalWLEM5PEhtvO2FcAIEsMw7MCJEAdO7C/+4FiA5cQJgyhKoMRWHpCsvAAnsgDJjixFL1OiJEYzfIlDzvu+uruqzvn/986H/a/qJkVJFK8SXxFnEZddXV1dVX1OEWdx7bXXmomYGdcTX/VlyrXxDqNAfXXk4tXGNUZkcFpUyrog3mBouBjmI8M8sbplXIwTwxOGXGs03eOeQhSRxzoi8NrQ4dJnBtnhh/d+xxbd1J/UxoYc9/mkhDcEx0yJBjEHYgPhBozEPEKd0NHJAsBCa4rihLZ8TRfCZ5qnctkiiXSNSoupE616aWCPK501/UuOiOn1OUF4+qwOY+Sr5/+4AeoZCbKwqwULFixY8KD4YsnVy4dxn4g8DbzS7/8U8OyVx70F+PTne4KI+CDwQYBHn16FT54hjg573dNqYGWgxJ5iaWgvluO72g7KVWU33SOYQGaCPUhFNRCJrIyTIf02LrgXoOdZdRXrSK5INYODohVgqqgoRS/N7SGORCCutObQnN3tlxnK40zFmYc9sTL05AZv3HmFzbUz/uB3rHnrO9/Oyc1zxhNj2oM/ecawuwuvvshwdgH3oZ6fIdsz3qQn/IF3v42v2QT3b/8q68cmHjk1rtnI7hNn+CvKzsA3b7DeG9OucfKWkXICcq1RAspJIHvl3st7bFRO3wH6xIivJ2a9jwroLPgOzBtWLD1HOwhzpJSc7w2GIpmyXoQgtwPVnalVVusNzI6cNxzDPSitUM+DNoGsV1CEkIF20RjEYZUjWN+vUR3AArVK4wZ37iuv3D1n52tmD/YxMbOnMjFxzp4kWCFJopL4pj6ZWlaSvQNL8pA8TzSazuS4V2DvhGa6vzbtfYVOLLarBQsWLFjwgPhiydUPA/868Jf617915f4/ISJ/E/hHgbtfiN+KCFrN9cDwQKUSrkRT5jLnfarZLQedWKWxuXn2yjlJrjLTqI/6+lgvCFQEVIjoF9c4+KouzepXhTc9jAThcjxIxjCIwGxp2B5uFnarHS1eYrAVr7+mXJzPtOHj3Hr6Lo+8q/C+9zllcxcZzxDdslorPt/CfA2bkYs7W06uD5it2L1ywSx71sNtnn58xZM3GnF9xnYX7D6zY749onGCjY3Tm5Wowi5q9itaIwzmKRhNaBGce2NcVW48fkIMe8I0N/CaoBkRhR9iK2anzUFZ51ZhmyFqVxSLIWK0eaKsR1priAkVRxvIFDQToNDOgnbWMApq0sd/jaK5sZnrg4KIES7okCbz7Vy4fRG8ftGYwzNE9BC7wNzjU50m0Qme5ujyWF6t/dxdqlfhQRPPyAYPzIJW+wzT09TeWuZptTk+KytrwYIFCxYs+GLwhUQx/A3SvP4mEfkU8OdJUvXfi8i/AXwS+Bf6w/83MobheTKK4Y99Qe8iMv8IgappbD9Un9SxHsnVIY6h1tpDPCutVoKJFjuszN2crqR6cUmQcvKnV5LYO126Sq4+ayx4IFOZFM/xMp4jxMmCiMZwc83+2h52d1kNt/j4L245v/sG73jHOePqZd75rg3DjTdgmHtIpxEt0LsVnybm5nBrYB6BNsHgmDacu7QdzOcTq5PHibsT5y9l+KcVh9ZQF0KMwRq1zZg0EMNVchwnQi2wuSkw7gkcjRHxDFZlBsEyt2vn4FBUoDkxK1FzxcCBzY01Ps/QoNWWj10ZM4p6g73DegQK9WyHzUYRg5lMUG97ymqEChGlK4EGoohkbtj9C+e1ezP3q9FEcJwQx2k9cqFmthXeVUbAjeyUvvSDXX6sckNQI+ttIEmX9F5CpIfLuhM1N0cXLFiwYMGCB8UXsi34L/4GP/rWz/PYAP7t3+6biCZMd7N8VyzwFbTijGNj64ZZ6YnaQYTT2kxjxr1S4wIxR8wZbMixFZaRCQFmdkxz7+8xaZJk2GS7msrtSbpEFSSzk0QFw7M6hWAnjZCgNCV8z1wmPvFe5/rLZ9z75Bs88erEV39t5R/5thcAATXE6vH1yKY99uMZQkVprFVgBt8pnJ2wu3PBiThtY2wvGvLJezAppzc21Me2lI0xbFa8cf+Ca6MxrAfu6Y5rmw0SYPOE7NcwzIyPBjefOUmPkzq1VUYfeqxCy5Fpa3C9e5AC6q5RW2M1GjqSIaCToG0AMmYhTgOnMdxV/H7DdE3ZOvXiAnNSLRpBR6O2RlkVYEqVrNwAVzCjlhPKVGBX+Ad3LviZ8x13ynUKTrWaREgcqkATiJL6VPffmx4iOQSJcvVDxaHve++NQqPUKb1laui8BbE06UcBF/zgu1qwYMGCBQseAA9FQntEMO9nUM0tP1WgUbUyzzPugXkqE0mu0tzs0TIRXCJ9Vn1s99mu5MvvQ+TYHSf9R2mk7xlWRwWr+79EuFwlC0KgkOM2j0z0dgJZF+LpR7hbz7jBbZ5472NgExoFdyNKjsNEFa8VUVhrA4NQIUyRoaDDiAqMasRUGa6fshpnShgue5pMnD6q2es3VFbAfHePlUIZFBkM933WxPgFbo3rj4Ctp/y7JHB3sAy28q5CKYLJQQmC1oJilnU1tExTnzKDDMuNQEGgGb5tMDkUmHdT5l6YMJyM6GpFa5WyMrQM+DYPZdQZSuZb0Roehb0MfObsHlsvOdY1R1zzMxGWXYFqqPdUK3VMFMKz2PsYpfC55CiOIaHND5lYgUt2JgoBLQNivcUyFbwCEflTwAcj4uIf9ntZsGDBgt9NeGjIVewDrOElyUiI4ObUOceCHlfIVZ3x7r9R7b/fIwRCwOXygioSPUISrvxXD5Q8qEmQo8ROvDrzik6oklhl1GXPAL+MApD0He3Wysnbr/PYU69hj98FbVk7M/SnVgc7eIQCoabvaK1UCqYjtML5a3fYjEaRQt3u8HBmJrAJOWl5jPpb3VxXPIRpW9GVE7FHrDEMyTZUlZPTgphxfr5lGLU32cyp0pDeMjVDGjQP2uSYCGZpCpemiAnbaUItGMeSpv6dIg3YzxhGO9tlTIUKbAZ0PdLmihQDzVgGauaIZc6DEWoIzh54ZQpe2RVqWSEUijQIoXi+nksw1IkJRz16RhXHOIh+WtLU/nkYkoenZ8/zGObm6eWpiRZ4XbYFPwd/Cvh+csT/BUFELK52EX2Rj1mwYMGC3814KMgVFaa7MzYM2IpeqpzZSa2PropYXrgDvDVqnYkITFpeXjVoftj2iqMKleOvhIf0665kLlbA5cAw07uzOkWZvWJZgMeMoR4U8Z5UHpkqLpmsVUUxhxM75wPv37Hi07klx9jrYqyb9btaogV/tDDVRoSxutjQXtozf+qMsRih4DUYNmuGcc2836I+JmnYrBB1IirIhD02osD9+QJlZjUYoYIYjJsC60KNYD2ukZZ+ozrPx+NukplWddvDOAVsMGhO9UZreYzW10pXBSHOKpwZTGmeJyqrQSg2EuuSAbDzhNiKYKBV0CpYjIhCGweqDlQZuNtWvLhXPnx7x53VU1lRJDMSDYucHkobkGpUGswzrQatThmPoYZGZ4oROJoxDV3Vgu698jy/jQY+sQtQGhYDTAoVvMpl4vyXEETkzwK7iPirIvLdwFdFxO8TkW8lfZH3gQ8AG+B/jIg/LyJ/Engz8KMi8lpEfIuI/H7gPwJWwAvAH4uIMxH5OPC9wO8H/pqI/DTwnwGPA430ZD5L+jU/A3w18F4R+VeAPwmMwE8C/1Z/y/8l8H7yrH5vRHx3fz//JlCBX4qIP/L/2QFbsGDBggfEw0GuApi6ilSsT26SSNE3wziU8F7qUEAf6zlEa90z40go0lPXj6O+3PMjLvcH83mk16wc50oC0jvokLxYd1N37b/rPasyjs8Ma1duiHPKOWMLoq1xS3O+YuCODCva7iJJil1nCCH2gb+0w1+dGWajvOkaAbTZuTg/BwIbIEp6gny7JxMjnGEExoYOhbITpilYrUfcpy7STag26hxEdaQGq8EwHXLzr+66GggmJY9UJ4Ee5DhWBR1L+tbckWbEvX6+kCSLI9BDQdFMdDfbAJZ+phbUCipGEEwUZlbMseJTu4Hn7+74zGToMFBEMhk+JH1VrWASGZBaSifHjdbsmLV1hFwJEb288/KzEmBEVua4YyG0qMjeiFmg6peqqf3HgD8D/FWStKxEZAC+Cfhx4H+IiDckZcUfEZGv7ETsTwPfEhGvicibgD8HfFtEnIvIvwv8aeAv9NfYRcQ3AYjITwJ/KSJ+UETW5P+CnwW+HvjyiPiYiLwH+MPAN0bELCL/KfAvAx8GnrnSY/pIf/5/D3h7ROyv3PdZuJqd99a3vvV36NAtWLBgwW8fDwm5EpgzR8qqYVIoViiloGNBB8XM8KiZR3TwQ4VT5xmvFbWGljGTudVQbajacTyYglXp24HK5bAwLq+/cchJSqLnCBKNRlbCSMDcfdUZLZpBo4NDJdhaQwdD23Xk7Bqxupvmbx+BHnOwukl4Y/6o4/f2yFlj2G8wPcVvGFvOIZS5thx7mrPaWGY0ubMq6TD3mLAN+JCH72Szpk3O7df2THvYXqz56Iszt55+gs3N67zwiy/Qzhtve8spX/aVFWiMA0hJc3+bkzw1guFE0CH9b96PlU8O+8DPK3Y24ishNrC5ZTQa89xQD5QVEiNRC14Vnw7xCIW9Zr7VNlac1zX3psJP3Rm5XdZsT43Tlp62qYyZrt6CFQ1zQ01xCUz3VJ2gJplWyFiNvgCo6jiGRsNV0fAMPe1xEHG00CnNA2pDtwqT4bN/qRrafwb4OhG5DuyBnyVJ1jeTytEf6sSkAE8D7wU+9DnP8Q39/r/XGw1G4Ceu/PwHAPprPBMRPwgQEbt+P8BPRcTH+uO/Ffg64P/uP9uQeXn/M/AOEfke4H8F/nZ//IeA/1ZEfgj4oc/3R17Nznv/+9//JXkiFyxY8LsDDwe5IiMOrJMhEzLcUYVSPC/0RYim4IE1ZY8TIbRKZjIVqBMQgVhgJa+5YtLX/bOS+BCy0PDuOUq/VkT+PJWcoMjYfT1KRPq4TALxw9p/amEejuOMVWBSJr/B2j5D+F1au4a7MLYGnptp9c6O2qC9dAeqYLLCyzXyVBhWt8zzFolgvEF6tsYJVg1TsPUeutcsRbaGt2CehQGD/cgbrzi371UmvcWZPEa1a1x/Gp7/+U9w7xcuePz6dW7dbPDYxGEwOuMwgA6Cr3tOVIXSRmQS2vkWrykMyaOOnAa68lQLZ8X8BGUAbfgs1GnE6wpvDpqp+dgGR7jrGz5dR35tp7xRBpopgxg+GlMIVQTz3B41MTwi+wGj4eKIBJSJqC3T+7ULkAdjexciwwUPy6iHyDocBGiOuRDNk/xNLSMi9v4l2d3claGPkyPA/4skKt8CvBPYAv8O8IGIuC0i3wesP8/TCPB//Cbbw+dXHvcb4fzKbQH+64j4rl/3QiJfBXw7uXn8h4DvBP4g8E8A/wzwH4jI+yKi/iavtWDBggX/0PDQkCszxUqPXSiGmWFFKYNhw2FzDcIOfirBEbx1X5XDvG85flMhmmBFMBkQzcdH7887mtTJCzD5bdKtoJvkD0XOeb8IqZjF4drdf7+b6WcX7tbG7alwOp5S/AxhhthQ2wCz43Nlvr2F2tj4aa+GEUIn0C3VZ3zcYSfCaijYqSHFCanoAFh05ml5BTMu6eIcsGvUVeF2nbnHwJve8Q64foPVzQ23Hn+Kyk1e+Nlf4dd+7Rxa4U0D6AC6ElYn63R2E3id0QCpqebUXUNaxlrYKMjpQOiMzxBtxGRE2KQ/a2rMO2OeA28z6IxqZMefClsvvLgzPraFl5rBqlBEevp9jm0ljqeErOFJ9pSZXNkJKPQQUjIyI5P1r0wFRRDJBYQ45FldQWuRaQ2tZWZYhdb8s0bOX2L4MZJEfSfwC8BfIRWtGyTpuSsiTwJ/gCxih/RiXQdeA/4+8J+IyO+JiOdF5AR4S0T8P1dfJCLuicinROSfi4gfEpEV9Bn9Z+NHgL8lIt8dEa+IyKP9tc6BKSL+JxF5Afg+yZ6iZyPiR0Xk7wL/EnANuPM7dXAWLFiw4HcSDwW5EoQyGONYKOuR1WbFsCnYpjBuBmws3c8zoyF4mShTEC2YdhBVs4OuGjYaMoMPhhfFV2CFvMAP/fX0oHIETqplItZ9WoJGzz4SgzCE0mMeLMkZ4HMWR3trtLmy6/ERP/qhHb/33c/xnH0C8/tobJnraVaw1ODEN8gE2/PKdr9lZuKxd43YemKwBmrdh53jSIIkHgo5pMvrlBroYDjgVvFVAwofeTV4cbfhua/4Ot7y5R/g5z70C3Dngq//2n+Mp9/1T/KOr3mJv/v9f5l7uy3vnWG1EsoKVqstWsBGgXV05XAkLCgbJZr16AhoKth8gobSZpgbeKT5XRnRoTCsM7ZhL9fZTcrOgxfuBi/tCx/VU+Zhg6+MDXOqTA28tu4VO3jgUrkqkpTHxHAZCAlMRxRlrjnKUwBxXAONjFbInDIQl57wf/mZ09bwKkjTvD07tMM255ckfhz494Gf6J6pHfDjEfEPROTnSK/TR4G/d+V3Pgj87yLymW5o/6PA3+iECdKD9VnkquNfBf5zEfkLwMxlyPAREfFLIvLngL/dydNMKlVb4L/q9wF8F0nOvl9EbpL/X+K7I2IhVgsWLHho8VCQK+j1KsWwYogJ0pWsYSioFUIUay0DINW6x92JCaa9Ux1KCEPLsR1NkZLOKK90lUcISY+RHLMaLC+oIYhaljlLScWLXmAcmSYuYpmBddg+a42oDZ9zNinAS29UPlIuePNzj1AIxLcM7Szfewihp0ytcdfusHmycHpjg92EJkYDxl3GIgQN0bGrMYHilMHSuN/T7AkQH1AtiDtxb8Uv/fQF6zc9zrh6lJP1LcZY88JHfplreoO3v/1rGE9u4utTzuo9rBRWaygbWK0aYoEMECs/LgQwpLEpO46zV7C1gLbPyyGGFqOU8Whod6m4wD6E27sN9/fKvQme3yp3Ys08rLForOuew5j2oMFpJzf1oCH15YbDOVIUwzAGGoHGofom4xkU0rD+OcjIjUsBxUhDfPQ9BiOjHfRLlFtFxI8Aw5Xv333l9h/9DX7ne4DvufL93yG3Cj/3cc99zve/Cvy+z3nYR7lUxA6P+wG6V+tz8LWf575v+nzvccGCBQseRjwc5EpyFKc9QsCKYoNhQ6+8OWZWpQ/rUKxMy8aYeQ9zzY0+DaWJ5KRoAAisCG59rKR9w82sJ8IfRkyCUhAUoyBix8qdXKLq0RA9L6nOcxKrmre1OebBG2eNn/6VF3ly8wRP3LjFtbJmnF5mUJi3e3b7mSmcN71vhQ2WJvIWtGYEI7FtWSeDISsF68GodT4eLlUQDZgr7HNEKG1g99qGdn/H+vETrp08hnHCfH+mbJ3p3hleK9du3IJr17i4d48dwWYEPQFOSOKkTgz94NZtpkiokhS0bxFWsGhIUbRkjlaoAYZb47zB+Wzc2xVevCvcuwju1cKrdo1WBkqrjDEzxsRUNoeAh76CmefimAnq3aneIu/wrkp7c6U1AAAgAElEQVSFoAcTVaRq+Os+U6JHn1XW7XAkUBI5Zb268Uk/zwsWLFiwYMGD4KEgV4JQViNlVSirwjAMR6+VmYEpgWIRRE3XsjeIfWN3Xrk4m5jmwHZBXTfaDsoAtjJWJ8IwJEmp+ziqVsPJkNU4a0dFMSmoZOddbiumV8tUKb3Hrs2V6o25zcy7PW2a8XnG9zNDm2lt4o4OvChrPvnL97B5Roryphp8+c3Gt3/1M9x69hVidMKNaBPijbJtlJ3C3JUpcbwErZCJQhsoc0miN5R+/W+0VhFpaGucv2584iMXXEzOM28Sbj53ix2nvPLaXT75yU/y5d/wFfimsVtXnn7Pu3ntV15Hb02UJ8AebXBDCQMdFMaeGzUb2oyYod2ZUM9s1BWBqxBSmBlpbeDe/cbFbsfZ3nj+pTW3L0butxVnJ8Y8OqrBmh0rOUPGQmPNVm7gZUu62pTqh3gHYSI51cEF1TzHr6053jzfU2gGYUU3x8khBFYRcZDABEKMkOwX1O7v0kidLCTzuZKFXW6XLliwYMGCBV8sHgpydVAZVA0VQy1JlYqlb0Ykv5LEyBs0r8y+o80zdW/UnYJMzAGjrLI6xY2mBW2KWByCjlATogVoIN7Hf2JIFEyt9wgOaP9P+t89AybdYaowV+L4rzFHEGFoCCsNwuGiXCfGNbfsHreeEFa3drQBGtcYI83gualm+Jzbbzb28aSmL4gKMg9I6RGeXokuvagJwYraKr6dkLOJcQsXr97j7NOv8vS7P8BTb3sPL33q49wY1ozDCOMNnn3bVzB9+nk2py9Rrlf8FOw0/UkYuWRv4NLwPPToDZCqxAzTnQb3HyG2ay68cX/vPP+a8do94+5k3NkOhIy4DLCHMpMjRwvClMD6UsEerZWQyHGrCK1HlcpBwYpsQHRy888jC5ZbDLQGLY45Ghh5iuO4OZhBr4fE/jEUccvNTTlskdLHngfCtWDBggULFjwYHg5yRaoNivavcnTf9NQpLi97kt6lCJrDNAfzDuYdYJnq3Yb0P6lAzHnBtpAkUz1egQZhAnEwrXdiJ93TpaWPBTNPC88evuaVOs/UeabNMzFnpUpTIcSwng6vAqvYEdN9vvK5NV/xzg0ruwc4MgttrmgT8EKbamZyjRBSe2Rpt1U18N2MD2liF+33ed9ibJbm+n2gtXFiQewaZ6+/wrCaeeqZx3ns1iOc6MCoK1wLz779zdx94REiPpnKD9rreeCwnEcJKKCW0alSBJohLqxGoa0veP3F+3z4FzbcPVvx0bMLtjrhZUVljeicBHHqI0xVqjkUQSJwmQ8pY4Rk1GoVoUkO+CKUXhJEjaAh1Op4BK2Bu+B90/Ow5Xm5qHD4zHCsKMrjqahrz+jo4+b+M1W6erVgwYIFCxY8GB4KcnX0Uqnk2MZStZCeTyVqxGF5qHcItjZQZ2N7r3F+V5guYDU5vlEGgViRKdwyQzUoyhADFoYOxjCvKGpIDBQpFC0MlqNCVUXscN3NaAJvlXm/Za4T8zQx7SfqNCEBRYW9rVBzhjjjrNzkmt/mq0/v8M3vGnjP485gZ1mz0kb0ohJNoEX287XKxAwWlOuSE67BOGRbh0Hx/PujJfEy7aXLrSHAPmB1Ck89VZhiYtTMrXrmrW9j+76vZmxrTn2D6wg28ejjN/D7IDthuDDixgSWZdRJsLJz0K0Bip8A5Gtx0zE3Hn/Hhievjdz58AV3fhaaXyPMiDLnuexLCWgnaWXO3LBBc/SJ03zE+yiwapr685/24H7JiiGEmdYrjpzWtwRbRE/Qd6L78+SSh+exCkAsv3YUrNOvLK0WrJP7hWAtWLBgwYIHw0NBrqCPZUT6xU0ul8j6tl7vZUlPTsoRgNFa3xaclDIozcBnMjbAUqFybVgGVuWVu+QF9eCxOqhmergtfQMt+rjKG63OtJaKVZ2SWAV5IQ9RRLO5zgU0Jp5cbfnAO67xnqcaQ5wRdcTtBG8jpc3Ifg+ATw0twlgMSsNTSMsxpmUVjJNp8212fO6p5NBrfhSaIwOcPGI88mjjvkzstzPVH2U9nnLzxlu4/eqvcv2Zc3SeuPvyntuvXPDI9QE1R7Qdi2SEngkV9AGd9iW7g56WipZcnKA68K6vucNbfo9wst7wsY80XnplYu+bVP9sQMLyWCowZOdf1ALSspw7Mn7BRWjaaCLdt176116SLSSxAppD1KvZVWlobyTpjCufH+3PYb0+STiMDYWr0pkektsXLFiwYMGCB8RDQa5CwDS9Vmr6OT+VK//6hdp7rpJniW9MDi1VmBCYzwWpmTDeCogbTsNpIIJKQAnEYDDHzBnMGUqg4phCjYZ7FkTPuwum/Z779+7RponmDY9ANeWtJjDU+4Qa2zCeHV7iz37Dda6XCcLw/SMoa+reaNXROmJxAa0lOapAbTQNfCWoQiNzsTCQUYhwdIAyjNAUXKjne9p2RoDVY4Vx1Xgmgvtz4+b1l1ntfoWL1+9x9ks/yvlHf4aT3Sd59v3fzFOPnvLo+55giBVy7QJft1QLVWAwdIToRdiQGVI6HBLuyfHZmCPOUY3xVPmn//CE7xvnd27y8z+54/YbZ9y739htjf2+cbFt7M83eGxwuYkLOI2ZOUM+BSYxXDIcdi6pYs3k4XHJbkeXVLRai56cn0pTw0Cjp/IHZnmvIEfF6vC1BYhrEioH612Ux79vwYIFCxYseAA8FOTqICkkhZLP2di6Sq6u3gdIIOJJyOSQfQW4ZmxCc7wqoU54jqJUIouBpRMXyQocEfrWWXRfT6W1yjxP7HY75mnPvN/jrQd72mXcZOAMMdFiZC4b3vZI4Wa7QzDQ7AZaFamNlTpzrejsUILwwNuE7x0b6blc2omOIpY+KFGltrl7sNLyXSenTo0igg0jVWC43rj1JJQdKL/GnY/9IK/96uuszj/GEyeV6eMf5vVV8NhXPUHbfYTh+hZWTqwzV0wks7tyay7fA3ia/+lm/j5ic/W0qzGCGmXdUAuuj2d8/TdvqNs1293Ixfma+/d3vPLyOR/6hT1379zHPZ1pLg2P3NhzlNCaxnXRVK0yiSoFR5H+r5OqKynuh1vNvZdQB6F+vD8zso7fHrvAj5+l6GpofNYHb8GCBQsWLPii8HCQq24sTjUjCDQNzZF5RulXjrwgR6oYKoJKSZf3UJGYECs50oss6A3PUZJFXqxRTXVGINRxKuiKOFSv9G013JnrzDxP1Hlm38mVeyPioH4NXE6WFBjxgEfbPd5zc800VGwekHNF3bLteQ60TVkuPDd8mpkb6EkQa0HXiq1HKALW+ngwtx6VlsRnH9mJt2sUE2xUoDKIIKOycUf3Sov7THd+FovGU8/AtdvCBVvmO79Evf1rDHbGTEVd0Bhh1TJ9HYCWBERyaxGAnskV3muADtDa80wNGQzMWd3aMt4onACPesFb4bntNW7eGnnhVy745V/eMmmhSkBsuo+unzMxWijtkNbeOyFD+pjywLPDCclKbb/ariJJvKR3cGexcxIqyQOK9tLvjL2PXgDtvW1ywYIFCxYseDA8FORKFGRlRFFcBZeuCh3UiYijitEijnGRIspwOjLOIFUY0fRSjQ3JHuSecZTq0nE7TMjyX/E+ikxz89wq7k6rjd3+nGmfpOri7B5ZnBe5kSjS05cyiDQwdhREgm95euQff/IG87TN8V+DyhmQNTzmNS/2rVFWRhmUOPGcWQ0QzKloudMIYhZKNKwKyki9OyPFGIcRH1snkoFeNzBhvDYwzgKt4mXi0SdAL0BfDTYixFCZ5lew0xE9LczeqBcTq02eg1KAdVbHRK3UBggYnmpakZ5inh64Ns1ENJwCaFbNDJaF08yI30dCODkxvvYbb/KV738L/gMv8Msv3Gdfb7Kzll61XvfjgIcRrHBV8iPaWwajB6pCJ0ftMnoBcuNRNcNBAw42O5PcLj2uJobmbLA1vBnqGe+ghydbsGDBggULHgAPBbkCIYoSJscOPemVJ9FTu4Pot/vXw05ZgTIKmPYlN0cGRQpIATMQdTJ9Gw4yRnIsSXISefEOD1przPPMtN0y7XfUaaLVVGesRxUc0hwygSnJWlOhhPPWk+sM0x7X1HPcGjZAljhXfGoIIzIIFEtS5YFbj3sAvHXvEFCGLHyRveG7HEnqYDmS6xEH7k4Z08OkI3lWq6PrmvU1DpwCGj10ClqdKMPIIJrEZtcwWqo7K2BQZJ1J9wG0OY+5Wibpw4HfBB4tgzOkH0cOPYxkybRDhBFlogz3ePt7N3zq9TN2b2SdURNw7Djq0/A+DvTjWNBJpUn799ZJtrWsPor+Rp2WylRO+471QXk2Lk3szR1x7SPGQPvXhVotWLBgwYIHxUNBrkSBIofIqczrlrwKxmFjL+RSoSBraIIZ1LEVUHuFDoGU1mt00sdkpthhPpQlOV3F6iTtuIXm1Hlmnibm3ZZ5mqh1Am9gkttv0utnLC1Ih3I6N2NVK28+AYkLBlFaacw0RpuQqMR8yHaKvoHX0swdnuTFQVZQRJACKkOWzsxB2zbm+zOrWyNYo2nLNHXpY9OBVF+sEQ0gg0fdpyxiXpckrqVhRam1UTzQtSBDYZocZjANqC3Hp4WMUgDa1NJ71a1MGWhKTyTj6FlLXmP0WS6dYQGKjA3Y8pZ3bHjriysuLracu/Vj0ut/onUi1Jc7o3VyrbQWx63G6IsNeB8B0kkSPf9Les5Zf/lDh+DBOqZdpHKnK1fLxuCCBQsWLPidwUNBrlAh1qlc+SC4+nEFv7XskmvSQyQ9i5ORhpRgOAEpGQal5MW9iFIsSZCNkQrWEJhFqk4Sl/18PvXXcaZpzzzP7PcT7XxLeHqPxrGAQimC2XjM3vJIv5UjaOx594nz5tNXaKdnSRhHiCGQVmBe0e472/sNypbVNcEKaO9RLIN2raYhDXQyYi7sthNhwWjO+jGjrfcwgg3W1ywz3T6G7PxDx1TfdiesT0Zk/QYxNWKzQcZKWKOcGLqH2maKDsgAq5M1UXPEJ3uoe6D1fCoDU4GhQECtFebsd1S79DsdhqXRt/QSeSIyGR2IgafedMJ3/FPv5v1fMfF3fux5Xr5beXVbuK1PUWXEw6kyZTp7ddwVvOEOVSDi4I+S9Oa5d/LlOe4zwa70Ch48V61Fkti5YdWgOm0GJrCW4aaLdrVgwYIFCx4UDwW5EunGbYXj2iB9K8w9K0yQXnDc8gIY6aEqg+WYrytbSleWusJkZqhdDSY9WK+SBrgnYWutdXJVqXOqVYeA0FIGQkEHMBkzG0sL4pGjLBE27Hnbo6fo6lV2JzUDSq2ha2A34udwcS9Yr0bKSaDrdsyPCjST3jXJoTaD2di9MVFr49pjJ8h6JsZGrMHGHJNpjCA5qnO8j+vGVOn0GiIzIofNyAbjnMnrIyhG3WfchJggpR+blksEpUCdMndLDWSMlHuSvaY6NQVtannKNIeBB+O56GHD8KBgNWAAX6OsOFkFz75Z+b3f8GY+9pn7/OInz7n9+jlNx0xo9zguMxyOEeqZ4B7RT398tueKvkXouTmonVy5aFe5uiHfJRcMmtJaQ5vRvHXP1f8/n/kFCxYsWPCli4eCXKFgY+YdhfWk7l5Dk16b9M1EnWhtxuUcL2CjMZ5CafkYowdrRo6EMrepgRlRKow7KIqMKxqChrLb76m1UedK3Vba3KA1wjZoKRQzVpsBVUE1t9YQJSLQ7v+KCE6t8cybT4hbDa6Dno/E4DA0fHYmP+PkliKlUotT2gaiIVIR+uhrBrkYqBeZCL+5Yal+3bhgS2ADjEPBc+6Hy5RlyytFW6pxbX1G3DB48gL2oPcFVSNOt6l4NaEOM3IjGF4syJ3crtw9taeYZBL8RSMw9NoJxC7rfXaCdDWwDCPR63FsDzE5ckGSTYBhJoogTIQYokZ62oyIPaINVoqtlLd/WeG5Zx/nnU/e4MM/8hr3dKRFZWyZXeUCUcjMMWvoYQu0dV+6AOppdnfra4GZUwZJuoc5531RC61CrcG+TVAVrYZME4fxZVvI1YIFCxYseEA8HORKQIa+868ci3zdu6+JvjEYPQrhSliRFU2lKlLpMk+1QzTHZViOzjDpvYI5rvKWRnb3RquVOmWmlTeO465iA1aUYRiyEkcuu+oOpMp7tpL7ilduB/H2DcoZWCprNhtxB4YLo/iY3jCbaKV7uQi0cszoqtsJUWEYS3/fSiNN8WVlGQehORac5oppH8BZ/l0i5BKj0Rkm6cR3hyEzv9yDEoIMRrSKzy03DJXcuLtmeG1Iq6gJDEbdtazbMTDP0Zt0pVEs0+WpXbUSO74JgX7Qcrvw0BlJvz9Q1Iwbj1yj2KuIVqwbz48Dx+CyxFly++8QByHiXeCKzOWSzCpLy5d08awrUi2ordEaOV9s4NURt34+ZxbpasGCBQsWPCgeDnKFoKVvBEqOuCICdad59t1lPEEjoruOO7kaBsFDc+TT0lN1mF4hnuGYnWyIJsEKoLWuUPlMmxvekjwQAjpQykgZs2uw2IBYpqTnz9MhLRFIr8lp/ggfefkOk95EpWZOlRagwHZPOwt0zq1DH6CeVoqCHUZscyP2mYQu0k3+Bq6OaI4/1VLJO/icVMAsPUcMaSI/dCJmJlgeT1tLGrcPW36N7DRc5bEHgYtAV4IXiFUPP5gn/EA0h0KdG61mhIGYdHVw4DjKNYjWiBpIdN/VwffEYZmw35ESYI77JBgGGMqUPZA2IpqhC9YN+2gk6WpJvl1bVtj0SI0DKZLeLxg9q+tgWs/IivTv4d2fNoFWsq/xkIW2kKsFCxYsWPCAeCjIlSjEeNijy7WuXKGHWmcgPTjRWYEWx6L2XjxN0uNK1HbsxcsrOVC8K0Cl5yZB1AzkdA9anZJYueNhDMXQYWTYbCilUEpBiqZ3KbLE+PDmIiJLpd3ZDiteYM0P/9xH+dZ3PUZ58pwJhT0g99EbMG+dgYxSWFuOoXzn2S/Y37Jfy5+jyuQTNgp6mhEV1SfKIKBB9YauhMBpEZQxE+lV9LgEudum+rcZoA4wloyriPMKsxE3GtN5w/Yj8vpErAOuG7M0ygDSgjZBjcq4MspgFIeolZjo5vYcqaXY2EMYzMD18lh9vjLkLGWkSaG0mZXveOujjXt3Ltip0MQgKpCVQQRQApMcCVrJLsEy9OD4A7/qW4JEwb31kTJIGBGK95GiR35uwvsH0FqvsVzI1YIFCxYseDA8FOSK7qtJNSMzhw5Bn34gSZLFyBGOSGCD5bV3tH5xzQ1DOZCrDh0UK90vhWd6N4Bn+KZPjdbDKNUyv0GloKpZPqx6WSaN5+1jbHkqbCKWUQtFePVFePniLo9948hQCtqCvQU+k9lbkuO02ME85UhxGOzYTS1DIyz/VhsFWeVYsM6N0nO2mrejGtSSfxxnaKEg0pBm+Bwo6ZWKCLw2tBhFBZrhNhFj0C4axkC7mBCc0SxHliuhNKNNjbpvWLG+GGDQx5Eyt+xldvos0onqOTqlZx5k7n2WUR+zEPJcBwVapUTlmUev8YntlmlOVdLJ8yolx3oyO2GaQQ9GMioHCFwkIyj6udHeFHhI/c84j4yOENVUvizN7SIZtUHheFwXLFiwYMGCLxa/ZVOtiHyviLwiIr945b7/UEReFJGf7/++48rPvktEnheRj4jIt3/Bb6T09G8TtCi9ExkOqY+H7CKV9FmZIoORfMgoxRgGwwZLpankbRukdw8edLFDd2CjtRwHJgeQvlk4oENJ0zpZIpz1OBy/z38cb6PKKiY2MXG6f5Tp+Ya/NNNeOiNe38IEA8LKBKmGnwftPDCHoYw4ZHXMSI4CcebWsPWA9gJjsRwZHoIucwEuZRmVHKHFwWt1OGwtp4WHVPNwzwJoVcRzAhdDKmjCCmkFuQ96EegeJg+cwEoS2FYbUXu3opCmd8vCYwlFZhDPEmQJQ1zxmmNCb5Hkxy/fGy0QF6QFJo0nbm64PhqjeP69BmhDO/HEwK6EuJrl58BMLh9z+BySJNDEOjm+/MirSIa4DiAjOR5dBTHGUi+4YMGCBQseGF+IcvV9wF8D/pvPuf+7I+IvX71DRN4L/BHgfcCbgf9TRN4dEY3fDJLdbsd6mr65lRt5FboXK0w51A2OrUIozYTWKoTRam6+5W6aoKJYWH8JQ8PSExQZiNlqmsNFczNRi2GaoaOiDpoKUTu46hHUMzM8TEm6FQweFAaeu33Bt33yVTYriA9Vhned4I8Hw25ELgR2Rt1vkRHK2ghvhOyxE4EhcHXUknuYAasZCjlKXAuYMU2VMuRpE4d5aLACIYuTkykaUbv0MwDSWAmgeRylQMSeMhfCDVk14j7YcI16cYa/XpETYWREhhksGFd9/DZnbpdbQ2zKGKmDUmgQzTLXCwMfMEaE7IAMz/T2kKzKCQTV3HiUYeDNo/G2ceTu+chuKOAVCUORNNEDhKASmPUAK3ea9KUAz3PtkceK0L7kkFuHOkCToJkzypo2phLqUfvn94oouWDBggULFnyR+C3JVUT8mIg89wU+3z8L/M2I2AMfE5Hnga8HfuI3+yUBVO3X3X9IZ4dD5MHllh49PFIkowbcM1VcwlKB4pDE3alWaGaJa16QvXejiHVi1b+KaW4V9tf3/hpX32uPI6fvoyHAjX3luQnWFxesiqNb0IuCboM6SVattJbK2tCSoAk5XutjwewSVsIburIkKzg6AKpENEwlCZjnhqVJSyXH8n0JlqrQvmHZEEQcDq0JUgyJRpsh6mHjDppXbDTKyYb97j6xC1a7bt7HYbwkHu4V74GdRSQzyuYDAdUr/3K6qJe59Hm+LEuyBcE90lwfadovRv5NMYJkMCw9d10j2U/apHLJIT1WDRfL6I0AC0VV8TiMiQ8J/ZJBsmJ4dLIdLQvCO7n/fPawBQsWLFiw4LeDB/Fc/QkR+deAnwb+TETcBp4B/v6Vx3yq3/frICJ/HPjjANceXWH22W/lQKKESONxJzo5HkwjeV7tBRHvhCgVCNPSCVuqFtAzFFzSsBxpGFdRpLTurUrlSiwJVuSbwD3HaMf3lc+WnI++rBZwHefZG2see/sNuBnojS3ITOwF2SsxZSH0eJJHvdVAi6DrrH9pfhkqigo6WhqZDqFdJJlR63+3+iH8HDHFJbcKcSWaE5NTZsFqjgDzyOV41EhC05qjGYbApDMSmRZvk9Ga084bFo6sAYvcmBxI8tdyc69NfVjaR35OT49nTEUwrNfhCOKdrLVAaIQq4o54QI2uNqYKl/zVkr563s6T0tsFj4TIDh+ojN7g2NDT76dvWXIcZ6p6Ht9wwGgOefB9YVcLFixYsOCB8cWSq78O/EXycvcXgf8Y+E4+vx34865fRcQHgQ8CPPHc9ZCjN0aOv5KEKvoFNM3tSbgaIi1N7K3nWYlTxoGQ3mPXzTN2zDACn1uqOiYMlhlMoVN6vLQgVtKILXRCJz1fKd+P9uj3rsEgnvEAgwtr2yHDzPaZC9rjxskArUxENeTezLAaGa8ZbBoMOa4UEzwa1StlZeho1JixMVWr6jUT3i2gZvq4jULQcHXC2mUxdckFPd0LzBD3oeyUMMvy5gZND/7yXrEza8/DcmQMpvmC0UZ0LMgc2C5VsNg1vOVGpwygRZJMHVLO945PilIQHQkfLwnVgQGiMMeRMIZGz6aSHqtemFyZwzIAtA2pTFWOSwoSh3T+HKn2YsbjIoT1iIrSXzsVqX7cVJI/9diOlPtK99U3kCwfEl3I1YIFCxYseDB8UeQqIl4+3BaR/wL4X/q3nwKevfLQtwCf/kKeU48q1OHi1mMZtHBJtvr8iNz8irjkbVlt00mSWJKrSDUjeh2KdEN0XpA9y6FL3wjU3ICLPhuKg2k74rPGgkdiFTkSJAIT5clbj/DW68HJdBtnj17sscGZ3CkbRQdwGrrKSh+1kluA3rBezxMx50bhQBKeQa4Y1w/MNQg5xEsEYZmLlTyi+6waxBT4LFC7jtO6r63QA1UDmqcHyoMCzESqUkPGSxy28aRBzGTo59zN93PL4+g5ihUGBCW8EM262paBoVn47EjrmVU9JPbw9wBQChdzcDFBixGv/bE1x8F52o1G66Gghz86g0kPeam5Gtlfu583zRXKS/IexqFtOh+SipnHQq4OEJES0c1oCxYsWLDgt4UvilyJyNMR8Zn+7T8PHDYJfxj470Tkr5CG9ncBP/VbPh/pmzpeDHtIZ6ayJ7nw5j1rKnvl0o51CMc8bAsOXeXSfv2W3FTDMckkcA5BpOG5NVY0L6jSN/84PHdczgCvoqtgokBPRJj3Ex/W2/y/7L17sDXpVd73W2u93fuc811mNKORsAYNYMBATLjYEwIOdmFCirJzwU4CDqEIAlz8AZTjGGxCEoMcFymHchETHAcTG3ONLWMwUIhKEWMJwv0iLgKEhBHSXDQaaWa++S7nnL2733et/LHe3mfPMKMZaUbiQ+6ntHX26X17u3t/p59Zz7Oe9fK7NnzqsbIz4YpdoY4ztBl2E01bdvt1GS+0F0yUXqlKz79tjmAQqu+yKmUK5mhTxCRT1heSVCRJwqCdVyUJiZ0yn4L06AUrvfI1gVKzKzFAq1F7SnxpgmhW0hhTmmMOmAsRhpylbKnF4NRonnERRRXFwDfdX56/C9203hxvFRyMAUyIIZKYqSdBpHB2OvHzv/YQv3dr4CZ3MSOotx5inyQuWiXVR9/LvD2TAZFendq3DC6ycXdtdTJm9FbD3qzAQUeq9c7LDyZ06f6ryZ389Yj4QhH5MODbgXuAdwNfHBEPiMh3AE8Anwy8QURuAvcBf7T//HsR8b8/w2fcAv4h8GeBa8B/FRHvFpFPAr4VOAF+F/iSiLgmIq8HfpX0Y17t239BRF4NfCRpJXgl8I0R8X+JyHcD/yIifqh/3vcCr4mIH36RD9eKFStWvCh4PlEM/5Q0pH+MiDwkIl8KfKOIvFFEfp38g/rfAUTEbwL/HPgt4P8Bvj4pKCsAACAASURBVOI5OwX3HwRIXiQlfOm8x0P2JCo8q1HigjdhbmlOziiA6HxDKJLt9qpBaEtyUgLTln4bdUQraMUxHCOwLhmlxydDPQPxvGmQMmAYQyjWUnqsDjsTHvETfu7tM79VX86Dj1zlxu/BjSeDGAvTxogjAQvUgjY44Q2hUQqENRqRc41lQ8jY49cjTe0+EKPDUaTEV0D6e/kArgWrBdVGWEO2gu0ErTDMoJNABdspti2ZwUBBpsbQDKYkaULf3847mgpuWXGLOZAKsgtoE9ocreDbRsxCOrnKPkOMGZgNOVX0pqGnlmStNZqeMQ+nzEdnxHCKMNG2jYdvbXhC7+B8GFD3fbdfa071YPY+MagqUcl4h0hPmmGID0gUYMjB2qKIKoMMmJaUDXvkh2jJbTJgtsFkBIaskn2QQET+OPA/Ap8ZEZ8I/Lf9ob8PfFdEfALwvcAhYfpjwGdFxFf13z8W+GySCH29iAzP8FGXgDdExJ8AfgL4+r79u4Cv6Z/zxoPtAJci4k8BX04SvQWfAPzHwKcBXycirwD+EfDFfZ/uAP4U8KPvzbFYsWLFig8knk+34Oc/w+Z//B6e/w3AN7y3C8kiQpdulpj1PhNuaRqM1mf5taxeZdtYSngeWd0yQC1jHGp4D43MzjSJSF90QGvp08mw0MWb409ZzwLtkpJIn+PHRddiRNDCmdox7zh1fuA3HuRlNyY+ZzbkoXOuftwJ+oojqu7AK8WWd06fj6j1sM0surWW8+1SGgSk78Pe7G457UXkoilPlH3drQWxzSwqBaSlnphVsvRIxS5DPT1nWqd0V3N0UL5HT6L3NMnHnOcmIo33NqTZXkQypiJaJ1V91JBaktQW+DSjtVep+vlUGmKNkECZ8KbcmoPTEGZRPCYselXqoky5T+JPuTIu3HxLTMNy7mRRJbvU3NslDyXe5Zwvv1/0fX5Q4TPJis9jABHxRN/+acB/3u9/N/CNB6/5vqf9B9Fre/fvTkTeBbyclP8P4cBr+v3vAX6gk6A7I+In+vbvBL7v4DX/tK/pJ0Xkqojc2bf/UEScA+ci8jrgUyLiB0Xk/xCRl/V1f/8zSZaHTTL33Xffez4yK1asWPF+xO2R0I4QTXurPjl7d5G45i7ROfjkeHPq1GjNe/cg3TsTzHMjbF4ijgAoZSAkCI8e2dAjGCRH7BxeUg8vrU9Jel9i3aXbecgQ0oVc1VqZmnGrXeUd8jIqO4a3Pc5LX3IC5xWuHuOXA46UmCeKdnlQenq65VBmRJCyQyyQZWyPRiaujykHCqTi1UfkiGc8ehDYdmB6pDHfqAyl5KDrTgh9Jj1mprTZkuAQIDkUurXsslSH2AYyGkGDuWIhtB1Ir+y000I7CnQUynBMhDHvAjCUDcwDMVVi2qJ1my56ayBTdu95pBkeqOc7Hnhc+JnfmXlX3M1UlaHtkNZonTBH93b1uTV9XmDLDkHo5nRfTFeAImY9XNRA8mueQ7Y7W/fkD9H/z/FOrp+x/+IPKy66Q94zDp9z+rTHdgf3G8/vb8Z7+5mHvz/b9u8GvoDM0fuSZ3zDgyaZ+++//4PqRK5YseIPF26LyMSIJcE78BpEb/OPBjFHEqz+k0pKThWiCjF30jU5scvbdLqlbac0cy8eqV7humBIvewTZHRB832swr47jeV1sb8wu7d9uvs+5d0d91PCn+Ty9px7plOuXJ3YnZxSjyeiNooZanJhmJb06ge+XPshehCoLVUt9snkWcGKTrj6HBykJ6JDw6EZ7SbgSd6ClM72yauelStxI2aF1kfGtAzqZM77MgtM6WuKlsdaySYBY0RiINqItyNoR4iPDHbCYEf5eEtLk4WjpcIwEeMOhglsyhPYJmgTTzwhvPntO978KOziUgaPtjHJdq9SevM0scPeL5c7d3H9dJbZj9nwkIWpPImyDG6UfKxFo3mltZlWa5LQpcHhgws/DnyeiNwNICJ39e0/Q5IUSMLyUy/wcxT4L/v9/xr4qYi4DlwTkT/dt38hKRku+Et9TZ8OXO/PB/gcETnqa/4M4Bf79u8A/irs7QcrVqxYcdvi9qhcBXgv8kuvSkjvBmxTRi605vhUk8hMFXdwj+5dSlGnFgh1XALzglYQzSoGunQkLqGUdB/zwQW6X7SjdwIGsh+5A+m5coLmsSdVET3pveygzWzmyp1Ujj/MuHaHY1eN4UgQbdAOuhu7nBc4mX3Zqybm+woeSIaFLiTrKQFOEGpQ24WMOhfYNhSh0VAPwpxw6abzlOvEsgyn3gNHNeMq8CwAMeXB0RNgmwRNTZPshiNWMDlCYkyS1qXXZRizbxvSZsQrHE3EZsItEPN9pTAcxJW3vQPe9Dbn0fMRBjCv0DItIU+G92rVhayYN+9yaK9VBRfVK8mxSMC+KxAu+CW9MzA6OVtiOz7YzOwR8Zsi8g3AT4hIA34FeBXwV4BvF5G/Tje0v8CPOgX+uIj8MnCdTpyALwK+VUROgLc+7XOuicjP0A3tB9t/AXgtaaD/2xHxjr4vj4rIm4AffIFrXbFixYr3O24LcuURbM+2FxtqXoTdHXYHFaOp4q1R5xmPHrEwT9mNFoGKY5pJ3wwFimHtqJMroSgZQCqL/yajGSIOJEbysagXfq3oF11vTtWc1Ndqywv0MqdwhrPdCQ+eKJdkJl5hXH7lhq3tiEs78C3aAA/qxrr3KqspPSoVHQ1nkauM8IKTA5Nh6nMHG2JDJ34GxXDOqThcn9hMl9jpDuc8j0M2XmLdxCVNEasZj2AjNCMa6JESc4MJYgJo6CXgaMS3M6GZ7h41aG2HtctIO8mEc2/ZOJAHCTnbQpuIco5cOsdPgqbCID1QNDLYNGbn4TN4eNe4qQr+dszPmTlmasdoOK0GrSUhbu5Y9GqjZ/coZoQupCqXoJKkWkURK4Rp+vEkO0Nr9ZR1W913pOZB776uDyJExHeSfqfDbW8j/VhPf+6rnvb7q5/2+8e/h8/5m8DffNq2XwU+9Vle8v0R8bXPsP0tEfFlT9/YCdpH071aK1asWHE747YgV3jQtktuVEpK9EpKbXM3sTs+zURzmCvahObgtfYcq2xxMxW8BlqzUhJth/YBv22wfuGl05msyBCChiZZohvrW79aC4QJLn3gs2fVo3nNMTpeidbQMKo1TurA0AZ42S2iTWhY7/pXojpVQF2IkmRES6bGSx91sxRPRJ1g6r6wyKqXdIVPPStR0Wg6IpwwPrnDT4NZa/qR6ASEAQnp8/4WaXAxeBcEI7x3aRpQslKU5poCwwAYTFvAEA1oTtObme4+HSG1J9pTiXqG6y1kMyFjEAPYkiOlRrPC2Oaev2U8Om84azchrtM44TwuZ+WqzhnD0YLmAjjh0KIduHLmlFLDaGJkQa7tK3MihWAgKGCO0FB3TJVJKxE5uDui9eJf9AriitsJIvJZZEfhNx3IhytWrFhx2+K2IFfhwbyrWXzwSMOzB+HOvJArd5hqXtjnGZri7rRWUzaMHErcgFYlM57MKM0w0z5SRjNPS2PfUXY42ubQSxvdcB2akpRLUGlpA+/VKvqF3t1RF5o0hgpXNifE0S3CK5ujEYlKm51lcs1efEpFLclAN6+HLIJk7k9qXr5XM2XRCDWrP6otzf7XGvUmiDeU3BYx0txIejMmIYMkaiEpE0rOYSQcrHSZcIn/HEEHpDSYAsj2QrEhfWo+ZRq7a0qmPjPXLeVyQ48VhtZnJnYyx1LdmiGU3aQ8fG3Hac7gprl2ubDhtRFkxSmVW6U1kNyxnqzej2G2jWZ3oApqiqlhQyFQmu47ES6gLPaszPZayNUHne3q/Y+IuPxePv8znmX7q59l+78iZcIVK1as+EOB24JcuQfb62f7C5xU35MrWqV5ZCxATR9RmzNcsrlTW+3eZqd1wlQBMUVNmIruSYxZDvdVU0oRVJWJJFi6H72T2I+6EXALXJyWiU9A385CGBRjwEMZrXAjFHnFyzia30VrDeEKahvcJ2zY7UnHEq2F9TEwRhrZoQ9Z7p2SGSuf0QWlED1iAEDrOTEpv/GbcNXu5i7bYZFjdyqlxxEUVAulDFgzrFpWqkoa3BkHpt0pg6ZsJz5lFWsWfKg5lodjME1iZRt0GtCtsHv8FJuVMiTRG+4AvbNHL4gQMnSblENrDHMltnB9W/itxzf8zpPnnMvIVI1dnRB3rFaiWaYtLDEcy/2wzqUay3hJVQMNyvGY8yTNYNRu6s+qIPuqV8sOSU3/nBDE4v6PvT1rxYoVK1aseJ9xW5ArPJi3Fc3AKrr2lj+bp7nZG8wtk8Hn1i+8vXMM9sZ0hx501AiV7LxbKj7FMAtcnaYQFikjCngfhbKM0WlLhxnQzHGcpkmwltb/EHCV3pnW59RJ4bQKpxhXTkaYGkjJGIid7SMJpM8hXn5mUjlLA+PFRf6gu1BUslPQOwHrhvQ2FX777RN3Xmp82EuESzpSvLEx6wORG6I1s8Ai/VxmgpkRkoZudSOapXw4Z55UbHvlTkHKCTIYHobH2M3wQT2/Ba6UY4PS0KMG47zvGRANxJ1GdilKq0zn8MgTlTe+9Ra36oYWSluaAGv0oNCWpzRs72Mnvw45oqfP4wYydmEovYlSYFiCQtN3lZ2EORfIJW9iGVTrAaXYPjdNWNnVihUrVqx4YbgtyFVrje21s31nGHOXaWpDKunDcs9ATM8W/73Ks5/x1y+Woj1pQWgSF0Gb0QidaaKoQgyCaTAVQ8S7XJgVrIsqUn+tpSFJzQjJmIRWbH9xd1VgxDQQGbgVl/jd0x0fd89LGIcbxFyBY1RO0uNDYJphoZjsyVQmRQjezfZBxjU4WeHK8T3sA1WVRvO7eOzWZX7y0Yc58ye5e6y8RIwrg/GyqzOXinBlEO67PHBpyMk31WdKMSwapWhmq4elmX27Y3djYjgawTe5ppMRGUAmo3iBeYAtcDoxTEYpDY63+NFMHAlW7kpv19yQtgMaBWiz0dqGM7/KYzvhges3qVuheVBro1XJKKtm6DKHMDTT+ZcKlgIYRsq+42ZkHAt2PDJc2mRlsuS5XAJC3WveNP1V0Rqq2Z5qQib0B+D2NJl4xYoVK1aseO9xW5Cr8GC33abnxUHm7MWP1tAZLHJWoCFY7IPZk0QtHhnPGYLZbp/P3yt9DmCZTg64OiHWfd1pcM7kcNm/SFX37x+Lx6enorsEJpCuIC6yEnoMgMsRE0KTmUDQgZTftOBtGSzMRUTAwfV8mVl4EYypPWsrdcQl4kkQfGpcuzXxS298J7fKMbdoTHGT6ztjOBPefrrlksDdBdrdzl0nA1eKcomJYVM4sSET3wGrklWu6sSu0ZjRUagbRYZkmYJlQvoNJ7aBnzsWhiq4VeowAyfo2ZV8fnNivpkxFDSkCrs28MhjEw8+MnH9dMLrmIRzzo7LuWUVy+qSN5Zms4VcuTpIMIyGqTGOSa6kDJShIJYVK9DuX5P8Li1RF3jPvOrfDZWM2sjy3Iv5tV6xYsWKFf+W4va4mjjEWSMWn9WS3eQQk+8rOVoss53kQApcmrs8AzFd0mMjLklUQg+UNQcNNPIxoxelRPZykCCoKLp3m2eyuUuXjCSlrugXaieHArsGrkYtwSAztx49Q++eQHeEHSPjDmeX4Zl0fqVLDINcSFzkvibL3GuGhPUgsOkYLecgjQce2vCzbznnDb9XcQ3MGy7Ctghbh+tVKc15ZwS34pw7L828/GTkk8bKlVaye9KEmJ2wRlgQRdBRcK/YVmE0wgIoOIbNSlyb2G4FnxybJ9oAjTvw2dGzAWtCmNJC8N2IBag4Nx0e28JP/t5N3vjOiQfPlbk2fG60Gsy7jLvoCnAvHBoSLcfvOEQ/v6ZCGQwpBsOIDAW1kt2fIjjRyWkQLedIphsvPVfS+RSRsqJGRuVnw8CKFStWrFjxvuO2IFfRnPmJXa8SeQ4P7hUpi8ULlUqTSI5ZzhcuN0FdkdqSUOGIKOrLfUA1DdAumCjmiqkwiuXwZ1FE0vAukt1m9HmCYYv3KB3zIt6zlaQbo4WhKS4jTSdmznjg8YF7373hw14aHB89gF8ZOT+9xGa+B5vfufeIBYH1eYMiEC7pXxfNuX4EEZXS7iaao9ygUXj4iWO+9bWN8/GYU84Q2zIC7krVBpqVvKowhfDmKdC5cvWsccdLj/kIGbhj2zL2QkCuXkGkwjghl3f4DnQnjI+D3pipgxAYMHDjbe8mnmxsJkMlOBsaw5NHbMYNp+PAbxs8ujvl0e0pj25nprlRw3n8tHF6Do/fGpnayG42zk4nam14hXmbfnPPplAExXo3pJDDdRihHOVAZtkHzwumSYr7QBw8HG91/zPnJTZEGyZBdhPQTezWoy0upMQVK1asWLHifcVtQa5wQea8a2jmMgn9Qtku8iGXwb374kL/fUnypktJ3qsWaAZNpvsbUcsgSYQl/UDQFLwOhzNL/s7BLSTJVfQQ0iaCieNEpoOHYi2HRVdtvPGhU67dOOfPfuI9fNJHFoQtm1ERewmB/b6utIjscOyZ4aTM6PQaDDRBPKjAOx8zfuY3zrh5+aXMvkPd0JIMxKf+8ujylxqOMeOIwQ3gwR2cMHHPAJsmGAOxGXJYtJwjetaXcJwFn9aQXc2uu8HYnBTaLWd3OnEWI6cysp2FgcoNh187P+fR3Y7H5onH3dhVo4ZxNhnuMDcjdlCnRt3BPCf3aTtoNXsXJDIi4uL0Nig5SzH2sur+6AE5okigB4P25ofwnkcWIOl3E7qXLeijf1i01hUrVqxYseIF47YgVxnlZHsuY5IOH4GLrKe9e5wLv8zSQhYZQ74fbrPwqR4OtTT+LdvTvSRYJ1aKpFTIIgt2mbATrSWSISSp2J5siaS5nZYJUr0S0qJyXU6oNwd+7A07Xnnvh3BXeYTSzojhlJ3B5j0fDZZaTb5tA7kFFjzwoPCLv3HOWx4buXVyxlAbtus+o/AkaL6EYmVQJ1J6kjnsAh6e4XLAvRvhsiiXw2CqmEyITYg2tIDQWCo86r3EZY3x7oH5PDi9vuPR3ZZrmyMe8MY0z9ycgrefT5w12IZyNls2HzZhNwdthtYm3IPaGnUuzFNWq+ouiVVk4W3xs/fqXWSMVfSTuUjD/WsRPWg2PGjh1NbnDEZKjSGenYvqKCkna3Q5dl6+UCu7WrFixYoVLxy3BbkCsJIz9kwUe8pF7nCJmXd1QawCdcnRNQ4S2v09F1EGqe4ZJpLBkr2LbNAeNCmdXKGoWPdfGaLWU0Z7t15AkJJi8q1I43wvebhNhAHtCBRORZniMk+eHvF3XvMO/uQr7+TTP+GEe+94PHlBW9zypM+nkwWhD2V2IWYDLUSFKSrXt5f5l79UeFIuc3r1nEvxKOKFKAWxhsmAqCRBqXRmaiADppaVJ4UHmnBjgvNh4N4ivKI1Xj6fcnwsbI4uYzYiLrR5ZI6RmIX5+kxt5wwnOy7fd8J4zyVeuhWOrt3gycvw6w5vb8YTGpwNY+7LDmzrMAVeYXMGU23Mu8ZcYWqOz+A7iNC+ZsvROJ1cVRqIY4PBsWCjMgwXFcnW5hzijTFPE+yzyBZqnUdUJGBsqKXvTqxkar5nWJaE9uDYlWCtWLFixYoXhtuGXF10cDnYhVQjvZUuLUqtt9P53rP0THqOPOX+Ivlp3jQ7ASWHsqR5XfRAFuyBooeSYJfmJOi+HqBHUIp4Xph1YhZHOcKiQUw4jsg519pd/ORbj3noxjW+8s9tGG48CcdAkf3w4D10+d2ADV6VFsbZ2RG//ttnnG0+lPNyi8bEybWX0WJiy60e45BxDaZGFIHzlOEURd37DGNFhhNOrfBAE4TK2BovmQ2pBZ82FLsKEczzTG0FqiDXLatOp41Ld4/MlwbilVe4cmlHFIipsYtC9T5MumZzwkRjkprJ+WI4Al7QBjanfKcoTuaFiQuh9DwuljJj3kqa2ItJkiV6unrL78ZCgpfiX/YHJiEOAesGd+lDvEVybmSmwpMl0xUrVqxYseIF4rYhV9l7JyB9SEtXbESXvKPohvfuTzp8IRcyoC4pnB0LR1qiq4zsHswQzZ7Ort0g3S+4y+2p4mK/cB/MR5Fc8aJVpcjoywXciagIO7axYda7eMtj5zz0zuvcZw2Oj1IDU8fFeqhDQdsOkUaocv30Dh55YsdjN+GJG8LDj12mHRcGA2mKxhEVx6O/PoSiG9QGJIwo5BgZ79JiSI+bKLRhwzUJRndEB+70iZMpuLRzNqE0MnC0NkersdkOSIO6O8VvQr0UcJex08s8tt1y7awxR68C1SAqeKSw2Aia5NQd91ynhKLRUIEovYGhx95HhrnvQ1a1gKgzjIGOQKGPOmp4S4LqrX8vxFCV/fhrRGDo522REzXfT0MJDVzyMclE1Rf1e71ixYoVK/7tw21Droi+lMVoA2nxUe3p2oK7XSRJLqRqCR7tP50GmkN81RQt2SVoCuOYEQxajDIIYoqVpfNM0CUjSSUvtD3jSshuQTyIlonlGaPgnb05EoY1gCmjGlqyw4YS3KL5jnDj7U98IvPRTe4tb+XSpaN0cEshQpndeOvNj+KJ03OeOLvFGx+ssLkXveMelIZenTluNxhm2LUTro83aA00NoyDoGFsyp2obICBQXOwdGuVaT5HVSlWKMMlXIytOg+78y6v/Jujxt0BL5m33HWzYq3x0Sd3g9zirO44iwyecN9x7R23+NByB8dXNvzCzYlfuXXG23RkIqtWMTseSlTFmjI0RVt6n5Y8MleHAQYZsTE9U3WoREDzRmkj4aBDoOpYgaPjQDcgA+iYk33muQKCSWBWCIxGN8BL0BRmS7+WFfZVMCUQbYjn9yVi7AR3JVcrVqxYseKF4bYgV7/vcrZX5HquFEmwMshTc2gyQHjOHQwnDipKy0Bm1Yw1MM3YBbUkUVaky4NZocpUdj34bNm/32KmjoguDS5O69h3pu2rIsveLFW2XtlyiZ7srvzIzz7I5TrxyquFj/qYV3Dr5nU+5N5XQBl49+M3+d3dZc6qctZgZ3cylJcy6CWO2e6bAHNViyypOTNxyODUYgUVS7I6Cu4Fa9kpKQJFC6ojswhNaycWAw+XkSdCuEJw12Xj0iTcMSjjoJwB79SWNjE3zhTifOJEhbfuJh4KOB9G2ixYJ77h0i1yml150f1k6phFr0rm8dbwDElVwT2W7NRMqO9J+TaQ583ATDFrWX3qci/imA54CN6idwf274L0ZoU+NVsXDtUbEvLBAPWVWq1YsWLFiheM24JcLRUiWKS3hXClbydzp5Tmh16r3w+zPqHXyNlxpin/DYJZJo1rN6qHZdr3oIFotumr5uuTyA3stUkiA077MLps9fceHApiWV1xCVSWMIUgew4XM/mElJkbXjitGx70y/z0m7bghSvXJ+546VXK0d34cMo2Jio7wm8hfszxvCFKw6UipRI03KEMVzE2KJbZTQG0gQzmGhllg3ujeWOYdxlDIBBhGLnepkZjYOMb8OCGNt55ZcLazOPTDmPk7MR49+WGq6HuXNpVjs4nbLrJY27csMvYdsOVbaF5cGuZCxmW4WSeWp+UQKVRJHOowgO8pZk9HGuGRxBhtICInCFoNqAGw5FgA2hpWMmU0VIKJkOeJ+8zAvt3aCHpiGKDZRekWYbfi4E3XLzLjE6bZy5SaVesWLFixYr3DbcHuWLxy9CrHo5r+qOcQHGcjFvwfaHID17bCVd4lxIlZ+d12c9Me5WK7rfpRQtd2g4XYrdULgTvUmRIrxJJZCC8+8W2XtXyTsCWrAcByiI1ohQLtPRKmWZe1NXdUe4PcFxHru6UYsLNOEPaLaI9ifuM14Hqpc/Dm1Ct1Gh4KGaXKRxhGEUd0+wwbE2IGAgZEakZehp0eTWt3ya9KieBi+z9T0l0hZ0ZjzDjbGhWOFfL46wwFcMpGIVgINxQL/tqVUq33RjV7eoujlkSIlFHvMu9kdWqJedLliqk53PNBLWsNtnQJV7zfdXLNAk0nc/Rzx9I7xqNvecu50f6fluYITit5SBwkFUVXLFixYoVLxi3Dbla0tkDxSNQhyaNosYigx021h32CIpmHpT16ISUjVIuU+uBpKqI9sG8GjmD7mnNYd4H94XIvgIVBN4rVdm9tpTWIiXCTqZCuq+nE7mhpN/LFDYGRUaKjPvK2xgbxMGrcKSXGDhm5IjzdgVrp6if0ZiZ4hRxo4Qw9tE6dKJgcgnjCEMYC6hKVqUUPIwmBWkGUZO0tEoQqDkqgkbfN+BsrJQWlJoynSNsBebeETD4TERWzWZtuIx4Gxjn7LTciuIDOWHGl/CpHCMUoqg0QrM66OHdWwV0khWh1Nqy8zJ8HxQ7jEmSUPbESjWwzFdATC40ROhVuz6TUZOUqWS0hi1DvMVzpiDZAuHTlOuJ7AxdsWLFihUrXghuE3IV1ADt6euzp3RkluJa6z35EikLSmuEGKGSJuU09GDdkG4l2/oxiKK4diO7ZSVjIUKoUCXovfwHnYeCS5p9Ak85kqyozKSfXkgvj2lQhoJbQAmOxpSwxpJ+r6LGpoyZpyVpvBYJqiuSl3bMZobjHTYqOgrIMVLvoMgtVM/wyfFhi7PB5eWoHTFooaC4VZoHJe7mSC4xHCktZmqb2ValquGhqGyhTQRbQp4EEdw3XWJ0NjEwU5mZ0XCKO7M6cEoA8zL82g3amGSJma0OhJeU9DzDWIceztmyATIN/qEUt04uhxyyHUGNintLCbBLgfTuQhEwW7o9FSsXPi10zJR9CWBOM3ozrPY2w9I7Dc169auBtvTxaa4pz7mhpdCi5picFStWrFix4gXitiBXsZcCdZ970ADxoHXDsR2a1heJr/tp5DC/SOnRCkl+FhO8qKXq018bvWyVaeYdfZss24Uu+zVCUrfstvY0y5ugRRhKIUqACeNQMIOx9AqaKKMNFE0TfZE0cxcygFSjIWoUM8yMjR6xm4/xmHGpXc5UVA1Vo+iGYAOMeBSc3m5t3gAAIABJREFUHTUao55wPFymiDDVc5zMgloS54chD04LA0qXxYQIxcNprXZ7mVPbzDJhZhkpI2H92GQS6fJ7xkBkG96Sah+akQrSJVhd/GDSklSxjAxyIqwP2AaJjIsIrJ832VebVCJlXOkjkQRMDBXrhvkDSa971JWL6uQzzQwUSRJumsy7rTObV6xYsWLFi4Dbg1yxjANMOSglwbw6a5fqmuhFsGg3TYnqnjwtXWCZwt5Ny72SJb0rMGTxXUm31yzxoMtCFseV4FH79ToyhoFIY33/3MzJyg7EsRQYgjAYS6EYjINQNAMsByudaIFpNvw3sYwDiJQqteS6N1Y4LhU8qJLGfKRiNjDYQCkFYkTkEu4b3HcMWrnj5B7uOHoJgnPz1pO0ehPVHVkf22twiARFrXdiOh5ChFPJ4xoR7NoOD0G6PJu+KUOl5LEP7Z4pzayosCRZkVllTSTlU+/dfouA6yBx0YnpAeqR70XQE86Sfu01X89mhEVppGXgKH0SUu9xaB79/fM7klLgxc+nc6slMBZNiTUUTP1Ca16xYsWKFSveR9we5CpgatGDPtNHY2KEwNwvxEYD6RWN/RUwZ+lBH52jiwRke/lof63svitVTXUrnBCoC4HqcQu5oMy1yrTv6FKSMBShqFKKUUaljIVSjPHYKINhBpvBKEW6LJhryXgEujToneAN5DzErOWgacAvm8scywnb4S5mnQibiOEmIttMk2ckYkPEBrWXZJejCffe/bHcc8eHgFeeePIxHn7sAXbzo0TMuJ+D7lDxrDHZwOJaywZMTXkTwcrAXAtSZ5qDcbQnViqGUijDAJFGdu/hq+H5Xi3ohC0HKXtL2XHxzEVcEDo8aEw0l+7DWjISWh84vZyOfsyShmP72HahVkuW1Ylbp+AY1q1VBrS9mR86Oacb/COrgpTOrZ+hwrVixYoVK1a8N7g9yBW9ciX50yPTspe8IyQv2tl1llKbdEKli+yj2mfnLbP/eEor/pKZFbpkG+XPkOxWywiAww7Ei/XpMpevCCpKMWUohWJGGY1hKIwlt296aOlYlCLp+VHroaYifbYhhGSnWs8mzXXR98eyOmVyiSgTkyQ5EFKWDK9EzDmMWEpWlMjo8jKMjMMlNuUSWgswkf2BNaU1ApOU0Dyb//Cey6WRh8YkSaSJYWEYhvXPUQpFB5QNooUofcR2SFauQmghENH9anOSqwhqcyIarVpGRERj8prlpwN11kMITeJ58Q3po26e8sVZjOz92PVx3124ze/Fs5SiFoIF0mXJNLw/2/NXrFixYsWK54vnJFci8krgu4APIS+B3xYR3ywidwGvAT4ceBvweRFxTdLc8s3AnwfOgFdFxBve02cEMLdM9S6RFayIliZl8T0XaijGwezBZZwJ9C4vg2hd0spLrkdWNFpAeJIL6ZUpB6pEEhac5hcX7xYZ+pkmecOKMo4DoyibobA5GrN6NRjDpmTFSoXNaJhedO+pKlaGTgRjTwZj8Vz1lQeKK7hPmB0xyDE7OYGhoSJ4KwiVhlKjIVIZrIJtoB3x2I2bTFOu93x7k503dtPEFDtmdsBEkNIoLfcY76FQ7mgPQ9UIBik5m08HNAaMwmAbTAZMCkVHigyd2PXxQbIQG80khshyksd80B1ouDtTnah1Zp5nrtdGbdCaM7eJwFEiteE9qSJPZttv6pEd9O5AwaJXqzqj1r2OeEiXetshh+ONMgPNND1coiu5WrFixYoVLwzPx8Jbga+KiI8DPhX4ChH5d4D/HvjxiPho4Mf77wB/Dvjofvsy4P98rg+I6LN+G9QKXrOSIV2y8rCUoA6qSY2G01JS69WpCPrWSqXRJKgSVKkEM0QjvNFaY/ageVA9KyrNYSZvkyiufaidpfW8oGxEKEXQUbEBSklv1VERhgKl5IW6DIqWgpWC2dAT4g21AsXQYkgRKIoXQ4eCFMHEMZ8xnylSGUxQGSj6Eo7KKxiHezF9Kap3EnKJqiUjEXTglp/x7u27eNfp23ly+xA32js44xoTpz2nS6kKTSDCestjJ6fSaG2mtRlvjWgQLSXIIQZKDJgXSoyUGDmSY0Y9YtSBYz3iSDaccMyJHHMiIydWuFRGTmzDiR5z2S5x2U64XEYuDSNjSe+YmlJkg3WDvWoFq2AN10bTRlumBLqgTTqZMmiCuTE2+m1g9CNKjNgySknTo2V97E5GcRSMEcIQDLMCWggphA0vuiwoIh8uIr/xLI/9o/5v6dle+3oRuf9FXdB7gIh8roi8SURe97Tt+30Qkc8QkR95kT7vVSLy95/jORsR+Vci8qsi8pdE5E+LyG/2349fjHWsWLFixYuN56xcRcQjwCP9/k0ReRNwL/A5wGf0p30n8Hrga/r274o0MP2ciNwpIn+kv8+zwgnEHTd6rlQP7GyKLB2DPbzgYm2LT4ZexshOtmfeD/oIm0YsXqOlG5AsiFzcb3mB7v6urM5kNUQtpT0rRindfzX0wFITrFgfu9OfL2lqRzM7a7l22+HiRA5+d4KK0HLSnWgOY3YjtNFiwr3nOMmIUhAxWqvUuqXWJ6nzGTs/pfrcK3vLgeozGvOALf/rcl6SzRyCnD8lFOlSW6bAK6U3DGiXWk3zOSnJLU17crFfuvibAiOYW0Vbl0hNe+NBX+bexA7LOKElWPbgYB2cVPra+hpjkTujdxAG4tEbIBoXVav0dklPlV2M7fIBThCNiL/8Af3A58aXAl8eEa97zmd+4PDJwBARnwQgIt8K/N2I+Cd/sMtasWLFimfHe+W5EpEPJ//Y/Tzw8oUwRcQjIvKy/rR7gQcPXvZQ3/as5CogU8clW/tp6bFqGoi3fRcgRMp19K67ntyQJhsFTz+TdqtOw7FIs3WTfuEXCIk0XgNVejhAQOtxD6KCDK1HJmS1qpT0VtmgjBvj+GhkGJRSlHEs2RGoeT/N6+ldoo/u0aVjrUuDh1U4ld7RJ4EyMbsjLiAnSN2gMmIcgTuNCTHBMZATzNO4fTpdZ/IzbrXHqbFNj1af1ZdZVjUFyB4cqiLQZiQc90Y9bzT3lOemi7mFSJK3QQeKGIZmF6RpZk+pptHdly5AIfSCKu4bBUSotXb/VQWpiFZ0aKjkjdn31GkJG1XJ2YwL7zFPgmSumIN594SFMcRBin9/QaggJYg+S3KZJ0mXMpMkGhFCdlO+X2TBIiLfSf7beQvw30TEmYi8Hvhq4FeAfwzcT+7pt0fE/9Zf+7ki8g+AO4EvjYj/T0SOyIrw/WRl+a9FxOtE5FXAXwQ2wEcA/3dE/K2nL0ZEPh/4H0im+tqI+BoR+Trg04GPEJEfjoi//lw7JSKfAvw94Bg4B744It7c1/GfASfARwL/MiL+Rn/NFwNfS/49eAuw69v/U+B/AkbgceAL+rH4HuAeEfnVvs+fB3y2iHxWRHzBc61xxYoVK/4g8LzJlYhcBr4f+KsRceM9XISe6YHfVxIQkS8jZcMkSfsGwEbV3gGG7GfmSTjN08Dceh9+Cxj0oHpljrTOYrptx4OLsS70tv3ILMyllrNsa74MZ84Do50M7fOQLCtSpaew53idHqWgmqb6bok2oVekJElWPwxLnMRhfc2XmYkBok6nkWjUlPB86NEEktWkyFDNnFntRHNqO2OOU5pMuLScgegZNJENA45H69scDcFag3CiNmrNilVrQZt7h2ZPPxdRKMqiwGZtKkmiAhJ9jqIstZ/D0324/eLrIJpVpWAGrYQ3KP3VTwlJz/E5h1Z2CcVC+tifkuQKpYR1I73kd0TzRIR6npBeHpMe+S5L1arnYV2Y3F90fAxJjH5aRL4d+HLg7x48/knAvRHx8QAicufBYyUiPkVE/jzw9cBnAV8BEBH/roh8LPBjIvLH+vM/Bfh40u/4iyLy2oj4peXNROQVwP8K/EngWn/tX4iI/1lEPhP46sPnPwd+G/gzEVFF5LOA/wX4Lw726ZNJ8vRmEfkWkgj+rf7Z14HXkcQS4KeAT42IEJG/DPyNiPiqfv+rI+I/6ev/NOBHIuJfPH0xh39T7rvvvue5CytWrFjx4uN5kSsRGUhi9b0R8QN986OL3CcifwR4V9/+EPDKg5d/KPCOp79nRHwb8G0Aw6h70QqgeZrZlyiEi3UkWTDPq3qfowxc3E8zPCkPcTGtZvFkdc7W/VkHxCo8Te+ABSxMQlUORugc3D/oRlxuJheWaUhitaxtnyTwDFg6BnMxyTSFBjLlq5tlpUrJeYP7F6YJ331i9jMqW0JaVoq6DOreCHJ4c/MkV7PPGVNQG+IBrVHPs6rk1aElRbQhdyp6G6eI9HmJ/QBGD28llubLfefnwYneR1zEviOzJ97TcGk9pLVd0PJOnvM4Hoa8aj83ktJkGIPbPkzUxFLW7N8VlKxQaR7kWM5bPz9Pv138/4uOByPip/v97wH+Ck8lV28F/mgnIK8FfuzgseXf2y+TzSOQFaZvAYiI3xaRtwMLufp/I+JxABH5gf7cQ7L07wGvj4h39+d8L/BngB98H/brDuA7ReSjyVM/HDz24xFxvX/GbwEfBrz0aZ/9moN1fyjwmv63ZAR+771dzOHflPvvv/8Dq/GuWLFixQGeT7egkJLFmyLimw4e+mHgi4C/03/+0MH2rxSRfwb8+8D15/JbSRqqMuGolyg0cnav+4xajpEhdH/pK5aVE1nkQmk9MqABKS2Kgbpk1UMuspPCnakPC55otPALn45CSKa5LzMKS1GGoVC6WX3o+ValLD6rrE4pGRNhuTtJrvSp1ZCnJMJ3eMQFI4kMXHJ3WpwSUdm1bcZTiCKbLMmEzEzzxOyNuW05jxsEM9FSUmwEtdYehVCZ6y7jD7wxzedEdeS8oh7EHES9YEYWhSKaI20sCIuUaKMhDk2FUEVKYdD0Yi1ZocmH9WDflmMbtNb6kOSWIa0xg8yE1H5+Mp5f+vicaJodnN02JiKYFEwGNnJEiYENR90Qr6j0YxdOHeccgTMGjJUYnGa1k8GlhtjplGhS4bJ0Eb7oePqF/im/9y7bTwQ+m6xKfR7wJf3hXf/ZuPj3+p4W+R4/6zle+97ibwOvi4i/2C0Drz94bHdw/3Dtz0Z6vgX4poj4YRH5DODVL+I6V6xYseIDiudTufoPgC8E3th9D5B+jb8D/HMR+VLgAeBz+2M/SsYw/BtSmvji57MQ6aWrLBoluQjN9vpoGcMwe8pzghHEvt3+KZUhSd+OLtN+PfL5xt7E7qIQnlWbsAyfjEBlzpynyP8EL9FSbhJQcWyA0XKETZFIAhVg0Q3vy8y6bpRugLrj1tAeCSDN+5pLHwSzaJqZYdU8x9E4TvgpUc/Q1gjfIHqE2hWaatrefcvUZqaYqGRnZYuKR2ZIzewy0iI8KzrVc8zQrkF1fAfVhWiB7rKhAEA6mZo9/WiDCtUDXDI6wlOWzKHL6W2jy6DSXe3e96tJ4JJRC8iMy0yVmYnKrI3KOTVmXGvKfeRInuatl656LSk0ybN2EVAtTfZaMuRUFesdDhGgOoApoY6X7BQMV8Kir3NpLuhfvH7O4v3CrbhPRD4tIn4W+HxSAttDRF4KTBHx/SLyu8B3PMf7/STpSfrXXQ68D3gz8CeA/6jHpJwDf4ELkrbg54Fv7p95ra/nW97H/boDeLjff9XzeP7y2XcDN8i/Gb/2DO/1Re/jelasWLHitsDz6Rb8KZ79v3b/w2d4ftA9Ic8bB3KQdIIVZJXErXcAdvkugkzo7sZ27wUX7ebnFnk/XDGjp4xnd92+oLJIhYB0707QevVDevVJ9p6i7BTs8h8XN5WsdOiS+E1Peu/3pRvVLQKX2MuEh7t8cOQuKjzLfoXjkpEP3gQ0O/2aC3NkXtQslRqNpfjlnt6q5jPeapIpd7w2Wm2ZmD41ogWtOtECn51xvjCNh88ZRYFkVEHPgkqdVCjF+xDtliRHckRQetN0f5w8UloNyRwxJytWGbCw/GxEz/pC7BnrGv1t0jgvA0UKpkYR64GmeuH/8jwHOghhObQ7egZXjjz0A3nw6dLgi1vWOcCbgC8SkX8I/A6/P57kXuCfyIXp62uf4/3+AfCtIvJG0sf0qojY9arbTwHfDXwUaWh/in+qy/hfS/qdBPjRiPgh3jd8IykL/jXgXz/Xk/tnvxr4WdLQ/gYuGmdfDXyfiDwM/BxpyF+xYsWKP5SQ/ciXP0CMRxYv/5CjLo15ds0D0bJyJH3YchnyfnbkNcyU0SyrUATFskNvKENGIWgObF78UTp0mU5SNgMILO3S4dgQ+67Ak8vKMBjDYFy6fEQpwuX+cxgHjo5GrMuCm80mZUTNZHMVyXV3I9JwkPxt+5+atCJyvmELp7kzt6x4NSJ1lWIwDJwzMDVl8oL3107MRFTcK7VOeFRqPcejZgdgm3qchVN3c3brtcZ8tiU8aNs0nnkNYjuzn62o0jsBDSsDwzBwNI6MQ6GocnJyxGADgxnjOGJ96LSq9nT3ZC9BUKPSWqNG40Y7Zao7TttNZp+Y28RZu0lEAxG8Nyxk4GjKgW3niGfV6ni8zMDAIIXjzTEaxpFu+ogbScLXOxSqgpvgxfGjmZBgHhqu3qPo2QeJqhgihojyz77u13nXW2+9nzjW+xe9S+/+iPjKP+i1/EHj/vvvj1/6pefry1+xYsWK5wcR+eWIeM78wdti/A2w9+s8Baq4X1SMloG9zQMsL8S1E6ve2Jcv8/TutLhIvhKFVtmbm0UthSsRjAIajEaSq1IYCgzFGMx6lIJcdMQtJu0IIoTWGqpC652BgRyUQAQPMusKiOjSGcscvYx/CE9/eOtZW45QUVozXAtnATWgRRrMG1AjjWlZnWq9atUrVR54g+iZVa16r1R5RlPMQatAXeRC6EkNmStGwywlT48kqu5OsSSNdXBmszTTqFGGkl2TQLGFXGWgq+PUaOyYmGWmMVNjpsbUj1P6nrQb2b1Xktwzkj3HB1lmjJHmddWUEFXBpAcvRDevL+0RekGgRJZGBOEi2Uz2UQyydEWuWLFixYoVLxC3B7kSELPsBgwhaJ13SA4Ghl69kn10god3CfFiRE5DMQ9aDUwdUZIgaF68rQWIZ0WrZOdbVlzAinJ8NKR5fTSONt7DQYWxD17OETGCu1NrzYHHoUT4PpoB9x4a2gmAlkxm7yOF0+YjNK80MrizuffZhkETaKFUMaodM1M4n5RZo5MOo3matlurB5Wrml2B3TAe7kTN7j9vDa/ps6IJXg2fhbattLnR5kZUeufhheHezDGbscGo85zBqSrMc830+WJs5hlVYxiGHIotkR2LEnk+S6+i0Tj1c5pP7Notgj5TkENSc1Aw6t4p05LkTbrfSgqDjpQy9CoZXdTtEQ6tS5F4ktQA906set1QRDMKohMq1dJN7fr+MrR/QBAR38Fz+7VWrFixYsX7GbcHuSJ9TZFZAxeESfPCuKBHW+Yl2DNEtOFIv6CKNySsX6O72bo5EZohlS6opWFcFRDpUUiZPJ5jWZShGMXaPnU95a5FRsw1uHtWeNpijL7oQaP7q7LKlcGc0s3ZdE+YR59puCSi93e+SIsHd8VFcSlJmNLA1I9RXPiperUqehXMc/o14RcxCBLgLdfS5uD/b+9sYyY7yzr++9/3mXm2aBWwYhpaaUsgsfGDNMSQaIgGg9APVBNiSkLkQ6MBX6JRP9T0S6Of1IiJCVFRiUhU8J3GaKIihITYYpFSWpqVgo1WmhajqQTsPnPu+/LDdZ2Z6bLLzu7OMzO7Xr9kMueZZ3bmus85zzn/vV7HyMFqY49tfDRQDFkGbzvVzJjLWExVjwXGYcB1jCFVaiSJl1LoMppGeogn65Fgr8axHdPsGJtcjGvNQc+m+4BCb1YavammcGUJT+IyBGmGp9pPHkP3Sp1rELc3RiUS2hWfFWFFCleutEqSJEkOhYMRV1a9D1HHu2nTq3tBINojTEnNJQSIojdUZTmMuUMrlYYo5qk1VavnXoyZoFSQNaq5J0ileuhpGBhm3n6hzhTCimU4UJILGjpdg9/QrSMTVvxRbWW3Ab372BeqJ1JjxsI6dbrvm9E69AgnjvLBN6MGxlIZqSw8JR8wrwZkxKzRunurvCLQH0RKkS37NoW/LBps0hZYH/17W2MxNlqLRPju9rpwLNCMAVjQqLVTqveqGA2KNaoZ4+RJ61O1Xfd+W3RMjW5ngE5X41hf8fy4OikqoWgCO0nXLqLRaYkD7jMApRm1Di5+aveROaXQlu0XfDh37FJas+hr5iIThXgSmGLE9OStivE5TCHdJEmSJLkMDkJcSbgl3XNiulmkJPmNzuI+66NrOn0SXUBv9vzqPTqLUii9UYFBlWIxyqZU2gBDd09HjWSuEp3Wh1llmPu8wPnMUGGZ0yNFewjryxLFceE2lBilUmuhDUYthV6h1kZVYVEatU65Vi6Taveu5Q14Dr/hd8EZK3T5uJ5jOgsaoxRBLqP1Yx9lYyPNXChZ947sZdnSYXDPlgxTNOzsBXr13KyFhwMXC08277EkFRhqZTotavVKwKlT/Tgu6FaYH3kI0Cr0AnWAVsObppGxL6IpaKdr2jYkbwuxCgOWlZiJkKvFjEMhSq0MZe4PDcyGU8xL9fmGw8w9iFY8BGhibJF31jvHx8ce4quCmXu9zBRifKoEVWxHmYGWftEkSZIkuWQOQlx5KpGH1QygsRzKbGvv6XGT15T8bt6yIfwOGMU7svfGlCQNodHMk8k9YlZj2xt+Tl4pDxMpBjIrMuSNafixRR6QSayqLKPCUR5eUisUGQyTOPAqxt5jADVuv4sCojIQmnyG3rG5yOqC0UZG4Z68qcFD7+GlMg8PRghwEgViGkrcmYYau4dv6hdlEZr0GYElGqv21ZzqSGqPJqrxmg+tLtRaV8cp9tmqmsD8+FTWOhy4MHWRF/lOa3lNZpHFvvRETge7QqnUMqMWbxw6lNnzZgGaycOq3T1vi0XknPXOuPCcuaIS55C/33OuVntLKmv7LoVVkiRJcvkchrjChYzP3V0900NYmHuvivy5W/PeRZLf06PrtjTdpiM1iR4VhiX6LZVIcF7NFIzZyiEmPCl9uvcXxJoOoLceYUr5HMLlOBfwT2zYzD1XzKAUo9WKzaF1Hwoc6T1Uc4nS8EZFLQTVAqOrh+hqPniY6o1AzWBKVo8qQU1xU0I0yVtTdPBO59PMwvC2FQq1zKA2htoidLnWCBSWfbtqrcuxPrUKRa7TtLM9R8wlouLfm7qL0ehtRekrkXXerh+rXCfv3u6Dm70ycIi+VkOUBJQQVZGs3ozevDpyHEfv5dX7Ukyvn2OTgCbCg/7zssyAlFdJkiTJNjgMcSV86kv3vKSlsJrudJ6fvBqRsza8bunFis8p8XBnTZmKDj3zaGiUWpEaZRhgMOZHA/P5wNHRjPnRjPm8xDgbi1mCk58mBhtbwbpYjIull6R3b29gJp6rI7M60I7EMDPq0FmMnWEoMfzZhZBZCzkGx9FaoSO+PHTP31KldUHpS48ZdKyNYCNYo0zNKaZWAhZyR97ks8u/oUjYMEe9eZXfrNAYWcxL5F9BU4vWFCUGG4fAUYz0qeHJk5jNKlYKpsLYR9QtJtfYMteKCAtaaVMtX3i9zsLqshFs1HtCqcy5hsLAoDmVGdUqNhaXcQoR1mA8Hr0i0jpjxGmnQdp9JOYoyTWevGpTxKDtUM6Th3Nq25AkSZIkl8NhiCtwRUTxRpCRkjMFa5a9l9bufdNwZlglu3et5WYZ7u1R9aT2UimDJ6nXUhjmlflQmc+9SWYdopdVWfVE8iHNk3fDfO6hucemjT2Swb3qzvN5CgyeOz4rDShYt2UBW6meMC55Ava6uOp4Y9MFLlymGYcGKMbMLAcxR1MqF5Hy8T3yVhYyDy8WvLLO865A8vwpybAyuEepVk8gN0M13HewHCukUmIosqjD5O1xgWi1giqmMXKeIo679BdaiDFbhhunfblexSdNLThseSCLCuqR/2Te6V1mjOqryswubOyMx2NUhPpnTALJwjPYo3+XjGVO2sqDxVdvb++MTpIkSf6fciDiyihTQ80YpWJTqNBbIbnIKLhXJATFsmfB0lPVYmyMll4rBs8BqrUzO5ozVG8MOj81eOuFeaHMoAyRLE+ExcqqGagmDxh1WaXYmvfTas1YjB0fKm2MMSTxucVIQ8wit6qbUGcpUlonRt10/lfe36pjHGvmnxVZ/NYLhb4UjD72J/KXJrmgHsn8Cu/TJEhLBO60FEYIr7SLHl01PnhRXKkWefgP3AM0TOHXwV9XMW9ngWf7mxT7xr1TNgkqTeFCwm2oVRuEXlnOVFwT1YUKKq7J8CrBySPYLVbX3N6+zK1qy/BsrVFcYBZ9rTrW5Allcb6sxNNKZE2SahJfSZIkSXI5HIa4ElSad1+3FiLKvTU9IkmSV+550vqapyNCY9G3k4qYlRnD4NWB15yaMxvce/WC2SlKKcyGgWvmp5jNBo6uETVG3pQj91xRBYMP8dUkshDUmXtDxpFFM84s3Gs1jlOiunttFiZGFgzdmLXKkXdiQIOo5q1Ax+biaqRxrE4rPn9wjFEwpVaqDVAKxWo4daZeT5OHqaI1L9Hk3ZrCiB4m9OdagAGftWdeIdnKsMxFH+q6J2eVk1SjiatVi74W0SUjFK/3J6s+VkaAWgxHdq8UstUIouWB9Io9MyJdzMXYUCqKETiyAXqhL7x4QNYYm6HmuW/Hx4vnFyLUSLrHc928oaq3l9DilO+33ikW4q0MS49VCVmV4ipJkiTZBgcxW1DSF4EvA/+5b1vWuI6050Icmk3bsOdlZvbN2zAm2R+SvgSc3rcdW+bQ/t62Qa7pyuFqXNelrGmje8RBiCsASQ9uMgxxV6Q9F+bQbDo0e5L9cTWeC7mmK4OrcU1wda7rJNeUk2qTJEmSJEm2SIqrJEmSJEmSLXJI4urd+zbgLNKeC3NoNh2aPcn+uBrPhVzTlcHVuCa4Otd1YmtXKivFAAAFpklEQVQ6mJyrJEmSJEmSq4FD8lwlSZIkSZJc8exdXEl6g6TTkh6XdPeebHhC0qclPSTpwXjtxZL+TtJn4/lFJ2zDeyQ9I+mRtdfOaYOcX4999rCk23Zkz72S/iP200OSbl/73c+HPaclff8J2HOjpA9LekzSo5J+Kl7f2z5K9s+Frh+SjiR9IH7/gKSbdm/lxbHBmn5G0mfivP6QpJftw86LYdPrvKQ3SzJJB1+VtsmaJP1QHKtHJf3hrm28WDY49741rsOfjPPv9nN9ziFxrnvZWb8/mXvFqunk7h9ABT4H3ALMgU8Bt+7BjieA68567ZeBu2P7buCXTtiG1wK3AY9cyAbgduBv8I6XrwEe2JE99wI/d4733hrH7gi4OY5p3bI91wO3xfa1wL/E9+5tH+Vjv49Nrh/AjwG/Gdt3Ah/Yt91bWNP3Ai+I7XdcDWuK910LfBS4H3j1vu3ewnF6BfBJ4EXx80v2bfcW1vRu4B2xfSvwxL7t3mBdX3UvO+v3J3Kv2Lfn6juBx83s82Z2DLwfuGPPNk3cAbw3tt8L/MBJfpmZfRT4rw1tuAP4fXPuB14o6fod2HM+7gDeb2ZnzOxfgcfxY7tNe54ys3+O7S8BjwEvZY/7KNk7m1w/1s+PPwVeJ+mQ2/BfcE1m9mEz+0r8eD9ww45tvFg2vc7/Iv6fped2adwlssmafgR4l5n9N4CZPbNjGy+WTdZkwDfE9jcCX9ihfZfEBveyE7lX7FtcvRT497Wfn4zXdo0BfyvpE5J+NF77FjN7CvzGDrxkD3adz4Z97refCNfpe9ZCpTu1J0I7rwIe4DD3UbIbNjnGy/eY2Qg8C3zTTqy7NC72vL0L/1/3IXPBNUl6FXCjmf3VLg27DDY5Tq8EXinpY5Lul/SGnVl3aWyypnuBt0p6Evhr4Cd3Y9qJciL3in2Lq3P9D3If5YvfZWa3AW8EflzSa/dgw8Wwr/32G8DLge8AngJ+ddf2SPp64M+Anzaz//lab92VTcne2OQYX2nnwcb2Snor8GrgV07Uosvna65JUgF+DfjZnVl0+WxynAY8NPg9wFuA35H0whO263LYZE1vAX7PzG7Aw2nvi+N3JXMi14h975QngRvXfr6BPbgZzewL8fwM8Be4e/TpyTUYz/tw6Z7Phr3sNzN72syamXXgt1mF/nZij6QZLqz+wMz+PF4+qH2U7JRNjvHyPZIGPJSxabh7H2x03kr6PuAe4E1mdmZHtl0qF1rTtcC3Ax+R9ASe93LfgSe1b3rufdDMFpEucRoXW4fKJmu6C/hjADP7R+AUPp/vSuZE7hX7Flf/BLxC0s2S5njC6X27NEDS10m6dtoGXg88Ena8Ld72NuCDu7QrOJ8N9wE/HFUOrwGenUJjJ8lZcegfxPfTZM+dUZl1M34B+fiWv1vA7wKPmdk71351UPso2SmbXD/Wz483A/9gkcV6oFxwTRFC+y1cWB16Hg9cYE1m9qyZXWdmN5nZTXge2ZvM7MH9mLsRm5x7f4kXHyDpOjxM+PmdWnlxbLKmfwNeByDp23Bx9cWdWrl9TuZecQCZ/LfjlV+fA+7Zw/ffgldFfAp4dLIBz8v4EPDZeH7xCdvxR3iobYEr6bvOZwPuxnxX7LNPcwKVNeex533xfQ/HCXn92vvvCXtOA288AXu+G3fVPgw8FI/b97mP8rH/x7muH8Av4Ddn8Iv/n+BFFh8Hbtm3zVtY098DT6/9Hdy3b5svd01nvfcjV8Lf6wbHScA7gc/ENejOfdu8hTXdCnws7pcPAa/ft80brOlc97K3A29fO05bv1dkh/YkSZIkSZItsu+wYJIkSZIkyVVFiqskSZIkSZItkuIqSZIkSZJki6S4SpIkSZIk2SIprpIkSZIkSbZIiqskSZIkSZItkuIqSZIkSZJki6S4SpIkSZIk2SL/BzuDRD7D/AW3AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f9465579cc0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "img, label = next(iter(dataloaders[model.name]['test']))\n",
    "show_predict((img[0].unsqueeze(0), label[0]), model)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}