/pytorch-lightning_ipynb/cnn/cnn-basic.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7b5069a4",
   "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": "a90edc5e",
   "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": "9bb561b4",
   "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": "afe0859f",
   "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": "6922cf97",
   "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": "22553016",
   "metadata": {},
   "source": [
    "A basic convolutional neural network [1][2] trained on MNIST [3].\n",
    "\n",
    "### References\n",
    "\n",
    "- [1] L13.3 Convolutional Neural Network Basics (18:39), https://www.youtube.com/watch?v=7fWOE-z8YgY\n",
    "- [2] https://en.wikipedia.org/wiki/Convolutional_neural_network\n",
    "- [3] https://en.wikipedia.org/wiki/MNIST_database"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08f12215",
   "metadata": {},
   "source": [
    "## General settings and hyperparameters"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf50a41d",
   "metadata": {},
   "source": [
    "- Here, we specify some general hyperparameter values and general settings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b0f854be",
   "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": "1bf293bf",
   "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": "e886498f",
   "metadata": {},
   "source": [
    "## Implementing a Neural Network using PyTorch Lightning's `LightningModule`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "953236fd",
   "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": "7a665100",
   "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    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    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",
    "    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": "30fabde0",
   "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": "435bdf05",
   "metadata": {},
   "source": [
    "## Setting up the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29ce94a3",
   "metadata": {},
   "source": [
    "- In this section, we are going to set up our dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c39fcfe6",
   "metadata": {},
   "source": [
    "### Inspecting the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5d3e1550",
   "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": "94e5e0e0",
   "metadata": {},
   "source": [
    "### Performance baseline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afb31c43",
   "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": "a23a3921",
   "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": "245698f5",
   "metadata": {},
   "source": [
    "## A quick visual check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "5f203ee3",
   "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": "90e63953",
   "metadata": {},
   "source": [
    "### Setting up a `DataModule`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db1d531a",
   "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": "21236184",
   "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": "3a1d4954",
   "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": "6889a957",
   "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": "208c778d",
   "metadata": {},
   "source": [
    "## Training the model using the PyTorch Lightning Trainer class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a76c4ad",
   "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": "8a8fd5f4",
   "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": "ba023a1a",
   "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": "b901329e",
   "metadata": {},
   "source": [
    "- Now it's time to train our model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c40f0f01",
   "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": "45ffdf2494454a8a8d9e608a1458e898",
       "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": "4dd40caf626d4fabb6d7e68397225a6b",
       "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.80 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": "257228ac",
   "metadata": {},
   "source": [
    "## Evaluating the model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aefdd623",
   "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": "eba43087",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEGCAYAAABy53LJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABEy0lEQVR4nO3dd3hUZfrw8e+d3gstpAChIyiG3jWIImDBgooFQUUWlVXXxRW3vGLZ36rr2lYEG7ZV0FVRVBZUJCJSpCNVOoTQa3p93j/OBIcwSWYyM5kJuT/XNVfmnPOcc+6ZJHPPec5TxBiDUkop5awAXweglFKqbtHEoZRSyiWaOJRSSrlEE4dSSimXaOJQSinlkiBfB1AbGjVqZFJTU2u0b25uLpGRkZ4NyIM0PvdofO7R+NznzzGuXLnyiDGm8VkbjDHn/KNbt26mphYsWFDjfWuDxucejc89Gp/7/DlGYIVx8JmqVVVKKaVcoolDKaWUSzRxKKWUckm9uDmulDq3FBcXk5mZSUFBQZXlYmNj2bRpUy1FVTP+EGNYWBgpKSkEBwc7VV4Th1KqzsnMzCQ6OprU1FREpNJy2dnZREdH12JkrvN1jMYYjh49SmZmJi1btnRqH62qUkrVOQUFBTRs2LDKpKGcIyI0bNiw2qs3e5o4lFJ1kiYNz3H1vdTEUYXvNx/kqx1Fvg5DKaX8iiaOKizaepQvtxdjdM4SpZQ6TRNHFZLjwykshZP5xb4ORSnlR06cOMGrr77q8n7Dhg3jxIkTLu83ZswYPvnkE5f38xZNHFVIjgsDIPN4vo8jUUr5k8oSR2lpaZX7zZkzh7i4OC9FVXu0OW4VkuLCAcg6kc/5ybE+jkYp5cjjX25gY9Yph9tKS0sJDAx0+Zgdk2J47KpOlW6fNGkS27dvJy0tjeDgYKKiokhMTGTNmjVs3LiRa665hr1791JQUMADDzzAuHHjAEhNTWXFihXk5OQwdOhQ+vfvz6JFi2jWrBlffPEF4eHh1cY2f/58Jk6cSElJCT169GDq1KmEhoYyadIkZs+eTVBQEIMHD+a5557jv//9L48//jiBgYHExsaycOFCl98LRzRxVCHZljj2ndArDqXUb55++mnWr1/PmjVryMjI4IorrmD9+vWn+0FMnz6dBg0akJ+fT48ePbj++utp2LDhGcfYunUrM2bM4Pnnn+euu+7i008/5bbbbqvyvAUFBYwZM4b58+fTrl07br/9dqZOncrtt9/OrFmz2Lx5MyJyujrsiSeeYN68eSQnJ9eoiqwymjiq0CAyhJAA64pDKeWfqroyqK3OdT179jyj89zLL7/MrFmzANi7dy9bt249K3G0bNmStLQ0srOz6datG7t27ar2PFu2bKFly5a0a9cOgNGjRzNlyhQmTJhAWFgYY8eO5YorruDKK68EoF+/fowZM4Ybb7yR6667zkOvVu9xVElEaBAuZJ1wvmOMUqr+sZ9PIyMjg++++44lS5awdu1aunTp4rBzXWho6OnngYGBlJSUVHueylp4BgUF8fPPP3P99dfz+eefM2TIEACmTZvGU089xd69e0lLS+Po0aOuvjTH5/PIUc5hDcOETL3iUErZiY6OJjs72+G2kydPEh8fT0REBJs3b2bp0qUeO2+HDh3YtWsX27Zto02bNrz//vtcfPHF5OTkkJeXx7Bhw+jduzdt2rQBYPv27fTq1YtevXrx5Zdfsnfv3rOufGpCE0c1GoYHsEkTh1LKTsOGDenXrx/nn38+4eHhJCQknN42ZMgQpk2bRufOnWnfvj29e/f22HnDwsJ4++23ueGGG07fHB8/fjzHjh1j+PDhFBQUYIzhhRdeAODhhx9m69atGGMYNGgQF154oUfi0MRRjYZhwuHMQgqKSwkLdr11hlLq3PThhx86XB8aGsr//vc/h9vK72M0atSI9evXn14/ceLEKs/1zjvvnH4+aNAgVq9efcb2xMREfv7557P2++yzz6o8bk159R6HiAwRkS0isk1EJjnYfquIrLM9FovIhdXtKyINRORbEdlq+xnvzdfQMNwaw+XASb3PoZRS4MXEISKBwBRgKNARuFlEOlYothO42BjTGXgSeN2JfScB840xbYH5tmWvaRhmvUXaJFcp5W333XcfaWlpZzzefvttX4d1Fm9WVfUEthljdgCIyExgOLCxvIAxZrFd+aVAihP7DgfSbeXeBTKAR7z1IsqvODRxKKW8bcqUKb4OwSneTBzJwF675UygVxXl7wLKKwar2jfBGLMfwBizX0SaODqYiIwDxgEkJCSQkZHhavwAhJTkIQg/rd5Ek5ztNTqGN+Xk5NT4tdUGjc89Gp9jsbGxlbZqsldaWupUOV/ylxgLCgqc/l16M3E4GuDdYSNkERmIlTj6u7pvZYwxr2Or+urevbtJT093ZffTMjIyaBJTQkhcY9LTPdMiwZMyMjKo6WurDRqfezQ+xzZt2uRUxz5fz67nDH+JMSwsjC5dujhV1ps3xzOBZnbLKUBWxUIi0hl4ExhujDnqxL4HRSTRtm8icMjDcZ8lKS6crJNaVaWUUuDdxLEcaCsiLUUkBBgJzLYvICLNgc+AUcaYX53cdzYw2vZ8NPCFF18DYI1ZtU9HyFVKKcCLicMYUwJMAOYBm4CPjTEbRGS8iIy3Fft/QEPgVRFZIyIrqtrXts/TwGUishW4zLbsVclx4WSdLKCsTCd0UkrVTFRUFABZWVmMGDHCYZn09HRWrFhR6TFSU1M5cuSIV+JzhVc7ABpj5gBzKqybZvd8LDDW2X1t648CgzwbadWS48MpKinjSG4hTaLDavPUSqlzTFJSkl9NylQT2nPcCUmx5fNyFGjiUMrf/G8SHPjF4abw0hIIrMHHXNMLYGjVlRmPPPIILVq04N577wVg8uTJiAgLFy7k+PHjFBcX89RTTzF8+PAz9tu1axdXXnkl69evJz8/nzFjxrB161bOO+888vOdrxJ//vnnmT59OgBjx47lwQcfJDc3lxtvvJHMzExKS0v529/+xk033eRwrg53aOJwQnK8bV6O4/mkNYvzbTBKKb8wcuRIHnzwwdOJ4+OPP2bu3Ln84Q9/ICYmhiNHjtC7d2+uvvpqRBw1FIWpU6cSERHBunXrWLduHV27dnXq3CtXruTtt99m2bJlGGPo1asXF198MTt27CApKYmvv/4asAZcPHbsmMO5OtyhicMJ9jMBKqX8TBVXBvlebOrapUsXDh06RFZWFocPHyY+Pp7ExET+8Ic/sHDhQgICAti3bx8HDx6kadOmDo+xcOFCxo61aus7d+5M586dnTr3okWLuPbaa08P537dddfx448/MmTIECZOnMgjjzzClVdeyYABAygpKXE4V4c7dD4OJ8SEBREVGqS9x5VSZxgxYgSffPIJH330ESNHjuSDDz7g8OHDrFy5kjVr1pCQkOBwLg57lV2NVKWyeTnatWvHypUrueCCC3j00Ud54oknKp2rwx2aOJwgIlaTXE0cSik7I0eOZObMmXzyySeMGDGCkydP0qRJE4KDg1mwYAG7d++ucv+LLrqIjz/+GID169ezbt06p8570UUX8fnnn5OXl0dubi6zZs1iwIABZGVlERERwW233cbEiRNZtWoVOTk5nDx5kmHDhvHiiy+yZs0ad1+2VlU5KykuTKuqlFJn6NSpE9nZ2SQnJ5OYmMitt97KVVddRffu3UlLS6NDhw5V7n/PPfdw22230blzZ9LS0ujZs6dT5+3atStjxow5XX7s2LF06dKFefPm8fDDDxMQEEBwcDBTp04lOzvb4Vwd7tDE4aTk+HBW7z3h6zCUUn7ml19+a9HVqFEjlixZ4rBcTk4OYPXFKJ+LIzw8nHfeecfp+zD285I/9NBDPPTQQ2dsv/zyy7n88svP2s/RXB3u0KoqJyXFhXMir5jcwurnBVZKqXOZXnE4KdmuZVXbBN8PSKaUOnf16tWLwsLCM9a9//77XHDBBT6K6EyaOJxUnjj2aeJQyi8YY2rUIqkuWLZsWa2er7JWWpXRqion/daXQ6eQVcrXwsLCOHr0qMsfeOpsxhiOHj1KWJjzo2LoFYeTEmLCCAwQ9p3I83UoStV7KSkpZGZmcvjw4SrLFRQUuPSB6Av+EGNYWBgpKSnVF7TRxOGkwAChaUyYXnEo5QeCg4Np2bJlteUyMjKcnpzIV+pCjBVpVZULkuN1Xg6llNLE4QLtPa6UUpo4XJIcF86BUwWUlJb5OhSllPIZryYOERkiIltEZJuITHKwvYOILBGRQhGZaLe+vW1GwPLHKRF50LZtsojss9s2zJuvwV5SXDilZYZD2YXVF1ZKqXOU126Oi0ggMAVretdMYLmIzDbGbLQrdgy4H7jGfl9jzBYgze44+4BZdkVeMMa4NxNJDSTFWS0fsk7kn26eq5RS9Y03rzh6AtuMMTuMMUXATOCMqbCMMYeMMcuB4iqOMwjYboypepjJWpAS/1snQKWUqq+8mTiSgb12y5m2da4aCcyosG6CiKwTkekiEl/TAF2VFKeJQymlxFs9L0XkBuByY8xY2/IooKcx5vcOyk4GcipWP4lICJAFdDLGHLStSwCOAAZ4Ekg0xtzp4JjjgHEACQkJ3WbOnFmj15GTk0NUVNTp5Qnzc+nRNIjRnUJrdDxPqxifv9H43KPxucff4wP/jnHgwIErjTHdK673ZgfATKCZ3XIKVhJwxVBgVXnSALB/LiJvAF852tEY8zrwOkD37t1Nenq6i6e2ZGRkYL9vi3U/QkQo6enOjZvvbRXj8zcan3s0Pvf4e3xQN2KsyJtVVcuBtiLS0nblMBKY7eIxbqZCNZWIJNotXgusdytKF2lfDqVUfee1Kw5jTImITADmAYHAdGPMBhEZb9s+TUSaAiuAGKDM1uS2ozHmlIhEYLXI+l2FQz8rImlYVVW7HGz3qqS4cH7aduScHplTKaWq4tWxqowxc4A5FdZNs3t+AKsKy9G+eUBDB+tHeThMlyTHhZNbVMqpghJiw4N9GYpSSvmE9hx3UXJ5k1wds0opVU9p4nBRkt1MgEopVR9p4nBRsvblUErVc5o4XNQwMoSQoAC94lBK1VuaOFwUECAkx4WTqYlDKVVPaeKogaS4ML3iUErVW5o4aiApVmcCVErVX5o4aiA5PpxD2YUUlpT6OhSllKp1mjhqoLxJ7sGTOqGTUqr+0cRRAym2xJF5Is/HkSilVO3TxFEDv3UCLPBxJEopVfs0cdRAom0KWb1BrpSqjzRx1EBoUCCNo0O1Sa5Sql7SxFFDSTovh1KqntLEUUMpceF6xaGUqpc0cdRQUlwY+07k460525VSyl9p4qih5LhwCkvKOJpb5OtQlFKqVnk1cYjIEBHZIiLbRGSSg+0dRGSJiBSKyMQK23aJyC8iskZEVtitbyAi34rIVtvPeG++hsrovBxKqfrKa4lDRAKBKcBQoCNws4h0rFDsGHA/8FwlhxlojEkzxnS3WzcJmG+MaQvMty3XOp0JUClVX3nziqMnsM0Ys8MYUwTMBIbbFzDGHDLGLAeKXTjucOBd2/N3gWs8EKvLdEInpVR9Jd66uSsiI4AhxpixtuVRQC9jzAQHZScDOcaY5+zW7QSOAwZ4zRjzum39CWNMnF2548aYs6qrRGQcMA4gISGh28yZM2v0OnJycoiKijprvTGG8d/lcVFKELeeF1qjY3tCZfH5C43PPRqfe/w9PvDvGAcOHLiyQo0PAEFePKc4WOdKlupnjMkSkSbAtyKy2Riz0NmdbYnmdYDu3bub9PR0F079m4yMDCrbt/nqHwiIiiQ9/az3tdZUFZ8/0Pjco/G5x9/jg7oRY0XerKrKBJrZLacAWc7ubIzJsv08BMzCqvoCOCgiiQC2n4c8Em0NJMWF63hVSql6x5uJYznQVkRaikgIMBKY7cyOIhIpItHlz4HBwHrb5tnAaNvz0cAXHo3aBcnx2ntcKVX/eK2qyhhTIiITgHlAIDDdGLNBRMbbtk8TkabACiAGKBORB7FaYDUCZolIeYwfGmPm2g79NPCxiNwF7AFu8NZrqE5yXDjHcovILyolPCTQV2EopVSt8uY9Dowxc4A5FdZNs3t+AKsKq6JTwIWVHPMoMMiDYdaYfcuqNk388+aWUkp5mvYcd4N2AlRK1UeaONyQVD4vhyYOpVQ9oonDDU1jwggQveJQStUvmjjcEBQYQNOYML3iUErVK5o43JQcH67jVSml6hVNHG5Kigsn66QmDqVU/aGJw01JceHsP1FAaZlO6KSUqh80cbgpOS6ckjLD4exCX4eilFK1QhOHm37rBJjn40iUUqp2aOJw0+kJnXSwQ6VUPaGJw03lvce1ZZVSqr7QxOGmqNAgYsODtROgUqre0MThAda8HJo4lFL1gyYOD0iO097jSqn6QxOHByTH6YROSqn6QxOHByTFhZNdUMKpgmJfh6KUUl6nicMDypvk6n0OpVR94NXEISJDRGSLiGwTkUkOtncQkSUiUigiE+3WNxORBSKySUQ2iMgDdtsmi8g+EVljewzz5mtwhjbJVUrVJ16bOlZEAoEpwGVAJrBcRGYbYzbaFTsG3A9cU2H3EuCPxphVIhINrBSRb+32fcEY85y3YndVis4EqJSqR7x5xdET2GaM2WGMKQJmAsPtCxhjDhljlgPFFdbvN8assj3PBjYByV6M1S2NokIJDhTtPa6Uqhe8dsWB9UG/1245E+jl6kFEJBXoAiyzWz1BRG4HVmBdmRx3sN84YBxAQkICGRkZrp4agJycHKf2jQuB1Vt2kRF+oEbnqSln4/MVjc89Gp97/D0+qBsxnsUYU+0DiAQCbM/bAVcDwdXscwPwpt3yKODflZSdDEx0sD4KWAlcZ7cuAQjEulr6OzC9uvi7detmamrBggVOlRv52hJz3as/1fg8NeVsfL6i8blH43OPv8dnjH/HCKwwDj5Tna2qWgiEiUgyMB+4A3inmn0ygWZ2yylAlpPnQ0SCgU+BD4wxn5WvN8YcNMaUGmPKgDewqsR8LilOZwJUStUPziYOMcbkAddhXTVcC3SsZp/lQFsRaSkiIcBIYLZTJxMR4C1gkzHm+QrbEu0WrwXWO/kavCo5PpyD2QUUl5b5OhSllPIqZ+9xiIj0AW4F7nJmX2NMiYhMAOZhVS1NN8ZsEJHxtu3TRKQp1n2KGKBMRB7ESkidsaq2fhGRNbZD/tkYMwd4VkTSAAPsAn7n5GvwquS4MIyBAycLaNYgwtfhKKWU1zibOB4EHgVm2T78WwELqtvJ9kE/p8K6aXbPD2BVYVW0CJBKjjnKyZhrVXKclSz2ncjXxKGUOqc5lTiMMT8APwCISABwxBhzvzcDq2uS4sIA7cuhlDr3OXWPQ0Q+FJEYEYkENgJbRORh74ZWt2jvcaVUfeHszfGOxphTWD285wDNse5BnNuObKXJwR+cKhoWHEijqBCyTmriUEqd25xNHMG25rHXAF8YY4qxbk6f2xa/TPstr0DuEaeKJ8WFk6lXHEqpc5yzieM1rBZMkcBCEWkBnPJWUH6jzwQCy4pg+VtOFU/WmQCVUvWAU4nDGPOyMSbZGDPM1qFwNzDQy7H5XuP2HG3QHX5+HYqrH4cqyTahk9XhUimlzk3O3hyPFZHnRWSF7fEvrKuPc97eZsMh7wism1lt2eS4cAqKyziepxM6KaXOXc5WVU0HsoEbbY9TwNveCsqfnIi7AJp2hiVToKzqXuFJOry6UqoecDZxtDbGPGasIdJ3GGMeB1p5MzC/IQJ9fw9HfoVt31ZZNNmWOPQGuVLqXOZs4sgXkf7lCyLSD6g/n46droWYZFj87yqL6RSySqn6wNnEMR6YIiK7RGQX8Ap+MkZUrQgMhl6/g10/QtaaSovFRwQTFhzAPk0cSqlzmLOtqtYaYy7EGnywszGmC3CJVyPzN93GQEg0LHml0iIiok1ylVL+48Qe8EIrT5emjjXGnLL1IAd4yOPR+LOwWOh6O6z/DE5mVlqsvEmuUqqeKyuDvcuhpKj2z31sJ3x+L7x0Ieyodjxal7kz57jD0WvPab3HWz+XTau0SEq8XnEopYCFz8Jbl1of3ov/DYXZ3j/nib0w+354pTus/xR63QMJ53v8NO7MOV7/ernFNYeOw2Hlu3DRnyAs5qwiSbHhHMkpoqC4lLDgQB8EqZTyua3fQcbT0G4IFOXCN3+Fhf+EHmOh13iIauLZ853Kgh//ZX02iUD3O6H/QxCTWP2+NVBl4hCRbBwnCAHCvRKRv+s7ATZ8Bqvfhz73nbXZvi9Hq8ZRtR2dUsrXTuyBz8ZCk44w4m0IiYDMlfDTi/Dj87D4FUi7xWrm37C1e+fKPmgdd/lbYEqhy20wYCLENat2V3dUWVVljIk2xsQ4eEQbY6q9WhGRISKyRUS2icgkB9s7iMgSESkUkYnO7CsiDUTkWxHZavsZ78oLdltyN2jeF5ZOhdKSszefbpJb/RAlSqlzTEkhfDwaykrhpvetpAGQ0s1anrAC0m6GNR/Av7vBx7cTfWqr6+fJPQrf/M2qBlv2GlxwA/x+JVz1kteTBrh3j6NKIhIITAGGYk0He7OIVJyn/BhwP/CcC/tOAuYbY9oC823Ltavv7+HkXtj4+VmbyjsB7juRV8tBKaV8bt6fIWsVDJ/i+GqiURvrw/3B9dD/QdieQbdVE+Hdq2Db/OpbQOUfh/lPwkudrfsm510FE5bDNVMgPtUbr8ghryUOoCewzdbTvAiYCQy3L2CMOWSMWQ5UHNypqn2HA+/anr+LNdR77Wo3BBq2sZrmVvhFN40NQwT26RWHUvXLuo9h+ZvWF8uOV1ddNjoBLp0Mf1jP9lZj4MhW+M918NoA+OWTs2szCk5a90xe7Aw/PgdtLoV7l8L1b7hf3VUD3kwcycBeu+VM2zp3900wxuwHsP308F0mJwQEQO97IWs17F58xqbgwAASosN0JkCl6pODG+HLB6xq7EGTnd8vLIa9za+FB9bC1a9YVV2f3gX/7gLLXoecw9ZN7xc7Q8Y/oOVFMP4nuPFdaNLBay+nOuKtIcBF5AbgcmPMWNvyKKCnMeb3DspOBnKMMc9Vt6+InDDGxNnte9wYc9Z9DhEZB4wDSEhI6DZzZvWj2zqSk5NDVNTZN7kDSgvps+QuTsaex/oL/nLGtqeW5hMcAI/09H77gcri8xcan3s0PvfURnyBJXl0W/lHgkryWNH9BYpCG7i0/xkxmjIaHl1O8z2fEntqy+kyRxt0Y2fLW8iJbuPJ0Ks1cODAlcaY7mdtMMZ45QH0AebZLT8KPFpJ2cnARGf2BbYAibbnicCW6mLp1q2bqakFCxZUvnH+U8Y8FmvM4V/PWD3hw1VmwDPf1/icrqgyPj+g8blH43OP1+MrKzNm5m3GTI43ZueiGh3CYYxlZcbsWmzMvL8as2eZezG6AVhhHHymerOqajnQVkRaikgIMBKY7YF9ZwOjbc9HA194MGbX9LwbAkOsIdftJMWFsf9kPmVl9a+ri1L1ytJXYdNsuPQxSO3nueOKQIs+MPhJaNbTc8f1EK8lDmNMCTABmAdsAj42xmwQkfEiMh5ARJqKSCbW8CV/FZFMEYmpbF/boZ8GLhORrcBltmXfiGoCF94Ea2ecMS95Slw4xaWGIzmFPgtNKeVlu5dYTWI7XAl97/d1NLXKnZ7j1TLGzAHmVFg3ze75ASDF2X1t648CgzwbqRv6TIBV71kdcNIfAX7rBJh5Ip8mMWG+jE4p5Q05h+C/YyC+BVzzqnWFUI94s6qqfmjcHtoOhuVvnJ6X/JyZl2P3Ypj7qG8GaVPKX5WWwCd3Wk1kb3zfGgC1ntHE4Ql9JkDuYVj3EfDbFUedbpKbd8z6RrX0VZhb+30szwlZq2HOw1CY4+tIlCcteMqam+fK56Gp5wcQrAs0cXhCy4ug6QWn5yWPCQsmOiyobl9xzPsz5B21Zj9c8RasfMfXEdUtJ/bABzfAz6/DZ+Oqna9eeYExhBYc9ux8FJvnwKIXrPl50m7x3HHrGE0cniBi3Rw7suX0vOTJdXlejl/nWTf8+z8E178FrS+BryfCnmW+jqxuKMyGD2+yqvj6TIAtX8P3T/g6qvqjrBQ2zIJpA+izdCy8nAbfPwWHt1S7a5WO7YBZ4yExDYY844lI6yxNHJ5SYV5ya0KnOjjsSP4Jqwdsk45w0cMQEGglj9gU+HgUnNrv6wj9W1kpfHKX9SF14zsw+Cnodof1LXXNDF9Hd24rLbbe41d7W9WsJfnsaHkrxLe0el9P6QnT+sNPL8HJfa4duzgfPrrd+pJ443sQXL8bvWji8BT7ecn3r627U8jO+4vVYmT4FAgKsdZFNICRH1p19R/dZg2LoBz75m+wdR4Me9a6UhOBYf+E1AHw5f161eYNJYWwYro12uzn462+VSOmw30/s6fFjXD75/DQZusqITAUvv1/8EInePsKWPG2dT+vOl9PhIO/wHVvWC2p6jlNHJ7UdTSERMHiV0iKC+dkfjE5hWcPve4SLw0J49DW72DNf6DfA5Dc9cxtCR3h2mmwbwV8/VDtxlVXrHgblk6xJurpMfa39YHB1rfU2BSYeYt1/0O5rygPlrxqDS3+1R8gshHcPBPGL4Lzr7eulstFJ1gzeN49H36/Cgb+GXIOwlcPwnPt4MOR1ox5RQ5GtV71nvV/cdHD0G5wrb08f6aJw5PC46x5yTd8Ruuwk0ANm+TmHbPG2J/aD144H47v8miYDhWctL4RN2oPFz/iuEzHq61/ntX/sUYBVb/ZkQFzJkKby2Dw38/eHtEAbv7Iqk75cGTtTCN6rio4ZRv47wKY9yg0aA2jPoex86H90Or7VDRsDRf/yRqO/HcLrYSyf63VxPafbazGDFu/tX5XWWusq41W6ZD+aC28uLrBqx0A66Ve42HZNDpnzgDS2Xc8n3YJ0dXvZwzsWgSr3oWNs6G00LoJV5QD718Ld34DUY29F/c3f4Ps/XDXt1XX36b/GQ78YjXRbXIepPb3Xkx1xZGt8PHt0LCtVUUSWMm/VeN2cMPb8MEI68Pppg+skZaVc/KOWROo/fya9UWnzaXWbHct+tTseCKQeKH1uPRxq9/SL/+15tlZ9xFENISAIOtK5vq3zryCqec0cXhafAvoeA1Nfp1BFD2rb1mVfQDWfGhNRXtsB4TGWlctXUdZf9B7f4Z3r4YProfRXzmc59xt2xdYCavv/ZBy9kCYZwgIgOtehzcGWTOdjcuolRnH/FbeMfjwRggIhltmVv/7aTMIhjwN//sTzH8cLnu8duL0prJSq1FF3hFr6J28I1ZT7tyjUHgKQmOsq/HweOtnWPxvy2Gx1X8gZx+EJf+G5dOhONca4uOiiZDUxXOvISAQWg6wHsP+aU2q9Mt/IXO5Nf1rZCPPnescoInDG/pOIGDDZ9wc9AP7Tlxw9vbSEtg+35pY/te51lzBLfpZVUQdh0Ow3XDszXpaU07OGGnVj9/6iWdbdBRmw+z7rYmpBv7ZuX3CYq2b5W9cAh/dCnfOOzPm+qKkyLrSOJlpJXVnZ2DrOQ4ObbLmim7c3v/6AxhjfaPP3m99sck7+ltCyLUlBdu6vif3ww85YCrppxIYal09VyU0FsJjbYkkzi7BxFkz3q2dCWXF1n2L/g9Z99u8KSgUOgyzHsohTRzeYJuX/M69c3n2+Ojf1h/fZd0fWP0BZGdBZGPoOwG6jIJGbSs/XtvLYPirMGscfHY33PCO5y6bv33MmgbX1Q//xu2s2cdmjLSa7177Wv0ar8cY+PoPViu6696A5r2c37e8pdWx7dZ716AVNO/tvVjtlRRBzgGrWXV2lpUYTmVZScJ+XbGjqY/FulcT0cj6Bt64HUeCU0lq2/m3dRENrUf586BQ65wFJ6yrkvzjtufHrWX75+XbDm38bRngwpHQ/w8+melOOaaJw1v6TiBx5i20OjAX1u+1qoJ2ZABi1c0Ofcaagra8yWt1LrzJ+pY371H4+o9w5Qvuf1DvXGj1Cu99n2sffOXaD4WBf4EFf7eq1frc5148dcnif1tfAi56GDrf6Pr+gcFww7vw5iCYeSvc/b3nm3nuWQbrZlp9FrKzrMSQd+TscoEhEN0UopOs32O7odZyTJL1M7KxlQTC48/6wvJrRgZJ6elVxxEUYo0kHeXiZJ3GWFcyem/B72ji8JZ2QzkUksLvTz4HnwCxzaxWGWm31vyeQJ97rTGxFj1v/TNf8pfq96lMYQ58McH6tnvJX2t+nAETrRYp3/zV6jTYemDNj1VXbJ5j9QXoeI3VWKCmyltavXkpzLgZ7poHoU40pKjO3uWQ8X+w/XsIibaq0GISIanrb8kgOslaF51kxeGPV4siIJo0/JEmDm8JCGBXj8f4ceF7nGg9nDtH3YFU1trGFYP+n5U8Fj5ru2HXvmbHmf+E1Z/gjjkQElHzeAICrP4db14Gn9xh3Sx3tq6/Ltq/Dj4dC0lpcM1U91tFnW5pdYOtpdV/av4NO3OllTC2fWddIVz2hNWfJCTSvRiVqkDbAnpRz8tuZGf/f/Hk5iSm/rjLMwcVgStfhPZXwP/+RJODC10/xq6frCaNPcdBi77uxxQaDSM/sKoVZt4KRbnuH9MfZR+w7umEx1kdzdxJuPbKW1ptmWO1tHLVvlXwwY3w5iWwbyUMegweWGd15NSkobxAE4eX/XFwO4anJfHs3C18uTbLMwcNDIIRb0GLfnTY/KL1DdNZRXnwxX3WVcGlj3kmHrBuXI6Ybt3Y/OK+c69neXG+VZ2Uf8JKGtFNPXv8nndD9zutcZTWfOjcPllrrM6EbwyEvcvgkr/Bg7/AgIcgNMqz8Sllx6uJQ0SGiMgWEdkmImdN6iCWl23b14lIV9v69iKyxu5xSkQetG2bLCL77Lb5dZs5EeHZEZ3pmdqAP/53LSt2OTEujjOCw+HmGeRFNLcGX8tc6dx+3z8Fx3fC1a94/ttom0utb7sbZllNTX3tVBas+9iq8y84VfPjlJVZo6JmrbZakiV29lyM5URg6LPWEP1fPgB7llZedv86mHELvH4x7FkMA/9qJYyLJnrmHolS1fDaPQ4RCQSmYM0LngksF5HZxpiNdsWGAm1tj17AVKCXMWYLkGZ3nH3ALLv9XjDGPOet2D0tNCiQ10Z147qpi7n7vRXMurcfqY088KEdFsu6zo/Rd/NkqzfynfOsOvPK7FlqTczU/S6ro5M39HvAuln+3eOQcAE+uY1WXGCNGbXwX1aHsXKxzaBxB6vHe5PzoHEHAkqdGME44x9Wb+LLnoAOV3gtbIctrewd3GDFsulLq+9D+qPQ+556OQOd8i1v/lf3BLYZY3YAiMhMYDhgnziGA+8ZYwywVETiRCTRGGM/dvcgYLsxZrcXY/W6+MgQ3h7Tg+umLuaOd5bz2T19iY90siluFYpC42HULHjrcmtokru+gdjkswsW51tVSLHNvNtbWQSGv2INw/HpnYR3ftp756rIGKtD5dxHrauqDlda7f9zDlod7g5vtn7u/AFKrelwByCwvoXVIsw+qTRsa3W0XPex1RChy21Wz3pvi2gAt3xs9cyfMZLAdn+Dgxvhh6dh4xdWL+yLH4He91r3WpTyATFeqosWkRHAEGPMWNvyKKyriQl2Zb4CnjbGLLItzwceMcassCszHVhljHnFtjwZGAOcAlYAfzTGHHdw/nHAOICEhIRuM2fOrNHryMnJISrKc/XFW4+X8szyAlrFBjCxexghge41gyyPLyp7B2lr/kJhaANWd/kHJcFnDn3Ravs7NN87i7WdH+d4gzS3zumMsPyDdFv5R4oCw9nT8hYONemPCQj22vnC8zJps+0tGh5bRW5ECtva3F3p65SyUsIK9hOZu4fg49uILz5AZO4ewvOzCDClABgCyA9vSljBIU7FdGDthZO9Gn9F8cfW0Hnd4+SFNCSi6AilgaHsS76Kvc2GUxLsP9VRnv7/8DR/jw/8O8aBAweuNMacPQ6RMcYrD+AG4E275VHAvyuU+Rrob7c8H+hmtxwCHAES7NYlAIFY92f+DkyvLpZu3bqZmlqwYEGN963MV2uzTItHvjITPlxlSkvL3DrWGfHtWGjME42NeWOQMYU5v63fu9yYyXHGfPF7t87lsl2LTe7T5xnzWIwxz7Y2Zv6Txpzc59lz5J80Zt5fjXm8oTH/l2LM4leMKSlyevcz3r/iQmMObDDml0+Mmf+UMTNuMWbmbcbkHvVszM76+U1T9GSyMd9O9l0M1fDG/4cn+Xt8xvh3jMAK4+Az1ZtVVZmAfU+3FKBis6LqygzFuto4WL7C/rmIvAF85amAa8sVnRPZc6wDz8zdTPMG4Tx8eQfPHLjlAKu11ce3W4+bZ1oD0H1+r9XRa/BTnjmPs1r04eeer5DezFhzby98Dn58Hs67ypr0qnmfmnc8KyuzRjD97jGrKqrLbdaNeVd7J9sLCrHGQfL2WEjO6nEXP+W2Jr26ntlK1TJvJo7lQFsRaYl1c3skUHE0t9nABNv9j17ASXPm/Y2bgTPm26xwD+RaYL03gve28Re3Ys+xPKYs2E7zBhHc1KO5Zw583lVWP48v77cSRkySNRf6bZ96Z2Td6kgAtEm3+ioc22nN47H6fetmc8IF0GscXHCDa+Nk7VsF/3sEMn+2xgUbOQNSunnrFSilKvBa4jDGlIjIBGAeVtXSdGPMBhEZb9s+DZgDDAO2AXnAHeX7i0gEVous31U49LMikgYYYJeD7XWCiPDk8E7sO5HPn2etJykunAFtPTTfRrfR1phE85+wltNus5rK+lqDlnD5361ReNd9bF2FzP69NXxH19ut1l5VjdeUcxi+fwJWvW8NuTL8VbjwZp3TQqla5tW2ksaYOVjJwX7dNLvnBnA4Mp4xJg9o6GD9KA+H6TNBgQFMuaULN0xbwr3/WcUn9/SlfVMP3fjs/5A1ZPrWb60Pa38SEgnd74BuY2D3T9Zsh4tfsQYObDfUugppefFv1VilxdaVyoJ/WM1r+9xnzeCmzVCV8gkdq8rHosOCmT6mB9e++hN3vP0zn9/XjyYxHphvQwQunWw9/JWINYNgan9rTovlb1mjCG/52moa2/NuiGthzU54eBO0vgSGPFN1XxWllNfpNb4fSIoL563RPTiRX8yd7y4nt7DE1yHVvtgUawiUP2y0Bg8MCrOGj/9ghDU3xMgP4bbPNGko5Qc0cfiJ85NjmXJLVzZmneKBmaspLTvHxnpyVnCYNSPeuAxr/vNrpsF9P1s9tv1x6G+l6iFNHH5kYIcmPH51J77bdIgnv9pY/Q7nMhFr2ty0mz07Va5Sym16j8PPjOqTyp5jebzx406aN4jgzv4tfR2SUkqdQROHH3p06HnsPZbPk19vJCU+nMGdPDyEt1JKuUGrqvxQQIDwwk1pdE6JY8KHq5ntqXk8lFLKAzRx+KnwkEDeGdODtGZx3D9jNVMWbCsfq0sppXxKE4cfi48M4f2xPRmelsQ/521h0qe/UFxa5uuwlFL1nN7j8HOhQYG8eFMaLRpE8PL328g8kcert3YjNrz2hvhWSil7esVRB4gIDw1uzz9HdGbZjmOMmLqYzON5vg5LKVVPaeKoQ27o3oz37uzJgVMFXDNlMWv3nvB1SEqpekgTRx3Tt00jZt3bl7DgAG56fQkrD9bD4UmUUj6liaMOatMkmln39qN90xheWV3Imz/u0BZXSqlao4mjjmocHcrMu3vTLSGQp77exGOzN1CiLa6UUrVAW1XVYeEhgdybFsrS/Ka8vnAHe4/l8e9buhIVqr9WpZT36BVHHRcgwp+HncdT15zPwq1HuHHaEg6cLPB1WEqpc5hXE4eIDBGRLSKyTUQmOdguIvKybfs6Eelqt22XiPwiImtEZIXd+gYi8q2IbLX9jPfma6grbuvdgrdGd2f30VyumfITG7NO+TokpdQ5ymuJQ0QCgSnAUKAjcLOIdKxQbCjQ1vYYB0ytsH2gMSbNGNPdbt0kYL4xpi0w37asgPT2Tfjv+L4A3DBtMQs2H/JxREqpc5E3rzh6AtuMMTuMMUXATGB4hTLDgfeMZSkQJyKJ1Rx3OPCu7fm7wDUejLnO65gUw+f39SO1USR3vbuct3/aSVl9nRRKKeUV4q1mnCIyAhhijBlrWx4F9DLGTLAr8xXwtDFmkW15PvCIMWaFiOwEjgMGeM0Y87qtzAljTJzdMY4bY86qrhKRcVhXMSQkJHSbOXNmjV5HTk4OUVFRNdq3NlQWX0GJYeraQtYeLqVFTAA3tQ+hY8PAWo2ttMxw9FQuTeLq3vvnLzQ+9/h7fODfMQ4cOHBlhRofwLutqhzN81kxS1VVpp8xJktEmgDfishmY8xCZ09uSzSvA3Tv3t2kp6c7u+sZMjIyqOm+taGq+AZfYvhyXRbPzt3Cs8vzubhdYx4d1oEOTWO8GlNBcSn/XZnJ6wu3k3lMGNwpirEDWtG9RTziZ9O/1uXfrz/Q+NxXF2KsyJuJIxNoZrecAlScWKLSMsaY8p+HRGQWVtXXQuCgiCQaY/bbqrW0Ir8SAQHC8LRkLu/UlPeW7OKV77cx9KUfGdE1hT8Obk/TWM9OyXqqoJj/LN3N9EW7OJJTSFqzODpGF7Ns5zHmbTjIhSmx3DWgFUPPb0pwoDboU6qu8uZ/73KgrYi0FJEQYCQwu0KZ2cDtttZVvYGTtoQQKSLRACISCQwG1tvtM9r2fDTwhRdfwzkhLDiQcRe1ZuGfBnJXv5Z8sSaL9OcW8M95m8kuKHb7+IezC3l27mb6/eN7np27hfMSo5lxd29m3duXm88LZfGkS3jymvM5VVDC/TNWc/GzC3h94XZOeeDcSqna57UrDmNMiYhMAOYBgcB0Y8wGERlv2z4NmAMMA7YBecAdtt0TgFm2ao0g4ENjzFzbtqeBj0XkLmAPcIO3XsO5Ji4ihL9e2ZHRfVP557wtTFmwnRk/7+WBQW25pVdzl68C9h7L4/WFO/h4xV6KSssYdn4i96S35vzk2DPKRYQEMap3C27t2ZzvNx/izUU7+L85m3npu63c1KM5d/RLpVmDCE++VKWUF3m1i7ExZg5WcrBfN83uuQHuc7DfDuDCSo55FBjk2Ujrl2YNInj55i6MHdCS/5tjDVfyzuJd/Ony9gw5v2m19yE2HzjFtIztfLluPwEC13dNYdxFrWjVuOobfAEBwqUdE7i0YwLr953krUU7eW/JLt5ZvJMh5zflrv6t6NZCu+Uo5e90bIp6rHNKHDPu7s2CLYf4x5zN3PPBKro2j+MvV5xHtxYNziq/YtcxpmZsZ/7mQ0SEBHJnv1Tu6t+qRvdKzk+O5YWb0nhkSAfeXbKLD5buZs4vB+jSPI6x/VtxeacEgvQ+iFJ+SRNHPSciXNIhgYvaNuaTlZk8/+2vXD91CUM6NeVPQ9rTslEkGb8eZuqC7fy86xjxEcE8dFk7bu/TgriIELfP3zQ2jEeGdGDCwDZ8uiqTtxbt5L4PV5EcF84d/VK5qUczosN0tkOl/IkmDgVAUGAAI3s25+q0JN78cSev/bCd7zYdpHmDCHYcySUpNozHrurITT2aERHi+T+byNAgbu+Tyq29WjB/00He/HEnT329iRe/28qIbimM6tOC1tVUhSmlaocmDnWGiJAg7h/Ulpt7Nuel+b+yeX8296S3ZnhaMiFB3q86CgwQBndqyuBOTVm79wTvLN7FB8t2887iXQxo24gxfVNJb9+EwAD/6g+iVH2iiUM51Dg6lKeuucCnMVzYLI4Xbkrjz8POY8bPe/hg2W7uencFzRtEMKp3C27s3ozYCK3GUqq26d1H5fcaR4dy/6C2LHrkEl65pQsJMaH8fc4mev9jPo9+9gubD+hIwErVJr3iUHVGcGAAV3ZO4srOSWzIOsl7i3fz2apMZvy8h14tGzCmbyqXdfRca6ycwhJO5BURFxFCZEig3w2XopSvaOJQdVKnpFieGdGZSUM78PGKvby3ZDf3fLCKxNgwbuvdgpE9mtEwKrTS/Y0xHM4pZMeJUnLX7WffiTz2Hc9n34kC9p3IZ9/xPE4VlJwuHxIUQMPIEBpGhdAgMpSGkSE0sD0a2dY1iAw5XSYqNMhhoikuLSOvsJScohLyCkvILSolt7CE3MIS8opKySksIa+ohNxCa31mZhGByYfp1bJhrdxjUsoZmjhUnRYfGcLvLm7N2AGtmL/pIO8u2cU/523hpe+2cuWFiVxxQSLH84ptSSGPrPLEcCKfohLbHO1LVwEQHRpEcnw4yXHh9EiNJykunPiIYE7kFXMst4ijuUWnf+44nMOx3CLyikodxhUSGECDyBCiwoLILyo9nQyKXJgXPiIkkKLiUua+9TPRoUEM7NCEyzomkN6+sTZRVj6liUOdE+xbY209mM17S3bz6apMPlu173SZxtGhJMeF0zExhss6JpAcF86xzG0MGdCTpLhwYsNd/zAuKC61EkpOEUdyCzmWU2SXZArJLighPCSQqNAgIkKCiAwJJDI0iMjQQCJCgmzry9dZ2yNCg4gIDiQgQPhm/gICEjvyzcYDfLfpELPXZhEcKPRt3YjBnRK47LwEmsR4drBKpaqjiUOdc9omRPPkNefz8JD2bMw6RUJMGImxYYQFnz0fSUbGLs5LrPkw82HBgSTHWVcp3hASKKTbhmkpLTOs2nOcbzYc4JuNB/nLrPX8ZdZ60prFMbhTAoM7JtC6cZTei1Fep4lDnbNiwoLp3aqhr8PwmMAAoUdqA3qkNuDPw85j66Gc00nk2blbeHbuFlo1iuSyjgkM7pRAl2bxBGh/F+UFmjiUqoNEhHYJ0bRLiGbCJW3ZfzKf7zYe5JuNB3lr0U5eW7iDRlGh9G1t3VQvLTOUlBlKy8ooKTV2y4aSsjJKbc/PXG+IDAnknvTWXN6p+sEvfaWszHA8r4hD2YXW41QBh7ILOZxdyK+7CllZtIWWjSJPPzwxVE59p4lDqXNAYmw4o/qkMqpPKifzi8nYcohvNx5k5e7jAAQFCoEiBAZYj6BAITAggKDy5YAAwoLLn/+27teD2Yz/zyr6t2nEY1d1pG1CdK2+rkOnCth/ssCWFAo4dKrQlhRs604VciSnkJKys6fAjg4LIphSlmVsp9Rue3xEsC2JRNGq8W8JJbVhJOEhtTu9cl2liUOpc0xseDDD05IZnpbs9rFKSsv4YNke/vXNFoa+9COj+6bywKVtifFiqy5jDEt2HGXKgm38tO3oWdsbRobQODqUJjFhtEuIpkl0qPWICbM9D6NxdCjhIYFkZGTQt/9F7D2ex87Duew8ksvOo7nsPJzLT9uO8OmqzDOOnRQbRsvGVhJp2SiSdgnR9G/TSKv8KtDEoZSqVFBgAKP7pnJl50Se++ZXpv+0ky/W7ONPQzowomuKR89ljOH7zYd4ZcE2Vu85QePoUCYObkf7pjG2xBBKo6hQlyccCwkKoHXjKIeDZOYWlrDrqC2h2BLLjiO5fLVuPyfzrRkqO6fEMvnqTnRtrnPFlPNq4hCRIcBLWDMAvmmMebrCdrFtH4Y1A+AYY8wqEWkGvAc0BcqA140xL9n2mQzcDRy2HebPtgmjlFJe0jAqlH9cdwG39GzOY7PX86dP1vHBsj0MTy4l3c1jl5YZ5vyynykLtrH5QDbJceE8ec353NAtxWFLOE+KDA2iU1IsnZJiz9p2PLeIBVsO8czczVz36mKu75rCI0Pb0yRamz97LXGISCAwBbgMyASWi8hsY8xGu2JDgba2Ry9gqu1nCfBHWxKJBlaKyLd2+75gjHnOW7ErpRy7ICWWT+/py6zV+/jH/zbzxN5CNpes5eHLO9A4uvKe+o4UlZTx+ep9TP1hOzuP5NK6cST/uuFCrk5LcvmqwhviI0O4rmsKl3dqyr+/38Zbi3bwzYYDPHBpW0b3TfWLGH3Fm1ccPYFttmlgEZGZwHDAPnEMB96zTSG7VETiRCTRGLMf2A9gjMkWkU1AcoV9lVI+ICJc1zWFwZ2a8vA73zNr9T7+98sBHrRN8FXdB2pBcSkfLd/Laz9sJ+tkAZ2SYph6a1cu79TUL+8lRIYGMWloB27snsITX23kqa83MXP5XiZf1Yn+bRv5Ojyf8GbKTAb22i1n2ta5VEZEUoEuwDK71RNEZJ2ITBcRrXhUygeiQoO4qX0Icx+8iC4t4nnyq40Me+lHftp2xGH57IJipmZsp/8z3/PY7A0kx4fzzh09+Or3/Rl6QaJfJg17rRpH8faYHrx5e3eKSsq47a1ljH9/JZnH83wdWq0T68u+Fw4scgNwuTFmrG15FNDTGPN7uzJfA/8wxiyyLc8H/mSMWWlbjgJ+AP5ujPnMti4BOAIY4Ekg0Rhzp4PzjwPGASQkJHSbOXNmjV5HTk4OUVH+O/Ocxucejc895fEZY1hzuJQPNxVxON/QLSGQke1DaBwRQE6R4ZvdxXy3u5i8Eji/USBXtQqmfQPvN3311vtXVGqYu6uYr7YXY4ArWgUzrGUwIYGuJz9HMRaUGHaeLCMzu4y4MCEhQkiICCA0qHaT68CBA1caY7pXXO/NxNEHmGyMudy2/CiAMeYfdmVeAzKMMTNsy1uAdGPMfhEJBr4C5hljnq/kHKnAV8aY86uKpXv37mbFihU1eh0ZGRmkp6fXaN/aoPG5R+NzT8X4CopLefPHHbyyYBvGwKUdE1iw+RB5RaUM6dSUewe2pnNKnM/i87SsE/n8fc4mvl63n5T4cP56RUcu75TgUmfJBQsW0ObCXqzac5yVu63Hpv2ncNA1hcTYMKupcONIWtn6nrRsHEmz+AivjJ4sIg4ThzfvcSwH2opIS2AfMBK4pUKZ2VjVTjOxboqftCUNAd4CNlVMGnb3QACuBdZ78TUopVwQFhzIhEvacl3XFP5vzibmbTjAlZ2TuDe9da13HqwNSXHhTLmlK7f2OsLjszcy/j8rGdC2EY9d1Yk2TRxf6RSWlLIh6xSrbEliydZ8TsxbAFgjIqc1i+O+gW3o2iKejokxHM4utJoM2/VD+dquuTBYw9E0iw8n1daZsVWjyNPPk2LDPV4N6LXEYYwpEZEJwDys5rjTjTEbRGS8bfs0YA5WU9xtWM1x77Dt3g8YBfwiImts68qb3T4rImlYVVW7gN956zUopWomKS6cV27p6uswak3f1o34+v7+vL90N89/+ytDXlzIHf1SuX9QWwqKy1i15/jpRLFu38nTQ/qnxIfToUEAw3p2oGvzeDo0jT5rIrKEmDDOT3bcXHhnhYSy83Auy3YcI7/4t+H+XxvVjcs7NfXo6/VqPw7bB/2cCuum2T03wH0O9lsEOEyRxphRHg5TKaXcFhQYwB39WnLVhUn8c+4W3vhxJ+8v3U1BsZUkggOF85Njub13C7q1iKdri3gSYsKs6rQ+qS6fLz4yhPjIkLM6JhpjOJRdyA5bQunSLM4Dr+5M2nNcKaU8qFFUKM+M6MzNvZrz0fI9pDaMpFuLeM5PjvV6h0awmksnxISREBNGn9beGR1aE4dSSnlBWrM40rzwbd8f1N+uj0oppWpEE4dSSimXaOJQSinlEk0cSimlXKKJQymllEs0cSillHKJJg6llFIu0cShlFLKJV4bHdefiMhhYHcNd2+ENYy7v9L43KPxuUfjc58/x9jCGNO44sp6kTjcISIrHA0r7C80PvdofO7R+NxXF2KsSKuqlFJKuUQTh1JKKZdo4qje674OoBoan3s0PvdofO6rCzGeQe9xKKWUcolecSillHKJJg6llFIu0cRhIyJDRGSLiGwTkUkOtouIvGzbvk5Eam1CZRFpJiILRGSTiGwQkQcclEkXkZMissb2+H+1FZ/t/LtE5BfbuVc42O7L96+93fuyRkROiciDFcrU6vsnItNF5JCIrLdb10BEvhWRrbaf8ZXsW+Xfqhfj+6eIbLb9/maJSFwl+1b5t+DF+CaLyD673+GwSvb11fv3kV1su0RkTSX7ev39c5sxpt4/gEBgO9AKCAHWAh0rlBkG/A9rLvTewLJajC8R6Gp7Hg386iC+dOArH76Hu4BGVWz32fvn4Hd9AKtjk8/eP+AioCuw3m7ds8Ak2/NJwDOVxF/l36oX4xsMBNmeP+MoPmf+FrwY32RgohO/f5+8fxW2/wv4f756/9x96BWHpSewzRizwxhTBMwEhlcoMxx4z1iWAnEiklgbwRlj9htjVtmeZwObgOTaOLcH+ez9q2AQsN0YU9ORBDzCGLMQOFZh9XDgXdvzd4FrHOzqzN+qV+IzxnxjjCmxLS4FUjx9XmdV8v45w2fvXzkREeBGYIanz1tbNHFYkoG9dsuZnP3B7EwZrxORVKALsMzB5j4islZE/icinWo3MgzwjYisFJFxDrb7xfsHjKTyf1hfvn8ACcaY/WB9WQCaOCjjL+/jnVhXkI5U97fgTRNsVWnTK6nq84f3bwBw0BiztZLtvnz/nKKJwyIO1lVsp+xMGa8SkSjgU+BBY8ypCptXYVW/XAj8G/i8NmMD+hljugJDgftE5KIK2/3h/QsBrgb+62Czr98/Z/nD+/gXoAT4oJIi1f0teMtUoDWQBuzHqg6qyOfvH3AzVV9t+Or9c5omDksm0MxuOQXIqkEZrxGRYKyk8YEx5rOK240xp4wxObbnc4BgEWlUW/EZY7JsPw8Bs7CqBOz59P2zGQqsMsYcrLjB1++fzcHy6jvbz0MOyvj673A0cCVwq7FVyFfkxN+CVxhjDhpjSo0xZcAblZzX1+9fEHAd8FFlZXz1/rlCE4dlOdBWRFravpWOBGZXKDMbuN3WOqg3cLK8WsHbbHWibwGbjDHPV1Kmqa0cItIT63d7tJbiixSR6PLnWDdR11co5rP3z06l3/R8+f7ZmQ2Mtj0fDXzhoIwzf6teISJDgEeAq40xeZWUceZvwVvx2d8zu7aS8/rs/bO5FNhsjMl0tNGX759LfH133l8eWK1+fsVqcfEX27rxwHjbcwGm2Lb/AnSvxdj6Y11OrwPW2B7DKsQ3AdiA1UpkKdC3FuNrZTvvWlsMfvX+2c4fgZUIYu3W+ez9w0pg+4FirG/BdwENgfnAVtvPBrayScCcqv5Waym+bVj3B8r/BqdVjK+yv4Vaiu9929/WOqxkkOhP759t/Tvlf3N2ZWv9/XP3oUOOKKWUcolWVSmllHKJJg6llFIu0cShlFLKJZo4lFJKuUQTh1JKKZdo4lDKA0SkVM4cgddjo66KSKr9KKtK+VqQrwNQ6hyRb4xJ83UQStUGveJQyotscys8IyI/2x5tbOtbiMh824B880WkuW19gm2ui7W2R1/boQJF5A2x5mP5RkTCffaiVL2niUMpzwivUFV1k922U8aYnsArwIu2da9gDTPfGWuwwJdt618GfjDWYItdsXoPA7QFphhjOgEngOu9+mqUqoL2HFfKA0QkxxgT5WD9LuASY8wO20CVB4wxDUXkCNaQGMW29fuNMY1E5DCQYowptDtGKvCtMaatbfkRINgY81QtvDSlzqJXHEp5n6nkeWVlHCm0e16K3p9UPqSJQynvu8nu5xLb88VYI7MC3Aossj2fD9wDICKBIhJTW0Eq5Sz91qKUZ4SLyBq75bnGmPImuaEisgzri9rNtnX3A9NF5GHgMHCHbf0DwOsichfWlcU9WKOsKuU39B6HUl5ku8fR3RhzxNexKOUpWlWllFLKJXrFoZRSyiV6xaGUUsolmjiUUkq5RBOHUkopl2jiUEop5RJNHEoppVzy/wHKpP3FlxRunAAAAABJRU5ErkJggg==\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": "dee05155",
   "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": "6e186a1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Restoring states from the checkpoint path at logs/my-model/version_13/checkpoints/epoch=16-step=7292.ckpt\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "Loaded model weights from checkpoint at logs/my-model/version_13/checkpoints/epoch=16-step=7292.ckpt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "22034ac9972148a1b319f9cff6675ab0",
       "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.9818000197410583}\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[{'test_acc': 0.9818000197410583}]"
      ]
     },
     "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": "29deda86",
   "metadata": {},
   "source": [
    "## Predicting labels of new data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b38037df",
   "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": "72fbb4ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logs/my-model/version_13/checkpoints/epoch=16-step=7292.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": "eb56f06f",
   "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": "4fd1adfb",
   "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": "d4b2a531",
   "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": "f0d76a98",
   "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": "1f5c3c94",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy: 0.9818 (98.18%)\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": "33c8d8c6",
   "metadata": {},
   "source": [
    "## Inspecting Failure Cases"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7de967e2",
   "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": "3c9fd7f0",
   "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": "c43b53d1",
   "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": "a8dc04de",
   "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": "b209ec1c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 23;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/plot_confusion-matrix_basic.py\\nfrom torchmetrics import ConfusionMatrix\\nimport matplotlib\\nfrom mlxtend.plotting import plot_confusion_matrix\\n\\n\\ncmat = ConfusionMatrix(num_classes=len(class_dict))\\n\\nfor x, y in test_dataloader:\\n\\n    with torch.no_grad():\\n        pred = lightning_model(x)\\n    cmat(pred, y)\\n\\ncmat_tensor = cmat.compute()\\ncmat = cmat_tensor.numpy()\\n\\nfig, ax = plot_confusion_matrix(\\n    conf_mat=cmat,\\n    class_names=class_dict.values(),\\n    norm_colormap=matplotlib.colors.LogNorm()  \\n    # normed colormaps highlight the off-diagonals \\n    # for high-accuracy models better\\n)\\n\\nplt.show()\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/plot_confusion-matrix_basic.py\\nfrom torchmetrics import ConfusionMatrix\\nimport matplotlib\\nfrom mlxtend.plotting import plot_confusion_matrix\\n\\n\\ncmat = ConfusionMatrix(num_classes=len(class_dict))\\n\\nfor x, y in test_dataloader:\\n\\n    with torch.no_grad():\\n        pred = lightning_model(x)\\n    cmat(pred, y)\\n\\ncmat_tensor = cmat.compute()\\ncmat = cmat_tensor.numpy()\\n\\nfig, ax = plot_confusion_matrix(\\n    conf_mat=cmat,\\n    class_names=class_dict.values(),\\n    norm_colormap=matplotlib.colors.LogNorm()\\n    # normed colormaps highlight the off-diagonals\\n    # for high-accuracy models better\\n)\\n\\nplt.show()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/plot_confusion-matrix_basic.py\n",
    "from torchmetrics import ConfusionMatrix\n",
    "import matplotlib\n",
    "from mlxtend.plotting import plot_confusion_matrix\n",
    "\n",
    "\n",
    "cmat = ConfusionMatrix(num_classes=len(class_dict))\n",
    "\n",
    "for x, y in test_dataloader:\n",
    "\n",
    "    with torch.no_grad():\n",
    "        pred = lightning_model(x)\n",
    "    cmat(pred, y)\n",
    "\n",
    "cmat_tensor = cmat.compute()\n",
    "cmat = cmat_tensor.numpy()\n",
    "\n",
    "fig, ax = plot_confusion_matrix(\n",
    "    conf_mat=cmat,\n",
    "    class_names=class_dict.values(),\n",
    "    norm_colormap=matplotlib.colors.LogNorm()  \n",
    "    # normed colormaps highlight the off-diagonals \n",
    "    # for high-accuracy models better\n",
    ")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "f3ac2a0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numpy            : 1.22.0\n",
      "torchvision      : 0.11.2\n",
      "matplotlib       : 3.3.4\n",
      "torchmetrics     : 0.6.2\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",
      "pytorch_lightning: 1.5.1\n",
      "pandas           : 1.4.1\n",
      "\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 24;\n",
       "                var nbb_unformatted_code = \"%watermark --iversions\";\n",
       "                var nbb_formatted_code = \"%watermark --iversions\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%watermark --iversions"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}