{ "cells": [ { "cell_type": "code", "execution_count": 1, "id": "14749f84", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "torch : 1.10.1\n", "pytorch_lightning: 1.6.0.dev0\n", "torchmetrics : 0.6.2\n", "matplotlib : 3.3.4\n", "\n" ] } ], "source": [ "%load_ext watermark\n", "%watermark -p torch,pytorch_lightning,torchmetrics,matplotlib" ] }, { "cell_type": "markdown", "id": "41a16fc7", "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": "3434d08b", "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": "3b3ef378", "metadata": {}, "outputs": [], "source": [ "# %load_ext nb_black" ] }, { "cell_type": "markdown", "id": "11172ece", "metadata": {}, "source": [ "      \n", "\n", "# A Basic Convolutional Neural Network Trained on MNIST" ] }, { "cell_type": "markdown", "id": "e1786096", "metadata": {}, "source": [ "A basic convolutional neural network [1][2] trained on MNIST [3]. The weights are manually re-initialized using Kaiming He initialization scheme [4].\n", "\n", "### References\n", "\n", "- [1] L13.3 Convolutional Neural Network Basics (18:39), https://www.youtube.com/watch?v=7fWOE-z8YgY\n", "- [2] https://en.wikipedia.org/wiki/Convolutional_neural_network\n", "- [3] https://en.wikipedia.org/wiki/MNIST_database\n", "- [4] Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification, https://openaccess.thecvf.com/content_iccv_2015/html/He_Delving_Deep_into_ICCV_2015_paper.html" ] }, { "cell_type": "markdown", "id": "323d276f", "metadata": {}, "source": [ "## General settings and hyperparameters" ] }, { "cell_type": "markdown", "id": "8b6230f0", "metadata": {}, "source": [ "- Here, we specify some general hyperparameter values and general settings." ] }, { "cell_type": "code", "execution_count": 4, "id": "74a29375", "metadata": {}, "outputs": [], "source": [ "BATCH_SIZE = 128\n", "NUM_EPOCHS = 20\n", "LEARNING_RATE = 0.005\n", "NUM_WORKERS = 4" ] }, { "cell_type": "markdown", "id": "8fb4f14e", "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": "760684c1", "metadata": {}, "source": [ "## Implementing a Neural Network using PyTorch Lightning's `LightningModule`" ] }, { "cell_type": "markdown", "id": "b327d9ab", "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": "e0e79521", "metadata": {}, "outputs": [], "source": [ "import torch\n", "import torch.nn.functional as F\n", "\n", "\n", "# Regular PyTorch Module\n", "class PyTorchModel(torch.nn.Module):\n", " def __init__(self, num_classes):\n", " super().__init__()\n", "\n", " self.num_classes = num_classes\n", " \n", " # Calculate \"same\" padding:\n", " # (w - k + 2*p)/s + 1 = o\n", " # => p = (s(o-1) - w + k)/2\n", " \n", " self.features = torch.nn.Sequential(\n", " # 28x28x1 => 28x28x8\n", " torch.nn.Conv2d(\n", " in_channels=1,\n", " out_channels=8,\n", " kernel_size=(3, 3),\n", " stride=(1, 1),\n", " padding=1), # (1(28-1) - 28 + 3) / 2 = 1\n", " torch.nn.ReLU(),\n", " \n", " # 28x28x8 => 14x14x8\n", " torch.nn.MaxPool2d(\n", " kernel_size=(2, 2),\n", " stride=(2, 2),\n", " padding=0), # (2(14-1) - 28 + 2) = 0\n", " \n", " # 14x14x8 => 14x14x16\n", " torch.nn.Conv2d(\n", " in_channels=8,\n", " out_channels=16,\n", " kernel_size=(3, 3),\n", " stride=(1, 1),\n", " padding=1), # (1(14-1) - 14 + 3) / 2 = 1 \n", " torch.nn.ReLU(),\n", " \n", " # 14x14x16 => 7x7x16 \n", " torch.nn.MaxPool2d(\n", " kernel_size=(2, 2),\n", " stride=(2, 2),\n", " padding=0) # (2(7-1) - 14 + 2) = 0\n", " )\n", "\n", " self.output_layer = torch.nn.Linear(7*7*16, num_classes)\n", "\n", " ###############################################\n", " # Reinitialize weights using He initialization\n", " ###############################################\n", " for m in self.modules():\n", " if isinstance(m, torch.nn.Conv2d):\n", " torch.nn.init.kaiming_normal_(m.weight.detach())\n", " m.bias.detach().zero_()\n", " elif isinstance(m, torch.nn.Linear):\n", " torch.nn.init.kaiming_normal_(m.weight.detach())\n", " m.bias.detach().zero_()\n", "\n", " def forward(self, x):\n", " x = self.features(x)\n", " x = torch.flatten(x, start_dim=1)\n", " x = self.output_layer(x)\n", " return x # x are the model's logits" ] }, { "cell_type": "code", "execution_count": 6, "id": "7644dab9", "metadata": {}, "outputs": [], "source": [ "# %load ../code_lightningmodule/lightningmodule_classifier_basic.py\n", "import pytorch_lightning as pl\n", "import torchmetrics\n", "\n", "\n", "# LightningModule that receives a PyTorch model as input\n", "class LightningModel(pl.LightningModule):\n", " def __init__(self, model, learning_rate):\n", " super().__init__()\n", "\n", " self.learning_rate = learning_rate\n", " # The inherited PyTorch module\n", " self.model = model\n", " if hasattr(model, \"dropout_proba\"):\n", " self.dropout_proba = model.dropout_proba\n", "\n", " # Save settings and hyperparameters to the log directory\n", " # but skip the model parameters\n", " self.save_hyperparameters(ignore=[\"model\"])\n", "\n", " # Set up attributes for computing the accuracy\n", " self.train_acc = torchmetrics.Accuracy()\n", " self.valid_acc = torchmetrics.Accuracy()\n", " self.test_acc = torchmetrics.Accuracy()\n", "\n", " # Defining the forward method is only necessary\n", " # if you want to use a Trainer's .predict() method (optional)\n", " def forward(self, x):\n", " return self.model(x)\n", "\n", " # A common forward step to compute the loss and labels\n", " # this is used for training, validation, and testing below\n", " def _shared_step(self, batch):\n", " features, true_labels = batch\n", " logits = self(features)\n", " loss = torch.nn.functional.cross_entropy(logits, true_labels)\n", " predicted_labels = torch.argmax(logits, dim=1)\n", "\n", " return loss, true_labels, predicted_labels\n", "\n", " def training_step(self, batch, batch_idx):\n", " loss, true_labels, predicted_labels = self._shared_step(batch)\n", " self.log(\"train_loss\", loss)\n", "\n", " # Do another forward pass in .eval() mode to compute accuracy\n", " # while accountingfor Dropout, BatchNorm etc. behavior\n", " # during evaluation (inference)\n", " self.model.eval()\n", " with torch.no_grad():\n", " _, true_labels, predicted_labels = self._shared_step(batch)\n", " self.train_acc(predicted_labels, true_labels)\n", " self.log(\"train_acc\", self.train_acc, on_epoch=True, on_step=False)\n", " self.model.train()\n", "\n", " return loss # this is passed to the optimzer for training\n", "\n", " def validation_step(self, batch, batch_idx):\n", " loss, true_labels, predicted_labels = self._shared_step(batch)\n", " self.log(\"valid_loss\", loss)\n", " self.valid_acc(predicted_labels, true_labels)\n", " self.log(\n", " \"valid_acc\",\n", " self.valid_acc,\n", " on_epoch=True,\n", " on_step=False,\n", " prog_bar=True,\n", " )\n", "\n", " def test_step(self, batch, batch_idx):\n", " loss, true_labels, predicted_labels = self._shared_step(batch)\n", " self.test_acc(predicted_labels, true_labels)\n", " self.log(\"test_acc\", self.test_acc, on_epoch=True, on_step=False)\n", "\n", " def configure_optimizers(self):\n", " optimizer = torch.optim.Adam(self.parameters(), lr=self.learning_rate)\n", " return optimizer" ] }, { "cell_type": "markdown", "id": "cae6c7f9", "metadata": {}, "source": [ "## Setting up the dataset" ] }, { "cell_type": "markdown", "id": "2c5400f5", "metadata": {}, "source": [ "- In this section, we are going to set up our dataset." ] }, { "cell_type": "markdown", "id": "3b930598", "metadata": {}, "source": [ "### Inspecting the dataset" ] }, { "cell_type": "code", "execution_count": 7, "id": "6ba6bf9c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Training label distribution:\n", "\n", "Test label distribution:\n" ] }, { "data": { "text/plain": [ "[(0, 980),\n", " (1, 1135),\n", " (2, 1032),\n", " (3, 1010),\n", " (4, 982),\n", " (5, 892),\n", " (6, 958),\n", " (7, 1028),\n", " (8, 974),\n", " (9, 1009)]" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# %load ../code_dataset/dataset_mnist_check.py\n", "from collections import Counter\n", "from torchvision import datasets\n", "from torchvision import transforms\n", "from torch.utils.data import DataLoader\n", "\n", "\n", "train_dataset = datasets.MNIST(\n", " root=\"./data\", train=True, transform=transforms.ToTensor(), download=True\n", ")\n", "\n", "train_loader = DataLoader(\n", " dataset=train_dataset,\n", " batch_size=BATCH_SIZE,\n", " num_workers=NUM_WORKERS,\n", " drop_last=True,\n", " shuffle=True,\n", ")\n", "\n", "test_dataset = datasets.MNIST(\n", " root=\"./data\", train=False, transform=transforms.ToTensor()\n", ")\n", "\n", "test_loader = DataLoader(\n", " dataset=test_dataset,\n", " batch_size=BATCH_SIZE,\n", " num_workers=NUM_WORKERS,\n", " drop_last=False,\n", " shuffle=False,\n", ")\n", "\n", "train_counter = Counter()\n", "for images, labels in train_loader:\n", " train_counter.update(labels.tolist())\n", "\n", "test_counter = Counter()\n", "for images, labels in test_loader:\n", " test_counter.update(labels.tolist())\n", "\n", "print(\"\\nTraining label distribution:\")\n", "sorted(train_counter.items())\n", "\n", "print(\"\\nTest label distribution:\")\n", "sorted(test_counter.items())\n" ] }, { "cell_type": "markdown", "id": "c28a806e", "metadata": {}, "source": [ "### Performance baseline" ] }, { "cell_type": "markdown", "id": "7ff6d9b9", "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": "3ed1ef8b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Majority class: 1\n", "Accuracy when always predicting the majority class:\n", "0.11 (11.35%)\n" ] } ], "source": [ "# %load ../code_dataset/performance_baseline.py\n", "majority_class = test_counter.most_common(1)[0]\n", "print(\"Majority class:\", majority_class[0])\n", "\n", "baseline_acc = majority_class[1] / sum(test_counter.values())\n", "print(\"Accuracy when always predicting the majority class:\")\n", "print(f\"{baseline_acc:.2f} ({baseline_acc*100:.2f}%)\")" ] }, { "cell_type": "markdown", "id": "7dc3a1a1", "metadata": {}, "source": [ "## A quick visual check" ] }, { "cell_type": "code", "execution_count": 9, "id": "ff2d1efb", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# %load ../code_dataset/plot_visual-check_basic.py\n", "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import torchvision\n", "\n", "\n", "for images, labels in train_loader: \n", " break\n", "\n", "plt.figure(figsize=(8, 8))\n", "plt.axis(\"off\")\n", "plt.title(\"Training images\")\n", "plt.imshow(np.transpose(torchvision.utils.make_grid(\n", " images[:64], \n", " padding=2,\n", " normalize=True),\n", " (1, 2, 0)))\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "2c5b7124", "metadata": {}, "source": [ "### Setting up a `DataModule`" ] }, { "cell_type": "markdown", "id": "d107bd10", "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": "bae7e3af", "metadata": {}, "outputs": [], "source": [ "# %load ../code_lightningmodule/datamodule_mnist_basic.py\n", "from torch.utils.data.dataset import random_split\n", "\n", "\n", "class DataModule(pl.LightningDataModule):\n", " def __init__(self, data_path=\"./\"):\n", " super().__init__()\n", " self.data_path = data_path\n", "\n", " def prepare_data(self):\n", " datasets.MNIST(root=self.data_path, download=True)\n", " return\n", "\n", " def setup(self, stage=None):\n", " # Note transforms.ToTensor() scales input images\n", " # to 0-1 range\n", " train = datasets.MNIST(\n", " root=self.data_path,\n", " train=True,\n", " transform=transforms.ToTensor(),\n", " download=False,\n", " )\n", "\n", " self.test = datasets.MNIST(\n", " root=self.data_path,\n", " train=False,\n", " transform=transforms.ToTensor(),\n", " download=False,\n", " )\n", "\n", " self.train, self.valid = random_split(train, lengths=[55000, 5000])\n", "\n", " def train_dataloader(self):\n", " train_loader = DataLoader(\n", " dataset=self.train,\n", " batch_size=BATCH_SIZE,\n", " drop_last=True,\n", " shuffle=True,\n", " num_workers=NUM_WORKERS,\n", " )\n", " return train_loader\n", "\n", " def val_dataloader(self):\n", " valid_loader = DataLoader(\n", " dataset=self.valid,\n", " batch_size=BATCH_SIZE,\n", " drop_last=False,\n", " shuffle=False,\n", " num_workers=NUM_WORKERS,\n", " )\n", " return valid_loader\n", "\n", " def test_dataloader(self):\n", " test_loader = DataLoader(\n", " dataset=self.test,\n", " batch_size=BATCH_SIZE,\n", " drop_last=False,\n", " shuffle=False,\n", " num_workers=NUM_WORKERS,\n", " )\n", " return test_loader\n" ] }, { "cell_type": "markdown", "id": "6f9c4f68", "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": "53e05ebe", "metadata": {}, "outputs": [], "source": [ "import torch\n", "\n", "\n", "torch.manual_seed(1) \n", "data_module = DataModule(data_path='./data')" ] }, { "cell_type": "markdown", "id": "cadb198e", "metadata": {}, "source": [ "## Training the model using the PyTorch Lightning Trainer class" ] }, { "cell_type": "markdown", "id": "6f3fa662", "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": "29e94d50", "metadata": {}, "outputs": [], "source": [ "pytorch_model = PyTorchModel(num_classes=10)" ] }, { "cell_type": "code", "execution_count": 13, "id": "60d52673", "metadata": {}, "outputs": [], "source": [ "# %load ../code_lightningmodule/logger_csv_acc_basic.py\n", "from pytorch_lightning.callbacks import ModelCheckpoint\n", "from pytorch_lightning.loggers import CSVLogger\n", "\n", "\n", "lightning_model = LightningModel(pytorch_model, learning_rate=LEARNING_RATE)\n", "\n", "callbacks = [\n", " ModelCheckpoint(\n", " save_top_k=1, mode=\"max\", monitor=\"valid_acc\"\n", " ) # save top 1 model\n", "]\n", "logger = CSVLogger(save_dir=\"logs/\", name=\"my-model\")" ] }, { "cell_type": "markdown", "id": "73e23b91", "metadata": {}, "source": [ "- Now it's time to train our model:" ] }, { "cell_type": "code", "execution_count": 14, "id": "98e8453e", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/jovyan/conda/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/callback_connector.py:90: LightningDeprecationWarning: Setting `Trainer(progress_bar_refresh_rate=50)` is deprecated in v1.5 and will be removed in v1.7. Please pass `pytorch_lightning.callbacks.progress.TQDMProgressBar` with `refresh_rate` directly to the Trainer's `callbacks` argument instead. Or, to disable the progress bar pass `enable_progress_bar = False` to the Trainer.\n", " rank_zero_deprecation(\n", "GPU available: True, used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "-------------------------------------------\n", "0 | model | PyTorchModel | 9.1 K \n", "1 | train_acc | Accuracy | 0 \n", "2 | valid_acc | Accuracy | 0 \n", "3 | test_acc | Accuracy | 0 \n", "-------------------------------------------\n", "9.1 K Trainable params\n", "0 Non-trainable params\n", "9.1 K Total params\n", "0.036 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation sanity check: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "2849fb6cf586489999ff5ee0a66654df", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validating: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validating: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validating: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validating: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validating: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validating: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validating: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validating: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validating: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validating: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validating: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validating: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validating: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validating: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validating: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validating: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validating: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validating: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validating: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validating: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Training took 2.66 min in total.\n" ] } ], "source": [ "# %load ../code_lightningmodule/trainer_nb_basic.py\n", "import time\n", "\n", "\n", "trainer = pl.Trainer(\n", " max_epochs=NUM_EPOCHS,\n", " callbacks=callbacks,\n", " progress_bar_refresh_rate=50, # recommended for notebooks\n", " accelerator=\"auto\", # Uses GPUs or TPUs if available\n", " devices=\"auto\", # Uses all available GPUs/TPUs if applicable\n", " logger=logger,\n", " deterministic=False,\n", " log_every_n_steps=10,\n", ")\n", "\n", "start_time = time.time()\n", "trainer.fit(model=lightning_model, datamodule=data_module)\n", "\n", "runtime = (time.time() - start_time) / 60\n", "print(f\"Training took {runtime:.2f} min in total.\")" ] }, { "cell_type": "markdown", "id": "49555c2e", "metadata": {}, "source": [ "## Evaluating the model" ] }, { "cell_type": "markdown", "id": "94c99e88", "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": "5cb6a64e", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# %load ../code_lightningmodule/logger_csv_plot_basic.py\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "\n", "\n", "metrics = pd.read_csv(f\"{trainer.logger.log_dir}/metrics.csv\")\n", "\n", "aggreg_metrics = []\n", "agg_col = \"epoch\"\n", "for i, dfg in metrics.groupby(agg_col):\n", " agg = dict(dfg.mean())\n", " agg[agg_col] = i\n", " aggreg_metrics.append(agg)\n", "\n", "df_metrics = pd.DataFrame(aggreg_metrics)\n", "df_metrics[[\"train_loss\", \"valid_loss\"]].plot(\n", " grid=True, legend=True, xlabel=\"Epoch\", ylabel=\"Loss\"\n", ")\n", "df_metrics[[\"train_acc\", \"valid_acc\"]].plot(\n", " grid=True, legend=True, xlabel=\"Epoch\", ylabel=\"ACC\"\n", ")\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "2dcb96f0", "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": "4ee52559", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Restoring states from the checkpoint path at logs/my-model/version_1/checkpoints/epoch=15-step=6863.ckpt\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "Loaded model weights from checkpoint at logs/my-model/version_1/checkpoints/epoch=15-step=6863.ckpt\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "ac4f3c84e20a4fc38e24dfcb7e521c60", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Testing: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃        Test metric        ┃       DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│         test_acc          │    0.9865000247955322     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1m Test metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", "│\u001b[36m \u001b[0m\u001b[36m test_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.9865000247955322 \u001b[0m\u001b[35m \u001b[0m│\n", "└───────────────────────────┴───────────────────────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "[{'test_acc': 0.9865000247955322}]" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "trainer.test(model=lightning_model, datamodule=data_module, ckpt_path='best')" ] }, { "cell_type": "markdown", "id": "225cce7c", "metadata": {}, "source": [ "## Predicting labels of new data" ] }, { "cell_type": "markdown", "id": "7334a256", "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": "d29621f0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "logs/my-model/version_1/checkpoints/epoch=15-step=6863.ckpt\n" ] } ], "source": [ "path = trainer.checkpoint_callback.best_model_path\n", "print(path)" ] }, { "cell_type": "code", "execution_count": 18, "id": "b06512b7", "metadata": {}, "outputs": [], "source": [ "lightning_model = LightningModel.load_from_checkpoint(path, model=pytorch_model)\n", "lightning_model.eval();" ] }, { "cell_type": "markdown", "id": "0c5b0803", "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": "c0d62c53", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tensor([1, 2, 3, 4, 5])" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# %load ../code_lightningmodule/datamodule_testloader.py\n", "test_dataloader = data_module.test_dataloader()\n", "acc = torchmetrics.Accuracy()\n", "\n", "for batch in test_dataloader:\n", " features, true_labels = batch\n", "\n", " with torch.no_grad():\n", " logits = lightning_model(features)\n", "\n", " predicted_labels = torch.argmax(logits, dim=1)\n", " acc(predicted_labels, true_labels)\n", "\n", "predicted_labels[:5]\n" ] }, { "cell_type": "markdown", "id": "e50fa7b1", "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": "018e99a8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Test accuracy: 0.9865 (98.65%)\n" ] } ], "source": [ "test_acc = acc.compute()\n", "print(f'Test accuracy: {test_acc:.4f} ({test_acc*100:.2f}%)')" ] }, { "cell_type": "markdown", "id": "e764010a", "metadata": {}, "source": [ "## Inspecting Failure Cases" ] }, { "cell_type": "markdown", "id": "1ba517ab", "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": "e93be369", "metadata": {}, "outputs": [], "source": [ "class_dict = {0: 'airplane',\n", " 1: 'automobile',\n", " 2: 'bird',\n", " 3: 'cat',\n", " 4: 'deer',\n", " 5: 'dog',\n", " 6: 'frog',\n", " 7: 'horse',\n", " 8: 'ship',\n", " 9: 'truck'}" ] }, { "cell_type": "code", "execution_count": 22, "id": "e72aa090", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# %load ../code_lightningmodule/plot_failurecases_basic.py\n", "# Append the folder that contains the\n", "# helper_data.py, helper_plotting.py, and helper_evaluate.py\n", "# files so we can import from them\n", "\n", "import sys\n", "\n", "sys.path.append(\"../../pytorch_ipynb\")\n", "\n", "from helper_plotting import show_examples\n", "\n", "\n", "show_examples(\n", " model=lightning_model, data_loader=test_dataloader, class_dict=class_dict\n", ")\n" ] }, { "cell_type": "markdown", "id": "363e4ef2", "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": "5d3b37b8", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# %load ../code_lightningmodule/plot_confusion-matrix_basic.py\n", "from torchmetrics import ConfusionMatrix\n", "import matplotlib\n", "from mlxtend.plotting import plot_confusion_matrix\n", "\n", "\n", "cmat = ConfusionMatrix(num_classes=len(class_dict))\n", "\n", "for x, y in test_dataloader:\n", "\n", " with torch.no_grad():\n", " pred = lightning_model(x)\n", " cmat(pred, y)\n", "\n", "cmat_tensor = cmat.compute()\n", "cmat = cmat_tensor.numpy()\n", "\n", "fig, ax = plot_confusion_matrix(\n", " conf_mat=cmat,\n", " class_names=class_dict.values(),\n", " norm_colormap=matplotlib.colors.LogNorm() \n", " # normed colormaps highlight the off-diagonals \n", " # for high-accuracy models better\n", ")\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 24, "id": "d066f028", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "torchmetrics : 0.6.2\n", "numpy : 1.22.2\n", "matplotlib : 3.3.4\n", "pytorch_lightning: 1.6.0.dev0\n", "pandas : 1.2.5\n", "torchvision : 0.11.2\n", "sys : 3.8.12 | packaged by conda-forge | (default, Oct 12 2021, 21:59:51) \n", "[GCC 9.4.0]\n", "torch : 1.10.1\n", "\n" ] } ], "source": [ "%watermark --iversions" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.12" } }, "nbformat": 4, "nbformat_minor": 5 }