vgg16_trained_model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# License: BSD\n",
    "# Author: Sasank Chilamkurthy\n",
    "\n",
    "from __future__ import print_function, division\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.optim import lr_scheduler\n",
    "import numpy as np\n",
    "import torchvision\n",
    "from torchvision import datasets, models, transforms\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "import os\n",
    "import copy\n",
    "\n",
    "plt.ion()   # interactive mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Data augmentation and normalization for training\n",
    "# Just normalization for validation\n",
    "data_transforms = {\n",
    "    'train': transforms.Compose([\n",
    "        transforms.RandomResizedCrop(224),\n",
    "        transforms.RandomHorizontalFlip(),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "    ]),\n",
    "    'val': transforms.Compose([\n",
    "        transforms.Resize(256),\n",
    "        transforms.CenterCrop(224),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "    ]),\n",
    "}\n",
    "\n",
    "data_dir = './DATA/output'\n",
    "image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x])\n",
    "                  for x in ['train', 'val']}\n",
    "dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=4, shuffle=True, num_workers=4) for x in ['train', 'val']}\n",
    "dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}\n",
    "class_names = image_datasets['train'].classes\n",
    "\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=0)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def imshow(inp, title=None):\n",
    "    \"\"\"Imshow for Tensor.\"\"\"\n",
    "    inp = inp.numpy().transpose((1, 2, 0))\n",
    "    mean = np.array([0.485, 0.456, 0.406])\n",
    "    std = np.array([0.229, 0.224, 0.225])\n",
    "    inp = std * inp + mean\n",
    "    inp = np.clip(inp, 0, 1)\n",
    "    plt.imshow(inp)\n",
    "    if title is not None:\n",
    "        plt.title(title)\n",
    "    plt.pause(0.001)  # pause a bit so that plots are updated\n",
    "\n",
    "\n",
    "# Get a batch of training data\n",
    "inputs, classes = next(iter(dataloaders['train']))\n",
    "\n",
    "# Make a grid from batch\n",
    "out = torchvision.utils.make_grid(inputs)\n",
    "\n",
    "#imshow(out, title=[class_names[x] for x in classes])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model, criterion, optimizer, scheduler, num_epochs=25):\n",
    "    since = time.time()\n",
    "\n",
    "    best_model_wts = copy.deepcopy(model.state_dict())\n",
    "    best_acc = 0.0\n",
    "\n",
    "    for epoch in range(num_epochs):\n",
    "        print('Epoch {}/{}'.format(epoch, num_epochs - 1))\n",
    "        print('-' * 10)\n",
    "\n",
    "        # Each epoch has a training and validation phase\n",
    "        for phase in ['train', 'val']:\n",
    "            if phase == 'train':\n",
    "                model.train()  # Set model to training mode\n",
    "            else:\n",
    "                model.eval()   # Set model to evaluate mode\n",
    "\n",
    "            running_loss = 0.0\n",
    "            running_corrects = 0\n",
    "\n",
    "            # Iterate over data.\n",
    "            for inputs, labels in dataloaders[phase]:\n",
    "                inputs = inputs.to(device)\n",
    "                labels = labels.to(device)\n",
    "\n",
    "                # zero the parameter gradients\n",
    "                optimizer.zero_grad()\n",
    "\n",
    "                # forward\n",
    "                # track history if only in train\n",
    "                with torch.set_grad_enabled(phase == 'train'):\n",
    "                    outputs = model(inputs)\n",
    "                    _, preds = torch.max(outputs, 1)\n",
    "                    loss = criterion(outputs, labels)\n",
    "\n",
    "                    # backward + optimize only if in training phase\n",
    "                    if phase == 'train':\n",
    "                        loss.backward()\n",
    "                        optimizer.step()\n",
    "\n",
    "                # statistics\n",
    "                running_loss += loss.item() * inputs.size(0)\n",
    "                running_corrects += torch.sum(preds == labels.data)\n",
    "            if phase == 'train':\n",
    "                scheduler.step()\n",
    "\n",
    "            epoch_loss = running_loss / dataset_sizes[phase]\n",
    "            epoch_acc = running_corrects.double() / dataset_sizes[phase]\n",
    "\n",
    "            print('{} Loss: {:.4f} Acc: {:.4f}'.format( phase, epoch_loss, epoch_acc))\n",
    "\n",
    "            # deep copy the model\n",
    "            if phase == 'val' and epoch_acc > best_acc:\n",
    "                best_acc = epoch_acc\n",
    "                best_model_wts = copy.deepcopy(model.state_dict())\n",
    "\n",
    "        print()\n",
    "\n",
    "    time_elapsed = time.time() - since\n",
    "    print('Training complete in {:.0f}m {:.0f}s'.format( time_elapsed // 60, time_elapsed % 60))\n",
    "    print('Best val Acc: {:4f}'.format(best_acc))\n",
    "\n",
    "    # load best model weights\n",
    "    model.load_state_dict(best_model_wts)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def visualize_model(model, num_images=6):\n",
    "    was_training = model.training\n",
    "    model.eval()\n",
    "    images_so_far = 0\n",
    "    fig = plt.figure()\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for i, (inputs, labels) in enumerate(dataloaders['val']):\n",
    "            inputs = inputs.to(device)\n",
    "            labels = labels.to(device)\n",
    "\n",
    "            outputs = model(inputs)\n",
    "            _, preds = torch.max(outputs, 1)\n",
    "\n",
    "            for j in range(inputs.size()[0]):\n",
    "                images_so_far += 1\n",
    "                ax = plt.subplot(num_images//2, 2, images_so_far)\n",
    "                ax.axis('off')\n",
    "                ax.set_title('predicted: {}'.format(class_names[preds[j]]))\n",
    "                imshow(inputs.cpu().data[j])\n",
    "\n",
    "                if images_so_far == num_images:\n",
    "                    model.train(mode=was_training)\n",
    "                    return\n",
    "        model.train(mode=was_training)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "31"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import gc \n",
    "gc.collect() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_ft = models.vgg16(pretrained=True)\n",
    "num_ftrs = model_ft.classifier[6].in_features\n",
    "model_ft.classifier[6] = nn.Linear(num_ftrs,20)\n",
    "#num_ftrs = model_ft.fc.in_features\n",
    "# Here the size of each output sample is set to 2.\n",
    "# Alternatively, it can be generalized to nn.Linear(num_ftrs, len(class_names)).\n",
    "#model_ft.fc = nn.Linear(num_ftrs, 20)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_ft = model_ft.to(device)\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "# Observe that all parameters are being optimized\n",
    "optimizer_ft = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# Decay LR by a factor of 0.1 every 7 epochs\n",
    "exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0/24\n",
      "----------\n",
      "train Loss: 1.1630 Acc: 0.6506\n",
      "val Loss: 0.4285 Acc: 0.8623\n",
      "\n",
      "Epoch 1/24\n",
      "----------\n",
      "train Loss: 0.7666 Acc: 0.7683\n",
      "val Loss: 0.4881 Acc: 0.8556\n",
      "\n",
      "Epoch 2/24\n",
      "----------\n",
      "train Loss: 0.6378 Acc: 0.8015\n",
      "val Loss: 0.3839 Acc: 0.8792\n",
      "\n",
      "Epoch 3/24\n",
      "----------\n",
      "train Loss: 0.6008 Acc: 0.8176\n",
      "val Loss: 0.3011 Acc: 0.9055\n",
      "\n",
      "Epoch 4/24\n",
      "----------\n",
      "train Loss: 0.5706 Acc: 0.8281\n",
      "val Loss: 0.3836 Acc: 0.8873\n",
      "\n",
      "Epoch 5/24\n",
      "----------\n",
      "train Loss: 0.5341 Acc: 0.8351\n",
      "val Loss: 0.3003 Acc: 0.9170\n",
      "\n",
      "Epoch 6/24\n",
      "----------\n",
      "train Loss: 0.4934 Acc: 0.8469\n",
      "val Loss: 0.3025 Acc: 0.9022\n",
      "\n",
      "Epoch 7/24\n",
      "----------\n",
      "train Loss: 0.2898 Acc: 0.9083\n",
      "val Loss: 0.1552 Acc: 0.9541\n",
      "\n",
      "Epoch 8/24\n",
      "----------\n",
      "train Loss: 0.2348 Acc: 0.9273\n",
      "val Loss: 0.1412 Acc: 0.9528\n",
      "\n",
      "Epoch 9/24\n",
      "----------\n",
      "train Loss: 0.2231 Acc: 0.9318\n",
      "val Loss: 0.1423 Acc: 0.9561\n",
      "\n",
      "Epoch 10/24\n",
      "----------\n",
      "train Loss: 0.2173 Acc: 0.9323\n",
      "val Loss: 0.1376 Acc: 0.9541\n",
      "\n",
      "Epoch 11/24\n",
      "----------\n",
      "train Loss: 0.2121 Acc: 0.9367\n",
      "val Loss: 0.1427 Acc: 0.9548\n",
      "\n",
      "Epoch 12/24\n",
      "----------\n",
      "train Loss: 0.2091 Acc: 0.9348\n",
      "val Loss: 0.1323 Acc: 0.9568\n",
      "\n",
      "Epoch 13/24\n",
      "----------\n",
      "train Loss: 0.1903 Acc: 0.9395\n",
      "val Loss: 0.1390 Acc: 0.9615\n",
      "\n",
      "Epoch 14/24\n",
      "----------\n",
      "train Loss: 0.1966 Acc: 0.9362\n",
      "val Loss: 0.1326 Acc: 0.9595\n",
      "\n",
      "Epoch 15/24\n",
      "----------\n",
      "train Loss: 0.1827 Acc: 0.9410\n",
      "val Loss: 0.1308 Acc: 0.9588\n",
      "\n",
      "Epoch 16/24\n",
      "----------\n",
      "train Loss: 0.1845 Acc: 0.9421\n",
      "val Loss: 0.1305 Acc: 0.9595\n",
      "\n",
      "Epoch 17/24\n",
      "----------\n",
      "train Loss: 0.1779 Acc: 0.9426\n",
      "val Loss: 0.1298 Acc: 0.9595\n",
      "\n",
      "Epoch 18/24\n",
      "----------\n",
      "train Loss: 0.1763 Acc: 0.9421\n",
      "val Loss: 0.1295 Acc: 0.9609\n",
      "\n",
      "Epoch 19/24\n",
      "----------\n",
      "train Loss: 0.1772 Acc: 0.9425\n",
      "val Loss: 0.1308 Acc: 0.9609\n",
      "\n",
      "Epoch 20/24\n",
      "----------\n",
      "train Loss: 0.1758 Acc: 0.9447\n",
      "val Loss: 0.1312 Acc: 0.9609\n",
      "\n",
      "Epoch 21/24\n",
      "----------\n",
      "train Loss: 0.1792 Acc: 0.9413\n",
      "val Loss: 0.1310 Acc: 0.9602\n",
      "\n",
      "Epoch 22/24\n",
      "----------\n",
      "train Loss: 0.1775 Acc: 0.9439\n",
      "val Loss: 0.1308 Acc: 0.9609\n",
      "\n",
      "Epoch 23/24\n",
      "----------\n",
      "train Loss: 0.1811 Acc: 0.9428\n",
      "val Loss: 0.1306 Acc: 0.9609\n",
      "\n",
      "Epoch 24/24\n",
      "----------\n",
      "train Loss: 0.1783 Acc: 0.9462\n",
      "val Loss: 0.1305 Acc: 0.9609\n",
      "\n",
      "Training complete in 86m 55s\n",
      "Best val Acc: 0.961538\n"
     ]
    }
   ],
   "source": [
    "model_ft = train_model(model_ft, criterion, optimizer_ft, exp_lr_scheduler,num_epochs=25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "checkpoint = {'model': model_ft,\n",
    "          'state_dict': model_ft.state_dict(),\n",
    "          'optimizer' : optimizer_ft.state_dict()}\n",
    "\n",
    "torch.save(checkpoint, 'sgd_vgg16_finetune_checkpoint.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGwAAABeCAYAAADG1PFrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO29WaxlWZrf9VvTHs4+5873xhyRETlUZdbQ7TbVhasL0zItYYEl3myBZLWFWlZLCAshoXYbCSFwW/DCA0LGCCS3mYyNsQ1GiAckWuAebNPqdnVlZWVWZmRkRmRE3LjzGfawRh7WjtvhdGVVtunb7SvikyLuOXvvs88+67/XWt/6f//v2yKlxEu7PCZ/vy/gpf3O7CVgl8xeAnbJ7CVgl8xeAnbJ7CVgl8x+3wETQjwQQvzU+PrPCSH+q9+D7/xJIcSji/6ei7Dfd8BetJTSX0gp/cwPO04I8YtCiD//e3FNP8yEEL8khPiZT21LQojXLuL7flcBE0Lo383z/f/RfmgbppR+4D/gAfDzwHeAE+AvA9W47yeBR8DPAU+B/4Z8E/xZ4APgCPjrwNYL5/uTwEfjvn93PP9Pjfv+feC/feHYbwK/ApwCD4E/BfxpwAEWWAJ/Zzz2OvA/AQfAh8CfeeE8NfCL4/V/B/h3gEc/7Le/8PlvAP8AOBv/fmPc/gtAAPrxWv4z4P8CErAat/2J8dg/Bvzm+Ft+Bfjqp9r454BvAQOgP/NaPidg3wZuAVvALwN//gXAPPAfA+XYMP8W8GvAzXHbfwH81fH4t8Yf8YfHff/J+Pl/DDDgNrAA/lXAANvAj477fvH5NYzvJfDrwL8HFMA94D7wL477/yPg/x6v/9b4ex698Pm/CPzFz/j9WyPQfxLQ4/WcANvj/l8CfuZTn0nAay+8/zHgGfB1QAE/PbZr+UIb/+Z4bfUPxONzAvazL7z/l4APXgDMMva4cds7wL/wwvtr5B6hxwb9H17Y14yf/36A/Tzwtz7jmj4N2NeBjz91zM8Df3l8fR/4oy/s+9N8zh42AvX3P7XtV4E/9TsA7D8H/sNPHfMu8M+/0Mb/+ue5ns875zx84fVH5OHnuR2klPoX3t8B/pYQIr6wLQBXxs+dnyultBJCHH3Gd94iD6ufx+4A14UQpy9sU+Rexae/d/wNn9euf5/jPwJu/A7OcQf4aSHEv/nCtoJ/tB0f8jns8wJ264XXt4HHL7z/NN3/kHy3/PKnTyKEeAK8+cL7CXmo+372EPjxz9j3/b7zw5TS659x/BPyb3h7fH/7M477fvaY3OAv2m3gf/+Ma/l+9hD4hZTSL/yAYz5X2OTzeon/hhDiphBiC/hzwF/7Acf+JeAXhBB3AIQQu0KIf2Xc9zeAPyaE+KYQogD+gx9wDf8d8FNCiD8uhNBCiG0hxI+O+/bJ89Rz+/vAXAjxc0KIWgihhBBfFkJ8bdz/14GfF0JsCiFuAi/e6T/M/jfgDSHEvzZex58gz8X/62dcy/fb9l8CPyuE+LrI1ggh/mUhxOx3cB3ZPucc9txLPAX+CjB5YQ579KnjJfBvk8foBXlY+wsv7P9p4GM+n5f4zwF/D5iT79KfHre/zm97XH973HYd+Ktkb/WE7Pg8P+8E+K/H4/8xL5F8k/2lH9AG3yQ7NWfj32++sO8PAe+N3/mfjtt+ltyrT4E/Pm77o2QP83Tc9z8Csxfa+Kc+zxwmxg98pgkhHpAn1f/jBx740n5P7J8qpuOl/XB7Cdglsx86JL60f7rsZQ+7ZPYSsEtmF8auf/2PfD155xi6AR8TQghMaTBFzc7mHjeu3kCbAqHh6PAZH9z/HidHh4CgqifUVYnRBuc9/arFB09IabzDEiC4evUqq8WSs9UCpTVNM2N3c4dpPQUEUkiqoqKuDVKr7BYLQRKSoe+x1iGNQSnBxnTGtJlhCklVFpRVRRLw5Mkn/M9/539h6Pv8WQSJRAweEqT83/m5hRAAPP7oibiIdr0wwN649yX6rmU5n7PqV0QiIUW6zoEQHJ8ccraYs1wt6boV1vUUdc1k0nDtyk2++OZbCCF4/Mkj3n/vXbpuQYyJGCOkBAIOT08hgSkrRIIkFRFNP1iElBhl6PoOa3uk0dRVxebmOhvbmyAEfdfRth19P4AU6FJSVRWFNggkzg0cH58QYyQJQIBAwAhOeD79p8zCPQftIu3CALO9Y+gsuiiYacV0OuXsbMEXXrvJzdu3afsVH9+/jxAgU6A0hulkyrUbt7n36hdZ29omBs9sfZubd16FFCiU5ODwkI8e3Ge1WpFiRMl8Vy8WC/Z2r1AVE7zzpBhIMZKkAKFQEoLzHB0ec3h4xHOOVhtFVVZIwGhFSpFVt0QAvR34zjtv471DIs57mAAQAkEcO7vIi+hzrC4OtAsDbH5ywlk7Z2trh0k9YWN9i2EI7F65QYiC4CNFUVHrCuqIJ7K2tsHVq7e4duMOIQX6vifElgSkmPAktneusL2zSwqRREJrjZSCX/3lX+buK3fZ2dnj+PiI5ekpwXqsdVg3EBNUhULEQIhhbPZEbweW8xW6MLRdiykMSinKskCQCN6Tu1bKIIuIkBIJSDJQMUZSyuDFlPdflF0YYB89ecDu1WvUdc325hZNM+X+g/u8/e3fIKbIYj4nOMdifoYqDFeuXGNv7xqmKHnw4fs8O9jnycOPmS/PMIVmUtVUVY1UGqKnb1v6fqBpGibNhPnZCWcnp3SrjhACWiiqacmEhHMeNzis9XjviN6DFAiRKKuSK9evMJk2nJ2e8uzgkHbVQUpIEVnMF2OHEaSY8nAoJVIKkJIUI0IIpJIZsBi5yKXShQEmjMQnj3UdMVr6fkXfrXj3e9/BlAXXr11n2jT4YCmqmuvXb2HKiuOzI06Pjzk7OiTExNWr19na2qRpJihl6NqOk9NDuq4FEknAYAekEnz80X22t3dJSSBT7kOChJISGyI+RqRImKJgOm1Ym60xnTUUdYmLgaqq2FhfozIFdhg4nR/jQsi/JyWeE+rjoHj+LomEEIoUQ3Y85CUcEu/eusukbphUNSQ4ONinnpRcuXaFGD3z5Qmnp4muG1hHsL//lNnmDk1VMW2mNHVNEgKERAiRHQNhEQi2tne5cuU6s9mU6WyNmBK//g9+jbOjQ+688iqQOD7Yx/tASonCFEyUQihBDImu61itVnjnadslxmjW19dYq2t21qZIKQne8au/9mvEFEZkBELkHhRjPJ+3UkqEEIjRnTsjF+l4XBhgVdlQmpqyrBFCMJ2tYb3Hxchge6oEPibeeP3L7O5eZ7a2wfrWJrooWcxPWS0XxOARKBCglERpzdbWNpNmiht6Tg4PeO87b7O//4T9Z0+5e+cutu84PT7m4PApSmk2NjaZNFNiDLTtkpigKAvW19eoJjXee4Z+oLUeoQ0HR0fYvkcJwfHJGaYoCd6PTkpEaY0QkhgCzvtzjzV7kPnmupRD4ubmJtVkQggRJSXlZEI9nXEtBFKIOOdY9QP37r2OVAbrHftPHrP/7Cknx4dIqajG3laUJWVVszZbw0hJ8paD/cc8+OB92lWLUoq16QyRJIeHh0Tv2d29glKaQhe4oc/hdanO56F2sWBoW2IEqQ0iWtoYIES89zw5POTGnVd4c21GiomYIt5ZvPUEb3ny+BP2Dw/wIaKRJCVyT7xgqu/CAEsxcXp8jLUWZwectfjg85ACxBCoJ1NOjo+o6gZlFM2k4bXX3kDrL6F1hfMOrQ26qIgpoaVAGkNMien6Nq+9NYUE773zW/zYP/MNmmYtL2qjo9IGSWK1WnJ6esxysSCGQIwJISTGaJTWxJR7htKCstDUVQkS7JOB08dnPHro0VqjtCHFiHcOO/S03QohBSIKYsrD5fMF/aUcEp8+fUyMAectymiqakJTzlgsFpTVhL29K0zKCZPZGlIbJpMJQkkikkRCJokpDNoUhATRB2L0DDZgTEmzvs1sQ9Atz9h/9pQ33niTjfVNhBIgoDQGoxUheG4Fhx0scVwzSZXd8rYfGKxFRoHRkpgCvbVEsc/tu4k7r9xjuTjj7OSYs9MTDo+P6boW521eSI+e4wvBzNHi922T3w27MMA2tneIziMR7OztoYqCFBOfPPqYoR84Ojjk4apla3eX7a1tCq0pp1O0KlGFptQaIggpCeThKAWPljJTWkIhROLpxwe4oaOuCiBQyILCaGJKrFb92JgehAJpEFIhFERvicGzODkihkhRlAx24PjkiFW75PDokLPTOVVRsWyXKCG4eu0mN2++QnQ9J6cn3P/wA7yPqPE3x+fzWbqEPeyjjz9kb2sPkuDk6JiqrtFlyZVr11mcnXJ8fERZlVy/foN6MiUJjbOehEf00ApJVVYopfJiVEjKqsFoDd7T9kva5YK+a5FC8M53vs3V3asIKYnBE2IkhLyYlVIipUQog1YKozVSKbQWFKZEFCCVpKpLdrbXsd7z6JPHvP3t3+JL3/xJXAjYwSFkQiuNkpJrziKk4u13fouEgJiQKRFFRJ1D+LtvF+glljSTmq2dXXSZe4Q2BUPfsX90wNB3fPGNt4ghoJQgRodKkknT5LllZH2894TgkULinCMJ0BEQiUmzxsaO5/UvvsWPfOUPUFU1AN477DDgfEAKIGT2IcRIZz3OR2JK+ChIAhKBFAJgid5y+Gyf777zDhvbO5ydnSGFZPCBFH0GWimkFMzW1jFK4bzPoElBVU4w8hICdnX3Gjs7u+iqIAlBcI5utQIBX3jji9x//z2++923uXrtFklITFmRhER0PQhBjKCUIniLGwakUhSTCYUxVIVGlxUpJezTfe69+gU2NrYRIi+Qk/JUpmYiJEoqlNIkkSBGYiKDSGS1WtG3LcMw4ILD+4jWFUkq2q5nSyoOn+1jvQWVXfnDg2d52ZwSh0cHWB+QUpNSRKTEdDJlc3P3opr14gDru55nzw4oakNRltT1hMF2fPzgAfP5KdY5ZmvbKF0wDB5lIn3bIpLEB8/gHFpryqJAKEVRFpRa0XVLglDMlObDD95nd3ubja3Nc2+0Gwb6tsON86cuC6TWeO/zsCUkWoJQCqkkdVUwbSb0PtBbh/eOveu3+fGfmHB48JTlcsGjhw9IUvK1r32D27fvsbm5xeGzfX7l7/6f1PWEV994k+gsx4fPePzJIx6cnFxUs16gWy8EZV1TFJqyLKmqCU/393n/w++RYmI6W0NrRVNXTJuSZjpDKENKII3K4YuYkFJC8tihY7mY40NgUk3o7TMOD/epTcWkmYFIuODp+47jkyMOnz4l+kjZ1EzX1xi6Dtt1xDAyFUBRFKyvNeP3ZQAFeSklg6eQml5Ibt25y83bd7lz+x5KGaSU1M0aP6EVf+/v/hKPHz5iZ2ubspiwvb1H13UX1awXB9iDjz/k5u3bNGXNzdlNSIKbt16hmU75+MP79NZy885dZuubgMJZSwg9gxtwztKuWrquwzlLioGiKKjqms3NbaSExdkJRklOz44pJhNMXRCcI0bB+uYOG1t7FEWJNgakQiQIwTIMuRfF4BEJpHwekHRYZwneM3QL3vvee5RVxcbWNq+//kWqukEAWo7eYIStjR3u3r7Lw4ePuHH9Dq/cew2lJCGGi2rWC5zDrl9lY32TsijxCcJgsdaSkBRF7hUKwbMnj0lEZrM1rHdEElKA1iWbW5sUhWHSTFFKg5CQItY5hICiKDk5O+Kjhx+RUmJt2jCbzWjqCaYo2Fy/QVHV+OByZPrkBKkkzbRhbeMqlSmARIyBGCO99bRtx9nilCG8w+LoCKENH338EVf29pifnXF0dMhysWAxX9D3Le1qznK54Fd+9Zf4+PFDrl69xRe/8OYPbZ9/Ursw1dSf+bk/m6azdby3Yy/JaxQpBCKCdZbFasn89JS1jXV2d68RU170NvWEupmC1KAEWmpCcLhhABJlWVGWFUZrunbBd7/7HV577QvsbG5RmByKSQJsBI8kRU87P2V1doKUiiRk5jUHizZ5cT0MPcEHiBGfIk8efcRv/Mb/Q+cdd+6+zte/9oe4evUqJEXwjqPDQz76+EMefPAu+/tPWV/fIKac9fHaq1/kb/73f+VySQRAcPhsH+8GpMgur5AKow3eOx58+CEhBNbW1pgvFiyWS7Q0bG5us7mxidSSFBN28LQ2h1K0FAgEth8IPjEMPQ8//oBbt15FVzMGlzBGshosAQlKo0RCJcnGxjZrs3WklKQkiClhnSPGQCIwtCusHYghgpQ0zZTD4+M8f926TVHWhJiYnxxxenhCUdV8+Us/xptvfom//Tf/Gm+99VW+/CN/gFXbslosL6xVLwyw5XzOdNJQrW/kaC2RJARSKASwtr6B945n+/vY3nL1+k0m0ylFUeFjRDjPdLpGo02muGwOrTjv8WNs6+Bwn7P5kldMgbUeQsyxMSkJSKQQ1EWBUoLSGJQWY7BRZwbEORaLZZ53XIAoUNrggudb3/4Wf/BrP8GN67eRWuFjJHjP1nbB+voGy+WC05NDPn74gOA93ieODo7Z2d7j6s61i2rWiwNMap3D76sVQpGZijI7DiFGnj59wrMnT9jc2uHalasoIVnMz5g0kcZsMu88bXeE0YaYYp7bEMQERmtE9HSrBdNJw2JxxsaWwlRTlJCklDDj8Bujw7uAczaH/6VCSovSmkILKqPoeovzPi/MY2C1mhO9Z31ziyF44jhnGilH9VdBjBPa5YrNzS2+/s/+YW6/8lpe40kF4RJyiZ988pCtjS2KomBttgVSEX2g7wNd19G1HdoYhq7L8a5Cs1bMEIUmRE9ZlKhRO6GEBiIpRrQpqOsKEQNf/eqPcHx0TNd33H/3bdbXt7j32uuImHvzyPUSYiAGx9C3uJBAKoqipFCKwpSURUUAfIy0qyXNpKZpZjy4/wHGFJiiYLlaEG1ASYGzlqKs0KZg79odSlPkxlSSmBLztr2oZr04wHavXmF9toFAEZwgihyqN1JRb9Zcu7bHql3x5JNPmM42ULrM7IVWpBDzXBJijg8KSZKJoiyQUjIMnuAdKYLQFYLA2toOzXSd09MVSiqEkmglKQqDKioqrRBC0g6eZddxfDLPw2yMSK0oqoKmLAkhslgNtCvH6cmKV27tsL13BSEjBwdP+Yff+k2uXbnBzt4tlC5ASnyCUku0VBitkLq6qGa9OMB21q/gyZSUkoG60KQQCdHjgyB2imfPnhGSJESFGyzCebQpUUqSUiAJUMYgAOcyAUtKoBRGVzkc0nacnJ6yu7dHWVcoZSAJfAxY71n1Lc46RAKtNXVRURnJdK2BVHN2dsrQdcjoUUqytIH52Qo3WKp6wkcPHtC2PbONdcqi4s0vfJGubbn/4bvowlDpiqqqmc0a1qYzEMUFUr8XCFi37LGhR6QAAk6PB7a2t6knDZ3tmC8WbO9epyoqQsiyMykESsQ8Z0WHTILj42OGVUsSmtnWFvW0ISKI0bOcHxO8p2mmOB+YL+coZQg+4bxHkL3G4AK+d1jbMyyWxKGn61oG1+GGLAeQKExZcOf1L/Daq/fo3cDTJ48wWzPqeoouFNO1Lba2t3nw4bss5ydszjZp247lyrK1vUlZVSihKaryopr1ArnE1Slni1NccGxsbBC9RyHwLtC1AxuzLWKSeBcZhpaiKGimDdoopFL07ZKP3vse9999DyUFRmu2tve4/spdiumEsqrQRpBCYHd3j6qa4GMkEnGDpe0S3gXadiC1K7qzI85OT3OI33kGbwkE7NAzDB1SZznBfLWkbVuu3bmNt56tqzsYU6KMIRKRCBZHx0x84ObuNer1zZHxH7UcCQbb//AG+ie0i+th3YLHjx+xc+UKSkg2t3fQhcGnRFlOsC4Qg2V+dsL9D95lfWuLL7zxFmUzpSw0D9//gA+/9z4uBFyM3H3jHjeu38QNDr+cs7G2jjKauYsMg0eIgbqqEQLWJw1d0fHw/vscP31Gt1gx+AEEOOuyZCFarBs4PNxHKElRVhRFSe8Glr/56xwcPOGrP/ajKODp40/Yu7JHWTcEEm0/sLu5SzGZElIC5CgkjQSy/OGi7MIAK4xGGUM5nbK9d5WqKhFK8+zxI7Y2t3HB8+jBfR4/eUTTTLl58yZlPSEGx+nxKR++/z7HZ4fU9ZQr27t86a2vsr61xWqx5PjgGfsP7iOrNaIqWSwHhpXlxB/hhp750RFnZycwStQGZ2n7jkTE+8AwrOhtSze0tH2LMWZU60qICed6vvveMadnp9y8eYfN3S1cP0CCtu/Z3bvG9RuvYGMk9h0+JKbTrC8RUuCCv6hmvcB1mJJc2dvl2u4OELLIUgoODvd58uQhd27dZWNzg2s3rzOdrqFUMSqiA7Zv6boVPmSN/Gw24/TkBOss1jqiSCRvWTx9jKpn+JAzXKILKJkoS41tl5ws5yidXYCUEr1tsUOPC4EQLMF5Ellr6JxFa4PzEakU3jkODp5gbc+XJl/h3it3WbQ93gumsy2W8zN0WTCZTPjee9/m7r032NjcJcWY12IXZBcK2M7OHk3dnAtWJJKb12/y9tvfIqbInbt3kUIRosQ5j3eW4Du0VkzXZljvz7Xzi8UZi8UZEkW3WmFXPSIJVsunOOeJKTAMlqLUJNkglCDEiBs8MeVIcT+09F1LGLXwPngSCe/9uUbeaIM2Gucc2hTMF3O+9Vvfwg0RXVQUVU27mmPdwPrWNqa4RlkUHOzvo3UF0SMuMOvuwgALDqSE46NTUnBMJg1KF6w36/z4174xRqFz7EsqhQgO7zpEjNjeMmumnBwdI1Li2bMDDg4OkTILc6ztMaZAIPHRs+pWWDfgnSXGgPeWvb2rvHb3VZSQzJdnHJ0eslpkxsN5R4wj6R0TSiu891jvGOjGxTb4EJnNNmAleOedf8i1qze4e+8Ndm/f5myxYG1jk8IUrG/sUNcNbujxbkCry+gl2kAQAYWj6+ZIZVA+p8MJldBlRTe0WG8pixJSILoBQiBZDy6xsbaFkobgAhFHShYlBSEEnHMMdsBFx+AzUCF4hMiAPnn2hKaeslavURcVO+s5fantO0LyWGeJPmRXfNRlOO8gJrQyRJE4OzthGHrWput4OyHFQLtcceXqLcqqBhTWegpTs5i3OGtzDltYXFSzXhxgUUJZatrFKd3QsWsk02nD2ekxIsFkzVA1U5QuKI3h9PgZdtkyP5mznK/oB5c19bbL+vXksa6nH1rsMOTeRk7viSlkOXXMimLvPXawnJwe0a5aJpMaJRSz6QZ3lGH/6JDTdg5kvtF7jylr1taz3C7ExLJdsFic0VtHWC4RumamNH30HB4fkXxEPX3Kzt4emzs7lEVFVVX0Q5+zMy/ILgywWVOhhSdFRwiRwQb82YIQJCLB6emcqU/M1jZYdT1Hj/c5PjhkGCzWWbqhpbM9AYGSAikhpoAPPs89PmdyPlfjhhCIKRJiprVSSixWC9JEEAlICcZUlKbi+t516uWUKAPRRXprUULhvMU6T0iREBPrm7vcee1NmmrKld2rXL96BSElWhecHDzDWcfR8SHD0NNM19nY3KKpS6S6hNRUXTcoJaicJSbF2dmS2WzKpCpzA1uLSI7jx4842H9K2y5ZtCsG1+O9w4eQc5qlIiFJSGLIGZC6KAjBE1yWs1nnzxPqfAxIITBFRUgeFweS9Zntt5baVJSmZHdjC6EFJyenSK1xzmNXPZPpOnVZc+PmjFfvvcbW7h5usKzN1nKakZScnByzWC3RukCako3tKzTNhK7vmJ91YyrUxdiFAeZsJBCQSbK9s4GQBmMKlu2KZjLBDh0fv/8BfdfRDT3d0DP4gRgc3jlSTkjFmIhRFVIohthnOZlUNGXNYn6a3zPmbklJVdaUhUaOGSYxeKzzRAFSBYK3hFChpCYpwdXr1wgx8eGDD4gCNrevcP3aHZJz9CtH2kxMmgZdGpqqIQFKCQoD+0+f0cyaPHyenTFpGspJfTmpqW61zNFmKRBKsL2zyTA4tFCszs54+PAjrLXZ9XYOHy2ClIe7NCbRIVDSAILBDud5WVppJCLHyooCpQJKKepJgxSCtmtzKEYp7DBknWOKWeco5HkFgMF7nPM5Md5bbt95jaowbKxPMtnc9bhhQBDou5bH7WO6VY+Ljr29XV65+xqzZkbvcyapGyyEwO6VKxfVrBcHWGtXBB8JIXC6nNPbiIiJg2dPWCzmhOCyPl7mJARBBJHQUrLqLSEGjC7o+55BZO8rCbIwVEq8t0glMabA2iUhJYoQGJwlhqyy8sETQkBpjXWWwhgAvBdY6wgpp7tOmxlrkx20lKzPNugWHZkWFBwfnRFjYvCOdjUnAWubG3gfefzkENt/AmSu03mPDZ79o0soEXj49CnNpGF3Y4emLlgszvjk4SN8tDk8HyNGK7wbiCmRYsIYg9YG7y3LdkWMHgGZr5OSGCNKaSSJkCJlUbJcLBicQyrNfLlAAHVVkhJYO5B7pyWlfPMYbeispe8zQRtDJIZAZS3raxvYtiXZxLWbN1jbzDr7w2fPWCummKu7oARHRyccH51QN1PqaUmKiaaZIaVEGZ31/xdkF3bmsipp6hmFKjk9PuXkeJ/BtSOjLZACQrRAVuMKpdAyq35jyPQQQhJJuOgx0mQlr5Roo0gYQkxsbG0zC2sMw4B1Dmstq1WXnRA4XyAbo1EJvPX4GEhC5M9YR9f1FEXJYjHnyjW4fedVOmdZfPI0x8EmE0pT0i5adKGZNTVKFyhl6PueybRm0pTn9UIuZbqRTIHkeo6eLVm1c5wbSDEXV5FCIoQmRk9MEKOHGFksF/TW0tkBpXUWkCqNj5B87gltN1DZwGB7nLMArK+vM6kaJpWgGzpCHBkNZ4FACIEwWIR1SKkwhcEojVKKwVq6ocfFxO7VV/jyV/4gRVlTlAVD11MYjVQgomA2a4hSkGJOWj85PqQoC6Ir6VcDy0VPDDFr8S/ILgwwEwPYATvY0TPz+BAY88xJIpFidgYG2+Otw4Yw5iBPkNqgTInRGgU4PzodCFIMGFOMSeDQ9V3mLBPUkwmFKTg5O8WYEud6nHPnvbYwBoTADRalJM2koR96tndv8o1v/hH2dnayY2M0Q98SnGeiG7q2JYVIt+rwNrJq21zqAQgx0Q0daxsbSCXpVpcwHiHWRo8AAAqiSURBVNaulrS0eBcI0edFqXcIKSmEwDuHAOy4WG3bDlOVmKKCBEobhNJorTHaUFCRXO6hieyuC6WJ3hF8BiQJMo1lLVWRU2tTyqH/FOJ5umxRFmO2v0QIiVSaL7/1ZXZ3dugGi0BiQqJrHcFZijJlDzNF6rpATBTT9RpjNMFbfIycni1ZLVuk1HTDcFHNenGA7R/so02BkgpIpJSTEJK3hFHDnlJWNNkQkCYDNAwd3lqqZsrmdEapCtSYjWnqEu8HrOsZQs5jdl2H0pZ+6CmKimZSMwwt1nZIrWimDUM/4IUnhezqt22urlM3OYb15r2v8uWv/GiWbIdEioFu1dH1eYmR5i1SKmJ0aCWzdtFHDlenSJHna2MmlEaytbONMpfQ6XAhs99K5fCIROBDJI069pRS7gEITFGQErTLBdYOSJHl1ckNgKaqG4qiRimJVgohoNSGfnAgBSEKlCno+hXeDwgpUEpRaElwLqfbCoHUihAj02aKMBU721e4eeMOd+68yslJS7dsIQliCAilmU6bLDE0hhgj7coRXMKHnqppkEqgVJZ9x9DTLx197y5nQp/zCa0NXdsihKAszPk+7zNVpLTBFCXOWtrVKgtAR9deKzlWmvF03YKuXeSE8jHHedrMclmHomQsgkddT3DeUpYFpdbsbMxYLVt667De50Q+IagmU6Ss2dm8xqze4uRwmUGSECOYsqQqy6y2EgGpFImEUoJJ04wL8YTSJRIQymDKgnYxBwR1eQmZjhgzn7hYzHPOsfdorcbCIxATaCFJIdC1LTFG6rrOJRaUAsa8ZHKO9/NiXoy9z9oebSoEUJoSlyAlT7SJ1XJJKg3HBJx1SCHQSlEXhms7eyy9ZNLs0kw2qCcTehsY+g4lZRYMydxzypGztNYx9BaZFEMXkFpmvtOT61rpgOoze1JWiqq+hIANQ8vQF0ybhpOTE5Z2RVHkpHCps6cmpMzlGGKmjYwx54DmsoTPywQBzwFD/HYlmtgTYo6BkcivyWu6elKhVKa2TudLTFGyvr7OybIlSEPdZJJ4MV9QT6fcvLGXFcVK5Ui3FNmz9YIQHaaQpJDyUiQIhNBIlZkSpTQp5DpT1nqezA8uqlkvsDiYEBwfH1IUJYlESIneOupa5ztea7xzDH2PlJKiKMaagyMgpEwCp9+uoCZeOHeXIsbkUhJSqdwbhULKRD90HJ94NtenSCFRxhASnMxXCG2Yn5xy88Y9tnc30UojEHhn6SVoUyISzOfLvKayjsVigU9QGUNdawYXkCJilMb6ARsye1MUktVZz6q7hOsw77PAZbCW6do6zg7nDX5eUGu8K6VS4zwBpBzjCnEsUvn8iQijo5JTaFOulzguwjMhbJBaoKSkH7JsTUvFou1zWlFOmsS3HSEkpMmVR+u6IsSI0pKQEl3fc3q6xDtPt2zphoEkyESzj7SrlsEHqtIwMQWmkAgpcokJIZnMKnRlPrNd/r/axTEdUubxXUkm9YRBSlIMeB8wo8jFh4A245w1JhZKyVjBTeNTLs8QYxzzujLQQgiIgegygDnpIVEUFboo0VLQrZYQLAh5rojSWrNcHGPKhpOzFY+fnDCpDHVTMVurKYqckVk3Bd7CpJoSYp3XawjCWI1nmgK7V3az+MdZJrMZXd8iVYn3iUm8hNRUCDnksb61jdaG5eIMIXMdDjGWqcsFT3LNi+eNkueqOPp9Y9lvkQtvvVjDKaaEiinLA4RA6dxDpVJc3d3l+PQYbRRdP+TFelWxWi4JIVBKxdp0Da01IQm6NnOKIXi00ZSlGYtk5vQm7xyzaY2cKJSu0LqkmTbM53OiMtT1hLKqWax6iO6cAbkIuzjytyhIwHKxQI1usdGa57UfpZTUkyYzHkI+dyeAkZ0n5clcJqKzOYvzxaJbzwsijzV/U47OUBWGmS44OTlmGBzD4CirXByz705IQGEKXrt7k431dfohS9ysdXibQe96m3PRBJRVQUXOSVt1PVobYuFJcUEKnr7rieEUaUoIEVPoXO/qguziuERjWCyX58OZ1holFcmYPBcplQseyzwHMVaulkJCzMOPljo7G+O6R469Mj13Qp4DmARamzGHWvLs+ASkwPaOECMyJObtGUIIqmrCzVt3SWTAN2cNQiaQEELEx6xvdLbPGhGbICR669G6REmNc7kqjrOBdhlZLhfA8vwaxQUKEy8MsLP5/JzRCCHgvaeqKoQQeJ9JYKnEeZ2m55oMlEAJgVCKGANS5CDl80z/50NtVtdmf/65l5iSYNW2zFdL+qEjkTIb39tco1cITFFy7foNps2M4MA+D57K7NzkWh8DMglSVNihH5PiI872dP1ACIHBdiz7Hms9IYzerFJoU1FdRl1iUdYMfV4Qp5jJ0xizm5wilGWFTyHnPqdcBFPwfFGdzv8RM8su0rjeSRBjzoRUWmWiWBWEEInR4txAO36v954YQRtDWdTcunWX17/wZdanm8xPFgxD1tpzXl00y+ZCCLgYcDEPzTLl9CbvB6x3WO/o7ZI+OQS5ZqKWCl0UJKUuZw/bu3KLJ48fEGOHULl4Sdu2lGVgUk8I0Y9OR346xPPekmKWEhhTZEZeyCzyVpJIdjxEMkRSBkNrxDgcxuizdt7nIGgCbtx8nZs37rGznasTiKRwQxaiOhewPhKjz/G7IBhixMW85AgiZ6J4HwjRQfA5nUkmVD1lphVGSKSQ1KairjVlodHyErr1t29/henGLg8fvMvQjfTU6JKHmDASJDL3ntGhyGRwyLXhIbvp2qClIcRAks9ZBZ/XaynlXKyUMEVJcrByNteVAqZrW2zs3KastnFWc3CwQkbwKZFEoihGDzUKQkhZWhezWktKkRVZQlFUBm1maAlNaahmJWWpiGNYp6wqTo+OWN9co64nHB2eXVSzXiCXKASbG9dpvrTJ6fEnHOw/oF3O84TuXHYuIBO6zz3AlMbsy3EoEjILN9VIWcHoEeayennOCXkxTV6bOedIISKNpqwnSKkILuCSRGooSsXapKKsKrzLXl6IgaQy86tzsR3S+LyY6aRmOilzOfVCUpeGojRoLaBQ+ff0DmsThwcLfDhjcJcwP4yYn6ZQmwqzcYXV2WFezI7ZIkJkVgIgIvKdfs4XZgfARw8Bos9ZJs9BzT1yfFJDgvBCSXIxcpT5GSkKU00oCkMpJaYyTKclRVHgbMD1A/0wkFx+7IeQ8pzq0kXJpNFM6wJjcrK5NlmLYm1ktQxY6+i7Ae8CQheUZYH2A4W5hOEVIxJKRrQUpKqiqaYcwTm9lFIixMjz55gQR8DkC882GQsfn8P4vMxSGgv/p0TMWarnVUeBkerSuYJpFJwt5lk1pUAfJgSSQhtKbSh0fnRHUgZEJndLXbK5MWF9o4IUc0pUSKRRg2IHx2Leseodgw/nREC76rB2YOUuoUQg+A5d5LpO88WcebskP0zqt58ERByDmGJs8BE4KcQ/UjY3EGB0/xEiywSeU1ljYf8XC/wXZc3VG68yqbfo2hUIDTpXdVOFwCiDEQIFSC1oJhNizDdBWUomkwnGSIYuV3/rO8fgM2CSlFl8l5/honUuWhY9WOexSaLK+qKa9eUjFS+bvXxC3yWzl4BdMnsJ2CWzl4BdMnsJ2CWzl4BdMvt/AUayEGiM304WAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "visualize_model(model_ft)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_transforms = {'test': transforms.Compose([transforms.Resize(256),\n",
    "                                              transforms.CenterCrop(224),\n",
    "                                              transforms.ToTensor(),\n",
    "                                              transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]),}\n",
    "\n",
    "data_dir = './DATA/output'\n",
    "image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x]) for x in ['test']}\n",
    "dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=4, shuffle=True, num_workers=4) for x in ['test']}\n",
    "dataset_sizes = {x: len(image_datasets[x]) for x in ['test']}\n",
    "class_names = image_datasets['test'].classes\n",
    "\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = models.vgg16(pretrained=True)\n",
    "num_ftrs = model.classifier[6].in_features\n",
    "model.classifier[6] = nn.Linear(num_ftrs,20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "ch_pt = torch.load('sgd_vgg16_finetune_checkpoint.pth')\n",
    "model.load_state_dict(ch_pt['state_dict'])\n",
    "model = model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the network on the test images: 96 %\n"
     ]
    }
   ],
   "source": [
    "correct = 0\n",
    "total = 0\n",
    "with torch.no_grad():\n",
    "    for i, (images, labels) in enumerate(dataloaders['test']):\n",
    "        images = images.to(device)\n",
    "        labels = labels.to(device)\n",
    "        outputs = model(images)\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "\n",
    "print('Accuracy of the network on the test images: %d %%' % (100 * correct / total))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9662698412698413"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "correct/total  #test accuracy"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}