/pytorch-lightning_ipynb/cnn/cnn-he-init.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "98ad7e05",
   "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": "7072e3ad",
   "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": "e06aae23",
   "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": "2a8924fd",
   "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": "10184fbe",
   "metadata": {},
   "source": [
    "<a href=\"https://pytorch.org\"><img src=\"https://raw.githubusercontent.com/pytorch/pytorch/master/docs/source/_static/img/pytorch-logo-dark.svg\" width=\"90\"/></a> &nbsp; &nbsp;&nbsp;&nbsp;<a href=\"https://www.pytorchlightning.ai\"><img src=\"https://raw.githubusercontent.com/PyTorchLightning/pytorch-lightning/master/docs/source/_static/images/logo.svg\" width=\"150\"/></a>\n",
    "\n",
    "#  A Basic Convolutional Neural Network Trained on MNIST"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e345b663",
   "metadata": {},
   "source": [
    "A basic convolutional neural network [1][2] trained on MNIST [3]. The weights are manually re-initialized using Kaiming He initialization scheme [4].\n",
    "\n",
    "### References\n",
    "\n",
    "- [1] L13.3 Convolutional Neural Network Basics (18:39), https://www.youtube.com/watch?v=7fWOE-z8YgY\n",
    "- [2] https://en.wikipedia.org/wiki/Convolutional_neural_network\n",
    "- [3] https://en.wikipedia.org/wiki/MNIST_database\n",
    "- [4] Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification, https://openaccess.thecvf.com/content_iccv_2015/html/He_Delving_Deep_into_ICCV_2015_paper.html"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ca42848",
   "metadata": {},
   "source": [
    "## General settings and hyperparameters"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7353e2d2",
   "metadata": {},
   "source": [
    "- Here, we specify some general hyperparameter values and general settings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9279033f",
   "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": "802fa6d8",
   "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": "6f36a4bc",
   "metadata": {},
   "source": [
    "## Implementing a Neural Network using PyTorch Lightning's `LightningModule`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faa1b0aa",
   "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": "e52bfdd5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 5;\n",
       "                var nbb_unformatted_code = \"import torch\\nimport torch.nn.functional as F\\n\\n\\n# Regular PyTorch Module\\nclass PyTorchModel(torch.nn.Module):\\n    def __init__(self, num_classes):\\n        super().__init__()\\n\\n        self.num_classes = num_classes\\n        \\n        # Calculate \\\"same\\\" padding:\\n        # (w - k + 2*p)/s + 1 = o\\n        # => p = (s(o-1) - w + k)/2\\n        \\n        self.features = torch.nn.Sequential(\\n            # 28x28x1 => 28x28x8\\n            torch.nn.Conv2d(\\n                in_channels=1,\\n                out_channels=8,\\n                kernel_size=(3, 3),\\n                stride=(1, 1),\\n                padding=1),  # (1(28-1) - 28 + 3) / 2 = 1\\n            \\n            # 28x28x8 => 14x14x8\\n            torch.nn.MaxPool2d(\\n                kernel_size=(2, 2),\\n                stride=(2, 2),\\n                padding=0),  # (2(14-1) - 28 + 2) = 0\\n            \\n            # 14x14x8 => 14x14x16\\n            torch.nn.Conv2d(\\n                in_channels=8,\\n                out_channels=16,\\n                kernel_size=(3, 3),\\n                stride=(1, 1),\\n                padding=1),  # (1(14-1) - 14 + 3) / 2 = 1 \\n            \\n            # 14x14x16 => 7x7x16                             \\n            torch.nn.MaxPool2d(\\n                kernel_size=(2, 2),\\n                stride=(2, 2),\\n                padding=0)  # (2(7-1) - 14 + 2) = 0\\n        )\\n\\n        self.output_layer = torch.nn.Linear(7*7*16, num_classes)\\n\\n        ###############################################\\n        # Reinitialize weights using He initialization\\n        ###############################################\\n        for m in self.modules():\\n            if isinstance(m, torch.nn.Conv2d):\\n                torch.nn.init.kaiming_normal_(m.weight.detach())\\n                m.bias.detach().zero_()\\n            elif isinstance(m, torch.nn.Linear):\\n                torch.nn.init.kaiming_normal_(m.weight.detach())\\n                m.bias.detach().zero_()\\n\\n    def forward(self, x):\\n        x = self.features(x)\\n        x = torch.flatten(x, start_dim=1)\\n        x = self.output_layer(x)\\n        return x   # x are the model's logits\";\n",
       "                var nbb_formatted_code = \"import torch\\nimport torch.nn.functional as F\\n\\n\\n# Regular PyTorch Module\\nclass PyTorchModel(torch.nn.Module):\\n    def __init__(self, num_classes):\\n        super().__init__()\\n\\n        self.num_classes = num_classes\\n\\n        # Calculate \\\"same\\\" padding:\\n        # (w - k + 2*p)/s + 1 = o\\n        # => p = (s(o-1) - w + k)/2\\n\\n        self.features = torch.nn.Sequential(\\n            # 28x28x1 => 28x28x8\\n            torch.nn.Conv2d(\\n                in_channels=1,\\n                out_channels=8,\\n                kernel_size=(3, 3),\\n                stride=(1, 1),\\n                padding=1,\\n            ),  # (1(28-1) - 28 + 3) / 2 = 1\\n            # 28x28x8 => 14x14x8\\n            torch.nn.MaxPool2d(\\n                kernel_size=(2, 2), stride=(2, 2), padding=0\\n            ),  # (2(14-1) - 28 + 2) = 0\\n            # 14x14x8 => 14x14x16\\n            torch.nn.Conv2d(\\n                in_channels=8,\\n                out_channels=16,\\n                kernel_size=(3, 3),\\n                stride=(1, 1),\\n                padding=1,\\n            ),  # (1(14-1) - 14 + 3) / 2 = 1\\n            # 14x14x16 => 7x7x16\\n            torch.nn.MaxPool2d(\\n                kernel_size=(2, 2), stride=(2, 2), padding=0\\n            ),  # (2(7-1) - 14 + 2) = 0\\n        )\\n\\n        self.output_layer = torch.nn.Linear(7 * 7 * 16, num_classes)\\n\\n        ###############################################\\n        # Reinitialize weights using He initialization\\n        ###############################################\\n        for m in self.modules():\\n            if isinstance(m, torch.nn.Conv2d):\\n                torch.nn.init.kaiming_normal_(m.weight.detach())\\n                m.bias.detach().zero_()\\n            elif isinstance(m, torch.nn.Linear):\\n                torch.nn.init.kaiming_normal_(m.weight.detach())\\n                m.bias.detach().zero_()\\n\\n    def forward(self, x):\\n        x = self.features(x)\\n        x = torch.flatten(x, start_dim=1)\\n        x = self.output_layer(x)\\n        return x  # x are the model's logits\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "# Regular PyTorch Module\n",
    "class PyTorchModel(torch.nn.Module):\n",
    "    def __init__(self, num_classes):\n",
    "        super().__init__()\n",
    "\n",
    "        self.num_classes = num_classes\n",
    "        \n",
    "        # Calculate \"same\" padding:\n",
    "        # (w - k + 2*p)/s + 1 = o\n",
    "        # => p = (s(o-1) - w + k)/2\n",
    "        \n",
    "        self.features = torch.nn.Sequential(\n",
    "            # 28x28x1 => 28x28x8\n",
    "            torch.nn.Conv2d(\n",
    "                in_channels=1,\n",
    "                out_channels=8,\n",
    "                kernel_size=(3, 3),\n",
    "                stride=(1, 1),\n",
    "                padding=1),  # (1(28-1) - 28 + 3) / 2 = 1\n",
    "            \n",
    "            # 28x28x8 => 14x14x8\n",
    "            torch.nn.MaxPool2d(\n",
    "                kernel_size=(2, 2),\n",
    "                stride=(2, 2),\n",
    "                padding=0),  # (2(14-1) - 28 + 2) = 0\n",
    "            \n",
    "            # 14x14x8 => 14x14x16\n",
    "            torch.nn.Conv2d(\n",
    "                in_channels=8,\n",
    "                out_channels=16,\n",
    "                kernel_size=(3, 3),\n",
    "                stride=(1, 1),\n",
    "                padding=1),  # (1(14-1) - 14 + 3) / 2 = 1 \n",
    "            \n",
    "            # 14x14x16 => 7x7x16                             \n",
    "            torch.nn.MaxPool2d(\n",
    "                kernel_size=(2, 2),\n",
    "                stride=(2, 2),\n",
    "                padding=0)  # (2(7-1) - 14 + 2) = 0\n",
    "        )\n",
    "\n",
    "        self.output_layer = torch.nn.Linear(7*7*16, num_classes)\n",
    "\n",
    "        ###############################################\n",
    "        # Reinitialize weights using He initialization\n",
    "        ###############################################\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, torch.nn.Conv2d):\n",
    "                torch.nn.init.kaiming_normal_(m.weight.detach())\n",
    "                m.bias.detach().zero_()\n",
    "            elif isinstance(m, torch.nn.Linear):\n",
    "                torch.nn.init.kaiming_normal_(m.weight.detach())\n",
    "                m.bias.detach().zero_()\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.features(x)\n",
    "        x = torch.flatten(x, start_dim=1)\n",
    "        x = self.output_layer(x)\n",
    "        return x   # x are the model's logits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "79316d43",
   "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": "853fc1c6",
   "metadata": {},
   "source": [
    "## Setting up the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fb5720a",
   "metadata": {},
   "source": [
    "- In this section, we are going to set up our dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8986a0b0",
   "metadata": {},
   "source": [
    "### Inspecting the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f073ff08",
   "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": "64cd15ad",
   "metadata": {},
   "source": [
    "### Performance baseline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f3575d1",
   "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": "1ef31928",
   "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": "81346f8c",
   "metadata": {},
   "source": [
    "## A quick visual check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e593c956",
   "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": "6e421077",
   "metadata": {},
   "source": [
    "### Setting up a `DataModule`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d49d3f8",
   "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": "38aac0e0",
   "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": "445b7bf7",
   "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": "c028742d",
   "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": "b0933dca",
   "metadata": {},
   "source": [
    "## Training the model using the PyTorch Lightning Trainer class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6e032d0",
   "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": "c929978b",
   "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": "d33092ed",
   "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": "12a556e0",
   "metadata": {},
   "source": [
    "- Now it's time to train our model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "994155b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/jovyan/conda/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/callback_connector.py:90: LightningDeprecationWarning: Setting `Trainer(progress_bar_refresh_rate=50)` is deprecated in v1.5 and will be removed in v1.7. Please pass `pytorch_lightning.callbacks.progress.TQDMProgressBar` with `refresh_rate` directly to the Trainer's `callbacks` argument instead. Or, to disable the progress bar pass `enable_progress_bar = False` to the Trainer.\n",
      "  rank_zero_deprecation(\n",
      "GPU available: True, used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "\n",
      "  | Name      | Type         | Params\n",
      "-------------------------------------------\n",
      "0 | model     | PyTorchModel | 9.1 K \n",
      "1 | train_acc | Accuracy     | 0     \n",
      "2 | valid_acc | Accuracy     | 0     \n",
      "3 | test_acc  | Accuracy     | 0     \n",
      "-------------------------------------------\n",
      "9.1 K     Trainable params\n",
      "0         Non-trainable params\n",
      "9.1 K     Total params\n",
      "0.036     Total estimated model params size (MB)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d04d84e76c7d4a118492c33ec1e5c737",
       "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": "f40ee97acf234a908eab1c321992d37d",
       "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.68 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": "68b1cdc7",
   "metadata": {},
   "source": [
    "## Evaluating the model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63dfe4c1",
   "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": "9b969dd1",
   "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": "fa85d6de",
   "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": "573163ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Restoring states from the checkpoint path at logs/my-model/version_16/checkpoints/epoch=14-step=6434.ckpt\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "Loaded model weights from checkpoint at logs/my-model/version_16/checkpoints/epoch=14-step=6434.ckpt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5eba7b0bf34d4f46ae78c9815b2eb2a2",
       "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.98089998960495}\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[{'test_acc': 0.98089998960495}]"
      ]
     },
     "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": "f34ce729",
   "metadata": {},
   "source": [
    "## Predicting labels of new data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6e21faf",
   "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": "5c0290f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logs/my-model/version_16/checkpoints/epoch=14-step=6434.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": "a31e2c63",
   "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": "5184c44d",
   "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": "f09b97c7",
   "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": "3e130630",
   "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": "000e299a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy: 0.9809 (98.09%)\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": "5f9ab992",
   "metadata": {},
   "source": [
    "## Inspecting Failure Cases"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07a2fc0c",
   "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": "e0d9be2c",
   "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": "a956bb69",
   "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": "4a997bcd",
   "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": "6b279565",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAATQAAAErCAYAAABQAX/RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABQ8klEQVR4nO2dd5gU1dKH32LJcUEWJErOUYLkJEGUqBJUJKmgIogKgvrpFa8ZvQa4V8QEioICEkRFRKJKVpAgiCIZgSVnltn6/ji9y7BsmNnpZneH8z7PPNPTobqm+0zNSV0/UVUsFoslHMiU1g5YLBaLW9iAZrFYwgYb0CwWS9hgA5rFYgkbbECzWCxhgw1oFoslbMic1g6EG5I5h0q2fK7brV2puOs2AUTct+nVTCAvfAU47/PG4ZgLsZ7YzZUtwnWbXt2zcx5dg42//RqtqlEJ19uA5jKSLR/Zqt7lut2ffn7ddZsA2T0oAWcvuG8TvPEVYPeRc57Y3XfkrCd265Vx/w/Tq3u2/eApT+xWLpp7R2LrbZPTYrGEDTagWSyWsMEGNIvFEjbYgGaxWMIGG9A8ZFCPpqyePIw1U4bzUM+m8esf6N6EdVNHsGbKcF4Y3AGAnu2uZ/mkR+Nfp5aPpkb5okGdb+C9/SlZtBB1alVz9XvMnTuXihUrUq5cOV5++WVXbHrlK7jv797du+jeqS0tb6jJjQ1r88G4sS54aejcrDp3tG/EXR2a0LtzC9fsZpR7du7sWbrf3JwurRvQoUVdxox+PiR7kpGybYjIN8Cdqno0iGMmAHNUdZpXfvmTKde1mq3qXVQpcy0fv9CLpn3f4vwFH7Pfuo8hr0ynWKF8jOjXmq6PvM/5GB9R+XNz8MjJS2xULXstU1/rT5WuL8avOxLAKOePS5eQK1du7u3fmzVrNwTkb0ojhz6fjwoVKvD9999TvHhx6tWrx+TJk6lSpUqSxwQyYuaFr6n1N6VRzv3/7OPA/n+oXrM2J0+c4OZWDXn/k6lUqFQ52eMCGeXs3Kw6E2cuIrLANSnuG0dKo5zp6Z6lNMqpqpw+fYpcuXITExNDry5teOK5V6lVp36yx1UumnuNqtZNuD5D1dBU9eaEwUwM6e57VCpdiJUbdnLmXAw+XyxLf/mLzi2qM+C2Rrw2cQHnY3wAlwUzgO5ta/PFvF+DPmeTps0oUKBAyL77s3LlSsqVK0eZMmXImjUrPXv2ZNasWSHb9cJX8MbfwtcWoXrN2gDkzpOHchUq8c++PW646wkZ6Z6JCLly5QbgQkwMMTExSAgTDtNdIIhDRGaKyBoR2SgiA5x120WkoIiUEpHfReR/wC9ACRE5KSKvi8gvIvKDiFw26U5EnhGRVSKyQUTGi3PlRGSRiLwiIitF5A8RaeqsjxCR0c4xv4nIwED93/jXPzSpXYYC+XKSI1sWbmpcmeKFIylXMorGtcqw5MMhzBv3IHUql7js2Nvb1OKL74IPaF6wZ88eSpS46GPx4sXZsyf9/pi99nfXzu1s/G0ttVOoQQSMCIP7dqV3p+bMmDzBFZMZ7Z75fD66tm5IkxqladSsFTWvr5dqW+k2oAH9VbUOUBcYIiIJ6+QVgY9Vtbaq7gByAb+o6vXAYuBfidgcq6r1VLUakAPo4Lcts6rWB4b6HXsPcExV6wH1gPtEpHRCoyIyQERWi8hqvXAagC3bD/D6xwuYM2Ygs9++j9+27uWCz0fmiEzkz5uDZv3f5sm3v2LSS3dfYqte1ZKcPhvDpm3/BHGpvCOxLolQ/kG9xkt/T508ycA+d/Dsi6+RJ29eV2y+/8V3fDJ7CW9+OI2pk97jl5U/hWwzo92ziIgIZsxfxsI1W1i/djV/bN6YalvpOaANEZF1wHKgBFA+wfYdqrrc73Ms8LmzPAlokojNliKyQkTWA62Aqn7bvnTe1wClnOW2QG8RWQusAK5JxA9Udbyq1lXVupI5Z/z6ibNX0qj3G7QZ+D+OHDvNnzuj2XPgGDMXrgdg9aZdxMYqBSNzxR/TrW2tVDU3vaJ48eLs2rUr/vPu3bspWjS4wYoriVf+xsTEMKBPT7rc3pP2HbuEbC+OqMJFAChQMIoWbTuwad0vIdvMaPcsjrz5IqnfsCk/LpyfahvpMqCJSAugNdBQVWsCvwLZE+yW0jMVl/xNiUh24H/A7apaHXgvgc24nmEfFx8JE2CwqtZyXqVVdV6g3yMqv+kbKFE4ks4ta/DFvF/5avEGWtQtB0C5kgXJmiUz0UdPxfnIra1qMjUdBbR69eqxdetW/v77b86fP8+UKVPo1KlTWruVJF74q6oMHzKQ8hUqMWDQwy55CmdOn+LUyRPxyyuWLqRsheQHGgIhI92zw4cOcvzYUQDOnjnDsqULKV2uQqrtpddnOfMBR1T1tIhUAhoEcEwm4HZgCnAn8GOC7XHBK1pEcjv7pjTy+R3wgIgsUNUYEakA7FHVgB5Qm/xKHwrkzUmML5aho7/k6IkzTJy9knef7sHqycM4H+Pj3lGT4/dvUrsMew4cY/vew4GYv4zeve5g6eJFREdHU7ZUcZ5+ZhR9+9+TKltxZM6cmbFjx9KuXTt8Ph/9+/enatWqKR+YBr565e+qFT8z/fPPqFSlGu2amb6zEU8/R6s2N4Vk93D0QYY/YJ779fl8tOt4Ow2btw7JJmSse3Zw/36eeHgAvlgfsbGx3NTxVlq2aZ9qe+ly2oaIZANmAsWALUAU8CwwAdOnlhszFaOa3zEngTeAm4FjQA9VPeg/bUNEngd6AtuBXZhm67MisggYpqqrRaQgsFpVSzmjp88DHTG1tYNAF1U9lpTvcdM23CaQaRupwT6cbh9Ohwz5cHqi0zbSZUBLDSJyUlVzp7UfNqDZgBaHDWhXPqClyz40i8ViSQ1hE9DSQ+3MYrGkLWET0CwWi8UGNIvFEjbYgGaxWMKGsBnlTC/UrVtXV69e7brdHLUfct0mwJFV7qXC8ZroE96MRhbMk80Tu17h1WhvRkJE7CinxWIJb2xAs1gsYYMNaBaLJWywAc1isYQNNqBZLJawwQY0i8USNtiAlkYEq8qz44eXWD31yfjPt7auzZppT3FqzdtcX6Vk/PpWN1Tip08fZ9UXT/LTp4/TvN7F3FK3t72elZ8/wZppT/HCw50D9tULtR+vVJ+8Umjyyt+MpNTllV03baabgCYiXUQkaVkad85RSkQSlasRkffjzh+nXeCVHz6fj0GDBvHtt9+yadMmJk+ezKZNm5I9pvOg/17yeeNfe+n52Hv8+Mtfl6w/dPQktw99l3rdX+S+Zz7hw+d7A1AgXy5eHNqFm+8fQ53bX6DQNXlpUT+wRHp39+nLrDlzg/iGaWMTICJzZp7+9yssXLGOWfOWMPGDcfyx+feQ7Xrlrxd2U1O+0squ2zbTTUADugCeBrTkUNV7VTX0ux4AqVHlOXzs9CWft/y9n607Dly237otu9l30KRr2/TXPrJlzULWLJkpXewatu48QLSjMrVgxWa63FgrIH+9UPvxSvXJK4Umr/zNSEpdXth126anAS0J5aaTfttvF5EJItII6ASMFpG1IlJWRGqJyHJHbWmGiOR3jlkkIm+IyBJH+ameiHwpIludBI5xth911J02iMhQP7cyi8hEx+40EcnpZ/fyhHEivRw1qLUi8q6IRIR6Xa6UKk/X1rVYt2UX52Mu8Neug1QsVZiSRQoQEZGJTi1rUrxwftfPmZ5wXaEpg+BV+fLCrts2va6hpaTcBICq/gzMBoY7ufv/Aj4GRqhqDWA9l6o4nVfVZsA4YBYwCKgG9BWRa0SkDtAPuAGTvvs+EantHFsRGO/YPQ48mJTzIlIZ6AE0VtVaGL2By7I3+qs+HTx4MMWLciVUeSqXuZbnh3TmoeenAHD0xBmGvPg5k17pzw8fPsKOvYfw+WJdPWd6wguFpoyCV+XLC7tu2/T6qbAhItLVWU5MuSlRRCQfEKmqi51VE4GpfrvMdt7XAxtVdZ9z3DbnPE2AGXG5/0XkS6Cpc9wuVY3TCpsEDAFeS8KVG4E6wCrnIucALmvnqep4YDyYZzlT+n5eq/IUKxTJ5/8ZwL1Pf8Lfu6Pj13+zZAPfLDFdiP1vbYzPF0tb186afvBKoSmj4FX58sKu2zY9q6Elo9zk/4NPqOQUKHFPKcf6Lcd9zozJ/58UCQNOcgFIgIl+qk8VVfXZYJ1NiJeqPPly5+DLMffzzJjZLFu37ZJtcSpUkXlyMKB7Uz6ascyVc6YnvFJoykh4Vb68sOu2TS+bnEkpN+0XkcqOAElXv/1PAHkAHBGSI3EK5sDdGPHgQFkCdBGRnCKSyznPUmdbSRFp6CzfweXqUP78ANwuIoUARKSAiFwXhB+J4q/KU7lyZbp3756iKs+iiY9R4brC/Dn33/Tp0pBOLWvw59x/c0ONUnz59v3M/u8gAO7v2YyyJaIYed9NLJ8ykuVTRsYHstcev51fpj/FggmP8vpH3/PnzssHFRKjd687aNG0IX9s2ULZUsWZ8OEHoV0Aj2zCRYWmn5Yuol2z+rRrVp8F34c+iuiVv17YTU35Siu7btv0LH1QMspNBYFXMKpLG4DcqtpXRBpjtDLPYSTm8mD6yHIC24B+qnokgUJTC2e5g3NO/22PAv0dd95X1TdFpBTwDSbgNQK2Anc7Qdf/2O1AXVWNFpEewBOY4B8DDEogcHwJNn2Qd9j0QQabPijp9EE2H5rL2IDmHTagGWxAs/nQLBbLVYANaBaLJWywAc1isYQNNqBZLJawwQY0i8USNtjxEpdRhbMX3Le7ZPoL7hsF8jd81HWbv87+t+s2vaR4fm9GOXcf8WZUdkf06ZR3CpKsEd7UbaqXzOeJ3aSwNTSLxRI22IBmsVjCBhvQLBZL2GADmsViCRtsQLNYLGGDDWgWiyVssNM20oCB9/bn22/mEFWoEGvWJqrZkmo6N6tOzlx5yBSRiYiIzHw8a1GS+5aKysGO70Zx8MhJ6vYcDUD+vDn55MW7ua5IAXbsO0yvJz7m6IkzAAzreyN9O92ALzaWx16bwfzlWwDIkjmCNx6/lWbXlyVWldzZIzhx1pesn+fOnuXuW9tx/vw5Lly4QLtbujB4+P+F/P29sjt37lwefvhhfD4f9957LyNHjgzZ5t7duxj64D0c3L+fTJkycWefe7jnfneSEJw4foxXnhrCtj82IwJPvDSGarVDT0UeTPkKFDd/D1dVDS0p1Sd/xacUju8rIiGnp/BKQSiOdz79ik/n/JhiYYs+cZ7OQ8Zfsm5Yn1YsWrWV6re9xKJVWxnW50YAKpUuTLc2tbm+xyt0GjKet0bcRqZMJo/miP6tOXj4JDVuf5na3V/l9LnkgxlA1mzZ+Gjq18ycv5wZ3y/jx0XzWbtmZeq+sMd2vVJR8kqhCuCt55/ghqY38tl3K5gweynXla3oil0IvHwFipu/h6sqoCVFUopPbgiiJIZXCkLBcvKsj8PHL52k2aF5NSbNWQXApDmr6NiiWvz6qd//yvkYHzv2HuavXdHUq2r0QPt0qs/oCT8AJmOsL4CMVCJCrlwm8eSFmBhiYmJcyXvvhV2vVJS8Uqg6dfI461b/TIdudwOQJWtW8uS9shNcg8HN38PVGNAuU33yV3wSkZMi8pyIrAAaikg/EflDRBYDjdPW9QAQYXDfrvTu1JwZkycEfXihAnn459AJAP45dCI+222xqHzs3n80fr89B45RNCof+XKbLOr/uv8mfv7kUT59qTeBTjr3+Xx0bd2QJjVK06hZK2peXy9of6+E3Suh0uWmQtXenTuIzF+QF0c+RL/OzXn5ySGcOX3KBS8JuXx5zdUY0FJSfcoFbFDVG4C/gFGYQNaGJHRDL1F9ik5Z9clL3v/iOz6ZvYQ3P5zG1Env8cvKn1I+KBASqeSoQuaICIoXzs+yddtpdPd/WLF+B4UCTJgYERHBjPnLWLhmC+vXruaPzRtdcdVtu16rdLmtUOXzXeCPTevocmc/Ppq1mOw5czJp/JuhO4qH5cslrsaAllD1qUmC7T5gurN8A7BIVQ+q6nng88QMqup4Va2rqnWjCkZ54nSgRBUuAkCBglG0aNuBTet+Cer4A4dPcO01eQC49po8HHSEifccOEbxwpHx+xUrlI990cc4dOwUp86cY9ai9QB8+cM6smcJrljlzRdJ/YZN+XHh/KCOu1J2vVTp8kKhKuraokRdW5SqNU1C15btOvPHxt/csR1i+fKaqzGgpaT6dFZVfclsT7ecOX2KUydPxC+vWLqQshUqB2Xj6yUb6dXBNNF6dajHnMUbnPUb6NamNlmzRHBd0QKUKxnFqo07Afhm6Saa1SkLQIt65Tl3IWW9z8OHDnL82FEAzp45w7KlCyldrkJQvl4pu16pKHmlUHVNVGEKXVuMndu2ArB62WJKlQt9UMCN8uU1V+O0jZIi0lBVl3FR9aljEvuuAN5yBJKPA92AdaE60LvXHSxdvIjo6GjKlirO08+Mom//e0I1y+Hogwx/wOgg+3w+2nW8nYbNWye5f5lCOVj04cMUjMzFn3Oe4d/jv+O1iT8w6aXe9Ol0A7v2H+GukR8D8Pu2/Uyfv5ZfvxjBBV8sQ1+dTmysifX/N2YOH4y6k9GPdiH66EkOHD+foq8H9+/niYcH4Iv1ERsby00db6Vlm/YhXwMv7PorE/l8Pvr37++KilKcQlWlKtVo18z0nY14+jlatbkpZNuPPP0Ko4YN5ELMeYoWL8UTL4euHRFs+QoUN38PV5VISlKqT866OMWnk6qa2++YfhjVp33AWiBCVZOcLFSnTl39aYX7Iinrdx5z3SZAsx6jXLeZ0dIHVSqSyxO7Nn2Qd+mDcmRJXCTlqqqhqep2Eu/Yb+G3T27/Dar6EfCRp45ZLBZXuBr70CwWS5hiA5rFYgkbbECzWCxhgw1oFoslbLiqBgWuBCKQ3YOrWq+MN6NFZ1b9x3WbOeq5L7wC3vgKsHmfS48FJcCr0VMvRF28ugZXGltDs1gsYYMNaBaLJWywAc1isYQNNqBZLJawwQY0i8USNtiAZrFYwgYb0NKIuXPnUrFiRcqVK8fLL7+cbm2mxu64p3uw47tRrJ4yPH5d/rw5mTN2IOunP8GcsQOJzJMjftuwvjey4csnWTdtJK0bXExzM+vtAaz4dBhrPn+ct0fe7pm/KXHu7Fm639ycLq0b0KFFXcaMfj5km3Gkl3sWCF5dh4H39qdk0ULUqVUtZFs2oAWAiLQQkUZu2fNCdMMrIY/U2P1kzipXxFd6PTGRG+56jTo9Xo1PBe6FvynhlaBLerpngeDVdbAiKVeeFph0Q67gheiGV0IeqbH706/bXBFfOXHKpN/JHJGJLFkC06vx4jp4JeiSnu5ZIHh1HaxIikuISG9HLGWdiHwiIh1FZIWI/Coi80WksJND7X7gERFZKyJNQz2vF6IbXgl5uGU3WPGVOGa/PYCd857j5KnAcot5dR28EHRJ7/csMbwStnGLqzagiUhV4CmglarWBB7GZK9toKq1gSnA404OtXHAG6paS1WXhnpuL0Q3vBLy8FogJCnxlTg6DRlP6fbPki1rYM+TeeWvF4IuGfGeeSVs4xZXbUADWgHTVDUaQFUPA8WB70RkPTAcCCjP8iWqTwdTVn3yQnTDKyEPt+wGK77iz7nzF5izJDBFbS8FTcBdQZf0fs+Swythm1C5mgOacLkAyhhgrKpWBwYC2QMxdInqU1TKqk9eiG54JeThlt1gxVdy5cgaHwAjIjJxU+PAxDi8uA5eCbqk93uWEK+ug5tczdk2fgBmiMgbqnpIRAoA+YC4zoY+fvueAEIXTHTwQnTDKyGP1Nid+HwvmtYpF5L4Sq4cWZn2n3vImiUzERGZWLxqa5pdB68EXdLTPQsEr66DFUlxCRHpg2la+oBfgRnAG5igthyop6otRKQCMA2IBQYn149Wt25dXb3afZGUjIRNH2TwKn2QF3h1DUpFeXMNrEhKIqjqRGBigtWXjW+r6h9AjSvilMViSTVXcx+axWIJM2xAs1gsYYMNaBaLJWywAc1isYQNNqBZLJaw4aoe5fQCVTh7wX272w9mnGF1r6ZX5Kj/mCd2z6x83RO7u48E9vxpsBw6cd51m9myeFO3WbQl5Sdn3CTJgCYiJ7g4kz7uQTB1llVVXZtoarFYLG6QZEBT1TxX0hGLxWIJlYDqmSLSRET6OcsFRaS0t25ZLBZL8KQY0ETkX8AI4AlnVVZgkpdOWSwWS2oIpIbWFegEnAJQ1b2AbY5aLJZ0RyAB7byaJ9gVQEQyzhO3FovlqiKQgPaFiLwLRIrIfcB84D1v3Qpv3FS5icNLZSIv/IXQlIkG9WjK6snDWDNlOA/1vJgV/YHuTVg3dQRrpgznhcEd4tcP69OKDdOfYN3UEZcoS10JX5Ni7+5ddO/UlpY31OTGhrX5YNxYV+zG4fP56NG+CYP7dXPFnldlbMbH4xjYuSn3d2nGy8MHcv7c2VTbSjGgqeprmNQ504EKwDOqOibVZ0xDRORZERmW1n64qXITh1eKPOCNv6EoE1Upcy39utxA075vUf+u12nfpAplSxSkWZ2ydGhWlXp3vkadnqN5c9IiwFGWalub63u+SqeH3+Otx2+NV5by2tfkiMicmaf//QoLV6xj1rwlTPxgHH9s/j1ku3F89uE7riZg9KKMRe/fx6xP3+ftz+cxbuYSYmN9LP52ZqrtBTqbbj2wFFjiLF+1iEjIk5HdVLmJwytFHvDG31CUiSqVLsTKDTs5cy4Gny+Wpb/8RecW1RlwWyNem7iA8zE+gPg03x2aVWXqPD9lqd2H4pWlvPY1OQpfW4TqNWsDkDtPHspVqMQ/+9wRM9m/bw9LF3zHrT37pLxzgHhVxnwXLnD+3Fl8Fy5w7swZCkQVTrWtQEY57wVWArcCtwPLRaR/qs94hRGRp0Rki4jMByo668qKyFwRWSMiS0WkkrM+SkSmi8gq59XYWf+siIwXkXnAx2n3bZInvSvy+BOKMtHGv/6hSe0yFMiXkxzZsnBT48oULxxJuZJRNK5VhiUfDmHeuAepU9nYv1xZ6uglylJe+hoou3ZuZ+Nva6ldp74r9kaPGsnQJ59DMrn7BIDbZaxg4SLc1vdBereuzZ0tq5MzTx7qNG6ZanuBfNvhQG1V7auqfYA6mGkc6R4RqQP0BGpjAnLc1R+PyTxbBxgG/M9Z/xZG3akecBvwvp+5OkBnVb0zkfNcFEmJvrKPeviT3hV5/AlFmWjL9gO8/vEC5owZyOy37+O3rXu54POROSIT+fPmoFn/t3ny7a+Y9NLdcYYDOr8XvgbCqZMnGdjnDp598TXy5A39AZwlP3xL/msKUqV6bRe8uxS3y9iJY0dZvnAuH323mk8X/Ma5M6dZ8NXUVNsLJKDtxuTUj/cB2JXEvumNpsAMVT2tqseB2Rjhk0bAVBFZC7wLFHH2bw2MddbPBvKKSNwUldmqeiaxk1wiklIwZZEUr0mvijz+hKpMNHH2Shr1foM2A//HkWOn+XNnNHsOHGPmQtMjsnrTLmJjlYKRudhz4GgCZalI9kUfv2K+JkdMTAwD+vSky+09ad+xiys2165eweL539K+cTVGDu7Hqp+X8OTD97piOw63ytja5UsoXKwkkQUKkjlLFhrdeAub1q5Ktb0kA5qIPCoij2Ly669wml3/wuTa/zPVZ7zyJPx7zQQcdTQ2416V/bY19FtfTFXjgrk3T4e7REZQ5PEnVGWiOKHiEoUj6dyyBl/M+5WvFm+gRd1yAJQrWZCsWTITffQUXy/dSLe2fspSJQqyauPOK+ZrUqgqw4cMpHyFSgwY9HDI9uIYMuJZ5q3YzLc/beDlMR9Rr1EzXnzr/ZQPTAEvylhUkWJs/m0NZ8+cRlVZu2IpJcqk3mZyHdxxNZO/nFccofeGXjmWABNE5GXMd+2IqZH9LSLdVHWqmLZDDVVdB8wDHgJGA4hILVVd67ZTbqrcxOGVIo9X/oaqTDT5lT4UyJuTGF8sQ0d/ydETZ5g4eyXvPt2D1ZOHcT7Gx72jJgN+ylKfP+4oS31JbGzgTU6vVJRWrfiZ6Z9/RqUq1WjXzPSdjXj6OVq1uSlk217gRRmrVKMOTdp0YHD31kREZKZspWq073Z3qu2FveqTiDwF9AZ2YJrPmzBTUN7BNDWzAFNU9TkRKQj8F6iMCYBLVPV+EXkWOOlMYUmWOnXq6k8r3Fd9ykjpg7J7lJTKpg8yZKT0QdsPn/bEbvtqhVKn+iQiUcDjGBXxeOFdVW3lqoceoaovAC8ksumyv0FHRb1HIuufdd8zi8XiNoGE5U+BzUBpYBSwHUh9r53FYrF4RCAB7RpV/QCIUdXFqtofaOCxXxaLxRI0gfR2xDjv+0TkFmAvUNw7lywWiyV1BBLQnheRfMBjwBggL/CIp15ZLBZLKkgxoKnqHGfxGJD6ZxIsFovFY5ITSRnD5ZNS41HVIZ54lME5dyHWkykWlYp4k4bOC4Wq2ev/cd8o3k2vyNHoiZR3SgVbv37WE7vX5Mnqus2CebK5bhO8mRaUHMnV0NyfTGWxWCwekpzq08Qr6YjFYrGEilVOt1gsYYMNaBaLJWywAc1isYQNgWSsrSAiP4jIBudzDRH5P+9ds1gsluAIpIb2HkZkOAZAVX/DZIG1pBKv1HO8UCYC71Sfvpr0HoO7tuChrs2Z/cl41+yGch0G92jMmklDWT3pYSaO6km2rJn55Lk7WD5hMMsnDGbz9MdZPmEwAHUrF49fv2LiEDo1qxLUubxSffLKrlflwE27gQS0nKqaUNrFg9lLV560UoHyQj3HK2Ui8Eb1acfWzcyb/imvffYNb039gVVL5rN3x7aQ7YZyHYoWzMuD3RrRuP9Y6vZ6i4hMQrfWNbj7mck06DuGBn3HMHPRBmYtNmmnN27bT+N7/kuDvmPo/OhHjBnRlYiIwHtxvFJ98squF+XAbbuBXP1oESnLRaHh24F9rpz9KsUL9RyvlInAG9Wn3X9vpUKNOmTLkZOIzJmpVrcBy3/4NmS7oV6HzBGZyJEtCxERmciRPSv7ok9csv22VtX54vt1APGqUwDZsmYOSqcAvFN98squF+XAbbuBBLRBmCyvlURkDzAUeMCVs6cBSahA1RKR5SLym4jMEJH8zvp6zrplIjI6rh/RDdxWz7kSykRuUrJcRTb9spzjRw9z7sxp1ixdQPT+vSHbDeU67I0+zpuTl/LHjBH8PfsJjp88yw8rt8Zvb1yrFPsPn+Sv3Yfi19WrUsI0UT95mCGvzowPcMHituqT13bTK4EIDW9T1dZAFFBJVZuo6nbPPfOAZFSgPgZGqGoNjO7ov5z1HwH3q2pDwJeM3XjVpyOHogPyxW31HK+VidymRJkK3NpvEP8a0INnH7iTUhWrkCkiImS7oVyHyDzZ6dC0CpVvH02ZTi+RK0cWerarFb+9e+uaTJ2/7pJjVm3aRZ1eb9Lknv8yvHcLsmUNPl2v26pPXttNzwQyyvmMiDyDybbxiN/njEhiKlC5gEhVXezsMxFoJiKRQB5V/dlZ/1lSRv1Vn/JfUzAoh9xSz/FSmcgr2tx6J2988T0vTZhJnryRFC1ZJmSboVyHVnXLsX3vYaKPnuKCL5aZizbSoPp1AEREZKJzi6pMm/9bosdu2XGQU2fOU7VMcCK5Xqg+eWk3vRNIk/OU38sHtAdKeeiT1wTa0eFZ9cYL9RyvlIm85KhTmz24bzfLfviGZjd3CdlmKNdh1/5j1K9akhzZsgDQsm45tmw/AJhg98eOg+w5eFH+7roi+eMHAUpeG0mFklHs2HckYF+9Un3yym5GIJD0QZekOBCR1zA1m4xIUipQR0SkqaouBe4GFqvqERE5ISINVHU5Lk5V8UI9xytlIvBG9QnglUfv4fixI2TOnIWBT75E7ryRIdsM5Tqs2rSLGQs3sGzCQ1zwxbLuj318MMuMPndrXSN+MCCORjVLMaxXc2Iu+IhV5eHXZ3HoWOCiIF6pPnll16ty4KbdoFWfnA7zlapaPlVnTGOSUIGaD4wDcgLbgH5OQLsBMw/vFLAIaKaqjZOzX63m9Tpt7lLX/c5I6YPm/e5N+qBO1a/1xG5GSx/kBV6lD/KKHFkk1apP67nYTIvADA485657V45kVKAS00nY6AwUICIjsSmVLJZ0TSBDMh38li8A+1U1LCbWBsAtIvIE5jrtAPqmrTsWiyU5kg1oIpIJ+FpV3X3WIYOgqp8Dn6e1HxaLJTCSHeVU1VhgnYiUvEL+WCwWS6oJpMlZBNgoIisxneMAqGr6nhNgsViuOgIJaKM898JisVhcIJCAdrOqjvBfISKvAIuT2P+qJsYXy75jZ123mzt78I/UBIIXw/VeTa/wCq+mV5S/yZu0gWdWjHbdphfTd9KCQJ4UaJPIutBmgVosFosHJKfL+QDwIFBGRPwfYMsD/OS1YxaLxRIsybVjPgO+BV4CRvqtP6Gqhz31ymKxWFJBcrqcx4BjwB1Xzh2LxWJJPVb1yWKxhA02oFkslrDBBrQ0YOffW7mva4v4V4e6pZg2cVzIdjOa2o9XKlVu23Xjug7q0YTVnz3GmsmP8VDPJpdsG3pXc86sGM01+XJesr5E4UgOLnyeoXc1D/p8XlzbcFF9ChtEZIiI/C4in6alHyVLl+e9GYt4b8Yixk37gWw5ctKk9S0h281Iaj9eqVR5YTfU61qlTGH6db6Bpv3epn6vN2jfuAplS5jMxsUL5aNV/fLsTCQx5KuPdGLess1B++vVtQ0X1adw4kHMROG74laIiDczVgPkl+VLKFqiFNcWK5HyzimQkdR+vFKp8sJuqNe1UqnCrNywI14laumv2+jc3NRGXn2kE0+N/foyLYSOzary955DbNq2P2h/vbq24aL6FBaIyDigDDBbRI6JyHgRmQd8LCLXOerwvznvJZ1jyjpqUKtE5DkROem2Xwu/mUGrW25122y6V/vxSqXKa/Wr1FzXjdv+oUntMhTIm5Mc2bJwU6NKFC+cj1uaVmHvwWOs33qpKmTO7Fl4rHdLXnj/+1T5mNEUwNzkqgloqno/sBdoCbwB1AE6q+qdwFjgYyeZ46fA285hbwFvqWo959hE8Vd9OnbkUFK7XUbM+fP8vGAuzdu5+5x/RlD78Uqlykv1q9Re1y3bD/D6xwuZM+Y+Zr91L79t3csFXywj+t7Ic+/Ou2z/pwe0Y8zkJZw6cz5VfmY0BTA3SdPmVhozW1XPOMsNMbJ2AJ8Ar/qt7+Isfwa8lpghVR0PjAeoWK1WwDnNVy6dT/kqNShQsFBwnidDRlH78Uqlyiu7oV7XiV+tYuJXqwAY9cBNHDh8kh7trmflpEcAKFYoH8s+HkrTfmOoV7UEXVtW54WHbiFfnhzExipnz8UwbtrPyZ0inoyoAOYWV3NAO5XMtuCEFlLJgq+/dLW5mZHUfvzVmYoVK8aUKVP47LMklQLT1K4b1zUqfy4OHjlFicKRdG5RnRb3juW/n/8Yv33zjCdo3PctDh07TeuB78Svf+reNpw6cz7gYAbeXduMwFXT5EyBn7mo6nQXEFfSlgO3OcuuqT4BnD1zmjU/L6Zpmw4p7xwgcWo/Py1dRLtm9WnXrD4Lvg999Kh3rzto0bQhf2zZQtlSxZnw4Qch2/RXZ6pcuTLdu3d3RaXKC7tuXNfJL/fmlynDmPZ6P4aOnsHRE2dSPiiVeHVtvSgHbtsNWvUpIyMi24G6wEPASVV9zVlfCvgQKAgcxKg+7RSR8sAkjEbn18AAVS2W3DkqVqul46b94Lrv5Qvndt0meJM+yKNMR56x+8g5T+za9EHekWrVp3BCVUs5i88mWL8daJXIIXuABqqqItITq/pksaRrrqqAlgrqAGPFDBEdBfqnrTsWiyU5bEBLBkdJvWZa+2GxWALDDgpYLJawwQY0i8USNtiAZrFYwgbbh+YyebJnpmWla1y3u2rbMddtAqzc6X429fol3X+AGbyZYuKlXS+mVwDkqPeo6za3znvJdZsA+464r4CWHLaGZrFYwgYb0CwWS9hgA5rFYgkbbECzWCxhgw1oFoslbLABLY3wSiCkc7Pq3NG+EXd1aELvzi1SZeO//3qEfi2rM/S2lvHrThw7wqiBPRjUsTGjBvbg5PGjIfmZ0QRd0pNQzI7vRrF6yvD4z/nz5mTO2IGsn/4Ec8YOJDJPjvhtw/reyIYvn2TdtJG0blARgBzZsvDlG/eyduoI1nz+OP9+KDA9C6/uGbhTbiGMApqIlBKRDWntRyB4JWIRxzuffsWnc37k41mLUnV8i049ePp/l+rIzPhwLNVvaMJ/v/qJ6jc0YcaHoRXmjCTo4pXd1JaDzkPGX/J5WJ9WLFq1leq3vcSiVVsZ1udGACqVLky3NrW5vscrdBoynrdG3EamTCZz7ZuTFlGr2ys0uOt1GtYoTfbMKYcCr+5ZHKGWWwijgBYKV1ooxSsRC7eoWqcBufPmv2TdqkXf0bJjdwBaduzOyoWh/bgzkqCLV3ZTWw4OHz99yecOzasxaY7Jhjtpzio6tqgWv37q979yPsbHjr2H+WtXNPWqluTMuRiWrPkTgJgLPtZu2U1EAJHAq3vmJuEW0CJE5D0R2Sgi80Qkh4jUcoROfhORGSKSH0BEFonIiyKyGHhYRLqJyAYRWSciS5x9IkRktCOS8puIDHTDSU9FLEQY3LcrvTs1Z8bkCe7YBI4eiiZ/VGEA8kcV5tjhwLUTUiK9C7p4hVvloFCBPPxz6AQA/xw6QVR+kzuvWFQ+du8/evF8B45RNCrfJcfmy52dm5tW5eyF2KDO6fo9c6nchtuTAuWBO1T1PhH5ApNt9nFgsKouFpHngH8BQ539I1W1OYCIrAfaqeoeEYl0tt8DHFPVeiKSDfhJROap6t+hOOmliMX7X3xHVOEiHI4+yEN9unBd2fJcX7+xK7a9ICMIuniF52ImiZjyP2VERCYmvnA3//t8KQ/3ax+wWS/umVvlNtxqaH+r6lpneQ1QFhO0FjvrJgLN/Pb/3G/5J2CCiNwHRDjr2gK9RWQtsAK4BhM0L8Ff9engwYMpOumliEVU4SIAFCgYRYu2Hdi07hdX7EZeU5AjB41G5JGD+8lXIPTHuzKKoItXuFUODhw+wbXX5AHg2mvycPCIUVvcc+AYxQtHxu9XrFA+9kVffITuv09246+d0YydvCTgc3l1z9wqt+EW0PxzKfuAyBT2jxdKcWTu/g8oAawVkWsw/3GDVbWW8yqtqpfpjqnqeFWtq6p1o6KiUnTSX8Ti/PnzTJkyhU6dQpeyO3P6FKdOnohfXrF0IWUrVA7ZLkDd5m1Z+NUXACz86gvqtWgXkr2MJOjiFW6Vg6+XbKRXh3oA9OpQjzmLNzjrN9CtTW2yZonguqIFKFcyilUbdwLwr/vbky93Dob9Z2bA5/HqnrlZbsOtyZmQY8AREWnqJGu8G1ic2I4iUlZVVwArRKQjJrB9BzwgIgtUNUZEKgB7VDU5xagU8Rex8Pl89O/f3xURi8PRBxn+gBGF9/l8tOt4Ow2btw7azn9GPsDG1cs4cfQw97WtQ48HHuPW/g/x+uP388OMKUQVKcZjo98Nydc44ZFKVarRrpnphxnx9HO0anNTSHZ797qDpYsXER0dTdlSxXn6mVH07X9PSDa9spvacrDow4cpGJmLP+c8w7/Hf8drE39g0ku96dPpBnbtP8JdIz8G4Pdt+5k+fy2/fjGCC75Yhr46ndhYpVihfIy8pw2b/97PsknmQfecWTNx+nzy/Whe3TO3yi2EkUiKI3QyR1WrOZ+HAbmBmcA4ICewDSOAckREFgHDVHW1s/+XmOakAD9g+tkEeB7o6CwfBLqoapKpL+rWraurV7svPeBVto1dJ06nvFOQZLRsG17hlViMzbYB9ctGhrdIiiN0Us3vs78ocINE9m+R4HNiApkKPOm8LBZLOifc+tAsFstVjA1oFoslbLABzWKxhA02oFkslrDBBjSLxRI2hM0oZ3rhzPlY1u084brd6iXzpbxTKshz0P0i4NVQvVfTNtbv9GZKjFf37Miy/7huM3/j4SnvlApmfPi4J3aTwtbQLBZL2GADmsViCRtsQLNYLGGDDWgWiyVssAHNYrGEDTagWSyWsMFO20gjfD4fd3ZoTqFrizDmo6mu2Bx4b3++/WYOUYUKsWatO3ox586e5e5b23H+/DkuXLhAu1u6MHj4/7liu3Oz6uTMlYdMEZmIiMgckjhGHF5cgzgyir+h2hzUown9Ot+ACHw0awVjp/wYv23oXc15aUgHirf9F4eOnaZkkfysnTKcP3aaxKYrN+xgyCtfBnW+GR+PY+70TxERSpWvzKPPv0XWbNmD9huu4hqaiGwXkYKJrO8kIiO9Pv9nH75D6XIVXLXphTJR1mzZ+Gjq18ycv5wZ3y/jx0XzWbtmpWv23VD68ccr1ac4MoK/odisUqYw/TrfQNN+b1O/1xu0b1yFsiXMz6R4oXy0ql+enfuOXHLMtj2HaHD3GzS4+42gg1n0/n3M+vR93v58HuNmLiE21sfib2emyne4igNaUqjqbFV1TygzEfbv28PSBd9xa88+rtr1QplIRMiVy4huXIiJISYmxt289y7jleqTV3jhbyg2K5UqzMoNOzhzLgafL5alv26jc3OTlevVRzrx1NivE9VCCAXfhQucP3cW34ULnDtzhgKOGE9quCoCmojkEpGvHUWnDSLSw9k0WER+EZH1IlLJ2beviIx1lieIyDgRWSoif4hIBzf8GT1qJEOffA7JlDEuv8/no2vrhjSpUZpGzVpR8/p67hj2SKHKMzKav6lg47Z/aFK7DAXy5iRHtizc1KgSxQvn45amVdh78Bjrt+677JhSRQuw7OOhzHvnfhrXKh3U+QoWLsJtfR+kd+va3NmyOjnz5KFO45YpH5gEV0sf2k3AXlW9BUBE8gGvANGqer2IPAgMA+5N5NhSQHOM4MpCESmnqpc82yMiA4ABAEWKlbjMgD9LfviW/NcUpEr12qxatjS0b3WFiIiIYMb8ZRw/dpTB99zBH5s3UqFS6CnDM5pCVUbzNzVs2X6A1z9eyJwx93HqzHl+27qXC75YRvS9kQ5D3rts/3+ij1Oh0wscPn6a2pWK8cWrfbn+jtc4cepcItYv58SxoyxfOJePvltN7jz5ePGxe1jw1VRadeyWKv8zRhUhdNYDrUXkFUdfIO7hvbgG/xpM4EqML1Q1VlW3YlJ4V0q4g79ISv4Cl3XLXcLa1StYPP9b2jeuxsjB/Vj18xKefDixOJr+yJsvkvoNm/Ljwvmu2PNKocorMpq/qWXiV6to1Oct2tz/DkeOn2bHviNcV7QAKyc9wuYZT1CsUD6WfTyUwgXycD7GFy98/OvmPWzbfYjyJVIWCopj7fIlFC5WksgCBcmcJQuNbryFTWtXpdr3qyKgqeofQB1MYHtJRJ5xNsX9jfhIuraasMMgpA6EISOeZd6KzXz70wZeHvMR9Ro148W33g/FpKccPnSQ48eOAnD2zBmWLV3oymCGlwpVXpDR/A2FqPy5AChROJLOLarz6TdruK79KCp1fYlKXV9iz4FjNOz9JvsPn6BgZC4yZTJ9qqWKFqBciYL8vTdwEeqoIsXY/Nsazp45jaqydsVSSpRJffm6KpqcIlIUOKyqk0TkJNA3iMO7ichEoDRQBtjigYuu4IUy0cH9+3ni4QH4Yn3ExsZyU8dbadkmcFHapHBT6ccfr1SfMpK/odqc/HJvCuTLRcwFH0NHz+DoiTNJ7tukdhmeHtCWC75YfL5YBr8ynSPHk94/IZVq1KFJmw4M7t6aiIjMlK1Ujfbd7g74+ISEjepTcohIO2A0EAvEAA8A04C6qhotInWB11S1hYj0ddY/JCITgCNAXaAw8KiqzknuXFVrXK+fzUlUKS8kKhbN47pNgO0HQ1LkS5QTZy64bhO8S8eT0dIHeUFGSx/Uvlqh8FZ9Sg5V/Q6jselPKb/tq4EWzvIEYILffj+p6iOeOmixWFzhquhDs1gsVwdXRQ0ttahq37T2wWKxBI6toVkslrDBBjSLxRI22IBmsVjCBtuH5jLZs2TyZIrFlr3uK0kB1Czpvq9eqF4BRJ8I7HGaYDl53ptpJl6x7M/AJ64Gyq8zn3XdJkDtzs+kvJOL2BqaxWIJG2xAs1gsYYMNaBaLJWywAc1isYQNNqBZLJawwQY0i8USNtiAlgYMvLc/JYsWok6taq7b9vl89GjfhMH9UpfxMzHmzp1LxYoVKVeuHC+/7K7cgtv+7t29i+6d2tLyhprc2LA2H4wb64rdnX9v5b6uLeJfHeqWYtrEcSHb9aIseOXrubNn6X5zc7q0bkCHFnUZM/r5oI4f1KMpqycPY82U4TzUsykANcoXZfEHQ1g+6VF+nDiUulUuZnwe1qcVG6Y/wbqpI2jdoGJA5wi7gCYikU5KbTdstRCRZNMFpQYvlYncVpPy+XwMGjSIb7/9lk2bNjF58mQ2bdrkmn23/Y3InJmn//0KC1esY9a8JUz8YBx/bP49ZLslS5fnvRmLeG/GIsZN+4FsOXLSpPUtIdv1oix45WsoCmBVylxLvy430LTvW9S/63XaNzFqUi8M7sAL78+jQa//8O935/LCYCPbUal0Ybq1rc31PV+l08Pv8dbjt8YnkkyOsAtoQCRwWUATkYgr70rieKVM5IWa1MqVKylXrhxlypQha9as9OzZk1mzZrli2wt/C19bhOo1awOQO08eylWoxD/79rhmH+CX5UsoWqIU16agHxEIXqtUuelrKApglUoXYuWGnRfVpH75i84tqqNA3lxGgzNf7hzsiz4OQIdmVZk671fOx/jYsfcwf+0+RL2qJVM8TzgGtJeBsiKyVkRWichCEfkMWC8ipUQkXnlVRIaJyLPOcjkRme8oQ/0iImX9jYpIPRH5VUTKXNFvEwReqEnt2bOHEiUu/hiKFy/Onj3uBAiv1a927dzOxt/WUrtOfVftLvxmBq1uudVVm17htq+pVQDb+JejJpXPUZNqXJnihSMZ/p+ZvDikA1u/epqXhnTkmf9+A0CxqHzs3n80/vg9B45SNCrlhJnhGNBGAn+pai1gOFAfeEpVq6Rw3KfAf1W1JtAIiNfrEpFGwDigs6puS3igiAwQkdUisvpg9EGXvkZw+KtJuUliGY3d0OX0yt84Tp08ycA+d/Dsi6+RJ29e1+zGnD/Pzwvm0rxdJ9dseoUXvsYpgC1cs4X1a1fzx+aNAR1n1KQWMGfMQGa/fZ+jJuVjwG2NePyNWZTv+G8ef3MW7/xfd3NAImUskOza4RjQErJSVf9ObgcRyQMUU9UZAKp6VlVPO5srA+OBjqq6M7Hj/VWfogoGrnjjJl6pSRUvXpxdu3bFf969ezdFixYN2a6X6lcxMTEM6NOTLrf3pH3HLq7YjGPl0vmUr1KDAgULuWrXC7z0NTUKYBNnr6RR7zdoM/B/HDl2mj93RnPXLXWZuXA9ANPnr6NuFdOs3HPgKMULR8YfW6xQZHxzNDmuhoDmnzT/Apd+5+zOe3JVjn3AWcCbqoRLeKUmVa9ePbZu3crff//N+fPnmTJlCp06hf6P75W/qsrwIQMpX6ESAwY9HLK9hCz4+ssM09x029dQFcCi8pv+txKFI+ncsgZfzPuVfQeP0/R607vTol55/txlWjhfL91It7a1yZolguscNalVGxOtT1xCOGbbOAEklUJiP1BIRK4BTgIdgLmqelxEdotIF1WdKSLZgLhBhKPAPcA8ETmlqotCddArZSIvyJw5M2PHjqVdu3b4fD769+9P1aqhiwx7xaoVPzP988+oVKUa7ZqZvrMRTz9HqzY3hWz77JnTrPl5MY+M+k/ItuLwqix44WuoCmCTX+lDgbw5ifHFMnT0lxw9cYZBL05l9KOdyZw5gnPnYnjopWkA/L5tP9Pnr+XXzx/ngi+Woa9+SWxsyk3OsFR9cgYBagBngP2q2sFv2xBgCPA3sAfYrqrPikh54F2gIEYZqhtQEhimqh1EpCTwLdBfVVckde46derqTytWu/6dbPoguCZPVk/sbt1/0hO7Dctd44ldL9IHFcmXPeWdUoFX6YPOrvrP1aP6pKp3JrPtbeDtRNZvBVolWL0NWORs3wmk36qJxWK5KvrQLBbLVYINaBaLJWywAc1isYQNNqBZLJawwQY0i8USNoTltI20REQOAjsC3L0gEO2BGxnJbkbyNaPZzUi+Bmv3OlW97LEcG9DSEBFZndhcmqvJbkbyNaPZzUi+umXXNjktFkvYYAOaxWIJG2xAS1vGW7sZyteMZjcj+eqKXduHZrFYwgZbQ7NYLGGDDWgWiyVssAHNkiIikmHKibiRH9ySYckwBdUSHG79sEWkEvAvEcnthj0/uxF+y64kZRMRUadTWEQ8yzDsdtC8WoNwwu/txh+nDWhhQsLCoS6M9jgFrDgQBTwiIjlDtenYjQBaO7qnQ4A+IhJybj6/YHY3MEpEUpYJCgIRKR13HjeCkJ+NzM7nkKUW/f1ys2YdZ1dE8olIfpfMxv9Jikhf4PFQDdqAdoXxKxgVHGm8bG7Y9Psx3yUiT4vIbQml+IK0mUlVY1V1PrAWqAY85FJQEyAvMBqTPfgbVb3gxg9QRBoAXYChqnos1CDhd7/KA9+IyFMQelCLu2ciUh/4XUQKq6ovFH8TlIPewEgRuUNEQhb+dHztBMwDvnPKWKrtish1wGQRidPBy4JJqBoSNqBdYfwKxlTgfkzhqBOqTYhPL34fJr34/wGtQ7AZ69gcigkQCjQDHheRXCH6ewFYCZwHfgYqiUiOuHMGQ4IaSTagBVAeuNX5gftCCTzO/eoAPOv43F0cLddQgppz7I1Ae8y1XSQi1zr+pup36VcO7gMGOv6+D3RMjT1/RKQipmwNBPoC9UhE0DsIzgBLgSdFpAbmGoTe9aCq9nUFX0BpYC6QH+gKrAcKpNJWGb/lfMAYTO1nAPAdRuglK5AzCJvit1wY+AHI5XxuC/wPo3casM1EzlHYec8G3OHYvMNZVwW4NhW+lgQineX7gTcxOqqX7Rukr5HAKqAJpgJQA/gJeCLEclAR2A40xDTpRwM7/a5NplTYzAQUwExQLQ7cDXwPRKTmHmEClzi2ZmJqZzmd7aWArUCPYH30Wy4IDAVmAJ8716AuJljeHHctgnnZGtqV5xjmB/EAps+gs6oeFpFWwfQjiUgOTBPoWWfVcUzh+8mx2U5VfZhCXStAm5k07tcv0g5TkItgfswACxz/e2Kan0HXTkTkIWCSiIwGuqvqZGA10EhEpgCTMf/WKeLn61DgA2CKiLwJfAbsApqKSHf/fVOBD5MBYruaGuRGx/49IhKKTt4pYIGqLgOiVXU4sA5YKCJRqhobyPX130dNF8Fh4E/gPeAuoK2aWt/jItIyCP/KYWrPBVR1N/Cls76diBRQ1e2Y2l+OQA06Nea4mv8dQDHgC2AhUAcjTNQOGIH5bQSvihPKv4x9BfSPFPc0RjbnBmUFPgJ+Bao425phfiiVA7RZ3HmvgPkR/J/zuQtG1OU253Mvx26ZIH1uCMzHBMh+mBpUIz+brwCFUnEt+mICbimnIK8DHne2NQKeBKoGabMLpuaQCXgNWOisz+vYewnIHei98rtfRYFszvK/gOVADudze+cazI67h0GUg6zOex7n+/f326cHpkb8LZA9yOswGHjZWX4Q09xs4Hy+3TlXhSBt5gHG4dRGMXKOE53r3Bn4C7gxFeXgfmBDXLnE1FAHArOCLauX2Q7lYPsK+AZ2wlTZ38UoR9VwCu2Lzo9lI9AhADuCqaa/B+R31pUBNmGagXmcgr3AKRxrAwkQmMCYz1nuCBzgYlCshum43+Kc989gfxiOnbrAbZim9kOYZndzJ1CkuvmG6TNrB4x0AlsWP7+zkIrmPHATsAz4GPgUuA54Bvjduc5/Ao2d61EtCLvtMM2rcZim9nUYrdinMN0ES4GmwFiC6yZ4FPNHUc2vnDwLTHCu889A9QDLl38zPjOm6fc/zCALmFrfT5gmfWtnXUDNY8d+MWBJXBni0j+QJzE19ByB2rzsHKktSPYVcGGriKk19fALDJUxfWn9MFXrpv43NwCb2Z2C/6DzuazzY3vY+VzAOUdUAAUsG/AWToB01q8Alvl9jsAox98MlE7FNXjA+SGXw/wbzwQKOtu+BL6K+5ySv4n43wLYDcz2W38vMB2n7y8Au4WAO4Gczg/uD+f6VnDuz0+YP4uemCZ8VUwt9hegZIDnaID54+mK6Yvc7lyXYpha5P+A6piBnJUkE4gTBJ1rnGMLYf7c+mMCcVVMd0EVAqhN49RGneWWzvds6ff5XWCI87kvJpjfEug1do7LBOQCvsGpNXOxxlrU+S6p6k+OP0coB9tXijewhvNjfdZv3T3AZqBxkLYyJfjcAVOL6O98Lgv8BrwYhM0I5z0LUB9TM4ir4awGZrlwDTo5fl3nfC6CqUE2cn40kwIJZglsPgS87vyorsHUmjZhakBPOOcLuOmKqXV8APR2gso7/tcc+C9wl9/+9TA1y5oBXt/8TkB7xW9bFKbZVdNvXRNMR3uStb4Ewaw3pvk2C9P5PxvT//Q58GEQ3z8/phZX2QmEOzDatTO52NxsgWluPuZ8fhIzCBVoc74JF/+APwOm+W3ri/ljC6qZneh5QjVgX8nexNyYKvQcTAd7XPX6fsyIVgGCHIFyfkwlMLWT64HFwL3OtgpOkAs2QBTFBMTFzg8iLqgtwXRch3IN7geedJbj7D7mXJefUwoKfv7Fja4NwvTvlcH0C73hZ/N5TG2lUir8fBR4BzPqthfo57ftubgfsvP5OpIZicX0EZZylm90As19wIoE+73Jxb7JCOd+BtSHhGnCT/X73JmLI6RtMTXigIKNc8xTmD+CV4FWzrrrMcFypN93qeF3TP5k7MWV9UzOdxuAqeX1wNSEpzrlazSwxt9uSOXNDSP2ddlNrAbUdG5kNkwtZAxQzG/f4gHarMPFGkNfzL/6TOATTA2wFqYjeZCzT5YAbDYCejrLg5zA8LoTZFZgmllxwWdeoL4mca72mP7Cin7rOjjfJUcAxxdzrt1ATE1yGKZ28xjwNab5HeHnb2qmO7TFTHNZiqk9vIkZJX0SuBXTF9kiQFulMDXwakAl4MO4H6vf9a2KaVpuAOoHW8acsrUO07+XO8H2h51tKfaZOftndt4j/b53XK0/s1O+vgee9jsm4D9hnCY5Joj1wdT87nTWdcUM6pRz7TfolqGr/cXFYNYJ84/zEeYf6Xoujmx+EGxwwNTsfsSMCn7oFLzSmD6f2Zj5Qm0xTdt8Adq8BTP5dhSmGVHGsTEYU/tZALyRmuCQyLnyYmpOLzqBrBdmXldAhdj5AffFBNz+mD+HxcAUvx/jQ5j+qEwE2A/pZ7+Qc30rO58HYWpkozDB7XkCGLDx8/V2TJ9kTeAoZgDBv7b3llMOfgBuCaZsJVh3N6ZvrykXm8YRwL8JcLTcz1YXTH9gUcwI6SacJjsXa451gvXVsbcDaO98zsXFOZK94+6fmy9XjV2NL+cmxXVw1sZUowtiBgC2YiY51sfU1D4jyGkJjt1imKr/Zr91hTB9O13j/AjSZhtMDeFT53M2TB/K65haySRSMTUjiXMVwTQ9v8HUUgJqXnDxT6I3ptk+1wk00Vzsj+nr/ADLp9K3/JhmejPncxZM39w8TDNR/H0JwF4k8A/mD6Mrpkb5GtDcb58sQJ5g7Dr73oUZvXwQ80dxB6b21IQAauZJ2KyFqYFW8lv3KSbIB9UMTBDMHsWMat+FmaLU1m/bAqecRbpRvvxfdmJtCDgPP78MdHAmup7E9MHUwlSve2ECxYvADZiO5Y0B2M3kt5xVVfdgCvFxEXkPQFUPcLH5AXA6GN9V9XtMv8nNItJDVc+p6u+YkcijqtrLOUfIqOo+VR2HqQn0UdXfAjxOReQuTM3xSUxtx4cZxRsqIu9ggs7tqro1lb4dwfTntBCRaqoag+lUPwQsUecXGPceAMcxP+DMmBrjZMxjPu1EpJVjK0ZVTwRjV0QGYa7DEczI+XfOK25eWGrVks5hAlpzEXlGRBYAsZjA/IUEkQkl7ruISBvMIMgqVf0U00/2HxG5xXmM7DjwmqoeTaXPyTphXyG8MH0WH2D+jbM7657gYj/BA5j+rqCaAc6x/TEjj89hRt9KYGoOizG1lsWkogM8wTk6YB4KHoVpiv4KlE3r6+rn33PAcGc5K+YP4wtMH1pBAmxmp3CO4pim2nfAC5h5gS1CtHkdTnMTuBbT2T6aZDrSExwf14yMqyGOw6+/DRPg33eWBxHg9JFEzpMb02T/CVMzr4b582wVqE1MayGuidoXU2P+KsE+t2NqwgtwaQAgUV/SusBm1BeXPpM20Alat2KaE/0wjwj1x/z7NUqF/bswTcI2mP63VzEd7MWcH9x8QuisT3CuLpiazxSc0bn08nJ8m4lfUx0zOvoikNfF8+TB9CM+il/zMESbtTHzAwdgmt2pmZBcwSlTc3CeqnDW1yCIqRkBnCduPlhdJyC1CuLY8pg/2omYx5juxvQjD0mwXz6C7BoJ+nt4aTxcX37/msX91nXD9D3E9WndixkUuDlY25iO2Fdw5j5h+nke5eJoZ1GgqMvfqTnOXLH09MI0fV7AdM63wtQiZxPgA+xp/cKMUv8d6J8Pl45AD8bU8kY712A3F0cg78LUdiIJciAkifNGOL6uwO+h/iCOfw3TlHzA+dze+SMafCWvd8hJ9a5GVFVF5CbgNRH5BYjBFL4LQFcRyYIZkZygJs9XfJ6qxPDf7rz7RGQn0FlElqjqLqfv7GsRKamqOz34TovdtukGqnpURP6Lqf3+H+YaP6aq/6StZ4GhqmtEpIY6fWYBkB94SUym4OKYycJtMYMA84HnxWTjbYnJdHHUJT99IrIZE0z/TqnMJsI4zHSRR0XksKp+LiIHgP+JSLSaJASeYwNaKnDyl7XH9F0cwPQbzMT0R12DmeS4WFX3Q8odv3HbReQ2TBPjU0wVvhgmm+s0TGe9AIH+MMIGVd0LjBWRjzC1kZNp7VOQBOyvqn4tIueB/wDLVfUvEfkQM2IIZgR1PObpk0NuOqmqpzC1yRTLbCLH/gn8KSJHgRec9+yYnHfL3fQzOawuZ4D4ZRjNj8kysFFVmzoZRhUz1P+tqk4LtBaVIMNoL8yE1p8xVf+hmA7bBpim1jlMH8pa97+dJb0hIp0xZWqIqk5xRr77Yv7YXnWrZuYFTutlNCZF0j0awMi+a+e2AS1l/IJZe8yIzl+YOVEPq+oHzj6vAvtV9fVgbDrL12KaEKtU9U8nv1cbzLN/S5wg6lPV465/OUu6RURuwTy4/qJfUMsVRPM1zRCRQpiK3sEreV7b5AwAJ5jVx4y4TVHVH51/oR9EpBpmln4bzHOQKZIgmD0EPAKcxXTI9lfVN0XEB4wWkeGqusT9b2VJ7zjNz1hgvIhcUNVpZJAuB3VpDmOw2BpaEohIGczQ9ftOrvovMMn8yvvt0wgzU3sBMEBV94lIhJpMsYGcowlmAu5LmDlmA4A/VfVfzvaBmGas64MAloyDM1H1L1UNWUQk3LEBLQlEpBgmyGxT1QMiUhLz+NFyVX3Ab7+6mIekR6rqR4GMDjlNhzKYjAi/YybJxmL6zgYB+9SkZLZYLEFgH31KBKeWtQfzEPUiEXnZqSV1BMqKyFtx+6rqaqA7Row3MhmbCXO//4mZ7V4EMywfg2lyjgfyi0hB97+ZxRLe2BpaAvwGAMpiZvvnxEzJmK6qL4hIccyzfutU9UERyezMNcuuqmcDsN8HM4P8ABfTO/8bk91iFmZqRtZAbFkslkuxgwIJcIJZR8zM9O2YEc0ngTdExKeqL4tIT0zNCjUak2CmVSSLiNyPeRzqHUxz9ivMEwajMNkHYlT1a8wAgcViCRIb0BIgRnn7GcyoZRtME/AMZiRyvFMjex6TCC+exPrNEhkguA4YoaoLne27gOdVtZuIvIB5dtNisaQS24d2Obsx2QZqYTJp1MRMbr3b+bw0ECPO3LEqzvLNIlIUU6u7y2+3hcA5p7k6TVV3uPUlLJarERvQEqCqu1V1FeZh7U+dzvsJmBxUa1R1sX8HfzIUB3qJyMfAm87jO0OBWiLymrNPQ0ytLZfLX8NiuSqxTc6kWQ8MFKNm3hGTNWAnJP+cW9yggqqud55nG4LRjIx70LoTMFNEPsHklr/b7WfyLJarFTvKmQQikheTtLET8IGqfhPk8U0wz3gWxuhZLgHmOnPaIjH5xzKryZhqsVhcwAa0FPCblhFwOhURicJkrc2O6XdrjUnHPROjBFQQkwLnQlI2LBZL8NiAlgKpyAsVd1w9TA6vnJjg1hwT2BpgBD7WueqoxWKxAc1NRKQfRp7tKefz9ZhRzQvAC6p6XERyZ8B8XhZLhsCOcoZAIqOdizADCU8AqOovmPz/bYCnnHlpNphZLB5hRzlTSSIpgKphRkZvAeaISKyqvoJJ97IQeCPQLBwWiyV12CZniIjIg0APTNPyN4wwykqM/NwioDHQTlW3pJWPFsvVgq2hhYAzteN6oCfmmcxVmImyhTApgU5jHnXanWZOWixXEbaGFiJO8sdKmKcBWjq5zg5hsme8rKrn09RBi+UqwtbQQkRVz4nIaSCziMSpm3+NkbCzwcxiuYLYGpoLOLW0oZh5ZoWB7qq6OU2dsliuQmxAcwkx4sLXArFOtluLxXKFsQHNYrGEDXZircViCRtsQLNYLGGDDWgWiyVssAHNYrGEDTagWTI0ItJCROY4y51EZGQy+0Y6j6oFe45nRWRYoOsT7DNBRG4P4lylRMSK5aQSG9As6RIRiQj2GFWdraovJ7NLJEYAxxKm2IBmuaI4NZDNIjJRRH4TkWkiktPZtl1EnhGRH4FuItJWRJaJyC8iMlVEcjv73eTY+BGTRDPOdl8RGessFxaRGSKyznk1Al7GKN+vFZHRzn7DRWSV48soP1tPicgWEZmPEchJ6Xvd59hZJyLT476TQ2sRWSoif4hIB2f/CBEZ7XfugaFeW4sNaJa0oSIwXlVrAMe5tNZ0VlWbAPOB/wNaq+r1wGrgURHJDryHEa5pipnMnBhvA4tVtSYmgcBGjFjNX6paS1WHi0hboDxQHyNbWEdEmolIHUzCgdqYgFkvgO/0parWc873O3CP37ZSmIzFtwDjnO9wD3BMVes59u8TkdIBnMeSDPZZTktasEtVf3KWJ2GUseKk/T533htgdE1/cvJoZgWWYRIB/K2qWwFEZBIwIJFztMJkPMHJQ3fM0Ur1p63z+tX5nBsT4PIAM1T1tHOO2QF8p2oi8jymWZsb+M5v2xeqGgtsFZFtzndoC9Tw61/L55z7jwDOZUkCG9AsaUHCx1P8P59y3gX4XlXv8N9RRGolcnxqEeAlVX03wTmGpuIcE4AuqrpORPoCLfy2JfZ9BSON6B/4EJFSQZ7X4odtclrSgpIi0tBZvgP4MZF9lgONRaQcgIjkFJEKwGagtIiU9Ts+MX4AHnCOjXBy153A1L7i+A7o79c3V0xECmEkB7uKSA4RyYNp3qZEHmCf80zvXQm2dRORTI7PZYAtzrkfcPZHRCqIiBWcDhEb0Cxpwe9AHxH5DSgAvJNwB1U9CPQFJjv7LQcqqepZTBPza2dQYEcS53gYaCki64E1QFVH0PknEdkgIqNVdR7wGbDM2W8akMfRgvgcWAtMB5YG8J2eBlYA32OCrj9bgMXAt8D9znd4H9gE/OJM03gX22IKGftwuuWK4jSp5qhqtbT2xRJ+2BqaxWIJG2wNzWKxhA22hmaxWMIGG9AsFkvYYAOaxWIJG2xAs1gsYYMNaBaLJWywAc1isYQN/w8ElfTMlxldiAAAAABJRU5ErkJggg==\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": "33c85f41",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "matplotlib       : 3.3.4\n",
      "pandas           : 1.4.1\n",
      "torchvision      : 0.11.2\n",
      "pytorch_lightning: 1.5.1\n",
      "torch            : 1.10.1\n",
      "sys              : 3.8.12 | packaged by conda-forge | (default, Oct 12 2021, 21:59:51) \n",
      "[GCC 9.4.0]\n",
      "torchmetrics     : 0.6.2\n",
      "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
}