chapter-8/Chapter_8_CGAN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 8: Conditional GAN\n",
    "\n",
    "Conditional GAN is a GAN variant presented in the paper [Conditional Generative Adversarial Nets](https://arxiv.org/abs/1411.1784) by *Mehdi Mirza* and *Simon Osindero*. This architecture allows to direct the generator what samples to create.\n",
    "\n",
    "The provided example in this notebook is using the MNIST dataset to train a generator and allows to tell the generator what number should be generated. The CGAN has the following architecture.\n",
    "![Architecture](img/architecture.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Imports\n",
    "\n",
    "Some PyTorch modules and classes are imported as well as `tqdm` to provide graphical feedback during training and `matplotlib` for plotting graphs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader, RandomSampler\n",
    "import torch.cuda as cuda\n",
    "from torchvision.datasets import MNIST\n",
    "from torchvision.transforms import Compose, ToTensor, Lambda\n",
    "\n",
    "from tqdm.notebook import tqdm\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading data\n",
    "\n",
    "We use the PyTorch data loading capabilities and define the function `get_z_vector` to get a latent vector $z$ of the desired length.\n",
    "\n",
    "The PyTorch `torchvision` package provides a convenient way to access the MNIST dataset. The images in the dataset come in the range $\\left[0, 255\\right]$ and are first converted to a tensor in the range $\\left[0.0, 1.0\\right]$ and finally normalized with `Lambda` to be in $\\left[-1.0, +1.0\\right]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A transform which results that the images are in the desired range\n",
    "trans = Compose([ToTensor(), Lambda(lambda x: x * 2 - 1)])\n",
    "\n",
    "# The actual MNIST dataset on which the transformation is applied\n",
    "train_set = MNIST('~/pytorch', train=True, transform=trans, download=True)\n",
    "\n",
    "# Function to get the latent vector z\n",
    "def get_z_vector(batch_size, length):\n",
    "    return torch.randn(batch_size, length)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Support CUDA\n",
    "\n",
    "In PyTorch GPU (CUDA) support is done explicitly by moving the tensors to the device. Therefore, we define the variable `device` which is used in the following code to execute the tensors on the GPU or CPU."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using cuda device for training\n"
     ]
    }
   ],
   "source": [
    "if cuda.is_available():\n",
    "    print(\"Using cuda device for training\")\n",
    "    device = 'cuda'\n",
    "else:\n",
    "    print(\"Using cpu for training\")\n",
    "    device = 'cpu'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generator\n",
    "\n",
    "The generator takes as input a latent vector $z$ and a label $y$ and converts it to an image.\n",
    "\n",
    "![Generator](img/generator.png)\n",
    "\n",
    "The input vector $z$ and a embedding of the label $embed(y)$ are elementwise multiplied before passed to `Linear` layer. This layer is than reshaped to a three dimensional feature map of shape $(256, 7, 7)$ before passed to transposed convolutional layers `ConvTranspose2d`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Generator(nn.Module):\n",
    "    def __init__(self, num_classes, z_dim):\n",
    "        super().__init__()\n",
    "        \n",
    "        # Embedding which outputs a vector of dimension z_dim\n",
    "        self.embed = nn.Embedding(num_classes, z_dim)\n",
    "        \n",
    "        # Linear combination of the latent vector z\n",
    "        self.dense = nn.Linear(z_dim, 7 * 7 * 256)\n",
    "        \n",
    "        # The transposed convolutional layers are wrapped in nn.Sequential\n",
    "        self.trans1 = nn.Sequential(\n",
    "            nn.ConvTranspose2d(256, 128, 3, stride=2, padding=1, output_padding=1),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.LeakyReLU())\n",
    "        \n",
    "        self.trans2 = nn.Sequential(\n",
    "            nn.ConvTranspose2d(128, 64, 3, stride=1, padding=1),\n",
    "            nn.BatchNorm2d(64),\n",
    "            nn.LeakyReLU())\n",
    "        \n",
    "        self.trans3 = nn.Sequential(\n",
    "            nn.ConvTranspose2d(64, 1, 3, stride=2, padding=1, output_padding=1),\n",
    "            nn.Tanh())\n",
    "        \n",
    "    def forward(self, z, label):\n",
    "        # Apply embedding to the input label\n",
    "        embedded_label = self.embed(label)\n",
    "        \n",
    "        # Element wise multiplication of latent vector and embedding\n",
    "        x = embedded_label * z\n",
    "        \n",
    "        # Application of dense layer and transforming to 3d shape\n",
    "        x = self.dense(x).view(-1, 256, 7, 7)\n",
    "        x = self.trans1(x)\n",
    "        x = self.trans2(x)\n",
    "        x = self.trans3(x)\n",
    "        \n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Discriminator\n",
    "\n",
    "The descriminator converts the inputs $(x, y)$ into a prediction $\\sigma$, which is the probablity that the input is sampled from a real distribution $p_{data}$. The architecture is shown in the image below.\n",
    "\n",
    "![Discriminator](img/discriminator.png)\n",
    "\n",
    "The discriminator embeds the label $embed(y)$ and concatinates it with the image $x$. After that, three `Conv2d` layers with `LeakyReLU` activation and `BatchNorm2d` follow. Note that the fist layer does not use batch normalization.\n",
    "\n",
    "At the end of the network a `Linear` layer is used with `Sigmoid` activation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Discriminator(nn.Module):\n",
    "    def __init__(self, num_classes, img_size):\n",
    "        super().__init__()\n",
    "\n",
    "        # Embedding which outputs a vector of img_size\n",
    "        self.embed = nn.Embedding(num_classes, img_size[0] * img_size[1])\n",
    "        \n",
    "        # It convenient to group conv layers with nn.Sequential\n",
    "        self.conv1 = nn.Sequential(\n",
    "            nn.Conv2d(2, 64, 3, stride=2, padding=1),\n",
    "            nn.LeakyReLU())\n",
    "        \n",
    "        self.conv2 = nn.Sequential(\n",
    "            nn.Conv2d(64, 64, 3, stride=2, padding=1),\n",
    "            nn.BatchNorm2d(64),\n",
    "            nn.LeakyReLU())\n",
    "        \n",
    "        self.conv3 = nn.Sequential(\n",
    "            nn.Conv2d(64, 128, 3, stride=2, padding=0),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.LeakyReLU())\n",
    "        \n",
    "        # The 3D feature map is flattened to perform a linear combination\n",
    "        self.dense = nn.Sequential(\n",
    "            nn.Flatten(),\n",
    "            nn.Linear(3 * 3 * 128, 1),\n",
    "            nn.Sigmoid())\n",
    "        \n",
    "    def forward(self, x, label):\n",
    "        # Apply embedding and convert to same shape as x\n",
    "        embedded_label = self.embed(label).view_as(x)\n",
    "        \n",
    "        # Concatenation of x and embedded label\n",
    "        x = torch.cat([x, embedded_label], dim=1)\n",
    "        \n",
    "        x = self.conv1(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.conv3(x)\n",
    "        x = self.dense(x)\n",
    "        \n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "NUM_CLASSES = 10\n",
    "Z_DIM = 100\n",
    "IMG_SIZE = (28, 28)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generator and discriminater are instantiated as well as an `Adam` optimizer for each model. The optimizing criteria for each model is a Binary Cross Entropy Loss `BCELoss`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generator is instantiated\n",
    "generator = Generator(NUM_CLASSES, Z_DIM).to(device)\n",
    "\n",
    "# Discriminator is instantiated\n",
    "discriminator = Discriminator(NUM_CLASSES, IMG_SIZE).to(device)\n",
    "\n",
    "# Discriminator and generator have their own optimizer\n",
    "g_optim = optim.Adam(generator.parameters(), lr=0.001)\n",
    "d_optim = optim.Adam(discriminator.parameters(), lr=0.001)\n",
    "\n",
    "# Binary cross entropy loss is used for discriminator and generator\n",
    "criterion = nn.BCELoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The train function instantiates a `RandomSampler` and `DataLoader` to iterate through the dataset randomly in batch sizes. The training of the generator and discriminator are performed as follows:\n",
    "\n",
    "1. The discriminator is trained to predict correctly for real images\n",
    "2. The discriminator is trained to predict correctly for fake images\n",
    "3. The generator is trained to force the discrimintor to predict incorrectly on fake images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(batch_size, iterations, sample_interval):\n",
    "    # A random sampler which will provide the indicies to the DataLoader\n",
    "    sampler = RandomSampler(train_set, replacement=True, num_samples=batch_size * iterations)\n",
    "\n",
    "    # The DataLoader which provides us batches of data samples\n",
    "    train_loader = DataLoader(train_set, batch_size=batch_size, sampler=sampler, drop_last=True)\n",
    "    \n",
    "    # Vectors for real (all one) and fake (all zero) labels\n",
    "    y_real = torch.ones(batch_size, 1).to(device)\n",
    "    y_fake = torch.zeros(batch_size, 1).to(device)\n",
    "\n",
    "    # The losses are recorded all sample_interval\n",
    "    losses = []\n",
    "\n",
    "    # Variables used for recording of losses\n",
    "    iteration = 0\n",
    "    d_loss = 0.0\n",
    "    g_loss = 0.0\n",
    "    \n",
    "    for x, labels in tqdm(train_loader):\n",
    "        # Tensors have to be moved to the desired device\n",
    "        x = x.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        #\n",
    "        # 1. Train discriminator on real images\n",
    "        #\n",
    "        \n",
    "        # Perform forward pass for real images and calculate loss\n",
    "        d_out = discriminator(x, labels)\n",
    "        d_loss_real = criterion(d_out, y_real)\n",
    "\n",
    "        # Optimize according to the calculated loss\n",
    "        d_optim.zero_grad()\n",
    "        d_loss_real.backward()\n",
    "        d_optim.step()\n",
    "\n",
    "        \n",
    "        #\n",
    "        # 2. Train discriminator on fake images\n",
    "        #\n",
    "        \n",
    "        # Generate fake images and perform forward pass for fake images and\n",
    "        # calculate loss\n",
    "        x_gen = generator(get_z_vector(batch_size, Z_DIM).to(device), labels)\n",
    "        d_out = discriminator(x_gen, labels)\n",
    "        d_loss_fake = criterion(d_out, y_fake)\n",
    "        \n",
    "        # Optimize according to the calculated loss\n",
    "        d_optim.zero_grad()\n",
    "        d_loss_fake.backward()\n",
    "        d_optim.step()\n",
    "        \n",
    "        #\n",
    "        # 3. Train generator to force discriminator making false predictions\n",
    "        #\n",
    "        \n",
    "        # Generate fake images and perform forward pass for fake images but\n",
    "        # real labels and calculate loss\n",
    "        x_gen = generator(get_z_vector(batch_size, Z_DIM).to(device), labels)\n",
    "        d_out = discriminator(x_gen, labels)\n",
    "        g_loss_real = criterion(d_out, y_real)\n",
    "        \n",
    "        # Optimize according to the calculated loss\n",
    "        g_optim.zero_grad()\n",
    "        g_loss_real.backward()\n",
    "        g_optim.step()\n",
    "\n",
    "        # Calculate discriminator and generator loss for visualization\n",
    "        d_loss += 0.5 * (d_loss_real + d_loss_fake).item()\n",
    "        g_loss += g_loss_real.item()\n",
    "\n",
    "        iteration += 1\n",
    "        \n",
    "        if iteration % sample_interval == 0:\n",
    "            # Calculate the loss for the last sample_interval iterations\n",
    "            d_loss = d_loss / sample_interval\n",
    "            g_loss = g_loss / sample_interval\n",
    "            \n",
    "            print(f\"D-Loss: {d_loss:.4f} G-Loss: {g_loss:.4f}\")\n",
    "            \n",
    "            # Add loss and reset for next iterations\n",
    "            losses.append((d_loss, g_loss))\n",
    "            d_loss = 0\n",
    "            g_loss = 0\n",
    "\n",
    "    return losses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Training is performed with a batch `batch_size=32`, `iterations=12000` and `sample_interval=1000`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ccc02fb348834b83b7b4cd71bd502d5a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=12000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D-Loss: 0.1308 G-Loss: 4.8754\n",
      "D-Loss: 0.2342 G-Loss: 3.4194\n",
      "D-Loss: 0.2532 G-Loss: 2.9811\n",
      "D-Loss: 0.2838 G-Loss: 2.8567\n",
      "D-Loss: 0.3105 G-Loss: 2.6349\n",
      "D-Loss: 0.3068 G-Loss: 2.5829\n",
      "D-Loss: 0.3039 G-Loss: 2.5526\n",
      "D-Loss: 0.3246 G-Loss: 2.5178\n",
      "D-Loss: 0.3188 G-Loss: 2.4922\n",
      "D-Loss: 0.3082 G-Loss: 2.6052\n",
      "D-Loss: 0.3023 G-Loss: 2.5696\n",
      "D-Loss: 0.3157 G-Loss: 2.5355\n",
      "\n"
     ]
    }
   ],
   "source": [
    "losses = train(batch_size=32, iterations=12000, sample_interval=1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualizations\n",
    "\n",
    "## Generator\n",
    "The visualization of the generator shows that the generator is capable to create convincing digits with variation that can be controlled with the label `y`. The functions is adapted from the book GANs in Action."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample_digits(generator, image_grid_rows=6, image_grid_columns=10):\n",
    "    # Sample random noise\n",
    "    z = get_z_vector(image_grid_rows * image_grid_columns, 100).to(device)\n",
    "\n",
    "    # Generate images from random noise\n",
    "    with torch.no_grad():\n",
    "        generator.eval()\n",
    "        gen_imgs = generator(z, torch.tensor([i for _ in range(image_grid_rows) for i in range(0, 10)], device=device)).cpu().detach().view(-1, 28, 28).numpy()\n",
    "        generator.train()\n",
    "\n",
    "    # Rescale image pixel values to [0, 1]\n",
    "    gen_imgs = 0.5 * gen_imgs + 0.5\n",
    "\n",
    "    # Set image grid\n",
    "    fig, axs = plt.subplots(image_grid_rows,\n",
    "                            image_grid_columns,\n",
    "                            figsize=(10, 6),\n",
    "                            sharey=True,\n",
    "                            sharex=True)\n",
    "\n",
    "    cnt = 0\n",
    "    for i in range(image_grid_rows):\n",
    "        for j in range(image_grid_columns):\n",
    "            # Output a grid of images\n",
    "            axs[i, j].imshow(gen_imgs[cnt, :, :], cmap='gray')\n",
    "            axs[i, j].axis('off')\n",
    "            cnt += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 60 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sample_digits(generator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generator and discriminator loss\n",
    "Visualization of the discriminator and generator loss while iterating through the batches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_losses(data):\n",
    "    checkpoints = range(0, len(data) * 1000, 1000)\n",
    "    plt.figure(figsize=(15,5))\n",
    "    plt.plot(checkpoints, [x[0] for x in data], label='Discriminator')\n",
    "    plt.plot(checkpoints, [x[1] for x in data], label='Generator')\n",
    "    plt.ylabel(\"Loss\")\n",
    "    plt.xlabel(\"Batches\")\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_losses(losses)"
   ]
  }
 ],
 "metadata": {
  "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.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}