diff options
Diffstat (limited to 'Fundamentals_of_Deep_Learning/05b_presidential_doggy_door.ipynb')
| -rw-r--r-- | Fundamentals_of_Deep_Learning/05b_presidential_doggy_door.ipynb | 1153 |
1 files changed, 1153 insertions, 0 deletions
diff --git a/Fundamentals_of_Deep_Learning/05b_presidential_doggy_door.ipynb b/Fundamentals_of_Deep_Learning/05b_presidential_doggy_door.ipynb new file mode 100644 index 0000000..b29a4bd --- /dev/null +++ b/Fundamentals_of_Deep_Learning/05b_presidential_doggy_door.ipynb @@ -0,0 +1,1153 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<center><a href=\"https://www.nvidia.com/dli\"> <img src=\"images/DLI_Header.png\" alt=\"Header\" style=\"width: 400px;\"/> </a></center>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5b. Transfer Learning" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So far, we have trained accurate models on large datasets, and also downloaded a pre-trained model that we used with no training necessary. But what if we cannot find a pre-trained model that does exactly what you need, and what if we do not have a sufficiently large dataset to train a model from scratch? In this case, there is a very helpful technique we can use called [transfer learning](https://blogs.nvidia.com/blog/2019/02/07/what-is-transfer-learning/).\n", + "\n", + "With transfer learning, we take a pre-trained model and retrain it on a task that has some overlap with the original training task. A good analogy for this is an artist who is skilled in one medium, such as painting, who wants to learn to practice in another medium, such as charcoal drawing. We can imagine that the skills they learned while painting would be very valuable in learning how to draw with charcoal. \n", + "\n", + "As an example in deep learning, say we have a pre-trained model that is very good at recognizing different types of cars, and we want to train a model to recognize types of motorcycles. A lot of the learnings of the car model would likely be very useful, for instance the ability to recognize headlights and wheels. \n", + "\n", + "Transfer learning is especially powerful when we do not have a large and varied dataset. In this case, a model trained from scratch would likely memorize the training data quickly, but not be able to generalize well to new data. With transfer learning, you can increase your chances of training an accurate and robust model on a small dataset." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5b.1 Objectives" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Prepare a pretrained model for transfer learning\n", + "* Perform transfer learning with your own small dataset on a pretrained model\n", + "* Further fine tune the model for even better performance" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "from torch.optim import Adam\n", + "from torch.utils.data import Dataset, DataLoader\n", + "import torchvision.transforms.v2 as transforms\n", + "import torchvision.io as tv_io\n", + "\n", + "import glob\n", + "import json\n", + "from PIL import Image\n", + "\n", + "import utils\n", + "\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "torch.cuda.is_available()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5b.2 A Personalized Doggy Door" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In our last exercise, we used a pre-trained [ImageNet](http://www.image-net.org/) model to let in all dogs, but keep out other animals. In this exercise, we would like to create a doggy door that only lets in a particular dog. In this case, we will make an automatic doggy door for a dog named Bo, the United States First Dog between 2009 and 2017. There are more pictures of Bo in the `data/presidential_doggy_door` folder." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<img src=\"data/presidential_doggy_door/train/bo/bo_10.jpg\">" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The challenge is that the pre-trained model was not trained to recognize this specific dog, and, we only have 30 pictures of Bo. If we tried to train a model from scratch using those 30 pictures we would experience overfitting and poor generalization. However, if we start with a pre-trained model that is adept at detecting dogs, we can leverage that learning to gain a generalized understanding of Bo using our smaller dataset. We can use transfer learning to solve this challenge." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5b.2.1 Downloading the Pretrained Model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The [ImageNet torchvision.models](https://pytorch.org/vision/stable/models.html) are often good choices for computer vision transfer learning, as they have learned to classify various different types of images. In doing this, they have learned to detect many different types of [features](https://developers.google.com/machine-learning/glossary#) that could be valuable in image recognition. Because ImageNet models have learned to detect animals, including dogs, it is especially well suited for this transfer learning task of detecting Bo.\n", + "\n", + "Let us start by downloading the pre-trained model." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from torchvision.models import vgg16\n", + "from torchvision.models import VGG16_Weights\n", + "\n", + "# load the VGG16 network *pre-trained* on the ImageNet dataset\n", + "weights = VGG16_Weights.DEFAULT\n", + "vgg_model = vgg16(weights=weights)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we are downloading, there is going to be an important difference. The last layer of an ImageNet model is a [dense layer](https://developers.google.com/machine-learning/glossary#dense-layer) of 1000 units, representing the 1000 possible classes in the dataset. In our case, we want it to make a different classification: is this Bo or not? We will add new layers to specifically recognize Bo." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "VGG(\n", + " (features): Sequential(\n", + " (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU(inplace=True)\n", + " (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU(inplace=True)\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (6): ReLU(inplace=True)\n", + " (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (8): ReLU(inplace=True)\n", + " (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (11): ReLU(inplace=True)\n", + " (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (13): ReLU(inplace=True)\n", + " (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (15): ReLU(inplace=True)\n", + " (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (18): ReLU(inplace=True)\n", + " (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (20): ReLU(inplace=True)\n", + " (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (22): ReLU(inplace=True)\n", + " (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (25): ReLU(inplace=True)\n", + " (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (27): ReLU(inplace=True)\n", + " (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (29): ReLU(inplace=True)\n", + " (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))\n", + " (classifier): Sequential(\n", + " (0): Linear(in_features=25088, out_features=4096, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Dropout(p=0.5, inplace=False)\n", + " (3): Linear(in_features=4096, out_features=4096, bias=True)\n", + " (4): ReLU(inplace=True)\n", + " (5): Dropout(p=0.5, inplace=False)\n", + " (6): Linear(in_features=4096, out_features=1000, bias=True)\n", + " )\n", + ")" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vgg_model.to(device)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5b.2.2 Freezing the Base Model\n", + "Before we add our new layers onto the [pre-trained model](https://developers.google.com/machine-learning/glossary#pre-trained-model), let's take an important step: freezing the model's pre-trained layers. This means that when we train, we will not update the base layers from the pre-trained model. Instead we will only update the new layers that we add on the end for our new classification. We freeze the initial layers because we want to retain the learning achieved from training on the ImageNet dataset. If they were unfrozen at this stage, we would likely destroy this valuable information. There will be an option to unfreeze and train these layers later, in a process called fine-tuning.\n", + "\n", + "Freezing the base layers is as simple as setting [requires_grad_](https://pytorch.org/docs/stable/generated/torch.Tensor.requires_grad.html) on the model to `False`." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "VGG16 Frozen\n" + ] + } + ], + "source": [ + "vgg_model.requires_grad_(False)\n", + "print(\"VGG16 Frozen\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5b.2.3 Adding New Layers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now add the new trainable layers to the pre-trained model. They will take the features from the pre-trained layers and turn them into predictions on the new dataset. We will add two layers to the model. In a previous lesson, we created our own [custom module](https://pytorch.org/tutorials/beginner/examples_nn/two_layer_net_module.html). A transfer learning module works in the exact same way. We can use is a layer in a [Sequential Model](https://pytorch.org/docs/stable/generated/torch.nn.Sequential.html).\n", + "\n", + "Then, we'll add a `Linear` layer connecting all `1000` of VGG16's outputs to `1` neuron." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Sequential(\n", + " (0): VGG(\n", + " (features): Sequential(\n", + " (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU(inplace=True)\n", + " (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU(inplace=True)\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (6): ReLU(inplace=True)\n", + " (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (8): ReLU(inplace=True)\n", + " (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (11): ReLU(inplace=True)\n", + " (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (13): ReLU(inplace=True)\n", + " (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (15): ReLU(inplace=True)\n", + " (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (18): ReLU(inplace=True)\n", + " (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (20): ReLU(inplace=True)\n", + " (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (22): ReLU(inplace=True)\n", + " (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (25): ReLU(inplace=True)\n", + " (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (27): ReLU(inplace=True)\n", + " (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (29): ReLU(inplace=True)\n", + " (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))\n", + " (classifier): Sequential(\n", + " (0): Linear(in_features=25088, out_features=4096, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Dropout(p=0.5, inplace=False)\n", + " (3): Linear(in_features=4096, out_features=4096, bias=True)\n", + " (4): ReLU(inplace=True)\n", + " (5): Dropout(p=0.5, inplace=False)\n", + " (6): Linear(in_features=4096, out_features=1000, bias=True)\n", + " )\n", + " )\n", + " (1): Linear(in_features=1000, out_features=1, bias=True)\n", + ")" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "N_CLASSES = 1\n", + "\n", + "my_model = nn.Sequential(\n", + " vgg_model,\n", + " nn.Linear(1000, N_CLASSES)\n", + ")\n", + "\n", + "my_model.to(device)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we want to verify that the VGG layers are frozen, we can loop through the model [parameters](https://pytorch.org/docs/stable/generated/torch.nn.parameter.Parameter.html). " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 False\n", + "1 False\n", + "2 False\n", + "3 False\n", + "4 False\n", + "5 False\n", + "6 False\n", + "7 False\n", + "8 False\n", + "9 False\n", + "10 False\n", + "11 False\n", + "12 False\n", + "13 False\n", + "14 False\n", + "15 False\n", + "16 False\n", + "17 False\n", + "18 False\n", + "19 False\n", + "20 False\n", + "21 False\n", + "22 False\n", + "23 False\n", + "24 False\n", + "25 False\n", + "26 False\n", + "27 False\n", + "28 False\n", + "29 False\n", + "30 False\n", + "31 False\n", + "32 True\n", + "33 True\n" + ] + } + ], + "source": [ + "for idx, param in enumerate(my_model.parameters()):\n", + " print(idx, param.requires_grad)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we did want to make the VGG layers trainable, we could take `vgg_model` and set `requires_grad_` to `True`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "VGG16 Unfrozen\n", + "0 True\n", + "1 True\n", + "2 True\n", + "3 True\n", + "4 True\n", + "5 True\n", + "6 True\n", + "7 True\n", + "8 True\n", + "9 True\n", + "10 True\n", + "11 True\n", + "12 True\n", + "13 True\n", + "14 True\n", + "15 True\n", + "16 True\n", + "17 True\n", + "18 True\n", + "19 True\n", + "20 True\n", + "21 True\n", + "22 True\n", + "23 True\n", + "24 True\n", + "25 True\n", + "26 True\n", + "27 True\n", + "28 True\n", + "29 True\n", + "30 True\n", + "31 True\n", + "32 True\n", + "33 True\n" + ] + } + ], + "source": [ + "vgg_model.requires_grad_(True)\n", + "print(\"VGG16 Unfrozen\")\n", + "for idx, param in enumerate(my_model.parameters()):\n", + " print(idx, param.requires_grad)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But for now, we'd only like to train our new layers, so we will turn training off." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "VGG16 Frozen\n" + ] + } + ], + "source": [ + "vgg_model.requires_grad_(False)\n", + "print(\"VGG16 Frozen\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5.2.4 Compiling the Model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As with our previous exercises, we need to compile the model with loss and metrics options. We have to make some different choices here. In previous cases we had many categories in our classification problem. As a result, we picked categorical crossentropy for the calculation of our loss. In this case we only have a binary classification problem (Bo or not Bo), and so we will use [binary crossentropy](https://pytorch.org/docs/stable/generated/torch.nn.BCELoss.html). Further detail about the differences between the two can found [here](https://gombru.github.io/2018/05/23/cross_entropy_loss/). We will also use binary accuracy instead of traditional accuracy.\n", + "\n", + "By setting `from_logits=True` we inform the [loss function](https://gombru.github.io/2018/05/23/cross_entropy_loss/) that the output values are not normalized (e.g. with softmax)." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "loss_function = nn.BCEWithLogitsLoss()\n", + "optimizer = Adam(my_model.parameters())\n", + "my_model = my_model.to(device)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5b.3 Data Augmentation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Just like in the previous lessons, we'll create a custom [Dataset](https://pytorch.org/tutorials/beginner/basics/data_tutorial.html) to read in picutes of Bo (and not Bo). First, we'll grab the list of preprocessing transforms from the VGG `weights`." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "pre_trans = weights.transforms()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5b.3.1 The Dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Rather than read from a DataFrame like in previous lessons, we will read image files directly and infer the `label` based on the filepath." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "DATA_LABELS = [\"bo\", \"not_bo\"] \n", + " \n", + "class MyDataset(Dataset):\n", + " def __init__(self, data_dir):\n", + " self.imgs = []\n", + " self.labels = []\n", + " \n", + " for l_idx, label in enumerate(DATA_LABELS):\n", + " data_paths = glob.glob(data_dir + label + '/*.jpg', recursive=True)\n", + " for path in data_paths:\n", + " img = Image.open(path)\n", + " self.imgs.append(pre_trans(img).to(device))\n", + " self.labels.append(torch.tensor(l_idx).to(device).float())\n", + "\n", + "\n", + " def __getitem__(self, idx):\n", + " img = self.imgs[idx]\n", + " label = self.labels[idx]\n", + " return img, label\n", + "\n", + " def __len__(self):\n", + " return len(self.imgs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5b.3.2 The DataLoaders" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have our custom Dataset class, let's create our [DataLoaders](https://pytorch.org/tutorials/beginner/basics/data_tutorial.html#preparing-your-data-for-training-with-dataloaders)." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "n = 32\n", + "\n", + "train_path = \"data/presidential_doggy_door/train/\"\n", + "train_data = MyDataset(train_path)\n", + "train_loader = DataLoader(train_data, batch_size=n, shuffle=True)\n", + "train_N = len(train_loader.dataset)\n", + "\n", + "valid_path = \"data/presidential_doggy_door/valid/\"\n", + "valid_data = MyDataset(valid_path)\n", + "valid_loader = DataLoader(valid_data, batch_size=n)\n", + "valid_N = len(valid_loader.dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5b.3.3 Data Augmentation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's apply some data augmentation so the model can have a better chance at recognizing Bo. This time, we have color images, so we can use [ColorJitter](https://pytorch.org/vision/stable/auto_examples/transforms/plot_transforms_illustrations.html#colorjitter) to full effect." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "IMG_WIDTH, IMG_HEIGHT = (224, 224)\n", + "\n", + "random_trans = transforms.Compose([\n", + " transforms.RandomRotation(25),\n", + " transforms.RandomResizedCrop((IMG_WIDTH, IMG_HEIGHT), scale=(.8, 1), ratio=(1, 1)),\n", + " transforms.RandomHorizontalFlip(),\n", + " transforms.ColorJitter(brightness=.2, contrast=.2, saturation=.2, hue=.2)\n", + "])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5b.4 The Training Loop" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will use most of the same training loop as before but with a few slight differences. First, our `get_batch_accuracy` function will be different because of using [Binary Cross Entropy](https://pytorch.org/docs/stable/generated/torch.nn.BCELoss.html) as our loss function. We could run the output through the [sigmoid](https://en.wikipedia.org/wiki/Sigmoid_function) function, but we can be more efficient by being mathematically observant.\n", + "\n", + "When our model `output` is greater than `0`, running it through the sigmoid function would be closer to `1`. When the model `output` is less than `0`, running it through the sigmoid function would be closer to `0`. Therefore, we only need to check if the model output is greater than ([gt](https://pytorch.org/docs/stable/generated/torch.gt.html)) `0` to see which class our prediction leans towards." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def get_batch_accuracy(output, y, N):\n", + " zero_tensor = torch.tensor([0]).to(device)\n", + " pred = torch.gt(output, zero_tensor)\n", + " correct = pred.eq(y.view_as(pred)).sum().item()\n", + " return correct / N" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also section to print the last set of gradients to show that only our newly added layers are learning." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "def train(model, check_grad=False):\n", + " loss = 0\n", + " accuracy = 0\n", + "\n", + " model.train()\n", + " for x, y in train_loader:\n", + " output = torch.squeeze(model(random_trans(x)))\n", + " optimizer.zero_grad()\n", + " batch_loss = loss_function(output, y)\n", + " batch_loss.backward()\n", + " optimizer.step()\n", + "\n", + " loss += batch_loss.item()\n", + " accuracy += get_batch_accuracy(output, y, train_N)\n", + " if check_grad:\n", + " print('Last Gradient:')\n", + " for param in model.parameters():\n", + " print(param.grad)\n", + " print('Train - Loss: {:.4f} Accuracy: {:.4f}'.format(loss, accuracy))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Uncomment the below to see a sample of the model's gradients. Because VGG16 ends in 1000 neurons, there are 1000 weights connected to the single neuron in the next layer. Many numbers will be printed!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#train(my_model, check_grad=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `validate` function mostly remains the same:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def validate(model):\n", + " loss = 0\n", + " accuracy = 0\n", + "\n", + " model.eval()\n", + " with torch.no_grad():\n", + " for x, y in valid_loader:\n", + " output = torch.squeeze(model(x))\n", + "\n", + " loss += loss_function(output, y.float()).item()\n", + " accuracy += get_batch_accuracy(output, y, valid_N)\n", + " print('Valid - Loss: {:.4f} Accuracy: {:.4f}'.format(loss, accuracy))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Moment of truth: can the model learn to recognize Bo?" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 0\n", + "Train - Loss: 3.4079 Accuracy: 0.5971\n", + "Valid - Loss: 0.4075 Accuracy: 0.8000\n", + "Epoch: 1\n", + "Train - Loss: 2.4120 Accuracy: 0.8561\n", + "Valid - Loss: 0.3867 Accuracy: 0.7667\n", + "Epoch: 2\n", + "Train - Loss: 1.4431 Accuracy: 0.8561\n", + "Valid - Loss: 0.2389 Accuracy: 0.9000\n", + "Epoch: 3\n", + "Train - Loss: 1.4507 Accuracy: 0.8777\n", + "Valid - Loss: 0.1866 Accuracy: 0.9333\n", + "Epoch: 4\n", + "Train - Loss: 1.2968 Accuracy: 0.8849\n", + "Valid - Loss: 0.1654 Accuracy: 0.9333\n", + "Epoch: 5\n", + "Train - Loss: 1.3198 Accuracy: 0.8993\n", + "Valid - Loss: 0.1708 Accuracy: 0.9333\n", + "Epoch: 6\n", + "Train - Loss: 1.3608 Accuracy: 0.8777\n", + "Valid - Loss: 0.2057 Accuracy: 0.9333\n", + "Epoch: 7\n", + "Train - Loss: 1.1708 Accuracy: 0.9065\n", + "Valid - Loss: 0.2482 Accuracy: 0.8667\n", + "Epoch: 8\n", + "Train - Loss: 1.0456 Accuracy: 0.8849\n", + "Valid - Loss: 0.2445 Accuracy: 0.9000\n", + "Epoch: 9\n", + "Train - Loss: 1.0627 Accuracy: 0.8849\n", + "Valid - Loss: 0.2520 Accuracy: 0.9000\n" + ] + } + ], + "source": [ + "epochs = 10\n", + "\n", + "for epoch in range(epochs):\n", + " print('Epoch: {}'.format(epoch))\n", + " train(my_model, check_grad=False)\n", + " validate(my_model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Discussion of Results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Both the training and validation accuracy should be quite high. This is a pretty awesome result! We were able to train on a small dataset, but because of the knowledge transferred from the ImageNet model, it was able to achieve high accuracy and generalize well. This means it has a very good sense of Bo and pets who are not Bo.\n", + "\n", + "If you saw some fluctuation in the validation accuracy, that is okay too. We have a technique for improving our model in the next section." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fine-Tuning the Model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that the new layers of the model are trained, we have the option to apply a final trick to improve the model, called [fine-tuning](https://developers.google.com/machine-learning/glossary#f). To do this we unfreeze the entire model, and train it again with a very small [learning rate](https://developers.google.com/machine-learning/glossary#learning-rate). This will cause the base pre-trained layers to take very small steps and adjust slightly, improving the model by a small amount. VGG16 is a relatively large model,so the small learning rate will also prevent overfitting.\n", + "\n", + "Note that it is important to only do this step after the model with frozen layers has been fully trained. The untrained linear layer that we added to the model earlier was randomly initialized. This means it needed to be updated quite a lot to correctly classify the images. Through the process of [backpropagation](https://developers.google.com/machine-learning/glossary#backpropagation), large initial updates in the last layers would have caused potentially large updates in the pre-trained layers as well. These updates would have destroyed those important pre-trained features. However, now that those final layers are trained and have converged, any updates to the model as a whole will be much smaller (especially with a very small learning rate) and will not destroy the features of the earlier layers.\n", + "\n", + "Let's try unfreezing the pre-trained layers, and then fine tuning the model:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Unfreeze the base model\n", + "vgg_model.requires_grad_(True)\n", + "optimizer = Adam(my_model.parameters(), lr=.000001)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 0\n", + "Train - Loss: 1.0264 Accuracy: 0.8849\n", + "Valid - Loss: 0.2614 Accuracy: 0.9000\n", + "Epoch: 1\n", + "Train - Loss: 1.4997 Accuracy: 0.8849\n", + "Valid - Loss: 0.2534 Accuracy: 0.9000\n" + ] + } + ], + "source": [ + "epochs = 2\n", + "\n", + "for epoch in range(epochs):\n", + " print('Epoch: {}'.format(epoch))\n", + " train(my_model, check_grad=False)\n", + " validate(my_model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this case, we'll only train for a few `epochs`. Because VGG16 is such a large model, it can overfit when it trains for too long on this dataset." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Examining the Predictions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have a well-trained model, it is time to create our doggy door for Bo! We can start by looking at the predictions that come from the model. We will preprocess the image in the same way we did for our last doggy door." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import matplotlib.image as mpimg\n", + "\n", + "def show_image(image_path):\n", + " image = mpimg.imread(image_path)\n", + " plt.imshow(image)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "def make_prediction(file_path):\n", + " show_image(file_path)\n", + " image = Image.open(file_path)\n", + " image = pre_trans(image).to(device)\n", + " image = image.unsqueeze(0)\n", + " output = my_model(image)\n", + " prediction = output.item()\n", + " return prediction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Try this out on a couple images to see the predictions:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-3.5513756275177" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "make_prediction('data/presidential_doggy_door/valid/bo/bo_20.jpg')" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8.907306671142578" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "make_prediction('data/presidential_doggy_door/valid/not_bo/121.jpg')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It looks like a negative number prediction means that it is Bo and a positive number prediction means it is something else. We can use this information to have our doggy door only let Bo in! " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise: Bo's Doggy Door" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Fill in the following code to implement Bo's doggy door:" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "def presidential_doggy_door(image_path):\n", + " pred = make_prediction(image_path)\n", + " if FIXME:\n", + " print(\"It's Bo! Let him in!\")\n", + " else:\n", + " print(\"That's not Bo! Stay out!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Click on the '...' below to see the solution." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "# SOLUTION\n", + "def presidential_doggy_door(image_path):\n", + " pred = make_prediction(image_path)\n", + " if pred < 0:\n", + " print(\"It's Bo! Let him in!\")\n", + " else:\n", + " print(\"That's not Bo! Stay out!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's try it out!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "presidential_doggy_door('data/presidential_doggy_door/valid/not_bo/131.jpg')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "presidential_doggy_door('data/presidential_doggy_door/valid/bo/bo_29.jpg')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Great work! With transfer learning, you have built a highly accurate model using a very small dataset. This can be an extremely powerful technique, and be the difference between a successful project and one that cannot get off the ground. We hope these techniques can help you out in similar situations in the future!\n", + "\n", + "There is a wealth of helpful resources for transfer learning in the [NVIDIA TAO Toolkit](https://developer.nvidia.com/tlt-getting-started)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Clear the Memory\n", + "Before moving on, please execute the following cell to clear up the GPU memory." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import IPython\n", + "app = IPython.Application.instance()\n", + "app.kernel.do_shutdown(True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Next" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So far, the focus of this workshop has primarily been on image classification. In the next section, in service of giving you a more well-rounded introduction to deep learning, we are going to switch gears and address working with sequential data, which requires a different approach." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<center><a href=\"https://www.nvidia.com/dli\"> <img src=\"images/DLI_Header.png\" alt=\"Header\" style=\"width: 400px;\"/> </a></center>" + ] + } + ], + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} |
