{ "cells": [ { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "1czVdIlqnImH" }, "source": [ "# Data Augmentation" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "1KD3ZgLs80vY" }, "source": [ "### Goals\n", "In this notebook you're going to build a generator that can be used to help create data to train a classifier. There are many cases where this might be useful. If you are interested in any of these topics, you are welcome to explore the linked papers and articles! \n", "\n", "- With smaller datasets, GANs can provide useful data augmentation that substantially [improve classifier performance](https://arxiv.org/abs/1711.04340). \n", "- You have one type of data already labeled and would like to make predictions on [another related dataset for which you have no labels](https://www.nature.com/articles/s41598-019-52737-x). (You'll learn about the techniques for this use case in future notebooks!)\n", "- You want to protect the privacy of the people who provided their information so you can provide access to a [generator instead of real data](https://www.ahajournals.org/doi/full/10.1161/CIRCOUTCOMES.118.005122). \n", "- You have [input data with many missing values](https://arxiv.org/abs/1806.02920), where the input dimensions are correlated and you would like to train a model on complete inputs. \n", "- You would like to be able to identify a real-world abnormal feature in an image [for the purpose of diagnosis](https://link.springer.com/chapter/10.1007/978-3-030-00946-5_11), but have limited access to real examples of the condition. \n", "\n", "In this assignment, you're going to be acting as a bug enthusiast — more on that later. \n", "\n", "### Learning Objectives\n", "1. Understand some use cases for data augmentation and why GANs suit this task.\n", "2. Implement a classifier that takes a mixed dataset of reals/fakes and analyze its accuracy." ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "wU8DDM6l9rZb" }, "source": [ "## Getting Started\n", "\n", "### Data Augmentation\n", "Before you implement GAN-based data augmentation, you should know a bit about data augmentation in general, specifically for image datasets. It is [very common practice](https://arxiv.org/abs/1712.04621) to augment image-based datasets in ways that are appropriate for a given dataset. This may include having your dataloader randomly flipping images across their vertical axis, randomly cropping your image to a particular size, randomly adding a bit of noise or color to an image in ways that are true-to-life. \n", "\n", "In general, data augmentation helps to stop your model from overfitting to the data, and allows you to make small datasets many times larger. However, a sufficiently powerful classifier often still overfits to the original examples which is why GANs are particularly useful here. They can generate new images instead of simply modifying existing ones.\n", "\n", "### CIFAR\n", "The [CIFAR-10 and CIFAR-100](https://www.cs.toronto.edu/~kriz/learning-features-2009-TR.pdf) datasets are extremely widely used within machine learning -- they contain many thousands of “tiny” 32x32 color images of different classes representing relatively common real-world objects like airplanes and dogs, with 10 classes in CIFAR-10 and 100 classes in CIFAR-100. In CIFAR-100, there are 20 “superclasses” which each contain five classes. For example, the “fish” superclass contains “aquarium fish, flatfish, ray, shark, trout”. For the purposes of this assignment, you’ll be looking at a small subset of these images to simulate a small data regime, with only 40 images of each class for training.\n", "\n", "![alt text](CIFAR.png)\n", "\n", "### Initializations\n", "You will begin by importing some useful libraries and packages and defining a visualization function that has been provided. You will also be re-using your conditional generator and functions code from earlier assignments. This will let you control what class of images to augment for your classifier." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "colab": {}, "colab_type": "code", "id": "JfkorNJrnmNO" }, "outputs": [], "source": [ "import torch\n", "import torch.nn.functional as F\n", "import matplotlib.pyplot as plt\n", "from torch import nn\n", "from tqdm.auto import tqdm\n", "from torchvision import transforms\n", "from torchvision.utils import make_grid\n", "from torch.utils.data import DataLoader\n", "torch.manual_seed(0) # Set for our testing purposes, please do not change!\n", "\n", "def show_tensor_images(image_tensor, num_images=25, size=(3, 32, 32), nrow=5, show=True):\n", " '''\n", " Function for visualizing images: Given a tensor of images, number of images, and\n", " size per image, plots and prints the images in an uniform grid.\n", " '''\n", " image_tensor = (image_tensor + 1) / 2\n", " image_unflat = image_tensor.detach().cpu()\n", " image_grid = make_grid(image_unflat[:num_images], nrow=nrow)\n", " plt.imshow(image_grid.permute(1, 2, 0).squeeze())\n", " if show:\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "P1A1M6kpnfxw" }, "source": [ "#### Generator" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "colab": {}, "colab_type": "code", "id": "EvO7h0LYnEJZ" }, "outputs": [], "source": [ "class Generator(nn.Module):\n", " '''\n", " Generator Class\n", " Values:\n", " input_dim: the dimension of the input vector, a scalar\n", " im_chan: the number of channels of the output image, a scalar\n", " (CIFAR100 is in color (red, green, blue), so 3 is your default)\n", " hidden_dim: the inner dimension, a scalar\n", " '''\n", " def __init__(self, input_dim=10, im_chan=3, hidden_dim=64):\n", " super(Generator, self).__init__()\n", " self.input_dim = input_dim\n", " # Build the neural network\n", " self.gen = nn.Sequential(\n", " self.make_gen_block(input_dim, hidden_dim * 4, kernel_size=4),\n", " self.make_gen_block(hidden_dim * 4, hidden_dim * 2, kernel_size=4, stride=1),\n", " self.make_gen_block(hidden_dim * 2, hidden_dim, kernel_size=4),\n", " self.make_gen_block(hidden_dim, im_chan, kernel_size=2, final_layer=True),\n", " )\n", "\n", " def make_gen_block(self, input_channels, output_channels, kernel_size=3, stride=2, final_layer=False):\n", " '''\n", " Function to return a sequence of operations corresponding to a generator block of DCGAN;\n", " a transposed convolution, a batchnorm (except in the final layer), and an activation.\n", " Parameters:\n", " input_channels: how many channels the input feature representation has\n", " output_channels: how many channels the output feature representation should have\n", " kernel_size: the size of each convolutional filter, equivalent to (kernel_size, kernel_size)\n", " stride: the stride of the convolution\n", " final_layer: a boolean, true if it is the final layer and false otherwise \n", " (affects activation and batchnorm)\n", " '''\n", " if not final_layer:\n", " return nn.Sequential(\n", " nn.ConvTranspose2d(input_channels, output_channels, kernel_size, stride),\n", " nn.BatchNorm2d(output_channels),\n", " nn.ReLU(inplace=True),\n", " )\n", " else:\n", " return nn.Sequential(\n", " nn.ConvTranspose2d(input_channels, output_channels, kernel_size, stride),\n", " nn.Tanh(),\n", " )\n", "\n", " def forward(self, noise):\n", " '''\n", " Function for completing a forward pass of the generator: Given a noise tensor, \n", " returns generated images.\n", " Parameters:\n", " noise: a noise tensor with dimensions (n_samples, input_dim)\n", " '''\n", " x = noise.view(len(noise), self.input_dim, 1, 1)\n", " return self.gen(x)\n", "\n", "\n", "def get_noise(n_samples, input_dim, device='cpu'):\n", " '''\n", " Function for creating noise vectors: Given the dimensions (n_samples, input_dim)\n", " creates a tensor of that shape filled with random numbers from the normal distribution.\n", " Parameters:\n", " n_samples: the number of samples to generate, a scalar\n", " input_dim: the dimension of the input vector, a scalar\n", " device: the device type\n", " '''\n", " return torch.randn(n_samples, input_dim, device=device)\n", "\n", "def combine_vectors(x, y):\n", " '''\n", " Function for combining two vectors with shapes (n_samples, ?) and (n_samples, ?)\n", " Parameters:\n", " x: (n_samples, ?) the first vector. \n", " In this assignment, this will be the noise vector of shape (n_samples, z_dim), \n", " but you shouldn't need to know the second dimension's size.\n", " y: (n_samples, ?) the second vector.\n", " Once again, in this assignment this will be the one-hot class vector \n", " with the shape (n_samples, n_classes), but you shouldn't assume this in your code.\n", " '''\n", " return torch.cat([x, y], 1)\n", "\n", "def get_one_hot_labels(labels, n_classes):\n", " '''\n", " Function for combining two vectors with shapes (n_samples, ?) and (n_samples, ?)\n", " Parameters:\n", " labels: (n_samples, 1) \n", " n_classes: a single integer corresponding to the total number of classes in the dataset\n", " '''\n", " return F.one_hot(labels, n_classes)" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "qRk_8azSq3tF" }, "source": [ "## Training\n", "Now you can begin training your models.\n", "First, you will define some new parameters:\n", "\n", "* cifar100_shape: the number of pixels in each CIFAR image, which has dimensions 32 x 32 and three channel (for red, green, and blue) so 3 x 32 x 32\n", "* n_classes: the number of classes in CIFAR100 (e.g. airplane, automobile, bird, cat, deer, dog, frog, horse, ship, truck)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "colab": {}, "colab_type": "code", "id": "UpfJifVcmMhJ" }, "outputs": [], "source": [ "cifar100_shape = (3, 32, 32)\n", "n_classes = 100" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "gJM9afuu0IuD" }, "source": [ "And you also include the same parameters from previous assignments:\n", "\n", " * criterion: the loss function\n", " * n_epochs: the number of times you iterate through the entire dataset when training\n", " * z_dim: the dimension of the noise vector\n", " * display_step: how often to display/visualize the images\n", " * batch_size: the number of images per forward/backward pass\n", " * lr: the learning rate\n", " * device: the device type" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "colab": {}, "colab_type": "code", "id": "sJlx2W71lUCv" }, "outputs": [], "source": [ "n_epochs = 10000\n", "z_dim = 64\n", "display_step = 500\n", "batch_size = 64\n", "lr = 0.0002\n", "device = 'cuda'" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "jltxAMd00TRE" }, "source": [ "Then, you want to set your generator's input dimension. Recall that for conditional GANs, the generator's input is the noise vector concatenated with the class vector." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "colab": {}, "colab_type": "code", "id": "tuSOzzpwlXl7" }, "outputs": [], "source": [ "generator_input_dim = z_dim + n_classes" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "ccQZRSYFXsHh" }, "source": [ "#### Classifier\n", "\n", "For the classifier, you will use the same code that you wrote in an earlier assignment (the same as previous code for the discriminator as well since the discriminator is a real/fake classifier)." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "colab": {}, "colab_type": "code", "id": "cVPxAjGSfYlX" }, "outputs": [], "source": [ "class Classifier(nn.Module):\n", " '''\n", " Classifier Class\n", " Values:\n", " im_chan: the number of channels of the output image, a scalar\n", " n_classes: the total number of classes in the dataset, an integer scalar\n", " hidden_dim: the inner dimension, a scalar\n", " '''\n", " def __init__(self, im_chan, n_classes, hidden_dim=32):\n", " super(Classifier, self).__init__()\n", " self.disc = nn.Sequential(\n", " self.make_classifier_block(im_chan, hidden_dim),\n", " self.make_classifier_block(hidden_dim, hidden_dim * 2),\n", " self.make_classifier_block(hidden_dim * 2, hidden_dim * 4),\n", " self.make_classifier_block(hidden_dim * 4, n_classes, final_layer=True),\n", " )\n", "\n", " def make_classifier_block(self, input_channels, output_channels, kernel_size=3, stride=2, final_layer=False):\n", " '''\n", " Function to return a sequence of operations corresponding to a classifier block; \n", " a convolution, a batchnorm (except in the final layer), and an activation (except in the final\n", " Parameters:\n", " input_channels: how many channels the input feature representation has\n", " output_channels: how many channels the output feature representation should have\n", " kernel_size: the size of each convolutional filter, equivalent to (kernel_size, kernel_size)\n", " stride: the stride of the convolution\n", " final_layer: a boolean, true if it is the final layer and false otherwise \n", " (affects activation and batchnorm)\n", " '''\n", " if not final_layer:\n", " return nn.Sequential(\n", " nn.Conv2d(input_channels, output_channels, kernel_size, stride),\n", " nn.BatchNorm2d(output_channels),\n", " nn.LeakyReLU(0.2, inplace=True),\n", " )\n", " else:\n", " return nn.Sequential(\n", " nn.Conv2d(input_channels, output_channels, kernel_size, stride),\n", " )\n", "\n", " def forward(self, image):\n", " '''\n", " Function for completing a forward pass of the classifier: Given an image tensor, \n", " returns an n_classes-dimension tensor representing fake/real.\n", " Parameters:\n", " image: a flattened image tensor with im_chan channels\n", " '''\n", " class_pred = self.disc(image)\n", " return class_pred.view(len(class_pred), -1)" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "tYXJTxM9pzZK" }, "source": [ "#### Pre-training (Optional)\n", "\n", "You are provided the code to pre-train the models (GAN and classifier) given to you in this assignment. However, this is intended only for your personal curiosity -- for the assignment to run as intended, you should not use any checkpoints besides the ones given to you." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "colab": {}, "colab_type": "code", "id": "UXptQZcwrBrq" }, "outputs": [], "source": [ "# This code is here for you to train your own generator or classifier \n", "# outside the assignment on the full dataset if you'd like -- for the purposes \n", "# of this assignment, please use the provided checkpoints\n", "class Discriminator(nn.Module):\n", " '''\n", " Discriminator Class\n", " Values:\n", " im_chan: the number of channels of the output image, a scalar\n", " (MNIST is black-and-white, so 1 channel is your default)\n", " hidden_dim: the inner dimension, a scalar\n", " '''\n", " def __init__(self, im_chan=3, hidden_dim=64):\n", " super(Discriminator, self).__init__()\n", " self.disc = nn.Sequential(\n", " self.make_disc_block(im_chan, hidden_dim, stride=1),\n", " self.make_disc_block(hidden_dim, hidden_dim * 2),\n", " self.make_disc_block(hidden_dim * 2, hidden_dim * 4),\n", " self.make_disc_block(hidden_dim * 4, 1, final_layer=True),\n", " )\n", "\n", " def make_disc_block(self, input_channels, output_channels, kernel_size=4, stride=2, final_layer=False):\n", " '''\n", " Function to return a sequence of operations corresponding to a discriminator block of the DCGAN; \n", " a convolution, a batchnorm (except in the final layer), and an activation (except in the final layer).\n", " Parameters:\n", " input_channels: how many channels the input feature representation has\n", " output_channels: how many channels the output feature representation should have\n", " kernel_size: the size of each convolutional filter, equivalent to (kernel_size, kernel_size)\n", " stride: the stride of the convolution\n", " final_layer: a boolean, true if it is the final layer and false otherwise \n", " (affects activation and batchnorm)\n", " '''\n", " if not final_layer:\n", " return nn.Sequential(\n", " nn.Conv2d(input_channels, output_channels, kernel_size, stride),\n", " nn.BatchNorm2d(output_channels),\n", " nn.LeakyReLU(0.2, inplace=True),\n", " )\n", " else:\n", " return nn.Sequential(\n", " nn.Conv2d(input_channels, output_channels, kernel_size, stride),\n", " )\n", "\n", " def forward(self, image):\n", " '''\n", " Function for completing a forward pass of the discriminator: Given an image tensor, \n", " returns a 1-dimension tensor representing fake/real.\n", " Parameters:\n", " image: a flattened image tensor with dimension (im_chan)\n", " '''\n", " disc_pred = self.disc(image)\n", " return disc_pred.view(len(disc_pred), -1)\n", "\n", "def train_generator():\n", " gen = Generator(generator_input_dim).to(device)\n", " gen_opt = torch.optim.Adam(gen.parameters(), lr=lr)\n", " discriminator_input_dim = cifar100_shape[0] + n_classes\n", " disc = Discriminator(discriminator_input_dim).to(device)\n", " disc_opt = torch.optim.Adam(disc.parameters(), lr=lr)\n", "\n", " def weights_init(m):\n", " if isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d):\n", " torch.nn.init.normal_(m.weight, 0.0, 0.02)\n", " if isinstance(m, nn.BatchNorm2d):\n", " torch.nn.init.normal_(m.weight, 0.0, 0.02)\n", " torch.nn.init.constant_(m.bias, 0)\n", " gen = gen.apply(weights_init)\n", " disc = disc.apply(weights_init)\n", "\n", " criterion = nn.BCEWithLogitsLoss()\n", " cur_step = 0\n", " mean_generator_loss = 0\n", " mean_discriminator_loss = 0\n", " for epoch in range(n_epochs):\n", " # Dataloader returns the batches and the labels\n", " for real, labels in dataloader:\n", " cur_batch_size = len(real)\n", " # Flatten the batch of real images from the dataset\n", " real = real.to(device)\n", "\n", " # Convert the labels from the dataloader into one-hot versions of those labels\n", " one_hot_labels = get_one_hot_labels(labels.to(device), n_classes).float()\n", "\n", " image_one_hot_labels = one_hot_labels[:, :, None, None]\n", " image_one_hot_labels = image_one_hot_labels.repeat(1, 1, cifar100_shape[1], cifar100_shape[2])\n", "\n", " ### Update discriminator ###\n", " # Zero out the discriminator gradients\n", " disc_opt.zero_grad()\n", " # Get noise corresponding to the current batch_size \n", " fake_noise = get_noise(cur_batch_size, z_dim, device=device)\n", " \n", " # Combine the vectors of the noise and the one-hot labels for the generator\n", " noise_and_labels = combine_vectors(fake_noise, one_hot_labels)\n", " fake = gen(noise_and_labels)\n", " # Combine the vectors of the images and the one-hot labels for the discriminator\n", " fake_image_and_labels = combine_vectors(fake.detach(), image_one_hot_labels)\n", " real_image_and_labels = combine_vectors(real, image_one_hot_labels)\n", " disc_fake_pred = disc(fake_image_and_labels)\n", " disc_real_pred = disc(real_image_and_labels)\n", "\n", " disc_fake_loss = criterion(disc_fake_pred, torch.zeros_like(disc_fake_pred))\n", " disc_real_loss = criterion(disc_real_pred, torch.ones_like(disc_real_pred))\n", " disc_loss = (disc_fake_loss + disc_real_loss) / 2\n", " disc_loss.backward(retain_graph=True)\n", " disc_opt.step() \n", "\n", " # Keep track of the average discriminator loss\n", " mean_discriminator_loss += disc_loss.item() / display_step\n", "\n", " ### Update generator ###\n", " # Zero out the generator gradients\n", " gen_opt.zero_grad()\n", "\n", " # Pass the discriminator the combination of the fake images and the one-hot labels\n", " fake_image_and_labels = combine_vectors(fake, image_one_hot_labels)\n", "\n", " disc_fake_pred = disc(fake_image_and_labels)\n", " gen_loss = criterion(disc_fake_pred, torch.ones_like(disc_fake_pred))\n", " gen_loss.backward()\n", " gen_opt.step()\n", "\n", " # Keep track of the average generator loss\n", " mean_generator_loss += gen_loss.item() / display_step\n", "\n", " if cur_step % display_step == 0 and cur_step > 0:\n", " print(f\"Step {cur_step}: Generator loss: {mean_generator_loss}, discriminator loss: {mean_discriminator_loss}\")\n", " show_tensor_images(fake)\n", " show_tensor_images(real)\n", " mean_generator_loss = 0\n", " mean_discriminator_loss = 0\n", " cur_step += 1\n", "\n", "def train_classifier():\n", " criterion = nn.CrossEntropyLoss()\n", " n_epochs = 10\n", "\n", " validation_dataloader = DataLoader(\n", " CIFAR100(\".\", train=False, download=True, transform=transform),\n", " batch_size=batch_size)\n", "\n", " display_step = 10\n", " batch_size = 512\n", " lr = 0.0002\n", " device = 'cuda'\n", " classifier = Classifier(cifar100_shape[0], n_classes).to(device)\n", " classifier_opt = torch.optim.Adam(classifier.parameters(), lr=lr)\n", " cur_step = 0\n", " for epoch in range(n_epochs):\n", " for real, labels in tqdm(dataloader):\n", " cur_batch_size = len(real)\n", " real = real.to(device)\n", " labels = labels.to(device)\n", "\n", " ### Update classifier ###\n", " # Get noise corresponding to the current batch_size\n", " classifier_opt.zero_grad()\n", " labels_hat = classifier(real.detach())\n", " classifier_loss = criterion(labels_hat, labels)\n", " classifier_loss.backward()\n", " classifier_opt.step()\n", "\n", " if cur_step % display_step == 0:\n", " classifier_val_loss = 0\n", " classifier_correct = 0\n", " num_validation = 0\n", " for val_example, val_label in validation_dataloader:\n", " cur_batch_size = len(val_example)\n", " num_validation += cur_batch_size\n", " val_example = val_example.to(device)\n", " val_label = val_label.to(device)\n", " labels_hat = classifier(val_example)\n", " classifier_val_loss += criterion(labels_hat, val_label) * cur_batch_size\n", " classifier_correct += (labels_hat.argmax(1) == val_label).float().sum()\n", "\n", " print(f\"Step {cur_step}: \"\n", " f\"Classifier loss: {classifier_val_loss.item() / num_validation}, \"\n", " f\"classifier accuracy: {classifier_correct.item() / num_validation}\")\n", " cur_step += 1\n" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "ZYGOiy-xWHOH" }, "source": [ "## Tuning the Classifier\n", "After two courses, you've probably had some fun debugging your GANs and have started to consider yourself a bug master. For this assignment, your mastery will be put to the test on some interesting bugs... well, bugs as in insects.\n", "\n", "As a bug master, you want a classifier capable of classifying different species of bugs: bees, beetles, butterflies, caterpillar, and more. Luckily, you found a great dataset with a lot of animal species and objects, and you trained your classifier on that.\n", "\n", "But the bug classes don't do as well as you would like. Now your plan is to train a GAN on the same data so it can generate new bugs to make your classifier better at distinguishing between all of your favorite bugs!\n", "\n", "You will fine-tune your model by augmenting the original real data with fake data and during that process, observe how to increase the accuracy of your classifier with these fake, GAN-generated bugs. After this, you will prove your worth as a bug master." ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "oSuAJTuYYr2o" }, "source": [ "#### Sampling Ratio\n", "\n", "Suppose that you've decided that although you have this pre-trained general generator and this general classifier, capable of identifying 100 classes with some accuracy (~17%), what you'd really like is a model that can classify the five different kinds of bugs in the dataset. You'll fine-tune your model by augmenting your data with the generated images. Keep in mind that both the generator and the classifier were trained on the same images: the 40 images per class you painstakingly found so your generator may not be great. This is the caveat with data augmentation, ultimately you are still bound by the real data that you have but you want to try and create more. To make your models even better, you would need to take some more bug photos, label them, and add them to your training set and/or use higher quality photos.\n", "\n", "To start, you'll first need to write some code to sample a combination of real and generated images. Given a probability, `p_real`, you'll need to generate a combined tensor where roughly `p_real` of the returned images are sampled from the real images. Note that you should not interpolate the images here: you should choose each image from the real or fake set with a given probability. For example, if your real images are a tensor of `[[1, 2, 3, 4, 5]]` and your fake images are a tensor of `[[-1, -2, -3, -4, -5]]`, and `p_real = 0.2`, two potential random return values are `[[1, -2, 3, -4, -5]]` or `[[-1, 2, -3, -4, -5]]`. \n", "\n", "\n", "Notice that `p_real = 0.2` does not guarantee that exactly 20% of the samples are real, just that when choosing an image for the combined set, there is a 20% probability that that image will be chosen from the real images, and an 80% probability that it will be selected from the fake images.\n", "\n", "In addition, we will expect the images to remain in the same order to maintain their alignment with their labels (this applies to the fake images too!). \n", "\n", "
\n", "\n", "\n", "Optional hints for combine_sample\n", "\n", "\n", "\n", "1. This code probably shouldn't be much longer than 3 lines\n", "2. You can index using a set of booleans which have the same length as your tensor\n", "3. You want to generate an unbiased sample, which you can do (for example) with `torch.rand(length_reals) > p`.\n", "4. There are many approaches here that will give a correct answer here. You may find [`torch.rand`](https://pytorch.org/docs/stable/generated/torch.rand.html) or [`torch.bernoulli`](https://pytorch.org/docs/master/generated/torch.bernoulli.html) useful. \n", "5. You don't want to edit an argument in place, so you may find [`cur_tensor.clone()`](https://pytorch.org/docs/stable/tensors.html) useful too, which makes a copy of `cur_tensor`. \n", "\n", "
" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "colab": {}, "colab_type": "code", "id": "16JJ7RlKxrsY" }, "outputs": [], "source": [ "# UNQ_C1 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n", "# GRADED FUNCTION: combine_sample\n", "def combine_sample(real, fake, p_real):\n", " '''\n", " Function to take a set of real and fake images of the same length (x)\n", " and produce a combined tensor with length (x) and sampled at the target probability\n", " Parameters:\n", " real: a tensor of real images, length (x)\n", " fake: a tensor of fake images, length (x)\n", " p_real: the probability the images are sampled from the real set\n", " '''\n", " #### START CODE HERE ####\n", " make_fake = torch.rand(len(real)) > p_real\n", " target_images = real.clone()\n", " target_images[make_fake] = fake[make_fake]\n", " #### END CODE HERE ####\n", " return target_images" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "colab": {}, "colab_type": "code", "id": "1kDmOc81zJGN" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Success!\n" ] } ], "source": [ "n_test_samples = 9999\n", "test_combination = combine_sample(\n", " torch.ones(n_test_samples, 1), \n", " torch.zeros(n_test_samples, 1), \n", " 0.3\n", ")\n", "# Check that the shape is right\n", "assert tuple(test_combination.shape) == (n_test_samples, 1)\n", "# Check that the ratio is right\n", "assert torch.abs(test_combination.mean() - 0.3) < 0.05\n", "# Make sure that no mixing happened\n", "assert test_combination.median() < 1e-5\n", "\n", "test_combination = combine_sample(\n", " torch.ones(n_test_samples, 10, 10), \n", " torch.zeros(n_test_samples, 10, 10), \n", " 0.8\n", ")\n", "# Check that the shape is right\n", "assert tuple(test_combination.shape) == (n_test_samples, 10, 10)\n", "# Make sure that no mixing happened\n", "assert torch.abs((test_combination.sum([1, 2]).median()) - 100) < 1e-5\n", "\n", "test_reals = torch.arange(n_test_samples)[:, None].float()\n", "test_fakes = torch.zeros(n_test_samples, 1)\n", "test_saved = (test_reals.clone(), test_fakes.clone())\n", "test_combination = combine_sample(test_reals, test_fakes, 0.3)\n", "# Make sure that the sample isn't biased\n", "assert torch.abs((test_combination.mean() - 1500)) < 100\n", "# Make sure no inputs were changed\n", "assert torch.abs(test_saved[0] - test_reals).sum() < 1e-3\n", "assert torch.abs(test_saved[1] - test_fakes).sum() < 1e-3\n", "\n", "test_fakes = torch.arange(n_test_samples)[:, None].float()\n", "test_combination = combine_sample(test_reals, test_fakes, 0.3)\n", "# Make sure that the order is maintained\n", "assert torch.abs(test_combination - test_reals).sum() < 1e-4\n", "if torch.cuda.is_available():\n", " # Check that the solution matches the input device\n", " assert str(combine_sample(\n", " torch.ones(n_test_samples, 10, 10).cuda(), \n", " torch.zeros(n_test_samples, 10, 10).cuda(),\n", " 0.8\n", " ).device).startswith(\"cuda\")\n", "print(\"Success!\")" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "LpMGXMYU1a4O" }, "source": [ "Now you have a challenge: find a `p_real` and a generator image such that your classifier gets an average of a 51% accuracy or higher on the insects, when evaluated with the `eval_augmentation` function. **You'll need to fill in `find_optimal` to find these parameters to solve this part!** Note that if your answer takes a very long time to run, you may need to hard-code the solution it finds. \n", "\n", "When you're training a generator, you will often have to look at different checkpoints and choose one that does the best (either empirically or using some evaluation method). Here, you are given four generator checkpoints: `gen_1.pt`, `gen_2.pt`, `gen_3.pt`, `gen_4.pt`. You'll also have some scratch area to write whatever code you'd like to solve this problem, but you must return a `p_real` and an image name of your selected generator checkpoint. You can hard-code/brute-force these numbers if you would like, but you are encouraged to try to solve this problem in a more general way. In practice, you would also want a test set (since it is possible to overfit on a validation set), but for simplicity you can just focus on the validation set." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "colab": {}, "colab_type": "code", "id": "Fc7mFIVRVT_2" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Your model had an accuracy of 51.9%\n", "Success!\n" ] } ], "source": [ "# UNQ_C2 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n", "# GRADED FUNCTION: find_optimal\n", "def find_optimal():\n", " # In the following section, you can write the code to choose your optimal answer\n", " # You can even use the eval_augmentation function in your code if you'd like!\n", " gen_names = [\n", " \"gen_1.pt\",\n", " \"gen_2.pt\",\n", " \"gen_3.pt\",\n", " \"gen_4.pt\"\n", " ]\n", "\n", " #### START CODE HERE #### \n", " best_p_real, best_gen_name = 0.6, \"gen_4.pt\"\n", " #### END CODE HERE ####\n", " return best_p_real, best_gen_name\n", "\n", "def augmented_train(p_real, gen_name):\n", " gen = Generator(generator_input_dim).to(device)\n", " gen.load_state_dict(torch.load(gen_name))\n", "\n", " classifier = Classifier(cifar100_shape[0], n_classes).to(device)\n", " classifier.load_state_dict(torch.load(\"class.pt\"))\n", " criterion = nn.CrossEntropyLoss()\n", " batch_size = 256\n", "\n", " train_set = torch.load(\"insect_train.pt\")\n", " val_set = torch.load(\"insect_val.pt\")\n", " dataloader = DataLoader(\n", " torch.utils.data.TensorDataset(train_set[\"images\"], train_set[\"labels\"]),\n", " batch_size=batch_size,\n", " shuffle=True\n", " )\n", " validation_dataloader = DataLoader(\n", " torch.utils.data.TensorDataset(val_set[\"images\"], val_set[\"labels\"]),\n", " batch_size=batch_size\n", " )\n", "\n", " display_step = 1\n", " lr = 0.0002\n", " n_epochs = 20\n", " classifier_opt = torch.optim.Adam(classifier.parameters(), lr=lr)\n", " cur_step = 0\n", " best_score = 0\n", " for epoch in range(n_epochs):\n", " for real, labels in dataloader:\n", " real = real.to(device)\n", " # Flatten the image\n", " labels = labels.to(device)\n", " one_hot_labels = get_one_hot_labels(labels.to(device), n_classes).float()\n", "\n", " ### Update classifier ###\n", " # Get noise corresponding to the current batch_size\n", " classifier_opt.zero_grad()\n", " cur_batch_size = len(labels)\n", " fake_noise = get_noise(cur_batch_size, z_dim, device=device)\n", " noise_and_labels = combine_vectors(fake_noise, one_hot_labels)\n", " fake = gen(noise_and_labels)\n", "\n", " target_images = combine_sample(real.clone(), fake.clone(), p_real)\n", " labels_hat = classifier(target_images.detach())\n", " classifier_loss = criterion(labels_hat, labels)\n", " classifier_loss.backward()\n", " classifier_opt.step()\n", "\n", " # Calculate the accuracy on the validation set\n", " if cur_step % display_step == 0 and cur_step > 0:\n", " classifier_val_loss = 0\n", " classifier_correct = 0\n", " num_validation = 0\n", " with torch.no_grad():\n", " for val_example, val_label in validation_dataloader:\n", " cur_batch_size = len(val_example)\n", " num_validation += cur_batch_size\n", " val_example = val_example.to(device)\n", " val_label = val_label.to(device)\n", " labels_hat = classifier(val_example)\n", " classifier_val_loss += criterion(labels_hat, val_label) * cur_batch_size\n", " classifier_correct += (labels_hat.argmax(1) == val_label).float().sum()\n", " accuracy = classifier_correct.item() / num_validation\n", " if accuracy > best_score:\n", " best_score = accuracy\n", " cur_step += 1\n", " return best_score\n", "\n", "def eval_augmentation(p_real, gen_name, n_test=20):\n", " total = 0\n", " for i in range(n_test):\n", " total += augmented_train(p_real, gen_name)\n", " return total / n_test\n", "\n", "best_p_real, best_gen_name = find_optimal()\n", "performance = eval_augmentation(best_p_real, best_gen_name)\n", "print(f\"Your model had an accuracy of {performance:0.1%}\")\n", "assert performance > 0.512\n", "print(\"Success!\")" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "mmqeeBjE32ls" }, "source": [ "You'll likely find that the worst performance is when the generator is performing alone: this corresponds to the case where you might be trying to hide the underlying examples from the classifier. Perhaps you don't want other people to know about your specific bugs!" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "colab": {}, "colab_type": "code", "id": "aLRFjtb_HEuP" }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "f3ec21e2eeae4e6dbcf11405ee893caf", "version_major": 2, "version_minor": 0 }, "text/plain": [ "HBox(children=(FloatProgress(value=0.0, max=21.0), HTML(value='')))" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "accuracies = []\n", "p_real_all = torch.linspace(0, 1, 21)\n", "for p_real_vis in tqdm(p_real_all):\n", " accuracies += [eval_augmentation(p_real_vis, best_gen_name, n_test=4)]\n", "plt.plot(p_real_all.tolist(), accuracies)\n", "plt.ylabel(\"Accuracy\")\n", "_ = plt.xlabel(\"Percent Real Images\")" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "e2j-xodd1ykT" }, "source": [ "Here's a visualization of what the generator is actually generating, with real examples of each class above the corresponding generated image. " ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "colab": {}, "colab_type": "code", "id": "HpcnjIK_0WdF" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "examples = [4, 41, 80, 122, 160]\n", "train_images = torch.load(\"insect_train.pt\")[\"images\"][examples]\n", "train_labels = torch.load(\"insect_train.pt\")[\"labels\"][examples]\n", "\n", "one_hot_labels = get_one_hot_labels(train_labels.to(device), n_classes).float()\n", "fake_noise = get_noise(len(train_images), z_dim, device=device)\n", "noise_and_labels = combine_vectors(fake_noise, one_hot_labels)\n", "gen = Generator(generator_input_dim).to(device)\n", "gen.load_state_dict(torch.load(best_gen_name))\n", "\n", "fake = gen(noise_and_labels)\n", "show_tensor_images(torch.cat([train_images.cpu(), fake.cpu()]))" ] } ], "metadata": { "accelerator": "GPU", "colab": { "collapsed_sections": [ "P1A1M6kpnfxw", "ccQZRSYFXsHh", "tYXJTxM9pzZK" ], "name": "C3W1_1: (Student) CIFAR Data Augmentation.ipynb", "provenance": [], "toc_visible": true }, "coursera": { "schema_names": [ "GANSC3-1A" ] }, "kernelspec": { "display_name": "Python 3", "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.6.9" } }, "nbformat": 4, "nbformat_minor": 1 }