{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d6b34308",
   "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": "26637448",
   "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": "0349303a",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext pycodestyle_magic\n",
    "%flake8_on --ignore W291,W293,E703,E402,E999 --max_line_length=100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4a01b5f5",
   "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": "5258ee70",
   "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",
    "#  All-Convolutional Neural Network Trained on MNIST."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1100821b",
   "metadata": {},
   "source": [
    "All-Convolutional neural network [1][2] Trained on MNIST [3]\n",
    "\n",
    "### References\n",
    "\n",
    "- [1] L14.4.1 Replacing Max-Pooling with Convolutional Layers (08:19), https://www.youtube.com/watch?v=Lq83NFkkJCk\n",
    "- [2] Striving for Simplicity: The All Convolutional Net, https://arxiv.org/abs/1412.6806\n",
    "- [3] https://en.wikipedia.org/wiki/MNIST_database"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7e27d9d",
   "metadata": {},
   "source": [
    "## General settings and hyperparameters"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d137a5ee",
   "metadata": {},
   "source": [
    "- Here, we specify some general hyperparameter values and general settings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "05ce9388",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 4;\n",
       "                var nbb_unformatted_code = \"BATCH_SIZE = 128\\nNUM_EPOCHS = 20\\nLEARNING_RATE = 0.005\\nNUM_WORKERS = 4\";\n",
       "                var nbb_formatted_code = \"BATCH_SIZE = 128\\nNUM_EPOCHS = 20\\nLEARNING_RATE = 0.005\\nNUM_WORKERS = 4\";\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": [
    "BATCH_SIZE = 128\n",
    "NUM_EPOCHS = 20\n",
    "LEARNING_RATE = 0.005\n",
    "NUM_WORKERS = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "874744ee",
   "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": "75d875b4",
   "metadata": {},
   "source": [
    "## Implementing a Neural Network using PyTorch Lightning's `LightningModule`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50635763",
   "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": "4f14a375",
   "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\\nclass PyTorchModel(torch.nn.Module):\\n\\n    def __init__(self, num_classes):\\n        super().__init__()\\n        \\n        self.num_classes = num_classes\\n        # calculate same padding:\\n        # (w - k + 2*p)/s + 1 = o\\n        # => p = (s(o-1) - w + k)/2\\n        \\n        self.features = torch.nn.Sequential(\\n            # 28x28x1 => 28x28x4\\n            torch.nn.Conv2d(in_channels=1,\\n                            out_channels=4,\\n                            kernel_size=(3, 3),\\n                            stride=(1, 1),\\n                            padding=1),  # (1(28-1) - 28 + 3) / 2 = 1\\n            torch.nn.ReLU(),\\n        \\n            # 28x28x4 => 14x14x4\\n            torch.nn.Conv2d(in_channels=4,\\n                            out_channels=4,\\n                            kernel_size=(3, 3),\\n                            stride=(2, 2),\\n                            padding=1),\\n            torch.nn.ReLU(),\\n            \\n            # 14x14x4 => 14x14x8\\n            torch.nn.Conv2d(in_channels=4,\\n                            out_channels=8,\\n                            kernel_size=(3, 3),\\n                            stride=(1, 1),\\n                            padding=1),  # (1(14-1) - 14 + 3) / 2 = 1\\n            torch.nn.ReLU(),\\n        \\n            # 14x14x8 => 7x7x8                             \\n            torch.nn.Conv2d(in_channels=8,\\n                            out_channels=8,\\n                            kernel_size=(3, 3),\\n                            stride=(2, 2),\\n                            padding=1),\\n            torch.nn.ReLU(),\\n        \\n            # 7x7x8 => 7x7x16                             \\n            torch.nn.Conv2d(in_channels=8,\\n                            out_channels=16,\\n                            kernel_size=(3, 3),\\n                            stride=(1, 1),\\n                            padding=1),  # (1(7-1) - 7 + 3) / 2 = 1\\n            torch.nn.ReLU(),\\n        \\n            # 7x7x16 => 4x4x16                             \\n            torch.nn.Conv2d(in_channels=16,\\n                            out_channels=16,\\n                            kernel_size=(3, 3),\\n                            stride=(2, 2),\\n                            padding=1),\\n            torch.nn.ReLU(),\\n        \\n            # 4x4x16 => 4x4xnum_classes                             \\n            torch.nn.Conv2d(in_channels=16,\\n                            out_channels=self.num_classes,\\n                            kernel_size=(3, 3),\\n                            stride=(1, 1),\\n                            padding=1),  # (1(7-1) - 7 + 3) / 2 = 1\\n            torch.nn.ReLU(),\\n            torch.nn.AdaptiveAvgPool2d(output_size=1),\\n            torch.nn.Flatten()\\n        )\\n        \\n    def forward(self, x):\\n        logits = self.features(x)\\n        return logits\";\n",
       "                var nbb_formatted_code = \"import torch\\nimport torch.nn.functional as F\\n\\n\\nclass PyTorchModel(torch.nn.Module):\\n    def __init__(self, num_classes):\\n        super().__init__()\\n\\n        self.num_classes = num_classes\\n        # calculate same padding:\\n        # (w - k + 2*p)/s + 1 = o\\n        # => p = (s(o-1) - w + k)/2\\n\\n        self.features = torch.nn.Sequential(\\n            # 28x28x1 => 28x28x4\\n            torch.nn.Conv2d(\\n                in_channels=1,\\n                out_channels=4,\\n                kernel_size=(3, 3),\\n                stride=(1, 1),\\n                padding=1,\\n            ),  # (1(28-1) - 28 + 3) / 2 = 1\\n            torch.nn.ReLU(),\\n            # 28x28x4 => 14x14x4\\n            torch.nn.Conv2d(\\n                in_channels=4,\\n                out_channels=4,\\n                kernel_size=(3, 3),\\n                stride=(2, 2),\\n                padding=1,\\n            ),\\n            torch.nn.ReLU(),\\n            # 14x14x4 => 14x14x8\\n            torch.nn.Conv2d(\\n                in_channels=4,\\n                out_channels=8,\\n                kernel_size=(3, 3),\\n                stride=(1, 1),\\n                padding=1,\\n            ),  # (1(14-1) - 14 + 3) / 2 = 1\\n            torch.nn.ReLU(),\\n            # 14x14x8 => 7x7x8\\n            torch.nn.Conv2d(\\n                in_channels=8,\\n                out_channels=8,\\n                kernel_size=(3, 3),\\n                stride=(2, 2),\\n                padding=1,\\n            ),\\n            torch.nn.ReLU(),\\n            # 7x7x8 => 7x7x16\\n            torch.nn.Conv2d(\\n                in_channels=8,\\n                out_channels=16,\\n                kernel_size=(3, 3),\\n                stride=(1, 1),\\n                padding=1,\\n            ),  # (1(7-1) - 7 + 3) / 2 = 1\\n            torch.nn.ReLU(),\\n            # 7x7x16 => 4x4x16\\n            torch.nn.Conv2d(\\n                in_channels=16,\\n                out_channels=16,\\n                kernel_size=(3, 3),\\n                stride=(2, 2),\\n                padding=1,\\n            ),\\n            torch.nn.ReLU(),\\n            # 4x4x16 => 4x4xnum_classes\\n            torch.nn.Conv2d(\\n                in_channels=16,\\n                out_channels=self.num_classes,\\n                kernel_size=(3, 3),\\n                stride=(1, 1),\\n                padding=1,\\n            ),  # (1(7-1) - 7 + 3) / 2 = 1\\n            torch.nn.ReLU(),\\n            torch.nn.AdaptiveAvgPool2d(output_size=1),\\n            torch.nn.Flatten(),\\n        )\\n\\n    def forward(self, x):\\n        logits = self.features(x)\\n        return 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",
    "class PyTorchModel(torch.nn.Module):\n",
    "\n",
    "    def __init__(self, num_classes):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.num_classes = num_classes\n",
    "        # calculate same padding:\n",
    "        # (w - k + 2*p)/s + 1 = o\n",
    "        # => p = (s(o-1) - w + k)/2\n",
    "        \n",
    "        self.features = torch.nn.Sequential(\n",
    "            # 28x28x1 => 28x28x4\n",
    "            torch.nn.Conv2d(in_channels=1,\n",
    "                            out_channels=4,\n",
    "                            kernel_size=(3, 3),\n",
    "                            stride=(1, 1),\n",
    "                            padding=1),  # (1(28-1) - 28 + 3) / 2 = 1\n",
    "            torch.nn.ReLU(),\n",
    "        \n",
    "            # 28x28x4 => 14x14x4\n",
    "            torch.nn.Conv2d(in_channels=4,\n",
    "                            out_channels=4,\n",
    "                            kernel_size=(3, 3),\n",
    "                            stride=(2, 2),\n",
    "                            padding=1),\n",
    "            torch.nn.ReLU(),\n",
    "            \n",
    "            # 14x14x4 => 14x14x8\n",
    "            torch.nn.Conv2d(in_channels=4,\n",
    "                            out_channels=8,\n",
    "                            kernel_size=(3, 3),\n",
    "                            stride=(1, 1),\n",
    "                            padding=1),  # (1(14-1) - 14 + 3) / 2 = 1\n",
    "            torch.nn.ReLU(),\n",
    "        \n",
    "            # 14x14x8 => 7x7x8                             \n",
    "            torch.nn.Conv2d(in_channels=8,\n",
    "                            out_channels=8,\n",
    "                            kernel_size=(3, 3),\n",
    "                            stride=(2, 2),\n",
    "                            padding=1),\n",
    "            torch.nn.ReLU(),\n",
    "        \n",
    "            # 7x7x8 => 7x7x16                             \n",
    "            torch.nn.Conv2d(in_channels=8,\n",
    "                            out_channels=16,\n",
    "                            kernel_size=(3, 3),\n",
    "                            stride=(1, 1),\n",
    "                            padding=1),  # (1(7-1) - 7 + 3) / 2 = 1\n",
    "            torch.nn.ReLU(),\n",
    "        \n",
    "            # 7x7x16 => 4x4x16                             \n",
    "            torch.nn.Conv2d(in_channels=16,\n",
    "                            out_channels=16,\n",
    "                            kernel_size=(3, 3),\n",
    "                            stride=(2, 2),\n",
    "                            padding=1),\n",
    "            torch.nn.ReLU(),\n",
    "        \n",
    "            # 4x4x16 => 4x4xnum_classes                             \n",
    "            torch.nn.Conv2d(in_channels=16,\n",
    "                            out_channels=self.num_classes,\n",
    "                            kernel_size=(3, 3),\n",
    "                            stride=(1, 1),\n",
    "                            padding=1),  # (1(7-1) - 7 + 3) / 2 = 1\n",
    "            torch.nn.ReLU(),\n",
    "            torch.nn.AdaptiveAvgPool2d(output_size=1),\n",
    "            torch.nn.Flatten()\n",
    "        )\n",
    "        \n",
    "    def forward(self, x):\n",
    "        logits = self.features(x)\n",
    "        return logits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "063db1bd",
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "689f43c8",
   "metadata": {},
   "source": [
    "## Setting up the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7832b63a",
   "metadata": {},
   "source": [
    "- In this section, we are going to set up our dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6514660d",
   "metadata": {},
   "source": [
    "### Inspecting the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a2cda77f",
   "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": "73b0868f",
   "metadata": {},
   "source": [
    "### Performance baseline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37c9f167",
   "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": "a3d2484d",
   "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": "074b4cbc",
   "metadata": {},
   "source": [
    "## A quick visual check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6f2c157f",
   "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"
    },
    {
     "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": "7870b0fc",
   "metadata": {},
   "source": [
    "### Setting up a `DataModule`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44006335",
   "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": "22f66688",
   "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": "588ac808",
   "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": "f6ced83f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 11;\n",
       "                var nbb_unformatted_code = \"import torch\\n\\n\\ntorch.manual_seed(1) \\ndata_module = DataModule(data_path='./data')\";\n",
       "                var nbb_formatted_code = \"import torch\\n\\n\\ntorch.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": [
    "import torch\n",
    "\n",
    "\n",
    "torch.manual_seed(1) \n",
    "data_module = DataModule(data_path='./data')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b14b35d",
   "metadata": {},
   "source": [
    "## Training the model using the PyTorch Lightning Trainer class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5e945cd",
   "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": "f5904d2b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 12;\n",
       "                var nbb_unformatted_code = \"pytorch_model = PyTorchModel(num_classes=10)\";\n",
       "                var nbb_formatted_code = \"pytorch_model = PyTorchModel(num_classes=10)\";\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(num_classes=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "7f4918ad",
   "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\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7c6020b",
   "metadata": {},
   "source": [
    "- Now it's time to train our model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "33118695",
   "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 | 6.0 K \n",
      "1 | train_acc | Accuracy     | 0     \n",
      "2 | valid_acc | Accuracy     | 0     \n",
      "3 | test_acc  | Accuracy     | 0     \n",
      "-------------------------------------------\n",
      "6.0 K     Trainable params\n",
      "0         Non-trainable params\n",
      "6.0 K     Total params\n",
      "0.024     Total estimated model params size (MB)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e3bebc4e40d34236a1bc5ace2f19305c",
       "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": "767a4f516311404fa871ab8d10cb0ca6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training took 1.93 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=False,\\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=False,\\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=False,\n",
    "    log_every_n_steps=10,\n",
    ")\n",
    "\n",
    "start_time = time.time()\n",
    "trainer.fit(model=lightning_model, datamodule=data_module)\n",
    "\n",
    "runtime = (time.time() - start_time) / 60\n",
    "print(f\"Training took {runtime:.2f} min in total.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "704a3a83",
   "metadata": {},
   "source": [
    "## Evaluating the model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "accd76cb",
   "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": "d0a6d2ae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "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": "6d5dede8",
   "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": "cacdd1c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Restoring states from the checkpoint path at logs/my-model/version_12/checkpoints/epoch=11-step=5147.ckpt\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "Loaded model weights from checkpoint at logs/my-model/version_12/checkpoints/epoch=11-step=5147.ckpt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "07eed61e781f480dac305dd6e4f2a512",
       "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.9821000099182129}\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[{'test_acc': 0.9821000099182129}]"
      ]
     },
     "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": "3d02a1a1",
   "metadata": {},
   "source": [
    "## Predicting labels of new data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "486b490d",
   "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": "8eaed4eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logs/my-model/version_12/checkpoints/epoch=11-step=5147.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": "80f6d64d",
   "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": "a0fc9346",
   "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": "db15eda6",
   "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": "4cf16956",
   "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": "d6e53410",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy: 0.9821 (98.21%)\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": "62bc77a8",
   "metadata": {},
   "source": [
    "## Inspecting Failure Cases"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "482f724b",
   "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": "fa06b964",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 21;\n",
       "                var nbb_unformatted_code = \"class_dict = {0: 'airplane',\\n              1: 'automobile',\\n              2: 'bird',\\n              3: 'cat',\\n              4: 'deer',\\n              5: 'dog',\\n              6: 'frog',\\n              7: 'horse',\\n              8: 'ship',\\n              9: 'truck'}\";\n",
       "                var nbb_formatted_code = \"class_dict = {\\n    0: \\\"airplane\\\",\\n    1: \\\"automobile\\\",\\n    2: \\\"bird\\\",\\n    3: \\\"cat\\\",\\n    4: \\\"deer\\\",\\n    5: \\\"dog\\\",\\n    6: \\\"frog\\\",\\n    7: \\\"horse\\\",\\n    8: \\\"ship\\\",\\n    9: \\\"truck\\\",\\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": [
    "class_dict = {0: 'airplane',\n",
    "              1: 'automobile',\n",
    "              2: 'bird',\n",
    "              3: 'cat',\n",
    "              4: 'deer',\n",
    "              5: 'dog',\n",
    "              6: 'frog',\n",
    "              7: 'horse',\n",
    "              8: 'ship',\n",
    "              9: 'truck'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "b343358f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 15 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "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": "6bde3a44",
   "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": "2554411c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAATQAAAErCAYAAABQAX/RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABRhElEQVR4nO2dd3gU1feH30PovQrSRJr0Ir0XqUqzAQpKUQFFiiIK2EBR8Ysd/YkdFMQOIoogSpMeFKRIUQTpht4hJOf3x50NS0jZ7M5Asrnv8+yzu1POnLkze/a2OR9RVSwWiyUcyHClHbBYLBa3sAHNYrGEDTagWSyWsMEGNIvFEjbYgGaxWMIGG9AsFkvYkPFKOxBuSMZsKlnyuG73+orFXbcJ4MWsHRH3bQKci/FmilHmCG8cPnE2xhO7mTO6Xw+JjfWmbLN44CvAb7+tPqCqheIvtwHNZSRLHrJU7uG63ciVL7tuE+DMefdtZvXortp1+Kwndovny+KJ3SVbD3ti95qC2V23ecKLGwEoVSiHJ3azZZIdCS23TU6LxRI22IBmsVjCBhvQLBZL2GADmsViCRtsQPOQgd2aEDntEVZ/NpwHuzeJW35/18as/fIxVn82nOcGdQCg5NX5OLRoHMunPMzyKQ/zxohbU3y8H3/8keuuu46yZcsybtw4186j/719KVn0KmrVqOKaTfDG3z27dtK1Uxta1KvODQ1q8sHEN12x61XZHj92lCcG9eLOtvXo0a4e639fGbJNr8rg7JkzdL2xGV1a1adD89pMGD/WFbtu3l9papRTRH4A7lTVIynYZxIwS1W/8sqvhKhUugh9utSjSe/XOXc+hpmv38fsJX9S7Ko8dGhamTp3vsS56BgK5csZt8+23Qeo3/OVoI4XExPDwIED+emnnyhevDh16tShU6dOVKpUKeRzuatXbwY88CD39r07ZFs+vPI3ImNGnnz2RapWr8mJ48e5sWUDmjS/gfIVKqY6XwFeHzuSek1uYOyEyUSfO8eZM6dDtulFGQBkzpKFj778nhw5chIdHU3PLq1p0rINNWrVDcmum/dXmqqhqeqN8YOZGFLdeVS49ipWrv+X02ejiYmJZfFvf9O5eVX63dqQlyb/wrloM0cp6vAJV463cuVKypYtS+nSpcmcOTPdu3fn22+/dcV24yZNyZ8/vyu2fHjlb+EiV1O1ek0AcubKRdnyFdi3d3eq9PXkiWOsjVxKh9vvAiBT5szkyh36HEYvygBARMiRw/wBn4+OJjo6GnFh0qGb91eqCwQ+RGSGiKwWkQ0i0s9Ztl1ECopIKRH5U0T+D/gNKCEiJ0TkZRH5TUR+FpFLJt2JyFMiskpE1ovIu+JcDRFZICIvishKEdkiIk2c5REiMt7Z5w8R6R+o/xv+3kfjmqXJnyc72bJkol2jihQvnJeyJQvRqEZpFn04mLkTH6BWxRJx+5Qqmp9lnzzM3IkP0KjGtSkqr927d1OixAVbxYsXZ/fu0G9ir7gc/u78dzsb/lhDzRBrEF75uuffHeTNV5DnRzxIn87NGDdqMKdPnQzZrj9ulYGPmJgYbm7VgMbVrqVh05ZUv76OK3bdItUGNKCvqtYCagODRaRAvPXXAR+rak1V3QHkAH5T1euBhcDTCdh8U1XrqGoVIBvQwW9dRlWtCwz12/ce4Kiq1gHqAPeJyCWRRkT6iUikiETq+VMAbN7+Hy9//AuzJvRn5hv38cfWPZyPiSFjRAby5c5G075vMOqN75jygvl33nfgGOU7jaXBXa/w2GszmfRsT3LlCHzCZ0KJOt349/QKr/09eeIE/XvdwejnXyJX7twh2fLK15iY82zZuJYud/bho28XkjV7dqa8+1rIdn24WQY+IiIimD5vGfNXb2bdmki2bNrgil23SM0BbbCIrAWWAyWAcvHW71DV5X7fY4HPnc9TgMYJ2GwhIitEZB3QEqjst+4b5301UMr53Aa4W0TWACuAAgn4gaq+q6q1VbW2ZLwwi3vyzJU0vPtVWvf/Pw4fPcVf/x5g939HmTF/HQCRG3cSG6sUzJuDc9ExHDpqguHvm3axbdcBypW8pJKZKMWLF2fnzp1x33ft2kXRokUD3v9y46W/0dHR9OvVnS63dad9xy4h2/PK10JFilKoSFEqV68NQIu2ndmy4Y+Q7YL7ZRCf3HnyUrdBE36dP89126GQKgOaiDQHWgENVLU68DuQNd5mydXNL/pbFZGswP8Bt6lqVeC9eDZ9z9XEcGGwRIBBqlrDeV2rqnMDPQ9fh3+Jwnnp3KIaX8z9ne8Wrqd57bIAlC1ZkMyZMnLgyEkK5s1BhgzmX79U0fyULVGIf3YfDPRQ1KlTh61bt/LPP/9w7tw5PvvsMzp16hTw/pcbr/xVVYYP7k+58hXoN3CIC55652uBQoW5qkgx/t22FYDIZQspVfa6kO16UQYAhw5GcezoEQDOnD7NssXzubZsedfsu0FqHeXMAxxW1VMiUgGoH8A+GYDbgM+AO4Ff4633Ba8DIpLT2Ta5kc85wP0i8ouqRotIeWC3qgbU0THtxV7kz52d6JhYho7/hiPHTzN55kreebIbkdMe4Vx0DPeOmQZA45qlebJ/O87HxBITE8ugcV9x+FjgI14ZM2bkzTffpG3btsTExNC3b18qV66c/I4BcHfPO1i8cAEHDhygTKniPPnUGHr3vSckm175u2rFUr7+/FMqVKpC26am3+ixJ5+hZet2qc5XgIeefJExj/TnfPQ5ihYvxchxoU+x8KIMAKL272fkkH7ExMYQGxtLu4630KJ1+5D9dfP+ktQokiIiWYAZQDFgM1AIGA1MwvSp5cRMxajit88J4FXgRuAo0E1Vo/ynbYjIWKA7sB3YiWm2jhaRBcAjqhopIgWBSFUt5YyejgU6YmprUUAXVT2amO8ZchRRLx5OP20fTrcPpzvYh9MhWyZZraq14y9PlQEtGETkhKrmTH5Lb7EBzQY0HzagXf6Alir70CwWiyUYwiagpYbamcViubKETUCzWCwWG9AsFkvYYAOaxWIJG8JmlDO1ULt2bY2MjHTdbraaD7puE2DrL+6Pnqa1ETOvRmW9Ii2NTHuFiB3ltFgsYY4NaBaLJWywAc1isYQNNqBZLJawwQY0i8USNtiAZrFYwgYb0K4QKVUR2vHzC0R+OSru+y2tarL6q8c5ufoNrq9UMm55y3oVWDL1UVZ9MYolUx+lWZ0L+aq6tqvFqi9GsfLzkXz75gMUyJv8NIj0rCDkj1eqT17Y9aoMwBt/3bSZagKaiHQRkdBldJI+RikRWZ/Iuvd9x/dpF3jlh09FaPbs2WzcuJFp06axcePGJPfpPPCti75v+HsP3Ye9x6+//X3R8oNHTnDb0Heo0/V57nvqEz4ca5R0IiIyMH74bbTr9zp1u73A+q27GdCtWbK++hSE5q9Yy7dzFzH5g4ls2fRnCs/4UnwKQjPmLWf6T8v4dcE81qwOXcLtrl69+XbWjyHb8SeY63Ul7XpRBuCNv27bTDUBDegCeBrQkkJV71XV0O+mAAhGRciXntvH5n/2s3XHf5dst3bzLvZGmXRtG//eS5bMmcicKSMiIAI5smUGIFfObHHbJUV6VhDy4ZXqk1d2vSgD8MZft216GtASUW464bf+NhGZJCINgU7AeBFZIyJlRKSGiCx31Jami0g+Z58FIvKqiCxylJ/qiMg3IrLVSeDos/2wo+60XkSG+rmVUUQmO3a/EpHsfnYvTRgn0tNRg1ojIu+ISESo5XK5FJpublWDtZt3ci76POfPxzLk+c9Z9cUots19joqlizBpxtIU2UtvCkI+vLpeVqnLfZte19CSU24CQFWXAjOB4U7u/r+Bj4HHVLUasI6LVZzOqWpTYCLwLTAQqAL0FpECIlIL6APUw6Tvvk9Eajr7Xge869g9BjyQmPMiUhHoBjRS1RoYvYFLsjf6qz5FRUUlWyiXQ6GpYukijB3cmQfHfgZAxowZuO+2JtS/40VKt3mc9Vt2M7xvm4DtpUcFIR9eXS+r1OW+Ta8DWnLKTQkiInmAvKq60Fk0GWjqt8lM530dsEFV96rqWWCbc5zGwHRVPamqJzCKTk2cfXaq6hLnc2LqUD5uAGoBqxzlpxuA0vE38ld9KlQoeaUmrxWail2Vl89f6ce9T37CP7sOAFC9fHGAuO9f/fQb9atfcioJkl4VhHx4db2sUpf7Nj0LaEkoN/mH5PhKToHiy8Uc6/fZ9z0jJv9/YsT/S0jq6XwBJvupPl2nqqNT6mx8vFRoypMzG99MGMBTE2aybO22uOV7oo5SoXQRCjpKVDfUr8Dmf/Ylay89Kwj58Op6WaUu9216WUNLTLlpv4hUdARIbvbb/jiQC8ARITnsUzAH7sKIBwfKIqCLiGQXkRzOcRY760qKSAPn8x1cqg7lz8/AbSJyFYCI5BeRa1LgR4L4qwhVrFiRrl27JqsitGDyMMpfU5i/fnyWXl0a0KlFNf768VnqVSvFN28MYOZbAwEY0L0pZUoUYsR97Vj+2QiWfzaCQvlysjfqKM+/O5uf3h/Kys9HUq18cf73QfKKfD4FoSWLF9C2aV3aNq3LLz+FPoIWtX8/vW+7kc431OP2G5vSoGlL1xSEmjdpwJbNmylTqjiTPvwgZJvBXK8radeLMgBv/HXbpmfpg5JQbioIvIhRXVoP5FTV3iLSCKOVeRYjMZcL00eWHdOU7KOqh+MpNDV3Pndwjum/7mGgr+PO+6r6moiUAn7ABLyGwFbgLifo+u+7HaitqgdEpBswEhP8o4GB8QSOL8KmD7Lpg7zGpg9KPH2QzYfmMjag2YDmNTag2XxoFoslHWADmsViCRtsQLNYLGGDDWgWiyVssAHNYrGEDWlsbCP1cy5G2XX4bPIbppDff3jRdZsA5Vo/5rrNRV+Mcd0mpL2ROK/YvOe46zarl8zluk3wZkQ2KWwNzWKxhA02oFkslrDBBjSLxRI22IBmsVjCBhvQLBZL2GADmsViCRtsQLsCeKGkFIyKUpE8mdkx91kiP78wdSNf7uzMeut+1n3zOLPeup+8ubIBkD9Pdn6cOJCoRS/y6qO3xm2fM3sWlk8dHvfaOW8sJQoEluauc9Oq3NG+IT06NObuzs1TdsJJkNqViS6HXTApzru1b8ygPre7ZjO1q1Slq4CWmOqTv+JTMvv3FpGQo48XSkrBqCgdPX2ezoPeuWjZI71vYMHKLVS95TkWrNzCI71bAXDm7HmeefsHRr5+sYDFiVNnqd9jfNzr372HOXwyOmC/3576HVNn/crH3y4IeJ+kSAvKRF7b9fHph2+7mjQzLahUpauAlhiJKT65IYiSEF4oKQWjonT6XCyHjl2sJtWhWVWmzFoFwJRZq+jYvCoAp86cY+nafzhzNvGZkmVKFOSqfDk5cSYmlFMJibSgTOS1XYD9e3ez+Jc53NK9lyv2IG2oVKXHgHaJ6pO/4pOInBCRZ0RkBdBARPqIyBYRWQg0ctsZN5WU3FBRuip/LvYdPAbAvoPHKOSk7A6Erm1r8dVPvwd+MBEG9b6Zuzs1Y/q0SSn0NGHSgjKR13YBxo8ZwdBRzyAZ3PuJpwWVqvQY0JJTfcoBrFfVesDfwBhMIGtNIrqh/qpPhw4kr/rkw20lpSutonR7m5p8Mee3gLd//4s5fDJzEa99+BVfTnmP31YuSX6nZEgLykRe213082zyFShIpao1k984BaQFlar0GNCSU32KAb52PtcDFqhqlKqeAz5PyKC/6lP+gsmrPoG3SkqhqCj9d+g4RQqY4FqkQG6iDp9IZg9D1XJFyRiRgd837Qr4WIUKXw1A/oKFaN6mAxvXBh4MEyMtKBN5bXdN5AoWzptN+0ZVGDGoD6uWLmLUkHtDtpsWVKrSY0BLTvXpjKrGJLE+dAc8UFJyS0Xp+4Xr6dnBNFV7dqjDrIXrAtqva9vrU1Q7O33qJCdPHI/7vGLxfMqUr5hif+OTFpSJvLY7+LHRzF2xidlL1jNuwkfUadiU519/P9X66ybpMX9BSRFpoKrLuKD61DGRbVcArzsCyceA24G1oTrgU1KqUKkKbZuavrPHnnyGlq3bBW0zav9+Rg7pR0xsDLGxsbTreEuyKkpF82ZhwUdDKJg3J399P5pn353NS5PnMeWF3vTqXJ+d+w7TY8SkuO03zXyKXDmykDlTRjo2q0qHB99m0z/7Abi1VQ26DHk3YH8PHYhi+P1GszkmJoa2HW+jQbNWKT/xePirCMXExNC3b19XlYncsumlXa/wyt+7e97B4oULOHDgAGVKFefJp8bQu+89QdlKVyIpiak+Oct8ik8nVDWn3z59MKpPe4E1QISqJqpYUq1mLf3hl6Wu++6V8EjNjo+7btOr9EF1SufxxG5aY+2/Nn1QtkwJi6Skqxqaqm4n4Y795n7bXDSsp6ofAR956pjFYnGF9NiHZrFYwhQb0CwWS9hgA5rFYgkbbECzWCxhQ7oaFLgcZI4QiufL4oFlL2zC4eWvuW4zX4OHXbcJcHrVK57YTWtcV9SbEUkv2B518rIez9bQLBZL2GADmsViCRtsQLNYLGGDDWgWiyVssAHNYrGEDTagWSyWsMEGtCtEWhLySKmIxcQnu7FjzhgiPxsetyxf7uzMerM/674eyaw3+8eJr4DRMVj/zSjWfjWCVvWvi1s+Z+IDrP1qBMunDmP51GEB+5uWyja1i47Ex21/gxH3SRJVta9kXpiH1xsGsm2tWrU0Oc6fP6+lS5fWv//+W8+ePavVqlXTDRs2JLufFzZPRyf/+umXhbp0xWqtVLlyQNvfcN8Erd/jJV3/1x7NWvshzVr7IX158s/6xITvNGvth/SJCd/pS5N+1qy1H9Iat4/TtZt3a+4Gj+h1nZ7Vv3dGafa6D2vW2g/pwsit2vCul+NseFkOl9tmKHbdvl6no73z9889J5J8bdx9XCO37tM/95zQP3Yc1mo1a+u0735Jdj8gUhP4/dkaWmA0x6QbcoW0JOQBKRexWPL7tgTEV6rEE1+pErf8y59+51x0DDv2HOLvnQeoU7lk0L6mpbJNC6Ij/njhbzDiPkmRrgOaiNztiKWsFZFPRKSjiKwQkd9FZJ6IFHZyqA0AHhKRNSLSJNTjpiUhD7cw4ismj9e+g8fjxFeKFcrDrv1H4rbb/d9Riha6kPfsnafuYPnUYYy4p3VAx0lLZZvar1l8vPLXDXEfH+n20ScRqQw8DjRS1QMikh+Tbru+qqqI3As8qqrDRGQicEJVX3Lj2JqGhDw8JwEXfafS58mp7Ik6Ss7sWZj2Yu+AzKWlsk1r18wrf33iPseOHmHQPXewZdMGylcILhNueq6htQS+UtUDAKp6CCgOzBGRdcBwIKBS9Vd9iopKXvUpLQl5uIURXzHPIBYpkCtOfGX3f0cpXjhv3HbFrsrD3gNHAdgTZd5PnDrL5wHqFaSlsk3t1yw+XvsbiriPj/Qc0IRLBVAmAG+qalWgP5A1EEPqp/pUqFDyqk9pScjDLb5ftCGe+Mp6Z/l6bm9dk8yZIrimaH7KlizEqg3/EhGRgQJ5cgCQMSIDNzZOVtgeSFtlm9qvWXy88NctcR8f6bbJCfwMTBeRV1X1oNPkzAP4OgX8JaePA6ELZzqkJSEPSLmIxeSxPWlSqywF8+bgr1lP8ey7c3hp8s9MeeFuenWqx879h+kx4mMA/ty2n6/nreH3Lx7jfEwsQ//3NbGxSvasmZg5oR+ZMkYQEZGB+Su3XLFySGsiKW6KjnjtbzDiPkmRrkRS4iMivTBNyxjgd2A68ComqC0H6qhqcxEpD3wFxAKDVHVxYjZr166tkZGRnvvuFl6IWNj0Qd7ixTXL6lHVZtNeb9IHVSya04qkxEdVJwOT4y2+ZBxaVbcA1S6LUxaLJWjScx+axWIJM2xAs1gsYYMNaBaLJWywAc1isYQNNqBZLJawIV2Pclq8wavpFdnqDU9+oyA4vWK8J3Z3HT7riV0v8EapDGb8uc8Tu4mRaEATkeNcmEnve2BLnc+qqq5NNLVYLBY3SDSgqWraEf+zWCwWAuxDE5HGItLH+VxQRK711i2LxWJJOckGNBF5GngMGOksygxM8dIpi8ViCYZAamg3A52AkwCqugewzVGLxZLqCCSgnVPzBLsCiEgOb12yWCyW4AgkoH0hIu8AeUXkPmAe8J63boU/aUmZyCsVoVD8HditMZGfDmP1tGE82L0xAI/f25q/v3uC5Z88xPJPHqJtwwpx21cpezUL3n+Q1dOGsWrqw2TJnLIZS16U7Z5dO+naqQ0t6lXnhgY1+WDim6naLrhTDkf+28N7D/fglT5tebVvO5Z8PQmAdQt/4NW+7RjVqhy7Nq8LynZA6YNEpDXQxvk6V1V/CupoVxgRGY2LqbQTIpD0QTExMZQvX56ffvqJ4sWLU6dOHaZNm0alSoElMXTTZiCpaH5dvIgcOXJyb9+7Wb1mfbLbB5KKJhh/ffPQKpUuzMdje9KkzxucOx/DzNfuZfD/vqF725qcPH2O16YuvGi/iIgMLJs8lHvGTGPd1r3kz52dIydOExtr7v3k5qEFW7bJzUPbv28v/+3fR9XqNTlx/Dg3tmzA+598SfkKFZPcLzmCsRvIPLRgymHcL39fsuzYwf84fvA/ipWvwtlTJ5gwoAt3PfM2IoJkyMD0V5/gxv4jKX5d1UTtjryhbILpgwJ9UmAdsBhY5HxOt4hIyJOR05IyEXijIhSKvxVKFWbl+h2cPhtNTEwsi3/fRudmidceW9Urz/q/9rJu614ADh07FRfMvPY1KQoXuZqq1WsCkDNXLsqWr8C+vaGLjnhl161yyF3gKoqVN9crS/acXHVNGY4d2M9V15SlUInSIfkYyCjnvcBK4BbgNmC5iPQN6aiXERF5XEQ2i8g84DpnWRkR+VFEVovIYhGp4CwvJCJfi8gq59XIWT5aRN4VkbnAx6H6lJaUibwiFH83bNtH45qlyZ87O9myZKJdwwoUL2yUogbc1pCVUx5m4hO3x4kZlytZEEWZ+fq9LJ08hId7Nr9svgbKzn+3s+GPNdSsVTfV2vWiHA7v28WevzZSomL1UN0DAnv0aThQU1UPAohIAWAp8KErHniIiNQCugM1Mef6G7AaeBcYoKpbRaQe8H8Y0ZTXgVdV9VcRKQnMAXz19FpAY1U9ncBx+gH9AEqWTF5TMi0pE3lFKP5u3v4fL388n1kT7uPk6XP8sXUP52Niee+bZbzw4TxU4en+bRk3pAMDxn5JxogIGla/lsa9X+fUmWhmv9Wf3zbtYkHkX577GggnT5ygf687GP38S+TK7d4DOG7bdbsczp4+yZTRA+nwwBNkzeHOxIlAAtouTE59H8eBnYlsm9poAkxX1VMAIjITI3zSEPjS72L4OhBaAZX8lucWEV9Jz0womIERScEESWrXrp1sWyYtKRN5Raj+Tv5uFZO/M8LFY+5vx+7/jvLfoRNx6z/8dgXfvGwaErv/O8Li37Zx8KgRP/5x6SZqVigWcEDzsmyjo6Pp16s7XW7rTvuOXVyx6ZVdN8sh5nw0U0cPpMYNnajSpK0r/kESTU4ReVhEHsbk11/hNLuexuTaD+xOSB3EDzAZgCOqWsPvVdFvXQO/5cVU1RfMXUuOnpaUibwiVH8L5TOzh0oUzkvn5lX5Yu6aOJk8gM7NqrBxm3kw+qflW6hStgjZsmQiIiIDTWqW5s9/9l82XxNDVRk+uD/lyleg38AhIdvz2q5b5aCqfP3SSAqVLEuT20MXb/EnqRqa7+7423n5cKen+fKwCJgkIuMw59oReAf4R0RuV9UvxVTHqqnqWmAu8CAwHkBEaqjqGredSkvKROCNilCo/k4bdzf58+Qg+nwMQ8dP58jx03wwujvVyhVFFXbsPcSgcV8DcOT4ad6YtphfJw1GFeYs3cSPSzZdNl8TY9WKpXz9+adUqFSFtk1NH9djTz5Dy9btUqVdt8phx/rV/P7TDIpcex1v9OsIQJt7hhETfY6ZE8Zw8ughJo+6l6vLVqTvi5NSZDvsVZ9E5HHgbmAHpvm8EfgaeBu4GsgEfKaqz4hIQeAtTL9ZRmCRqg5IyXQPq/rknYKQTR/kHV6lD0po2oYbJDZtI9lbT0QKAY9iVMTjhHdVtaWrHnqEqj4HPJfAqkv+rhwV9W4JLB/tvmcWi8VtApmHNhXYBFwLjAG2A6s89MlisViCIpCAVkBVPwCiVXWhqvYF6nvsl8VisaSYQHo7op33vSJyE7AHKO6dSxaLxRIcgQS0sSKSBxgGTAByAw956pXFYrEEQbIBTVVnOR+PAi28dcdisViCJymRlAlcOik1DlUd7IlHaRzVtDUVwgtmrvNG6cer6RXZGo5MfqMgOLzoBU/sHjju/nQQL+5ZgJ41vemdSuyKJfUzSTuTqSwWi4WkVZ8mX05HLBaLJVSscrrFYgkbbECzWCxhgw1oFoslbAgkY215EflZRNY736uJyBPeu2axWCwpI5Aa2nuYUdJoAFX9A5MF1hIkqVFFKSm88ve7Ke8x6ObmPHhzM2Z+8q5rdkMph0HdGrF6ylAipwxh8pjuZMmckU+euYPlkwaxfNIgNn39KMsnDQKgZJG8HJr/TNy6N4Z3SbGvXpStV6pPacHXQAJadlVdGW+ZR7NWLi9O0spHLvdx7+rVm29n/eiqzZiYGAYOHMjs2bPZuHEj06ZNY+PGja7Y9sLfHVs3Mffrqbz06Q+8/uXPrFo0jz07toVsN5RyKFowNw/c3pBGfd+kds/Xicgg3N6qGnc9NY36vSdQv/cEZixYz7cLN8Tts233wbh1g8fPSLG/XpRtRMaMPPnsi8xfsZZv5y5i8gcT2bLpz5DtpgVfAwloB0SkDBeEhm8D9gZ9REuqU1FKDi/83fXPVspXq0WWbNmJyJiRKrXrs/zn2SHbDbUcMkZkiMtsmy1rZvYeOH7R+ltbVuWLn9aG7KcPL8rWK9WntOBrIAFtICbLawUR2Q0MBe4P+ohXmERUoGqIyHIR+UNEpotIPmd5HWfZMhEZ7+tHTI2kNdWnkmWvY+Nvyzl25BBnT59i9eJfOLB/T8h2QymHPQeO8dq0xWyZ/hj/zBzJsRNn+Hnl1rj1jWqUYv+hE/y962DcslJX52fZpEHMfes+GlUvFbL/buOVmpQXuOFrsgFNVbepaiugEFBBVRur6vagj3gFiacCdQtQx1n1MfCYqlbD6I4+7Sz/CKMO1QCIScJuPxGJFJHIqANRnvmfFGlN9alE6fLc0mcgT/frxuj776TUdZXIEBERst1QyiFvrqx0aFKJireNp3SnF8iRLRPd29aIW9+1VXW+nHehdrbv4HHK3/wiDXpP4LE3vmfS6G7kyu5N5tdg8EpNygvc8jWQjLVPxfsOgKo+E/RRrxwJqUDlAPKqqk9uezJGESovkEtVlzrLPwU6JGTUX/WpVq3kVZ+8IK2pPgG0vuVOWt9yJwCfvP48BQqH7m8o5dCydlm27znEgSNGD2fGgg3Ur3oNn81ZQ0REBjo3r0yjPhc6rc9Fx3Ao2ihJ/b55D9t2H6JcyYL8tunK14y9UpPyAjd9DaTJedLvFQO0B0qFdNQrS6ABJ/VWbxIgrak+ARw5eACAqL27WPbzDzS9sUvINkMph537j1K3ckmyZckEQIvaZdm8/T/ABLstO6LYHXUsbvuCeXOQIYO5TUoVzUfZEgX4Z/ehkM8hVLxSffICt30NpMn5st/rOaA5UCzkI18ZFgE3i0g2R2+zIyZQHxaRJs42dwELVfUwcFxEfNl5XZuqcnfPO2jepAFbNm+mTKniTPrwg5Bt+ivyVKxYka5du7qq+uS2vwAvPnwPA7s0ZeygXvQf9QI5c+cN2WYo5bBq406mz1/PskkPEjllCBkyCB98awb4b29V7ZLBgMY1SrHq4yGsmDyYT5/rwaD/zeDw8QSlWxPFi7L1qT4tWbyAtk3r0rZpXX75KfTRybTga4pVn5wO85WqWi7oo15BElGBmgdMBLID24A+qnrYUVV/DxP0FgBNVbVRUvZr1aqtS1a4n6jEq/RBXqSNmfunN+mDOlUt4oldmz4ICubypu/PC18BSuTPGrTq0zouNNMiMIMDabH/DEhSBSohnYQNzkABIjICm1LJYknVBPK/798Rfh7Yr6phMbE2AG4SkZGYctoB9L6y7lgslqRIMqCJSAbge1V195mXNIKqfg58fqX9sFgsgZHkoICqxgJrRaTkZfLHYrFYgiaQJufVwAYRWYnpHAdAVVP3nACLxZLuCCSgjfHcC4vFYnGBQALajar6mP8CEXkRWJjI9umas+dj2R51MvkNU2o3OtZ1mwDXFc3luk2vplcs2XrYE7tT3/ZGwCxfo+Ge2PVC/WrTXvfvWYAKV+fwxG5iBPKkQOsElrV32xGLxWIJlaR0Oe8HHgBKi8gffqtyAUu8dsxisVhSSlJNzk+B2cALwAi/5cdV9co/sGaxWCzxSEqX8yhwFLjj8rljsVgswWNVnywWS9hgA5rFYgkbbEC7Apw9c4auNzajS6v6dGhemwnjx7pmOyYmhm7tGzOoz+2u2UxrKlXHjx3liUG9uLNtPXq0q8f63+Nr/ATGW08/RJ8WVRl6a4sLto8eZkz/bgzs2Igx/btx4tiRgGwN7NaYyE+HsXraMB7s3hiAp/q3ZeWUh1n+yUN898Z9XF3QZGrNnzs7P/5ff6Lmj+XVR7oE5bsXZevVfeumr+kqoInIYBH5U0SmXkk/MmfJwkdffs+MecuZ/tMyfl0wjzWrg/vRxefTD9/m2rLlXbHlI62pVL0+diT1mtzAp3NWMGnmYq4pc11Qdpp36saT/3fxrTL9wzepWq8xb323hKr1GjP9w+Rl1yqVLkyfzvVo0ucN6vZ8lfaNKlGmREFenbKAuj1fof5drzL7142MvKcVAGfORfPMO3MY+casoPz2qmy9uG/d9jVdBTTMNJQbVbWHb4GIeJRpLHFEhBw5cgJwPjqa6OhoV/L/79+7m8W/zOGW7r1CtuVPWlKpOnniGGsjl9Lh9rsAyJQ5M7ly5wnKVuVa9cmZO99Fy1YtmEOLjl0BaNGxKyvnJx/oK5QqzMr1Ozh9NpqYmFgW/76Nzs2qcPzkhVxh2bNlxpea8NSZaJau3c6Zc8EltfGqbL24b932Nd0ENBGZCJQGZorIURF5V0TmAh+LyDWOOvwfzntJZ58yjhrUKhF5RkROuOVPTEwMN7dqQONq19KwaUuqX18n+Z2SYfyYEQwd9QySIfVfVq9Uqvb8u4O8+Qry/IgH6dO5GeNGDeb0KfdmwR85eIB8hQoDkK9QYY4eOpjMHrBh2z4a1yxN/tzZyZYlE+0aVqB4YRNkRw9ox9aZj9O97fU8++4cV3z0UgHM7fvWbV9T/53vEqo6ANgDtABeBWoBnVX1TuBN4GMnmeNU4A1nt9eB11W1jrNvgvirPh128uQnR0REBNPnLWP+6s2sWxPJlk0bkt8pCRb9PJt8BQpSqWrNkOxcLrxSqYqJOc+WjWvpcmcfPvp2IVmzZ2fKu6+FbDcUNm//j5c/ns+sCfcx8/V7+WPrHs7HmEfZRk/8kXKdnuOzOb8x4PYkkyEHjJcKYG7ft277mm4CWgLMVFVfAvgGmInEAJ8Ajf2Wf+l8/pREUNV3VbW2qtbOV6BgipzInScvdRs04df581K0X3zWRK5g4bzZtG9UhRGD+rBq6SJGDbk3JJte4pVKVaEiRSlUpCiVq5vszC3admbLhj+S2Stw8hYoyOGo/QAcjtpPnvwFAtpv8neraNjrdVoPeJvDx07x186L//i+mPM7XVpUdcXHy6EA5tZ967av6TmgJdUO8VSK7tDBKI4dPQLAmdOnWbZ4fsgd+YMfG83cFZuYvWQ94yZ8RJ2GTXn+9fdd8NYbvFKpKlCoMFcVKca/24xAcOSyhZQqG9ygQELUbtaG+d99AcD8776gTvO2Ae1XKJ95SLtE4bx0bl6VL+auoUyJC39+NzWpzJYd/7nio1dl68V967avl71DPJWyFKPq9AnQA/jVWb4cuBWTtdY11aeo/fsZOaQfMbExxMbG0q7jLbRonXqf97+75x0sXriAAwcOUKZUcZ58agy9+94Tkk1/daaYmBj69u3rmkrVQ0++yJhH+nM++hxFi5di5LjkRyIT4pUR97MhchnHjxzivja16Hb/MG7p+yAvPzqAn6d/RqGrizFs/DsB2Zo27m7y58lB9PkYho6fzpHjp3n78dspV7IQsbHKv/sOM/jFr+O23zR9JLlyZCVzpgg6NqtMh8HvsemfwAKeV2XrxX3rtq8pVn1Ky4jIdqA28CBwQlVfcpaXAj4ECgJRGNWnf0WkHDAFo9H5PdBPVZOU8KtS/Xr96sfFrvueltIHeaVQ5VX6oP2nznhit0e/Vzyxa9MHgYgEp/oUTqhqKefj6HjLtwMtE9hlN1BfVVVEumNVnyyWVE26CmhBUAt4U8ywyxGg75V1x2KxJIUNaEmgqouB6lfaD4vFEhjpeZTTYrGEGTagWSyWsMEGNIvFEjbYPjSXyZopgydD1bsOn01+oyA4cNwbu15Q69p8yW8UBF5NM/FiegVAttpDXbd5OvI1120CrNp21BO7iWFraBaLJWywAc1isYQNNqBZLJawwQY0i8USNtiAZrFYwgYb0K4QXohY7Nm1k66d2tCiXnVuaFCTDyYGl2XCa5te2k1rgi7B2N0x91kiP38s7nu+3NmZ9db9rPvmcWa9dT95c2UDIH+e7Pw4cSBRi17k1UdvvchGpowRvDmqK398PYo1X4301N9A6Ny0Kne0b0iPDo25u3PzoO2ETUATkVIisv5K+xEIXolYRGTMyJPPvsj8FWv5du4iJn8wkS2b/kx1Nr20m5YEXYK123nQxSmLHul9AwtWbqHqLc+xYOUWHuntiK2cPc8zb//AyNcvzdH/WN/WRB0+QbVbn6fm7YEFJi+FbQDenvodU2f9ysffLgjaRtgEtFC43EIpXolYFC5yNVWrmxTcOXPlomz5CuzbG1oueS9semk3LQm6BGv30LFTF33v0KwqU2atAmDKrFV0bG4y3546c46la//hzNlLxVZ6darH+I9MttlAU4h5VQ5uEm4BLUJE3hORDSIyV0SyiUgNR+jkDxGZLiL5AERkgYg8LyILgSEicruIrBeRtSKyyNkmQkTGOyIpf4hIfzec9FLEwsfOf7ez4Y811KxVN1Xb9NKuW3h1vdyye1X+XOw7eAyAfQePUShfziS3z5PTNEmfvv9Glk4ZxtRxvS+rvwkiwqDeN3N3p2ZMnzYpaDPhFtDKAW+pamVMup9bgY+BxxwBlHXA037b51XVZqr6MvAU0FZVqwO+HMD3AEcdkZQ6wH0icm2oTnopYgFw8sQJ+ve6g9HPv0Su3LlTrU0v7bqJV9fL6/sgMTJGZKB4kXwsW7uNhj1fZsW67QHt56W/738xh09mLuK1D7/iyynv8dvKJUHZCbeA9o+qrnE+rwbKYILWQmfZZKCp3/af+31eAkwSkfuACGdZG+BuEVkDrAAKYILmRfirPkVFRSXrpJciFtHR0fTr1Z0ut3Wnfccuqdaml3bdxqvr5Zbd/w4dp0gB82dQpEBuog4nrbZ48OhJTp4+y7fz1wHwzbw1l9XfhChU+GoA8hcsRPM2Hdi49reg7IRbQPN/MDEGyJvM9nF5hx2ZuyeAEsAaESmASb09SFVrOK9rVXVufCP+qk+FChVK1kmvRCxUleGD+1OufAX6DRwSsj2vbHpp1wu8ul5u2f1+4Xp6djD6mD071GHWwnXJ7vPD4g00rVUWgOZ1AhM68aocTp86yckTx+M+r1g8nzLlKwZlK9wfTj8KHBaRJk6yxruAhQltKCJlVHUFsEJEOmIC2xzgfhH5RVWjRaQ8sFtVQ0rA7pWIxaoVS/n680+pUKkKbZua/qjHnnyGlq3bpSqbXtpNS4Iuwdpd8NEQCubNyV/fj+bZd2fz0uR5THmhN70612fnvsP0GDEpbttNM58iV44sZM6UkY7NqtLhwbfZ9M9+nnjjOz54pifjh93MgWRqdKH6mxyHDkQx/P4egBlJbdvxNho0axWUrbARSXGETmapahXn+yNATmAGMBHIDmzDCKAcFpEFwCOqGuls/w2mOSnAz8BQ5/NYoKPzOQrooqqJphCoXbu2Rka6Lz3gVbaNtETBXFk8setVtg2vsNk2oG6ZvOEtkuIInVTx+/6S3+r6CWzfPN73WxIyC4xyXhaLJZUTbn1oFoslHWMDmsViCRtsQLNYLGGDDWgWiyVssAHNYrGEDWEzyplaUIUzlz4LHDLF83kzZWH+poOu2zx89pzrNgFurHy1J3a9mlpQp3QeT+z+/t1zrtvMVm+46zYBln/5lCd2E8PW0CwWS9hgA5rFYgkbbECzWCxhgw1oFoslbLABzWKxhA02oFkslrDBBrQrQFpSJvr3n63cd3PzuFeH2qX4avLEoGy99fRD9GlRlaG3tohbdvzoYcb078bAjo0Y078bJ44dCclfr8oW3FMm8seLa3b2zBm63tiMLq3q06F5bSaMH5ui/Qd2a0zkp8NYPW0YD3ZvfNG6oT2acXrFeArkyQ5A7UolWP7JQyz/5CFWTHmITs2CK/eYmBi6tW/MoD63B7W/j3Qb0ERku4gUTGB5JxEZ4eWx05IyUclry/He9AW8N30BE7/6mSzZstO41U1B2WreqRtP/t/Ui5ZN//BNqtZrzFvfLaFqvcZM/zA0OTsvytYfN5SJfHh1zTJnycJHX37PjHnLmf7TMn5dMI81q1cGtG+l0oXp07keTfq8Qd2er9K+USXKlDA/k+JX5aFl3XL8u/dw3PYb/t5Ho96vU/+uV+k85H0mjLiViIiUh5VPP3yba8sGlmgyKdJtQEsMVZ2pqu4JDiZAWlIm8ue35YsoWqIURYqVSH7jBKhcqz45c+e7aNmqBXNo0bErAC06dmXl/NCCkRdl6xVeXTMRIUcOI5RyPjqa6OjogHP/VyhVmJXrd3D6bDQxMbEs/n0bnZ1a1/8e6sTjb35/kbaAbzuALJkzoqQ8v+L+vbtZ/MscbuneK8X7xiddBDQRySEi3zuKTutFpJuzapCI/CYi60SkgrNtbxF50/k8SUQmishiEdkiIh2u2Ekkw+VQkpr/w3Ra3pRQ2rjgOXLwAPkKFQYgX6HCHD3k/pMLruGSMpEPL69ZTEwMN7dqQONq19KwaUuqX18noP02bNtH45qlyZ87O9myZKJdwwoUL5yHm5pUYk/UUdZt3XvJPnUql2D1tGFEfjqMweO+iQtwgTJ+zAiGjnoGyRB6OEoXAQ1oB+xR1epORltfNeCAql4PvA08ksi+pYBmwE3ARBHJGn+Di0RSDiQvkuIFXisIRZ87x9JffqRZ29BzyKdV3FIm8uHlNYuIiGD6vGXMX72ZdWsi2bJpQ0D7bd7+Hy9/PJ9ZE+5j5uv38sfWPZyPieWx3jfwzDuXyGkAsGrDTmrd8TKN+7zB8F4tyJI58CcqF/08m3wFClKpas2A90mK9BLQ1gGtRORFR1/A9/DeN877akzgSogvVDVWVbdiUnhXiL/BRSIpBZMXSfECLxV5AFYunke5StXIX/Aq12wC5C1QkMNR+wE4HLWfPPkLuGrfTdxSJvLh9TUDyJ0nL3UbNOHX+fMC3mfyd6to2Ot1Wg94m8PHTrFj72GuKZqflVMeYtP0kRS7Kg/LPh5K4fy5Ltpv8/b/OHnmHJVLFwn4WGsiV7Bw3mzaN6rCiEF9WLV0EaOG3Bvw/vFJFwFNVbcAtTCB7QUR8T0x60vUH0PiD+rH/xtNlSIMXiny+Pjl+29cb24C1G7WhvnffQHA/O++oE7ztq4fww3cVCby4dU1O3QwimNHjwBw5vRpli2en6IO90L5cgBQonBeOjevytQfVnNN+zFUuPkFKtz8Arv/O0qDu19j/6HjXHN1vrhBgJJF8lK+ZCF27D0U8LEGPzaauSs2MXvJesZN+Ig6DZvy/OvvB36y8UgX2TZEpChwSFWniMgJoHcKdr9dRCYD1wKlgc2h+pOWlIkAzpw+xeqlC3lozCsh2XllxP1siFzG8SOHuK9NLbrdP4xb+j7Iy48O4Ofpn1Ho6mIMG/9OSMfwomzBXWUiH15ds6j9+xk5pB8xsTHExsbSruMttGjdPuD9p427m/x5chB9Poah46dz5PjpRLdtWONaHrm7BdHnY4mNjWXI/6Zz8OipkM8hWMJG9SkpRKQtMB6IBaKB+4GvgNqqekBEagMvqWpzEentLH9QRCYBh4HaQGHgYVWdldSxatWqrUtWuK/65JUykU0fBOv+TVvpgzbtDUlFMUFqdhntuk3wLn1QjWtyh7fqU1Ko6hyMxqY/pfzWRwLNnc+TgEl+2y1R1Yc8ddBisbhCuuhDs1gs6YN0UUMLFlXtfaV9sFgsgWNraBaLJWywAc1isYQNNqBZLJawwfahpRG8GKoHaFDW/Zn5B46fTX6jIFiw2ZvHyppfd2We7giW7Yfcn+d1esV4120CZKvzsCd2E8PW0CwWS9hgA5rFYgkbbECzWCxhgw1oFoslbLABzWKxhA02oFkslrDBBrQrgBfKRKEq/SSFF/7u2bWTrp3a0KJedW5oUJMPJoYmjuLP9I8n0r9zEwZ0acq44f05d/ZMyDbTklIXeFMGEJq/A7s3IfKz4az+/FEevKMpANXKF2Xhh0NYPnUYv05+iNqVSgJQ8up8HFr8IsunDmP51GG8MeK2gI4RdgFNRPKKyAMu2WouIkmmCwoGL5SJQlH6SQ4v/I3ImJEnn32R+SvW8u3cRUz+YCJbNv0Zst0D+/fy7dT3eePzuUycsYjY2BgWzp4Rst20pNTlVRmE4m+lMkXo06U+TXq9Rt07X6J9Y6Mm9dygjjz3/hzq93iZZ9/5kecGX5Dt2Lb7APV7vEz9Hi8zeNxXAR0n7AIakBe4JKCJSMTldyVhvFAmCkXpJzm88LdwkaupWt3kkc+ZKxdly1dg316XBELOn+fc2TPEnD/P2dOnye+IsIRCWlPq8qIMQvG3QqnCrFznpyb12990bl4VVSV3DiPTkSdnVvZGHQvJx3AMaOOAMiKyRkRWich8EfkUWCcipURkvW9DEXlEREY7n8uKyDxHGeo3ESnjb1RE6ojI7yJS+rKeTQoIVunnSrPz3+1s+GMNNWvVDdlWwcJXc2vvB7i7VU3ubFGV7LlyUatRi+R3vAJ4pfrkVRmE4u+Gv/caNak8PjWpihQvnJfhr8zg+cEd2TrrSV4Y0omn3vo+bp9SRfOzbMrDzH1nII1qXBvQccIxoI0A/lbVGsBwoC7wuKpWSma/qcBbqlodaAjE6XWJSENgItBZVbfF3zE1qD5B8Eo/V5KTJ07Qv9cdjH7+JXLlzh2yveNHj7B8/o98NCeSqb/8wdnTp/jluy9d8NR9vFJ98qoMQvE3Tk3qzQHMfKNfnJpUv1sb8egr31Kuw7M8+uoM3n7SKEzuO3CM8h2fpUHPV3js1W+ZNLYnuXJkSfY44RjQ4rNSVf9JagMRyQUUU9XpAKp6RlV9D8xVBN4FOqrqvwntnxpUn/wJRunnShAdHU2/Xt3pclt32nfs4orNNcsXUbhYSfLmL0jGTJloeMNNbFyzyhXbbuOV6pNXZRCqv5NnrqDhXa/Quv9bHD52ir92RtGjQ21mzP8DgK/nrY0bFDgXHcMhR5vg90272LbrIOVKJv/bSg8Bzf+p7vNcfM4+jc2k/mb2AmcAd4QDPSJUpZ/LjaoyfHB/ypWvQL+BQ1yzW+jqYmz6YzVnTp9CVVmzYjElSqfOcvBK9cmrMgjV30L5TB9vicJ56dyiKl/M+Z29Ucdocr3p3Wlepxx/7TQtnIJ5c5Ahg/lZliqWn7IlCvHP7uTVpMIx28ZxIFci6/YDV4lIAeAE0AH4UVWPicguEemiqjNEJAvgG0Q4AtwDzBWRk6q6IFQHvVAmClXp53L7u2rFUr7+/FMqVKpC26am7+yxJ5+hZet2IdmtUK0WjVt3YFDXVkREZKRMhSq0v/2ukGxC2lLq8qoMQvV32ou9yZ8nO9HnYxn6v284cvw0A5/7gvHDupAxIoKz56J58HnTNG5cswxPDmjH+fOxxMTGMmjclxw+lnyWkbBUfXIGAaoBp4H9qtrBb91gYDDwD7Ab2K6qo0WkHPAOUBCjDHU7UBJ4RFU7iEhJYDbQV1VXJHZsr1Sftkd5kz6oVKEcrtv0Kn3Q+j2hjYAlhlfpg7xS6vpxg/v9tO0qe1MGXqUPOhP5avpRfVLVO5NY9wbwRgLLtwIt4y3eBixw1v8LuCN0abFYPCE99KFZLJZ0gg1oFoslbLABzWKxhA02oFkslrDBBjSLxRI2hOW0jSuJiEQBOwLcvCBwwAM30pLdtORrWrOblnxNqd1rVPWSuSY2oF1BRCQyobk06cluWvI1rdlNS766Zdc2OS0WS9hgA5rFYgkbbEC7srxr7aYpX9Oa3bTkqyt2bR+axWIJG2wNzWKxhA02oFkslrDBBjRLsohImrlPxC1lGEuaJM3cqJaU4dYPW0QqAE+LSE437PnZjfD7nFhCzpTaFHU6hUXEswzDbgfN9BqE45+3G3+cNqCFCfFvDnVhtMe5wYoDhYCHRCR7qDYduxFAK0f3dDDQS0RCzs3nF8zuAsaISJ5QbfojItf6juNGEPKzkdH5HrLUor9fbtasfXZFJI+I5HPJbNyfpIj0Bh4N1aANaJcZvxujvCONl7yUTQA2/X7MPUTkSRG5Nb4UXwptZlDVWFWdB6wBqgAPuhTUBMgNjMdkD/5BVc+78QMUkfpAF2Coqh4NNUj4Xa9ywA8i8jiEHtR810xE6gJ/ikhhVY0Jxd9498HdwAgRuUNEQhYUdXztBMwF5jj3WNB2ReQaYJqI+LQWM2ESqoaEDWiXGb8b40tgAObmqBWqTYhLL34fJr34E0CrEGzGOjaHYgKEAk2BR0UkpLzdqnoeWAmcA5YCFUQkm++YKSFejSQL0BwoB9zi/MBjQgk8zvXqAIx2fO4qjpZrKEHN2fcGoD2mbBeISBHH36B+l373wX1Af8ff94GOwdjzR0Suw9xb/YHeQB0SEPROAaeBxcAoEamGKYPQux5U1b4u4wu4FvgRyAfcDKwD8gdpq7Tf5zzABEztpx8wByP0khnIngKb4ve5MPAzkMP53gb4P4zeacA2EzhGYec9C3CHY/MOZ1kloEgQvpYE8jqfBwCvYXRUL9k2hb7mBVYBjTEVgGrAEmBkiPfBdcB2oAGmST8e+NevbDIEYTMDkB8zQbU4cBfwExARzDXCBC5xbM3A1M6yO+tLAVuBbin10e9zQWAoMB343CmD2phgeaOvLFLysjW0y89RzA/ifkyfQWdVPSQiLVPSjyQi2TBNoNHOomOYm2+JY7OtqsZgbuoaAdrMoL5fv0hbzI18NebHDPCL4393TPMzxbUTEXkQmCIi44GuqjoNiAQaishnwDTMv3Wy+Pk6FPgA+ExEXgM+BXYCTUSkq/+2QRCDyQCxXU0NcoNj/x4RCUV/7yTwi6ouAw6o6nBgLTBfRAqpamwg5eu/jZougkPAX8B7QA+gjZpa36MikhL59LKY2nN+Vd0FfOMsbysi+VV1O6b2ly1Qg06N2VfzvwMoBnwBzAdqYYSJ2gKPYX4bmVPgryGUfxn7Cugfyfc0RhbnAmUGPgJ+Byo565pifigVA7RZ3Hkvj/kRPOF874IRdbnV+d7TsVs6hT43AOZhAmQfTA2qoZ/NF4GrgiiL3piAW8q5kdcCjzrrGgKjgMoptNkFU3PIALwEzHeW53bsvQDkDPRa+V2vokAW5/PTwHIgm/O9vVMGM33XMAX3QWbnPZdz/n39tumGqRHPBrKmsBwGAeOczw9gmpv1ne+3Occqn0KbuYCJOLVRjJzjZKecOwN/AzcEcR8MANb77ktMDbU/8G1K79VLbIeys30FfAE7Yars72CUo6o5N+3zzo9lA9AhADuCqaa/B+RzlpUGNmKagbmcG/sX5+ZYE0iAwATGPM7njsB/XAiKVTAd95ud4/6V0h+GY6c2cCumqf0gptndzAkUQTffMH1mbYERTmDL5Od3JoJozgPtgGXAx8BU4BrgKeBPp5z/Aho55VElBXbbYppXEzFN7WswWrGPY7oJFgNNgDdJWTfBw5g/iip+98loYJJTzkuBqgHeX/7N+IyYpt//YQZZwNT6lmCa9K2cZQE1jx37xYBFvnuIi/9ARmFq6NkCtXnJMYK9kewr4JvtOkytqZtfYKiI6Uvrg6laN/G/uAHYzOrc+A8438s4P7Yhzvf8zjEKBXCDZQFexwmQzvIVwDK/7xEY5fgbgWuDKIP7nR9yWcy/8QygoLPuG+A73/fk/E3A/+bALmCm3/J7ga9x+v4CsHsVcCeQ3fnBbXHKt7xzfZZg/iy6Y5rwlTG12N+AkgEeoz7mj+dmTF/kdqdcimFqkf8HVMUM5KwkiUAcL+gUcPa9CvPn1hcTiCtjugsqEUBtGqc26nxu4ZxnC7/v7wCDne+9McH8pkDL2NkvA5AD+AGn1syFGmtR51yC6k+OO0YoO9tXshewmvNjHe237B5gE9AohbYyxPveAVOL6Ot8LwP8ATyfApsRznsmoC6mZuCr4UQC37pQBp0cv65xvl+NqUE2dH40UwIJZvFsPgi87PyoCmBqTRsxNaCRzvECbrpiah0fAHc7QeVt/zIH3gJ6+G1fB1OzrB5g+eZzAtqLfusKYZpd1f2WNcZ0tCda64sXzO7GNN++xXT+z8T0P30OfJiC88+HqcVVdALhDox27QwuNDebY5qbw5zvozCDUIE25xtz4Q/4U+Arv3W9MX9sKWpmJ3icUA3YV5IXMSemCj0L08Huq14PwIxo5SeFI1DOj6kEpnZyPbAQuNdZV94JcikNEEUxAXGh84PwBbVFmI7rUMpgADDK+eyzO8wpl6XJBQU//3yjawMx/XulMf1Cr/rZHIuprVQIws+Hgbcxo257gD5+657x/ZCd79eQxEgspo+wlPP5BifQ3AesiLfda1zom4xwrmdAfUiYJvyXft87c2GEtA2mRhxQsHH2eRzzR/A/oKWz7HpMsBzhdy7V/PbJl4Q9372ewTm3fphaXjdMTfhL5/4aD6z2txvS/eaGEfu65CJWAao7FzILphYyASjmt23xAG3W4kKNoTfmX30G8AmmBlgD05E80NkmUwA2GwLdnc8DncDwshNkVmCaWb7gMzdQXxM5VntMf+F1fss6OOeSLYD9izll1x9Tk3wEU7sZBnyPaX5H+PkbzHSHNphpLosxtYfXMKOko4BbMH2RzQO0VQpTA68CVAA+9P1Y/cq3MqZpuR6om9J7zLm31mL693LGWz/EWZdsn5mzfUbnPa/feftq/Rmd++sn4Em/fQL+E8ZpkmOCWC9Mze9OZ9nNmEGdsq79Bt0ylN5fXAhmnTD/OB9h/pGu58LI5gcpDQ6Ymt2vmFHBD50b71pMn89MzHyhNpimbZ4Abd6EmXw7BtOMKO3YGISp/fwCvBpMcEjgWLkxNafnnUDWEzOvK6Cb2PkB98YE3L6YP4eFwGd+P8YHMf1RGQiwH9LP/lVO+VZ0vg/E1MjGYILbWAIYsPHz9TZMn2R14AhmAMG/tve6cx/8DNyUknsr3rK7MH17TbjQNI4AniXA0XI/W10w/YFFMSOkG3Ga7FyoOdZKqa+OvR1Ae+d7Di7Mkbzbd/3cfLlqLD2+nIvk6+CsialGF8QMAGzFTHKsi6mpfUoKpyU4dothqv6b/JZdhenbudnnRwpttsbUEKY637Ng+lBextRKphDE1IxEjnU1pun5A6aWElDzggt/Endjmu0/OoHmABf6Y3o7P8ByQfqWD9NMb+p8z4Tpm5uLaSaKvy8B2MsL7MP8YdyMqVG+BDTz2yYTkCsldp1te2BGLx/A/FHcgak9NSaAmnkiNmtgaqAV/JZNxQT5FDUD4wWzhzGj2j0wU5Ta+K37xbnP8rpxf/m/7MTaEHAefh4HdHAmup7A9MHUwFSve2ICxfNAPUzH8oYA7Gbw+5xZVXdjbuJjIvIegKr+x4XmB8CplPiuqj9h+k1uFJFuqnpWVf/EjEQeUdWezjFCRlX3qupETE2gl6r+EeB+KiI9MDXHUZjaTgxmFG+oiLyNCTq3qerWIH07jOnPaS4iVVQ1GtOpfhBYpM4v0PceAMcwP+CMmBrjNMxjPm1FpKVjK1pVj6fErogMxJTDYczI+Rzn5ZsXFqxa0llMQGsmIk+JyC9ALCYwfyEpyITiOxcRaY0ZBFmlqlMx/WSviMhNzmNkx4CXVPVIkD4n6YR9hfDC9Fl8gPk3zuosG8mFfoL7Mf1dKWoGOPv2xYw8PoMZfSuBqTksxNRaFhJEB3i8Y3TAPBQ8BtMU/R0oc6XL1c+/Z4DhzufMmD+MLzB9aAUJsJmdzDGKY5pqc4DnMPMCm4do8xqc5iZQBNPZPp4kOtLj7e9rRvpqiBPx62/DBPj3nc8DCXD6SALHyYlpsi/B1MyrYP48WwZqE9Na8DVRe2NqzN/F2+Y2TE34F1waAEjQlyt9w6bVFxc/k9bfCVq3YJoTfTCPCPXF/Ps1DMJ+D0yTsDWm/+1/mA72Ys4Pbh4hdNbHO1YXTM3nM5zRudTycnybgV9THTM6+jyQ28Xj5ML0Iz6MX/MwRJs1MfMD+2Ga3cFMSC7v3FOzcJ6qcJZXIwVTMwI4jm8+WG0nILVMwb7lMH+0kzGPMd2F6UceHG+7PKSwayTF5+Gl8XB9+f1rFvdbdjum78HXp3UvZlDgxpTaxnTEvogz9wnTz/MwF0Y7iwJFXT6nZjhzxVLTC9P0eQ7TOd8SU4ucSYAPsF/pF2aU+p9A/3y4eAR6EKaWN94pg11cGIHsgant5CWFAyGJHDfC8XUFfg/1p2D/lzBNyfud7+2dP6JBl7O8Q06qlx5RVRWRdsBLIvIbEI25+c4DN4tIJsyI5CQ1eb7i8lQlhP965z1GRP4FOovIIlXd6fSdfS8iJVX1Xw/OaaHbNt1AVY+IyFuY2u8TmDIepqr7rqxngaGqq0Wkmjp9ZgGQD3hBTKbg4pjJwm0wgwDzgLFisvG2wGS6OOKSnzEisgkTTP9J7p5NgImY6SIPi8ghVf1cRP4D/k9EDqhJQuA5NqAFgZO/rD2m7+I/TL/BDEx/VAHMJMeFqrofku/49a0XkVsxTYypmCp8MUw2168wnfUCBPrDCBtUdQ/wpoh8hKmNnLjSPqWQgP1V1e9F5BzwCrBcVf8WkQ8xI4ZgRlDfxTx9ctBNJ1X1JKY2mew9m8C+fwF/icgR4DnnPSsm591yN/1MCqvLGSB+GUbzYbIMbFDVJk6GUcUM9c9W1a8CrUXFyzDaEzOhdSmm6j8U02FbH9PUOovpQ1nj/tlZUhsi0hlzTw1W1c+cke/emD+2/7lVM/MCp/UyHpMi6R4NYGTftWPbgJY8fsGsPWZE52/MnKghqvqBs83/gP2q+nJKbDqfi2CaEKtU9S8nv1drzLN/i5wgGqOqx1w/OUuqRURuwjy4/rxfUMuRgubrFUNErsJU9KIu53FtkzMAnGBWFzPi9pmq/ur8C/0sIlUws/RbY56DTJZ4wexB4CHgDKZDtq+qviYiMcB4ERmuqovcPytLasdpfsYC74rIeVX9ijTS5aAuzWFMKbaGlggiUhozdP2+k6v+C0wyv3J+2zTEzNT+BeinqntFJEJNpthAjtEYMwH3Bcwcs37AX6r6tLO+P6YZ6/oggCXt4ExU/VtVQxYRCXdsQEsEESmGCTLbVPU/ESmJefxouare77ddbcxD0iNU9aNARoecpkNpTEaEPzGTZGMxfWcDgb1qUjJbLJYUYB99SgCnlrUb8xD1AhEZ59SSOgJlROR137aqGgl0xYjx5k3CZvzc739hZrtfjRmWj8Y0Od8F8olIQffPzGIJb2wNLR5+AwBlMLP9s2OmZHytqs+JSHHMs35rVfUBEcnozDXLqqpnArDfCzOD/D8upHd+FpPd4lvM1IzMgdiyWCwXYwcF4uEEs46YmenbMSOao4BXRSRGVceJSHdMzQo1GpNgplUkiYgMwDwO9TamOfsd5gmDMZjsA9Gq+j1mgMBisaQQG9DiIUZ5+ynMqGVrTBPwNGYk8l2nRjYWkwgvjoT6zRIYILgGeExV5zvrdwJjVfV2EXkO8+ymxWIJEtuHdim7MNkGamAyaVTHTG69y/m+OBAjztyxSs7nG0WkKKZW18Nvs/nAWae5+pWq7nDrJCyW9IgNaPFQ1V2qugrzsPZUp/N+EiYH1WpVXejfwZ8ExYGeIvIx8Jrz+M5QoIaIvORs0wBTa8vh8mlYLOkS2+RMnHVAfzFq5h0xWQP+haSfc/MNKqjqOud5tsEYzUjfg9adgBki8gkmt/xdbj+TZ7GkV+woZyKISG5M0sZOwAeq+kMK92+MecazMEbPchHwozOnLS8m/1hGNRlTLRaLC9iAlgx+0zICTqciIoUwWWuzYvrdWmHScc/AKAEVxKTAOZ+YDYvFknJsQEuGIPJC+farg8nhlR0T3JphAlt9jMDHWlcdtVgsNqC5iYj0wcizPe58vx4zqnkeeE5Vj4lIzjSYz8tiSRPYUc4QSGC0cwFmIGEkgKr+hsn/3xp43JmXZoOZxeIRdpQzSBJIAVQFMzJ6EzBLRGJV9UVMupf5wKuBZuGwWCzBYZucISIiDwDdME3LPzDCKCsx8nMLgEZAW1XdfKV8tFjSC7aGFgLO1I7rge6YZzJXYSbKXoVJCXQK86jTrivmpMWSjrA1tBBxkj9WwDwN0MLJdXYQkz1jnKqeu6IOWizpCFtDCxFVPSsip4CMIuJTN/8eI2Fng5nFchmxNTQXcGppQzHzzAoDXVV10xV1ymJJh9iA5hJixIWLALFOtluLxXKZsQHNYrGEDXZircViCRtsQLNYLGGDDWgWiyVssAHNYrGEDTagWdI0ItJcRGY5nzuJyIgkts3rPKqW0mOMFpFHAl0eb5tJInJbCo5VSkSsWE6Q2IBmSZWISERK91HVmao6LolN8mIEcCxhig1olsuKUwPZJCKTReQPEflKRLI767aLyFMi8itwu4i0EZFlIvKbiHwpIjmd7do5Nn7FJNH02e4tIm86nwuLyHQRWeu8GgLjMMr3a0RkvLPdcBFZ5fgyxs/W4yKyWUTmYQRykjuv+xw7a0Xka985ObQSkcUiskVEOjjbR4jIeL9j9w+1bC02oFmuDNcB76pqNeAYF9eazqhqY2Ae8ATQSlWvByKBh0UkK/AeRrimCWYyc0K8ASxU1eqYBAIbMGI1f6tqDVUdLiJtgHJAXYxsYS0RaSoitTAJB2piAmadAM7pG1Wt4xzvT+Aev3WlMBmLbwImOudwD3BUVes49u8TkWsDOI4lCeyznJYrwU5VXeJ8noJRxvJJ+33uvNfH6JoucfJoZgaWYRIB/KOqWwFEZArQL4FjtMRkPMHJQ3fU0Ur1p43z+t35nhMT4HIB01X1lHOMmQGcUxURGYtp1uYE5vit+0JVY4GtIrLNOYc2QDW//rU8zrG3BHAsSyLYgGa5EsR/PMX/+0nnXYCfVPUO/w1FpEYC+weLAC+o6jvxjjE0iGNMArqo6loR6Q0091uX0PkKRhrRP/AhIqVSeFyLH7bJabkSlBSRBs7nO4BfE9hmOdBIRMoCiEh2ESkPbAKuFZEyfvsnxM/A/c6+EU7uuuOY2pePOUBfv765YiJyFUZy8GYRySYiuTDN2+TIBex1nuntEW/d7SKSwfG5NLDZOfb9zvaISHkRsYLTIWIDmuVK8CfQS0T+APIDb8ffQFWjgN7ANGe75UAFVT2DaWJ+7wwK7EjkGEOAFiKyDlgNVHYEnZeIyHoRGa+qc4FPgWXOdl8BuRwtiM+BNcDXwOIAzulJYAXwEybo+rMZWAjMBgY45/A+sBH4zZmm8Q62xRQy9uF0y2XFaVLNUtUqV9oXS/hha2gWiyVssDU0i8USNtgamsViCRtsQLNYLGGDDWgWiyVssAHNYrGEDTagWSyWsMEGNIvFEjb8P9vWhJ64jHvZAAAAAElFTkSuQmCC\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": "a083942d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys              : 3.8.12 | packaged by conda-forge | (default, Oct 12 2021, 21:59:51) \n",
      "[GCC 9.4.0]\n",
      "torch            : 1.10.1\n",
      "torchmetrics     : 0.6.2\n",
      "pytorch_lightning: 1.5.1\n",
      "matplotlib       : 3.3.4\n",
      "torchvision      : 0.11.2\n",
      "pandas           : 1.4.1\n",
      "numpy            : 1.22.0\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
}