09_adversarial_learning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creative machine learning - Adversarial learning\n",
    "\n",
    "### Author: Philippe Esling (esling@ircam.fr)\n",
    "\n",
    "Generative adversarial networks (GANs) are neural networks that generate material, such as images, music, speech, or text, that is similar to what humans produce.\n",
    "\n",
    "In this course we will cover\n",
    "1. The global principle of [adversarial learning](#adversarial)\n",
    "2. How to train your own GAN on a [toy dataset](#toy)\n",
    "3. A practical example on [MNIST](#mnist) using PyTorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"adversarial\"></a>\n",
    "## Adversarial learning\n",
    "\n",
    "This is the code used in first example of the article [Generative Adversarial Networks: Build Your First Models](https://realpython.com/generative-adversarial-networks/) on Real Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "from cml.plot import cml_figure_matplotlib as figure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generative adversarial networks (GANs) are machine learning systems that can learn to mimic a given distribution of data. GANs consist of two neural networks, one trained to *generate* data and the other trained to *discriminate* fake data from real data (hence the “adversarial” nature of the model).\n",
    "\n",
    "GANs require to define two neural networks, one called the *generator* and the other called the *discriminator*. The role of the generator is to estimate the probability distribution of the real samples in order to provide generated samples resembling real data. The discriminator, in turn, is trained to estimate the probability that a given sample came from the real data rather than being provided by the generator.\n",
    "\n",
    "These two networks define a *zero-sum game* as they are trained to compete with each other: the generator tries to get better at fooling the discriminator, while the discriminator tries to get better at identifying generated samples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training GANs on a toy dataset\n",
    "\n",
    "To understand how GAN training works, consider a toy example with a dataset composed of two-dimensional samples $(x_{1}, x_{2})$, with $x_{1}$ in the interval from $0$ to $2\\pi$ and $x_{2} = sin(x_{1})$, as illustrated in the following "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_data_length = 128\n",
    "train_data = torch.zeros((train_data_length,2))\n",
    "train_data[:,0] = 2*math.pi*torch.rand(train_data_length)\n",
    "train_data[:,1] = torch.sin(train_data[:,0])\n",
    "train_labels = torch.zeros(train_data_length)\n",
    "trainset = [(train_data[i], train_labels[i]) for i in range(train_data_length)]\n",
    "figure(5,8)\n",
    "plt.plot(train_data[:, 0], train_data[:, 1], '.')\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As usual, we need to define a `DataLoader` that will provide us with the training data in different batches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 32\n",
    "train_loader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we define the generator, which is fed with random data from a latent space. Its role is to generate data resembling the real samples. In this example, you have a two-dimensional latent space, so that the generator is fed with random $(z_{1}, z_{2})$ pairs and is required to transform them so that they resemble the real samples.\n",
    "\n",
    "We can define any type of network in the generator, given that it has sufficient complexity to generate the underlying type of data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Generator(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.model = nn.Sequential(\n",
    "            nn.Linear(2, 16),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(16, 32),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(32, 2),            \n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        output = self.model(x)\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "generator = Generator()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In turn, the discriminator is fed with either real samples from the training dataset or generated samples provided by the generator. Its role will be to estimate the probability that the input belongs to the real dataset or is a generated one. The training is performed so that the discriminator outputs 1 when it is fed a real sample and 0 when it is fed a generated sample. Again, we can choose any architecture of our liking for this network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Discriminator(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.model = nn.Sequential(\n",
    "            nn.Linear(2, 256),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.3),\n",
    "            nn.Linear(256, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.3),\n",
    "            nn.Linear(128, 64),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.3),\n",
    "            nn.Linear(64, 1),\n",
    "            nn.Sigmoid()\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        output = self.model(x)\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "discriminator = Discriminator()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now define our training hyper-parameters that will condition the learning procedure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr = 0.001\n",
    "num_epochs = 600\n",
    "loss_function = nn.BCELoss()\n",
    "optimizer_discriminator = torch.optim.Adam(discriminator.parameters(), lr=lr)\n",
    "optimizer_generator = torch.optim.Adam(generator.parameters(), lr=lr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, our goal is to understand and implement the training procedure for this simple type of GAN.\n",
    "\n",
    "***\n",
    "\n",
    "<div class=\"alert alert-success\" markdown=\"1\" style=\"color:white; background-color: #013220; border-color: #03C03C\">\n",
    "\n",
    "> ### Question 1.1 - GAN Training implementation\n",
    "\n",
    "> We divide the training procedure into several steps that will all be successively applied within one iteration loop.\n",
    "\n",
    "> 1. Generate data from random latent positions\n",
    "> 2. Prepare the labels for training\n",
    "> 3. Apply training and loss for the discriminator\n",
    "> 4. Apply training and loss for the generator\n",
    "    \n",
    "</div>\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_d = torch.zeros(int(num_epochs / 10))\n",
    "loss_g = torch.zeros(int(num_epochs / 10))\n",
    "for epoch in range(num_epochs):\n",
    "    for n, (real_samples, _) in enumerate(train_loader):\n",
    "        \n",
    "        ######################\n",
    "        # YOUR CODE GOES HERE\n",
    "        ######################\n",
    "        ...\n",
    "\n",
    "    # Show loss\n",
    "    if epoch % 10 == 0 and n == batch_size - 1:\n",
    "        loss_d[int(epoch / 10)] = loss_discriminator\n",
    "        loss_g[int(epoch / 10)] = loss_generator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we look at the evolution of different losses, we can clearly see the competing nature of both networks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,8))\n",
    "plt.plot(loss_d.detach())\n",
    "plt.plot(loss_g.detach())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can visualize the samples that can be generated by drawing some random latent positions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "latent_space_samples = torch.randn(100, 2)\n",
    "generated_samples = generator(latent_space_samples)\n",
    "generated_samples = generated_samples.detach()\n",
    "plt.figure(figsize=(10,8))\n",
    "plt.plot(generated_samples[:,0], generated_samples[:,1], '.')\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, the randomly generated points closely follow the original distribution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Handwritten digits generator with GAN\n",
    "\n",
    "Generative adversarial networks can also generate high-dimensional samples such as images. In this example, we are going to define a GAN to generate images of handwritten digits. For that, we will train the models using the infamous MNIST dataset. \n",
    "\n",
    "Again, we are going to make use of `torch` and `torchvision` . Notably, we will use `transforms` to obtain the training data and perform image conversions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn, optim\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since this example uses images in the training set, the models need to be more complex, with a larger number of parameters. This makes the training process slower, taking about two minutes per epoch when running on CPU. To reduce the training time, you can use a GPU to train the model if you have one available. The following piece of code allows to automatically select the best device available on your system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = ''\n",
    "if torch.cuda.is_available():\n",
    "    device = torch.device('cuda')\n",
    "else:\n",
    "    device = torch.device('cpu')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preparing the training data\n",
    "\n",
    "The MNIST dataset consists of 28 × 28 pixel grayscale images of handwritten digits from 0 to 9. To use them with PyTorch, we need to convert them to Tensors. Also, in order to ensure adequate learning, it is always best to normalize the data. This is were we make use of `torchvision.transforms` in order to perfom thesse automatically while loading the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "transform = transforms.Compose(\n",
    "    [transforms.ToTensor(),\n",
    "     transforms.Normalize((0.5,), (0.5,))])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, as usual, we can load both the *training* and *testing* data with the datasets objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 32\n",
    "# Load the training set\n",
    "train_set = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)\n",
    "# Create a batched data loader\n",
    "train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we plot some examples of the train set, to better understand the underlying data that we are working with."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(20,5))\n",
    "real_samples, mnist_labels = next(iter(train_loader))\n",
    "for i in range(16):\n",
    "    ax = plt.subplot(1, 16, i+1)\n",
    "    plt.imshow(real_samples[i].reshape(28, 28), cmap='gray_r')\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "plt.tight_layout()    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementing the discriminator and generator\n",
    "\n",
    "Here, we are going to first define our *discriminator*. In our case, we will use an MLP, that will be responsible for receiving the images and trying to find which images are fake. Here, we propose the converse exercise of the previous one, as you need to implement your own architecture before training it.\n",
    "\n",
    "***\n",
    "\n",
    "<div class=\"alert alert-success\" markdown=\"1\" style=\"color:white; background-color: #013220; border-color: #03C03C\">\n",
    "\n",
    "> ### Question 1.2 - Discriminator architecture\n",
    "\n",
    "> 1. Define an architecture of your choice for the discriminator\n",
    "> 2. (Optional) Compare the use of feed-forward and convolutional architectures.\n",
    "    \n",
    "</div>\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Discriminator(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "        ######################\n",
    "        # YOUR CODE GOES HERE\n",
    "        ######################\n",
    "        ...\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x.view(-1, 784)\n",
    "        output = self.model(x)\n",
    "        return output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To input the image coefficients into the MLP neural network, you vectorize them so that the neural network receives vectors with 784 coefficients. The vectorization occurs in the first line of `.forward()`, as the call to `x.view()` converts the shape of the input tensor. In this case, the original shape of the input x is 32 × 1 × 28 × 28, where 32 is the batch size you’ve set up. After the conversion, the shape of x becomes 32 × 784, with each line representing the coefficients of an image of the training set.\n",
    "\n",
    "To run the discriminator model using the GPU, you have to instantiate it and send it to the GPU with .to(). To use a GPU when there’s one available, you can send the model to the device object you created earlier:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "discriminator = Discriminator().to(device=device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the generator is going to generate more complex data, it’s necessary to increase the dimensions of the input from the latent space. In this case, the generator is going to be fed a 100-dimensional input and will provide an output with 784 coefficients, which will be organized in a 28 × 28 tensor representing an image. \n",
    "\n",
    "***\n",
    "\n",
    "<div class=\"alert alert-success\" markdown=\"1\" style=\"color:white; background-color: #013220; border-color: #03C03C\">\n",
    "\n",
    "> ### Question 1.3 - Generator architecture\n",
    "\n",
    "> 1. Define an architecture of your choice for the generator\n",
    "> 2. (Optional) Compare the use of feed-forward and convolutional architectures.\n",
    "    \n",
    "</div>\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Generator(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "        ######################\n",
    "        # YOUR CODE GOES HERE\n",
    "        ######################\n",
    "        ...\n",
    "\n",
    "    def forward(self, x):\n",
    "        #x = x.view(x.size(0), 100)\n",
    "        output = self.model(x)\n",
    "        output = output.view(x.size(0), 1, 28, 28)\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "generator = Generator().to(device=device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As usual, we define the training hyper-parameters that will condition our learning procedure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr = 0.0001\n",
    "num_epochs = 50\n",
    "loss_function = nn.BCELoss()\n",
    "optimizer_discriminator = torch.optim.Adam(discriminator.parameters(), lr=lr)\n",
    "optimizer_generator = torch.optim.Adam(generator.parameters(), lr=lr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "latent_space_samples_plot = torch.randn((16, 100)).to(device=device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "\n",
    "<div class=\"alert alert-success\" markdown=\"1\" style=\"color:white; background-color: #013220; border-color: #03C03C\">\n",
    "\n",
    "> ### Question 1.4 - Training procedure\n",
    "\n",
    "> 1. Implement the training procedure for the whole GAN\n",
    "\n",
    "**Note:** This implementation should be extremely similar to question 1.1\n",
    "    \n",
    "</div>\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load trained NN when it exists, or train a new NN\n",
    "if os.path.isfile('discriminator.pt') and os.path.isfile('generator.pt'):\n",
    "    discriminator.load_state_dict(torch.load('./discriminator.pt'))\n",
    "    generator.load_state_dict(torch.load('./generator.pt'))   \n",
    "else:\n",
    "    for epoch in range(num_epochs):\n",
    "        for n, (real_samples, _) in enumerate(train_loader):\n",
    "        \n",
    "            ######################\n",
    "            # YOUR CODE GOES HERE\n",
    "            ######################\n",
    "            ...\n",
    "\n",
    "            # Show loss\n",
    "            if n == batch_size - 1:\n",
    "                print(f\"Epoch: {epoch} Loss D.: {loss_discriminator}\")\n",
    "                print(f\"Epoch: {epoch} Loss G.: {loss_generator}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 900x600 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "latent_space_samples = torch.randn(batch_size, 100).to(device=device)\n",
    "\n",
    "generated_samples = generator(latent_space_samples)\n",
    "generated_samples = generated_samples.cpu().detach()\n",
    "\n",
    "plt.figure(dpi=150)\n",
    "for i in range(16):\n",
    "    ax = plt.subplot(4, 4, i+1)\n",
    "    plt.imshow(generated_samples[i].reshape(28, 28), cmap='gray_r')\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save trained NN parameters\n",
    "torch.save(generator.state_dict(), 'generator.pt')\n",
    "torch.save(discriminator.state_dict(), 'discriminator.pt')"
   ]
  }
 ],
 "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.9.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}