pytorch-lightning_ipynb/mlp/mlp-batchnorm.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a26e9ac9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch            : 1.10.1\n",
      "pytorch_lightning: 1.5.1\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": "c94aeda6",
   "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": "d95a5e76",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext pycodestyle_magic\n",
    "%flake8_on --ignore W291,W293,E703,E402 --max_line_length=100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a3eefdb4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 3;\n",
       "                var nbb_unformatted_code = \"%load_ext nb_black\";\n",
       "                var nbb_formatted_code = \"%load_ext nb_black\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%load_ext nb_black"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3903c912",
   "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",
    "# Multilayer Perceptron with BatchNorm trained on MNIST"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64c5c3ee",
   "metadata": {},
   "source": [
    "A simple multilayer perceptron [1][2] with BatchNorm [3][4][5] trained on MNIST [6].\n",
    "\n",
    "### References\n",
    "\n",
    "- [1] https://en.wikipedia.org/wiki/Multilayer_perceptron\n",
    "- [2] L9.1 Multilayer Perceptron Architecture (24:24): https://www.youtube.com/watch?v=IUylp47hNA0\n",
    "- [3] https://en.wikipedia.org/wiki/Batch_normalization\n",
    "- [4] L11.2 How BatchNorm Works (15:14): https://www.youtube.com/watch?v=34PDIFvvESc\n",
    "- [5] Batch normalization: Accelerating deep network training by reducing internal covariate shift, http://proceedings.mlr.press/v37/ioffe15.html\n",
    "- [6] https://en.wikipedia.org/wiki/MNIST_database"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "454310a9",
   "metadata": {},
   "source": [
    "## General settings and hyperparameters"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "359a99b1",
   "metadata": {},
   "source": [
    "- Here, we specify some general hyperparameter values and general settings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5e359318",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 4;\n",
       "                var nbb_unformatted_code = \"HIDDEN_UNITS = (128, 256)\\nBATCH_SIZE = 256\\nNUM_EPOCHS = 10\\nLEARNING_RATE = 0.005\\nNUM_WORKERS = 4\\nDROPOUT_PROBA = 0.5\";\n",
       "                var nbb_formatted_code = \"HIDDEN_UNITS = (128, 256)\\nBATCH_SIZE = 256\\nNUM_EPOCHS = 10\\nLEARNING_RATE = 0.005\\nNUM_WORKERS = 4\\nDROPOUT_PROBA = 0.5\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "HIDDEN_UNITS = (128, 256)\n",
    "BATCH_SIZE = 256\n",
    "NUM_EPOCHS = 10\n",
    "LEARNING_RATE = 0.005\n",
    "NUM_WORKERS = 4\n",
    "DROPOUT_PROBA = 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8358f61f",
   "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": "e8424235",
   "metadata": {},
   "source": [
    "## Implementing a Neural Network using PyTorch Lightning's `LightningModule`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b958a33d",
   "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": "2192b28a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 5;\n",
       "                var nbb_unformatted_code = \"import torch\\nimport torch.nn.functional as F\\n\\n\\n# Regular PyTorch Module\\nclass PyTorchModel(torch.nn.Module):\\n    def __init__(self, input_size, hidden_units, num_classes):\\n        super().__init__()\\n\\n        # Initialize MLP layers\\n        all_layers = []\\n        for hidden_unit in hidden_units:\\n            layer = torch.nn.Linear(input_size, hidden_unit, bias=False)\\n            all_layers.append(layer)\\n            all_layers.append(torch.nn.BatchNorm1d(hidden_unit))\\n            all_layers.append(torch.nn.ReLU())\\n            input_size = hidden_unit\\n\\n        output_layer = torch.nn.Linear(\\n            in_features=hidden_units[-1],\\n            out_features=num_classes)\\n\\n        all_layers.append(output_layer)\\n        self.layers = torch.nn.Sequential(*all_layers)\\n\\n    def forward(self, x):\\n        x = torch.flatten(x, start_dim=1)  # to make it work for image inputs\\n        x = self.layers(x)\\n        return x  # x are the model's logits\";\n",
       "                var nbb_formatted_code = \"import torch\\nimport torch.nn.functional as F\\n\\n\\n# Regular PyTorch Module\\nclass PyTorchModel(torch.nn.Module):\\n    def __init__(self, input_size, hidden_units, num_classes):\\n        super().__init__()\\n\\n        # Initialize MLP layers\\n        all_layers = []\\n        for hidden_unit in hidden_units:\\n            layer = torch.nn.Linear(input_size, hidden_unit, bias=False)\\n            all_layers.append(layer)\\n            all_layers.append(torch.nn.BatchNorm1d(hidden_unit))\\n            all_layers.append(torch.nn.ReLU())\\n            input_size = hidden_unit\\n\\n        output_layer = torch.nn.Linear(\\n            in_features=hidden_units[-1], out_features=num_classes\\n        )\\n\\n        all_layers.append(output_layer)\\n        self.layers = torch.nn.Sequential(*all_layers)\\n\\n    def forward(self, x):\\n        x = torch.flatten(x, start_dim=1)  # to make it work for image inputs\\n        x = self.layers(x)\\n        return x  # x are the model's logits\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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, input_size, hidden_units, num_classes):\n",
    "        super().__init__()\n",
    "\n",
    "        # Initialize MLP layers\n",
    "        all_layers = []\n",
    "        for hidden_unit in hidden_units:\n",
    "            layer = torch.nn.Linear(input_size, hidden_unit, bias=False)\n",
    "            all_layers.append(layer)\n",
    "            all_layers.append(torch.nn.BatchNorm1d(hidden_unit))\n",
    "            all_layers.append(torch.nn.ReLU())\n",
    "            input_size = hidden_unit\n",
    "\n",
    "        output_layer = torch.nn.Linear(\n",
    "            in_features=hidden_units[-1],\n",
    "            out_features=num_classes)\n",
    "\n",
    "        all_layers.append(output_layer)\n",
    "        self.layers = torch.nn.Sequential(*all_layers)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = torch.flatten(x, start_dim=1)  # to make it work for image inputs\n",
    "        x = self.layers(x)\n",
    "        return x  # x are the model's logits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "26f52f6c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 6;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/lightningmodule_classifier_basic.py\\nimport pytorch_lightning as pl\\nimport torchmetrics\\n\\n\\n# LightningModule that receives a PyTorch model as input\\nclass 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\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/lightningmodule_classifier_basic.py\\nimport pytorch_lightning as pl\\nimport torchmetrics\\n\\n\\n# LightningModule that receives a PyTorch model as input\\nclass 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\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c38927e",
   "metadata": {},
   "source": [
    "## Setting up the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f9c27a8",
   "metadata": {},
   "source": [
    "- In this section, we are going to set up our dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8427abe",
   "metadata": {},
   "source": [
    "### Inspecting the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "13239d0a",
   "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"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 7;\n",
       "                var nbb_unformatted_code = \"# %load ../code_dataset/dataset_mnist_check.py\\nfrom collections import Counter\\nfrom torchvision import datasets\\nfrom torchvision import transforms\\nfrom torch.utils.data import DataLoader\\n\\n\\ntrain_dataset = datasets.MNIST(\\n    root=\\\"./data\\\", train=True, transform=transforms.ToTensor(), download=True\\n)\\n\\ntrain_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\\ntest_dataset = datasets.MNIST(\\n    root=\\\"./data\\\", train=False, transform=transforms.ToTensor()\\n)\\n\\ntest_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\\ntrain_counter = Counter()\\nfor images, labels in train_loader:\\n    train_counter.update(labels.tolist())\\n\\ntest_counter = Counter()\\nfor images, labels in test_loader:\\n    test_counter.update(labels.tolist())\\n\\nprint(\\\"\\\\nTraining label distribution:\\\")\\nsorted(train_counter.items())\\n\\nprint(\\\"\\\\nTest label distribution:\\\")\\nsorted(test_counter.items())\";\n",
       "                var nbb_formatted_code = \"# %load ../code_dataset/dataset_mnist_check.py\\nfrom collections import Counter\\nfrom torchvision import datasets\\nfrom torchvision import transforms\\nfrom torch.utils.data import DataLoader\\n\\n\\ntrain_dataset = datasets.MNIST(\\n    root=\\\"./data\\\", train=True, transform=transforms.ToTensor(), download=True\\n)\\n\\ntrain_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\\ntest_dataset = datasets.MNIST(\\n    root=\\\"./data\\\", train=False, transform=transforms.ToTensor()\\n)\\n\\ntest_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\\ntrain_counter = Counter()\\nfor images, labels in train_loader:\\n    train_counter.update(labels.tolist())\\n\\ntest_counter = Counter()\\nfor images, labels in test_loader:\\n    test_counter.update(labels.tolist())\\n\\nprint(\\\"\\\\nTraining label distribution:\\\")\\nsorted(train_counter.items())\\n\\nprint(\\\"\\\\nTest label distribution:\\\")\\nsorted(test_counter.items())\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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": "2d9eaff5",
   "metadata": {},
   "source": [
    "### Performance baseline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afcb616e",
   "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": "8cead536",
   "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"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 8;\n",
       "                var nbb_unformatted_code = \"# %load ../code_dataset/performance_baseline.py\\nmajority_class = test_counter.most_common(1)[0]\\nprint(\\\"Majority class:\\\", majority_class[0])\\n\\nbaseline_acc = majority_class[1] / sum(test_counter.values())\\nprint(\\\"Accuracy when always predicting the majority class:\\\")\\nprint(f\\\"{baseline_acc:.2f} ({baseline_acc*100:.2f}%)\\\")\";\n",
       "                var nbb_formatted_code = \"# %load ../code_dataset/performance_baseline.py\\nmajority_class = test_counter.most_common(1)[0]\\nprint(\\\"Majority class:\\\", majority_class[0])\\n\\nbaseline_acc = majority_class[1] / sum(test_counter.values())\\nprint(\\\"Accuracy when always predicting the majority class:\\\")\\nprint(f\\\"{baseline_acc:.2f} ({baseline_acc*100:.2f}%)\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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": "6a19bc75",
   "metadata": {},
   "source": [
    "## A quick visual check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4eb6fa59",
   "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"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1: E999 SyntaxError: invalid syntax\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 9;\n",
       "                var nbb_unformatted_code = \"# %load ../code_dataset/plot_visual-check_basic.py\\n%matplotlib inline\\nimport matplotlib.pyplot as plt\\nimport numpy as np\\nimport torchvision\\n\\n\\nfor images, labels in train_loader:  \\n    break\\n\\nplt.figure(figsize=(8, 8))\\nplt.axis(\\\"off\\\")\\nplt.title(\\\"Training images\\\")\\nplt.imshow(np.transpose(torchvision.utils.make_grid(\\n    images[:64], \\n    padding=2,\\n    normalize=True),\\n    (1, 2, 0)))\\nplt.show()\";\n",
       "                var nbb_formatted_code = \"# %load ../code_dataset/plot_visual-check_basic.py\\n%matplotlib inline\\nimport matplotlib.pyplot as plt\\nimport numpy as np\\nimport torchvision\\n\\n\\nfor images, labels in train_loader:\\n    break\\n\\nplt.figure(figsize=(8, 8))\\nplt.axis(\\\"off\\\")\\nplt.title(\\\"Training images\\\")\\nplt.imshow(\\n    np.transpose(\\n        torchvision.utils.make_grid(images[:64], padding=2, normalize=True), (1, 2, 0)\\n    )\\n)\\nplt.show()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "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": "86d6829f",
   "metadata": {},
   "source": [
    "### Setting up a `DataModule`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d985135b",
   "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": "c4443e49",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 10;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/datamodule_mnist_basic.py\\nfrom torch.utils.data.dataset import random_split\\n\\n\\nclass 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",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/datamodule_mnist_basic.py\\nfrom torch.utils.data.dataset import random_split\\n\\n\\nclass 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",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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": "b529b097",
   "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": "82aa3f69",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 11;\n",
       "                var nbb_unformatted_code = \"torch.manual_seed(1) \\ndata_module = DataModule(data_path='./data')\";\n",
       "                var nbb_formatted_code = \"torch.manual_seed(1)\\ndata_module = DataModule(data_path=\\\"./data\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "torch.manual_seed(1) \n",
    "data_module = DataModule(data_path='./data')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "145890b8",
   "metadata": {},
   "source": [
    "## Training the model using the PyTorch Lightning Trainer class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b02578f",
   "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": "3bdf56f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 12;\n",
       "                var nbb_unformatted_code = \"pytorch_model = PyTorchModel(\\n    input_size=28*28,\\n    hidden_units=HIDDEN_UNITS,\\n    num_classes=10\\n)\";\n",
       "                var nbb_formatted_code = \"pytorch_model = PyTorchModel(\\n    input_size=28 * 28, hidden_units=HIDDEN_UNITS, num_classes=10\\n)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pytorch_model = PyTorchModel(\n",
    "    input_size=28*28,\n",
    "    hidden_units=HIDDEN_UNITS,\n",
    "    num_classes=10\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "55b32795",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 13;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/logger_csv_acc_basic.py\\nfrom pytorch_lightning.callbacks import ModelCheckpoint\\nfrom pytorch_lightning.loggers import CSVLogger\\n\\n\\nlightning_model = LightningModel(pytorch_model, learning_rate=LEARNING_RATE)\\n\\ncallbacks = [\\n    ModelCheckpoint(\\n        save_top_k=1, mode=\\\"max\\\", monitor=\\\"valid_acc\\\"\\n    )  # save top 1 model\\n]\\nlogger = CSVLogger(save_dir=\\\"logs/\\\", name=\\\"my-model\\\")\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/logger_csv_acc_basic.py\\nfrom pytorch_lightning.callbacks import ModelCheckpoint\\nfrom pytorch_lightning.loggers import CSVLogger\\n\\n\\nlightning_model = LightningModel(pytorch_model, learning_rate=LEARNING_RATE)\\n\\ncallbacks = [\\n    ModelCheckpoint(save_top_k=1, mode=\\\"max\\\", monitor=\\\"valid_acc\\\")  # save top 1 model\\n]\\nlogger = CSVLogger(save_dir=\\\"logs/\\\", name=\\\"my-model\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23254d05",
   "metadata": {},
   "source": [
    "- Now it's time to train our model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b92c3460",
   "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 | 136 K \n",
      "1 | train_acc | Accuracy     | 0     \n",
      "2 | valid_acc | Accuracy     | 0     \n",
      "3 | test_acc  | Accuracy     | 0     \n",
      "-------------------------------------------\n",
      "136 K     Trainable params\n",
      "0         Non-trainable params\n",
      "136 K     Total params\n",
      "0.546     Total estimated model params size (MB)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9d320e4597dc49cfafc51ccd8656904e",
       "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": "af8467ef0148444f8682ec381c0854a8",
       "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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training took 1.55 min in total.\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 14;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/trainer_nb_basic.py\\nimport time\\n\\n\\ntrainer = 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=True,\\n    log_every_n_steps=10,\\n)\\n\\nstart_time = time.time()\\ntrainer.fit(model=lightning_model, datamodule=data_module)\\n\\nruntime = (time.time() - start_time) / 60\\nprint(f\\\"Training took {runtime:.2f} min in total.\\\")\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/trainer_nb_basic.py\\nimport time\\n\\n\\ntrainer = 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=True,\\n    log_every_n_steps=10,\\n)\\n\\nstart_time = time.time()\\ntrainer.fit(model=lightning_model, datamodule=data_module)\\n\\nruntime = (time.time() - start_time) / 60\\nprint(f\\\"Training took {runtime:.2f} min in total.\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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=True,\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.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "896acd5c",
   "metadata": {},
   "source": [
    "## Evaluating the model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6ed0d55",
   "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": "105d19fa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEGCAYAAAB/+QKOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAA8T0lEQVR4nO3deXxU1d348c83O9mBLEASSWRJ2AOERUBMxAVExbqwqHWplgeXuhUt9tHu7ePvqXWrCA9WsS4VFdFSS0UFRhQQw74HAgQSFsMWSICELOf3xx3IJAyQhLmZZPJ9v155Ze5y7nxzxPnOPefcc8QYg1JKKVWbn7cDUEop1TRpglBKKeWWJgillFJuaYJQSinlliYIpZRSbgV4OwBPiomJMcnJyQ0qe/z4ccLCwjwbUDOldVGT1kdNWh/VfKEuVq5cedAYE+vumE8liOTkZFasWNGgsg6Hg8zMTM8G1ExpXdSk9VGT1kc1X6gLEdl1rmPaxKSUUsotTRBKKaXcsjVBiMhIEckRkVwRmeLmeJqILBORMhGZXOvY4yKyUUQ2iMj7IhJiZ6xKKaVqsq0PQkT8ganA1UABkC0ic40xm1xOOww8AtxUq2yCc393Y8xJEfkQGA+8ZVe8Sqmmp7y8nIKCAkpLS70diltRUVFs3rzZ22HUSUhICImJiQQGBta5jJ2d1AOBXGPMDgARmQWMAc4kCGNMIVAoIqPPEVsrESkHQoG9NsaqlGqCCgoKiIiIIDk5GRHxdjhnKS4uJiIiwtthXJAxhkOHDlFQUEBKSkqdy9mZIBKAfJftAmBQXQoaY/aIyPPAbuAk8IUx5gt354rIRGAiQHx8PA6Ho0HBlpSUNLisr9G6qEnro6bGrI+oqCjatm1LSUlJo7xffVVWVlJcXOztMOokKCiIoqKiev23szNBuEv3dZo6VkRaY91tpABFwEcicqcx5t2zLmjMDGAGQEZGhmnokDNfGK7mKVoXNWl91NSY9bF582YiIyMb5b0aorncQZwWEhJC375963y+nZ3UBUCSy3YidW8mugrYaYw5YIwpB+YAQzwcHwCl5ZX839fb2Xiw0o7LK6VUs2VngsgGuohIiogEYXUyz61j2d3AYBEJFavhcQRgS09QkL8fMxbv4Js95XZcXimlmi3bEoQxpgJ4GJiP9eH+oTFmo4hMEpFJACLSTkQKgCeAZ0SkQEQijTHLgdnAKmC9M84ZdsTp5ydckRrL+oOVVFbp4klKqWpFRUW89tpr9S533XXXUVRUVO9y99xzD7Nnz653ObvY+hyEMWaeMaarMaaTMeaPzn3TjTHTna/3G2MSjTGRxpho5+tjzmO/NsakGWN6GmN+bIwpsyvOrNQ4jpfDmvwiu95CKdUMnStBVFaev0l63rx5REdH2xRV4/GpuZgaaniXWARw5BTSv2Nrb4ejlHLjt//ayKa9xzx6ze4dIvn1DT3OeXzKlCls376d9PR0AgMDCQ8Pp3379qxZs4ZNmzYxYcIE9u3bR2lpKY8++igTJ04EqueFKykpYdSoUQwbNoylS5eSkJDAP//5T1q1anXB2BYsWMDkyZOpqKhgwIABTJs2jeDgYKZMmcLcuXMJCAjgmmuu4fnnn+ejjz7it7/9Lf7+/kRFRbF48WKP1I9OtQFEhQbSpbUfi3IKvR2KUqoJee655+jUqRNr1qzhz3/+M99//z1//OMf2bTJepxr6tSprFy5khUrVvDKK69w6NChs66xbds2HnroITZu3Eh0dDQff/zxBd+3tLSUe+65hw8++ID169dTUVHBtGnTOHz4MJ988gkbN25k3bp1PPPMMwD87ne/Y/78+axdu5a5c+va1Xthegfh1DvGn9nbjlFYXEpchM7qoVRTc75v+o1l4MCBNR40mz59OvPmzQMgPz+fbdu20bZt2xplUlJSSE9PB6B///7k5eVd8H1ycnJISUmha9euANx9991MnTqVhx9+mJCQEO6//35Gjx7N9ddfD8DQoUO55557GDt2LDfffLMH/lKL3kE49Y71B+DrnANejkQp1VS5rv3gcDhwOBwsW7aMtWvX0rdvX7dTggQHB5957e/vT0VFxQXfxxj3A2YCAgL4/vvvueWWW/j0008ZOXIkYCWqP/zhD+Tn55Oenu72TqYhNEE4JUX4ER8ZjEMThFLKKSIi4pxPSh89epTo6GhCQ0PZsmUL3333ncfeNy0tjby8PHJzcwF45513uOKKKygpKeHo0aNcd911vPTSS6xZswaA7du3M2jQIH73u98RExNDfn7+ea5ed9rE5CQiZHaNY96GfZRXVhHor7lTqZaubdu2DB06lJ49e9KqVSvi4+PPHBs5ciSvvvoqvXv3JjU1lcGDB3vsfUNCQpg5cya33XbbmU7qSZMmcfjwYcaMGUNpaSnGGF588UUAnnzySbZt24YxhhEjRtCnTx+PxKEJwkVWWiwfrMhn1a4jDLq07YULKKV83j/+8Q+3+4ODg5kzZ47bqTZO9zPExMSwYcOGM/snT5581rmu3nrrrTOvR4wYwerVq2scb9++Pd9///1Z5ebMmXPe6zaUfk12MbRzDAF+wiJtZlJKKU0QriJCAhmQ3AaHDndVStnooYceIj09vcbPzJkzvR3WWbSJqZastFj+NG8Le4tO0iH6wg+zKKVUfU2dOtXbIdSJ3kHUkpUaB8DXW7WZSSnVsmmCqKVzXDgJ0a1YtEWbmZRSLZsmiFpEhKy0WJbkHqSsQteIUEq1XJog3MjsGsfxU5WsyDvi7VCUUsprNEG4MaRzW4L8/bSZSSlVL+Hh4QDs3buXW2+91e05mZmZrFix4pzXSE5O5uDBg7bEV1+2JggRGSkiOSKSKyJT3BxPE5FlIlImIpNrHYsWkdkiskVENovIZXbG6io0KIBBl7bR2V2VUg3SoUOHJrXwT0PZNsxVRPyBqcDVWOtTZ4vIXGPMJpfTDgOPADe5ucTLwOfGmFudS5aG2hWrO1mpcfzus03sPnSCS9o26lsrpdz5zxTYv96z12zXC0Y9d87Dv/jFL+jYsSMPPvggAL/5zW8QERYvXsyRI0coKyvjT3/6E2PGjKlRLi8vj+uvv54NGzZw8uRJ7r33XjZt2kS3bt04efJkncN74YUXePPNNwG4//77eeyxxzh+/Dhjx46loKCAyspKnn32WcaNG+d2nYiLZedzEAOBXGPMDgARmQWMAc4kCGNMIVAoIqNdC4pIJDAcuMd53inglI2xniUrzUoQjq2F3HVZcmO+tVKqiRg/fjyPPfbYmQTx4Ycf8vnnn/P4448TGRlJXl4eV111FTfeeCMi4vYa06ZNIzQ0lHXr1rFu3Tr69etXp/deuXIlM2fOZPny5RhjGDRoEFdccQU7duygQ4cO/Pvf/wasSQNPrxOxZcsWRKRBy526Y2eCSABcpxQsAAbVseylwAFgpoj0AVYCjxpjjtc+UUQmAhMB4uPjcTgcDQq2pKTkrLLxocLspVu4pCyvQddsrtzVRUum9VFTY9ZHVFRU9Wyqw/7bnjc5x2ytAJ07d2b//v1s3bqVgwcPEhkZSXh4OJMnT2bp0qWICHv27GH79u1nJvIrLi6mpKSEqqoqiouLWbhwIZMmTaK4uJiUlBR69uzJ8ePHzzlLrDGGkpISvvrqK6677jqqqqoAGD16NF9++SVXXXUVX375JY8//jgjR45kyJAhVFVVERQUxN133821117LyJEj3V6/tLS0Xv/t7EwQ7tKp+0nOzxYA9AN+ZoxZLiIvA1OAZ8+6oDEzgBkAGRkZJjMzs0HBOhwOapcddWwjs7J3M3jo5YQE+jfous2Ru7poybQ+amrM+ti8ebPbyfAa09ixY/n888/Zv38/d9xxB3PnzuXo0aOsXr2a0tJSevXqRUBAwJk4IyIiCA8Px8/Pj4iICAICAggLCztz3M/Pr8Z2bSJCeHg4wcHBBAcHnzkvODiYkJAQ+vXrx6pVq5g3bx6///3vueaaa/jVr37FihUrWLBgAbNmzeKNN95g4cKFZ107JCSEvn371vlvt7OTugBIctlOBPbWo2yBMWa5c3s2VsJoVFlpcZSWV/HdDs8svqGUan7Gjx/PrFmzmD17NrfeeitHjx4lLi6OwMBAFi9ezK5du85bfvjw4bz33nsAbNiwgXXr1tXpfYcPH86nn37KiRMnOH78OJ988gmXX345e/fuJTQ0lDvvvJPJkyezatWqc64TcbHsvIPIBrqISAqwBxgP3F6XgsaY/SKSLyKpxpgcYAQufReNZVBKG0IC/XDkHCDTOQWHUqpl6dGjB8XFxSQkJNC+fXvuuOMObrjhBjIyMujRowdpaWnnLf/AAw9w77330rt3b9LT0xk4cGCd3rdfv37cc889Z86///776du3L/Pnz+fJJ5/Ez8+PwMBApk2bRnFxsdt1Ii6WbQnCGFMhIg8D8wF/4E1jzEYRmeQ8Pl1E2gErgEigSkQeA7obY44BPwPec45g2gHca1es5xIS6M+QTjEs3FLIr2/ofs5OKKWUb1u/vnr0VExMDMuWLQOs/gbXpqKSkhLAepbh9DoQrVq1YtasWXV+L9c1q5944gmeeOKJGsevvfZarr322rPKuVsn4mLZOpurMWYeMK/Wvukur/djNT25K7sGyLAzvrrISo1l4ZZCdh48zqWx4d4ORymlGo1O930BVtPSRhblHNAEoZTymEGDBlFWVlZj3zvvvEOvXr28FNHZNEFcQFKbUDrHhePIKeS+YSneDkepFscY45PNu8uXL7/wSR5kTF0HkVbTuZjqICs1luU7DnO8rMLboSjVooSEhHDo0KEGfbipasYYDh06REhISL3K6R1EHWSlxvH6NztZtv0QV3WP93Y4SrUYiYmJFBQUcOBA01zAq7S0tN4fut4SEhJCYqLbLt9z0gRRBxnJbQgL8mdRTqEmCKUaUWBgICkpTbdp1+Fw1OvBs+ZGm5jqICjAj6GdY3DkHNBbXaVUi6EJoo6y0uLYU3SSbYUl3g5FKaUahSaIOspMjQXQRYSUUi2GJog6ah/VirR2EbqIkFKqxdAEUQ9ZaXGsyDvCsdJyb4eilFK20wRRD1mpcVRUGZZsaxrrxSqllJ00QdRDv0uiiQgJwJHTNMdkK6WUJ2mCqIcAfz+Gd41lUU6hDndVSvk8TRD1lJUaR2FxGZv2HfN2KEopZStNEPV0RVdruKs2MymlfJ2tCUJERopIjojkisgUN8fTRGSZiJSJyGQ3x/1FZLWIfGZnnPURGxFMr4QofR5CKeXzbEsQIuIPTAVGAd2BCSLSvdZph4FHgOfPcZlHgc12xdhQWamxrNp9hKITp7wdilJK2cbOO4iBQK4xZocx5hQwCxjjeoIxptAYkw2c9WCBiCQCo4G/2Rhjg2SmxVFlYLEOd1VK+TA7E0QCkO+yXeDcV1cvAU8BVR6MySP6JEbTOjQQhzYzKaV8mJ3TfbtbAqpOY0NF5Hqg0BizUkQyL3DuRGAiQHx8PA6Ho35ROpWUlNSrbFpUFV9u3MPCRUfw87HVrupbF75O66MmrY9qvl4XdiaIAiDJZTsR2FvHskOBG0XkOiAEiBSRd40xd9Y+0RgzA5gBkJGRYTIzMxsUrMPhoD5lj0bv4dFZa2jbuS99kqIb9J5NVX3rwtdpfdSk9VHN1+vCziambKCLiKSISBAwHphbl4LGmKeNMYnGmGRnuYXukoM3De8Siwg6eZ9SymfZliCMMRXAw8B8rJFIHxpjNorIJBGZBCAi7USkAHgCeEZECkQk0q6YPKl1WBDpSdEs0uchlFI+ytYlR40x84B5tfZNd3m9H6vp6XzXcAAOG8K7aFmpcbz41VYOlpQREx7s7XCUUsqj9Enqi5CVGocxsHir3kUopXyPJoiL0KNDJDHhwdrMpJTySZogLoKfn5CZGsvirQeoqGxyj2sopdRF0QRxkbJS4zh6spw1+UXeDkUppTxKE8RFGtYlBn8/0dldlVI+RxPERYpqFUj/jq31eQillM/RBOEBmamxbNx7jB+OlXo7FKWU8hhNEB6QlRoHwNfazKSU8iGaIDwgrV0E7SJDtJlJKeVTNEF4gIiQlRbLN9sOUq7DXZVSPkIThIdkpsZRUlbBirwj3g5FKaU8QhOEhwztHEOgv+DQZiallI/QBOEh4cEBDExpo89DKKV8hiYID8pKjSPnh2L2FJ30dihKKXXRNEF4UKZzuKs2MymlfIEmCA/qFBtGYutWLNqizUxKqebP1gQhIiNFJEdEckVkipvjaSKyTETKRGSyy/4kEVkkIptFZKOIPGpnnJ4iImSlxrEk9yBlFZXeDkcppS6KbQlCRPyBqcAooDswQUS61zrtMPAI8Hyt/RXAz40x3YDBwENuyjZJWWmxnCyv5Pudh70dilJKXRQ77yAGArnGmB3GmFPALGCM6wnGmEJjTDZQXmv/PmPMKufrYqw1rRNsjNVjLrs0hqAAP21mUko1e3auSZ0A5LtsFwCD6nsREUkG+gLLz3F8IjARID4+HofDUd+3oNWJvRyvCG1QWXdSo4V5q/MYHtE8O6tLSko8Vhe+QOujJq2Par5eF3YmCHGzz9TrAiLhwMfAY8aYY+7OMcbMAGYAZGRkmMzMzPpFeeIw/PVeDoSlEvvAv8A/sH7l3cgL3Mlv/rWJlF4D6Ng27KKv19gcDgf1rkcfpvVRk9ZHNV+vCzubmAqAJJftRGBvXQuLSCBWcnjPGDPHw7FVC20DV/yC2IPL4KN7oOLURV+yerirNjMppZovOxNENtBFRFJEJAgYD8ytS0EREeANYLMx5gUbY7QMnsS2zhNhy2ceSRLJMWFcGhOms7sqpZo12xKEMaYCeBiYj9XJ/KExZqOITBKRSQAi0k5ECoAngGdEpEBEIoGhwI+BK0VkjfPnOrtiBdiTOBquex5y/g0f3gUVZRd1vStSY1m2/RAnT+lwV6VU82RnHwTGmHnAvFr7pru83o/V9FTbt7jvw7DXwJ+CCPz751aSGPs2BAQ36FJZqXHMXJLHdzsOkZUW5+FAlVLKfvokdW0D7ofrX4Stn8MHd0J5w5YRHZjShlaB/trMpJRqtjRBuJPxE7jhZdj2RYOTREigP0M7t2XhlkKMqdfgLaWUahI0QZxL/3vgxr9C7lcw6/YGJYnM1DgKjpxk+4Hjno9PKaVspgnifPrdZSWJ7Qth1gQor9803pmpsYDO7qqUTzqyi7YHs6Gy/MLnNlOaIC6k349hzFTYvgjeHw+nTtS5aGLrULrGh+vzEEr5iqpKyPkc3rsNXu5Drw1/gFcHwPrZUOV769FrgqiLvnfATdNgx9f1ThJZqXEs33mI42UVNgaolLJVSSEsfh5eTof3x8G+dXDFU2zs/hQEhcHH98GM4bDtK/ChPkdNEHWVPgF+9H+Q9w38Yyycqlu/QmZqHOWVhiW5B20OUCnlUcZA3rfw0b3wQndY+Htok2INf398A2T9kgNxQ+G/voGbX4fSY/DeLfD3GyA/29vRe4Stz0H4nD7jrOckPvkv+Mc4uP0D69vDeWQktyY8OIBFOQe4pke7RgpUKdVgpUdh7SxY8SYc2AIh0TBwImTcCzFdzj7fzw96j4XuN8HKt2Dx/8IbV0Ha9TDiVxCb2sh/gOdogqiv3mNB/GDOT612yNs/hODwc54e6O/HsM4xOHKs4a7WLCJKqSZn7xpY8YbVn1B+AhL6w5jXoOfNENjqwuUDgmDQREi/Hb57DZa8AjmDoc/tkPU0RLl7Jrhp0wTREL1ute4kPnYmiTs+Om+SyEqL5fON+8n5oZi0dpGNGKhS6rxOnYCNn1iJYc9KCAy1/v/O+Al06NuwawaHwxVPQcZ98M1fIPt1WP+RNVPD5T+3JghtJjRBNFTPWwCBj++H9251JokIt6eent110ZYDmiCUagoObrOakNa8ZzUpxaTCqP+F3uOgVbRn3iOsLYz8Ewx+ABz/Y91VrHobhjxi7TvPl8qmQjupL0bPm+HWNyH/e3j3FquTyo34yBC6t4/UaTeU8qbKctj4qdWJ/GoGfP86dBoB9/wbHloOg/7Lc8nBVXQS3PQaPLAUUobDoj/AK32t9/fA8gJ20gRxsXrcBLfNtG5Pz5MkstJiWbnrCEdP+u5DNUo1SUf3wMI/wos94aO74fBOuPJZeGKT9f9u8jCrydhucd1g/Htw35dWZ/e8yTB1AKz7qMk+Q6EJwhO6j4Hb3oK9q+Ddm61b1lqyUuOorNLhrko1iqoqa5qc92+Hl3rC4j9D+94w4QN4dC0MnwzhXpplOWmgdddyx2wIioA598P/DYdtXza5Zyg0QXhKtxus8dF718A7P4KTRTUOpydFE9UqkEVbtJlJKdscPwRLXoa/9rPu6POXw9BH4dE1Vj9h6kjw8/d2lNYdS5er4b8Ww81/g1PFVl/mW9dbTdZNRJ0ShIiEiYif83VXEbnRuSTohcqNFJEcEckVkSlujqeJyDIRKRORyfUp2ySljbaSxL51ZyWJAH8/Lu8Sg2PrAaqqmta3BKWaNWNg93KYMxFe6AZf/goi2sMtb1jNSFf9BloneztK9/z8oPdt8FC2tWDZwa3wxtXWnU/hFm9HV+c7iMVAiIgkAAuAe4G3zldARPyBqcAooDswQUS61zrtMPAI8HwDyjZNadfBuHdg/3p45yY4eeTMoazUOA4Ul7Fpn/t+CqVUPZQVQ/YbMH0YvHkNbJlnTbD5wDL4yX+s4aoNXPCr0QUEWcNgH1kNWc9YMzZMuww+fRCK8r0WVl0ThBhjTgA3A381xvwI64P7fAYCucaYHcaYU8AsYIzrCcaYQmNMNlC75/aCZZu01FEw7l34YSO8PQZOHAasZUgBbWZSqiGMsTqYN3wM/3oM/tIN/v2E1Vxz/Uvw8y0w+nmIbx7fJd0KDocrnoRH1sDgB62H9v7aDz7/pdV81sjq+hyEiMhlwB3AfXUsmwC4pr4CYFAd36/OZUVkIjARID4+HofDUce3qKmkpKTBZd0LoU33X9Bzw/9w/LURrO3zOyoCI0iJ8uOf2bn08t/jwffyLM/XRfOm9VFTY9VHUNkhIopziTy2jYjibUQUbyewohiASr8gDsQOZW+HURyL7AolAstW2B5TbbbWRfDVBA9IJznvfdp9N43K7DfJT/oRBYk3UhlQhye7PaCuCeIx4GngE2PMRhG5FFh0gTLuxo3VtfG9zmWNMTOAGQAZGRkmMzOzjm9Rk8PhoKFlzy0TeqcTMet2hm3/f3DXXFaXH+SVhdvoPWAIbcKCPPx+nmFPXTRfWh812VIfxw/B3tXWSMC9q2HPKijZbx0Tf2uIaK+bIKEfdOiHf1x32gUE4e3ZzRrn38ZtULiFgIW/J2XLP0g58CUMf8pa1CzA3s+QOiUIY8zXwNcAzs7qg8aYRy5QrABIctlOBPbWMa6LKdu0dLkKJvzD6nT6+41cddXbvGzgm20HGJOe4O3olGp8pcdg3xorCZxOCkW7q4+37QKXXgEd+lnTXbTrBUGhXgu3SYhLs56hyM+Gr34D/3kSlr0KVz4DPW+1OrttUKcEISL/ACYBlcBKIEpEXjDG/Pk8xbKBLiKSAuwBxgO31zGuiynb9HS+Cia8D7Nup+eXd9Ap9Oc4cjRBqBag/KQ1qs/17uDgNs40CERfYiWCjPusu4P2fSAkyqshN2lJA+CezyB3ASz4jTVp6JKXYcSvrWGzHn7gr65NTN2NMcdE5A5gHvALrERxzgRhjKkQkYeB+YA/8KazeWqS8/h0EWkHrAAigSoReczlvc4q27A/sYnoPAImzELeH8+7gX/gzpxnqKzqg7+fzu6qfETFKSjcZCWCPausZ4IKN4GptI6Hx1vJoNdtzruDdAiL8WbEzZOI1TLR6UrYOMdap2Luw9YDgHWZdbYe6pogAp3PPdwEvGqMKReRC/YnGGPmYSUU133TXV7vx2o+qlPZZq9TFtz+AbHvjeO1il+zaVsfeqW6mV9eqdpKCq3navz8wT8Q/ALAL9D9dmNMG1FVaY3Zd20m2r8BKsus4yHR1h1B18etZqKEfhDZwf64WhI/P2sob7cb4fB2jycHqHuC+D8gD1gLLBaRjoAO5m+ISzM5eev7XDJrHMc/vQ0e+sJ7j/yrputoAeQtgV3fwq6lcCi37mX9As6fQM5s+zv3BTj3nW/beU2E9NzlsGQXlDtXVQwKh/bp1jh+ZycyrZMbJ1Epq6M6rps9l67LScaYV4BXXHbtEpEsWyJqASK6Xcmv2vyeXx75lfVo/d3/goh4b4elvMUYOLLTmRCWWknhdKdtcBR0vMx6ACwywZqRtKoCqsqtb/Fntl1+au+r03YlVJRB1fHq7SqX8yqrz/cLiLHWaT/diRzTpWlMX6E8rq6d1FHAr4Hhzl1fA78Dzp6VTtVJXK8R3PVlCR8c/Qvy99NJwtuD9lSjMMZqntm1pDopFDsH6YW2hY5DYPBD1u/4Hk3uw3eVDvttMeraxPQmsAEY69z+MTAT68lq1QCZqXE8/0U3vh4wnczsB+Ct0XD3ZxDZ3tuhKU+rqrI6a3ctcf4sheMHrGPh7SB5qJUMOg6z1i/WphnVRNQ1QXQyxtzisv1bEVljQzwtRo8OkcRFBPPRwfZk3vmxcybH0dZShxHtrMnGTv9u6WPAm5vKCti/ztlc5EwIpUXWsagka5Ga5KHQcSi0uVQTgmqy6pogTorIMGPMtwAiMhQ4aV9Yvk9EyEyN5fMN+6kYdzUBd86BD+6EL/777JODo5zJolbiqPG7XfOZmMzXVJZbI3nynB3Ku7+zpm8GKwF0u8FKBslDrXH/SjUTdU0Qk4C3nX0RAEeAu+0JqeXISo3jwxUFrM4vYkDyIJi81VpsqHg/FO9z/3vXUut1lZuV6ULb1kwY7pJJWJw1IkU1XHkp7Flh/bfI+xYKsqH8hHUsNs2avrmj8w5BmwxVM1bXUUxrgT4iEuncPuZ8qG2djbH5vKFdYgjwExZtKWRAchurqaFVtPUTl3buglVV1jTiZyWRvdXbP2yEkh/A1F7KUKxhtee5Gwk8pSOYXflVlsL2RdXNRQUrnOP9BeJ7WiOMOjr7EfTBL+VD6vVV0hjj+snxBPCSR6NpYSJDAunfsTWLcg7w1MjzJITa/PwgrK31067nuc+rqrQ6Q891N3Jsj7WW9ukOU6ehABsSIbE/JGRAYoY1zr0l9IXUeABsFexZybB96+CbSmvSuPZ9YNBEKyFcMhhatfZ2xErZ5mLaGrRnzQOy0uJ47j9b2H+0lHZRIZ69uJ9/dXPT+VScguOFZ5JH7ooFdA45ajWjbPqndY74W/PsJ7gkjZhU2yYJaxTGWM8bOBMBe1Zbk8idKrGOB0VAh3Tyk35Ex+ETIGkQBEd4NWSlGtPFJAhdN9MDslKtBOHIKWT8QC91YAYEQVSi9QMU/BBB59Pj3EsKrQ/PghVWwtjwCax8yzoWFAEJfasTRkJG037gr+SAyzxBzt8nDlrH/IOsWUPTb7ceAEvoD207g58fOx0OOnbO9GroSnnDeROEiBTjPhEI0DgrVvi4rvHhdIgKYZE3E8T5hMdZK+SljrK2q6qsaR/2rKhOGktfsZ6yBYhsIk1TZcXWZHGudwdHnU8ni5/Vmdx1pDPB9Ye4HrbPra9Uc3PeBGGM0ftpm4kImWlx/HP1Hk5VVBEU0MSbbPz8ILar9ZPunIH99JTOrknjrKapDOuD2I6mqYoy+GGDdUdw+u7gQA7VU0p3tJLWoInW3UH7PtbSjkqp89Lxjk1AVmoc/1i+mxV5hxnSuRmOgglsBZcMsn5OO6tpag6snGkdu5imqapKaz2BPSurm4l+2ACVp6zjYbFWEuhxc/XEcWFtPfv3KtVCaIJoAoZ0akuQvx+OrQeaZ4Jwp75NU1FJ1ge6a9NUYCuXTmTnj5tOZAY/UN1vEJWoTyYr5SGaIJqAsOAABl3ahkVbCvnldfZM2+t1DWmaCom0nveA6k7kPhOcI6n6WUtTNudRVEo1cbYmCBEZCbyMtSrc34wxz9U6Ls7j1wEngHuMMaucxx4H7sdqSF4P3GuMKbUzXm+6omssf/j3ZvIPnyCpTQt43gAu3DR1vNDqL+jQz3ogTTuRlWpUtn39EhF/YCowCugOTBCR7rVOGwV0cf5MBKY5yyYAjwAZxpieWAlmvF2xNgVXdYtHBJ6cvZbiUjfTaLQUp5umRjwLN/4VBtxv3S1oclCq0dl5fz4QyDXG7DDGnAJmAWNqnTMGeNtYvgOiReT05DUBQCsRCQBCgb02xup1yTFhvDQunRV5R5jw+nccLCnzdkhKqRbOziamBCDfZbsAGFSHcxKMMStE5HlgN9assV8YY75w9yYiMhHr7oP4+HgcDkeDgi0pKWlwWU+JAh7pG8Srq48x+oUFTM4IITa08dvYm0JdNCVaHzVpfVTz9bqwM0G4G0pS+6E7t+eISGusu4sUoAj4SETuNMa8e9bJxswAZgBkZGSYhq505Wgiq2RlAkMHHuEnb2Xz59VVvH1fBmntIhs1hqZSF02F1kdNWh/VfL0u7Px6WgAkuWwncnYz0bnOuQrYaYw5YIwpB+YAQ2yMtUnp37E1H026DD8Rxk5fxoq8w94OSSnVAtmZILKBLiKSIiJBWJ3Mc2udMxe4SyyDgaPGmH1YTUuDRSTUOdJpBLDZxlibnK7xEcx+4DJiwoO5843lLNzyg7dDUkq1MLYlCGNMBfAwMB/rw/1DY8xGEZkkIpOcp80DdgC5wOvAg86yy4HZwCqsIa5+OJuRWpLE1qF8NOkyusRF8NO3V/LJ6gJvh6SUakFsfQ7CGDMPKwm47pvu8toAD52j7K+BX9sZX3PQNjyY9ycOZuLbK3j8g7UcPl7OfcNSvB2WUqoF0MdQm4Hw4ABm3juAUT3b8fvPNvHn+VuwcqtSStlHE0QzERzgz6u392PCwEuYumg7v/xkPZVVmiSUUvbRuZiaEX8/4U8/6knbsCBeXZTLkePlvDQ+nZBAf2+HppTyQXoH0cyICJOvTeVX13fn8437uXdmdsuemkMpZRtNEM3UT4al8NK4dLLzDuvUHEopW2iCaMZu6pvA63dnkFtYwm3Tl5F/+IS3Q1JK+RBNEM1cVmoc790/iEMlZdw6fSk5+4u9HZJSykdogvAB/Tu24aNJ1kwkt01fyspdOjWHUuriaYLwEantIpg9aQhtw4O542/LWbSl0NshKaWaOU0QPiSpjTU1R+e4cH769go+Xb3H2yEppZoxTRA+JiY8mPd/OpiBKW147IM1vPntTm+HpJRqpjRB+KCIkEDevGcAI3u043efbeL5+Tk6NYdSqt40QfiokEB/pt7RjwkDk3h1US6//GSDTs2hlKoXnWrDh1lTc/SiTVgQUxdtp+jEKV4an05wgE7NoZS6ML2D8HEiwpPXpvHs9d35zwZrao6Ssgpvh6WUagZsTRAiMlJEckQkV0SmuDkuIvKK8/g6EenncixaRGaLyBYR2Swil9kZq6+7b1gKL4ztw/Kdh5kwQ6fmUEpdmG0JQkT8ganAKKA7MEFEutc6bRTQxfkzEZjmcuxl4HNjTBrQhxa25Kgdbu6XyOt39WdbYTFjpy+j4IhOzaGUOjc77yAGArnGmB3GmFPALGBMrXPGAG8by3dAtIi0F5FIYDjwBoAx5pQxpsjGWFuMK9Piefe+QRwsKeOWaUvZ+oNOzaGUcs/OTuoEIN9luwAYVIdzEoAK4AAwU0T6ACuBR40xx2u/iYhMxLr7ID4+HofD0aBgS0pKGly2OXqyfyB/WVHKj15dzOP9QujcurrjuqXVxYVofdSk9VHN1+vCzgQhbvbVHmd5rnMCgH7Az4wxy0XkZWAK8OxZJxszA5gBkJGRYTIzMxsUrMPhoKFlm6vMoSf48RvLeX5VKdPu7E9WahzQMuvifLQ+atL6qObrdWFnE1MBkOSynQjsreM5BUCBMWa5c/9srIShPCipTSizHxhCp9hwfvp3nZpDKVWTnQkiG+giIikiEgSMB+bWOmcucJdzNNNg4KgxZp8xZj+QLyKpzvNGAJtsjLXFigkPZtbEwWQkt+axD9Ywc4lOzaGUstiWIIwxFcDDwHysEUgfGmM2isgkEZnkPG0esAPIBV4HHnS5xM+A90RkHZAO/MmuWFu6iJBA3rp3INf2iOe3/9rE7K2nKKuo9HZYSikvs/VJamPMPKwk4LpvustrAzx0jrJrgAw741PVQgL9ee2O/vz3J+uZlZ3Pkj8t4Ka+CYwbkERau0hvh6eU8gKdakOd4e8n/M/NvUg0B9hyqjXvfbebmUvy6JMUzbiMJG7o056IkEBvh6mUaiSaIFQNIkLPGH8ezuzHkeOn+GT1Hj7IzueXn6zn959tYnTv9owbkERGx9aIuBuEppTyFZog1Dm1DgviJ8NSuHdoMmsLjvJB9m7mrtnL7JUFXBobxriMJG7ul0hsRLC3Q1VK2UAThLogESE9KZr0pGievb47/163jw+y8/mf/2zhz/NzGNEtjnEDkhjeJZYAf53/USlfoQlC1UtoUAC3ZSRxW0YSuYUlfLQin49XFTB/4w/ERwZzW/8kxmYkcUnbUG+HqpS6SJogVIN1jgvn6eu6MfnaVBZsLuSD7N285sjl1UW5DOnUlnEDkri2RztCAnX9CaWaI00Q6qIF+vsxsmc7RvZsx76jJ5m9ooAPV+bz6Kw1RIYE8KO+CYwdkESPDlHeDlUpVQ+aIJRHtY9qxc9GdOGhrM58t+MQs7LzeT87n78v20WvhCjGDkjixj4diGqlw2WVauo0QShb+PkJQzrHMKRzDEUnTvHPNXuZlZ3Ps59u4A+fbWJ0r/aMHZDEoJQ2OlxWqSZKE4SyXXRoEHcPSeauyzqyYc8xZjmHy85ZvYfktqGMHZDErf0SiYsM8XaoSikXmiBUoxEReiVG0SuxF8+M7s5/NuxjVnY+//t5Dn/5YitZqbGMG3AJWak6XFappkAThPKKVkH+3NwvkZv7JbLjQAkfrijg41UFfLV5BbERwdzSL5FxA5JIiQnzdqhKtViaIJTXXRobzpRRafz8mq44cg7wQfZuXv9mB9O/3s6VaXHcPyyFyzq11b4KpRqZJgjVZAT6+3F193iu7h7PD8dK+cfy3bz73S5u/9ty0tpFcN+wFG5M70BwgD5XoVRj0IZe1STFR4bw+NVdWTLlSv7fLb2oMoYnZ69j6HOLePmrbRwqKfN2iEr5PFsThIiMFJEcEckVkSlujouIvOI8vk5E+tU67i8iq0XkMzvjVE1XSKA/4wZcwvzHhvPOfQPpmRDJi19t5bLnFjLl43Vs/aHY2yEq5bNsa2ISEX9gKnA11hrT2SIy1xjjunToKKCL82cQMM35+7RHsVaj0xVrWjgR4fIusVzeJZbcwmLeXJLHxysLmJWdz+VdYrhvWApXdI3VfgqlPMjOO4iBQK4xZocx5hQwCxhT65wxwNvG8h0QLSLtAUQkERgN/M3GGFUz1Dkugj/9qBfLnh7B5Gu6krO/mHtmZnPNi4t5//vdlJbrcqlKeYKdCSIByHfZLnDuq+s5LwFPAVU2xaeauTZhQTx8ZRe+/cWVvDC2D0EBfjw9Zz1DnlvIX77IobC41NshKtWs2TmKyd29vqnLOSJyPVBojFkpIpnnfRORicBEgPj4eBwOR/0jBUpKShpc1tc0x7poA0zuZchJDGF+XjmvLszltUW5DG4fwDXJAXSMbPjIp+ZYH3bS+qjm63VhZ4IoAJJcthOBvXU851bgRhG5DggBIkXkXWPMnbXfxBgzA5gBkJGRYTIzMxsUrMPhoKFlfU1zrossYBKQd/A4M5fs5KOVBSzZW8pll7blvmEpXJkWh59f/fopmnN92EHro5qv14WdTUzZQBcRSRGRIGA8MLfWOXOBu5yjmQYDR40x+4wxTxtjEo0xyc5yC90lB6XOJTkmjN+O6cmyKSN4elQauw4d5/63VzDiha95e1keJ05VeDtEpZo82xKEMaYCeBiYjzUS6UNjzEYRmSQik5ynzQN2ALnA68CDdsWjWqao0ED+64pOfP1UFn+d0JfIVoH86p8bGfynBfzPfzaz7+hJb4eoVJNl65PUxph5WEnAdd90l9cGeOgC13AADhvCUy1IoL8fN/TpwPW927Nq9xHe+HYnry/ewRvf7OS6Xu25b1gKfZKivR2mUk2KTrWhWhQRoX/HNvTv2Ib8wyf4+9I8ZmXnM3ftXjI6tua+YSlc06Md/vXsp1DKF+lUG6rFSmoTyjPXd2fZ01fy7PXd+aG4lAfeW8UVf17EG9/upLi03NshKuVVegehWryIkEDuG5bCPUOS+XLTft74die//2wTL365lXEDkrjUVFFVZeo9+kmp5k4ThFJO/n7CyJ7tGdmzPesKinjj2538fWkeFVWG51Z8Qe+kKNKToklPak2fpCjiInQFPOXbNEEo5UbvxGheHt+Xp0d14/V/fUNpWDvWFhTxf1/voKLKet4zIboVfZxJo09iNL0SowgN0v+llO/Qf81KnUe7qBAuTwwkM7MXAKXllWzce5TVu4tYW3CUNflHmLd+P2DdgXSNjyD9dNJIiqZLXIR2eKtmSxOEUvUQEuh/ZhTUaYdKylhbUMSa3UWsKTjKvPX7ef97a4qx0CB/eiVEkX5JNOmJ0aRfEk37qFbeCv+iGGMoLdep0VoSTRBKXaS24cFcmRbPlWnxgPVBmnfoBGvyj7A2/yir84uY+W0epyqtD9f4yGD6OJNFurNpKiIk0CuxG2M4drKCAyVlHDz9U1xmbRefqt5XcooDJWWcqqiia2s/gpMOcVmntl6JWTUeTRBKeZiIkBITRkpMGD/qmwhAWUUlm/cVs2b3EWfTVBFfbPrBeT50jg0/0yyVnhRNarsIAv0bNgq9qspQdLK85od9yakz2wddtg+VnDqTuFz5iZX4YsKDiQkPolNsODERwQT5+/Hu0u1MeP07hnRqy+NXd2VAchs3UShfoAlCqUYQHODvHAEVfWZf0YlTVrLYXcTagiIWbCnko5UFAIQE+tGzQ1SNpNEqyN/5IV/9zd71m/4B54f/4eOnznSkuwrwE9qGBzk/9IPpGh9BTEQQsc7t2IjqhNA6NOicw3p7B+wlPziZaY5cbpu+jMu7xPD41V3pd0lrW+pOeY8mCKW8JDo0iCu6xnJF11jAau4pOHKS1flFrM0vYk1+Ee98t4u/fbvznNcI8vcjJjyImIhg2kWF0DMh8kwCiImwPuxPJ4CoVoEeeZYjyF+4b1gKEwYm8e53u5j+9Q5ufm0pWamxPH51V3onRl/0e6imQROEUk2EiJDUJpSkNqHc2KcDAOWVVeTsL2ZNfhGVVebMN/wY57f9yJAAry2zGhoUwMThnbhjUEf+viyPGYt3cOOrS7iqWzyPX92FHh2ivBKX8hxNEEo1YYH+fvRMiKJnQtP9sA0LDuDBzM78eHBH3lqSx+vf7GD0Kz8wqmc7HruqK6ntIrwdomogTRBKKY+ICAnkZyO6cNeQZN74didvfruTzzfuZ3Sv9jx2VRc6x2miaG50sj6llEdFtQrkiau78u0vsngwsxMLtxRy9YuLeWzWanYcKPF2eKoeNEEopWwRHRrEk9em8c1TWUwcfinzN/7AVS98zeSP1rL70Alvh6fqwNYEISIjRSRHRHJFZIqb4yIirziPrxORfs79SSKySEQ2i8hGEXnUzjiVUvZpGx7M06O6sfipLO4dmsK/1u7lyr84mPLxOgqOaKJoymxLECLiD0wFRgHdgQki0r3WaaOALs6ficA05/4K4OfGmG7AYOAhN2WVUs1IbEQwz17fncVPZXHn4I7MWbWHrOcd/Pcn63Xp1ybKzjuIgUCuMWaHMeYUMAsYU+ucMcDbxvIdEC0i7Y0x+4wxqwCMMcVYa1on2BirUqqRxEeG8Jsbe/D1U5mMG5DEhyvyueJ/Hfxm7kZ+OFbq7fCUC7GWhbbhwiK3AiONMfc7t38MDDLGPOxyzmfAc8aYb53bC4BfGGNWuJyTDCwGehpjjrl5n4lYdx/Ex8f3nzVrVoPiLSkpITw8vEFlfY3WRU1aHzV5uj4OnqziX9vL+XZPBX4CVyYFcN2lQUQFN/1ZcH3h30ZWVtZKY0yGu2N2DnN191+3djY67zkiEg58DDzmLjkAGGNmADMAMjIyTGZmZoOCdTgcNLSsr9G6qEnroyY76uNWYPehE/x14TbmrN7D13tLufuyZCYOv5S24cEefS9POXmqkvmLvmbY5cMJaOC8WU2dnQmiAEhy2U4E9tb1HBEJxEoO7xlj5tgYp1KqCbikbSh/vq0PD2Z15pUF23j9mx28890u7h2azE8vv5To0CDbY6iqMhw5cYrCYmtuq+rfpWe2Dzp/l5RVAPC44z+0DQsiNiKEuAhrTqu40z+RIc7XIcRGBNMqyN/2v8GT7EwQ2UAXEUkB9gDjgdtrnTMXeFhEZgGDgKPGmH1izR3wBrDZGPOCjTEqpZqYlJgwXhyXzkNZnXh5QS6vObbz96W7+MmwFO4blkJUq/pPjV5aXlnjA/+Aywe+6++DJWVuJzoMC/InLjKE2PBgunWIZHh4MHGRwezdtZM2HTrWuF7O/uJzXiciOIDYyOAaScNKJNb26f2Rrbw3hYor2xKEMaZCRB4G5gP+wJvGmI0iMsl5fDowD7gOyAVOAPc6iw8FfgysF5E1zn2/NMbMsytepVTT0jkugr9O6MvDWZ15ecFWXlmwjZlLdvLTyy/l3qHJhAcHUHSinAMlZRQeK+NASan12803/2OlFWdd//SU5rHOD/u0dhHERVrbsREhLq+DCQt2/1HpcBSQmdn1rP1VVYbDJ06diaXwWOlZMa0tKKLwWBknyyvPKh8U4HcmrtNJ48zdiUsyaRsebOuKhbZOteH8QJ9Xa990l9cGeMhNuW9x3z+hlGphUttF8Nod/dm09xgvfbWVF77cymuOXCqrDOWVZ39LbxXof+bDPbVdBMM6x5z59h8bWZ0Q2oQG2dZ34OcnZ2bV7db+3OcZYygpq6hxJ1N4rPpupLC4lJ0Hj7N852GKTpSf/T4CbcKCSYkJ5aNJQzz+d+hcTEqpZqF7h0hm3JXB+oKjzF6ZT6uggBpt/rHONv+wIP8m0TxTFyJCREggESGBdIo9/2iosorKs5vFnHcmdtEEoZRqVnolRtErsenObmuX4AB/EluHktg6tNHe0zfHZimllLpomiCUUkq5pQlCKaWUW5oglFJKuaUJQimllFuaIJRSSrmlCUIppZRbmiCUUkq5Zdt6EN4gIgeAXQ0sHgMc9GA4zZnWRU1aHzVpfVTzhbroaIyJdXfApxLExRCRFedaNKOl0bqoSeujJq2Par5eF9rEpJRSyi1NEEoppdzSBFFthrcDaEK0LmrS+qhJ66OaT9eF9kEopZRyS+8glFJKuaUJQimllFstPkGIyEgRyRGRXBGZ4u14vElEkkRkkYhsFpGNIvKot2PyNhHxF5HVIvKZt2PxNhGJFpHZIrLF+W/kMm/H5E0i8rjz/5MNIvK+iIR4OyZPa9EJQkT8ganAKKA7MEFEuns3Kq+qAH5ujOkGDAYeauH1AfAosNnbQTQRLwOfG2PSgD604HoRkQTgESDDGNMT8AfGezcqz2vRCQIYCOQaY3YYY04Bs4AxXo7Ja4wx+4wxq5yvi7E+ABK8G5X3iEgiMBr4m7dj8TYRiQSGA28AGGNOGWOKvBqU9wUArUQkAAgF9no5Ho9r6QkiAch32S6gBX8guhKRZKAvsNzLoXjTS8BTQJWX42gKLgUOADOdTW5/E5EwbwflLcaYPcDzwG5gH3DUGPOFd6PyvJaeIMTNvhY/7ldEwoGPgceMMce8HY83iMj1QKExZqW3Y2kiAoB+wDRjTF/gONBi++xEpDVWa0MK0AEIE5E7vRuV57X0BFEAJLlsJ+KDt4n1ISKBWMnhPWPMHG/H40VDgRtFJA+r6fFKEXnXuyF5VQFQYIw5fUc5GythtFRXATuNMQeMMeXAHGCIl2PyuJaeILKBLiKSIiJBWJ1Mc70ck9eIiGC1MW82xrzg7Xi8yRjztDEm0RiTjPXvYqExxue+IdaVMWY/kC8iqc5dI4BNXgzJ23YDg0Uk1Pn/zQh8sNM+wNsBeJMxpkJEHgbmY41CeNMYs9HLYXnTUODHwHoRWePc90tjzDzvhaSakJ8B7zm/TO0A7vVyPF5jjFkuIrOBVVij/1bjg9Nu6FQbSiml3GrpTUxKKaXOQROEUkoptzRBKKWUcksThFJKKbc0QSillHJLE4RS9SAilSKyxuXHY08Ti0iyiGzw1PWUulgt+jkIpRrgpDEm3dtBKNUY9A5CKQ8QkTwR+X8i8r3zp7Nzf0cRWSAi65y/L3HujxeRT0RkrfPn9DQN/iLyunOdgS9EpJXX/ijV4mmCUKp+WtVqYhrncuyYMWYg8CrWTLA4X79tjOkNvAe84tz/CvC1MaYP1pxGp5/g7wJMNcb0AIqAW2z9a5Q6D32SWql6EJESY0y4m/15wJXGmB3OCQ/3G2PaishBoL0xpty5f58xJkZEDgCJxpgyl2skA18aY7o4t38BBBpj/tAIf5pSZ9E7CKU8x5zj9bnOcafM5XUl2k+ovEgThFKeM87l9zLn66VUL0V5B/Ct8/UC4AE4s+51ZGMFqVRd6bcTpeqnlctMt2Ct0Xx6qGuwiCzH+uI1wbnvEeBNEXkSa0W20zOgPgrMEJH7sO4UHsBamUypJkP7IJTyAGcfRIYx5qC3Y1HKU7SJSSmllFt6B6GUUsotvYNQSinlliYIpZRSbmmCUEop5ZYmCKWUUm5pglBKKeXW/wfFaLAVr51vIQAAAABJRU5ErkJggg==\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": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 15;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/logger_csv_plot_basic.py\\nimport pandas as pd\\nimport matplotlib.pyplot as plt\\n\\n\\nmetrics = pd.read_csv(f\\\"{trainer.logger.log_dir}/metrics.csv\\\")\\n\\naggreg_metrics = []\\nagg_col = \\\"epoch\\\"\\nfor i, dfg in metrics.groupby(agg_col):\\n    agg = dict(dfg.mean())\\n    agg[agg_col] = i\\n    aggreg_metrics.append(agg)\\n\\ndf_metrics = pd.DataFrame(aggreg_metrics)\\ndf_metrics[[\\\"train_loss\\\", \\\"valid_loss\\\"]].plot(\\n    grid=True, legend=True, xlabel=\\\"Epoch\\\", ylabel=\\\"Loss\\\"\\n)\\ndf_metrics[[\\\"train_acc\\\", \\\"valid_acc\\\"]].plot(\\n    grid=True, legend=True, xlabel=\\\"Epoch\\\", ylabel=\\\"ACC\\\"\\n)\\n\\nplt.show()\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/logger_csv_plot_basic.py\\nimport pandas as pd\\nimport matplotlib.pyplot as plt\\n\\n\\nmetrics = pd.read_csv(f\\\"{trainer.logger.log_dir}/metrics.csv\\\")\\n\\naggreg_metrics = []\\nagg_col = \\\"epoch\\\"\\nfor i, dfg in metrics.groupby(agg_col):\\n    agg = dict(dfg.mean())\\n    agg[agg_col] = i\\n    aggreg_metrics.append(agg)\\n\\ndf_metrics = pd.DataFrame(aggreg_metrics)\\ndf_metrics[[\\\"train_loss\\\", \\\"valid_loss\\\"]].plot(\\n    grid=True, legend=True, xlabel=\\\"Epoch\\\", ylabel=\\\"Loss\\\"\\n)\\ndf_metrics[[\\\"train_acc\\\", \\\"valid_acc\\\"]].plot(\\n    grid=True, legend=True, xlabel=\\\"Epoch\\\", ylabel=\\\"ACC\\\"\\n)\\n\\nplt.show()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "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": "0f56851c",
   "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": "3d758dc5",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Restoring states from the checkpoint path at logs/my-model/version_27/checkpoints/epoch=9-step=2139.ckpt\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "Loaded model weights from checkpoint at logs/my-model/version_27/checkpoints/epoch=9-step=2139.ckpt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "91a89ae0becc401f9a393fec58e86dd1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------\n",
      "DATALOADER:0 TEST RESULTS\n",
      "{'test_acc': 0.9789000153541565}\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[{'test_acc': 0.9789000153541565}]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 16;\n",
       "                var nbb_unformatted_code = \"trainer.test(model=lightning_model, datamodule=data_module, ckpt_path='best')\";\n",
       "                var nbb_formatted_code = \"trainer.test(model=lightning_model, datamodule=data_module, ckpt_path=\\\"best\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "trainer.test(model=lightning_model, datamodule=data_module, ckpt_path='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3710fce6",
   "metadata": {},
   "source": [
    "## Predicting labels of new data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "845d2600",
   "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": "5fa39e10",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logs/my-model/version_27/checkpoints/epoch=9-step=2139.ckpt\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 17;\n",
       "                var nbb_unformatted_code = \"path = trainer.checkpoint_callback.best_model_path\\nprint(path)\";\n",
       "                var nbb_formatted_code = \"path = trainer.checkpoint_callback.best_model_path\\nprint(path)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "path = trainer.checkpoint_callback.best_model_path\n",
    "print(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "ff0a16e7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 18;\n",
       "                var nbb_unformatted_code = \"lightning_model = LightningModel.load_from_checkpoint(path, model=pytorch_model)\\nlightning_model.eval();\";\n",
       "                var nbb_formatted_code = \"lightning_model = LightningModel.load_from_checkpoint(path, model=pytorch_model)\\nlightning_model.eval()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "lightning_model = LightningModel.load_from_checkpoint(path, model=pytorch_model)\n",
    "lightning_model.eval();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e70777e",
   "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": "b45e1a54",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 19;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/datamodule_testloader.py\\ntest_dataloader = data_module.test_dataloader()\\nacc = torchmetrics.Accuracy()\\n\\nfor 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\\npredicted_labels[:5]\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/datamodule_testloader.py\\ntest_dataloader = data_module.test_dataloader()\\nacc = torchmetrics.Accuracy()\\n\\nfor 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\\npredicted_labels[:5]\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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": "4f61530a",
   "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": "f09b25cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy: 0.9789 (97.89%)\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 20;\n",
       "                var nbb_unformatted_code = \"test_acc = acc.compute()\\nprint(f'Test accuracy: {test_acc:.4f} ({test_acc*100:.2f}%)')\";\n",
       "                var nbb_formatted_code = \"test_acc = acc.compute()\\nprint(f\\\"Test accuracy: {test_acc:.4f} ({test_acc*100:.2f}%)\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_acc = acc.compute()\n",
    "print(f'Test accuracy: {test_acc:.4f} ({test_acc*100:.2f}%)')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c295fa7",
   "metadata": {},
   "source": [
    "## Inspecting Failure Cases"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "292df05e",
   "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": "5aa9198f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 21;\n",
       "                var nbb_unformatted_code = \"# In the case of MNIST, the class label mapping\\n# is relatively trivial\\nclass_dict = {0: 'digit 0',\\n              1: 'digit 1',\\n              2: 'digit 2',\\n              3: 'digit 3',\\n              4: 'digit 4',\\n              5: 'digit 5',\\n              6: 'digit 6',\\n              7: 'digit 7',\\n              8: 'digit 8',\\n              9: 'digit 9'}\";\n",
       "                var nbb_formatted_code = \"# In the case of MNIST, the class label mapping\\n# is relatively trivial\\nclass_dict = {\\n    0: \\\"digit 0\\\",\\n    1: \\\"digit 1\\\",\\n    2: \\\"digit 2\\\",\\n    3: \\\"digit 3\\\",\\n    4: \\\"digit 4\\\",\\n    5: \\\"digit 5\\\",\\n    6: \\\"digit 6\\\",\\n    7: \\\"digit 7\\\",\\n    8: \\\"digit 8\\\",\\n    9: \\\"digit 9\\\",\\n}\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# In the case of MNIST, the class label mapping\n",
    "# is relatively trivial\n",
    "class_dict = {0: 'digit 0',\n",
    "              1: 'digit 1',\n",
    "              2: 'digit 2',\n",
    "              3: 'digit 3',\n",
    "              4: 'digit 4',\n",
    "              5: 'digit 5',\n",
    "              6: 'digit 6',\n",
    "              7: 'digit 7',\n",
    "              8: 'digit 8',\n",
    "              9: 'digit 9'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "16a6db06",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAEbCAYAAAAWFMmuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABm+klEQVR4nO2dd5ysVXn4v2d62957v5cOIggo4FUUDAqogAUsRI0xWGKMMepPBdEolhhUJCZqMJYIgkCkChiKBZUrSOfe7b3vzO6UnX5+f8yed8vdvrM7M7vn+/ns5+7OnHnnvM897/u8z3makFKi0Wg0Gk06MWV6AhqNRqPZfWjlotFoNJq0o5WLRqPRaNKOVi4ajUajSTtauWg0Go0m7WjlotFoNJq0s+PKRQjxQyHEF+d+P0sIcWidn1v32L2Glml60fJML1qe6SVX5Lku5SKE6BFCzAohAkKIUSHEjUIIz1a/XEr5Gynl/s2MnZvTa1aZ8+Vz81U/ISGEFEK8dKvzTgc5KtPThRAPCCGmhBDjQohbhBBVW51zOshRedqEELfOjZNCiANbnW+6yEV5zo05Rwjx4tz1/pAQomGrc04HuSrPBWOvmluj6xoPG7NcLpBSeoCTgVOBz2zgszuOlPKnUkqP+gGuBLqAJzI8tYXklEyBIuA/gUagAfADN2ZyQkvINXkC/BZ4BzCS6YksQ07JUwhRCtwGfBYoBg4CN2d0UovJKXkqhBAtwCXA8EY+t+FtMSnlIHAvcNw6J/YSIcQTQgi/EOJmwLHgvQNCiIEFf58shHhybuwtQoibF5h/xlghxI+BeuDOuSeBT6xjKu8GfiSzsCRBrshUSnmvlPIWKeWMlDIEXA+8Ygunvi3kkDyjUsrrpJS/BRJbOeftJFfkCbwZeG5ujYaBq4EThRBHbe7Mt4cckqfieuCfgehGznPDykUIUQecDzw59/cnhRB3rTDWBtwB/JjUk8QtwMWrjL0d+OHc2J8Bb1purJTynUAfc08CUsqvrjHnBuBs4Eern11myEWZznE28Nw6xu0oOSzPrCSH5Hks8NSCzwSBzrnXs4YckidCiEuBqJTynnWenoFlA2PvEELEgWngbuBLc5O8dpXPnA5YgevmLIZbhRAfW2WsBfjW3NjbhBB/2sD8VuNdwG+klN1pOl66yFmZCiFOAD4HXJSO46WJnJVnlpJr8vQA40temwbytnDMdJJT8hQpn9CXgHM38/mNKJc3Sikf3ODxq4HBJVtRvRsY27/B71uJdzH3H5ll5KRMhRCtpMz6v5dS/marx0sjOSnPLCbX5BkA8pe8lk/KN5gN5Jo8Pw/8eLMP5dsdijwM1AghxILX6jcwtm6VY6/LdyKEeAUpod+6nvE5QEZlOrfF+CDwBSnlj9canwNkfI3uMjIpz+eAE9UfQgg30EIWbt1ugEzK8xzgI0KIESHEyNyxfi6E+Oe1Jg3br1weA+KkJmgRQrwZeNkqYxPAh+bGXrTKWIBRoHkdc3g38AspZbY8vWyVjMlUCFED/B/wHSnldzc1++wjo2tUCGEXQigHrU0I4Vhyc8g1MinP24HjhBAXz8n0c8DTUsoXN3wW2UMm5XkOqaCDk+Z+hoC/Bb6znolvWbkIIT4thLh3ufeklFFSERxXAF7graRCBVcb+17ARyo88y4gssJXfxn4jBDCJ4T4+ApzcwBvAf57naeTFWSxTN9HajFeJRbkEK33vDJFFssT4BAwC9QAv5r7PStyM1YiW+UppRwn5ez+l7nvPg1423rPK1NksTwnpZQj6oeU4vJKKdd1zYssjMw1EEL8EfiulDKbcilyGi3T9KLlmV60PNNLJuWZVbXFhBCvFEJUzpl07wZOAO7L9LxyGS3T9KLlmV60PNNLNslzI9FiO8F+4OekQgo7gUuklBvKCtUcgZZpetHyTC9anukla+SZ1dtiGo1Go8lNsmpbTKPRaDS7g0yU3H9YCPG+ud8vF0Lcv87PrXvsXkLLM/1omaYXLc/0kjPylFKu+UMq81X9JEmFS6q/L1/PMRYc62HgfRv5zArHkUDrKu9/esm8Z+fmXrrV707D3HNRnq8nVcHXR6qC7/eAvEzLMsdlWgX8klT+gAQaMy3HXJbn3JjLSGWwB0nV5CrOtCxzWZ4Lxt64kfFSyvVZLnJx6fqFxc48UsqfrucYO42U8ktL5v0V4GEp5UQWzC3n5AkUAF8kVe3gaKAW+FpGZ7SAHJVpklQkz7KFCDNJLspTCHEs8B/AO4EKIATckNFJzZGL8lQIIc4kVelgQ2z7tpgQ4rUi1bxnWghxPSAWvHeFEOK3C/4+VwhxaG7sDUKIRxaYf8ZYIcSjcx95ai6R761rzEGQWnA5lUy5HJmSp5Tyf6SU90kpQ1JKLynLJevK7W+GDMp0VEp5A/D4tp7gDpPBa/5y4E4p5aMylej3WeDNQohsKVy5KTJ5DxVCWIBvAx/a6LzTkaF/gxBi2acDkWre8wtSTXFKSYXGLXtDmht7K/ApoIRU5vLLlxsrpTx77tcT5zT/Wg2BziL1JPOLNcZlnByRJ2Rpuf3lyCGZ5gRZLM+lJfc7SfUg2beO08oYWSxPgH8AHpVSPr3O0zHYsnKRUl4ppbxyhbfPB56XUt4qpYwB17Fyx73zSTX6uU1KGQe+tcrYjfJu4Fa5zrIFmSQX5CmEeC0pmX4uHcfbbnJBprlEFsvTQ6qc/UKyqeT+smSrPEWq78zfssnrfLu3xapZUPJZpjxDK5WAXm7swApj140Qwglcyi7YEiM75Hk68D+kkrMOb/V4WUDGZbrLyKQ8s73k/mbIpDyvA66RUi5V2OtiJ0ruGyWf53wfK5WAHiblJF44tnaFsRvhzcAUqQiLXCej8hRCvIRUdNN7pJS/3sqxsohsWKO7iUzKc2nJ/WbADuTyQ1Am5XkO8DUxX3If4DEhxGXr+fB2K5e7gWOFEG+ecwx9BKhcZezxQog3zo394CpjYWMl9380p8VznYzJUwhxHKnIpg9LKe/c1Oyzk4yuUZGq3G2f+3Nh+f1cJZPy/ClwgRDiLJHq5XINcJvM7XYbmZTnPlLK+qS5H4ALSLU2WJN0OPS/K4RYtrfHXNjvpcC1wCTQBvxujbFfnRt7DHCQlctFXw38t0iVi37LCnOrAV4N/Gi955Npslie/wiUAT8Q8+X2c8Whn60yhfl8B4AX5/7OarJVnlLK54APkFIyY6R8LSv5MrKGLJbnmFxcch9gQkq5rjWatbXFhBAmUvuFl0spH8r0fHIdLc/0o2WaXrQ800um5ZlVtcWEEOcJIQqFEHZSGfYC+EOGp5WzaHmmHy3T9KLlmV6ySZ5ZpVyAM0jFcU+Q2tt743pNMM2yaHmmHy3T9KLlmV6yRp5Zuy2m0Wg0mtwl2ywXjUaj0ewC1upEudvNGrH2kLSi5Zl+tEzTi5Znetmz8tSWi0aj0WjSjlYuGo1Go0k7WrloNBqNJu1o5aLRaDSatLOWQ1+TpSSTSfx+P8lk0mgrGovFSCQSzM7OkkwmATCZTHg8HsxmMzabDYvFgtPpxGTSzxUajWb70MolR/H7/dx///34fD5isRiRSIT+/n58Ph9//vOfCYVCAOTl5XHgwAHKyspobm6mpKSEM844A7fbneEz0Gg0uxmtXHKMRCLB1NQU4+PjdHR04PV6DeUyMDCAz+ejvb2d2dlUUm5eXh61tbX4fD5MJhOzs7OEw2EcDgdmsznDZ5P7xONxotEoo6OjJJNJCgsLsVqteDwebR0ug5SSRCLB9PQ00WiUYDCIlBKbzYbVaqW4uBir1arX5i5AK5ccY2pqiv/4j/+gq6uLhx9+mEAggJSSZDJJPB4nkUgQicwXQQ0GgzzyyCM4HA6efPJJmpqaOOGEE0gmkxQXF+uLeAvE43FGRkbo6enhM5/5DJFIhLe97W00Njby6le/mry8rG6AuONIKYlEIkxOTnLLLbfQ19fHww8/TCwWo6Ghgbq6Oj7wgQ9QVVVFSUmJXps5jlYuOYKyWAYGBujo6KC7u5vx8XGCwaAxxmazIYQgPz8fIQSJRIJEIkEgECAcDmO1WnG73UxOTpKXl0dBQYG+gLdAMpkkGAzi9Xrp6ekhHA4zPT1NKBRCl1U6Eikl8XicUChET08PnZ2ddHZ2Eo1GicVixGIxJicncbvdFBYW6rW5BOVXVXIymUxUVlZisWzsNi6lJBwOA2CxWDCZTNsia61ccgRlsXR0dPDggw8aNzGFzWajsrKS/Px8jj32WKxWK+Pj40xPT/P0008TCoUYHx9HCMFvf/tbRkdHKS8vx2azZfCscptoNEp/fz/9/f3E43EsFgtFRUUUFhbqLbFlSCQS+Hw+BgcHefjhh+nt7WV2dhYpJb29vYTDYf785z/j8/moqKjQa3MJsViMvr4++vv7ueGGG3A4HFx77bXU1NRs6DjhcJjnn3+eRCJBVVUVDodjW3YxtHLJctTTit/vp6uri56eHqanpwkGg8Y+dUlJCU6nk+rqagoKCti3bx8Wi4XCwkImJibo7OwkkUgQjUaJRCLMzMwwMzNjRJRpNoeK2AsEAiSTSex2O/n5+eTl5emn7iUkk0mi0SjDw8MMDQ3h8/kIBALGe5FIhEgkQjAYJBQK6bW5DEo5T0xM0Nvbi9vtJhaLbeo4k5OTxva5x+MhPz9fK5e9RiwWo6enh46ODh5//HH6+voIh8PYbDaqqqqor6/nQx/6EFVVVRQWFho3OJPJZESQjY+P09PTQ39/P4lEgmAwSDAY1BfwFonFYvT39zM4OIjZbKagoICXvvSltLS04HDkerfi9KGU8NDQED/4wQ/o6urC6/Vmelo5RyQS4bnnnqOrq4tAILBpyy4cDvPUU08xNjZGOBymrKyMv/u7v6OsrCyt802bcpFSMjs7SywWM548zGYzQqTqmpnNZpxOJ2az2Xh9o3uFe5FkMkkoFCIYDBIIBJidnTVyVRoaGmhqaqK1tZWqqio8Hg8WiwW73U4ymcTr9WK1Wo3/A0jlvTgcDhwOx6LXNetH+Q5mZ2cZHx9namoKl8tFQUEBHo8Hp9OZ6SlmBclkkkAgQCQSYXx8nIGBAXp7exkaGlr2iTuZTBIOh5mdnWV6ehrAiBxT/sS9TDweZ2pqiqmpKRKJxKaPoyL2VJSj2h2RUqZVxmm7u8/OznLw4EFGR0f5zW9+w+zsLPn5+UbiXl5eHqeffjr5+fkUFBRgt9spLy/XCmYNVNjm9PQ0iUQCs9lsWCwf//jHaWxspKmpCbvdjslkQgiBEIJAIMD9999PR0cH7e3tjI+PE4vFcDgcHH/88bS1temn600Sj8cZGBigq6uLX/3qV3i9Xk444QRaWlq0YllAIBDg17/+NSMjIxw8eJDx8XGeeOIJ/H4/8Xj8iPHRaJTDhw8bW7aFhYXU1NQYW712uz0DZ5EdqIfMp59+mu7ubsMhvxlsNhsNDQ0IIXjmmWeIxWIEg0EikQh2uz1tCiZtd/ZYLMbAwAADAwNGnkVBQQEWiwWr1UpeXh7FxcXk5+dTWFiI0+lkdnZ2S047ZQXl5eUZ37Pbnm5MJhN2ux2Px0N9fT0ej4eamhrq6upobGykurp62ZyVWCzG0NAQQ0NDhEIhotEoUkpMJhNOpxOn07nrZLVTqCgxv99v+A7Kysr0w9IS1JZuf38/3d3deL1egsHgin4C9WQO836AWCxGcXExNTU1CCF25TW+FslkktnZWQKBAFNTU0xPT+NyuTadS6V2jcxmM6FQCIvFQjweT/s2edquhOnpaW699VY6Ozvp6+sjFosZNzz1NH333XdjtVpxuVw4HA4aGho2rVyUw7qkpITzzjuP8vJyGhsbd12EicPh4MQTT2Tfvn00NTURi8XIy8vD4XBQX1+PzWZb1hE3OzvL448/Tnt7+4pPiprNEY/HGR0dZXh4mFAohNVq5ZRTTqG1tVVbLgvw+XzcfPPNRrix2opZiXA4zBNPPIHZbOb3v/89NpuNiooKamtrcTqd1NbWbumekatEIhFefPFFOjo6eOGFF/D7/bz2ta+lra1tU+tNWUEqci8QCBgPoOncLk/rY5bZbMZiseB2u43QTMDQiir+f3p6GpvNZoxZOG7VyVosJJNJksmkEfbp8/kYGxvDarVSV1eXztPJCoQQOJ1ObDYbTU1NJJNJw1JRW2ELUc5TtTfr8/lIJpMIIbDZbDgcDpxOZ1rN371GPB5nYmKCyclJI0qsqKiIoqIiHSVGSj6Tk5MMDQ0xOjrK5OTkmmtN+WGV8gkEApjNZuPe0d7eTjwep7q6es8oF+XbCwaD9Pb20tfXRyQSwWKxUFtbS01NDVardcPHTSQS+P1+/H4/kUjEUPzpzs1Km3IpKiri3e9+NxMTE/T09ABQVVUFwNDQEIFAgP7+fmZmZjh06BCzs7N0d3cjhKC4uBhI5XIsp2CU0vJ4PEDKSlKKqbi4mPLyclpbWzetyXMBs9lMSUmJsbUFLGsS+/1+fvWrX9HR0UFHR4fha1HKqbW1lf3791NXV7dnLtJ04/f7ue++++ju7sZut1NVVUVLSwuNjY2buth3G5OTk3zzm9+kvb2dqampNW9aZrPZ2OJxOp1GwnA0GmVychKfz8c111xDW1sbN954456pi6d8ez09PXznO99haGgIs9lMY2MjF154IQ0NDcY9cSOoaLH29vYt+W7WIm3KxWq1Ultba/g/AKqrqwFwu90Eg0Hsdjt+v9/QnKOjowghqKioAFI3y6VREEIITCYTVquVoqIiotEoPp+PaDRqhOSGw2HDp7CbWe2pWGXdTk9P093dbSSoqe1Jh8NBVVUV1dXVeDweHS22SeLxOJFIhNHRUSYmJgyL0Ol07nmZqvIufr+f/v5+BgYGVt0GM5vNuN1u7HY7xcXFhhxjsRhCCMLhMH6/3/Afut1uvF4vJSUluN3uXZ+oGo/HGR8fZ3h4mOHhYXw+H42NjdTU1FBaWropSzmZTBoZ/l6vd1u3y9OmXOx2O0cddRTJZJKTTjopdfAl22KxWMxw2i20XJqbmwHo7OxcVBcLMJx4NpuN6upqRkZG+H//7//R399PIBDAYrFQVlZGaWnpnnamqqeRrq4ubrrpJoaHh/F6vUgp8Xg8VFdXc+mll9Lc3ExpaakO7dwEartneHiYrq4uBgcHKS0txWq1Yrfb97xMI5EIhw8fpqenh76+PkZGRozw1uXk4vF4OHDgAOXl5Rx//PG43W5cLpeRzzE8PMxdd91lhCWHQiEefvhhBgcHOXDgwKae2nMJv9/P3XffbViAbreb9773vbS0tFBZWbnhrW0ViDI1NcULL7xAd3f3ppIw10va7sZCiHWFtiaTSfLz8wmHw8Y+a0NDg3GMlZSLxWIhPz+faDRqfE496RQWFlJQULDrn2RWQ2XvTk5OMjU1ZVRLttlsFBQUUFJSQk1NDVVVVXsy4iYdqLwNv99POBwmFosZUTcqDHyvovJ++vr66O3tZWZmhnA4vCgCyWQyYbFYDD9iSUkJTU1NVFVV0dzcjNvtxul0Eg6HCQaDhsWtEn6j0Si9vb1YLBaOO+44kskkbrd71/m5VM7g9PQ0AwMDhpJ2Op3U1NRQU1OzqQcZtd04OTnJ7Oys4cB3OBxGjbF0suOP+iaTCZfLhdPpNJ481D71Mcccs+zWlhCCUCjEU089ZZSZj0QiVFVV0dTUxMtf/nIaGhp2rb9lPagLr6enx9gOA3A6nZx66qm0trZy4okn6ppNWyASiXDo0CHa29uJRCIIIYyQ2b38YKMsut7eXm644QZ6enqMLbGF2y4qCKegoIBTTjmF2tpa3va2t1FWVmaUzBFCEIvFqKiooKuri3vvvZdIJEIgEGBmZoZbb72V8vJyotGoUX16O0qXZBKVM9jV1cXBgwcZGxsjPz+fmpoaWltbaWho2JRvb6ElFAwGcTgc7N+/n3379hnpIVmZRLkR1IW4dEGstEBUpNng4CCDg4NEIhHMZjMVFRVUVVVRVFREXl7enrzA1Tbj2NgYQ0NDhgPfbDbjcrkoLCykrq6Ouro68vLy9nQi2lZRkXgqyU8FlOgosVROy+zsLMPDw4yMjBCJRAzFoiwVl8tFY2MjJSUltLa2UlNTQ2VlJYWFhYuexG02G0VFRZSUlFBWVmbUG1NKDFJb6JDaKlOdVXeL5ah8LaOjo8zMzBCJRKirq6OkpASXy7Wph0NlWQ4MDDA4OEg8HsdqtVJVVWVssS2sqJIOst5JkUwmmZmZoa+vj5/85Cd0dnbi8/koKiri9a9/Pfv27aOysnJPOPiWY2pqiuuvv57u7m7++Mc/GkUtXS4XZ5xxBk1NTVx22WVUVVXp/iJbRCUKDw4OEovF8Hg8vO51r2Pfvn27fv9/NVQ5EZXpvbRund1uZ9++fTQ0NHDllVdSVVVFWVmZkRy89KamIiMBLrjgAjo6OvjZz37G5OQk0WiU8fFxbrnlFpqbmznttNMQQuyqBFZluXR0dODz+XA4HLzyla+ktbUVl8u14eMppdzf38/vf/97oz1EWVkZ559/Pm1tbdvSfiPr/zcWVgIdGRlhYmKCZDKJzWajvLycsrIyrFbrnlQsiUSC2dlZ+vv76e3tZXx83OhAabfbqampob6+noqKCt0YbAtIKYlGo4RCISPKxmKx4HK5qKqqoqKiYtfc2LaCystQikX5WPLy8qivr6epqYmGhgYqKyvXzC5X/pbq6mpCoRBut9uoUxaLxZiamqKwsJBYLLalOlvZhqrzpXwjquRTdXX1lvJavF4vExMTeL1eZmZmFq3fysrKbQmhz/orIhAI8NBDD3H48GFGRkYIBoM4nU7y8/Oprq7esxe2qjk2Pj7OoUOH6O7uNpJU3W43VVVVXHTRRTQ1NVFaWqqTJrdANBqls7OTrq4uHnroIUZGRigpKaGxsZETTzyR+vp6vd24DFarlYaGBurr63n/+99vbM8ul/y7HKo6RWFhIfv378fhcNDT03NE0M9uQUppZM6rhoCxWAy3282rXvWqTVsuwWCQRx99lPb2dqMSckVFBfX19Rx//PHbVvUgax/3Vcx8IBCgr6+PgYEBIpGI0X2tpqaG/Pz8PbsdFo/HGRoaYnBwEL/fz+zsLMlkEpPJREFBgZFcqkK0tWLZPEqRe71eoz6W0+kkLy/PCJ/di2twJVQVDZW429LSQm1tLZWVldhstnXLSgX/uN1uHA7HETfAeDxu/J/sButlYbvyUChEOBzG4XCQn59Pfn7+pmuJKctFJaZCKgxcVfDergfPrH3kj0ajtLe309XVxR133EFfX59RIPCDH/wgLS0tHH/88Xg8nj2ZFT05OckNN9xAZ2cn/f39BINBEokEHo+H008/ndbWVurr6ykrK9uTll06iUQivPDCC7S3txuRiiqYxOl07sn1txJSSiPis6ysjE9/+tO0tLRQXFxshG1v5njJZNL4XR1/enqa//3f/6WtrY0PfOADOW89qi2xSCSC1+slHA5zyimnbLnySCKRMJJ+E4kEVqt1S9ts6yVr7zpL8zYCgQBWq5X8/HwaGhpoaGjA5XLtuQt7aQx8f38/kUjEqDmWn59vbD84nU6tWNKACiqZnp4mGo0ihKCwsJDCwkItX+bls7S7qcViobKy0igDtZnjql5G4XCYSCRyRKrCbrPIVcKpqkqicvyUgt2o5aLyg6anp/H5fCQSCaOU1nZH2GbtlREOh3nmmWdob28nFAphNps56qijaGtr4+ijj6a2tnZP5mvMzs4a+T6HDh1iaGiIaDSK3W5n//79NDU1cemllxqhx5qto3qXDwwMkEgkcLvdvPSlL9U9ceYIBoM88sgjdHR0MDs7u+iGv5Wbv6o60dHRweHDhxkdHSUejxs34IKCAi666CJaW1t3xVpXjfzy8vJoaGjAYrEwOjqK3W7H5/MZ27DrVQhK6Y+NjfH4448bftnS0lL27dtHa2vrtt5Ds1K5qKgTZbWomOzq6uo9XRtL9Rpf2KdFPc2pNrtFRUWbrjukORJVJl5VkVUdVVWkorZcUr6PsbEx4+avbn6buT6VvyYej+P3+xkcHDyiJxFgdFwtKiqisLBw16x1s9m8qC1JIBBgenqawcFBTCYTFRUVK+7WqG01Jb94PG6U1Z+ZmSEYDALzPaK2u1xR1l0ZSkAzMzM8++yzdHZ2kkgkKCkpMZ5SdtNiWi+q9MjIyAh33XUXXV1d+Hw+I1HNYrFQV1dnVErV0WFbJ5FIMDMzw/j4OC+++CIDAwMUFRXR2NjIqaeeSmNjo7ZcmLemt1plVyWphsNhhoaG6O/vN/ytfr/fGLdwW2czfpxsRZW6cjqdVFRUEAgE6OzsZHx8nH/913+lurqa8847j/z8/GU/H4vFGBwcJBQKGWkJ4+PjRtDD0u/a7iCUrFMuytei+pHMzMxgt9vJy8szYrL34tOiivhQVVLHxsaMLQKViV9ZWWk82WjFsnWSySQ+nw+v12vc9EpLS43Inb1cbmghyg84Ozu7pcrkiUSCyclJ/H6/EagyMjKC1+s1/A3qqbu6unpRQMVuWe9KwZSXl+P3+3G5XITDYQYHBwmHw7S3t6+qXIaGhpidnWViYsJQLsFg0PAVAkb33j3ncwkEAtx33310dHTw/PPPEwwG2b9/P62trRxzzDFG0ba9RiAQ4P7776ejo4Nnn33WyFZ2uVy85CUvoampibe+9a3U1NTsiv3nbCAYDPK73/2Ojo4ORkdHCYfDNDY20tzcvCfX4HYzMzPDPffcQ1dXFw888IARPptIJEgmk5jNZoqKiqiqquJv/uZvaGxspLW11cjy3y3k5+dz4YUXMjg4iJSSoaEhXnjhBQYHBzl06NCKilQlngohiMfjRgj90hpvLpeLV7ziFZvOm1kvWaNcFvYj6enpobe3l1AoBGBEnKjeD3uRWCxGf38/fX19BINBI5FMdaVraGigvLxc+1rSiLJcVP8gVZl2L/r7thPlXx0dHTX6wAwMDBAIBBaNW2ilq4hI1ZV1N2E2mykrK0NKSUtLC06nE6/Xa+S+rNTrXhUGVTs7KqwZFnf53XOWSzgc5umnn6azs5Nbb72V4eFhEokElZWVXHjhhbS0tOzpJ3K/388DDzxAR0eH4ZgDKCws5LLLLqOtrY3y8nLta0kjqiioamesbm46aTK9qM6VfX19HDp0yCjXvxQV1NPQ0MCxxx67a1seW61WKisrKSsro76+nmAwSHt7O4FAgLGxsRV7sHg8Hk455RTcbjdCCMbGxvj+979PT08Pf/zjHxcpaxXmvOsd+slkknA4zMDAAH19fYyPjzMzM2OU566srNxVhek2QzKZZHp6mpmZmSPKmC/sZ7PSU40K31y6mJYmpqnvSiQSBAKBFY+notPSXUk1m1goc1UFeSfyA3KRpetHvabyVGDeb6jqj6nPjI6O0t7ezsDAABMTE4TDYSOvYyHKSq+rqzOCVnYr6ubvcDgoKCggkUgQDAbJz89fsXuk2+2mubnZ2OpyOp2Ulpbi9XqPWK8qmmxXJ1GqKKjBwUF++tOfGlWP7XY7xx57LPv27eOYY46hurp6zyVMrodEIkEoFMLv968aOaP6k5vNZmNMIpEwil+qC1klrnm9Xh544AFmZmYWHUdFmRQXF3PxxRcb7Wl3o4JZmGulqsiecMIJOr9lFRY+qMzOzvLss88akUrj4+P86Ec/YmxsDJ/PZ6y5aDRqlCZZWAJlKSUlJXz4wx+mra2N4uLinTupDGO1WqmvryeZTNLS0rLiONXaQKG69Pp8vkUP5tFolIGBAaP52HbdVzOuXFSEQ19fH4ODg4yNjQGponW1tbXU1NTg8Xh2pfmbDuLxOH19fUaHz5WUi+o9olpGQ2qRqQqs6mJeqFza29uPUC6QslpKS0sZHx/HZDJRWlq6q/a9F1ZBnpmZMSw4paDT3VQp1zGZTMYe/sjIiPF6JBKhu7vbsFwmJiZob29nfHyc6enpRQpEKaTl5Go2m3G73YYzv6ysbJvPKLtQEWTAhq01i8ViKJaF1uVOrN+MKpdkMsn4+DjXXXcd7e3tHD58mHA4TElJCXV1dVx88cU0NTXtaV/LWoyOjnL11Vcb+6crLRq1H1tQUEBhYSGAseXzpz/9ydiPXVjLye/3rxhaqhI1m5ubueCCCygoKNiW88sE0WiUw4cPGzfCpVuRmsW43W4OHDhATU0NIyMjRnFEr9fLt7/9baMNtErqSyQSSCmXXavLvebxeDhw4ABtbW3bGt20G1l4PSusVqvRLnlXboupZMlQKERfXx/9/f1G6YiysjIjjn23PRVvFpPJZPQYVz4RmLf81sLtdlNcXExeXp6hCFQ9qK6urkVBAgtRGekmk2nR9pfFYjH2bbeS25CNqGq7U1NTRsaz3W7H4XAYmdPacplH1RBTOWkWi4VkMkksFmN0dBRYPmlP/b20HpnqA6P8iUVFRUYhVr01vnWUJbTdssyYclGtPAcHB+ns7KSvr49oNEpFRQVve9vbaG1tpaWlhfz8/D3tyFc4HA6OP/54HA4HTz75pBGmvV5CoRAHDx40EtFgvtSGOpZyzi+0gJxOJyeddBJFRUU0NDQYZrnL5eLkk082esXsJsLhME8++aTRa9xsNlNfX09rayvHHnus7t+yBKfTycknn0xBQQG/+MUvCIVCqwaDrIQKmHA6nVRVVVFVVcW73vUuKisrqa6uNvo4adbPwkKYS1/fbjJy147H44TDYfr7+xeViy8qKjKa2NTW1uqqvgtQjZcSiQSDg4MEg8FlLQZVl01Fl6gxUkrjRqlCadUNUjn6XS4XFotlkYXicrnYt28fhYWFi5SL3W6nrKxsVT9PLqIs6omJCaNEuclkoqioiOLiYqO3iLZc5jGbzeTn51NcXExNTQ3JZNJoShUIBNbda0W1N87Ly6OlpYXq6mpaW1spLy+noKBgV5V62SkWBlgoJbNTa3fH79wqd6Cvr4+vfe1rdHd3Mzk5SX5+Ppdeeimtra2ceeaZlJSU6IicBZSUlHDllVcyMTHBUUcdZYR0LkXVF/L5fDz++ONHbHep7NzCwkLKysqMi1VV+i0oKKCqqsowmVWlVlVQTy1MIQQ2m814fTegHPkzMzNGzlUkEsHlchlVkHWOy5EopWCz2bjyyisZHR3liSeeYGhoiF//+tfLBoUsR15eHq9//etpamri3HPPNVIRFioVrdTXj3pQUlu7artxp6I7d1y5qFj3sbEx+vv7GRoaMuKtq6qqqK6uJj8/XzvulqCydm02Gy0tLUxPTy/7RBiNRnG73UZm+ezs7KL3PR6PYYmoLpWQUjqtra2GctnLFqOqPh2LxYweOcoHuFsUabpRvrm6ujrcbjczMzO43W4OHz5sdO9MJBJGcqSylj0eD0IIpJRGIE9dXZ0uY5QGVFCOUu4Wi4WSkhKKi4t3xALc8TtIKBQyej8MDAwYYbCqH0lbW5vez16FvLw8Xve61y1KQlvIwm2xhfkrCnUTUPku6glmoYWyVxWLEGJRyXO1zVNTU8Mb3vAGampqcLvdmZ5m1mKz2di3bx+JRILjjz+emZkZXvKSlzAyMsIjjzzC+Pg4Tz31FEIITjzxRCoqKjj77LPxeDxAyq941FFHUVBQoHct0sDC2njAjlc72bG7iNpy8Pv9Ru2g2dlZY2tHCIHdbtflS9bAZDJpp+Y2orb7VN2q/Px8KisrjWrIektsZdQ1DClL2Ol0GjeykZERCgsLCYVCmEwm2traqKiooK2tDY/Hg5QSm81GSUmJEZ2o2TqqVExFRQVlZWU0NzfvWNTdjikXlTvQ3d3NfffdZzjyNZpswmw2U1VVxac+9SnDma8KAu7mUjfbgcPh4LjjjiMej3PKKacYgTzqPYvFssiHJYQwQpG1437rWK1WGhsbKSkp4bWvfS1VVVWceuqpRkfL7WbHlIsq/zw1NYXX6zWSqWC+jo5KttJoMonK29BsDSGEsb2ltr40O4cqGxMOh2lpaaG8vJySkpIdczvsmHKJRCJGL+yZmRmjPa/VaqW0tJSysjKjpL5WMBqNRrM1SktL+fCHP0wymcTj8RiRYjvFjvpcwuEw4XDY8LPY7XacTieNjY00NjYaykVvPWg0Gs3WUBGmmSJjYUE2m42amhoaGhr45Cc/SX19PXV1dUb5CI1Go9HkLjt2FzebzRQWFlJeXk5bWxuhUIja2lrq6+tpbGw0+mHrLTGNRqPJfcQaRQfTVpFQ9W1R4cjJZNJw5JeUlBhRIjvMTu+/7a4Kj0eSif1MLdP0ouWZXvasPHdMuWQpeqGlF61c0o9eo+lFyzO9bFq5aDQajUazYbSDQ6PRaDRpRysXjUaj0aQdrVw0Go1Gk3a0ctFoNBpN2tHKRaPRaDRpZ+cTS4T4oRDii3O/nyWEOLTOz6177F5DyzS9aHmmFy3P9JIr8lyXchFC9AghZoUQASHEqBDiRiHElsucSil/I6Xcv5mxc3N6zSpztgkhbp0bJ4UQB7Y633SSizJdiBDiqjm5rmv8dpOr8hRCvE8I0TE37/uEENVbnXM6yEV5CiEa59ZkYMHPZ7c653SQi/KcG7Pp9bkRy+UCKaUHOBk4FfjMBj6bKX4LvAMYyfREViAXZYoQogW4BBjO9FyWkFPyFEK8EvgScBFQDHQDP8vopBaTU/JcQKGU0jP384VMT2YBOSXPra7PDW+LSSkHgXuB49Y5wZcIIZ4QQviFEDcDjgXvHRBCDCz4+2QhxJNzY28RQty8wPwzxgohfgzUA3fOadRPLDPPqJTyOinlb4Ejm81nEbki0wVcD/wzEN3oue4EOSTPC4BbpJTPSSmjwBeAs+eUd9aQQ/LMCXJInltanxtWLkKIOuB84Mm5vz8phLhrhbE24A7gx6Q03y3AxauMvR344dzYnwFvWm6slPKdQB9zTwJSyq9u9DyyiVySqRDiUiAqpbxnnae34+SQPAWLy2eo39d109kpckieil4hxMDc1lPpmie4w+SQPLe0PjdSFfkOIUQcmAbuJmUuIaW8dpXPnA5Ygetkqs7MrUKIj60y1gJ8a27sbUKIP21gfrlITslUpPaIvwScu9ljbDM5JU/gHuBmIcR3gXbgc6RqUbm2cMx0kmvynCC13fQXoAT4DvBT4LwtHDOd5Jo8t7Q+N6Jc3iilfHCDk6sGBuXiAma9Gxjbv8HvyzVyTaafB34spezewjG2k5ySp5Ty10KIq4BfAAXAvwF+YGDVD+4cuSbPAHBw7s9RIcSHgGEhRL6Ucmazx00juSbPLa3P7Q5FHgZqhFjUWrJ+A2PrVjn2Xq24mUmZngN8RAgxIoQYmTvWz4UQ/7zWpLOYjK5RKeV3pJRtUspyUhexBXh2rc9lMdl0zavxudzaNmfX53Yrl8eAOKkbkkUI8WbgZauMTQAfmht70SpjAUaB5tW+XAhhF0Io55dNCOFYIvhcJJMyPYfUfutJcz9DwN+S2n7IVTImz7n1eJxIUQ/8J/BNKaV3U2eSHWRSnqcJIfYLIUxCiBLgW8DDUsrpTZ1JdpCz63PLykUI8WkhxL3LvTcXYfBm4ArAC7wVuG2Nse8FfKRCiO8CIit89ZeBzwghfEKIj68w5hAwC9QAv5r7vWHNk8ow2SpTKeWklHJE/ZBayN657YisJVvlSSrq53+AAPAnUjeHrMjLWI0slmczcB+prZtn547z9nWdVAbJYnluaX1mdT8XIcQfge9KKW/M9Fx2C1qm6UXLM71oeaaXTMozq2qLCSFeKYSonDPp3g2cQOpJRLNJtEzTi5ZnetHyTC/ZJM+NRIvtBPuBnwMeoBO4REqZbVnguYaWaXrR8kwvWp7pJWvkmdXbYhqNRqPJTbJqW0yj0Wg0u4NMlNx/WAjxvrnfLxdC3L/Oz6177F5CyzP9aJmmFy3P9JIz8pRSrvlDKhRN/SRJhfSqvy9fzzEWHOth4H0b+cwKx5FA6yrvVwG/JJWLIYHGrX5nun5yUZ5Lxt64kfFapiu+L4D/R6rG0wxwE5CfaVnmsDwPzM114dzfnWlZ5rA8t7Q+12W5yPny1R4WFzvzSCl/up5jZIAkqSiJZYu8ZZIclScAQogzgayq2gs5K9N3Ae8EXkGqdIcT+HZGZzRHjsoTYGjh3KWU/53pCUHOynNL63Pbt8WEEK8VQrwohJgWQlzPglIMQogrhBC/XfD3uUKIQ3NjbxBCPLLA/DPGCiEenfvIUyJVLvqtS79XSjkqpbwBeHxbT3CHyZQ858ZZSC2uD23X+WWCDMr0AuAHUsp+mUpE/QrwViFEthSu3BSZXKO7kVxdn+nI0L9BCHHDCu+VkqpH8xmglFRo3CtWGXsr8ClSFU0PAS9fbqyU8uy5X0+c0/w3b+kksogsl+c/AI9KKZ9e5+lkBVks0+VKmtuBtrXOKZNksTwBykWq02O3EOLfhBDu9Z5XpshieW5pfW5ZuUgpr5RSXrnC2+cDz0spb5VSxoDrWLkr5PnAc1LK26SUcVJ1gbK1g+S2ka3yFKkeFH9Lqux2TpGtMiXVMOp9ItWet4BUAzbInpL7y5LF8nyRVM27KuDVwEuBb2zheDtCFstzS+tzu7fFqllQ8lmmvEQrlYBebmy2lB7PFjIpz+uAa2RuFwFcjkzK9L9INXR6GHgOeGju9Vxe9xmTp0zVvHteSpmUqbYQnyDVjjuXydn1uRMl942Sz0IIwcoloIeB2iVja1cYu1fJpDzPAb4m5svtAzwmhLhsC8fMBjIm07mb4FVSykYpZS2pC3hw7idXyaZrXpLb5fYhh9fndiuXu4FjhRBvnnMGfwSoXGXs8UKIN86N/eAqY2F9JfcdpPYIARaW389VMinPfcCJzJfbh5TD7/Z1zz47yZhMhRDFQogWkeIYUls410gpk5s6k+wgk/I8IISon5NnHXAt8L+bOovsIWfXZzoc+t8VqTaYRyClnAAuJfWfPEnKEfS7NcZ+dW7sMaS6yq1ULvpq4L9Fqlz0W1YYo2LJIbUfO7vW+WSabJWnlHJMLi63DzAhpdQy3fwaLSXVSjZIan/7v6SU/7nO08oYWSzPk0mVhQ8CvydVdv8j6zurzJHF8tzS+sza2mJCCBOpvb3LpZQPrTVeszpanulHyzS9aHmml0zLM6tqiwkhzhNCFAoh7MCnSe2X/iHD08pZtDzTj5ZpetHyTC/ZJM+sUi7AGaTiuCdI7ee/MRe2XbIYLc/0o2WaXrQ800vWyDNrt8U0Go1Gk7tkm+Wi0Wg0ml3AWp0od7tZs9Mx8Fqe6UfLNL1oeaaXPStPbbloNBqNJu1o5aLRaDSatKOVi0aj0WjSjlYuGo1Go0k7WrloNBqNJu2sFS2m0Wg0O04ymURKSSKRYGkunhACs9lMMpkkEAggpcRqtSKEOOJfTebQykWj0WQVyWSSUChENBplamqKeDy+6H2LxUJJSQnBYJAHHniAcDhMTU0NLpeLiooK3G43dXV1WK3WDJ2BBrRy0Wg0GUZKSTgcJh6PEw6HicViTE1NEQ6HGR8fJxaLLRpvtVqZmZkhGAzS2dlJKBQiFArhcrmYmZmhsLCQiooKrVwyTFYrlzvvvBOACy+8EIBvf/vbAPzd3/0dAGazOTMTyzBjY2MAvOUtqSrZL395qk32+9//fgAaGxu3dPzp6VSzyUcffRSA173udQD6YtVsC+FwmKeffprJyUn+8pe/MDk5yQsvvEAgEGB4ePgI5WKz2aiurkZKSW9vL5FIqqK82g5raWnhxhtvxO12Z+J0NHNktXLRaDS7i3g8TiKRIBAIEI/HCQaDBAIB2tvbmZiYoL29Ha/XS3d3N4FAgLGxsWUtl3A4jBCCyclJ4vE40WjUeN/lch3xGc3Ok5XKZXJyEpi3UBQf/vCHAXjve98LgNPp3NmJZRiv1wvAscceC8xbGBUVFUD6LJaTTz4ZgImJCQAOHjwIQFtb25aOn0vMzMwA8MlPfhKA5557DoAHH3wQ0FbcZojH44yPjzM5OclDDz3E0NAQjzzyCDMzM/j9fmKxGLOzsySTSaLRKMlkclklEYvFGB0dNY6pi+9mJ1mpXDQaze5D+Vb8fj/d3d309vbS2dnJzMwM0Wh0XUrCZrOtGQ3mdDoxmXSWRabJSuWi9voHBwcXvf72t78dAIfDseNzyiTKglA+FmXZffCDHwTmfVFb5Ytf/CIA3d3dAPznf6Y6mu4li+UnP/kJAJ/5zGcA6OvrW/S+smhKSkp2dmK7gEQigdfrpb+/n/vvv5+BgQFCodCy4cbLYbPZqKysxOVyUVNTs6L1WFtbu+d2NTo6OoD5e8Xtt98OwMMPPwxgKNsPfOADwLyfdjuv7axULhqNJjdJJpOGT0VKic1mw2w243A4jLyVeDxOIBAgGAwaOStSSoQQOBwOTCYTVqsVk8mEzWYz/rVarVRVVeHxeKipqcFmsy07h9LSUr1tmQWs1SxsRzczVdSH0qpPPPHEovfvueceAP7qr/4qXV+ZE+W377//fmA+akuh9p3Lysq2NKlnn30WgOOPPx6AN73pTQD893//NwB5eXnrPVTOltwfGBgA4CUveQkw/wS4dOvlbW97GwDXX389AMXFxen4+tXIiTUKGEmNXq+XBx98kGg0SmtrK0VFRRx33HEAvPDCC3R0dPC5z32OkZER7HY7Ukqi0SgOh4Ojjz6agoICampqyMvLo6mpiby8POrq6nA6nbhcLiwWC263e8WtL4vFQlFR0UrRpDkjz9V45plnAPjOd74DwG233QbA+Pj4uj6vlO/+/fsBOPPMMwH45je/CbCi4l6GFeWpLReNRrNllIIYHBxkbGyM9vZ2EokEZWVl2O12ksmkYcHk5eVRX1+P0+k0woWDwSAOh4N9+/ZRUFBAdXX1IuVSX1+P3W7HarViNpsN34sme8kq5fL0008DR1osFktqmmm0WHIClc/yi1/8YtHr//Vf/wWkz2J57Wtfu+j1N7/5zcCGLJac5+tf/zow789aiZtuugmAe++9F5j3zahIxg088e0apJREIhEGBwf5xje+QVdXF4cOHaKwsJD9+/dTUlJibJG1tLRQVVXFF7/4ReLxuLGGJycnEUJQWVmJzWZbtB2mtsmEEIZC2WuKRd0blaVy8803A/MRnora2loAzjrrLGA+gvRrX/saAC996UsB+OMf/wjMr3e1K3TiiScC876ZrZBVykWj0eQeKjR4cHCQrq4uBgYGiMfjmEwmHA6H4UcRQhjKor6+Hkj5RwAKCgoAKCwsxGKx7DnlsRvJKuWi9g2XsvTJeq/wj//4j8B8BJPKP7n00kvTcvzf/va3AIyMjADw13/91wC84x3vSMvxc4He3l4AbrzxxkWvqyc4lUP0wAMPLHpfPTEqi+fyyy8HoLKycvsmm4Wo3JXvfe97dHR08Mwzz2AymXjta19LU1MTL3vZyygvL8dutxufsVgshlJRfhHlu9qrVTdW4m//9m+B+eivpT6V17zmNcC8v/RLX/oScGRE7WOPPQbAv//7vwPz1/pf/vIXYH7dXnnllQBcfPHFwNZ2R3QwuEaj2TBSSmKxGF6vl7GxMbq6uujt7TUy5+vq6mhsbKSgoACn03mEJWI2mxcpkqV/a3KfrLJcHnnkkUV/q/1rpY33Gkv3l2tqaoDN7+vPzs4C8/JU+7fq+MqXs5dQT24qf+Xss88G5tdiOBwG4H/+538A+PKXvwzM5xUoq++iiy4C5n0xOxBFljGUj2Vqaop77rmHrq4ufv/73zM1NYXFYqGqqorzzz+fpqYmiouL9TbXBlDr7atf/SoA3/ve9wCMPKDy8nJgvnrJP/3TPwGsWUdN+VZUhenPf/7zAJx33nkA9PT0pGX+C9GWi0aj2RAq5Hhqaoquri56enoIBoMAhsVSVlZGUVGRVix7mKywXH7/+98D8/uCCpfLBcBJJ52001PKSu666y4Azj33XCDl/IQja7AtRWXpqn//8Ic/LHo/XT6cXGRhRV2Af/iHf1j0vtq7fs973gPArbfeCkBnZycw/0Sp1upeiBabnZ3lySefpLOzk9tvv52JiQmsVitNTU186lOforGxkfr6ehwOh1YsG0Rdoyq6S60vtWuh/NIve9nLVj1OIpEAoL+/H4B3vetdALz+9a8H5usULuWd73wnMH9v2QractFoNBtClXGZmJjA6/Xi9/txOBwUFBRQX19PXV2dzkPRZIfl8vjjjy/7+lpP5Ludv//7vwfg//7v/wAYGhoC5v0B6qnmf//3f1c9jhq39GJvaWkB9q5PC+BnP/vZor/vvvtuAN74xjcuO15ViF7K6aefDoDH40nf5LKUaDRKR0cHnZ2dRCIRrFYrDQ0NNDU1UV5evlp2vGYNlE9kqfxURr3KT1EW9IsvvrhonKqp9sILLyz6V0XnKR/hUlRUpMrbSkf5HG25aDSaDZFIJJicnMTr9ZJMJgGMnip+v5+ZmRlmZ2fXXelYszvJitpiKq/ipz/9KTC/36fq56is020gJ+oMqf1RFdl03333AfMRJeqp493vfveyn1f7qCeccMKyr6saYmkg52qL/fznPwfma4YpGalMfLUGVZ7BLbfcAsxXL1D/Nyo67De/+Q0AxxxzzFamtZCsW6Pd3d285z3voaOjg7GxMZLJJB6Ph/Lyci677DJqa2s56aSTKCwspL6+PtuKSGadPBeiIjovu+wyYD6/KhQKpQ62wv1aVTFRls9aqLpsqhrHt771LQCqqqo2Ml3QtcU0Gk26SCaTRoMvVQV5dnaW6elpuru7mZ2dxeVyUVxcjNVqxeVyGYEOytFssVgwmUyLosmklMbNUWXy6+213CWjlovKEFe5BWouDQ0NwPbEXi8hq59i0kVXVxcw72NR0Xeq2vJWa5QtIOcsl6mpKWBeNirzfiU/laoWoXKE3vCGNwBw+PBhAN7//vcD8N3vfncr01pI1q3Rw4cPc8EFF9De3r7odVWtWCmUwsJCzjnnHMrLy2lubsZsNjM1NYUQgvLyclwuF9XV1YZlE4vFGBoawmQy0dzcjNvt3g7/TdbJczV8Ph8A1157LQC/+93vgPl+QqqMjop6fOqpp4B538xKKH+28rduITpMWy4ajSY9mM1mPB4P+fn5BINBwxqJx+OGchZCMD09TWdnJz6fj0QisUi5+Hw+XC4XgUDgCOWi+rvk5eURCoVwOp0UFxdrKybHyKhyUVmjS62nvVpLbLu45pprgPmncOWrSaPFkrMoX4nypVxyySXAkRbMRz7yEQC+8pWvAPP5L2rPWmXu/+pXvwLm82CURbSb8Hg8nHfeeXR0dHD//fcb1Q0WIqUkEAjw8MMPG9WNhRCGIjKbzUYhy4XbYtFoFIvFQklJCXl5eRx99NE0NDTw/ve/34h42ksoi0JZLmuh8lmWWi75+fkAfOMb3wDgiiuuALa3lpu2XDQazYaw2WxGKffDhw8zOTnJ5OQkyWTSUMaxWIxEIrGs4lkLs9mM3+/H4/FgsViM4phWq5W8vLwVm4RpsouM+lxWihJTvoBTTz11O78ecmz/daOop/G3vOUtwPzTy0MPPQTMV1lOIznnc1nKgw8+CMzXElNrUll/S/NYlkb3qJyjNEbiZd0aTSQS+Hw+AoEAzz//PH19fXz/+99nfHycZDJpFLSMxWKbDkU2m82YTCbsdjtlZWVcccUVtLS08PrXv94oz79Jsk6e6UDtRqg8lVgstuh9dY9V6zSNaJ+LRqNJD2azmaKiItxuN+FwGLvdTltbG0VFRSQSCWKxGMPDw8RiMZLJJPF4HL/fb+TCrEfhJBIJ41gOh4Ph4WHy8vKMbTVN9pMR5aL6launQ4XKZ9kBi2VPoCr0KlRdoW2wWHYNqj+G+nctVEb0W9/6VmDeclHWoYpG221VkpVV0dTURG1tLfv37zfCiEOhEM899xyhUMgoFfPLX/6S0dFRenp6jMim9RKNRunr68Nutx/xRL7X+f73vw/AF7/4ReBIi+W4444D5vuz7CTactFoNJtCOeRtNtuiku/hcJhIJMLs7CyJRIKJiQnKy8uJRCJH9HBxu91G9BmkWh8kEgmCwaBh4SSTSaLRKJFIRGf85xAZUS6qCvLShaJ6YmjSg7Jc1IX/8Y9/PJPT2dUov9Yvf/lLYD7D//rrrwfgc5/7XGYmlgHsdjtHHXUUUkqklEZp/tLSUg4fPkwoFMJsNpOXl8eZZ55JVVUVZ511FslkkgceeIChoSH+9Kc/GWX8NUfypz/9CZjvVuv3+xe9rypIqM6TCzuB7hTactFoNGlFCLGozW40GqW0tBSv12uUKQEM5QOpm18ymUQIccRDpxACs9mcbWVkNGuQEeWi8lsUKn79ox/9aAZms/tQ2eGqAqqqPaZ9LduHCo/9xCc+AcAdd9wBwNVXXw3M1y7bt2/fjs8t09jtdo499lisVqvxBJ1IJAgEAjz66KPk5eUZFb8PHjxIMBg0amlBSrZFRUUUFhbqRMo57rzzToAjQr3VLoWyoM8888ydndgCtOWi0Wi2FbPZTH5+PoWFheTn5+PxeIzMfr/fTywWM4J8pqenjVa/ZrPZ6BNTXl5OWVmZVi45REaUi8piVtTV1QFsNX5dM4eyXFTm8/nnn7/ofbU/qyr6qvpEmq2j6rZ94QtfAOb9XJ/61KcA+MlPfgLMR5ntBSwWC1VVVSSTSU477TTKysoMCwVSdbFUX5JoNAqkFIvL5eKEE06gsbGRd7zjHdTU1Bi5WnsVde2qvJalqNzBAwcO7NSUVkRbLhqNZltRUWVut5uGhgYSiQSHDh1CSmnkwqjwZKvVislkIi8vj4KCApqbm2lqaqKiokLXF8sxdlS5qBjsjo6ORa8r55922G0Pyomqnpr/7d/+DZiPgU9jPxfNHKrG03/8x38A873PVSXhpb11djNCCKxWK2VlZbz97W9nYGCAUCjEwMAAfX19hEIh/H4/JpOJ4uJiCgsLOeOMM2hoaODSSy+lrKzMqI68V1snBwIBAI4++mhg3sJTnHjiiQBcd911Ozqv1dCWi0aj2XYWKphkMklraysOh8PI3rdYLJjNZhobGyktLWXfvn3U1tZSU1Ojt8tzlB1VLiqiRmXgP/fccwC0tbXt5DT2HN/73veA+Wze973vfQB89rOfzdicdjuq4rSqVaZ6FKnqtkurU+wFTCYT+fn5uFwuPvrRj+Lz+Xj00UeZmJjg8OHDuN1u3vSmN1FWVkZFRQV2u93I19jr/N///R8Ag4ODy76vqh0vDAHPNNpy0Wg0O4Yqv19eXo7b7aaxsdFw0rtcLhobG41y+7r6cW6zo8pFOeP+5V/+BZiPZtL5F+nl29/+NgBXXXUVMN/pU3WfKyoqAjBaz2q2DxWJp3oUqfyD559/HoBjjjkmMxPLApxOJ2eccQaJRIJoNGo48lVFZM08K+0yqLyqV7/61Ts5nXWhLReNRpMRTCbToppkmt1FRvu5ZAG7srdDBsn5fi7bhcqkVlE93/zmNwG48MIL1/qoXqPpJSflqXIBVbJpeXk5AH/5y18AqKqqSsfXbIYV5altT41Go9GkHb0tptHsAMpp3d3dneGZaHKRj33sY4v+VT6YDFosa6ItF41Go9GkHe1z2Vm0PNOPlml60fJML3tWntpy0Wg0Gk3aWcty0Wg0Go1mw2jLRaPRaDRpRysXjUaj0aQdrVw0Go1Gk3a0ctFoNBpN2tHKRaPRaDRpZ8eVixDih0KIL879fpYQ4tA6P7fusXsNLdP0ouWZXrQ800uuyHNdykUI0SOEmBVCBIQQo0KIG4UQnq1+uZTyN1LK/ZsZOzen16wx73OEEC8KIUJCiIeEEA1bnXO6yGGZuoQQNwghJoQQ00KIR7c653SQw/J8nxCiY27e9wkhqrc653SQw/LMyms+F+UphLAJIW6dGyeFEAc2MreNWC4XSCk9wMnAqcBnNvJFO40QohS4DfgsUAwcBG7O6KSOJKdkOsd/kpLn0XP//kNmp7OInJKnEOKVwJeAi0jJshv4WUYntZhck2e2X/M5Jc85fgu8AxjZ6Ac3vC0mpRwE7gWOW894IcRLhBBPCCH8QoibAceC9w4IIQYW/H2yEOLJubG3CCFuXmD+GWOFED8G6oE7554EPrHMV78ZeE5KeYuUMgxcDZwohDhqo+e83eSKTIUQ+4ELgfdLKcellAkp5Z+3cOrbQq7IE7gAuEVK+ZyUMgp8AThbCNGyyVPfFnJInjlxzeeKPKWUUSnldVLK3wKJjZ7nhpWLEKIOOB94cu7vTwoh7lphrA24A/gxqSeJW4CLVxl7O/DDubE/A9603Fgp5TuBPuaeBKSUX11m2LHAUws+EwQ6517PKnJIpqcBvcDnRWpb7BkhxLLfnUlySJ6CxbWZ1O/ruunsFDkkz5y45nNInltiIyX37xBCxIFp4G5S5jxSymtX+czpgBW4TqbqzNwqhPjYKmMtwLfmxt4mhPjTBua3FA8wvuS1aSBvC8dMN7km01pSN75fANXAGcDdQojnpZQvbOG46SLX5HkPcLMQ4rtAO/A5UoUOXVs4ZjrJNXlm+zWfa/LcEhtRLm+UUj64weNXA4NycQGz3g2M7d/g9y0kAOQveS0f8G/hmOkm12Q6C8SAL0op48AjQoiHgHOBbFAuOSVPKeWvhRBXkVLWBcC/kVqfA6t+cOfIKXmS/dd8rslzS2x3KPIwUCOEWGj6129gbN0qx16r4uZzwInqDyGEG2iZez2XyaRMn17H/HKNTMoTKeV3pJRtUspyUkrGAjy71ueyGH3Np5eMrs+tsN3K5TEgDnxECGERQrwZeNkqYxPAh+bGXrTKWIBRoHmV928HjhNCXCyEcJDacnhaSvnihs8iu8ikTB8ltU/7qbnjvQI4APxqg+eQTWRMnkIIhxDiOJGinlQk3jellN5NnUl2oK/59JJJeSKEsM/JEsA2t2bX1RNny8pFCPFpIcS9y703FwHzZuAKwAu8lVSo4Gpj3wv4SIW/3QVEVvjqLwOfEUL4hBAfX+Z446QcX/8y992nAW9b73llkiyWaYxU2Oz5pPaNvwe8K9sv3myVJ6mon/8htZ3zJ1I3h8+u66QySLbKM1ev+WyV5xyHSG2H15B6iJwF1pU7lNX9XIQQfwS+K6W8MdNz2S1omaYXLc/0ouWZXjIpz6yqLSaEeKUQonLOpHs3cAJwX6bnlctomaYXLc/0ouWZXrJJnhuJFtsJ9gM/JxVS2AlcIqUczuyUch4t0/Si5ZletDzTS9bIM6u3xTQajUaTm2TVtphGo9FodgeZKLn/sBDifXO/Xy6EuH+dn1v32L2Elmf60TJNL1qe6SVn5CmlXPOHVKik+kmSCkdTf1++nmMsONbDwPs28pkVjiOB1jXGXEYqmzVIqj5P8Va/Nx0/OSzPMlKhsz5SYZE/zbQsc1mmpGqJ/T9SuUMzwE1AfqZlmavynBujr/k0yROoAn4JDM2NbdzI8ddluchUYTOPTJWLXljszCOl/Ol6jrHTCCGOBf4DeCdQAYSAGzI6qTlyUZ5z3Eaq9HYDUA58PbPTmSdHZfouUuvzFaRKdziBb2d0RnPkojz1NZ92kqQizTZVnHbbt8WEEK8VqeY900KI61lQBVYIcYUQ4rcL/j5XCHFobuwNQohHFph/xlgx36DqKZEqF/3WZb76cuBOKeWjUsoAqeS0NwshsqWI3abIlDyFEOeSKiXxT1LKaSllTEr55Hae606RwTV6AfADKWX/3Br9CvBWIUS2FK7cFPqaTy+ZkqeUclRKeQPw+GbmnY4M/RuEEMs+HYhU855fkGqKU0oqNO4Vq4y9FfgUUEIqM/Tly42VUp499+uJc5p/uYZAS8tvdwJRYN86TitjZLE8T587xn8LISaFEI+LVLOrrCeLZbpcyX070LbWOWWSLJanvubTK88tsWXlIqW8Ukp55Qpvnw88L6W8VaZKh1zHyh3NzifV6Oc2maq4+61Vxq4HD6kSJQvJpvLby5LF8qwlVf34IaAS+Ffgf+cWdFaTxTK9F3ifEKJRCFEA/PPc61ltuWSxPPU1n155bont3harZkHJZ5nyEq1UAnq5sVspPZ7t5bc3QyblOQv0SCl/MLcldtPc8Zd9isohMinT/yLV0OlhUpV7H5p7PVtK7m8Gfc2nl0zKc0vsRMl9o+SzEEKwcgnoYVJPxwvH1q4wdj0sLb/dTGrL4fAWjplpMinPp9nmEt0ZImMylVImpZRXSSkbpZS1pNbs4NxPrqKv+fSSSXluie1WLncDxwoh3iyEsAAfIbWlstLY44UQb5wb+8FVxsLa5aJ/ClwghDhLpPo6XAPcJqXM5aeYTMrzdqBICPFuIYRZCHEJqUqpv9vwWWQXGZOpEKJYCNEiUhwDfAO4RkqZ3NSZZAf6mk8vmZQnIlVu3z7358Ly+2uSDof+d0WqTesRSCkngEuBa4FJUo7KZW9GC8Z+dW7sMcBBVi4XfTUp57JPCPGWZY73HPABUgtujNS+60r7mllDFstzCrgQ+DipfexPAhfNfU9Wk60yJeWgvYdUTsa9wH9JKf9znaeVMbJVnvqaT/v6hPl8HIAX5/5eF1lbW0wIYSK1X3i5lPKhtcZrVkfLM/1omaYXLc/0kml5ZlVtMSHEeUKIQiGEHfg0qdDMP2R4WjmLlmf60TJNL1qe6SWb5JlVygU4g1Qc9wSpBLM3SinXbYZpjkDLM/1omaYXLc/0kjXyzNptMY1Go9HkLtlmuWg0Go1mF7BWJ8rdbtaItYekFS3P9KNlml60PNPLnpWntlw0Go1Gk3a0ctFoNBpN2tHKRaPRaDRpRysXjUaj0aSdtRz6miwnFosxPj5ONBolFoshhMDhcGCz2SgpKcFsNmd6ihqNZg+ilUsOE4vFGBoa4tprr6W3t5f+/n4sFgsnnHACTU1NfPCDH6SsrCzT09RoNHsQrVxylFgsxuTkJMPDw3R1ddHd3U1/fz82m42qqiqKi4tJJBKZnqZGo9mjZES5/OY3vwHg5S9PdeA8dOgQAHfddRcAd999NwCvf/3rF33ujDPOAOCss87akXlmK0qx3HTTTXR2dvLMM8/g9XqJRqPk5eXR2NhIQ0MDNpst01PVaDQ7wNVXXw3A5z//eQAOHDgAwEMPZa7+p7ZccoxEIsH09DTj4+N0d3fT19dHMpnEbrdTVlZGaWkp1dXVlJeXa3+LJutIJpNIKYnFYiQSCcLhMPF4HL/fTzKZamNjMplwOp2YzWbjJy8vD7PZjMmkY5ByhbVqi6Ulu3RmZgaAyy+/HIBf//rXADidTiD1JA7g96/e00eNd7vdAPz7v/87AJdccslmp5Zz2brT09Pcd999dHZ2cuONN+L3+6mvr6eiooKLLrqI6upqTjzxRDweD3l5eTt9MeoM/fSTc2t0JZLJJKFQiNnZWfr7+/H5fDz77LOMjIxw33334ff7EULgdrs55ZRTyMvLo7S0lJKSEs4991yKiorIz8/f6preNfJcyKte9SoAHn744UWvK8tFWTLbwIry1JZLjpFIJPD5fExOTjI9PU0kEqGgoICysjKam5uprq6mrKxMb4lpsoZEIkEgECASiTA2NkYwGKSnpwefz0d7ezujo6N0dnYaD6Eej4eCggLy8/Pxer34fD4GBwdJJBK4XC69tnOEHVEu//zP/wzM+1QUs7OpStBHH300AOXl5QDk5+cvGqfMZeWLUZ9773vfC8C+ffsAOOGEE9I+92wjmUwyPT3NzMwMiUQCu93OMcccQ0tLC0cffTQlJSVYrdZMT1OjAeYfhu6//34GBgZ48MEH8Xq9jI+PE4/HjW2xUCgEgBCCcDjME088gclkwmQyUVBQwPT0NC0tLbz3ve+lpKQkw2eVfSy1WJa+vo2Wy4poyyXHkFISjUaJx+MAmM1mioqKKC4u1k91mqwikUgwMzPD5OQknZ2d9PX10dXVhc/nY3p62ohmNJlMWK1WrFYrsViMZDJJMBg0jpNMJunt7cVutxtb6JrsZ1uVy7PPPgvArbfeuuj1uro6AH70ox8B0NraCkBhYSGQMosXoiyXa665BoAvfOELwLwvR0VK/OAHPwCgqKgobeeQbSSTSSKRCOFwGJPJhMvl4phjjqG1tRW73Z7p6e06nnzySQA++9nPAnDPPfcAKSUPqSdtgEsvvRSAf/mXfwGgqqoKmN/zPuecc4B5v+FeIBgM8sgjj9DV1cVPf/pTxsbGCIVCJBKJRWHydrudtrY2IBU5GoksbvkeCoV47LHHmJycNCwczfpQ98ZMoC2XHCKRSBCLxZiensbv92OxWHC73RQWFqbD0anRpI1YLEYoFKKvr4+enh4mJibw+XyLxlgsFvLz88nLy6O5uRkpJV6vl5mZGQKBgKGAlM8mEAigmxvmDtuqXAKBAAATExPA/FPeJz7xCWD9+4Dqpqm0cDQaBeDrX/86ALfffjsA73nPewB4wxvesMWZZx9q73pwcJBHH32UoaEhqqqqaGlpoaWlhbq6Ou1rSQNq2+WRRx4B4IorrgBgeHgYmF/DCvW3ss6VZdLX1wfM73krK/0d73jHNs08e1CVI7q7u7njjjvo6ekx7gULyc/P5+KLL6axsZHzzz+fRCLBz3/+c3p6erjvvvuMnQlNbqItlxwhkUgwOTnJ+Pg4Pp+PQCCAxWLBbrcbtcQ2gvLdJJPJRVsUQgisVismkwmLRS8PzcZQFsvIyAjDw8OMjY3h9XqNNWa1WrFYLJSUlFBRUUFrayuNjY3U1dURj8dpbW3FbDbT2NjIxMQEExMTxjZaPB5nYGAAp9NJeXm5Xp9Zzrb+7yzdO1VPgR/60Ie2dNwvfelLANx0000AdHd3A3DbbbcBu9NymZmZ4a677qK9vX3NfKD1EI1G6ezsJBQK4fV6jQABm81GXV0dbrebioqKPXcBP/HEEwCcd955i16vrq4G4PrrrwfA5XIter+3t3fR6x/+8IcBDD+Y8sHsZpTFMjIyws0330xPTw+Dg4MEAgGSySRWq5WioiJqa2v58Ic/TH19Pfv27cPtduPxeJBSctFFFxEIBHj5y19Ob28v3/72txkeHiYYDDI6OsrVV1/Nvn37uPrqq/eETNfLVVddBcxn6CvUbk8mfC97686Rw8TjcUZGRhgZGSGRSGA2m4396vX4WtS2WiwWIxwOMzs7S0dHB8FgkMnJSSNowmazEYlEDB+O0+nU/hzNukgmk/j9fnw+HwMDAwwPDxOJRIjH40ZYsbJYmpubqauro7S0FKvVamwvFhUV4XK5jICVsrIyZmdnCYfDxGIxenp6MJlMDA8PY7PZKCws1JUospRtVS4qwkZx2mmnpfX4r3vd64D5TP0//OEPaT1+NhEOh3n66ac5fPgw4XCYwsJCzjzzTPbt23fEU/Ry+Hw+fvKTnzAwMMDTTz/NzMwMPp/PyDVQ2xYWiwWPx0NpaSmve93rqK+v54ILLqCgoGC7TzGjqMjGCy+8cNHrr3nNawD48pe/DMDJJ5+87OeHhoYAuOiiiwAM57XyL6posd1MNBqlv7+fjo4O/vznPzM8PEw4HAZSftP8/Hxe9apX0draSltbG8XFxVgslkV+LLPZjNPppLm5GbfbzYEDB2hvbzcy+IeGhgiHw3z/+99n3759vOtd76K4uDhTp5w1LLVYsgFtueQAUkoSiYRROkP1bKmurqaysnLZrSvlU4nFYkxNTTEyMkJ7ezsDAwMcPnzYeBpMJpMIIYx6T4Dh0+nu7sZkMjE7O4vH49FPiJpVSSaT+Hw+vF4vwWDQSHYWQhgWcF1dHbW1tbhcrhUDUIQQ2Gw2PB4P9fX1RKNR3G63sWZDoRDDw8Pk5eXpvJcsZluUS1dXFwCDg4PAfP7K8ccfn9bvefWrXw3MWy67EaUkVOKkEILCwkKqqqo466yzaGpqOsJyUbkwqsfLDTfcwMDAAH19fcaWmBACl8tFfn4+LS0tQCrCSflgxsfHefjhh+nr6+Occ84xtjR2q4L54he/CMD4+Dgw77f713/9VwAjD2MllOWjfDYKZV3vBcLhMM888wwdHR1EIhHjocXhcLB//35aW1u54IILqK2tNeoDrkZBQQEXX3wx3d3dHDx4kM7OToaGhoztMZvNppVLFqMtlywnmUwyMzPD9PQ0sVgMKSX5+flGEb+FF6mKqlF5Ah0dHfT19Rn1m1SegNvtxm63U1lZSV5eHq2trZhMJhwOBzMzMxw+fNjIp/F6vczOzhKJRHSOgWZFkskksVgMn8+Hz+czfHgq+rC0tJTy8nKKiorIy8tb1zFNJhOFhYWUlpZSWlpqWOBSSiKRCNFoVK/JLGZblMtPfvITYN6CUVWLVf8WzfoJBoP85je/ob29nZGREaLRKMceeyxtbW04HA5jnHLY+3w+HnnkEfr7+7n99tuZmJhgcnISgLy8PAoKCjj99NOprq7mnHPOobi4mIqKCsxmM7FYjJGREa677jp6enp4/vnn8Xq9TE1NUVxcvCvDP//mb/4GgJ///OfAfHWIa6+9FljbYlFPzsono252Kofrla98ZXonnIUkk0kCgQBTU1N0dnbS3d1t5KJBKoLujDPOoK2tbVMVClwuF6effjolJSX09PToLP0cYXfdKXYhKr9lcnLSuGCXixJT48bGxujq6qK3t5e+vj78fj92ux273U5NTQ2lpaW0tbVRXV1Nc3MzhYWFFBUVGdtdVquVkpISpqamgFSUWjwe110tNSuSTCYNX4jf7ycYDJJMJjGbzVitVlwuF+Xl5ZSVlW3q4cRkMuHxeHC73cY6VX5ItTZ363ZtLrMtyuVnP/sZMO9r+fu///vt+Jo9gYrA6e/vJxqNYrfbqaioOMKRr/Jgurq6uOeeewynqt1uZ//+/dTW1nLZZZdRXV1NS0sLLpcLl8tlNGNSWCwWKioqmJmZ2RMX7MGDB4H5THu1zXjMMces+jllsaiIyEcffXTRcT73uc+lf7JZivKBdHV1MTw8zOTkJPF4HLvdzr59+2hqauKUU06hrq5ukbW9WVRhSxX2XFBQQEFBwZ5Yr7mEtlyyHCklwWCQUCiElBIhBGazeZFiicfjzM7OMjAwQH9/v1Hgz+12U1BQYJSHaWpqoqKigrKyslUjdSwWy6Lsf1UBYGnpE40G5vNbZmZmiMViixJyKysrqaqqoqCgALfbnZY1pCIbw+EwwWCQcDh8RJsOTebZVuVy1FFHAXDmmWdu59fsapQvZXp62nCSLkQlV/b09PDYY4/R29tLOBzG7XZz9tln09TUxLvf/W4qKiqMvIL11CCz2+00NDRQWlpKS0sL9fX1unYZ0NPTA8ANN9wAzEeTKVQm/0knnbST08oo0WiU3t5eent7F0Vv5eXlceGFF9LW1kZlZSUulystybjxeJypqSlcLhf9/f3Y7XZjbWsWo6sia1ZESkk8HjciY5ZGx6gLbXx8nOnpaUKhEE6nk6KiIpqbm2lubqa2tnZDF18ikUBKafhqHA4HdrtdWy6aZZFSEg6HCYfDi9aoxWKhsrKSyspKbDZb2qo8KMtFXRcqilKTXaRVuagGP8os1mwdFXa5MItevQ4pmf/617+mvb3dqD596qmn0tzczPve9z6qq6s3tB+tcmQikciiJk679alQdUF9+umnAYxAhpe85CXLjld5MCojf6nCVZn4yt+4F1C5WJFI5Ig+Lfv27aOtrS1tTezUul/uQUuTXezOO8YuI5lMrnghLQxBVlsSDocDt9tNWVnZhkpjLOwXMz09bfhftMWiWQ0VLaYsF4WqJKGb2O1N0qpcbr75ZgA6OjoAKC0tTefhj+CXv/zlor93q09guZu7em2hclFKaHp6Gp/Pt6Hw4aX9YkZHRznxxBN3fWFA1b1UVZq+++67gXlLZiXU2vvxj38MzPdz+cAHPrAt88xmVLRYb2/vEbsW6X4wUccTQuiHnixHl7rNMZZeUGazmaKiIoqLi42ILtW1b2pqyrBolgsGWEg8Hmd4eJjBwUF8Ph+RSITCwkKKi4t3tXLRbJ2FJYpURON23vhVxKTJZDL+1WQfObkt9uc//xmAO++8c9Hrqn/5XqKwsJB3vvOddHZ28txzzzEwMEB3dzd+v5877riDxsZGDhw4YISCrnQhTk5OcsMNN9DR0YHf76eoqIjzzjuP1tbWddWBylVUxrhaS6pzpMp/Uai8l/PPPx+AK6+8EoBbbrkFgP379wMYddo024cQwgg0ycvLw+PxaAWTheSkctkrqAzk1SwPi8VCeXk5s7OzNDU1ATAwMEAkEqG7u5tEIkFjYyPl5eXU19cbUV8qwicWi+H3+41e56rabHl5OZWVlZvOqtZo0oXKo/H7/SQSCSwWC8XFxZSVleF2u3E4HHqLLAvJqbuGslhUboHqmaHyaHZTBVrlA5mcnMTr9a6Y52IymXC73TQ3N3PVVVfR19fHt771LQYHB7nnnnuw2+38+c9/pqmpiY9+9KNUVlbicDgIh8M89dRTDA8Pc+eddzIyMsITTzyB1Wrl3HPPpaWlhRNOOGHVhMvdiKoJpv5die9+97vA/DblqaeeCkBZWdm2zW2vEgqFeOyxx2hvb2d2dpb8/HwuvPBCWltbOe644yguLt5Ta3Q51HpVlrdCd6LUrIjav1Y3MRWZMzs7azjwTSYTdruduro6zGYzra2tWK1Wo0S/slTi8TiRSMR4Cuzo6GBoaIiuri4mJyexWq0UFBTQ1NREY2MjHo8nbSGkmt3LQr+f1WrFbDYbFbrHx8cpKChYVL9uo6hK3yrowuFwUF9fT319PW63W6/RLCWtyqWxsREg7aUYVNTT17/+dQBuuukmAGpraxe9vpu2b8xms1FuvLq6mlAoxPj4OOFwmBdffJFEIoHf7zcuLrPZbPhVPve5zzEzM8Pjjz9OMpmkoaEBl8uFzWZjaGiIu+++m76+Ph588EHDeZ+fn8+5555LU1MTb3/72yktLV13afS9hMrQVygZffSjH935yWQJ+fn5XHLJJXR2dtLV1cXAwADBYBCv18sPf/hD2trauOKKKygpKdnU8VXV5WAwiMfjobKykle96lU0NzevqwurJjPsnrvxLsRsNmO32w3l0tnZSTwex+v1MjY2Rn9/P4lEwnhiNJlMCCEoKioyqhtHIhEAo3mYz+czOlKOjY0RjUYpKSmhrKyMlpYWGhsbKS0t3fVtjTXpY6Hfr7Ky0kj6jcVi9Pb2YrPZCAaD5OXlYbVa1+0fSSQSRuO6UChEMpnE5XKRl5dHYWEh+fn5OpIxi0mrclGdIVV9penpaQAjc3y9eS8qx0DVb1Ld/R5//PFF41TfmNNOO20r085qioqKeNe73kVPTw9TU1P09/fz4osvGhFhVVVVnHfeeRQVFS3KxA8Gg7z44otMTU3R0dHB9PQ03d3dhMNhI0EyPz+fsrIy3vSmN1FXV8fZZ59NQUGBtlhW4Zprrln0t+pYefLJJ2diOlmB1Wqlvr6evLw83v72t9PR0cEPfvADvF4vBw8eZGxsjDe84Q1Eo1Hq6+vXvY3l9Xr50Y9+RHt7O/39/cRiMY499lj27duH2+3e834WmPexLPW1ZAPacslyVH2mRCJBU1MTQgimpqaYnZ2lt7eXUChEe3v7EcolFAoxMDCA1+ulp6eH6elpenp6SCQSOJ1OXC4XDQ0NVFVV0draSk1NDWVlZZtq5qTZ26huky6Xy7CyCwoKjKrFqjT+zMzMmvlWMF/yyO/3G626Y7EYFouF6upqKisrtWLJAbZVubzwwgsAnHfeeQBUVVWt63N//OMfgXmLR6EicS644AJgPkJnN6OcpU6nk3/8x3+ku7ubL3/5ywwODtLX10dvby8vvPDCEX1ZVI0wFcqsmn653W5e/vKX09DQwFvf+lYqKiqoqqoy8gY0y/Pss88CcNttty16fTdFKG4Vm81Ga2srLpeLM888k97eXg4ePIjf7+fQoUMkk0laW1vXXGeRSIQXX3yRrq4u/vCHPzA8PIzNZqOqqooLL7yQ5uZmbV3P8fnPfz7TU1gRbbnkAGazGYfDQXV1NclkkpaWFqxWK729vYYCURFkUspFpc2V0jGZTLhcLgoLC2lra6O+vp7GxkZKSkpWTa7UaNaL6hhZWFhIfX09yWSSZ555BoDh4WFcLhdjY2MkEgkKCgoWrbl4PE4ymSQajeL3+41yMqrpnaoWoXKvtK8l+9kW5fKlL30JgC984QvAvM9ko6jFp6JMPvaxjwHwyU9+cqtTzDlUNJjT6eSzn/0sU1NTPPbYY/h8PsbGxvB6vTzyyCMIITj77LOPUBh5eXmceeaZlJSUGFE2yiGqFcvaPPnkk0Cq4yfM57doa28ei8ViRBlecskldHd38/zzzzMyMsK9995LYWEh09PTNDU18aY3vcmoHK16EgWDQXp6ehgcHORHP/oRIyMjDAwM4Ha7Oe2002hra6OlpWXP5V4tx1q+loceeghYO19rO9GWSw6hosdqamrIz883ergUFBTg9XoZGRlBCEFbWxsej2dRVE5eXh6tra3G099uCtvWZA9qXZWVlREOh2lqasJsNjM0NEQgEKCnp4dkMklPTw+lpaW43W6i0Sg9PT3MzMzQ1dXF0NAQ/f39TE1NYbPZ8Hg81NTUUF1djdPp3POKJVcQa/RE2FLDBNXzQu1LKxN5Ld7//vcD8z01trHS7E7XjEhLAwopJYlEwujxEo/HSSQShEIhAFwu1xHbBmpbbGmL5DSTiRocO9LU4xvf+AYA//RP/wTAcccdB8BTTz213V+dk2tUrc/Ozk7DEhkeHqa/vx+z2UxTUxNlZWW88pWvJBaLceuttxrVKCKRCDMzM9jtdo477jjq6+v567/+a2pqamhpadlqCf+clOdSlMXyqle9CoCrrroKyEgm/ory1I+vOYjqs+LxeDI9FY1mWZSfsLa2FqvVSlNTE1arFb/fTzQaZWJigmg0SmdnJ7FYDK/Xi9/vN/KyKioq8Hg8tLa2UltbS3l5+Zay/DU7z7ZaLjnArniKySJ2reWirGiVg/WVr3wFgI9//OPb/dU5vUZVA7rh4WGCwSB9fX2MjY1x7733Mj4+TldXF1arlTPOOAO3220kSr70pS+luLjYyGkpKirCYrGkw+rOaXlmIdpy0Wg0O48KGKmoqCASiWA2m/F4PDQ2NuJwOPD5fNhsNhobG42yUS6Xi9bWVoqKiqipqcFut+ugkxxEKxeNZh0cffTRwNodKjVHIoTA6XQa7bcbGhrYv3+/UUhVCLGoJ4vJZMLhcGA2mzdULkaTXWjlotFoth1Vndtms2Gz2XTByT2AVi4azTr4q7/6KwC6urqAvVEdQqPZCnojU6PRaDRpR0eL7SxanulHyzS9aHmmlz0rT225aDQajSbtrGW5aDQajUazYbTlotFoNJq0o5WLRqPRaNKOVi4ajUajSTtauWg0Go0m7WjlotFoNJq0o5WLRqPRaNLO/wckXdn17dPy6QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 15 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 22;\n",
       "                var nbb_unformatted_code = \"# %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\\nimport sys\\n\\nsys.path.append(\\\"../../pytorch_ipynb\\\")\\n\\nfrom helper_plotting import show_examples\\n\\n\\nshow_examples(\\n    model=lightning_model, data_loader=test_dataloader, class_dict=class_dict\\n)\";\n",
       "                var nbb_formatted_code = \"# %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\\nimport sys\\n\\nsys.path.append(\\\"../../pytorch_ipynb\\\")\\n\\nfrom helper_plotting import show_examples\\n\\n\\nshow_examples(model=lightning_model, data_loader=test_dataloader, class_dict=class_dict)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "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": "5b73177d",
   "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": "50db45b8",
   "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": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 23;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/plot_confusion-matrix_basic.py\\nfrom torchmetrics import ConfusionMatrix\\nimport matplotlib\\nfrom mlxtend.plotting import plot_confusion_matrix\\n\\n\\ncmat = ConfusionMatrix(num_classes=len(class_dict))\\n\\nfor x, y in test_dataloader:\\n\\n    with torch.no_grad():\\n        pred = lightning_model(x)\\n    cmat(pred, y)\\n\\ncmat_tensor = cmat.compute()\\ncmat = cmat_tensor.numpy()\\n\\nfig, 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\\nplt.show()\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/plot_confusion-matrix_basic.py\\nfrom torchmetrics import ConfusionMatrix\\nimport matplotlib\\nfrom mlxtend.plotting import plot_confusion_matrix\\n\\n\\ncmat = ConfusionMatrix(num_classes=len(class_dict))\\n\\nfor x, y in test_dataloader:\\n\\n    with torch.no_grad():\\n        pred = lightning_model(x)\\n    cmat(pred, y)\\n\\ncmat_tensor = cmat.compute()\\ncmat = cmat_tensor.numpy()\\n\\nfig, 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\\nplt.show()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "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": "2f25a950",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "matplotlib       : 3.3.4\n",
      "pytorch_lightning: 1.5.1\n",
      "pandas           : 1.4.1\n",
      "torchvision      : 0.11.2\n",
      "numpy            : 1.22.0\n",
      "sys              : 3.8.12 | packaged by conda-forge | (default, Oct 12 2021, 21:59:51) \n",
      "[GCC 9.4.0]\n",
      "torchmetrics     : 0.6.2\n",
      "torch            : 1.10.1\n",
      "\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 24;\n",
       "                var nbb_unformatted_code = \"%watermark --iversions\";\n",
       "                var nbb_formatted_code = \"%watermark --iversions\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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
}