Course 3/Week 1/Week 1 Data Augmentation.ipynb

{
 "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": null,
   "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",
    "<details>\n",
    "<summary>\n",
    "<font size=\"3\" color=\"green\">\n",
    "<b>Optional hints for <code><font size=\"4\">combine_sample</font></code></b>\n",
    "</font>\n",
    "</summary>\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",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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",
    "    fake_sample = torch.rand(len(real)) > p_real\n",
    "    target_images = real.clone()\n",
    "    target_images[fake_sample] = fake[fake_sample]\n",
    "    #### END CODE HERE ####\n",
    "    return target_images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Fc7mFIVRVT_2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your model had an accuracy of 52.0%\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.7, \"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": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "aLRFjtb_HEuP"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5d0958b8a3d242f4969edfba42bbacf3",
       "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": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "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": 13,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HpcnjIK_0WdF"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "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()]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}