DCGAN_rectangular.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8a7EldJxII_3"
   },
   "source": [
    "# Abstract\n",
    "\n",
    "This notebook provides in-depth look at DCGANs, the motivation behind them, and a highly detailed overview of the optimization techniques and tricks necessary to stabilize training between a Generator/Discriminator pair. This is my implementation of [Radford et al, 2015](https://arxiv.org/abs/1511.06434) with the addition of techniques presented in [Improved GAN, Salimans et al 2016](https://arxiv.org/abs/1606.03498), [Spectral Normalization, Miyato et al 2018](https://arxiv.org/abs/1802.05957), and others. I stray from the common path and try to generate sort-of-HD CelebA images in their original, rectangular, 5:4 aspect ratio at 157x128. \n",
    "\n",
    "The GAN was first introduced in 2014 by [Goodfellow et al](https://arxiv.org/abs/1406.2661): A pair of two feed-forward networks - a Generator and Discriminator -  play a min-max game with each other in an attempt to learn the distribution of image training data and reconstruct it from low-dimensional Gaussian latent vectors.\n",
    "\n",
    "The GAN was quickly followed by the DCGAN by [Radford et al](https://arxiv.org/pdf/1511.06434v2), a GAN implemented with two separate CNN models. The DCGAN has since taken the mainstage for image generation tasks and has seen many improved iterations dealing with the stability of the min-max game played by the two opposing networks.\n",
    "\n",
    "The difficulty of training the GAN speaks for itself - once you give it a shot. Achieving stability in training and ensuring convergence to a nash equillibrium is not nearly as easy as it is made out to be by recent DCGAN papers implementing weight and image regularization techniques such as SELU and Spectral Norm. The plain DCGAN, even with contemporary regularization techniques, doesn't quite cut it in the state-of-the-art - but comes surprisingly close for its simplicity. Progressively Growing GANs and the MSG-GAN are some better, more recent candidates which build on the DCGAN to produce truly impressive results at higher resolutions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZKfq5PRc9-Pj"
   },
   "source": [
    "<!--TABLE OF CONTENTS-->\n",
    "# Table of Contents:\n",
    "- [Intro to GANs](#Intro-to-GANs)\n",
    "- [Dataset Setup & Inspection](#Dataset-Setup-&-Inspection)\n",
    "    - [Preprocess Images: Resize, Normalize](#Preprocess-Images:-Resize,-Normalize)\n",
    "- [Training a GAN](#Training-a-GAN)\n",
    "- [The DCGAN Architecture](#The-DCGAN-Architecture)\n",
    "- [Stabilizing a DCGAN: One Weird Trick(s)](#Stabilizing-a-DCGAN:-One-Weird-Trick)\n",
    "    - [Activation functions](#Activation-functions)\n",
    "    - [SELU and Self-Normalizing Neural Networks](#SELU-and-Self-Normalizing-Neural-Networks)\n",
    "    - [Spectral Normalization](#Spectral-Normalization)\n",
    "    - [Minibatch Standard Deviation](#Minibatch-Standard-Deviation)\n",
    "    - [Pixelwise Normalization](#Pixelwise-Normalization)\n",
    "    - [WGAN / Wasserstein Loss](#WGAN-/-Wasserstein-Loss)\n",
    "    - [Gaussian Instance Noise](#Gaussian-Instance-Noise)\n",
    "    - [Batch Size](#Batch-Size)\n",
    "    - [Latent Vector Dimension](#Latent-Vector-Dimension)\n",
    "- [Building a DCGAN](#Building-a-DCGAN)\n",
    "    - [Building the Generator Network](#Build-Generator-Network)\n",
    "    - [Building the Discriminator Network](#Build-Discriminator-Network)\n",
    "    - [Verifying Model Architecture](#Verify-Model-Architecture)\n",
    "    - [Choice of Optimizer and Loss Function](#Choice-of-Optimizer-and-Loss-Function)\n",
    "- [Training a DCGAN](#Training-a-DCGAN)\n",
    "    - [Making Training Utilities](#Make-Training-Utilities)\n",
    "    - [Building Training Loop](#Build-Training-Loop)\n",
    "    - [Tracking Progress with TensorBoard](#Track-Progress-with-TensorBoard)\n",
    "    - [Configuring Training Params & Training Model](#Configure-Training-Params-&-Train-Model)\n",
    "    - [Loading Pre-Trained Checkpoints to Resume Training](#Load-Pre-Trained-Checkpoints-to-Resume-Training)\n",
    "- [Testing Model](#Test-Model:-Generate-Images)\n",
    "  - [Image Generating Utilities](#Image-Generating-Utilities)\n",
    "  - [Generated Images and Checkpoint Progression](#Generated-Images-and-Checkpoint-Progression)\n",
    "- [Lessons Learned: How to Stabilize and Optimize a GAN](#Lessons-Learned:-How-to-Stabilize-and-Optimize-a-GAN)\n",
    "- [References](#References) \n",
    "\n",
    "<br>\n",
    "\n",
    "- [Appendix A](#Appendix-A)\n",
    "  - [Animating GAN Training Progress](#Animating-GAN-Training-Progress)\n",
    "  - [Spherical Interpolation](#Spherical-Interpolation)\n",
    "  - [CelebA Attributes](#CelebA-Attributes)\n",
    "  - [Wasserstein Loss: The WGAN](#Wasserstein-Loss:-The-WGAN)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Y585MOPUhanI"
   },
   "source": [
    "# Intro to GANs\n",
    "\n",
    "In this notebook I'm going to give a brief intro to Generative Adversial Networks (GANs) and an in-depth analysis of Deep Convolutional GANs (DCGANs) and their tuning.\n",
    "\n",
    "[GANs were first introduced by Goodfellow et al in 2014.](https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf)\n",
    "\n",
    "We can imagine any training data to lie in an n-dimensional space - for example, 28x28 images from MNIST\n",
    "can be sampled from a 28x28 = 784-dimensional space; each of 784 pixels in each image has a probability\n",
    "associated with all its possible values, i.e. pixel values in range [0,255]). **Hence, MNIST images can be represented by a probability distribution - one image is a point in a 784-dimensional space** \n",
    "\n",
    "<img src=\"img/bivariate gaussian distro.jpg\">\n",
    "\n",
    "<sub><center> A bivariate gaussian distribution of a 2 dimensional space. The height of the plot is the probability of a certain data point appearing. In reality, this plot would have many peaks and can only be visualized on a 784-dimensional MNIST image by first reducing its dimensionality (e.g. with PCA). Image by [Raghavendra Selvan](https://www.researchgate.net/project/Bayesian-Tracking-of-Multiple-Point-Targets)</center></sub>\n",
    "\n",
    "The idea is simple: Two networks act as adversaries - the generator (G) has the objective to fool the discriminator (D), while D has the objective to not be fooled.\n",
    "G samples data from a random distribution. D is fed either samples from G or samples from real training data and attempts to classify \n",
    "G's output as having come from the real training data distribution or not. \n",
    "\n",
    "\n",
    "**G is penalized by outputs which D accurately classifies as fakes; it thus learns to generate data as close\n",
    "as possible to the real training data distribution.** \n",
    "\n",
    "<img src=\"img/discriminator.png\">\n",
    "\n",
    "<sub><center>Generator training process; loss is based on discriminator's prediction on generated images. Figure adapted from [Google GAN overview](https://developers.google.com/machine-learning/gan/gan_structure)</center></sub>\n",
    "\n",
    "**D is penalized by incorrectly classifying fake inputs as real and vice versa; it thus learns to identify fake \n",
    "data; D's role is to provide feedback to and facilitate G's learning.**\n",
    "\n",
    "<img src=\"img/generator.png\">\n",
    "\n",
    "<sub><center> Discriminator training process; loss is based on discriminator's predictions on both fake and real images. Figure adapted from [Google GAN overview](https://developers.google.com/machine-learning/gan/gan_structure)</center></sub> \n",
    "\n",
    "\n",
    "\n",
    "For game theory enthusiasts, the generator-discriminator network pair are playing a [minimax game](https://en.wikipedia.org/wiki/Minimax) against each other; their objective function is the predictability of G's output. G tries to minimize predictability while D tries to maximize it.\n",
    "\n",
    "**When G reaches its optimal strategy, loss converges at a Nash equillibrium for both networks at a saddle point in the objective function representing their game.**\n",
    "\n",
    "According to Goodfellow et al, the networks' strategy converges when G recovers the training data as\n",
    "truthfully as possible and D can't distinguish between fake and real data, being 50% sure that anything G makes is real - and at this point neither G nor D can do their task any better.\n",
    "\n",
    "**Once G can generate such data, it will theoretically be able to generate images closely resembling real training data by sampling from a low-dimensional space.**\n",
    "\n",
    "Both networks can be trained by backpropogation; common implementations of generator-discriminator network pairs are \n",
    "multilayer perceptrons and CNNs. In this notebook, we'll implement the CNN-based GAN: the DCGAN\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "K52ZH9MUhanO"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import re\n",
    "import time\n",
    "import enum\n",
    "\n",
    "import cv2 as cv\n",
    "import numpy as np\n",
    "from scipy.special import expit\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torchvision.utils\n",
    "from torch import nn\n",
    "from torch.optim import Adam, AdamW, SGD\n",
    "from torchvision import transforms, datasets\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.tensorboard import SummaryWriter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "QRvcogx4h1Mw",
    "outputId": "4bd3cf47-d079-45ab-c408-737862a19a6f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mounted at /content/gdrive\n"
     ]
    }
   ],
   "source": [
    "# need to import files from google drive into colab \n",
    "from google.colab import drive\n",
    "drive.mount(\"/content/gdrive\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DIR2M0wZhanU"
   },
   "source": [
    "We'll try applying the GAN paradigm on the MNIST dataset, our objective being to generate real handwritten digits.\n",
    "\n",
    "\n",
    "Just kidding. [MNIST is no good for computer vision](https://twitter.com/fchollet/status/852594987527045120): Ian Goodfellow, the original author of GANs, and Francois Chollet, Keras author, give a few details in the above link to their twitter conversation: the gist is that **when you use MNIST, often good CV optimizations don't work, and bad ones do. So MNIST is a poor representation of CV tasks.**\n",
    "\n",
    "Instead, we're going to use CelebA: Celebrity Face Attributes by [Liu et al, 2015](http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Ftw1SpJhkOVB",
    "outputId": "93c948c4-c5d8-41d8-ed3b-f087c95230b9"
   },
   "outputs": [],
   "source": [
    "# copy CelebA dataset from (my) gdrive and unzip\n",
    "!cp '/content/gdrive/My Drive/DL/DCGAN/datasets1.zip' .\n",
    "!unzip -q datasets1.zip \n",
    "print('CelebA dataset loaded from gdrive')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QivMboAQvM9Q"
   },
   "source": [
    "# Dataset Setup & Inspection\n",
    "\n",
    "We can download the CelebA dataset using PyTorch directly, as below - but it usually errors due to a limitation with the gdrive where it is hosted. Instead, download it from the [CelebA homepage by Liu et al](http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html). More details on obtaining CelebA provided in code comments.\n",
    "\n",
    "We'll use torch.datasets.CelebA to make use of its built-in train set split, in place of torch.datasets.ImageFolder, which we would need for a custom dataset. We don't really need train and test sets here - but the **CelebA dataset does specify train/test/validation partition in a text file, so we'll use the training partition to make our results comparable to other DCGAN implementations trained on CelebA.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "id": "WYOU9kouhanV",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# CelebA (Celebrity Face Attributes), included with PyTorch\n",
    "# if you try to download fom PyTorch you may encounter an error \n",
    "# in that case download from official (Liu et al) baidu drive: https://pan.baidu.com/s/1CRxxhoQ97A5qbsKO7iaAJg\n",
    "# password \"rp0s\" for baidu drive\n",
    "# torch tries to download from (Liu et al) gdrive which has a limit on how many downloads it can provide \n",
    "# but try it out; you might get lucky. Otherwise, this function just loads from 'root' on disk\n",
    "class CelebA():\n",
    "    def __init__(self, split, transform=transforms.ToTensor()):\n",
    "        self.data = datasets.CelebA(root='./datasets/CelebA', split=split, download=True, transform=transform)\n",
    "        \n",
    "    def __getitem__(self, index):\n",
    "        x = self.data[index]\n",
    "        return x\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "7FFTcOuhL-DE",
    "outputId": "b43ea504-945d-42b5-d31a-fa306d460b91"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "CelebA: 162770 celebrity face training images.\n",
      "Images are size torch.Size([3, 218, 178]) (C,H,W)\n",
      "Pixel values are in range [0.0, 1.0]\n",
      "\n",
      "Labels are size torch.Size([40])\n",
      "CelebA attribute labels: tensor([0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1,\n",
      "        1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1])\n"
     ]
    }
   ],
   "source": [
    "# instantiate the dataset as an object \n",
    "dataset = CelebA(split='train', transform=transforms.ToTensor())\n",
    "\n",
    "# choose a batch size - 128 used in original DCGAN by Radford et al, but lower is better. More on this later.\n",
    "# I ultimately used a batch size of 32 which has been used by more recent DCGAN papers such as HDCGAN by Curto et al. \n",
    "# Create a PyTorch DataLoader object which returns CelebA images in shuffled batches of 32, \n",
    "# discarding the last batch of <32 images with drop_last=True\n",
    "dataloader = DataLoader(\n",
    "    dataset,\n",
    "    batch_size=32,\n",
    "    num_workers=1,\n",
    "    shuffle=True,\n",
    "    drop_last=True\n",
    ")\n",
    "\n",
    "# check dataset size\n",
    "print(f'CelebA: {dataset.__len__()} celebrity face training images.')\n",
    "\n",
    "# generate a batch of images from our dataloader\n",
    "batch = next(iter(dataloader))  \n",
    "\n",
    "# images in (C,H,W) format\n",
    "print(f'Images are size {batch[0].size()[1:]} (C,H,W)')\n",
    "# check pixel values \n",
    "print(f'Pixel values are in range [{torch.min((batch[0][0]))}, {torch.max((batch[0][0]))}]')\n",
    "\n",
    "# Check labels\n",
    "print(f'\\nLabels are size {batch[1].size()[1:]}')\n",
    "# should have 40 boolean labels\n",
    "print(f'CelebA attribute labels: {batch[1][0]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NkstdhRHPO13"
   },
   "source": [
    "We get ~160k images in the CelebA training set and our dataloader returns two tensors per batch - one with 32 RGB images, one with 32 labels. According to [Liu et al, 2015](http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html), images each have 40 boolean labels representing various visual attributes such as:\n",
    " - wearing a hat\n",
    " - pointy nose\n",
    " - wavy hair\n",
    " - sunglasses\n",
    " - and so forth. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Q5WJzUV-OpKp"
   },
   "source": [
    "# Preprocess Images: Resize, Normalize\n",
    "\n",
    "The dataset is loaded by TorchVision into a PIL Image with pixel values in range [0,255], while torch.transforms.ToTensor converts the PIL Image to a Float Tensor of shape (C,H,W) in range [0,1]. **We're going to want to normalize these images to [-1,1] before training the discriminator on them because the DCGAN generator uses tanh activation, producing images also in range [-1,1]. From [Radford et al, 2015](https://arxiv.org/pdf/1511.06434v2):** _\"We observed that using a bounded [tanh] activation [in the generator's final layer] allowed the model to learn more quickly to saturate and cover the color space of the training distribution.\"_\n",
    "\n",
    "We normalize pixels with _pixels = (pixels - mean) / stdev_. **I've seen some DCGAN implementations use a mean of 0.5 and stdev of 0.5 for all pixel values and image batch dimensions, which is incorrect**. The PyTorch image normalization documentation uses values of mean = (0.485, 0.456, 0.406), stdev = (0.229, 0.224, 0.225), which are the values from the [ImageNet dataset](http://www.image-net.org/) - which is the correct way to do it. We'll calculate the mean and stdev of each pixel dimension in (C,H,W) and use those to properly normalize the images to [-1,1].\n",
    "\n",
    "We use the aligned & cropped CelebA dataset, provided at 218x178. **We'll keep the 5:4 rectangular aspect ratio and resize the images to 157x128 to slightly lower the complexity of the required network, else we would require extra layers to upsample/downsample larger images.** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "VDrRs1zzFdaD",
    "outputId": "670844db-2b84-442c-b9b1-da60c18dee9c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100.000% processed\n",
      "Pixel Mean: tensor([0.5063, 0.4258, 0.3832]), Pixel Stdev: tensor([0.3107,0.2904,0.2897]\n"
     ]
    }
   ],
   "source": [
    "# Get real mean and stdev of each pixel dimension in (C,H,W) in the batch of 10k images\n",
    "# For reference, ImageNet uses mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]\n",
    "def get_stats(dataloader):\n",
    "    tot_pixels = 0\n",
    "    num_samples = 0\n",
    "    mean = torch.empty(3)\n",
    "    stdev = torch.empty(3)\n",
    "\n",
    "    for data in dataloader:\n",
    "        data = data[0]\n",
    "        b, c, h, w = data.shape\n",
    "        num_pixels = b * h * w\n",
    "        sum_ = torch.sum(data, dim=[0, 2, 3])\n",
    "        sum_of_square = torch.sum(data ** 2, dim=[0, 2, 3])\n",
    "        mean = (tot_pixels * mean + sum_) / (tot_pixels + num_pixels)\n",
    "        stdev = (tot_pixels * stdev + sum_of_square) / (tot_pixels + num_pixels)\n",
    "        num_samples += 1\n",
    "        tot_pixels += num_pixels\n",
    "        print('\\r'+f'{(num_samples / len(dataloader)*100):.3f}% processed',end='')\n",
    "\n",
    "    return mean, torch.sqrt(stdev - mean ** 2)\n",
    "\n",
    "mean, stdev = get_stats(dataloader)\n",
    "\n",
    "print(f'\\nPixel Mean: {mean}, Pixel Stdev: {stdev}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EXfxkhdWAoFJ"
   },
   "source": [
    "Close, but not exactly the same as ImageNet. **Certainly not (0.5,0.5,0.5) for both mean and stdev.** \n",
    "\n",
    "Now reload the dataset resized, and normalized to [-1,1] according to the values from the previous step. We'll create a composite transform using TorchVision for this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 491,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "02iX0v3AAmf5",
    "outputId": "2015d7fe-a00c-47c3-c59b-c4c6649b1a36"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "20096 pixels in each 157x128 RGB image\n",
      "Pixel values are in range [-1.0, 1.0]\n"
     ]
    }
   ],
   "source": [
    "# images are often represented by pixel brightness values in a range [0,255] \n",
    "# Normalizing pixel values to the [-1,1] range helps train GANs: see https://github.com/soumith/ganhacks\n",
    "# make a PyTorch function which moves PIL images to a tensor and normalizes them to [-1,1]:\n",
    "resize_normalize = transforms.Compose([\n",
    "        transforms.Resize(size=(157,128)),\n",
    "        transforms.ToTensor(),\n",
    "        #For reference, ImageNet uses mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]\n",
    "        transforms.Normalize(mean=[0.5063,0.4258, 0.3831], std=[0.3107,0.2904,0.2897], inplace=True)  \n",
    "    ])\n",
    "\n",
    "# instantiate the resized and normalized dataset  \n",
    "dataset = CelebA(split='train', transform=resize_normalize)\n",
    "\n",
    "# create a new dataloader with the processed dataset images\n",
    "dataloader = DataLoader(\n",
    "    dataset,\n",
    "    batch_size=32,\n",
    "    num_workers=1,\n",
    "    shuffle=True,\n",
    "    drop_last=True\n",
    ")\n",
    "\n",
    "# get a batch from the dataloader\n",
    "batch = next(iter(dataloader))\n",
    "\n",
    "# check that we've normalized to [-1,1] correctly by inspecting pixel dimensions\n",
    "# batch[0] --> (N,C,H,W); batch[0][0] --> (C,H,W) containing image pixel values \n",
    "# we want to make sure all pixels in all 3 RGB channels are between [-1,1], i.e. in (C,H,W)\n",
    "print(f'{batch[0][0][0].numel()} pixels in each {batch[0].size()[2]}x{batch[0].size()[3]} RGB image')\n",
    "print(f'Pixel values are in range [{torch.min((batch[0][0]))}, {torch.max((batch[0][0]))}]')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wry2wM6lhani"
   },
   "source": [
    "Looks good - 157x128 RGB images with pixels normalized to [-1,1].\n",
    "\n",
    "Let's look at the images:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 492,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 390
    },
    "id": "Pa0C5bPuhani",
    "outputId": "6ee005a5-33ae-4ee9-cd3c-85f6b406d900",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# get the images from the batch\n",
    "img = batch[0]\n",
    "\n",
    "# we'll visualize a 4x4 grid of images\n",
    "img_grid_size = 5\n",
    "img_grid = img[:img_grid_size**2] \n",
    "\n",
    "# make a grid of images from the tensor; normalize to [0,1] so all pixels are visible\n",
    "# make_grid pads images with 2 black pixels by default; set pad_value==white (1) so we can see a grid\n",
    "grid = torchvision.utils.make_grid(tensor=img_grid,nrow=img_grid_size, normalize=True,pad_value=1)\n",
    "\n",
    "# swap H,W dimensions for matplotlib's imshow() to work properly\n",
    "grid = np.moveaxis(grid.numpy(), 0, 2) \n",
    "\n",
    "# plot images \n",
    "plt.figure(figsize=(6, 6))\n",
    "plt.title(\"CelebA Samples\")\n",
    "# imshow plots axes with # of pixels by defaul|t\n",
    "plt.imshow(grid)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qGQJf5Khhanm"
   },
   "source": [
    "Those are faces alright, presumably of celebrities. \n",
    "\n",
    "And our dataset is ready to use."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0dBm8ujchanu"
   },
   "source": [
    "# Training a GAN\n",
    "Common implementations of generator-discriminator network pairs use\n",
    "multilayer perceptrons and CNNs.\n",
    "Both networks of a GAN can be trained by backpropogation of the error from the adversarial loss function, as introduced by [Goodfellow et al, 2014](https://arxiv.org/pdf/1406.2661.pdf):\n",
    "\n",
    "<img src=\"img/adversarial loss.GIF\"><sub><center>Image from Goodfellow et al, 2014.</center></sub>\n",
    "\n",
    "- _x_ is an image in (C,H,W) format. \n",
    "- _z_ is a vector constructed by sampling from  a latent space learned by the generator\n",
    "- _D(x)_ is the discriminator function which outputs the probability that _x_ comes from the distribution of the real training data. The function _D_ is simply a binary classifier - real data, or fake data.\n",
    "- _G(z)_ is the generator function, transforms the latent space vector _z_ to the same space as the training data (i.e. 3x32x32 for MNIST)\n",
    "- _p<sub>data</sub>_ is the probability distribution of the real training data\n",
    "- _p<sub>z</sub>_ is the probability distribution of the fake training data output by _G(z)_\n",
    "- _D(G(z))_ is the probability that G(z) is classfied same as real data, G(x)\n",
    "- D learns to output lim_D(x)_ -> 1, and lim_D(G(z))_ -> 0\n",
    "- D's objective is to maximize log(D(x)) - log probability of classifying real data as real data\n",
    "- G's objective is to minimize log(1-D(G(z))) - log inverted probability of classifying fake data as real data (i.e. prob of classifying fake data as fake data\n",
    "\n",
    "We use log probability so probabilities are additive (otherwise the product of probabilities would always approach 0). \n",
    "The GAN's loss function is then just binary cross-entropy over outputs from two batches of data; real and fake.\n",
    "In Goodfellow et al, the authors say that log(1-D(G(z)) saturates when G is poorly trained and D is well trained.\n",
    "According to [Arjovsky and Bottou, 2017](arxiv.org/pdf/1701.04862.pdf), if the discriminator is too good, then its loss gradients will vanish and so the generator will not learn: An optimized disciminator precludes the generator from making progress.\n",
    "\n",
    "**As such, in practice G is trained by maximizing log(D(G(z))** which provides higher gradients, faster training, and a lesser likelihood of a vanishing gradient. In sum: Instead of training the GAN to minimize D being correct, we train the GAN to maximize that D is incorrect.\n",
    "\n",
    "And that's it - that's the meat of the GAN, the adversarial loss function: just a doubled application of binary cross entropy.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "p1WiqYbmhanv"
   },
   "source": [
    "# The DCGAN Architecture\n",
    "It is identical to the original GAN architecture, but uses CNNs for both G and D (instead of dense MLPs).\n",
    " \n",
    "We should first understand transpose 2D convolutional layers, used for upsampling latent Gaussian vectors into 2D generated images. \n",
    "\n",
    "<img src=\"img/conv2dtranspose.gif\" width=500 height=500>\n",
    "<sub><center> Conv2D Fractionally Strided, i.e. Transpose Kernels; stacked across input channels, they create 3D Conv2D Transpose Filters</center></sub>\n",
    "\n",
    "Conv transpse is sort of like the opposite of maxpool; conv transpose layers increase dimensionality of their inputs.\n",
    "However, conv transpose is unlike maxpool in that it uses kernels with weights, as in regular Conv2D layers. **In transpose convolutional layers, we achieve upsampling by taking the product of _each_ (single) value in the input volume\n",
    "with each (of many) weights of the filter.** \n",
    "\n",
    "From [The original DCGAN by Radford et al](https://arxiv.org/abs/1511.06434), we build the discriminator CNN with:\n",
    " - Strided convolutions (CNN filters)\n",
    " - No Pooling layers \n",
    " - Batch Norm\n",
    " - LeakyReLU activation (ReLU that doesn't saturate below 0) for all layers \n",
    "\n",
    "We build the generator CNN with:\n",
    " - Fractional Strided Convolutions (Conv-Transpose Filters)\n",
    " - No Pooling layer\n",
    " - BatchNorm\n",
    " - ReLU activation for all layers except\n",
    " - Tanh only on output layer\n",
    "\n",
    "And they also suggest to avoid fully connected layers in deeper architectures. I've followed these guidelines and then made improvements on them, drawing from papers that followed the DCGAN such as [The Improved GAN, Salimans et al, 2016](https://arxiv.org/abs/1606.03498) and [Progressive Growing GANs, Karras et al, 2017](https://arxiv.org/abs/1710.10196).\n",
    "\n",
    "\n",
    "The input to the generator is a latent space vector _z_ sampled from a standard normal distribution. Its output is an image in standard (C,H,W) format. The Conv2D Transpose filters transform the 1D vector into a 3D volume,\n",
    "in direct and opposite analogy to the way regular Conv2D layers transform 3D inputs into 1D vectors, as will our discriminator.\n",
    "\n",
    "<img src=\"img/conv2d transpose.png\">\n",
    "\n",
    "<sub><center>Generator from Radford et al. A \"backwards\" CNN, where a 100-dimensional Gaussian vector is projected to 3D feature map representation by reshaping. Then transpose Conv2D layers transform the input vector into intermediate feature maps and eventually, an image.</center></sub>\n",
    "\n",
    "Notably, fully connected hidden layers are avoided. **I've used an FC linear layer to upsample the 100-dim input vector to the discriminator's input convolutional filter, while the discriminator 'flattens' its output by a final convolutional layer which produces a scalar.** \n",
    "\n",
    "Some DCGAN implementations use 1024 filters in the first discriminator and last generator layer - I found no improvement over 512 filters in that layer, with about half the model parameters required. [HDCGAN](https://arxiv.org/abs/1711.06491) used 64 filters in each of its layers - so **it seems that number of filters is less significant than other aspects of the network architecture, particularly normalization of output feature maps.**\n",
    "\n",
    "Finally, the original DCGAN uses sigmoid activation on the final discriminator layer along with regular binary cross entropy (BCE) loss. **However, I use BCE with logits and no sigmoid activation on the final discriminator layer, which is more numerically stable because we use the log-sum-exp (LSE) trick by combining a sigmoid layer and log-loss in one class.**\n",
    "\n",
    "----------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7hqDKZF_hanv"
   },
   "source": [
    "# Stabilizing a DCGAN: One Weird Trick\n",
    "Now we can define the GAN with some caveats. GANs in general, and especially DCGANs are notoriously unstable due to the competitive interplay between the Discriminator/Generator pair, which encourages weights to spiral out of control for one network to beat the other - and that is the case unless both networks are very carefully tuned. Some recent advances in GAN architecture will help:\n",
    "\n",
    "### Activation functions\n",
    "\n",
    "I found LeakyReLU to work best, as suggested in the original DCGAN paper. I tried ReLU - which lead to less stable loss dynamics and lower gradients - and SELU (Scaled Exponential Linear Unit) - which had its advantages, see below. \n",
    "\n",
    "Otherwise, I'm going to implement some tricks from recent years that were developed after DCGAN came out.  These are mostly normalization techniques - this is necessary so that the discriminator loss is stable and doesn't go to 0 - training collapse - when the discriminator learns too quickly and and the generator is left with zero information gain.  \n",
    "\n",
    "### SELU and Self-Normalizing Neural Networks \n",
    "Self-Normalizing Neural Networks (SNNs) were introduced by [Klambauer et al, 2017](https://arxiv.org/abs/1706.02515) with the SELU activation. They show that activations with close to zero mean and unit variance converge towards zero mean and unit variance as they are propogated through network layers. They show that there is an upper bound on activations that aren't close to zero mean and unit variance as well - so gradient issues become \"impossible\". SELU worked to normalize regular machine learning models and dense feedforward networks with many layers. \n",
    "\n",
    "<img src=\"img/SNN.GIF\"><sub><center>Loss on CIFAR-10 classificaiton task using FC feedforward networks, comparing BatchNorm vs SNN at different numbers of hidden layers. Image from [Klambauer et al, 2017](https://arxiv.org/pdf/1706.02515.pdf) </center></sub>\n",
    "\n",
    "In the [HDCGAN](https://arxiv.org/pdf/1711.06491.pdf), they found that using SELU in conjunction with [BatchNorm](https://arxiv.org/abs/1502.03167) results in model activations with mean close to 0 and variance close to 1. I took inspiration from this paper to try SELU here.\n",
    "\n",
    "\"[Using SELU+BatchNorm] ... given a sufficiently large sample size by the Central Limit Theorem, we can attain NASH equilibrium.\" -[Curto et al, 2020](https://arxiv.org/pdf/1711.06491.pdf)\n",
    "\n",
    "However, they found SELU not to work as well in practice, supposedly due to numerical errors introduced by GPU calculation - so they used BatchNorm to overcome this problem. They say this paradigm greatly increased convergence speed.\n",
    "\n",
    "**I found SELU activation + BatchNorm to work well, but not better than properly tuned LeakyReLU, and at a higher computational cost. I ultimately stuck with LeakyReLU. I attribute this result to the normalizing properties of Spectral Normalization + Batch Normalization - so SELU had little to work on. The idea is sound though - I suspect it will be much more important in larger (>512x512) DCGAN tasks.**\n",
    "\n",
    "### Spectral Normalization\n",
    "Proposed in [Miyato et al, 2018, Spectral Normalization for Generative Adversarial Networks](https://arxiv.org/abs/1802.05957). They find that Spectral Norm for model weights outperforms the use of gradient penalty for weight normalization in the WGAN-GP, and at lower computational cost. \n",
    "\n",
    "**Spectral Normalization constrains the [Lipschitz constant](https://en.wikipedia.org/wiki/Lipschitz_continuity) (uniform continuity) of the convolutional filters. In the discriminator, for example, discriminator(x) and discriminator(y) will be sufficiently close granted that distribution of (x) and (y) are sufficiently close, which stabilizes training.** \n",
    "\n",
    "<img src=\"img/specnorm.GIF\"><sub><center> Imapct of Spectral Normalization (SN) on CIFAR-10 image generation task (Inception score ~= generated image quality) at different Adam hyperparameters (lr, b1, b2) represented by A,B,C,D,E,F. SN makes GANs highly robust to hyperparameter choice. Image from [Miyato et al, 2018](https://arxiv.org/pdf/1802.05957.pdf) </center></sub>\n",
    "\n",
    "**With the global weight regularization of the discriminator using Spectral Normalization, we obtain more diverse generated images. I found this to be true, and to also help when added on the Generator.**\n",
    "\n",
    "### Minibatch Standard Deviation\n",
    "From [Salimans et al 2016, Improved Techniques for Training GANs](https://arxiv.org/abs/1606.03498), they introduce \n",
    "\"Minibatch discrimination\". The idea is to compute feature stats across entire minibatches (not just for each image) and append it to the feature map of each image within that minibatch, the aim being to have generated and real training images match more closely in their statistics. They implement it with a layer at the end of the discriminator which learns a tensor of weights to project the activation to an array of statistics which is used as a feature by the discriminator. [Karras et al, 2018 - Progressive Growing of GANs For Improved Quality, Stability, and Variation](https://arxiv.org/pdf/1710.10196.pdf) suggest a simpler approach they call \"Minibatch Standard Deviation\", without the weighted tensor. In their approach, **we take the standard deviations of each feature over the entire minibatch and average them, concatenating that to the minibatch as a single additional feature map. Goes on the last layer of the discriminator, before activation.** \n",
    "\n",
    "### Pixelwise Normalization\n",
    "Pixelwise Normalization is another technique suggested by [Karras et al, 2018](https://arxiv.org/pdf/1710.10196.pdf) in their progressively growing GANs paper. While we usually use BatchNorm in the generator after each conv2d layer, the progressive GAN instead uses pixelwise normalization to transform the feature vector of each pixel in each image to unit length after the last conv2d layer. I've also seen some implementations stack BatchNorm and pixelwise normalization. Karras et al say that pixelwise normalization does not harm the generator in any way, but does prevent activation magnitudes from spiralling out of control due to the competition between discriminator and generator. **In the implementation of pixelwise norm, each pixel in the feature map is simply divided by the L2 norm over that pixel's RGB channels; goes after BatchNorm in generator layers.**\n",
    "\n",
    "\n",
    "### WGAN / Wasserstein Loss\n",
    "I've discussed the WGAN above - and since the idea is to minimize the distance betwene the distribution of the training data and generated data, this should work great. Unfortunately,\n",
    "WGAN doesn't work as well as intended. For example, in [Mescheder et al, 2018, Which Training Methods for GANs do actually Converge?](https://arxiv.org/pdf/1801.04406.pdf), WGAN seems to fail to reach convergence and is outperformed in this regard by all other recent implementations - even the regular unregularized GAN authored by Goodfellow et al in 2014. \n",
    "\n",
    "WGAN loss is simple to implement:\n",
    "\n",
    "    Discriminator (Critic) Loss = [average critic score on real images] – [average critic score on fake images]\n",
    "    Generator Loss = -[average critic score on fake images]\n",
    "\n",
    "And we would then clip the weights of the discriminator to [-C, C] (using torch.clamp on model params) at every iteration simplying using to enforce a [Lipschitz constraint](https://en.wikipedia.org/wiki/Lipschitz_continuity) on the discriminator. C=0.05 worked OK for me but not at all great.\n",
    "\n",
    "From Mescehder et al, 2018: _\"Our\n",
    "findings show that neither Wasserstein GANs (WGANs) (Arjovsky et al., 2017) nor Wasserstein GANs with Gradient\n",
    "Penalty (WGAN-GP) (Gulrajani et al., 2017) converge on this simple example ... On the other hand, we show that instance noise (Sønderby\n",
    "et al., 2016; Arjovsky & Bottou, 2017) ... lead to local convergence_\"\n",
    "\n",
    "**WGANs aren't ideal. So I used instance noise instead as suggested by [Sonderby at al, 2016](https://arxiv.org/abs/1610.04490) and verified by [Mescheder et al, 2018](https://arxiv.org/pdf/1801.04406.pdf).** I implemented WGAN loss in the training loop to test it out - it didn't do me any favours.\n",
    "\n",
    "### Gaussian Instance Noise \n",
    "From [Sonderby et al, 2016](https://arxiv.org/abs/1610.04490), they propose (in the appendix) using instance noise in GANs to stabilize training. It's motivated by the lack of congruence between the supports of the generated and real training data. \n",
    "\n",
    "**I implemented instance noise by using 10% of the input tensor's pixel values as the standard deviation of noise added to that tensor from a normal (Gaussian) distribution.** \n",
    "\n",
    "### Batch Size\n",
    "Recent papers use smaller batch sizes, such as [HDCGAN](https://arxiv.org/pdf/1711.06491.pdf) with a batch size of 32. There are many more implementations using smaller batch sizes, and I found this to indeed work better than batch sizes of 128 or larger, especially when dealing with image resolutions larger than 64x64. **Smaller batch sizes should avoid the discriminator learning too quickly and overpowering the generator, especially early in training.**\n",
    "\n",
    "\n",
    "### Latent Vector Dimension\n",
    "The dimension of the latent space vector we give to the generator should determine the quality of its output. However, 100-dimensional latent vectors (_z_) are used in the original DCGAN by Radford et al and in a ton of DCGAN papers to this day. **This number can be reduced with little loss in quality, while higher latent vector dimension leads to higher computational cost with impereceptible improvements, if any.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "V1kGQrdv4OPP"
   },
   "source": [
    "**We'll implement and try out Gaussian instance noise, Spectral Normalization, Pixelwise Norm, and Minibatch Standard Deviation. We'll also try SELU activation.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qWZ-PdSRa6hZ"
   },
   "source": [
    "# Building a DCGAN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "id": "6Lunf8aE4NJI"
   },
   "outputs": [],
   "source": [
    "# simple addition layer of gaussian instance noise \n",
    "# suggested in https://arxiv.org/abs/1906.04612\n",
    "class GaussianNoise(nn.Module):\n",
    "    # sigma: sigma*pixel value = stdev of added noise from normal distribution \n",
    "    def __init__(self, sigma=0.1):\n",
    "        super().__init__()\n",
    "        self.sigma = sigma\n",
    "        self.register_buffer('noise', torch.tensor(0))\n",
    "\n",
    "    def forward(self, x):\n",
    "        if self.training and self.sigma != 0:\n",
    "            # scale of noise = stdev of gaussian noise = sigma * pixel value \n",
    "            scale = self.sigma * x.detach()\n",
    "            sampled_noise = self.noise.expand(*x.size()).float().normal_() * scale\n",
    "            x = x + sampled_noise\n",
    "        return x \n",
    "\n",
    "# spectralnorm constrains the Lipschitz constant (strong form of uniform continuity) of the convolutional filters \n",
    "# i.e. discriminator(x), discriminator(y) will be sufficiently close granted that distribution of (x) and (y) are sufficiently close \n",
    "# stabilizes the training of the| discriminator network. works well in practice, but slows down discriminator\n",
    "# may need to adust discriminator learning rate (2-4x greater than that of generator)\n",
    "class SpectralNorm(nn.Module):\n",
    "    def __init__(self, module):\n",
    "        super().__init__()\n",
    "        self.module = nn.utils.spectral_norm(module)\n",
    "    def forward(self, x):\n",
    "        return self.module(x)\n",
    "\n",
    "# From Progressively Growing GANs https://arxiv.org/abs/1710.10196\n",
    "# For every pixel in a feature map, divide that pixel \n",
    "# by the L2 norm over that pixel's channels\n",
    "# theoretically goes after batchnorm only in generator layers\n",
    "# didn't help my training \n",
    "class PixelwiseNorm(nn.Module):\n",
    "    def __init__(self, alpha=1e-8):\n",
    "        super().__init__()\n",
    "        self.alpha = alpha\n",
    "    def forward(self, x):\n",
    "        y = x.pow(2.).mean(dim=1, keepdim=True).add(self.alpha).sqrt()\n",
    "        y = x / y\n",
    "        return y\n",
    "\n",
    "# From Progressively Growing GANs https://arxiv.org/abs/1710.10196\n",
    "# Standard deviation of each feature in the activation map is calculated \n",
    "# and then averaged over the minibatch. \n",
    "# goes on the final layer of discriminator, just before activation\n",
    "# didn't find it to help my network and I wanted to reduce complexity for easier debugging\n",
    "class MinibatchStdDev(nn.Module):\n",
    "    def __init__(self, alpha=1e-8):\n",
    "        super().__init__()\n",
    "        self.alpha = alpha\n",
    "    def forward(self, x):\n",
    "        batch_size, _, height, width = x.shape\n",
    "        y = x - x.mean(dim=0, keepdim=True)\n",
    "        y = y.pow(2.).mean(dim=0, keepdim=False).add(self.alpha).sqrt()\n",
    "        y = y.mean().view(1, 1, 1, 1)\n",
    "        y = y.repeat(batch_size, 0, height, width)\n",
    "        y = torch.cat([x, y], 1)\n",
    "        return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cCihlB7Bhanw"
   },
   "source": [
    "## Build Generator Network\n",
    "\n",
    "Using all the tricks defined above. I'll make a base transpose convolutional layer and build off of that. The goal of the generator is to upsample a latent vecotr of 100 features up to a 3x157x128 image. **We transform the latent vector with a dense layer to 512x4x4 so that a 512-channel 4x4 kernel filter can take it as input. We also take care to not BatchNorm the last layer of the generator, and use tanh activation instead of SELU/ReLU.** We then proceed with transpose convolutional layers more or less as in a standard CNN. Some DCGAN implementations use dropout in the generator - I found this to actually hurt performance, but to give a moderate boost to diversity of generated images when used in the discriminator.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "id": "8TUBZ9yLhanw"
   },
   "outputs": [],
   "source": [
    "# dimension of the latent space vector we give to the generator\n",
    "# dim (100,) 1D array\n",
    "# 100 is used in a ton of GAN papers up to this day; this number can be reduced with little loss in quality\n",
    "# higher latent vector dim leads to higher computational cost\n",
    "latent_vector_dim = 100\n",
    "\n",
    "####################### GENERATOR CNN ############################################\n",
    "                                            # kernel to (5,4) for rectangular original CelebA aspect ratio, else (4,4)\n",
    "def conv2d_transpose_block(in_channels, out_channels, kernel=(5,4), stride=2, padding=1, noise=True, normalize=True, dropout=True, activation=False):\n",
    "    \n",
    "    # build the base conv2d layer for downsampling \n",
    "    conv2d_upsample = nn.ConvTranspose2d(\n",
    "                in_channels=in_channels, \n",
    "                out_channels=out_channels, \n",
    "                kernel_size=kernel, \n",
    "                stride=stride, \n",
    "                padding=padding, \n",
    "                bias=False)\n",
    "    \n",
    "    #  make a list of layers which we'll unpack when building the sequential model for the generator\n",
    "    layers = [SpectralNorm(conv2d_upsample)]\n",
    "   \n",
    "\n",
    "    # add a BatchNorm layer before activation (batchnorm not present on last layer of generator)\n",
    "    # Goodfellow has a talk where he says placement of activation does not matter w.r.t. BatchNorm\n",
    "    # Others have said that activation is better after batchnorm (Szegedy)\n",
    "    if normalize:\n",
    "        layers.append(nn.BatchNorm2d(out_channels))\n",
    "\n",
    "    # we only use gaussian noise in the discriminator; didn't help training to have it on generator\n",
    "    #if noise:\n",
    "    #    layers.append(GaussianNoise(out_channels))\n",
    "\n",
    "    # use only in D, didn't help here\n",
    "    #if dropout:\n",
    "    #    layers.append(nn.Dropout(0.3))\n",
    "\n",
    "    if activation:\n",
    "        layers.append(activation)\n",
    "    else:\n",
    "        # modify tensors in place to save VRAM when processing high res images\n",
    "        #nn.SELU(inplace=True)) works very well; however ReLU trained faster\n",
    "        layers.append(nn.ReLU(inplace=True))\n",
    "\n",
    "    return layers\n",
    "\n",
    "\n",
    "class ConvolutionalGenerativeNet(nn.Module):\n",
    "\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "        # linear layer of generator takes 1D latent vector dim to generator image input volume dim \n",
    "        # generator input volume dim == 512x4x4: 512 input filters and 4x4 kernel size \n",
    "        self.linear = nn.Linear(latent_vector_dim, 512 * (4*4))\n",
    "        \n",
    "        # unpack layers from conv2d_transpose_block for the transpose (upsampling) conv layers\n",
    "        self.generator = nn.Sequential(\n",
    "            *conv2d_transpose_block(512,512),\n",
    "            *conv2d_transpose_block(512,256),\n",
    "            *conv2d_transpose_block(256,128),\n",
    "            *conv2d_transpose_block(128,64),\n",
    "            # padding to (2,1) on last layer for rectangular 218x178 (resized to 157x128) original CelebA size\n",
    "            *conv2d_transpose_block(64,3, padding=(2,1), normalize=False, dropout=False, noise=False, activation=nn.Tanh())\n",
    "        )\n",
    "\n",
    "    def forward(self, latent_vector_batch):\n",
    "        \n",
    "        # pass 1D latent vectors through linaer layer to transform into input image volume dim 1024x4x4\n",
    "        latent_vector_batch = self.linear(latent_vector_batch)\n",
    "        \n",
    "        # reshape into 3D volume 512x4x4 (input filter depth on 1st generator layer * kernel size)\n",
    "        latent_vector_batch = latent_vector_batch.view(latent_vector_batch.shape[0], 512, 4, 4)\n",
    "\n",
    "        return self.generator(latent_vector_batch)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FkSQ13nrhan3"
   },
   "source": [
    "## Build Discriminator Network\n",
    "\n",
    "A standard CNN, for all intents and purposes - plus some GAN tricks. \n",
    "\n",
    "The DCGAN paper by Radford et al doesn't use a final FC layer to flatten the feature map; instead, we flatten with a final conv2d layer. **We structure the network such that the final Conv2D layer receives a 512x4x4 feature map and passes a single 512x4x4 filter over it to output a tensor of size (1,1,1), i.e. a scalar value.**\n",
    "\n",
    "**Take care not to normalize the first or last layer. Spectral Normalization on all layers except the last one, which outputs a scalar. We use dropout on all layers except the last one, and I found that to improve the diversity of images created by the generator.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "id": "V8XLODabhan3"
   },
   "outputs": [],
   "source": [
    "############################# DISCRIMINATOR CNN ##########################################\n",
    "\n",
    "# make a function to create a conv2d block since first DCGAN layer doesn't use batchnorm\n",
    "# and last layer doesn't use ReLU (tanh in Radford et al, 2014)\n",
    "def conv2d_block(in_channels, out_channels, kernel=4, stride=2, padding=1, specnorm=True, normalize=True, noise=True, activation=False, dropout=True):\n",
    "    \n",
    "    # build the base conv2d layer for downsampling \n",
    "    conv2d_downsample =  nn.Conv2d(\n",
    "                in_channels=in_channels, \n",
    "                out_channels=out_channels,\n",
    "                kernel_size=kernel, \n",
    "                stride=stride, \n",
    "                padding=padding, \n",
    "                bias=False)\n",
    "    \n",
    "    # make a list of layers to unpack when building the sequential model for discriminator \n",
    "    # don't use specnorm in final layer which outputs scalar and simulates an FC layer\n",
    "    if specnorm:\n",
    "        layers = [SpectralNorm(conv2d_downsample)]\n",
    "    else:\n",
    "        layers = [(conv2d_downsample)]\n",
    "\n",
    "    # add a BatchNorm layer if desired\n",
    "    # but spectral norm replaces batch norm completely in discriminator; present in all layers \n",
    "    #if normalize:\n",
    "        # layers.append(nn.BatchNorm2d(out_channels))\n",
    "    \n",
    "    # Goodfellow has a talk where he says placement of activation does not matter w.r.t. BatchNorm\n",
    "    # Others have said that activation is better after batchnorm (such as Francois Chollet quoting Szegedy directly - easily google-able)\n",
    "    if activation:\n",
    "        layers.append(activation)\n",
    "    else:\n",
    "        # modify tensors in place to save VRAM when processing high res images\n",
    "        # SELU() worked well but is outperformed in speed by nn.LeakyReLU(0.2) \n",
    "        layers.append(nn.LeakyReLU(negative_slope=0.2, inplace=True))\n",
    " \n",
    "    # works well in discriminator with dropout p value in range [0.15,0.5]\n",
    "    if dropout:\n",
    "        layers.append(nn.Dropout(0.3))\n",
    "    \n",
    "    return layers\n",
    "\n",
    "class ConvolutionalDiscriminativeNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "        # 2nd last layer outputs (512), and the last layer applies a single 512 filter\n",
    "        # The DCGAN paper doesn't use a final FC layer; instead of FC dense layer to flatten, we  use a final conv2d layer \n",
    "        # the final conv2d layer replaces the FC layer because a single 512 filter will output (Kx1x1), i.e. a scalar value K\n",
    "        # we then pass K into sigmoid activation and the \"FC conv layer\"/\"flattening\" is complete\n",
    "        # unpack layers from conv2d_block for the regular (downsampling) conv layers\n",
    "        self.discriminator = nn.Sequential(\n",
    "            \n",
    "            # Gaussian noise with stdev 0.1 relative to input tensor\n",
    "            # Salimans et al used it in the output layer of D while OpenAI has it on the input\n",
    "            GaussianNoise(),\n",
    "            # no batch norm layer on layer 1 helps performance,\n",
    "            *conv2d_block(3, 64, normalize=False),\n",
    "            *conv2d_block(64, 128),\n",
    "            *conv2d_block(128, 256),\n",
    "            *conv2d_block(256, 512),\n",
    "            *conv2d_block(512, 512),\n",
    "            # Minibatch standard deviation as in Karras et al, on final layer\n",
    "            # MinibatchStdDev(),\n",
    "            # \"fake FC layer\": no batchnorm, no padding\n",
    "            # no Gaussian noise, batchnorm, dropout on last layer \n",
    "            # use BCELossWithLogits which implements sigmoid activation; so no activation on last layer \n",
    "            *conv2d_block(512, 1, noise=False, specnorm=False, normalize=False, padding=0, dropout=False),\n",
    "        )\n",
    "\n",
    "    def forward(self, batch):\n",
    "        return self.discriminator(batch)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6Iw8XQy-Eg_H"
   },
   "source": [
    "# Verify Model Architecture \n",
    "Let's make sure we correctly downsample our 3x157x128 images to a binary cross entropy-classifiable scalar, and upsample our gaussian latent vector (with 100 features total per image) to the original 3x157x128 image size. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "dFoF64bRtIGu",
    "outputId": "59937384-02bb-4dce-ba69-48d4252fb91b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DISCRIMINATOR ARCHITECTURE: Downsample Image dim==(3x157x128) to Scalar (1x1x1)\n",
      "----------------------------------------------------------------\n",
      "        Layer (type)               Output Shape         Param #\n",
      "================================================================\n",
      "     GaussianNoise-1          [-1, 3, 157, 128]               0\n",
      "            Conv2d-2           [-1, 64, 78, 64]           3,072\n",
      "      SpectralNorm-3           [-1, 64, 78, 64]               0\n",
      "         LeakyReLU-4           [-1, 64, 78, 64]               0\n",
      "           Dropout-5           [-1, 64, 78, 64]               0\n",
      "            Conv2d-6          [-1, 128, 39, 32]         131,072\n",
      "      SpectralNorm-7          [-1, 128, 39, 32]               0\n",
      "         LeakyReLU-8          [-1, 128, 39, 32]               0\n",
      "           Dropout-9          [-1, 128, 39, 32]               0\n",
      "           Conv2d-10          [-1, 256, 19, 16]         524,288\n",
      "     SpectralNorm-11          [-1, 256, 19, 16]               0\n",
      "        LeakyReLU-12          [-1, 256, 19, 16]               0\n",
      "          Dropout-13          [-1, 256, 19, 16]               0\n",
      "           Conv2d-14            [-1, 512, 9, 8]       2,097,152\n",
      "     SpectralNorm-15            [-1, 512, 9, 8]               0\n",
      "        LeakyReLU-16            [-1, 512, 9, 8]               0\n",
      "          Dropout-17            [-1, 512, 9, 8]               0\n",
      "           Conv2d-18            [-1, 512, 4, 4]       4,194,304\n",
      "     SpectralNorm-19            [-1, 512, 4, 4]               0\n",
      "        LeakyReLU-20            [-1, 512, 4, 4]               0\n",
      "          Dropout-21            [-1, 512, 4, 4]               0\n",
      "           Conv2d-22              [-1, 1, 1, 1]           8,192\n",
      "        LeakyReLU-23              [-1, 1, 1, 1]               0\n",
      "================================================================\n",
      "Total params: 6,958,080\n",
      "Trainable params: 6,958,080\n",
      "Non-trainable params: 0\n",
      "----------------------------------------------------------------\n",
      "Input size (MB): 0.23\n",
      "Forward/backward pass size (MB): 18.83\n",
      "Params size (MB): 26.54\n",
      "Estimated Total Size (MB): 45.61\n",
      "----------------------------------------------------------------\n",
      "\n",
      "\n",
      "GENERATOR ARCHITECTURE: Upsample Latent Space Vector dim==(100,) to Image (3x157x128)\n",
      "----------------------------------------------------------------\n",
      "        Layer (type)               Output Shape         Param #\n",
      "================================================================\n",
      "            Linear-1                 [-1, 8192]         827,392\n",
      "   ConvTranspose2d-2            [-1, 512, 9, 8]       5,242,880\n",
      "      SpectralNorm-3            [-1, 512, 9, 8]               0\n",
      "       BatchNorm2d-4            [-1, 512, 9, 8]           1,024\n",
      "              ReLU-5            [-1, 512, 9, 8]               0\n",
      "   ConvTranspose2d-6          [-1, 256, 19, 16]       2,621,440\n",
      "      SpectralNorm-7          [-1, 256, 19, 16]               0\n",
      "       BatchNorm2d-8          [-1, 256, 19, 16]             512\n",
      "              ReLU-9          [-1, 256, 19, 16]               0\n",
      "  ConvTranspose2d-10          [-1, 128, 39, 32]         655,360\n",
      "     SpectralNorm-11          [-1, 128, 39, 32]               0\n",
      "      BatchNorm2d-12          [-1, 128, 39, 32]             256\n",
      "             ReLU-13          [-1, 128, 39, 32]               0\n",
      "  ConvTranspose2d-14           [-1, 64, 79, 64]         163,840\n",
      "     SpectralNorm-15           [-1, 64, 79, 64]               0\n",
      "      BatchNorm2d-16           [-1, 64, 79, 64]             128\n",
      "             ReLU-17           [-1, 64, 79, 64]               0\n",
      "  ConvTranspose2d-18          [-1, 3, 157, 128]           3,840\n",
      "     SpectralNorm-19          [-1, 3, 157, 128]               0\n",
      "             Tanh-20          [-1, 3, 157, 128]               0\n",
      "================================================================\n",
      "Total params: 9,516,672\n",
      "Trainable params: 9,516,672\n",
      "Non-trainable params: 0\n",
      "----------------------------------------------------------------\n",
      "Input size (MB): 0.00\n",
      "Forward/backward pass size (MB): 19.69\n",
      "Params size (MB): 36.30\n",
      "Estimated Total Size (MB): 56.00\n",
      "----------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "from torchsummary import summary\n",
    "\n",
    "# need device to instantiate model\n",
    "device = 'cuda'\n",
    "\n",
    "# Instantiate Discriminator\n",
    "model = ConvolutionalDiscriminativeNet().to(device)\n",
    "# USE INPUT IMAGE SIZE. Should downsample to scalar (1x1x1) CxHxW\n",
    "print('DISCRIMINATOR ARCHITECTURE: Downsample Image dim==(3x157x128) to Scalar (1x1x1)')\n",
    "summary(model, input_size=(3,157,128))\n",
    "\n",
    "# Instantiate Generator\n",
    "model = ConvolutionalGenerativeNet().to(device)\n",
    "# USE LATENT VECTOR (z) as input. Should upsample to (3x157x128) CxHxW\n",
    "print('\\n\\nGENERATOR ARCHITECTURE: Upsample Latent Space Vector dim==(100,) to Image (3x157x128)')\n",
    "summary(model, input_size=((latent_vector_dim,)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tpQa0tzpFybV"
   },
   "source": [
    "Looks good. We should be able to compute a prediction on a generated image by passing a latent vector through G, and the result through D to get D(G(z)) to plug into the adversarial loss function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vh2CMoEEhaoH"
   },
   "source": [
    "# Choice of Optimizer and Loss Function\n",
    "[Radford et al 2015](https://arxiv.org/abs/1511.06434) used Adam for both discriminator and generator with lr=0.0002. I extensively tried to optimize on this and could find no better - although SGD is commonly used to slow down the discriminator in absence of the normalization techniques we've implemented. SGD was much too slow for the normalized discriminator to learn, and Adam worked decently with the parameters lr = 0.0002, b1=0.5, b2 = 0.999 from the original DCGAN by Radford et al 2015.\n",
    "\n",
    "However, I have swapped Adam for AdamW, [Decoupled Weight Decay Regularization by Loshchilov and Hutter, 2017](https://arxiv.org/abs/1711.05101). Adam incorrectly implements weight decay regularization by equating it with L2 regularization, which is not correct. AdamW overcomes this issue by decoupling the weight decay from the learning rate, with the paper showing improved performance particularly on image classification tasks - precisely as we have here in the discriminator. \n",
    "\n",
    "As for learning rates - lr=0.0002 as proposed in the original DCGAN paper by Radford et al worked great for me. [Heusel et al, 2017 - GANs Trained by a Two Time-Scale Update Rule [TTUR] Converge to a Local Nash Equilibrium](https://arxiv.org/abs/1706.08500) suggest that different learning rates for the discriminator and generator can also work well, but I didn't find \"TTUR\" necesary or helpful.\n",
    "\n",
    "Instead of using the standard torch binary cross entropy class BCELoss(), we'll use BCELossWithLogits. This is because it is more numerically stable since it uses the [log-sum-exp (LSE) trick](https://en.wikipedia.org/wiki/LogSumExp#log-sum-exp_trick_for_log-domain_calculations) by combining a sigmoid layer and log-loss in one class. Because of this, we won't use a sigmoid activation as the final layer of the discriminator as in Radford et al. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "g_hRgUqZhaoI"
   },
   "outputs": [],
   "source": [
    "####### Note that these are here for a proper python implementation #############################\n",
    "####### But they have to be specified explicitly in the training loop for google colab - a bug #####\n",
    "def get_optimizers(G, D):\n",
    "    \n",
    "    # optimizer for discrminator\n",
    "    D_optimizer = Adam(D.parameters(), lr=0.0002,betas=(0.5, 0.999)) \n",
    "    \n",
    "    # optimizer for generator\n",
    "    # currently using same optimizer for both networks; can (and should) play with lr\n",
    "    G_optimizer = Adam(G.parameters(), lr=0.0002, betas=(0.5, 0.999)) \n",
    "    \n",
    "    return D_optimizer, G_optimizer\n",
    "\n",
    "# using standard binary cross entropy works great\n",
    "def get_criterion():\n",
    "    GAN_loss = nn.BCEWithLogitsLoss()\n",
    "    return GAN_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iSaQ0qwta_a5"
   },
   "source": [
    "# Training a DCGAN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZNq4_lTXhaoS"
   },
   "source": [
    "## Make Training Utilities\n",
    "\n",
    "Generating the latent vectors for each batch.\n",
    "\n",
    "Weight initialization to a standard normal distribution as in Radford et al, 2015, with mean=0 and stdev = 0.02. \n",
    "\n",
    "And we plot the mean and max of the gradients in each layer of the discriminator (whose gradients are ultimately responsible for the entire network's learning) to make sure we don't have anything vanish or explode. Will show us whether gradients are behaving properly, and at which layer. We call this function specifically for the discriminator network, since we're most concerned with creating stable dynamics for the discriminator gradients - they define the learning of the generator as well (and so the entire DCGAN)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "JNpIMHvPhaoZ"
   },
   "outputs": [],
   "source": [
    "# generates a latent vector (z) sampled from a standard normal (Gaussian) distribution\n",
    "# adapted from https://discuss.pytorch.org/t/check-gradient-flow-in-network/15063/10\n",
    "def get_gaussian_latent_vectors(batch_size, device):\n",
    "    return torch.randn((batch_size, latent_vector_dim), device=device)\n",
    "\n",
    "# this explicit weight init from standard normal distribution didn't improve performance \n",
    "# possibly because batchnorm is enough to mitigate the impact of poorly initialized weights\n",
    "def init_weights(model):\n",
    "    classname = model.__class__.__name__\n",
    "    #print(classname)\n",
    "    if classname.find(\"Conv2d\") != -1:\n",
    "        torch.nn.init.normal_(model.weight.data, 0.0, 0.02)\n",
    "    elif classname.find(\"BatchNorm2d\") != -1:\n",
    "        # 1-centered normal distribution, stdev==0.02 as specified in Radford et al, 2015\n",
    "        torch.nn.init.normal_(model.weight.data, 1.0, 0.02)\n",
    "        torch.nn.init.constant_(model.bias.data, 0.0)\n",
    "    print(f'Weights initialized for {model.__class__.__name__}')\n",
    "\n",
    "# function to plot gradients after training loop is over \n",
    "# will make it obvious if any gradients are exploding/vanishing\n",
    "# goes into training loop after loss.backwards()\n",
    "from matplotlib.lines import Line2D\n",
    "def plot_grad_flow(named_parameters):\n",
    "    ave_grads = []\n",
    "    max_grads= []\n",
    "    layers = []\n",
    "    for n, p in named_parameters:\n",
    "        if(p.requires_grad) and (\"bias\" not in n):\n",
    "            layers.append(n)\n",
    "            ave_grads.append(p.grad.abs().mean())\n",
    "            max_grads.append(p.grad.abs().max())\n",
    "    plt.bar(np.arange(len(max_grads)), max_grads, alpha=0.1, lw=1, color=\"c\")\n",
    "    plt.bar(np.arange(len(max_grads)), ave_grads, alpha=0.1, lw=1, color=\"b\")\n",
    "    plt.hlines(0, 0, len(ave_grads)+1, lw=2, color=\"k\" )\n",
    "    plt.xticks(range(0,len(ave_grads), 1), layers, rotation=\"vertical\")\n",
    "    plt.xlim(left=0, right=len(ave_grads))\n",
    "    plt.ylim(bottom = -0.001, top=0.02) # zoom in on the lower gradient regions\n",
    "    plt.xlabel(\"Layers\")\n",
    "    plt.ylabel(\"average gradient\")\n",
    "    plt.title(\"Gradient flow\")\n",
    "    plt.grid(True)\n",
    "    plt.legend([Line2D([0], [0], color=\"c\", lw=4),\n",
    "                Line2D([0], [0], color=\"b\", lw=4),\n",
    "                Line2D([0], [0], color=\"k\", lw=4)], ['max-gradient', 'mean-gradient', 'zero-gradient'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QoYR8anphaow"
   },
   "source": [
    "## Build Training Loop\n",
    "\n",
    "Based on the [original DCGAN paper by Radford et al](https://arxiv.org/abs/1511.06434), here's what we're going for: \n",
    "\n",
    "**Update Discriminator:**\n",
    "\n",
    "- Forward real images minibatch through the Discriminator;\n",
    "\n",
    "- Compute Discriminator loss and calculate gradients for the backward pass;\n",
    "\n",
    "- Generate fake images minibatch via forward pass of latent vector z to Generator\n",
    "\n",
    "- Forward generated fake minibatch (G(z)) through the Discriminator;\n",
    "\n",
    "- Compute the Discriminator loss and compute gradients for the backward pass;\n",
    "\n",
    "- Add: real minibatch gradients + fake minibatch gradients\n",
    "\n",
    "- Update Discriminator using Adam or SGD.\n",
    "\n",
    "**Update Generator:**\n",
    "\n",
    "- **Log Trick:** Flip the target labels: fake images from the generator G(z) get labeled as real. This step configures binary cross-entropy to maximize log(D(G(z))) for the Discriminator loss passed to the Generator and helps overcome the problem of Generator's vanishing gradients. This is the log trick where instead of minizming log(1 - D(G(z))) we instead maximize log(D(G(z))).\n",
    "\n",
    "- Forward fake images minibatch through the updated Discriminator: D(G(z)), where z is labeled as real images for the log trick;\n",
    "\n",
    "- Compute Generator loss based on the updated Discriminator output;\n",
    "\n",
    "- Update the Generator using Adam (SGD results in a too-slow generator that is outpaced by the Discriminator, whose loss goes to 0 signalling a failure mode)\n",
    "\n",
    "\n",
    "In the above, we specifically train the discriminator first; this is not by chance. This is because if the generator produces an image that looks entirely real to the discriminator, the generator will just get stuck producing that image. This is called [mode collapse](https://developers.google.com/machine-learning/gan/problems). **Training the discriminator first is one way to avoid mode collapse.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "id": "pvfHxO9ohaox"
   },
   "outputs": [],
   "source": [
    "def train(training_config, G=None, D=None, epoch=0):\n",
    "    \n",
    "    # instantiate tensorboard \n",
    "    writer = SummaryWriter()  # (tensorboard) writer will output to ./runs/ directory by default\n",
    "    \n",
    "    # need GPU/TPU for training purposes on such a heavy model and dataset\n",
    "    #for TPU: device = device = xm.xla_device() \n",
    "    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "    ########## instantiate discriminator ##############\n",
    "    # instantiate, set to training mode and move to GPU\n",
    "    discriminator = ConvolutionalDiscriminativeNet().train().to(device)\n",
    "\n",
    "    if not D:\n",
    "        # init weights from normal distribution with mean=0, stdev=0.2 as in Radford et al 2015\n",
    "        # didn't help training much in my experiments \n",
    "        # intiiate discriminator weights for fresh models\n",
    "        discriminator.apply(init_weights)\n",
    "        # instantiate optimizer\n",
    "        D_optimizer = AdamW(discriminator.parameters(), lr=0.002, betas=(0.5,0.999))\n",
    "    else:\n",
    "        # load discriminator weights from checkpoint\n",
    "        discriminator.load_state_dict(D_checkpoint['model_state_dict'])\n",
    "        # instantiate optimizer and load state from checkpoint\n",
    "        D_optimizer = AdamW(discriminator.parameters())\n",
    "        D_optimizer.load_state_dict(D_checkpoint['optimizer_state_dict'])\n",
    "        print(f'Epoch {epoch} checkpoint D model and optimizer state loaded')\n",
    "    \n",
    "    ########## instantiate generator ###############\n",
    "    # instantiate, set to training mode and move to GPU\n",
    "    generator = ConvolutionalGenerativeNet().train().to(device)\n",
    "\n",
    "    if not G:\n",
    "        # initiate generator weights for fresh models\n",
    "        generator.apply(init_weights)\n",
    "        G_optimizer = AdamW(generator.parameters(), lr=0.0002, betas=(0.5, 0.999)) \n",
    "    else: \n",
    "        # load generator weights from discriminator\n",
    "        generator.load_state_dict(G_checkpoint['model_state_dict'])\n",
    "        # instantiate optimizer and load state from checkpoint\n",
    "        G_optimizer = AdamW(generator.parameters())\n",
    "        G_optimizer.load_state_dict(G_checkpoint['optimizer_state_dict'])\n",
    "        print(f'Epoch {epoch} checkpoint G model and optimizer state loaded\\n')\n",
    "\n",
    "\n",
    "    # We use binary cross-entropy since we are effectively training the discriminator binary classifier\n",
    "    # loss from the discriminator will be used to train both the discriminator and the generator\n",
    "    # so BCELoss covers loss for both discriminator and generator model training\n",
    "    GAN_loss = nn.BCEWithLogitsLoss()\n",
    "    \n",
    "    # We use a single BCELoss function to train the entire GAN using the adversarial loss as in from Radford et al 2015:\n",
    "    # passing real image labels (torch.ones) into BCEloss will return -log(x)\n",
    "    # Using one-sided label smoothing (only on real labels) - do not use on fake images \n",
    "    # purpose is to slow down the discriminator training on real samples, so we don't smooth generator labels \n",
    "    real_image_label = torch.autograd.Variable(torch.Tensor(training_config['batch_size'], 1,1,1).fill_(0.9).type(torch.cuda.HalfTensor))\n",
    "    # unsmoothed labels: \n",
    "    # real_image_label = torch.ones((training_config['batch_size'], 1, 1, 1), device=device)\n",
    "\n",
    "    # passing fake image labels (torch.zeros) into BCEloss will return -log(1-x)\n",
    "    fake_image_label = torch.zeros((training_config['batch_size'], 1, 1, 1), device=device)\n",
    "\n",
    "    # record progress for logging to TensorBoard\n",
    "    # number of debug images generated every so often during training \n",
    "    # keeps track of gradients and training progress/direction\n",
    "    ref_batch_size = 25\n",
    "\n",
    "    # this is just a latent vector (z) of dim (100,) of random Gaussian noise\n",
    "    # used to keep track of progress to generate intermediate/debug imagery\n",
    "    reference_latent_vec = get_gaussian_latent_vectors(num_reference_debug_images, device)\n",
    "\n",
    "    # Store losses for logging to TensorBoard\n",
    "    D_loss_values = []\n",
    "    G_loss_values = []\n",
    "    # Number of generated ebug images \n",
    "    image_count = 0\n",
    "    \n",
    "    # measure training time (to get an idea of differences w.r.t. hyperparameters)\n",
    "    start_time = time.time() \n",
    " \n",
    "    # training loop, encompasses training of entire GAN\n",
    "    for epoch in range(epoch, training_config['num_epochs']):\n",
    "        for batch_idx, (real_images, _) in enumerate(dataloader):\n",
    "            \n",
    "            # move images to GPU\n",
    "            real_images = real_images.to(device) \n",
    "\n",
    "            ######## Train discriminator by maximizing adversarial loss log(D(x)) + log(1-D(G(z)))  #######\n",
    "\n",
    "            # Notation: x = real images, z = latent Gaussian vectors\n",
    "            # G(z) = fake images, \n",
    "            # D(G(z)) = probability that fake image is real, \n",
    "            # D(G(x)) = probability that real image is real\n",
    "\n",
    "            # zero out the gradient for each new batch so it doesn't accumulate\n",
    "            D_optimizer.zero_grad()\n",
    "\n",
    "            # get D's predictions on real images D(x)\n",
    "            D_output_real = discriminator(real_images)#.view(-1)\n",
    "            # Store D(x) to track progress\n",
    "            # remember D outputs logits, so take sigmoid activation (scipy.expit)\n",
    "            D_x = expit(D_output_real.mean().item())\n",
    "\n",
    "            # -log(D(x)) is minimized when D(x) = discriminator(real_images) == 1\n",
    "            real_D_loss = GAN_loss(D_output_real, real_image_label)\n",
    "\n",
    "            # get latent vector\n",
    "            z = get_gaussian_latent_vectors(training_config['batch_size'], device)\n",
    "\n",
    "            # get G(z) = fake image generated on latent vector \n",
    "            fake_images = generator(z)\n",
    "            \n",
    "            # D(G(z)) = prob that fake image is real\n",
    "            # add call to .detach() to discard gradidents on generator's backward() pass\n",
    "            fake_images_predictions = discriminator(fake_images.detach())\n",
    "            # store prediction on fake images to track progress\n",
    "            # remember D outputs logits, so take sigmoid activation (scipy.expit)\n",
    "            D_G_z = expit(fake_images_predictions.mean().item())\n",
    "\n",
    "            # -log(1 - D(G(z))) is minimized when D(G(z)) = 0\n",
    "            # BCELoss returns -log(1 - D(G(z))) when we pass fake image labels (0) as ground truth\n",
    "            fake_D_loss = GAN_loss(fake_images_predictions, fake_image_label)\n",
    "            \n",
    "            # train the discriminator first, before the generator\n",
    "            # using BCELoss\n",
    "            D_loss = real_D_loss + fake_D_loss\n",
    "\n",
    "            ## IF USING WGAN ##\n",
    "            # D_loss = -(D_out_real.mean() - D_out_fake.mean())\n",
    "\n",
    "            # compute gradients after discriminator's forward pass\n",
    "            D_loss.backward() \n",
    "            \n",
    "            ####### this function shows discriminator gradients at the end of the training run for debdugging\n",
    "            # a little costly to run so only enable when debugging\n",
    "            # DO NOT ENABLE FOR FINAL TRAINING LOOP\n",
    "            # plot_grad_flow(discriminator.named_parameters())\n",
    "            \n",
    "            # update discriminator weights \n",
    "            D_optimizer.step() \n",
    "\n",
    "            ## IF USING WGAN: CLIP WEIGHTS TO [-0.05, 0.05] ##\n",
    "            #for p in discriminator.parameters():\n",
    "            #        p.data.clamp(-0.05, 0.05)\n",
    "            \n",
    "            ############# Train generator by maximizing log(D(G(z))) ###################\n",
    "            # zero out the gradient for each new forward pass so it doesn't accumulate\n",
    "            G_optimizer.zero_grad()\n",
    "\n",
    "            # z = latent vector \n",
    "            z = get_gaussian_latent_vectors(training_config['batch_size'], device)\n",
    "\n",
    "            # pass z through G to get generated (fake) images\n",
    "            generated_images = generator(z)\n",
    "\n",
    "            # get D(G(z)) = prob that fake image is real\n",
    "            generated_images_predictions = discriminator(generated_images)#.view(-1)\n",
    "            # Store fake image prediction after updating D in previous step\n",
    "            # remember D outputs logits, so take sigmoid activation (scipy.expit)\n",
    "            D2_G_z = expit(generated_images_predictions.mean().item())\n",
    "\n",
    "            # -log(D(G(z))) is minimized when D(G(z)) = 1\n",
    "            # BCELoss returns -log(D(G(z))) when we pass real image labels (1) as ground truth\n",
    "            # by passing real image labels for fake (generated) images we configure \n",
    "            # BCELoss to the \"log trick\"\n",
    "            G_loss = GAN_loss(generated_images_predictions, real_image_label)\n",
    "            \n",
    "            ## IF USING WGAN ##\n",
    "            # G_loss = -D_out_fake.mean()\n",
    "\n",
    "            # compute gradients after generator's forward pass\n",
    "            G_loss.backward()  \n",
    "            # update discriminator weights \n",
    "            G_optimizer.step()\n",
    "            \n",
    "            ############################ TensorBoard Logging ######################\n",
    "            G_loss_values.append(G_loss.item())\n",
    "            D_loss_values.append(D_loss.item())\n",
    "\n",
    "            # log to TensorBoard\n",
    "            if training_config['enable_tensorboard']:\n",
    "                # write losses for G and D to tensorboard\n",
    "                writer.add_scalars('LOSS: ', {'GEN': G_loss.item(), 'DISC': D_loss.item(), 'DISC_REAL': real_D_loss.item(), 'DISC_FAKE': fake_D_loss.item(), 'D_x': D_x, 'D_G_z': D_G_z, 'D2_G_z':D2_G_z}, len(dataloader) * epoch + batch_idx + 1)\n",
    "                # show generated images in TensorBoard for easy tracking of training progress\n",
    "                if training_config['debug_imagery_log_freq'] is not None and batch_idx % training_config['debug_imagery_log_freq'] == 0:\n",
    "                    # don't compute gradients on debug imagery \n",
    "                    with torch.no_grad():\n",
    "                        # generate the debug imagery on current generator model\n",
    "                        log_generated_images = (generator(reference_latent_vec))\n",
    "                        # resize generated debug imagery for easier viewing if desired\n",
    "                        log_generated_images_resized = nn.Upsample(scale_factor=2, mode='nearest')(log_generated_images)\n",
    "                        # make grid of 5x5 generated images to get an idea of G's performance\n",
    "                        intermediate_imagery_grid = torchvision.utils.make_grid(log_generated_images, nrow=int(np.sqrt(ref_batch_size)), normalize=True)\n",
    "                        writer.add_image('intermediate generated imagery', intermediate_imagery_grid, len(dataloader) * epoch + batch_idx + 1)\n",
    "                        # also save images to disk \n",
    "                        torchvision.utils.save_image(log_generated_images, os.path.join(training_config['debug_path'], f'{str(image_count).zfill(6)}.jpg'), nrow=int(np.sqrt(ref_batch_size)), normalize=True)\n",
    "                        # count of how many image grids have been generated (once for every 'debug_imagery_log_freq' size batch)\n",
    "                        image_count += 1\n",
    "\n",
    "            # log to stdodut once for every 'console_log_freq' size batch\n",
    "            if training_config['console_log_freq'] is not None and batch_idx % training_config['console_log_freq'] == 0:\n",
    "                print(f'GAN training: time elapsed= {(time.time() - start_time):.2f} [s] | epoch={epoch + 1} | batch= [{batch_idx + 1}/{len(dataloader)}]')\n",
    "                print(f'G loss: { G_loss.item():.3f}, D loss: {D_loss.item():.3f}, D_REAL: {real_D_loss.item():.3f}, D_FAKE: {fake_D_loss.item():.3f}, \\nD_X: {D_x:.3f}, D_G_z: {D_G_z:.3f}, D2_G_z:{D2_G_z:.3f} Debug Image: {str(image_count - 1).zfill(6)}.jpg')\n",
    "                print('\\n')\n",
    "\n",
    "        # save a checkpoint of the DCGAN every epoch \n",
    "        # performance often degrades past a certain epoch and may not recover\n",
    "        # save generator\n",
    "        G_checkpoint_name = f'G-DCGAN-{epoch}.pt'\n",
    "        torch.save({\n",
    "            'epoch': epoch,\n",
    "            'model_state_dict': generator.state_dict(),\n",
    "            'optimizer_state_dict': G_optimizer.state_dict(),\n",
    "            'loss': G_loss,\n",
    "            }, './binaries/'+G_checkpoint_name)\n",
    "        # save discriminator\n",
    "        D_checkpoint_name = f'D-DCGAN-{epoch}.pt'\n",
    "        torch.save({\n",
    "            'epoch': epoch,\n",
    "            'model_state_dict': discriminator.state_dict(),\n",
    "            'optimizer_state_dict': D_optimizer.state_dict(),\n",
    "            'loss': D_loss,\n",
    "            }, './binaries/'+D_checkpoint_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ABVLzhlP5SBO"
   },
   "source": [
    "## Track Progress with TensorBoard\n",
    "Google Colab has magic functions for this to run TensorBoard inline, as long as we've logged to SummaryWriter() correctly. Nice to have so we don't have to scroll through stdout, and we'll also configure it to display the latest generated images so we know when (if ever) we're happy with the DCGAN's results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "54hwpKMp5Rm5"
   },
   "outputs": [],
   "source": [
    "%load_ext tensorboard\n",
    "%tensorboard --logdir runs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nJ2aSRRkhao2"
   },
   "source": [
    "## Configure Training Params & Train Model\n",
    "\n",
    "Training config is mostly for logging purposes. The batch_size was set by the dataloader in the first couple of cells, so make sure to change it there if you want to change it here. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 493,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "RJwMnJdve_eR",
    "outputId": "7874427a-1ec8-4686-958b-4c5ccdb152cf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weights initialized for GaussianNoise\n",
      "Weights initialized for Conv2d\n",
      "Weights initialized for SpectralNorm\n",
      "Weights initialized for LeakyReLU\n",
      "Weights initialized for Dropout\n",
      "Weights initialized for Conv2d\n",
      "Weights initialized for SpectralNorm\n",
      "Weights initialized for LeakyReLU\n",
      "Weights initialized for Dropout\n",
      "Weights initialized for Conv2d\n",
      "Weights initialized for SpectralNorm\n",
      "Weights initialized for LeakyReLU\n",
      "Weights initialized for Dropout\n",
      "Weights initialized for Conv2d\n",
      "Weights initialized for SpectralNorm\n",
      "Weights initialized for LeakyReLU\n",
      "Weights initialized for Dropout\n",
      "Weights initialized for Conv2d\n",
      "Weights initialized for SpectralNorm\n",
      "Weights initialized for LeakyReLU\n",
      "Weights initialized for Dropout\n",
      "Weights initialized for Conv2d\n",
      "Weights initialized for LeakyReLU\n",
      "Weights initialized for Sequential\n",
      "Weights initialized for ConvolutionalDiscriminativeNet\n",
      "Weights initialized for Linear\n",
      "Weights initialized for ConvTranspose2d\n",
      "Weights initialized for SpectralNorm\n",
      "Weights initialized for BatchNorm2d\n",
      "Weights initialized for ReLU\n",
      "Weights initialized for ConvTranspose2d\n",
      "Weights initialized for SpectralNorm\n",
      "Weights initialized for BatchNorm2d\n",
      "Weights initialized for ReLU\n",
      "Weights initialized for ConvTranspose2d\n",
      "Weights initialized for SpectralNorm\n",
      "Weights initialized for BatchNorm2d\n",
      "Weights initialized for ReLU\n",
      "Weights initialized for ConvTranspose2d\n",
      "Weights initialized for SpectralNorm\n",
      "Weights initialized for BatchNorm2d\n",
      "Weights initialized for ReLU\n",
      "Weights initialized for ConvTranspose2d\n",
      "Weights initialized for SpectralNorm\n",
      "Weights initialized for Tanh\n",
      "Weights initialized for Sequential\n",
      "Weights initialized for ConvolutionalGenerativeNet\n",
      "GAN training: time elapsed= 0.97 [s] | epoch=1 | batch= [1/5086]\n",
      "G loss: 0.395, D loss: 1.371, D_REAL: 0.667, D_FAKE: 0.705, \n",
      "D_X: 0.518, D_G_z: 0.506, D2_G_z:0.976 Debug Image: 000000.jpg\n",
      "\n",
      "\n",
      "GAN training: time elapsed= 28.48 [s] | epoch=1 | batch= [201/5086]\n",
      "G loss: 1.897, D loss: 0.573, D_REAL: 0.364, D_FAKE: 0.209, \n",
      "D_X: 0.919, D_G_z: 0.188, D2_G_z:0.123 Debug Image: 000001.jpg\n",
      "\n",
      "\n",
      "GAN training: time elapsed= 54.84 [s] | epoch=1 | batch= [401/5086]\n",
      "G loss: 0.738, D loss: 0.996, D_REAL: 0.352, D_FAKE: 0.643, \n",
      "D_X: 0.879, D_G_z: 0.474, D2_G_z:0.473 Debug Image: 000002.jpg\n",
      "\n",
      "\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "ignored",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-493-7a2873fee8e8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     18\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     19\u001b[0m \u001b[0;31m# use pretrained G/D loaded from checkpoint if desired\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 20\u001b[0;31m \u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtraining_config\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#G=generator, D=discriminator)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-71-0ca707940708>\u001b[0m in \u001b[0;36mtrain\u001b[0;34m(training_config, G, D, epoch)\u001b[0m\n\u001b[1;32m    129\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    130\u001b[0m             \u001b[0;31m# compute gradients after discriminator's forward pass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 131\u001b[0;31m             \u001b[0mD_loss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    132\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    133\u001b[0m             \u001b[0;31m####### this function shows discriminator gradients at the end of the training run for debdugging\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torch/tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph)\u001b[0m\n\u001b[1;32m    183\u001b[0m                 \u001b[0mproducts\u001b[0m\u001b[0;34m.\u001b[0m \u001b[0mDefaults\u001b[0m \u001b[0mto\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    184\u001b[0m         \"\"\"\n\u001b[0;32m--> 185\u001b[0;31m         \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    186\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    187\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables)\u001b[0m\n\u001b[1;32m    125\u001b[0m     Variable._execution_engine.run_backward(\n\u001b[1;32m    126\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_tensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 127\u001b[0;31m         allow_unreachable=True)  # allow_unreachable flag\n\u001b[0m\u001b[1;32m    128\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    129\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Track generator output on a reference latent Gaussian vector throughout training\n",
    "# also allows us to build a nice animation of training progress\n",
    "# since the intermediate/dedbug generated faces will always be the 'same'\n",
    "# will make a 5x5 grid of debug images\n",
    "num_reference_debug_images = 25\n",
    "\n",
    "# configuration for training; mostly for logging\n",
    "training_config = {\n",
    "    'num_epochs' : 200, # more than necessary to enable manual stopping\n",
    "    'batch_size' : 32, # lower batch size is better for GAN; 128 used in Radford et al, lower works even better.\n",
    "    'enable_tensorboard' : True,\n",
    "    # save images each time this many batches are processed\n",
    "    'debug_imagery_log_freq' : 200,\n",
    "    # log training progress to stdout each time this many batches are processed\n",
    "    'console_log_freq' : 200,\n",
    "    'debug_path' : './debug_path/'\n",
    "}\n",
    "\n",
    "# use pretrained G/D loaded from checkpoint if desired\n",
    "train(training_config) #G=generator, D=discriminator) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You get the idea."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BsJ1kJWn_bFR"
   },
   "source": [
    "## Load Pre-Trained Checkpoints to Resume Training\n",
    "\n",
    "We'll pass the loaded checkpoint to the training loop function and load the model and optimizer state dicts in there (to make sure Colab plays nicely). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 646
    },
    "id": "CBGCJxBzXT9e",
    "outputId": "fe8d3f81-36bc-41b6-a3bf-c7beaa6c849e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "G loaded from  ./binaries1/G-DCGAN-11.pt\n",
      "D loaded from  ./binaries1/D-DCGAN-11.pt\n",
      "\n",
      "\n",
      "Epoch 11 checkpoint D model and optimizer state loaded\n",
      "Epoch 11 checkpoint G model and optimizer state loaded\n",
      "\n",
      "GAN training: time elapsed= 0.64 [s] | epoch=12 | batch= [1/5086]\n",
      "G loss: 1.241, D loss: 1.078, D_REAL: 0.527, D_FAKE: 0.552, \n",
      "D_X: 0.917, D_G_z: 0.376, D2_G_z:0.271 Debug Image: 000000.jpg\n",
      "\n",
      "\n",
      "GAN training: time elapsed= 8.59 [s] | epoch=12 | batch= [81/5086]\n",
      "G loss: 0.837, D loss: 1.150, D_REAL: 0.664, D_FAKE: 0.487, \n",
      "D_X: 0.692, D_G_z: 0.381, D2_G_z:0.424 Debug Image: 000001.jpg\n",
      "\n",
      "\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "ignored",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-152-16c78bb1a241>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0;31m# but this always leads to mode collapse. I'm not exactly sure why - let me know if you do.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 19\u001b[0;31m \u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtraining_config\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mG\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mG_checkpoint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mD\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mD_checkpoint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepoch\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mepoch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-150-b7d38eced2a6>\u001b[0m in \u001b[0;36mtrain\u001b[0;34m(training_config, G, D, epoch)\u001b[0m\n\u001b[1;32m    157\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    158\u001b[0m             \u001b[0;31m# compute gradients after generator's forward pass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 159\u001b[0;31m             \u001b[0mG_loss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    160\u001b[0m             \u001b[0;31m# update discriminator weights\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    161\u001b[0m             \u001b[0mG_optimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torch/tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph)\u001b[0m\n\u001b[1;32m    183\u001b[0m                 \u001b[0mproducts\u001b[0m\u001b[0;34m.\u001b[0m \u001b[0mDefaults\u001b[0m \u001b[0mto\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    184\u001b[0m         \"\"\"\n\u001b[0;32m--> 185\u001b[0;31m         \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    186\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    187\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables)\u001b[0m\n\u001b[1;32m    125\u001b[0m     Variable._execution_engine.run_backward(\n\u001b[1;32m    126\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_tensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 127\u001b[0;31m         allow_unreachable=True)  # allow_unreachable flag\n\u001b[0m\u001b[1;32m    128\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    129\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# path to saved generator checkpoint\n",
    "G = './binaries1/G-DCGAN-11.pt' \n",
    "# load generator checkpoint\n",
    "G_checkpoint = torch.load(G)\n",
    "epoch = G_checkpoint['epoch']\n",
    "print('G loaded from ',G)\n",
    "\n",
    "# path to save discriminator checkpoint\n",
    "D = './binaries1/D-DCGAN-11.pt'\n",
    "# load discriminator checkpoint\n",
    "D_checkpoint = torch.load(D)\n",
    "print('D loaded from ',D)\n",
    "print('\\n')\n",
    "\n",
    "# note you can change optimizer learning rate before restarting a checkpoint\n",
    "# using G/D_optimizer.param_groups[0]['lr'] = 0.0001\n",
    "# but this always leads to mode collapse. I'm not exactly sure why - let me know if you do. \n",
    "\n",
    "train(training_config, G=G_checkpoint, D=D_checkpoint, epoch=epoch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, you get the idea."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Yku61L3phao9"
   },
   "source": [
    "# Test Model: Generate Images\n",
    "\n",
    "## Image Generating Utilities\n",
    "We need to process generated images: we rescale back to [0,1] after tanh outputs pixels in [-1,1] and resize to OpenCV's (H,W,C), BGR format. \n",
    "\n",
    "We'll also make a function to generate and save images from a random latent vector so we can play with the trained generator. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "id": "pxo5xBTFhao-"
   },
   "outputs": [],
   "source": [
    "def process_generated_image(generated_image_tensor):\n",
    "\n",
    "    # Move the tensor from GPU to CPU, convert to numpy array, extract first batch\n",
    "    generated_image = generated_image_tensor.detach().to('cpu').numpy()[0]\n",
    "\n",
    "    # move colour channel from dim 0 to dim 2 (C,H,W) -> (H,W,C)\n",
    "    generated_image = np.moveaxis(generated_image,0, 2)\n",
    "\n",
    "    # Since CelebA images are RGB we don't use this\n",
    "    # if generating grayscale/1 channel images use this to repeat channel 3 times to get RGB image for OpenCV to display\n",
    "    # generated_image = np.repeat(generated_image, 3, axis=2)\n",
    "\n",
    "    # Generator outputs pixel valeus in [-1,1] due to tanh activation on last layer\n",
    "    # transform to [0,1] range for display: add (-1), divide by 2\n",
    "    generated_image -= np.min(generated_image)\n",
    "    generated_image /= np.max(generated_image)\n",
    "\n",
    "    return generated_image\n",
    "\n",
    "\n",
    "# wrapper to make latent vector z, generate image G(z), and process it for display\n",
    "def generate_from_random_latent_vector(generator):\n",
    "\n",
    "    # don't compute gradients when just generating images for dedbugging/tracking (saves VRAM)\n",
    "    with torch.no_grad(): \n",
    "        \n",
    "        # Generate latent vector (z)\n",
    "        latent_vector = get_gaussian_latent_vectors(1, next(generator.parameters()).device)\n",
    "        \n",
    "        # Generate image G(z)\n",
    "        image = generator(latent_vector)\n",
    "\n",
    "        # Process the generated image for display (i.e. convert pixel values from [-1,1] to [0,1])\n",
    "        generated_image = process_generated_image(image)\n",
    "\n",
    "    return generated_image\n",
    "\n",
    "\n",
    "# find next available file name (XXXXXXX.jpg) for generating image\n",
    "def get_image_ID(input_dir): \n",
    "\n",
    "    # search for present images in xxxxxxx.jpg format and dget next available image name \n",
    "    def valid_frame_name(str):\n",
    "        pattern = re.compile(r'[0-9]{6}\\.jpg')  # regex, examples it covers: 000000.jpg or 923492.jpg, etc.\n",
    "        return re.fullmatch(pattern, str) is not None\n",
    "\n",
    "    # Filter out only images with xxxxxx.jpg format from the input_dir\n",
    "    valid_frames = list(filter(valid_frame_name, os.listdir(input_dir)))\n",
    "    if len(valid_frames) > 0:\n",
    "        # Images in xxxxxx.jpg format: find the biggest such xxxxxx number and increment by 1\n",
    "        last_img_name = sorted(valid_frames)[-1]\n",
    "        new_prefix = int(last_img_name.split('.')[0]) + 1  # increment by 1\n",
    "        # fill with 0's\n",
    "        return f'{str(new_prefix).zfill(6)}.jpg'\n",
    "    else:\n",
    "        # return first image if dir is empty\n",
    "        return '000000.jpg'\n",
    "\n",
    "# save generated image to directory\n",
    "# resolution is 2* 157x128 for easier veiwing by default\n",
    "def save_image(image_dir, image, resolution=(256, 314), display=False):\n",
    "\n",
    "    # should get numpy array after postprocessing function\n",
    "    assert isinstance(image, np.ndarray), f'Expected numpy array got {type(image)}.'\n",
    "\n",
    "    # get name for image that isn't taken yet\n",
    "    image_name = get_image_ID(image_dir)\n",
    "\n",
    "    # convert to uint8 for OpenCV to display\n",
    "    if image.dtype != np.uint8:\n",
    "        image = (image*255).astype(np.uint8)\n",
    "\n",
    "    # OpenCV expects BGR format, so reverse image's channel dim (from RGB) using [::-1]\n",
    "    cv.imwrite(os.path.join(image_dir, image_name), cv.resize(image[:, :, ::-1], resolution, interpolation=cv.INTER_NEAREST)) \n",
    "    image = cv.resize(image, resolution, interpolation=cv.INTER_NEAREST)\n",
    "    # print image to stdout if desired\n",
    "    if display:\n",
    "        plt.imshow(image)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3df-vuJ-hapj"
   },
   "source": [
    "# Generated Images and Checkpoint Progression\n",
    " \n",
    "Now we can check how the generator has progressed through the training epochs. \n",
    "\n",
    "### 5 Epochs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 386,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 286
    },
    "id": "dVnt_nhEhapk",
    "outputId": "02677edb-4b26-4168-c2a7-3f0b15fddfc1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating celebrity face\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# load the desired Generator checkpoint\n",
    "# select dedsired epoch\n",
    "epoch = 5\n",
    "model_path = f'./final_binaries/G-DCGAN-{epoch}.pt' \n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "# instantiate model\n",
    "generator = ConvolutionalGenerativeNet().to(device)\n",
    "# load model weights from checkpoint\n",
    "generator.load_state_dict(torch.load(model_path)['model_state_dict'])\n",
    "# set to validation phase: don't update gradients, no batchnorm in validation phase\n",
    "generator.eval() \n",
    "\n",
    "# store generated images here \n",
    "generated_image_path = './images'\n",
    "\n",
    "# Generate faces (using DCGAN Generator trained on CelebA)\n",
    "print('Generating celebrity face')\n",
    "generated_image = generate_from_random_latent_vector(generator)\n",
    "save_image(generated_image_path, generated_image, display=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vaz4Y_YKtUWv"
   },
   "source": [
    "### 10 Epochs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 387,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 286
    },
    "id": "NCNvdoDDhaqI",
    "outputId": "1022fe1a-8b5f-4374-b549-b3ab814527a9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating celebrity face\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# load the desired Generator checkpoint\n",
    "# select dedsired epoch\n",
    "epoch = 10\n",
    "model_path = f'./final_binaries/G-DCGAN-{epoch}.pt' \n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "# instantiate model\n",
    "generator = ConvolutionalGenerativeNet().to(device)\n",
    "# load model weights from checkpoint\n",
    "generator.load_state_dict(torch.load(model_path)['model_state_dict'])\n",
    "# set to validation phase: don't update gradients, no batchnorm in validation phase\n",
    "generator.eval() \n",
    "\n",
    "# store generated images here \n",
    "generated_image_path = './images'\n",
    "\n",
    "# Generate faces (using DCGAN Generator trained on CelebA)\n",
    "print('Generating celebrity face')\n",
    "generated_image = generate_from_random_latent_vector(generator)\n",
    "save_image(generated_image_path, generated_image, display=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WXifjtLatWIO"
   },
   "source": [
    "### 25 Epochs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 413,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 286
    },
    "id": "kS2yuV-ZhaqO",
    "outputId": "f60dd763-ad90-44fb-a96f-f173580ec4fb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating celebrity face\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# load the desired Generator checkpoint\n",
    "# select dedsired epoch\n",
    "epoch = 25\n",
    "model_path = f'./final_binaries/G-DCGAN-{epoch}.pt' \n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "# instantiate model\n",
    "generator = ConvolutionalGenerativeNet().to(device)\n",
    "# load model weights from checkpoint\n",
    "generator.load_state_dict(torch.load(model_path)['model_state_dict'])\n",
    "# set to validation phase: don't update gradients, no batchnorm in validation phase\n",
    "generator.eval() \n",
    "\n",
    "# store generated images here \n",
    "generated_image_path = './images'\n",
    "\n",
    "# Generate faces (using DCGAN Generator trained on CelebA)\n",
    "print('Generating celebrity face')\n",
    "generated_image = generate_from_random_latent_vector(generator)\n",
    "save_image(generated_image_path, generated_image, display=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JbMCxEoUtZjF"
   },
   "source": [
    "### 37 Epochs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 443,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 286
    },
    "id": "ChJM5ZYMtJRy",
    "outputId": "673aed60-5b96-48ba-b4b1-bdcd85fc7c16"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating celebrity face\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# load the desired Generator checkpoint\n",
    "# select dedsired epoch\n",
    "epoch = 37\n",
    "model_path = f'./binaries/G-DCGAN-{epoch}.pt' \n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "# instantiate model\n",
    "generator = ConvolutionalGenerativeNet().to(device)\n",
    "# load model weights from checkpoint\n",
    "generator.load_state_dict(torch.load(model_path)['model_state_dict'])\n",
    "# set to validation phase: don't update gradients, no batchnorm in validation phase\n",
    "generator.eval() \n",
    "\n",
    "# store generated images here \n",
    "generated_image_path = './images'\n",
    "\n",
    "# Generate faces (using DCGAN Generator trained on CelebA)\n",
    "print('Generating celebrity face')\n",
    "generated_image = generate_from_random_latent_vector(generator)\n",
    "save_image(generated_image_path, generated_image, display=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "comwPEDs-QZy"
   },
   "source": [
    "Now that might fool me even on a good day - it's certainly a palatable human face, perhaps even a little celebrity-like.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Plq-vNyiuHUV"
   },
   "source": [
    "# Lessons Learned: How to Stabilize and Optimize a GAN\n",
    "\n",
    "The difficulty of training the GAN speaks for itself - once you give it a shot. Achieving stability in training and ensuring convergence (of the min-max game between the Generator and Discriminator) to a nash equillibrium is not nearly as easy as it is made out to be by recent papers implementing weight and image regularization techniques such as SELU and Spectral Norm. I've concluded that the plain DCGAN, even with contemporary regularization, doesn't quite cut it. [Progressively Growing GANs](https://arxiv.org/abs/1710.10196) and the [MSG-GAN](https://arxiv.org/abs/1903.06048) are some better candidates for truly impressive results at higher resolutions. \n",
    "\n",
    "**Here's what I've gathered from trying to get something impressive out of the plain DCGAN architecture:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IGXhEQTFzOhQ"
   },
   "source": [
    "**Training and Failure Modes:**\n",
    "- Best results are rarely at the last epoch of training - check intermediate epochs, because the generator's output sometimes degrades before picking back up\n",
    "- When the DCGAN is properly tuned, D loss decreases with time and has low variance.\n",
    "- When G loss is low or consistently decreases, it's likely fooling D with garbage images.\n",
    "- Slowing down D with different learning rates as in the TTUR paper sometimes works, but isn't necessary with proper normalization (SpectralNorm + Noise).\n",
    "- We can actually get away with a 5-10x faster learning rate on D when using all the regularization techniques in this notebook: Spectral Norm + Gaussian Instance Noise + Dropout.\n",
    "- Slowing down D with altered learning schedule (training D/G in a for loop for each batch) won't avoid training collapse - it'll only delay it.\n",
    "\n",
    "**Architecture/Hyperparameters:**\n",
    "- More filters is not better. 512 is a good maximum. 64 filters in each layer of both G and D works decently as well. Other hyperparams appear more important.\n",
    "- Use Dropout ONLY ON D, and not on its final layer. Using dropout on G leads to poor generated images.\n",
    "- Use Gaussian Instance Noise ONLY ON D - works well on input or in multiple layers (but not the last layer). Use in G causes it to be unable to generate decent images early on and it never recovers. \n",
    "- Adding Gaussian Instance Noise generally made discriminator less sensitive to hyperparameters.\n",
    "- Gaussian Noise didn't seem to make a big difference to stability of D when using SpectralNorm + BatchNorm.\n",
    "- SpectralNorm is a powerful normalization technique and can be used together with BatchNorm in G.\n",
    "- SpectralNorm performed better alone than SpectralNorm + BatchNorm in D. Both improved performance in G.\n",
    "- SpectralNorm can replace the normalization power of SELU, working well with leakyReLU.\n",
    "- Large batch is much faster to train (1024), but smaller batches train MUCH better GANs.\n",
    "- Batch in radford et al (128) works well; smaller batches (64, 32) are more stable but slower to train.\n",
    "\n",
    "**Activation & Optimizers:**\n",
    "- Activation function: In terms of performance for this model, I found LeakyReLU+ReLU to lead to faster equillibrium than SELU, though SELU also produced good generated images.\n",
    "- Use BCELossWithLogits and no sigmoid activation on final discriminator layer: More stable than BCELoss() because of log-sum-exp trick.\n",
    "- Optimizer: I found AdamW to work better than Adam. AdamW is better than SGD for discriminator, although SGD has been used to slow down the discriminator - it seems SGD slows down D too much with proper discriminator normalization.\n",
    "- SELU from HDCGAN paper (SNN): Performed as well as LeakyReLU for this model. SpecNorm+BatchNorm probably means weights are already regularized such that SELU behaves similarly to LeakyReLU. \n",
    "- SELU is indeed self normalizing, as it produced decent images even without SpectralNorm and BatchNorm - however, I found it better to have explicit normalization such as SpecNorm and BatchNorm and just use LeakyReLU + ReLU. \n",
    "\n",
    "**Other tricks:**\n",
    "- One-sided label smoothing: set discriminator labels for real images from 1 -> 0.9 to make the only the discriminator's job harder.\n",
    "- Popular GANHacks GitHub page incorrectly says to smooth both real and fake labels (1->0.9, 0->0.1).\n",
    "- Pixelwise Normalization didn't really change performance, just added complexity. Likely due to Spectral Normalization.\n",
    "- Minibatch Standard Deviation didn't help much either. Again, likely has to do with Spectral Normalization working so well. \n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "**Thanks for reading - I sincerely appreciate it. Any comments, errors, or questions, please drop me a line at ilzenkov@gmail.com.** \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4yQzIvdEx2pt"
   },
   "source": [
    "# References\n",
    "- Arjovsky and Bottou, 2017. Towards Principled Methods for Training Generative Adversarial Networks. https://arxiv.org/abs/1701.04862\n",
    "- Arjovsky et al, 2017. Wasserstein GAN. https://arxiv.org/abs/1701.07875 \n",
    "- Curto et al, 2020. High-resolution Deep Convolutional Generative Adversarial Networks. https://arxiv.org/pdf/1711.06491.pdf\n",
    "- Dumoulin and Visin, 2018. A guide to convolution arithmetic for deep learning. https://arxiv.org/pdf/1603.07285.pdf\n",
    "- Goodfellow et al, 2014. Generative Adversarial Networks. https://arxiv.org/abs/1406.2661\n",
    "- Heusel et al, 2017. GANs Trained by a Two Time-Scale Update Rule Converge to a Local Nash Equilibrium. https://arxiv.org/abs/1706.08500\n",
    "- Jenni and Favaro, 2019. On Stabilizing Generative Adversarial Training with Noise. https://arxiv.org/abs/1906.04612\n",
    "- Karras et al, 2017. Progressive Growing of GANs for Improved Quality, Stability, and Variation. https://arxiv.org/abs/1710.10196\n",
    "- Klambauer et al, 2017. Self-Normalizing Neural Networks. https://arxiv.org/abs/1706.02515\n",
    "- Liu et al, 2016. Large-scale CelebFaces Attributes (CelebA) Dataset. http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html\n",
    "- Mescheder et al, 2018. Which Training Methods for GANs do actually Converge? https://arxiv.org/pdf/1801.04406.pdf\n",
    "- Miyato et al, 2018. Spectral Normalization for Generative Adversarial Networks. https://arxiv.org/abs/1802.05957\n",
    "- Radford et al, 2015. Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks. https://arxiv.org/abs/1511.06434\n",
    "- Salimans et al, 2016. Improved Techniques for Training GANs. https://arxiv.org/pdf/1606.03498.pdf\n",
    "- Sonderby et al, 2016. Amortised MAP Inference for Image Super-resolution. https://arxiv.org/abs/1610.04490\n",
    "\n",
    "\n",
    "Notable mention to GanHacks GitHub: https://github.com/soumith/ganhacks/blob/master/README.md\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "e1Y_ZpI88p_N"
   },
   "source": [
    "# Appendix A\n",
    "\n",
    "## Animating GAN Training Progress\n",
    "\n",
    "We can use imageio to take all the intermediate debug images dumped during training and write it to a GIF. We'll need to load, resize, and rescale the images out of OpenCV format.\n",
    "\n",
    "We'll wrap imageio.mimwrite to write a series of images from our debug image path at a chosen framerate, and implement downsampling so we don't end up with a 2GB GIF. \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "id": "Z2pskxgv6WRo"
   },
   "outputs": [],
   "source": [
    "import imageio\n",
    "\n",
    "# load a single face image from disk, resize if desired\n",
    "def load_image(img_path, target_shape=None):\n",
    "\n",
    "    # convert openCV BGR images back into RGB\n",
    "     # [:, :, ::-1] converts BGR (images saved in opencv format) into RGB\n",
    "    img = cv.imread(img_path)[:, :, ::-1] \n",
    "\n",
    "    # resize with OpenCV\n",
    "    if target_shape is not None:  # resize section\n",
    "        if isinstance(target_shape, int) and target_shape != -1:  \n",
    "            current_height, current_width = img.shape[:2]\n",
    "            new_width = target_shape\n",
    "            new_height = int(current_height * (new_width / current_width))\n",
    "            img = cv.resize(img, (new_width, new_height), interpolation=cv.INTER_CUBIC)\n",
    "        else:  # set both dimensions to target shape\n",
    "            img = cv.resize(img, (target_shape[1], target_shape[0]), interpolation=cv.INTER_CUBIC)\n",
    "\n",
    "    # normalize to [0,1] range after cv.resize pushes it out of that range\n",
    "    img = img.astype(np.float32)  # convert from uint8 to float32\n",
    "    img /= 255.0  # get to [0, 1] range\n",
    "    return img\n",
    "\n",
    "def create_gif(frames_dir, out_path, downsample=1, img_width=None, fps=60, start_frame = 0, stop_frame=None):\n",
    "    # get images saved as .jpg\n",
    "    frame_paths = [os.path.join(frames_dir, frame_name) for count, frame_name in enumerate(os.listdir(frames_dir)) if count % downsample == 0]\n",
    "    \n",
    "    # for resizing image for GIF\n",
    "    if img_width is not None: \n",
    "        for frame_path in frame_paths:\n",
    "            img = load_image(frame_path, target_shape=img_width)\n",
    "            cv.imwrite(frame_path, np.uint8(img[:, :, ::-1] * 255))\n",
    "\n",
    "    # make sure we build the GIF from first to last image to visualize G's learning\n",
    "    frame_paths.sort()\n",
    "    \n",
    "    # store list of images from frame_path \n",
    "    images = [imageio.imread(frame_path) for frame_path in frame_paths]\n",
    "\n",
    "    # truncate images at stop frame if provided \n",
    "    if stop_frame:\n",
    "        images = images[start_frame:stop_frame]\n",
    "\n",
    "    # make it into a gif with mimwrite, which writes a series of images to the specified URI (out_path)\n",
    "    imageio.mimwrite(out_path, images, fps=fps)\n",
    "\n",
    "    print(f'\\nGIF saved to {out_path} at {fps} FPS.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 496,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "o9aFpsCs8XOW",
    "outputId": "f4c18d74-b015-412b-e588-4d9a128fed45"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GIF saved to debug_path_final.gif at 5 FPS.\n"
     ]
    }
   ],
   "source": [
    "# debug_path/xxxxxx.jpg contains all intermediate generated training images \n",
    "create_gif('debug_path_final', 'debug_path_final.gif', downsample=100, fps = 5, stop_frame=400)\n",
    "#create_gif('debug_path_relu_nospecD', 'debug_path_relu_nospecD.gif', downsample=2, fps = 20)\n",
    "#create_gif('debug_pathSELU', 'debug_pathSELU.gif', downsample=2, fps = 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 486,
   "metadata": {
    "id": "1oY6B_WIe91i"
   },
   "outputs": [],
   "source": [
    "!unzip -q debug_path_final.zip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4LM-A_mj6oEI"
   },
   "source": [
    "And here's a sample of what we get:\n",
    "\n",
    "<img src=\"generated_images/training_progress 2.gif\">\n",
    "\n",
    "And here's when things go wrong - this is an example of mode collapse:\n",
    "\n",
    "<img src=\"generated_images/mode_collapse.gif\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xRqP4gFh6c9f"
   },
   "source": [
    "\n",
    "## Spherical Interpolation\n",
    "\n",
    "We can save the various latent vectors (_z_) we use to generate images, and then use these vectors to interpolate between them, generating new images. This can help us deduce which features are present in a certain latent vector - but it's mostly for fun.\n",
    "\n",
    "Spherical interpolation is suggested over linear interpolation for GANs by [GAN Hacks](https://github.com/soumith/ganhacks). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "id": "MqYZe-2l6Di3"
   },
   "outputs": [],
   "source": [
    "# Suggested to use slerp instead of linear interp for GANs by https://github.com/soumith/ganhacks\n",
    "# Spherical interpolation formula from https://en.wikipedia.org/wiki/Slerp\n",
    "def spherical_interpolation(t, p0, p1):\n",
    "    # t is the interpolation parameter in range [0,1]\n",
    "    # p0 and p1 are the two latent vectors \n",
    "    if t <= 0:\n",
    "        return p0\n",
    "    elif t >= 1:\n",
    "        return p1\n",
    "    elif np.allclose(p0, p1):\n",
    "        return p0\n",
    "\n",
    "    # Convert p0 and p1 to unit vectors and find the angle between them (omega)\n",
    "    omega = np.arccos(np.dot(p0 / np.linalg.norm(p0), p1 / np.linalg.norm(p1)))\n",
    "    return np.sin((1.0 - t) * omega) /  np.sin(omega) * p0 + np.sin(t * omega) /  np.sin(omega) * p1\n",
    "\n",
    "# generates intermediate interpolated imagery \n",
    "# between two latent vectors a and b using \n",
    "def interpolation_gif(generator, a, b, gif_dir='interpolation_result', image_dir='images', fps=5):\n",
    "    \n",
    "    # number of images between the vectors a and b, including a and b\n",
    "    interpolation_resolution = 48 \n",
    "\n",
    "    # make intermediate image directory and gif directory\n",
    "    os.mkdir(image_dir)\n",
    "\n",
    "    # store intermediate images \n",
    "    generated_imgs = []\n",
    "\n",
    "    for i in range(interpolation_resolution):\n",
    "        # t in range [0,1] i.e. fraction of total interpolation\n",
    "        t = i / (interpolation_resolution - 1) \n",
    "        # generate intermediate interpolated vector\n",
    "        current_latent_vector = spherical_interpolation(t, a, b)\n",
    "        # convert to tensor for compatibility with image processing functions previously defined\n",
    "        current_latent_vector = torch.unsqueeze(torch.tensor(current_latent_vector, device='cuda'), dim=0)\n",
    "        # generate image from latent vector and process for saving\n",
    "        generated_img = process_generated_image(generator(current_latent_vector))#.detach())\n",
    "        # track progress for sanity\n",
    "        print('\\r'+f'Image {i+1}/{interpolation_resolution} processed',end='')\n",
    "        # make directory to save intermediate images\n",
    "        \n",
    "        # save intermediate interpolated image \n",
    "        save_image(image_dir, generated_img)\n",
    "        # convert from openCV (H,W,C) to (C,H,W) for torchvision.utils.save_image\n",
    "        # make list of interpolated images \n",
    "        generated_imgs.append(torch.tensor(np.moveaxis(generated_img, 2, 0)))\n",
    "    \n",
    "    # make a GIF of the interpolation\n",
    "    create_gif(image_dir, gif_dir+'.gif', downsample=1, fps = fps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "tHCcWb04CT_z",
    "outputId": "863ff2ff-c6c7-4c86-fa58-7760c4863e0d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image 48/48 processed\n",
      "GIF saved to ____interpolated_gifs/interp-0.gif at 10 FPS.\n",
      "Image 48/48 processed\n",
      "GIF saved to ____interpolated_gifs/interp-1.gif at 10 FPS.\n",
      "Image 48/48 processed\n",
      "GIF saved to ____interpolated_gifs/interp-2.gif at 10 FPS.\n"
     ]
    }
   ],
   "source": [
    "# load the desired Generator checkpoint\n",
    "# select dedsired epoch\n",
    "epoch = 37\n",
    "model_path = f'./final_binaries/G-DCGAN-{epoch}.pt' \n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "# instantiate model\n",
    "generator = ConvolutionalGenerativeNet().to(device)\n",
    "# load model weights from checkpoint\n",
    "generator.load_state_dict(torch.load(model_path)['model_state_dict'])\n",
    "# set to validation phase: don't compute gradients/update weights, no batchnorm in validation phase\n",
    "generator.eval() \n",
    "\n",
    "# generate two random Gaussian latent vectors \n",
    "z1 = np.random.normal(size=100).astype('Float32')\n",
    "z2 = np.random.normal(size=100).astype('Float32')\n",
    "\n",
    "# generate and save interpolated images between z1 and z2\n",
    "# make a couple of gifs so we can pick through them later \n",
    "for i in range(5):\n",
    "\n",
    "    # generate two random Gaussian latent vectors \n",
    "    z1 = np.random.normal(size=100).astype('Float32')\n",
    "    z2 = np.random.normal(size=100).astype('Float32')\n",
    "\n",
    "    # create interpolations between z1 and z2, and save to a gif\n",
    "    interpolation_gif(generator, z1, z2, fps=10, image_dir=f'____interpolation-{i}', gif_dir=f'____interpolated_gifs/interp-{i}')\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "navDUhj4Uyli"
   },
   "source": [
    "<img src=\"generated_images/interpolation/interp-2.gif\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "D5VaOc256D15"
   },
   "source": [
    "## CelebA Attributes\n",
    "We can make a dictionary to hold the attributes so we can play with the trained DCGAN later on. Attributes from Liu et al's baidu drive 'list_attr_celeba.txt'.\n",
    "\n",
    "**This will mostly be useful to figure out which feature is which using linear interpolation once our generator is trained; for labelling samples we would use an Auxilliary GAN (AC-GAN) where we embed image labels into an extra tensor dimension.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Dj_yzuCSLRPa"
   },
   "outputs": [],
   "source": [
    "# CelebA dataset attributes \n",
    "attributes_dict = {\n",
    "    '5_o_Clock_Shadow': torch.bool,\n",
    "    'Arched_Eyebrows': torch.bool,\n",
    "    'Attractive': torch.bool,\n",
    "    'Bags_Under_Eyes': torch.bool,\n",
    "    'Bald': torch.bool,\n",
    "    'Bangs': torch.bool,\n",
    "    'Big_Lips': torch.bool,\n",
    "    'Big_Nose': torch.bool,\n",
    "    'Black_Hair': torch.bool,\n",
    "    'Blond_Hair': torch.bool,\n",
    "    'Blurry': torch.bool,\n",
    "    'Brown_Hair': torch.bool,\n",
    "    'Bushy_Eyebrows': torch.bool,\n",
    "    'Chubby': torch.bool,\n",
    "    'Double_Chin': torch.bool,\n",
    "    'Eyeglasses': torch.bool,\n",
    "    'Goatee': torch.bool,\n",
    "    'Gray_Hair': torch.bool,\n",
    "    'Heavy_Makeup': torch.bool,\n",
    "    'High_Cheekbones': torch.bool,\n",
    "    'Male': torch.bool,\n",
    "    'Mouth_Slightly_Open': torch.bool,\n",
    "    'Mustache': torch.bool,\n",
    "    'Narrow_Eyes': torch.bool,\n",
    "    'No_Beard': torch.bool,\n",
    "    'Oval_Face': torch.bool,\n",
    "    'Pale_Skin': torch.bool,\n",
    "    'Pointy_Nose': torch.bool,\n",
    "    'Receding_Hairline': torch.bool,\n",
    "    'Rosy_Cheeks': torch.bool,\n",
    "    'Sideburns': torch.bool,\n",
    "    'Smiling': torch.bool,\n",
    "    'Straight_Hair': torch.bool,\n",
    "    'Wavy_Hair': torch.bool,\n",
    "    'Wearing_Earrings': torch.bool,\n",
    "    'Wearing_Hat': torch.bool,\n",
    "    'Wearing_Lipstick': torch.bool,\n",
    "    'Wearing_Necklace': torch.bool,\n",
    "    'Wearing_Necktie': torch.bool,\n",
    "    'Young': torch.bool,\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-2q1ue_CLSj6"
   },
   "source": [
    "## Wasserstein Loss: The WGAN\n",
    "In addition to the many normalization techniques above, one way to avoid mode collapse is by using [Wasserstein loss, as first described by Arjovsky et al, 2017](https://arxiv.org/abs/1701.07875) instead of adversarial loss as described by Radford et al. Wasserstein loss measures the distance between two probability distributions (similar to KL divergence, used in sparse autoencoders to ensure training weights are close to 0 in each hidden layer of a network). Roughly speaking, Wasserstein loss computes the quantity (percentage) of the difference between probability distributions, and the distance between the portion of the probability disributions which are different. [Earth mover's distance](https://en.wikipedia.org/wiki/Earth_mover%27s_distance) is another name for Wasserstein loss, and here's why: We imagine two different probability disributions as two differently-shaped dirt piles: the Wasserstein distance (loss) is then the product of the amount of dirt moved and the distance over which it is moved so that the two piles take on the exacft same shape. Wasserstein distance quantifies the minimum energy cost in transforming one probability distribution into the shape of another. **Wasserstein loss ultimately penalizes the generator w.r.t. the distance between the probability distributions of generated training images _P<sub>z</sub>_ and real training images _P<sub>data</sub>_**"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "DCGAN-Advanced-TEMP.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "KERNEL",
   "language": "python",
   "name": "kernel"
  },
  "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}