{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "37a4ca10",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch            : 1.10.1\n",
      "pytorch_lightning: 1.6.0.dev0\n",
      "torchmetrics     : 0.6.2\n",
      "matplotlib       : 3.3.4\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%load_ext watermark\n",
    "%watermark -p torch,pytorch_lightning,torchmetrics,matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d69e4366",
   "metadata": {},
   "source": [
    "The three extensions below are optional, for more information, see\n",
    "- `watermark`:  https://github.com/rasbt/watermark\n",
    "- `pycodestyle_magic`: https://github.com/mattijn/pycodestyle_magic\n",
    "- `nb_black`: https://github.com/dnanhkhoa/nb_black"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "dab647f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext pycodestyle_magic\n",
    "%flake8_on --ignore W291,W293,E703,E402,E999 --max_line_length=100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "df774680",
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load_ext nb_black"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1c4c922",
   "metadata": {},
   "source": [
    "<a href=\"https://pytorch.org\"><img src=\"https://raw.githubusercontent.com/pytorch/pytorch/master/docs/source/_static/img/pytorch-logo-dark.svg\" width=\"90\"/></a> &nbsp; &nbsp;&nbsp;&nbsp;<a href=\"https://www.pytorchlightning.ai\"><img src=\"https://raw.githubusercontent.com/PyTorchLightning/pytorch-lightning/master/docs/source/_static/images/logo.svg\" width=\"150\"/></a>\n",
    "\n",
    "#  A Basic Convolutional Neural Network Trained on MNIST"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6ca7538",
   "metadata": {},
   "source": [
    "A basic convolutional neural network [1][2] trained on MNIST [3].\n",
    "\n",
    "### References\n",
    "\n",
    "- [1] L13.3 Convolutional Neural Network Basics (18:39), https://www.youtube.com/watch?v=7fWOE-z8YgY\n",
    "- [2] https://en.wikipedia.org/wiki/Convolutional_neural_network\n",
    "- [3] https://en.wikipedia.org/wiki/MNIST_database"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12715ae0",
   "metadata": {},
   "source": [
    "## General settings and hyperparameters"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a17e6079",
   "metadata": {},
   "source": [
    "- Here, we specify some general hyperparameter values and general settings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5102ee38",
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 128\n",
    "NUM_EPOCHS = 20\n",
    "LEARNING_RATE = 0.005\n",
    "NUM_WORKERS = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae17116b",
   "metadata": {},
   "source": [
    "- Note that using multiple workers can sometimes cause issues with too many open files in PyTorch for small datasets. If we have problems with the data loader later, try setting `NUM_WORKERS = 0` and reload the notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47c3db2b",
   "metadata": {},
   "source": [
    "## Implementing a Neural Network using PyTorch Lightning's `LightningModule`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d9ccfc9",
   "metadata": {},
   "source": [
    "- In this section, we set up the main model architecture using the `LightningModule` from PyTorch Lightning.\n",
    "- In essence, `LightningModule` is a wrapper around a PyTorch module.\n",
    "- We start with defining our neural network model in pure PyTorch, and then we use it in the `LightningModule` to get all the extra benefits that PyTorch Lightning provides."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cf256434",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "# Regular PyTorch Module\n",
    "class PyTorchModel(torch.nn.Module):\n",
    "    def __init__(self, num_classes):\n",
    "        super().__init__()\n",
    "\n",
    "        self.num_classes = num_classes\n",
    "        \n",
    "        # Calculate \"same\" padding:\n",
    "        # (w - k + 2*p)/s + 1 = o\n",
    "        # => p = (s(o-1) - w + k)/2\n",
    "        \n",
    "        self.features = torch.nn.Sequential(\n",
    "            # 28x28x1 => 28x28x8\n",
    "            torch.nn.Conv2d(\n",
    "                in_channels=1,\n",
    "                out_channels=8,\n",
    "                kernel_size=(3, 3),\n",
    "                stride=(1, 1),\n",
    "                padding=1),  # (1(28-1) - 28 + 3) / 2 = 1\n",
    "            torch.nn.ReLU(),\n",
    "            \n",
    "            # 28x28x8 => 14x14x8\n",
    "            torch.nn.MaxPool2d(\n",
    "                kernel_size=(2, 2),\n",
    "                stride=(2, 2),\n",
    "                padding=0),  # (2(14-1) - 28 + 2) = 0\n",
    "            \n",
    "            # 14x14x8 => 14x14x16\n",
    "            torch.nn.Conv2d(\n",
    "                in_channels=8,\n",
    "                out_channels=16,\n",
    "                kernel_size=(3, 3),\n",
    "                stride=(1, 1),\n",
    "                padding=1),  # (1(14-1) - 14 + 3) / 2 = 1 \n",
    "            torch.nn.ReLU(),\n",
    "            \n",
    "            # 14x14x16 => 7x7x16                             \n",
    "            torch.nn.MaxPool2d(\n",
    "                kernel_size=(2, 2),\n",
    "                stride=(2, 2),\n",
    "                padding=0)  # (2(7-1) - 14 + 2) = 0\n",
    "        )\n",
    "\n",
    "        self.output_layer = torch.nn.Linear(7*7*16, num_classes)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.features(x)\n",
    "        x = torch.flatten(x, start_dim=1)\n",
    "        x = self.output_layer(x)\n",
    "        return x   # x are the model's logits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "62a5f90a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load ../code_lightningmodule/lightningmodule_classifier_basic.py\n",
    "import pytorch_lightning as pl\n",
    "import torchmetrics\n",
    "\n",
    "\n",
    "# LightningModule that receives a PyTorch model as input\n",
    "class LightningModel(pl.LightningModule):\n",
    "    def __init__(self, model, learning_rate):\n",
    "        super().__init__()\n",
    "\n",
    "        self.learning_rate = learning_rate\n",
    "        # The inherited PyTorch module\n",
    "        self.model = model\n",
    "        if hasattr(model, \"dropout_proba\"):\n",
    "            self.dropout_proba = model.dropout_proba\n",
    "\n",
    "        # Save settings and hyperparameters to the log directory\n",
    "        # but skip the model parameters\n",
    "        self.save_hyperparameters(ignore=[\"model\"])\n",
    "\n",
    "        # Set up attributes for computing the accuracy\n",
    "        self.train_acc = torchmetrics.Accuracy()\n",
    "        self.valid_acc = torchmetrics.Accuracy()\n",
    "        self.test_acc = torchmetrics.Accuracy()\n",
    "\n",
    "    # Defining the forward method is only necessary\n",
    "    # if you want to use a Trainer's .predict() method (optional)\n",
    "    def forward(self, x):\n",
    "        return self.model(x)\n",
    "\n",
    "    # A common forward step to compute the loss and labels\n",
    "    # this is used for training, validation, and testing below\n",
    "    def _shared_step(self, batch):\n",
    "        features, true_labels = batch\n",
    "        logits = self(features)\n",
    "        loss = torch.nn.functional.cross_entropy(logits, true_labels)\n",
    "        predicted_labels = torch.argmax(logits, dim=1)\n",
    "\n",
    "        return loss, true_labels, predicted_labels\n",
    "\n",
    "    def training_step(self, batch, batch_idx):\n",
    "        loss, true_labels, predicted_labels = self._shared_step(batch)\n",
    "        self.log(\"train_loss\", loss)\n",
    "\n",
    "        # Do another forward pass in .eval() mode to compute accuracy\n",
    "        # while accountingfor Dropout, BatchNorm etc. behavior\n",
    "        # during evaluation (inference)\n",
    "        self.model.eval()\n",
    "        with torch.no_grad():\n",
    "            _, true_labels, predicted_labels = self._shared_step(batch)\n",
    "        self.train_acc(predicted_labels, true_labels)\n",
    "        self.log(\"train_acc\", self.train_acc, on_epoch=True, on_step=False)\n",
    "        self.model.train()\n",
    "\n",
    "        return loss  # this is passed to the optimzer for training\n",
    "\n",
    "    def validation_step(self, batch, batch_idx):\n",
    "        loss, true_labels, predicted_labels = self._shared_step(batch)\n",
    "        self.log(\"valid_loss\", loss)\n",
    "        self.valid_acc(predicted_labels, true_labels)\n",
    "        self.log(\n",
    "            \"valid_acc\",\n",
    "            self.valid_acc,\n",
    "            on_epoch=True,\n",
    "            on_step=False,\n",
    "            prog_bar=True,\n",
    "        )\n",
    "\n",
    "    def test_step(self, batch, batch_idx):\n",
    "        loss, true_labels, predicted_labels = self._shared_step(batch)\n",
    "        self.test_acc(predicted_labels, true_labels)\n",
    "        self.log(\"test_acc\", self.test_acc, on_epoch=True, on_step=False)\n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        optimizer = torch.optim.Adam(self.parameters(), lr=self.learning_rate)\n",
    "        return optimizer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d00cf846",
   "metadata": {},
   "source": [
    "## Setting up the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6570816f",
   "metadata": {},
   "source": [
    "- In this section, we are going to set up our dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc3d054b",
   "metadata": {},
   "source": [
    "### Inspecting the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b366b602",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Training label distribution:\n",
      "\n",
      "Test label distribution:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[(0, 980),\n",
       " (1, 1135),\n",
       " (2, 1032),\n",
       " (3, 1010),\n",
       " (4, 982),\n",
       " (5, 892),\n",
       " (6, 958),\n",
       " (7, 1028),\n",
       " (8, 974),\n",
       " (9, 1009)]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# %load ../code_dataset/dataset_mnist_check.py\n",
    "from collections import Counter\n",
    "from torchvision import datasets\n",
    "from torchvision import transforms\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "\n",
    "train_dataset = datasets.MNIST(\n",
    "    root=\"./data\", train=True, transform=transforms.ToTensor(), download=True\n",
    ")\n",
    "\n",
    "train_loader = DataLoader(\n",
    "    dataset=train_dataset,\n",
    "    batch_size=BATCH_SIZE,\n",
    "    num_workers=NUM_WORKERS,\n",
    "    drop_last=True,\n",
    "    shuffle=True,\n",
    ")\n",
    "\n",
    "test_dataset = datasets.MNIST(\n",
    "    root=\"./data\", train=False, transform=transforms.ToTensor()\n",
    ")\n",
    "\n",
    "test_loader = DataLoader(\n",
    "    dataset=test_dataset,\n",
    "    batch_size=BATCH_SIZE,\n",
    "    num_workers=NUM_WORKERS,\n",
    "    drop_last=False,\n",
    "    shuffle=False,\n",
    ")\n",
    "\n",
    "train_counter = Counter()\n",
    "for images, labels in train_loader:\n",
    "    train_counter.update(labels.tolist())\n",
    "\n",
    "test_counter = Counter()\n",
    "for images, labels in test_loader:\n",
    "    test_counter.update(labels.tolist())\n",
    "\n",
    "print(\"\\nTraining label distribution:\")\n",
    "sorted(train_counter.items())\n",
    "\n",
    "print(\"\\nTest label distribution:\")\n",
    "sorted(test_counter.items())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "885089c6",
   "metadata": {},
   "source": [
    "### Performance baseline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43804979",
   "metadata": {},
   "source": [
    "- Especially for imbalanced datasets, it's pretty helpful to compute a performance baseline.\n",
    "- In classification contexts, a useful baseline is to compute the accuracy for a scenario where the model always predicts the majority class -- we want our model to be better than that!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "11bc7c47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Majority class: 1\n",
      "Accuracy when always predicting the majority class:\n",
      "0.11 (11.35%)\n"
     ]
    }
   ],
   "source": [
    "# %load ../code_dataset/performance_baseline.py\n",
    "majority_class = test_counter.most_common(1)[0]\n",
    "print(\"Majority class:\", majority_class[0])\n",
    "\n",
    "baseline_acc = majority_class[1] / sum(test_counter.values())\n",
    "print(\"Accuracy when always predicting the majority class:\")\n",
    "print(f\"{baseline_acc:.2f} ({baseline_acc*100:.2f}%)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "722aba24",
   "metadata": {},
   "source": [
    "## A quick visual check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d386a471",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_dataset/plot_visual-check_basic.py\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torchvision\n",
    "\n",
    "\n",
    "for images, labels in train_loader:  \n",
    "    break\n",
    "\n",
    "plt.figure(figsize=(8, 8))\n",
    "plt.axis(\"off\")\n",
    "plt.title(\"Training images\")\n",
    "plt.imshow(np.transpose(torchvision.utils.make_grid(\n",
    "    images[:64], \n",
    "    padding=2,\n",
    "    normalize=True),\n",
    "    (1, 2, 0)))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "740666d5",
   "metadata": {},
   "source": [
    "### Setting up a `DataModule`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c25de5e3",
   "metadata": {},
   "source": [
    "- There are three main ways we can prepare the dataset for Lightning. We can\n",
    "  1. make the dataset part of the model;\n",
    "  2. set up the data loaders as usual and feed them to the fit method of a Lightning Trainer -- the Trainer is introduced in the following subsection;\n",
    "  3. create a LightningDataModule.\n",
    "- Here, we will use approach 3, which is the most organized approach. The `LightningDataModule` consists of several self-explanatory methods, as we can see below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c31b543e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load ../code_lightningmodule/datamodule_mnist_basic.py\n",
    "from torch.utils.data.dataset import random_split\n",
    "\n",
    "\n",
    "class DataModule(pl.LightningDataModule):\n",
    "    def __init__(self, data_path=\"./\"):\n",
    "        super().__init__()\n",
    "        self.data_path = data_path\n",
    "\n",
    "    def prepare_data(self):\n",
    "        datasets.MNIST(root=self.data_path, download=True)\n",
    "        return\n",
    "\n",
    "    def setup(self, stage=None):\n",
    "        # Note transforms.ToTensor() scales input images\n",
    "        # to 0-1 range\n",
    "        train = datasets.MNIST(\n",
    "            root=self.data_path,\n",
    "            train=True,\n",
    "            transform=transforms.ToTensor(),\n",
    "            download=False,\n",
    "        )\n",
    "\n",
    "        self.test = datasets.MNIST(\n",
    "            root=self.data_path,\n",
    "            train=False,\n",
    "            transform=transforms.ToTensor(),\n",
    "            download=False,\n",
    "        )\n",
    "\n",
    "        self.train, self.valid = random_split(train, lengths=[55000, 5000])\n",
    "\n",
    "    def train_dataloader(self):\n",
    "        train_loader = DataLoader(\n",
    "            dataset=self.train,\n",
    "            batch_size=BATCH_SIZE,\n",
    "            drop_last=True,\n",
    "            shuffle=True,\n",
    "            num_workers=NUM_WORKERS,\n",
    "        )\n",
    "        return train_loader\n",
    "\n",
    "    def val_dataloader(self):\n",
    "        valid_loader = DataLoader(\n",
    "            dataset=self.valid,\n",
    "            batch_size=BATCH_SIZE,\n",
    "            drop_last=False,\n",
    "            shuffle=False,\n",
    "            num_workers=NUM_WORKERS,\n",
    "        )\n",
    "        return valid_loader\n",
    "\n",
    "    def test_dataloader(self):\n",
    "        test_loader = DataLoader(\n",
    "            dataset=self.test,\n",
    "            batch_size=BATCH_SIZE,\n",
    "            drop_last=False,\n",
    "            shuffle=False,\n",
    "            num_workers=NUM_WORKERS,\n",
    "        )\n",
    "        return test_loader\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f33b7f3",
   "metadata": {},
   "source": [
    "- Note that the `prepare_data` method is usually used for steps that only need to be executed once, for example, downloading the dataset; the `setup` method defines the dataset loading -- if we run our code in a distributed setting, this will be called on each node / GPU. \n",
    "- Next, let's initialize the `DataModule`; we use a random seed for reproducibility (so that the data set is shuffled the same way when we re-execute this code):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "84090b2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "\n",
    "torch.manual_seed(1) \n",
    "data_module = DataModule(data_path='./data')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "227f013d",
   "metadata": {},
   "source": [
    "## Training the model using the PyTorch Lightning Trainer class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f11c42b",
   "metadata": {},
   "source": [
    "- Next, we initialize our model.\n",
    "- Also, we define a call back to obtain the model with the best validation set performance after training.\n",
    "- PyTorch Lightning offers [many advanced logging services](https://pytorch-lightning.readthedocs.io/en/latest/extensions/logging.html) like Weights & Biases. However, here, we will keep things simple and use the `CSVLogger`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "bd1db7d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "pytorch_model = PyTorchModel(num_classes=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "672d2f61",
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load ../code_lightningmodule/logger_csv_acc_basic.py\n",
    "from pytorch_lightning.callbacks import ModelCheckpoint\n",
    "from pytorch_lightning.loggers import CSVLogger\n",
    "\n",
    "\n",
    "lightning_model = LightningModel(pytorch_model, learning_rate=LEARNING_RATE)\n",
    "\n",
    "callbacks = [\n",
    "    ModelCheckpoint(\n",
    "        save_top_k=1, mode=\"max\", monitor=\"valid_acc\"\n",
    "    )  # save top 1 model\n",
    "]\n",
    "logger = CSVLogger(save_dir=\"logs/\", name=\"my-model\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a93e646",
   "metadata": {},
   "source": [
    "- Now it's time to train our model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "60710815",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/jovyan/conda/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/callback_connector.py:90: LightningDeprecationWarning: Setting `Trainer(progress_bar_refresh_rate=50)` is deprecated in v1.5 and will be removed in v1.7. Please pass `pytorch_lightning.callbacks.progress.TQDMProgressBar` with `refresh_rate` directly to the Trainer's `callbacks` argument instead. Or, to disable the progress bar pass `enable_progress_bar = False` to the Trainer.\n",
      "  rank_zero_deprecation(\n",
      "GPU available: True, used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "\n",
      "  | Name      | Type         | Params\n",
      "-------------------------------------------\n",
      "0 | model     | PyTorchModel | 9.1 K \n",
      "1 | train_acc | Accuracy     | 0     \n",
      "2 | valid_acc | Accuracy     | 0     \n",
      "3 | test_acc  | Accuracy     | 0     \n",
      "-------------------------------------------\n",
      "9.1 K     Trainable params\n",
      "0         Non-trainable params\n",
      "9.1 K     Total params\n",
      "0.036     Total estimated model params size (MB)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation sanity check: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4470d9cfe0924ebb98e606f98502ffa9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training took 2.65 min in total.\n"
     ]
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/trainer_nb_basic.py\n",
    "import time\n",
    "\n",
    "\n",
    "trainer = pl.Trainer(\n",
    "    max_epochs=NUM_EPOCHS,\n",
    "    callbacks=callbacks,\n",
    "    progress_bar_refresh_rate=50,  # recommended for notebooks\n",
    "    accelerator=\"auto\",  # Uses GPUs or TPUs if available\n",
    "    devices=\"auto\",  # Uses all available GPUs/TPUs if applicable\n",
    "    logger=logger,\n",
    "    deterministic=False,\n",
    "    log_every_n_steps=10,\n",
    ")\n",
    "\n",
    "start_time = time.time()\n",
    "trainer.fit(model=lightning_model, datamodule=data_module)\n",
    "\n",
    "runtime = (time.time() - start_time) / 60\n",
    "print(f\"Training took {runtime:.2f} min in total.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f72da03f",
   "metadata": {},
   "source": [
    "## Evaluating the model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d2779e2",
   "metadata": {},
   "source": [
    "- After training, let's plot our training ACC and validation ACC using pandas, which, in turn, uses matplotlib for plotting (PS: you may want to check out [more advanced logger](https://pytorch-lightning.readthedocs.io/en/latest/extensions/logging.html) later on, which take care of it for us):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "1a142920",
   "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"
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/logger_csv_plot_basic.py\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "metrics = pd.read_csv(f\"{trainer.logger.log_dir}/metrics.csv\")\n",
    "\n",
    "aggreg_metrics = []\n",
    "agg_col = \"epoch\"\n",
    "for i, dfg in metrics.groupby(agg_col):\n",
    "    agg = dict(dfg.mean())\n",
    "    agg[agg_col] = i\n",
    "    aggreg_metrics.append(agg)\n",
    "\n",
    "df_metrics = pd.DataFrame(aggreg_metrics)\n",
    "df_metrics[[\"train_loss\", \"valid_loss\"]].plot(\n",
    "    grid=True, legend=True, xlabel=\"Epoch\", ylabel=\"Loss\"\n",
    ")\n",
    "df_metrics[[\"train_acc\", \"valid_acc\"]].plot(\n",
    "    grid=True, legend=True, xlabel=\"Epoch\", ylabel=\"ACC\"\n",
    ")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8f13c32",
   "metadata": {},
   "source": [
    "- The `trainer` automatically saves the model with the best validation accuracy automatically for us, we which we can load from the checkpoint via the `ckpt_path='best'` argument; below we use the `trainer` instance to evaluate the best model on the test set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "e3b3241a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Restoring states from the checkpoint path at logs/my-model/version_2/checkpoints/epoch=15-step=6863.ckpt\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "Loaded model weights from checkpoint at logs/my-model/version_2/checkpoints/epoch=15-step=6863.ckpt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "059ea2ee2d4444869afa2801e8857642",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃<span style=\"font-weight: bold\">        Test metric        </span>┃<span style=\"font-weight: bold\">       DataLoader 0        </span>┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│<span style=\"color: #008080; text-decoration-color: #008080\">         test_acc          </span>│<span style=\"color: #800080; text-decoration-color: #800080\">    0.9879000186920166     </span>│\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "</pre>\n"
      ],
      "text/plain": [
       "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃\u001b[1m \u001b[0m\u001b[1m       Test metric       \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      DataLoader 0       \u001b[0m\u001b[1m \u001b[0m┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│\u001b[36m \u001b[0m\u001b[36m        test_acc         \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.9879000186920166    \u001b[0m\u001b[35m \u001b[0m│\n",
       "└───────────────────────────┴───────────────────────────┘\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[{'test_acc': 0.9879000186920166}]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trainer.test(model=lightning_model, datamodule=data_module, ckpt_path='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "433906c5",
   "metadata": {},
   "source": [
    "## Predicting labels of new data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0087d833",
   "metadata": {},
   "source": [
    "- We can use the `trainer.predict` method either on a new `DataLoader` (`trainer.predict(dataloaders=...)`) or `DataModule` (`trainer.predict(datamodule=...)`) to apply the model to new data.\n",
    "- Alternatively, we can also manually load the best model from a checkpoint as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "6d19af28",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logs/my-model/version_2/checkpoints/epoch=15-step=6863.ckpt\n"
     ]
    }
   ],
   "source": [
    "path = trainer.checkpoint_callback.best_model_path\n",
    "print(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0fc7c925",
   "metadata": {},
   "outputs": [],
   "source": [
    "lightning_model = LightningModel.load_from_checkpoint(path, model=pytorch_model)\n",
    "lightning_model.eval();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bf6cd82",
   "metadata": {},
   "source": [
    "- For simplicity, we reused our existing `pytorch_model` above. However, we could also reinitialize the `pytorch_model`, and the `.load_from_checkpoint` method would load the corresponding model weights for us from the checkpoint file.\n",
    "- Now, below is an example applying the model manually. Here, pretend that the `test_dataloader` is a new data loader."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "63c2db97",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/datamodule_testloader.py\n",
    "test_dataloader = data_module.test_dataloader()\n",
    "acc = torchmetrics.Accuracy()\n",
    "\n",
    "for batch in test_dataloader:\n",
    "    features, true_labels = batch\n",
    "\n",
    "    with torch.no_grad():\n",
    "        logits = lightning_model(features)\n",
    "\n",
    "    predicted_labels = torch.argmax(logits, dim=1)\n",
    "    acc(predicted_labels, true_labels)\n",
    "\n",
    "predicted_labels[:5]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77491b8a",
   "metadata": {},
   "source": [
    "- As an internal check, if the model was loaded correctly, the test accuracy below should be identical to the test accuracy we saw earlier in the previous section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "d49d1cc4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy: 0.9879 (98.79%)\n"
     ]
    }
   ],
   "source": [
    "test_acc = acc.compute()\n",
    "print(f'Test accuracy: {test_acc:.4f} ({test_acc*100:.2f}%)')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80e7461b",
   "metadata": {},
   "source": [
    "## Inspecting Failure Cases"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7dd9e65a",
   "metadata": {},
   "source": [
    "- In practice, it is often informative to look at failure cases like wrong predictions for particular training instances as it can give us some insights into the model behavior and dataset.\n",
    "- Inspecting failure cases can sometimes reveal interesting patterns and even highlight dataset and labeling issues."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "11eb66f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class_dict = {0: 'airplane',\n",
    "              1: 'automobile',\n",
    "              2: 'bird',\n",
    "              3: 'cat',\n",
    "              4: 'deer',\n",
    "              5: 'dog',\n",
    "              6: 'frog',\n",
    "              7: 'horse',\n",
    "              8: 'ship',\n",
    "              9: 'truck'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "5de41c23",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 15 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/plot_failurecases_basic.py\n",
    "# Append the folder that contains the\n",
    "# helper_data.py, helper_plotting.py, and helper_evaluate.py\n",
    "# files so we can import from them\n",
    "\n",
    "import sys\n",
    "\n",
    "sys.path.append(\"../../pytorch_ipynb\")\n",
    "\n",
    "from helper_plotting import show_examples\n",
    "\n",
    "\n",
    "show_examples(\n",
    "    model=lightning_model, data_loader=test_dataloader, class_dict=class_dict\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d7b767d",
   "metadata": {},
   "source": [
    "- In addition to inspecting failure cases visually, it is also informative to look at which classes the model confuses the most via a confusion matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "cdae5045",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAATQAAAErCAYAAABQAX/RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABMoUlEQVR4nO2dd5gU1dKH32LJOYOASM5RlhwEJBiIXgkqSlBBJYgBRQwXvah4wayfqNeAgoCiKGIAyYikJUmQIEoQkCA5L0t9f5zeZVg2TOje3RnO+zzzzHSqrjndU3NS109UFYvFYokEMqW3AxaLxeIWNqBZLJaIwQY0i8USMdiAZrFYIgYb0CwWS8RgA5rFYokYMqe3A5GGZM6hki2f63avrVrKdZsAdtaOd5w9f8ETu9mzhE89xKv7a9WqlQdVtUji9TaguYxky0e26ne4bjdm+cuu2wQ4c94TsxZg+4GTntitclUuT+x6gVf3V44ssiOp9eET6i0WiyUVbECzWCwRgw1oFoslYrABzWKxRAw2oHnIwB7NiZn0KCsnD2NQz+YAfPr8nSyd8DBLJzzMpq+fZOmEhwFo3aASi8cPZcVnj7J4/FCui64Q8Pl+/PFHKleuTIUKFRg9erRr32PAPf0oXaIo9erUyNA2w83u2TNn6H7TdXRp04gOLaN5c8wo12x7dS94YdfNsg2rgCYi34tI/gCP+VhEbvXIpWSpVq44fbs0pHmf12lwx8vc2Kwa5a8uzJ1PfkqjXq/QqNcrfD3vV76Ztw6Af46c5NZHPqT+7WO599nJfDjy9oDOFxcXx8CBA/nhhx/YuHEjkyZNYuPGja58lzt79+GbGT+6YstLm+FmN2u2bHz0xXd8PXsp035aws/zZ7Nm5fKQ7Xp1L3hl182yDauApqo3qeoR33ViyHDfo0rZoixfv5PTZ2OJi7vAolXb6Nyy5iX7/KtNHT6ftRqAtVt2s/fgMQA2/vE32bJlJmuWKL/Pt3z5cipUqEC5cuXImjUrPXv25JtvvnHluzRr3oKCBQu6YstLm+FmV0TIlSs3AOdjY4mNjUVEQrbr1b3glV03yzbDBYJ4RORrEVkpIhtEpL+zbruIFBaRMiLym4j8H7AKuFpETojIyyKySkTmiMhlk+5E5BkRWSEi60XkPXHuHhGZLyIvichyEdkiIs2d9VEiMsY55lcRGeCv/xu2/U2zuuUomC8nObJl4YamVSlVLH/C9qZ1y7Hv0HG27Tp42bFdW9di7ebdnIuN87u8du/ezdVXX52wXKpUKXbv3u338Zb0IS4ujq5tGtOsVlmatGhN7Wvrh2zTq3shHO6xDBvQgH6qWg+IBoaISKFE2ysDn6hqXVXdAeQCVqnqtcAC4N9J2HxLVeurag0gB9DBZ1tmVW0ADPU59m7gqKrWB+oD94pI2cRGRaS/iMSISIyePwXA5u37efmTucx4cwDT37iXX7fu4XzcxQDVvV1dvpi5+jIHq5YrxqhBNzPoxamplc8lJJWo041/e4u3REVFMW32Euat3My6NTFs2bQhZJte3QvhcI9l5IA2RETWAkuBq4GKibbvUNWlPssXgCnO5wlAsyRsthKRZSKyDmgNVPfZ9pXzvhIo43xuB9wlImuAZUChJPxAVd9T1WhVjZbMORPWj5++nCZ3vUrbAf/H4aOn+H2nqY1FRWWic8uaTJ295hI7JYvmY8p/+3LPyEn8ufufJNxPnlKlSrFr166E5b/++osSJUoEZMOSfuTNl58GjZvz87zZIdvy6l4Ih3ssQwY0EWkJtAEaq2ptYDWQPdFuqT1XcsnfiYhkB/4PuFVVawLvJ7J51nmP4+IjYQIMVtU6zqusqs7y93sUKWD6R64ulp/OrWol9Je1rl+RLTv2s3v/0YR98+XOzlev3sMzb3/Hkl+3+3uKBOrXr8/WrVv5888/OXfuHJMnT6ZTp04B27GkHYf+OcCxo0cAOHP6NEsWzaNshUoh2/XqXgiHeyxDBjQgH3BYVU+JSBWgkR/HZALiRzNvB35OtD0+eB0Ukdw++6bETOB+EckCICKVRMTvB+kmvdSbVZOHMfWVuxk65iuOHD8NQLd2dROCWzz3dW9G+VKFGH5324RpHfEB0R8yZ87MW2+9Rfv27alatSrdu3enevXqqR/oB3f1uo2WzRuzZfNmypcpxccffpAhbYab3QP79tHn1pvofH1Dut3UgsYtWtOq7Y0h2/XqXvDKrptlKxlRJEVEsgFfAyWBzUARYCTwMaZPLTcww+kLiz/mBPAqcBNwFOihqgdE5GNn36kiMgroCWwHdmGarSNFZD7wqKrGiEhhIEZVyzijp6OAjpja2gGgi6perFolIlOu4urFw+mn7cPpYYd9ON3Th9NXqmp04vUZMqAFg4icUFX/qzQeYQOaJR4b0NI+oGXUJqfFYrEETMQEtIxQO7NYLOlLxAQ0i8VisQHNYrFEDDagWSyWiMFqCrjMtVVLeZL/P0fdQa7bBFj9/Uuu2yxTxJtRuOwe3a1ejcTl9shhL/zdvOe4+0aB2qXzeGI3OWwNzWKxRAw2oFkslojBBjSLxRIx2IBmsVgiBhvQLBZLxGADmsViiRhsQEsnAlXP2THnRWK+GJGwfEubuqyc+iQnV77BtdVKJ6xv3bAKiyc+xorPR7B44mNcV/9ifq1v3nqAZVOGs3Lqk7zxZE8yZUo926hXykReqTNBxlcmimfPX7vo3qkdrRrW5vrGdflg3Fuu2PWybOPi4uhxYzMG9+3mmk03r1eGCWgi0kVEqnl8jjIisj6Zbf+LP3+8doFXfgSjntN54NuXLG/Ytoeej7zPz6u2XbL+nyMnuHXou9Tv/gL3PvMpH466K2Fbr8c/pGGP0dS79XmKFMjNv9pem6qvXikTeaXOFA7KRPFEZc7M0/95iXnL1vLNrIWM/2AcWzb9FrJdr8oW4LMP33ElCWU8bl+vDBPQgC6ApwEtJVT1HlV1R/ctFYJRzzl09NQly5v/3MfWHfsv22/t5r/Ye8Cka9u4bS/ZsmYhaxYzwfP4yTMAZM6ciSyZo5LMEZ8Yr5SJvFJnCgdloniKFb+KmrXrApA7Tx4qVKrC33tDFx3xqmz37d3NorkzuaVnb9dsun29PA1oySg3nfDZfqujm9kE6ASMEZE1IlJeROqIyFJHbWmaiBRwjpkvIq+KyEJH+am+iHwlIludBI7xth921J3Wi8hQH7cyi8h4x+5UEcnpY/fyhHEivRw1qDUi8q6I+K8tlwxppZ7TtU0d1m7exbnYi1PLp789kJ1zRnPi1Fm+mn25SEtSeKFM5BXhoEyUFLt2bmfDr2uoW69BeruSLGOeHc7QEc8hmdwLG25fL69raKkpNwGgqr8A04FhTu7+bcAnwOOqWgtYx6UqTudUtQUwDvgGGAjUAPqISCERqQf0BRpi0nffKyJ1nWMrA+85do8BDyTnvIhUBXoATVW1DkZv4LLsjb6qTwcOHEi1UNJCPadqueKMGtKZQaMmX7K+08C3Kdt2BNmyZqZl/cp+2fJCmcgrwkGZKDEnT5xgQO/bGPnCWPLkzZve7iTJwjk/UKBQYarVrJv6zgHg9vXyOqClptyUJCKSD8ivqgucVeOBFj67THfe1wEbVHWvqp4F/nDO0wyYpqonVfUERtGpuXPMLlVd7HxOTh0qnuuBesAKR/npeqBc4p18VZ+KFLlMDvQyvFbPKVk0P1Ne6c89T3/Kn39drvt59tx5ZixYR8dEwsep4aYykVeEgzKRL7GxsfTv3ZMut/bkxo5d0tudZFkTs4wFs3/gxqY1GD64Lyt+WciIB+8J2a7b18uzgJaCcpNvSE6s5OQv8QpNF3w+xy9nxuT/T47EfwkpdSQJMN5H9amyqo4M1NnEeKmeky93Dr568z6eeXM6S9b+kbA+V46sFC9s/v2jojJxQ9NqbN6+L1V7XikTeUU4KBPFo6oMGzKAipWq0H/gg+ntTooMeXwks5Zt4ofF6xn95kfUb9KCF17/X8h23b5eXtbQklNu2iciVR0Bkq4++x8H8gA4IiSH4xXMgTsx4sH+shDoIiI5HZWmrsAiZ1tpEWnsfL6Ny9WhfJkD3CoiRQFEpKCIXBOAH0kSjHrO/PGPUOmaYvz+43/o3aUxnVrV4vcf/0PDWmX46o37mP72QADu69mC8lcXYfi9N7B08nCWTh5OkQK5yZUjG1NfG8DyKU+wfMoTHDh8gvenpvTVDV4pE3mlzhQOykTxrFj2C19O+YzFi+bTvkUD2rdowNyfQh+d9KpsvcDt6+WZSEoKyk2FgZcwqkvrgdyq2kdEmmK0Ms9iJObyYPrIcmKakn1V9XAihaaWzucOzjl9tz0M9HPc+Z+qviYiZYDvMQGvCbAVuNMJur7HbgeiVfWgiPQAnsAE/1hgYCKB40uIjo7WmJiYEEouaWz6oPBLH3Tw+NnUdwqCwnmyuW4z3NIHiUS46lNGwQY0G9DisQEt7QNaRpqHZrFYLCFhA5rFYokYbECzWCwRgw1oFoslYrABzWKxRAxW9cllzsUpfx12f3Tr9Gp3UsskJkf0UNdtno55zXWbXuLV6KkXo5EA2w+cdN1m5RJpq87kFbaGZrFYIgYb0CwWS8RgA5rFYokYbECzWCwRgw1oFoslYrABzWKxRAw2oKUDXqn9BKOes2PWf4iZ8njCcoG8OZnx9v2s++pJZrx9P/nz5ACgdcNKLP70EVZMfozFnz7CddEXc3XOfHcQa78cwdKJw1g6cZin/qaXXa989UKhKdyUuiJS9SktSE71yVfxKZXj+4hIyNHHC7WfYNVzOg9+95LlR/tcz/zlW6h5y/PMX76FR/u0AeCfIye59aH3qd/zv9w7ciIfPndpJvK+T31KozvG0OiOMZ76mx52vfIVvFFoCielrkhWfUo3klN8ckMQJSm8UPsJVj3n0LFL1aQ6XFeTCTNWADBhxoqENN1rN+9m78FjAGzc9rejJhV88XilzuSFXa98BW8UmsJJqSusVJ8yKJepPvkqPonICRF5TkSWAY1FpK+IbBGRBUBTt51xS+3HLfWcogXz8Pc/JnD9/c8xihTIfdk+Xa+vzdrNf3EuNi5h3bv/vo2lE4cx/O52aepvWtgNRyWpcFHqCjfVp4xIaqpPuYD1qtoQ2AY8iwlkbUlGN9RX9enQwdRVn+JxU+0nrdSOqpYrzqjBHRn0wucJ6/o+9Sn1e/6XNve+QdO6l2nIJIlX/nphNxyVpMJFqSvcVJ8yIqmpPsUBXzqfGwLzVfWAqp4DpiRl0Ff1qWDh1FWfwH21H7fUc/YfOk7xQia4Fi+UlwOHE2RUKVk0H1PG9OOef0/kz93/JKzf4wgbnzh1lik/rkpTf9PCbrgpSfmS0ZW6wkb1KQOTmurTGVWNS2F76A54oPbjlnrOdwvW06uDaZ706lCfGQvWAY6a1Gv9eebtGSxZ+2fC/lFRmSiUz6TczhyViZuapzq24qq/aWE3nJSkILyUusJJ9SmjEojq0zKgpSNenAXo5oYDXqj9BKueM/+jB6l0TVF+/24kvTs3ZOz42bRuWJl1Xz1J64aVGfvxHADu69GM8lcXZvjd7ROmZxQpkJtsWTIz/a37WD7pMZZ9Now9+4966m962PXKV/BGoSmclLrCRvUpI5Kc6pOzLl7x6YSq5vY5pi9G9WkvsAaIUtVkFUtq1a2n38/9xXXfSxXwJhWNTR/kHV6Jr3iRPijchG2SE0m5ovKhqep2ku7Yb+mzzyXDeqr6EfCRp45ZLBZXuBKbnBaLJUKxAc1isUQMNqBZLJaIwQY0i8USMVxRgwJpQdYo8WxE0gu8GJHMUf9h120CnF7xiid2vRC1Ae9Gpqtc5f6IpFdl4JVQTHLYGprFYokYbECzWCwRgw1oFoslYrABzWKxRAw2oFkslojBBjSLxRIx2ICWToSTkEegdsc93YMdM58lZvJFwZQCeXMy460BrPvyCWa8NSBBfAWMjsH6r0awdupw2jSqnLB+5rgHWDt1OEsnPsLSiY945m9qeCVqAxnnmvmDV+XgqviKqtpXKi/Mw+tN/Nm3Xr16mhrnz5/XcuXK6bZt2/Ts2bNaq1Yt3bBhQ6rHpbXNYO1ef++b2uiOsbr+9z2aPfohzR79kL48fo4+9ea3mj36IX3qzW917MdzNHv0Q1qn22hdu3m35m38qFbu9B/dtuuA5mzwsGaPfkgXxGzVJne+nGDDK393HTqT4itm45/6/bwluuvQGf1txwEtW76CzvlldarHeeFrepVBsOVwOlZTff00d4H+smylVqte3a/9T8eqAjGaxO/P1tD8oyUm3ZArhJOQRzB2F6/+IwnxlRqJxFdqJKz/4qfVnIuNY8eeQ2zbdZD61Uunqb+p4YWojVe+emnXq3JwU3zlig5oInKXI5ayVkQ+FZGOIrJMRFaLyGwRKebkULsPeEhE1ohI81DPG05CHu6KrxwH4O9/jieIr5Qsko+/9h25eL79RylRJF/C8rvP3MbSiY8w/O62aepvcrglagMZ/5qlhJvl4CZX7KNPIlIdeBJoqqoHRaQgJt12I1VVEbkHeExVHxGRccAJVR3rxrk1jIQ8vLJ70VhS5zTvfZ+eyJ4DR8mdMxuTXurjlzkv/XVT1AbC95q5XQ5uciXX0FoDU1X1IICqHgJKATNFZB0wDPArF7Cv6tOBA6mrPoWTkIe74it5ACheKE+C+Mru/UcpVSx/wn4li+Zj70GTxvsS8ZWZ6Su+4raoDWT8a5YUXpSDm1zJAU24XADlTeAtVa0JDACy+2NIfVSfihRJXfUpnIQ8XBNfWbghkfjKemf9erq1rUvWLFFcU6IgFUoXYcWGnZeLrzRLP/EV9UDUBjL+NUuMV+XgJldskxOYA0wTkVdV9R+nyZkPiO9s6O2z73HAtbq1rzBEXFwc/fr1c1XIwy2bwdodP6oXzetVoHD+XPw+4xn+895Mxo6fw4QX76J3p4bs2neYO4Z/AsBvf+zjy9lrWP3545yPu8DQ/37JhQtKzuxZmP5mf7JkjiIqKhPzlm9Jt3KIF7WpUq0G7VuYPqPHn36O1m1vCMluRrpm/uBVOdzV6zYWLZjPwYMHKV+mFE8/8yx9+t0dlK0rSiQlMSLSG9O0jANWA9OAVzFBbSlQX1VbikglYCpwARisqouSsxkdHa0xMTGe+56RsemDDOGURirc0gflyGJFUi5DVccD4xOtvmx8W1W3ALXSxCmLxRI0V3IfmsViiTBsQLNYLBGDDWgWiyVisAHNYrFEDDagWSyWiOGKHuUMJ86cT28P/Mer6RU5GvifQigQTi9/2RO7a3ce98Ru7dJ5PLHrBUt+/ydNz5dsQBOR41ycSR//IJg6n1VVM9ZDXBaL5Yon2YCmquHzN2CxWCz42YcmIs1EpK/zubCIlPXWLYvFYgmcVAOaiPwbeBx4wlmVFZjgpVMWi8USDP7U0LoCnYCTAKq6B7DNUYvFkuHwJ6CdU/MEuwKISC5vXbJYLJbg8CegfS4i7wL5ReReYDbwvrduRT5eqPK4qp6TBnZDKYOBPZoTM+lRVk4exqCeF7Oi39+9GWu/eJyVk4fx/OAOAPRsfy1LJzyc8Dq5dAy1KgaW8NArdSaAuLg4etzYjMF9u7lmM5xUn3b+uZV7u7ZMeHWILsPU8eOCsuVX+iARaQu0cxZnqepPQZ0tnRGRkbiYSjsp/EkfFBcXR6VKlfjpp58oVaoU9evXZ9KkSVSrlnwSQ3/mof28aCG5cuXmnn53sXLN+kBdd81udj9mNwZTBvHz0KqVK84nz/eieZ/XOXc+jumv38uQl76kZNF8PN63DV0f+h/nYuMoUiB3QmbceKqXL84XY/tRresLCetSm4cWjK/g/zy0T99/iw2/ruLkieO8+dEXqe6f2jy0YPz1J33Qvr/3sn/f39SsXZcTx49zU+vG/O/TL6hUpWqyx2zddyLZbcn53r1lTd6ePJPiJa9Odr/WVQsnmT7I3ycF1gGLgIXO5ysWEQl5MrJXqjxuqud4bTeUMqhStijL1+/k9NlY4uIusGjVNjq3rEn/fzVh7Pi5nIuNA7gsmAF0b1eXz2etTjNfU2Pf3t0smjuTW3r2Tn1nPwk31SdfVi1dSImry6QYzFLCn1HOe4DlwC3ArcBSEekX1NnSARF5UkQ2i8hsoLKzrryI/CgiK0VkkYhUcdYXEZEvRWSF82rqrB8pIu+JyCzgk1B9SgtVnoxOKGWwYdvfNKtbjoL5cpIjWxZuaFqVUsXyU6F0EZrWKcfCD4cwa9wD1Kt6+Y/i1rZ1+HxmYAHNy+s15tnhDB3xHJLJvacQw1n1ad7302h98y1BH+9PbWMYUFdV/wEQkULAL8CHQZ81jRCRekBPoC7mu64CVgLvAfep6lYRaQj8H0Y05XXgVVX9WURKAzOB+Pp0PaCZqp5O4jz9gf4ApUunrinpuZJSGBBKGWzevp+XP5nLjDcHcPL0WX7duofzcXFkjspEgbw5aNHvDaKrXc2EF++kapeLTcv61Utz6kwsG//4O818TYmFc36gQKHCVKtZlxVLkk2CHDDhqvoUe+4cv8z9kXseeipoG/4EtL8wOfXjOQ7sSmbfjEZzYJqqngIQkekY4ZMmwBc+Fzk+T3AboJrP+rwiEt9hMT2pYAZGJAUTJImOjk61U9JLVZ5wIdQyGD99OeOnLwfg2ftvZPf+o1QuU4yv55kekZiNu7hwQSmcPxcHj5wEoFu7OgE3N93wNTnWxCxjwewf+Hn+T5w7e4aTx48z4sF7eOH1/4VkN1xVn5Yvmk3FarUoWLho0DaSreeKyMMi8jAmv/4yp9n1b0yu/d+DPmPakzjAZAKOqGodn1dVn22NfdaXVNX4YH7SLYe8UuUJJ0Itg3ih4quL5adzq1p8Pms13y5YT8voCgBUKF2YrFkyJwQzEeGW1rX5IoiA5tX1GvL4SGYt28QPi9cz+s2PqN+kRcjBzEt/vVZ9mvvdVyE1NyHlPrQ8zmsb8DUXA8M3wN6Qzpp2LAS6ikgOp6bVETgF/Cki3QDEUNvZfxYwKP5gEanjhVO+qjxVq1ale/furqjy3NXrNlo2b8yWzZspX6YUH3/4gQveemM31DKY9FJvVk0extRX7mbomK84cvw046cvp2zJQsRMepRPRt3JPc9OSti/Wd1y7N5/lO17DqW5r2mNV/7Gqz4tXjSf9i0a0L5FA+b+9GPoDgNnTp9i5S8LaN62Q0h2Il71SUSeBO4CdmCazxuBL4F3gKuALMBkVX1ORAoDb2P6zTIDC1X1vkCme3il+hRO6YP8mbYRDDZ9kMGL9EFeqT4FOm3DX5KbtpHqrSciRYDHMCriCcK7qtraVQ89QlWfB55PYtNlYoKOinqPJNaPdN8zi8XiNv6MFU8ENgFlgWeB7cAKD32yWCyWoPAnoBVS1Q+AWFVdoKr9gEYe+2WxWCwB409vR6zzvldEbgb2AKW8c8lisViCw5+ANkpE8gGPAG8CeYGHPPXKYrFYgiDVgKaqM5yPR4FW3rpjsVgswZOSSMqbXD4pNQFVHeKJR5Yk8WoqhBcs3nrYE7teTa/I0Xi4J3ZXf/W0J3bDiVZVCqXp+VL6mbg/mcpisVg8JCXVp/Fp6YjFYrGEilVOt1gsEYMNaBaLJWKwAc1isUQM/mSsrSQic0RkvbNcS0SCz8BmsVgsHuFPDe19jMhwLICq/orJAmsJAS9UebxSJvLK7vFjR3lqcG9ub9+QO25oyPrVy12xG4q/g3s2Y+XEh4iZMJTxz/YkW9bM1Kp4FQvef4Cl44fw84eDiK5mHpQpmDcnP751LwfmPMurjwSeb+zsmTN0v+k6urRpRIeW0bw5ZlTANpIjnFSf3PTVn9lNOVV1eaIUvmGUzCZ50kIFKini4uIYOHDgJao8nTp1SlVFKK1temkX4PVRT9Cw+fWMenM8sefOceZMkgmB08zfEkXy8kC3JtS9/RXOnD3PhFG3061NbXq0q83zH8xm1tIttG9cmecH3kT7ge9x5lwsz703i2rli1O9XLGAfc2aLRsfffEduXLlJjY2ll5d2tK8dTvqhJin36trFpU5M0//56VLVJ+at7w+RdWntPbVnxraQREpz0Wh4VsJnwSPGRIvVHm8Uvrxyu7JE8dYG/MLHbrdCUCWrFnJkzdfyHZD9TdzVCZyZMtCVFQmcmTPwt6Dx1CFvLlM5qx8ubOz9+AxAE6dieWXX3dw5mxw/+8iQq5cJvPu+dhYYmNjXcn9H06qT2776k8NbSAmX34VEdkN/An0CvqM6YxPwsddwAFgpZOZdhyQE5Oht5+qHhaR+sAHmPTbPwM3qmrIartJqfIsW7Ysw9n00u6enTvIX6AwLwwfxO+b1lO5em0efOpFcuTMFZLdUPzdc+AYr322iC3ThnP6bCxzlm9lzvKt/LXvCN++djcvDr6JTJmEVv3fCclHX+Li4ri1fTN2bv+D2/r0p/a19UO26dU188Ut1Se3fU21hqaqf6hqG6AIUEVVm6nq9qDPmI4kUoG6BYi/ez4BHlfVWhjd0X876z/CqEM1BuJSsNtfRGJEJObAgQOp+uGFKo9XSj9e2Y2LO8+WjWvpcntfPvpmAdlz5mTCe6+FbDcUf/PnyUGH5tWo+q//Uq7jC+TKnpWe7evQ/5ZGPPb6DCp2Gc1jr8/gnRH/CtnPeKKiopg2ewnzVm5m3ZoYtmzaELLNcFJ9cttXf0Y5nxGRZzDZNh7yWQ5HElSgVPUYMB3IBeRX1QXOPuOBFiKSH8ijqr846z9Lzqiqvqeq0aoaXaRIkVSd8EKVxyulH6/sFilegiLFS1C9tsmi3Kp9Z7Zs+DVku6H427p+BbbvPcTBIyc5H3eBrxdsoFHNa7jjpnp8Pd8oxn85Zx3R1YITwU2JvPny06Bxc36eNztkW+Gk+uS2r/70oZ30ecUBNwJlgj5j+uOviIJnQpleqPJ4pfTjld1CRYpRtHhJdv6xFYCYJQsoU6FyyHZD8XfX30doUL00ObJlAaBVdHk2bz/A3oPHaF63HAAto8vz+66DIfsJcOifAxw7egSAM6dPs2TRPMpWqBSy3XBSfXLbV3/SB12S4kBExmJqNuHIQuBjERmN+e4dgXeBwyLSXFUXAXcCC5w+tOMi0khVl+LiVBVfVZ64uDj69esXsiqPFza9tAvw0NMv8eyjAzgfe44SpcrwxOjQpwGE4u+KjbuYNm8dS8YP5vz5C6zdsocPvlnG2i27GfNQRzJHRXH2XCyDRk9LOGbTV4+TJ1c2smaOomOL6nR48AM2bd/v1/kO7NvHEw/2J+5CHBcuXOCGjrfQqu2NQX1vX7y6ZvGqT1Wq1aB9C9N39vjTz9G67WXyHOnma8CqTyJSAFiuqhWDPms6kowK1GwuDgr8AfR1AlpDzDy8k8B8oIWqNk3JvleqT+GEV+mDmlYs4IndcEsfVOWq0AZOksIr1adSBbKlvlMQiEjQqk/ruNhMi8IMDjznrntpRwoqUEnpJGxwBgoQkeHYlEoWS4bGn2kbvsqf54F9qhoRE2v94GYReQJTTjuAPunrjsViSYkUA5qIZAK+c2PuVTiiqlOAKenth8Vi8Y8URzlV9QKwVkRKp5E/FovFEjT+NDmvAjaIyHJM5zgAqhr6OLDFYrG4iD8B7VnPvbBYLBYX8Ceg3aSqj/uuEJGXgAXJ7H9Fcy5OPRkCP3HGm3EYL6YA1CvrzfSKTXtPpr5TECyd8qQndut2GemJ3dPLxrhu85/j51y3Cd5N20gOf54UaJvEutBn/1ksFovLpKTLeT/wAFBORHwfsssDLPbaMYvFYgmUlJqcnwE/AC8CvlOpj6vqIU+9slgsliBISZfzKHAUuC3t3LFYLJbgsapPFoslYrABzWKxRAw2oKUDXqjnhJuC0IB7+lG6RFHq1XH3qTovyyEuLo4eNzZjcN9uAR87sEczYj57hJWTHmFQz2aXbBt6x3WcXjaGQvlyAo6a1P8N4MC8Ubz6aJegfPVKqSuUMkgON329ogKaiAwRkd9EZGJ6+hGvnjNv2Vq+mbWQ8R+MY8um30KyGa8g9PXspUz7aQk/z5/NmpWhy8LFq/L88MMPbNy4kUmTJrFx48aQ7d7Zuw/fzPgxZDuJ8aocAD778J2gEjBWK1eMvp0b0rzvGzTo9So3Nq1G+asLA1CqaD5aN6jIzr0XUy6dORfLc+/O5Ik3ZgTlp1fXDIIvg+Rw29crKqBhpqHcpKp3xK8QEX8mF7uKF+o54aYg1Kx5CwoWLBiyncR4VQ779u5m0dyZ3NKzd8DHVilTjOXrd3D6bCxxcRdYtPoPOl9naqb/fagTT7713SW59U+dieWXtds5cy64ydReXbNQyiA53Pb1igloIjIOKAdMF5GjIvKeiMwCPhGRaxx1+F+d99LOMeVFZKmIrBCR50TkhNt+uaWeA+bfrmubxjSrVZYmLVp7piC0e3dowddrvCiHMc8OZ+iI55BMgf9kNvzxN83qlqNg3pzkyJaFG5pUoVSxfNzcvBp7Dhxl3VZ3VSG9umahlEFyuO3rFRPQVPU+YA/QCngVqAd0VtXbgbeAT5xkjhOBN5zDXgdeV9X6zrFJ4qv6dOhg6qpP8bipngPhqSDkBW6Xw8I5P1CgUGGq1awb1PGbt+/n5U/mMePNe5n++j38unUP5+Mu8Hif63nu3Vkh+ZYUXlyzUMsgOdJc9SmCma6q8VLdjbmo6vQp0Mxn/RfOZ79UnwoWTl31CdxXz/ElXBSEvMatclgTs4wFs3/gxqY1GD64Lyt+WciIB+8JyMb4b1fQpPfrtL3vHQ4fO8WOvYe5pkRBlk94iE3TnqBk0Xws+WQoxQrmCclX8OaauVEGSZEeqk+RSkpPOgcmtBAgXqjnhJuCkFd4UQ5DHh/JrGWb+GHxeka/+RH1m7Tghdf/F5CNIgVMEoCri+Wnc8uaTPx+Jdfc+CxVur5Ila4vsnv/URrf9Rr7Dh0PyVfw5pq5UQZp4Wuad4hnUH7BqDp9CtyBUUkHWAr8C5O11jXVJy/Uc8JNQeiuXrexaMF8Dh48SPkypXj6mWfp0+/ukO16VQ6hMmn0XRTMl4vY83EMHTONI8dPp7j/pmlPkCdXdrJmiaLjddXpMOR9Nv3pn5qUl0pdbpPuqk/hjIhsB6KBQcAJVR3rrC8DfAgUBg5gVJ92ikhFYAJGo/M7oL+qlkzpHLXq1tPv5/6S0i5BEU7pgzxyle0HvEkfdDb2gid2G3XzRkvIi/RBa3eGXjNMitqlQ29CJ0XQqk+RhKqWcT6OTLR+O9A6iUN2A41UVUWkJ1b1yWLJ0FxRAS0I6gFviRl2OQL0S193LBZLStiAlgKOknrt9PbDYrH4x5U8ymmxWCIMG9AsFkvEYAOaxWKJGGwfmstkjRJPlG7OnPdGPWfFH0ddt1mzdD7XbQKUKeL+FBMv8WJ6BUCO6KGu2zy89DXXbQJMX/e3J3aTw9bQLBZLxGADmsViiRhsQLNYLBGDDWgWiyVisAHNYrFEDDagpRPhJDzSuUVNbruxCXd0aMZdnVu6YtMrX8PNbjD3wY5Z/yFmyuMJywXy5mTG2/ez7qsnmfH2/eTPkyNh26N92rB+2pOs/XIEbRpVSVh/a9u6LJ/0GCunPM7zQzr6dV6vyuDbCe8zuGtLBnW9jumfvheSrYgJaCJSRkTWp7cf/hBuwiMA70z8lokzfuaTb+a7Ys8rX8PJbrD3QefB716y/Gif65m/fAs1b3me+cu38GifNgBUKVuMbu3qcm330XQaPI7Xh99KpkxCwXw5eeHBTtx0/9vU6/ESRQvmIZMfSWK9KIMdWzcx68uJjP3se17/Yg4rFs5mz44/grYXMQEtFNJaKCXchEe8wCtfw8lusPfBoWOnLlnucF1NJsxYAcCEGSvo2LJmwvovZq3mXGwcO/YcYtuug9Svfg1lSxZi6479HDxi0jHNXb7Fr4DmRRn89edWKtWqR7YcOYnKnJka0Y1YOueHoO1FWkCLEpH3RWSDiMwSkRwiUscROvlVRKaJSAEAEZkvIi+IyALgQRHpJiLrRWStiCx09okSkTGOSMqvIjLADSfDTnhEhMF9unJXp+uYNunj9PYmYnDrPihaMA9//3MMgL//OUaRAkb1qmTRfPy176I83u79RyhRNB/bdh2kcplilL6qIFFRmejUsibppRJRukJlNq5ayrEjhzh7+hQrF83l4L5k5TtSJdKeFKgI3Kaq94rI55hss48Bg1V1gYg8B/wbGOrsn19VrwMQkXVAe1XdLSL5ne13A0dVtb6IZAMWi8gsVf0zFCfDTXjkf5/PpEixqzh08ACDenfhmvIVubZB0/R2K+xJj/tAVTly/DRDRn/BhBd7c+GCsvTXkG7nkLi6XCVu6TuQf/fvQfacuShTuRqZoqKCthdpNbQ/VXWN83klUB4TtBY468YDLXz2n+LzeTHwsYjcC8SXaDvgLhFZAywDCmGC5iX4qj4dOJC66lO4CY8UKXYVAAULF6Fluw5sXLsqnT2KDNy6D/YfOk7xQkY1rHihvBw4bNQWd+8/SqliBRL2K1k0P3sPmJrc94s20KLPq7Ts9xpbduz3VkQjFdrecjuvfv4TL378NXny5qdE6XJB24q0gHbW53MckD+V/RNyOjsyd08BVwNrRKQQJvX2YFWt47zKquplumO+qk9FiqSu+hROwiOnT53k5InjCZ+XLZpH+UpV09mryMCt++C7Bevp1cFoj/bqUJ8ZC9aZ9QvX061dXbJmieKaEgWpcHVhVmzYAZDQLM2fJwf9b21GnDdZyP3iyD8HATiw9y+WzPmeFjd1CdpWpAW0xBwFDotIc2f5TmBBUjuKSHlVXaaqzwAHMYFtJnC/iGRx9qkkIiE/Ie0rDFG1alW6d+/umvBIy+aN2bJ5M+XLlOLjDz8I2eahgwe4t8cN3H5zU/rccj1NW7Wj8XVtMqSv4WY32Ptg/kcPUumaovz+3Uh6d27I2PGzad2wMuu+epLWDSsz9uM5APz2x998OXsNq794gulv3sfQ/37JhQumLjb20VtY9flw5n7wIC+Pn+1XDc2rsn3p4bsZ2KUFowb3ZsCIF8mdN3/QtiJGJMUROpmhqjWc5UeB3MDXwDggJ/AHRgDlsIjMBx5V1Rhn/68wzUkB5mD62QQYBXR0Ph8AuqhqsikqoqOjNSbGfekBr4RH1u0Mn2wb4UZ2j3qowynbxqzfvMm20bnWVZEtkuIIndTwWR7rs7lREvu3TLR8S1JmgRHOy2KxZHAivclpsViuIGxAs1gsEYMNaBaLJWKwAc1isUQMNqBZLJaIIWJGOTMKZ2IvsGnvydR3DJAqV3kjEOLFFAuvpit4hVdTYryyezrmNddt5mjwiOs2AVZ/85wndpPD1tAsFkvEYAOaxWKJGGxAs1gsEYMNaBaLJWKwAc1isUQMNqBZLJaIwQa0dODsmTN0v+k6urRpRIeW0bw5ZpQrdr1QkoKMpXiUXnavBDWpeAb2aE7MpEdZOXkYg3o2T1h/f/dmrP3icVZOHsbzgzsAUPqqAhxaOJqlEx5m6YSHeWP4vwI6l9u/hSs2oInIdhEpnMT6TiIy3MtzZ82WjY+++I6vZy9l2k9L+Hn+bNasXB6STa+UpCBjKR6ll90rQU0KoFq54vTt0pDmfV6nwR0vc2OzapS/ujAt6pWnQ4vq1L99LPV6juG1CfMTjvlj90Ea9XqFRr1eYcjoLwPy1e3fwhUb0JJDVaerqnvVhSQQEXLlMhlDz8fGEhsbG3Iuea+UpCBjKR6ll90rQU0KoErZoixfv5PTZ2OJi7vAolXb6NyyJv3/1YSx4+dyLjYOICHNd6i4/Vu4IgKaiOQSke8cRaf1ItLD2TRYRFaJyDoRqeLs20dE3nI+fywi40RkkYhsEZEObvkUFxdH1zaNaVarLE1atKb2tfVDshduSlJe+Rtu5eAFoZTBhm1/06xuOQrmy0mObFm4oWlVShXLT4XSRWhapxwLPxzCrHEPUK/qRftlShRkyacPM2vcAzStUzZgf938LVwRAQ24AdijqrWdjLbxdfyDqnot8A7waDLHlgGuA24GxolI9sQ7+IqkHHbyo6dGVFQU02YvYd7KzaxbE8OWTRsC/EqXEm5KUl75G27l4AWhlMHm7ft5+ZO5zHhzANPfuJdft+7hfFwcmaMyUSBvDlr0e4MRb3zLhBfvBODvg8eo1GkUje98hcdfm87H/+lFnlzZAvLXzd/ClRLQ1gFtROQlEWnuk0L7K+d9JSZwJcXnqnpBVbdiUnhXSbyDr0hKgUKXdculSN58+WnQuDk/z5sd0HGJCTclKa/8Dbdy8IJQy2D89OU0uetV2g74Pw4fPcXvOw+ye/9Rvp5nxFdiNu7iwgWlcP5cnIuN49BRI3y8etNf/PHXQSqWTl0oKCnc+C1cEQFNVbcA9TCB7UURecbZFK8SFUfyD+on/rsLWYTh0D8HOHb0CABnTp9myaJ5lK1QKSSb4aQkBd75G27l4AWhlkG8ItTVxfLTuVUtPp+1mm8XrKdldAUAKpQuTNYsmTl45CSF8+cikyO7XqZEQSpcXYQ/d//j97nc/i2EWV6E4BCREsAhVZ0gIieAPgEc3k1ExgNlgXLA5lD9ObBvH0882J+4C3FcuHCBGzreQqu2N4Zk01dBKC4ujn79+rmiJAVG7WfRgvkcPHiQ8mVK8fQzz9Kn390Z0l+v7HpRBl7ZDbUMJr3Um4J5cxIbd4GhY77iyPHTjJ++nHef7kHMpEc5FxvHPc9OAqBZ3XI8PeAGzsddIC7uAoNHT+XwsdN+n8vt30LEqD6lhIi0B8YAF4BY4H5gKhCtqgdFJBoYq6otRaSPs36QiHwMHAaigWLAw6o6I6Vz1ah9rU79cZHr38Gr9EFepLix6YO8xYvyDbf0QVVL5I5s1aeUUNWZGI1NX8r4bI8BWjqfPwY+9tlvsao+5KmDFovFFa6IPjSLxXJlcEXU0IJFVfuktw8Wi8V/bA3NYrFEDDagWSyWiMEGNIvFEjHYPjSXyZ4lkydTLMJtaoEXLN562BO71xTO6YndUgUCewTIX7woh60zX3DdJkDFdk94Yjc5bA3NYrFEDDagWSyWiMEGNIvFEjHYgGaxWCIGG9AsFkvEYAOaxWKJGGxASyesMpF3qk/Hjx3lqcG9ub19Q+64oSHrV4cmQLPnr11079SOVg1rc33junww7i2XPA2fMoDQy2Fgz+bETB7GyimPMei2FgDUrFiC+R8MYcWkYUx95e6EbLcF8+Xkx3ce4MCCF3l12C1+nyPiApqI5BeRB1yy1VJEUkwXFAxWmchblarXRz1Bw+bX89nMZXw8fRHXlK8ckr2ozJl5+j8vMW/ZWr6ZtZDxH4xjy6bfQvYznMoAQiuHauWL07dLI5r3fo0Gt49NUJN656nuPPX2d9S/bQzT563joTtbAXDm7HmeG/cDT7w+PSAfIy6gAfmBywKaiESlvStJY5WJvCuDkyeOsTbmFzp0Mznvs2TNSp68+UKyWaz4VdSsXReA3HnyUKFSFf7eG7rwSjiVAYRWDlXKFGP5uh2XqUlVLF2Un1dtA2Du8i10aVULgFNnzvHL2j85cy6wGeWRGNBGA+VFZI2IrBCReSLyGbBORMqIyPr4HUXkUREZ6XyuICKzHWWoVSJS3teoiNQXkdUiUi5UB60ykXdlsGfnDvIXKMwLwwfRt/N1jB4xhNOnToZsN55dO7ez4dc11K3XIGRb4VoGEHg5bNi291I1qSZGTWrjH3vp0MJk073l+tqUKpY/JL8iMaANB7apah1gGNAAeFJVq6Vy3ETgbVWtDTQB9sZvEJEmwDigs6r+kfhAX9WnAwcOpOqgVSbyrgzi4s6zZeNautzel4++WUD2nDmZ8N5rIdsFOHniBAN638bIF8aSJ2/ekO2FYxlAcOVg1KTmMeOt+5j+Rn9HTeoCA56bwoBuzVj8yUPkzpktQfczWCIxoCVmuar+mdIOIpIHKKmq0wBU9YyqnnI2VwXeAzqq6s6kjvdVfSpSJHXFG6tM5F0ZFClegiLFS1C9tsnO3Kp9Z7Zs+DVku7GxsfTv3ZMut/bkxo5dQrYH4VcGEFo5jJ++jCZ3vkLbAW9z+Ngpft91gC079tNx8Ls0vetVPp+1OiCBlaS4EgKab137PJd+53iNzZT+FvcCZ4C6bjlklYm8K4NCRYpRtHhJdv6xFYCYJQsoUyG0DnFVZdiQAVSsVIX+Ax8M2cd4wqkMIPRyuFRNqiafz1ydsE5EGN6vDe9/+UtIPkZito3jQJ5ktu0DiopIIeAE0AH4UVWPichfItJFVb8WkWxA/CDCEeBuYJaInFTV+aE6aJWJvFWpeujpl3j20QGcjz1HiVJleGJ0aNMsViz7hS+nfEaVajVo38L0GT3+9HO0bntDSHbDqQwg9HKY9FIfCubLSez5Cwz9r1GTGtizOQNubQrAN/PX8cm3F6eXbPrmKfLkyk7WLFF0vK4GHQa/y6Y/96V4johUfXIGAWoBp4F9qtrBZ9sQYAjwJ7Ab2K6qI0WkIvAuUBijDNUNKA08qqodRKQ08APQT1WXJXfu6OhojYmJcf07hVP6IK9Un2z6IIMX5eBVGXiVPuhMzKtXjuqTqt6ewrY3gDeSWL8VaJ1o9R/AfGf7TsCdv0+LxeIJV0IfmsViuUKwAc1isUQMNqBZLJaIwQY0i8USMdiAZrFYIoaInLaRnojIAWCHn7sXBg564EY42Q0nX8PNbjj5Gqjda1T1ssdybEBLR0QkJqm5NFeS3XDyNdzshpOvbtm1TU6LxRIx2IBmsVgiBhvQ0pf3rN2w8jXc7IaTr67YtX1oFoslYrA1NIvFEjHYgGaxWCIGG9AsqSIiYXOfyJWWy9xyCWFzo1oCw60ftohUAf4tIrndsOdjN8rnc3IJOQO1Kep0CouIaxmGkzpPRrYXLiT+3m78cdqAFiEkvjnUhdEe5wYrBRQBHhIRV7IAOsGsjaN7OgToLSIh5+bzCWZ3As+KSOjabT6ISNn487gRhHxsZHaWQ5Za9PXLzZp1vF0RySciBVwym/AnKSJ9gMdCNWgDWhrjc2NUcqTxQk5rmqhmcoeIPC0i/0osxRegzUyqekFVZwNrgBrAIJeCmgB5gTGY7MHfq+p5N36AItII6AIMVdWjoQYJn+tVEfheRJ6E0INa/DUTkQbAbyJSTFXjQvE30X1wFzBcRG4TkZBFVR1fOwGzgJnOPRa0XRG5BpgkIvWdVVkwCVVDwga0NMbnxvgCuA9zc9QL1SYkpBe/F5Ne/CmgTQg2Lzg2h2IChAItgMdEJFeI/p4HlgPngF+AKiKSI/6cgZCoRpINaAlUBG5xfuBxoQQe53p1AEY6PncXR8s1lKDmHHs9cCOmbOeLSHHH36B+lz73wb3AAMff/wEdg7Hni4hUxtxbA4A+QH2SEPQOgNPAImCEiNTClEHoXQ+qal9p+ALKAj8CBYCuwDqgYJC2yvl8zge8ian99AdmYoResgI5A7ApPp+LAXOAXM5yO+D/MHqnfttM4hzFnPdswG2OzducddWA4kH4WhrI73y+D3gNo6N62b4B+pofWAE0w1QAagGLgSdCvA8qA9uBxpgm/Rhgp0/ZZArCZiagIGaCaingTuAnICqYa4QJXOLY+hpTO8vpbC8DbAV6BOqjz+fCwFBgGjDFKYNoTLC8Kb4sAnnZGlracxTzg7gf02fQWVUPiUjrQPqRRCQHpgk00ll1DHPzLXZstlfVOMxNXcdPm5k0/tcv0h5zI1+F+TEDzHX874lpfgZcOxGRQcAEERkDdFfVSUAM0EREJgOTMP/WqeLj61DgA2CyiLwGfAbsApqLSHfffYMgDpMBYruaGuQGx/7dIhKKpt1JYK6qLgEOquowYC0wT0SKqOoFf8rXdx81XQSHgN+B94E7gHZqan2PiUirAPyrgKk9F1TVv4CvnPXtRaSgqm7H1P5y+GvQqTHH1/xvA0oCnwPzgHoYYaL2wOOY30bWAPw1hPIvY19+/SPFP42RzblAWYGPgNVANWdbC8wPpaqfNks575UwP4KnnOUuGFGXfznLvRy75QL0uTEwGxMg+2JqUE18bL4EFA2iLPpgAm4Z50ZeCzzmbGsCjACqB2izC6bmkAkYC8xz1ud17L0I5Pb3WvlcrxJANufzv4GlQA5n+UanDKbHX8MA7oOsznse5/v389mnB6ZG/AOQPcByGAyMdj4/gGluNnKWb3XOVSlAm3mAcTi1UYyc43innDsD24Drg7gP7gPWx9+XmBrqAOCbQO/Vy2yHcrB9+X0BO2Gq7O9ilKNqOTftC86PZQPQwQ87gqmmvw8UcNaVAzZimoF5nBt7rnNzrPEnQGACYz7nc0dgPxeDYg1Mx/1m57y/B/rDcOxEA//CNLUHYZrd1zmBIujmG6bPrD0w3AlsWXz8zkIQzXngBmAJ8AkwEbgGeAb4zSnn34GmTnnUCMBue0zzahymqX0NRiv2SUw3wSKgOfAWgXUTPIz5o6jhc5+MBD52yvkXoKaf95dvMz4zpun3f5hBFjC1vsWYJn0bZ51fzWPHfklgYfw9xKV/ICMwNfQc/tq87BzB3kj25ffNVhlTa+rhExiqYvrS+mKq1s19L64fNrM7N/4DznJ558f2oLNc0DlHET9usGzA6zgB0lm/DFjisxyFUY6/CSgbRBnc7/yQK2D+jb8GCjvbvgK+jV9Ozd8k/G8J/AVM91l/D/AlTt+fH3aLArcDOZ0f3BanfCs512cx5s+iJ6YJXx1Ti10FlPbzHI0wfzxdMX2R251yKYmpRf4fUBMzkLOcFAJxoqBTyDm2KObPrR8mEFfHdBdUw4/aNE5t1PncyvmerXyW3wWGOMt9MMH8Zn/L2DkuE5AL+B6n1szFGmsJ57sE1Z+ccI5QDravVC9gLefHOtJn3d3AJqBpgLYyJVrugKlF9HOWywO/Ai8EYDPKec8CNMDUDOJrODHANy6UQSfHr2uc5aswNcgmzo9mgj/BLJHNQcDLzo+qEKbWtBFTA3rCOZ/fTVdMreMD4C4nqLzjW+bA28AdPvvXx9Qsa/tZvgWcgPaSz7YimGZXbZ91zTAd7cnW+hIFs7swzbdvMJ3/0zH9T1OADwP4/gUwtbiqTiDcgdGu/ZqLzc2WmObmI87yCMwglL/N+WZc/AP+DJjqs60P5o8toGZ2kucJ1YB9pXgRc2Oq0DMwHezx1ev7MCNaBQlwBMr5MV2NqZ1cCywA7nG2VXKCXKABogQmIC5wfhDxQW0hpuM6lDK4DxjhfI63+4hTLr+kFhR8/IsfXRuI6d8rh+kXetXH5ihMbaVKEH4+DLyDGXXbA/T12fZc/A/ZWb6GFEZiMX2EZZzP1zuB5l5gWaL9XuNi32SUcz396kPCNOG/8FnuzMUR0naYGrFfwcY55knMH8F/gdbOumsxwXK4z3ep5XNMgRTsxd/rmZzv1h9Ty+uBqQl/4dxfY4CVvnZDut/cMGJfl13EGkBt50Jmw9RC3gRK+uxbyk+b9bhYY+iD+Vf/GvgUUwOsg+lIHujsk8UPm02Ans7ngU5geNkJMsswzaz44DPLX1+TOdeNmP7Cyj7rOjjfJYcfx5d0ym4Apib5KKZ28wjwHab5HeXjbzDTHdphprkswtQeXsOMko4AbsH0Rbb001YZTA28BlAF+DD+x+pTvtUxTcv1QINA7zHn3lqL6d/LnWj7g862VPvMnP0zO+/5fb53fK0/s3N//QQ87XOM33/COE1yTBDrjan53e6s64oZ1Kng2m/QLUNX+ouLwawT5h/nI8w/0rVcHNn8INDggKnZ/YwZFfzQufHKYvp8pmPmC7XDNG3z+WnzZszk22cxzYhyjo3BmNrPXODVYIJDEufKi6k5veAEsl6YeV1+3cTOD7gPJuD2w/w5LAAm+/wYB2H6ozLhZz+kj/2iTvlWdZYHYmpkz2KC2yj8GLDx8fVWTJ9kbeAIZgDBt7b3unMfzAFuDuTeSrTuTkzfXnMuNo2jgP/g52i5j60umP7AEpgR0o04TXYu1hzrBeqrY28HcKOznIuLcyTvir9+br5cNXYlvpyLFN/BWRdTjS6MGQDYipnk2ABTU/uMAKclOHZLYqr+m3zWFcX07XSN9yNAm20xNYSJznI2TB/Ky5hayQSCmJqRzLmuwjQ9v8fUUvxqXnDxT+IuTLP9RyfQHORif0wf5wdYMUjfCmCa6S2c5SyYvrlZmGai+Prih738wN+YP4yumBrlWOA6n32yAHkCsevsewdm9PIBzB/FbZjaUzP8qJknY7MOpgZaxWfdREyQD6gZmCiYPYwZ1b4DM0Wpnc+2uc59lt+N+8v3ZSfWhoDz8PNooIMz0fUEpg+mDqZ63QsTKF4AGmI6ljf4YTeTz+esqrobcxMfE5H3AVR1PxebHwCnAvFdVX/C9JvcJCI9VPWsqv6GGYk8oqq9nHOEjKruVdVxmJpAb1X91c/jVETuwNQcR2BqO3GYUbyhIvIOJujcqqpbg/TtMKY/p6WI1FDVWEyn+j/AQnV+gfHvfnAM8wPOjKkxTsI85tNeRFo7tmJV9XggdkVkIKYcDmNGzmc6r/h5YcGqJZ3FBLTrROQZEZkLXMAE5s8lgEwo8d9FRNpiBkFWqOpETD/ZKyJys/MY2TFgrKoeCdLnFJ2wrxBemD6LDzD/xtmddU9wsZ/gfkx/V0DNAOfYfpiRx+cwo29XY2oOCzC1lgUE0QGe6BwdMA8FP4tpiq4Gyqd3ufr49xwwzPmcFfOH8TmmD60wfjazUzlHKUxTbSbwPGZeYMsQbV6D09wEimM628eQQkd6ouPjm5HxNcRx+PS3YQL8/5zPA/Fz+kgS58mNabIvxtTMa2D+PFv7axPTWohvovbB1Ji/TbTPrZia8FxcGgBI0pf0vmHD9cWlz6QNcILWLZjmRF/MI0L9MP9+TYKwfwemSdgW0//2X0wHe0nnBzebEDrrE52rC6bmMxlndC6jvBzfvsanqY4ZHX0ByOviefJg+hEfxqd5GKLNupj5gf0xze5gJiRXcu6pGThPVTjraxHA1Aw/zhM/HyzaCUitAzi2IuaPdjzmMaY7Mf3IQxLtl48Au0YC/h5eGo/Ul8+/Zimfdd0wfQ/xfVr3YAYFbgrUNqYj9iWcuU+Yfp6HuTjaWQIo4fJ3ug5nrlhGemGaPs9jOudbY2qR0/HzAfb0fmFGqf/098+HS0egB2NqeWOcMviLiyOQd2BqO/kJcCAkmfNGOb4uw+eh/gCOH4tpSt7vLN/o/BENTsvyDjmp3pWIqqqI3ACMFZFVQCzm5jsPdBWRLJgRyY/V5PlKyFOVFL7bnfc4EdkJdBaRhaq6y+k7+05ESqvqTg++0wK3bbqBqh4Rkbcxtd+nMGX8iKr+nb6e+YeqrhSRWur0mflBAeBFMZmCS2EmC7fDDALMBkaJycbbCpPp4ohLfsaJyCZMMP0ztXs2CcZhpos8LCKHVHWKiOwH/k9EDqpJQuA5NqAFgZO/7EZM38V+TL/B15j+qEKYSY4LVHUfpN7xG79dRP6FaWJMxFThS2KyuU7FdNYL4O8PI2JQ1T3AWyLyEaY2ciK9fQoQv/1V1e9E5BzwCrBUVbeJyIeYEUMwI6jvYZ4++cdNJ1X1JKY2meo9m8SxvwO/i8gR4HnnPTsm591SN/1MCavL6Sc+GUYLYLIMbFDV5k6GUcUM9f+gqlP9rUUlyjDaCzOh9RdM1X8opsO2EaapdRbTh7LG/W9nyWiISGfMPTVEVSc7I999MH9s/3WrZuYFTutlDCZF0t3qx8i+a+e2AS11fILZjZgRnW2YOVEPquoHzj7/Bfap6suB2HQ+F8c0IVao6u9Ofq+2mGf/FjpBNE5Vj7n+5SwZFhG5GfPg+gs+QS1XAM3XdENEimIqegfS8ry2yekHTjBrgBlxm6yqPzv/QnNEpAZmln5bzHOQqZIomA0CHgLOYDpk+6nqayISB4wRkWGqutD9b2XJ6DjNzwvAeyJyXlWnEiZdDurSHMZAsTW0ZBCRcpih6/85ueo/xyTzq+izTxPMTO25QH9V3SsiUWoyxfpzjmaYCbgvYuaY9Qd+V9V/O9sHYJqxrg8CWMIHZ6LqNlUNWUQk0rEBLRlEpCQmyPyhqvtFpDTm8aOlqnq/z37RmIekh6vqR/6MDjlNh3KYjAi/YSbJXsD0nQ0E9qpJyWyxWALAPvqUBE4tazfmIer5IjLaqSV1BMqLyOvx+6pqDNAdI8abPwWbiXO//46Z7X4VZlg+FtPkfA8oICKF3f9mFktkY2toifAZACiPme2fEzMl40tVfV5ESmGe9Vurqg+ISGZnrll2VT3jh/3emBnk+7mY3vk/mOwW32CmZmT1x5bFYrkUOyiQCCeYdcTMTN+OGdEcAbwqInGqOlpEemJqVqjRmAQzrSJFROQ+zONQ72Cas99injB4FpN9IFZVv8MMEFgslgCxAS0RYpS3n8GMWrbFNAFPY0Yi33NqZKMwifASSKrfLIkBgmuAx1V1nrN9FzBKVbuJyPOYZzctFkuQ2D60y/kLk22gDiaTRm3M5NY7neVF/hhx5o5Vcz7fJCIlMLW6O3x2mwecdZqrU1V1h1tfwmK5ErEBLRGq+peqrsA8rD3R6bz/GJODaqWqLvDt4E+BUkAvEfkEeM15fGcoUEdExjr7NMbU2nK5/DUslisS2+RMnnXAADFq5h0xWQN2QsrPucUPKqjqOud5tiEYzcj4B607AV+LyKeY3PJ3uv1MnsVypWJHOZNBRPJikjZ2Aj5Q1e8DPL4Z5hnPYhg9y4XAj86ctvyY/GOZ1WRMtVgsLmADWir4TMvwO52KiBTBZK3Njul3a4NJx/01RgmoMCYFzvnkbFgslsCxAS0VgsgLFX9cfUwOr5yY4HYdJrA1wgh8rHXVUYvFYgOam4hIX4w825PO8rWYUc3zwPOqekxEcodhPi+LJSywo5whkMRo53zMQMITAKq6CpP/vy3wpDMvzQYzi8Uj7ChnkCSRAqgGZmT0ZmCGiFxQ1Zcw6V7mAa/6m4XDYrEEh21yhoiIPAD0wDQtf8UIoyzHyM/NB5oC7VV1c3r5aLFcKdgaWgg4UzuuBXpinslcgZkoWxSTEugU5lGnv9LNSYvlCsLW0ELESf5YBfM0QCsn19k/mOwZo1X1XLo6aLFcQdgaWoio6lkROQVkFpF4dfPvMBJ2NphZLGmIraG5gFNLG4qZZ1YM6K6qm9LVKYvlCsQGNJcQIy5cHLjgZLu1WCxpjA1oFoslYrATay0WS8RgA5rFYokYbECzWCwRgw1oFoslYrABzRLWiEhLEZnhfO4kIsNT2De/86haoOcYKSKP+rs+0T4fi8itAZyrjIhYsZwgsQHNkiERkahAj1HV6ao6OoVd8mMEcCwRig1oljTFqYFsEpHxIvKriEwVkZzOtu0i8oyI/Ax0E5F2IrJERFaJyBciktvZ7wbHxs+YJJrxtvuIyFvO52IiMk1E1jqvJsBojPL9GhEZ4+w3TERWOL4862PrSRHZLCKzMQI5qX2vex07a0Xky/jv5NBGRBaJyBYR6eDsHyUiY3zOPSDUsrXYgGZJHyoD76lqLeAYl9aazqhqM2A28BTQRlWvBWKAh0UkO/A+RrimOWYyc1K8ASxQ1dqYBAIbMGI121S1jqoOE5F2QEWgAUa2sJ6ItBCRepiEA3UxAbO+H9/pK1Wt75zvN+Bun21lMBmLbwbGOd/hbuCoqtZ37N8rImX9OI8lBeyznJb0YJeqLnY+T8AoY8VL+01x3hthdE0XO3k0swJLMIkA/lTVrQAiMgHon8Q5WmMynuDkoTvqaKX60s55rXaWc2MCXB5gmqqecs4x3Y/vVENERmGatbmBmT7bPlfVC8BWEfnD+Q7tgFo+/Wv5nHNv8eNclmSwAc2SHiR+PMV3+aTzLsBPqnqb744iUieJ44NFgBdV9d1E5xgaxDk+Brqo6loR6QO09NmW1PcVjDSib+BDRMoEeF6LD7bJaUkPSotIY+fzbcDPSeyzFGgqIhUARCSniFQCNgFlRaS8z/FJMQe43zk2yslddxxT+4pnJtDPp2+upIgUxUgOdhWRHCKSB9O8TY08wF7nmd47Em3rJiKZHJ/LAZudc9/v7I+IVBIRKzgdIjagWdKD34DeIvIrUBB4J/EOqnoA6ANMcvZbClRR1TOYJuZ3zqDAjmTO8SDQSkTWASuB6o6g82IRWS8iY1R1FvAZsMTZbyqQx9GCmAKsAb4EFvnxnZ4GlgE/YYKuL5uBBcAPwH3Od/gfsBFY5UzTeBfbYgoZ+3C6JU1xmlQzVLVGevtiiTxsDc1isUQMtoZmsVgiBltDs1gsEYMNaBaLJWKwAc1isUQMNqBZLJaIwQY0i8USMdiAZrFYIob/BzGL0/vjFyEsAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/plot_confusion-matrix_basic.py\n",
    "from torchmetrics import ConfusionMatrix\n",
    "import matplotlib\n",
    "from mlxtend.plotting import plot_confusion_matrix\n",
    "\n",
    "\n",
    "cmat = ConfusionMatrix(num_classes=len(class_dict))\n",
    "\n",
    "for x, y in test_dataloader:\n",
    "\n",
    "    with torch.no_grad():\n",
    "        pred = lightning_model(x)\n",
    "    cmat(pred, y)\n",
    "\n",
    "cmat_tensor = cmat.compute()\n",
    "cmat = cmat_tensor.numpy()\n",
    "\n",
    "fig, ax = plot_confusion_matrix(\n",
    "    conf_mat=cmat,\n",
    "    class_names=class_dict.values(),\n",
    "    norm_colormap=matplotlib.colors.LogNorm()  \n",
    "    # normed colormaps highlight the off-diagonals \n",
    "    # for high-accuracy models better\n",
    ")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "6d55360a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torchmetrics     : 0.6.2\n",
      "matplotlib       : 3.3.4\n",
      "numpy            : 1.22.2\n",
      "torchvision      : 0.11.2\n",
      "pandas           : 1.2.5\n",
      "pytorch_lightning: 1.6.0.dev0\n",
      "sys              : 3.8.12 | packaged by conda-forge | (default, Oct 12 2021, 21:59:51) \n",
      "[GCC 9.4.0]\n",
      "torch            : 1.10.1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%watermark --iversions"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}