diff --git a/C3W2_GauGAN_(Optional).ipynb b/C3W2_GauGAN_(Optional).ipynb
new file mode 100644
index 0000000..9df7a16
--- /dev/null
+++ b/C3W2_GauGAN_(Optional).ipynb
@@ -0,0 +1,2075 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "C3W2: GauGAN (Optional).ipynb",
+ "provenance": [],
+ "collapsed_sections": [],
+ "toc_visible": true,
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "accelerator": "GPU"
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "1czVdIlqnImH"
+ },
+ "source": [
+ "# GauGAN\n",
+ "\n",
+ "*Please note that this is an optional notebook, meant to introduce more advanced concepts if you're up for a challenge, so don't worry if you don't completely follow!*\n",
+ "\n",
+ "It is recommended that you should already be familiar with:\n",
+ " - Pix2PixHD, from [High-Resolution Image Synthesis and Semantic Manipulation with Conditional GANs](https://arxiv.org/abs/1711.11585) (Wang et al. 2018)\n",
+ " - Synchronized batch norm. See Pytorch's [SyncBatchNorm](https://pytorch.org/docs/stable/generated/torch.nn.SyncBatchNorm.html) documentation.\n",
+ " - Kullbach-Leibler divergence\n",
+ "\n",
+ "### Goals\n",
+ "\n",
+ "In this notebook, you will learn about GauGAN, which synthesizes high-resolution images from semantic label maps, which you implement and train. GauGAN is based around a special denormalization technique proposed in [Semantic Image Synthesis with Spatially-Adaptive Normalization](https://arxiv.org/abs/1903.07291) (Park et al. 2019)\n",
+ "\n",
+ "### Background\n",
+ "GauGAN builds on Pix2PixHD but simplifies the overall network by adding spatially adaptive denormalization layers. Because it learns its denormalization parameters via convolving the instance segmentation map, it actually is better for multi-modal synthesis, since all it needs as is a random noise vector. Later in the notebook, you will see how the authors further control diversity with the noise vector."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "SnUBfO3P4vFm"
+ },
+ "source": [
+ "## GauGAN Submodules\n",
+ "\n",
+ "Let's first take a look at the building blocks behind GauGAN."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "F-V4Q3J3QBYB"
+ },
+ "source": [
+ "### Synchronized BatchNorm\n",
+ "\n",
+ "So you've already heard of batch norm, which is a normalization technique that tries to normalize the statistics of activations a standard Gaussian distribution.\n",
+ "\n",
+ "Batch norm, however, performs poorly with small batch sizes. This becomes a problem when training large models that can only fit small batch sizes on GPUs. Training on multiple GPUs will increase the effective batch size, but vanilla batch norm will only update its statistics asynchronously on each GPU. Essentially, if you train on 2 gpus with `nn.BatchNorm2d`, the two batchnorm modules will have a different running averages of statistics and batch norm stability isn't better from larger effective batch size.\n",
+ "\n",
+ "Synchronized batch norm ([nn.SyncBatchNorm](https://pytorch.org/docs/stable/generated/torch.nn.SyncBatchNorm.html)) does exactly what its name suggests - it synchronizes batch norm running average updates across multiple processes so that each update will be with the statistics across all your minibatches.\n",
+ "\n",
+ "The authors report slightly better scores with synchronized batch norm as opposed to regular (asynchronous) batch norm. Since you will likely be running this on one machine, this notebook will stick to regular `nn.BatchNorm2d` modules."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ciGiwTnpQNL-"
+ },
+ "source": [
+ "### Spatially Adaptive Denormalization (SPADE)\n",
+ "\n",
+ "Recall that normalization layers are formulated as\n",
+ "\n",
+ "\\begin{align*}\n",
+ " y &= \\dfrac{x - \\hat{\\mu}}{\\hat{\\sigma}} * \\gamma + \\beta\n",
+ "\\end{align*}\n",
+ "\n",
+ "where $\\hat{\\mu}$ and $\\hat{\\sigma}$ correspond to an exponential moving average of minibatch means and standard deviations and are used to normalize the input activation $x$. The parameters $\\gamma$ and $\\beta$ apply \"denormalization,\" essentially allowing the model to invert the normalization if necessary.\n",
+ "\n",
+ "In GauGAN, batch norm is the preferred normalization scheme. Recall that batch norm can be formulated for each input neuron as\n",
+ "\n",
+ "\\begin{align*}\n",
+ " y_{c,h,w} &= \\dfrac{x_{c,h,w} - \\hat{\\mu}_c}{\\hat{\\sigma}_c} * \\gamma_c + \\beta_c\n",
+ "\\end{align*}\n",
+ "\n",
+ "where $\\hat{\\mu}_c$ and $\\hat{\\sigma}_c$ are per-channel statistics computed across the batch and spatial dimensions. Similarly, $\\gamma_c$ and $\\beta_c$ are per-channel denormalization parameters.\n",
+ "\n",
+ "With vanilla batch norm, these denormalization parameters are spatially invariant - that is, the same values are applied to every position in the input activation. As you may imagine, this could be limiting for the model. Oftentimes it's conducive for the model to learn denormalization parameters for each position.\n",
+ "\n",
+ "The authors address this with **SPatially Adaptive DEnormalization (SPADE)**. They compute denormalization parameters $\\gamma$ and $\\beta$ by convolving the input segmentation masks and apply these elementwise. SPADE can therefore be formulated as\n",
+ "\n",
+ "\\begin{align*}\n",
+ " y_{c,h,w} &= \\dfrac{x_{c,h,w} - \\hat{\\mu}_c}{\\hat{\\sigma}_c} * \\gamma_{c,h,w} + \\beta_{c,h,w}\n",
+ "\\end{align*}\n",
+ "\n",
+ "Now let's implement SPADE!\n",
+ "\n",
+ "Note: the authors use spectral norm in all convolutional layers in the generator and discriminator, but the official code omits spectral norm for SPADE layers."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "3JCxv5rhWNhr"
+ },
+ "source": [
+ "import torch\n",
+ "import torch.nn as nn\n",
+ "import torch.nn.functional as F\n",
+ "\n",
+ "class SPADE(nn.Module):\n",
+ " '''\n",
+ " SPADE Class\n",
+ " Values:\n",
+ " channels: the number of channels in the input, a scalar\n",
+ " cond_channels: the number of channels in conditional input (one-hot semantic labels), a scalar\n",
+ " '''\n",
+ "\n",
+ " def __init__(self, channels, cond_channels):\n",
+ " super().__init__()\n",
+ "\n",
+ " self.batchnorm = nn.BatchNorm2d(channels)\n",
+ " self.spade = nn.Sequential(\n",
+ " nn.Conv2d(cond_channels, channels, kernel_size=3, padding=1),\n",
+ " nn.ReLU(inplace=True),\n",
+ " nn.Conv2d(channels, 2 * channels, kernel_size=3, padding=1),\n",
+ " )\n",
+ "\n",
+ " def forward(self, x, seg):\n",
+ " # Apply normalization\n",
+ " x = self.batchnorm(x)\n",
+ "\n",
+ " # Compute denormalization\n",
+ " seg = F.interpolate(seg, size=x.shape[-2:], mode='nearest')\n",
+ " gamma, beta = torch.chunk(self.spade(seg), 2, dim=1)\n",
+ "\n",
+ " # Apply denormalization\n",
+ " x = x * (1 + gamma) + beta\n",
+ " return x"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "fB1Vq8ps7Bfd"
+ },
+ "source": [
+ "### Residual Blocks\n",
+ "\n",
+ "Let's now implement residual blocks with SPADE normalization. You should be familiar with the residual block by now, but this implementation will be a bit different to accomodate for the extra semantic label map input. For a refresher on residual blocks, please take a look [here](https://paperswithcode.com/method/residual-block)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "GHD_wif07f4b"
+ },
+ "source": [
+ "class ResidualBlock(nn.Module):\n",
+ " '''\n",
+ " ResidualBlock Class\n",
+ " Values:\n",
+ " in_channels: the number of input channels, a scalar\n",
+ " out_channels: the number of output channels, a scalar\n",
+ " cond_channels: the number of channels in conditional input in spade layer, a scalar\n",
+ " '''\n",
+ "\n",
+ " def __init__(self, in_channels, out_channels, cond_channels):\n",
+ " super().__init__()\n",
+ "\n",
+ " hid_channels = min(in_channels, out_channels)\n",
+ "\n",
+ " self.proj = in_channels != out_channels\n",
+ " if self.proj:\n",
+ " self.norm0 = SPADE(in_channels, cond_channels)\n",
+ " self.conv0 = nn.utils.spectral_norm(\n",
+ " nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False)\n",
+ " )\n",
+ "\n",
+ " self.activation = nn.LeakyReLU(0.2)\n",
+ " self.norm1 = SPADE(in_channels, cond_channels)\n",
+ " self.norm2 = SPADE(hid_channels, cond_channels)\n",
+ " self.conv1 = nn.utils.spectral_norm(\n",
+ " nn.Conv2d(in_channels, hid_channels, kernel_size=3, padding=1)\n",
+ " )\n",
+ " self.conv2 = nn.utils.spectral_norm(\n",
+ " nn.Conv2d(hid_channels, out_channels, kernel_size=3, padding=1)\n",
+ " )\n",
+ "\n",
+ " def forward(self, x, seg):\n",
+ " dx = self.norm1(x, seg)\n",
+ " dx = self.activation(dx)\n",
+ " dx = self.conv1(dx)\n",
+ " dx = self.norm2(dx, seg)\n",
+ " dx = self.activation(dx)\n",
+ " dx = self.conv2(dx)\n",
+ "\n",
+ " # Learn skip connection if in_channels != out_channels\n",
+ " if self.proj:\n",
+ " x = self.norm0(x, seg)\n",
+ " x = self.conv0(x)\n",
+ "\n",
+ " return x + dx"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "I8PjnPm142YM"
+ },
+ "source": [
+ "## GauGAN Parts\n",
+ "\n",
+ "Now that you understand the main contributions of GauGAN and its submodules, let's dive into the encoder, generator, and discriminator!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "5F38Et-m3_1B"
+ },
+ "source": [
+ "### Encoder\n",
+ "\n",
+ "GauGAN's encoder serves a different purpose than Pix2PixHD's. Instead of learning feature maps to be fed as input to the generator, GauGAN's encoder encodes the original image into a mean and standard deviation from which to sample noise, which is given to the generator. You may recall this same technique of encoding to a mean and standard devation is used in variational autoencoders (VAEs, covered in a Course 2 optional notebook). "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "MfLUrDS440vm"
+ },
+ "source": [
+ "class Encoder(nn.Module):\n",
+ " '''\n",
+ " Encoder Class\n",
+ " Values:\n",
+ " spatial_size: tuple specifying (height, width) of full size image, a tuple\n",
+ " z_dim: number of dimensions of latent noise vector (z), a scalar\n",
+ " n_downsample: number of downsampling blocks in the encoder, a scalar\n",
+ " base_channels: number of channels in the last hidden layer, a scalar\n",
+ " '''\n",
+ "\n",
+ " max_channels = 512\n",
+ "\n",
+ " def __init__(self, spatial_size, z_dim=256, n_downsample=6, base_channels=64):\n",
+ " super().__init__()\n",
+ "\n",
+ " layers = []\n",
+ " channels = base_channels\n",
+ " for i in range(n_downsample):\n",
+ " in_channels = 3 if i == 0 else channels\n",
+ " out_channels = 2 * z_dim if i < n_downsample else max(self.max_channels, channels * 2)\n",
+ " layers += [\n",
+ " nn.utils.spectral_norm(\n",
+ " nn.Conv2d(in_channels, out_channels, stride=2, kernel_size=3, padding=1)\n",
+ " ),\n",
+ " nn.InstanceNorm2d(out_channels),\n",
+ " nn.LeakyReLU(0.2),\n",
+ " ]\n",
+ " channels = out_channels\n",
+ "\n",
+ " h, w = spatial_size[0] // 2 ** n_downsample, spatial_size[1] // 2 ** n_downsample\n",
+ " layers += [\n",
+ " nn.Flatten(1),\n",
+ " nn.Linear(channels * h * w, 2 * z_dim),\n",
+ " ]\n",
+ "\n",
+ " self.layers = nn.Sequential(*layers)\n",
+ "\n",
+ " def forward(self, x):\n",
+ " return torch.chunk(self.layers(x), 2, dim=1)"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "bKIst9xTs7OI"
+ },
+ "source": [
+ "### Generator\n",
+ "\n",
+ "The GauGAN generator is actually very different from previous image-to-image translation generators. Because information from the semantic label map is injected at each batch normalization layer, the generator is able to just take random noise $z$ as input. This noise is reshaped and upsampled to the target image size.\n",
+ "\n",
+ "Let's take a look at the implementation!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "NqgMm3Gs0B0a"
+ },
+ "source": [
+ "class Generator(nn.Module):\n",
+ " '''\n",
+ " Generator Class\n",
+ " Values:\n",
+ " n_classes: the number of object classes in the dataset, a scalar\n",
+ " bottom_width: the downsampled spatial size of the image, a scalar\n",
+ " z_dim: the number of dimensions the z noise vector has, a scalar\n",
+ " base_channels: the number of channels in last hidden layer, a scalar\n",
+ " n_upsample: the number of upsampling operations to apply, a scalar\n",
+ " '''\n",
+ "\n",
+ " max_channels = 1024\n",
+ "\n",
+ " def __init__(self, n_classes, spatial_size, z_dim=256, base_channels=64, n_upsample=6):\n",
+ " super().__init__()\n",
+ "\n",
+ " h, w = spatial_size[0] // 2 ** n_upsample, spatial_size[1] // 2 ** n_upsample\n",
+ " self.proj_z = nn.Linear(z_dim, self.max_channels * h * w)\n",
+ " self.reshape = lambda x: torch.reshape(x, (-1, self.max_channels, h, w))\n",
+ "\n",
+ " self.upsample = nn.Upsample(scale_factor=2)\n",
+ " self.res_blocks = nn.ModuleList()\n",
+ " for i in reversed(range(n_upsample)):\n",
+ " in_channels = min(self.max_channels, base_channels * 2 ** (i+1))\n",
+ " out_channels = min(self.max_channels, base_channels * 2 ** i)\n",
+ " self.res_blocks.append(ResidualBlock(in_channels, out_channels, n_classes))\n",
+ "\n",
+ " self.proj_o = nn.Sequential(\n",
+ " nn.Conv2d(base_channels, 3, kernel_size=3, padding=1),\n",
+ " nn.Tanh(),\n",
+ " )\n",
+ "\n",
+ " def forward(self, z, seg):\n",
+ " h = self.proj_z(z)\n",
+ " h = self.reshape(h)\n",
+ " for res_block in self.res_blocks:\n",
+ " h = res_block(h, seg)\n",
+ " h = self.upsample(h)\n",
+ " h = self.proj_o(h)\n",
+ " return h"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "8HoyIbXajoMC"
+ },
+ "source": [
+ "### Discriminator\n",
+ "\n",
+ "The architecture of the discriminator follows the one used in Pix2PixHD, which uses a multi-scale design with the InstanceNorm. The only difference here is that they apply spectral normalization to all convolutional layers. GauGAN's discriminator also takes as input the image concatenated with the semantic label map (no instance boundary map as in Pix2PixHD)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "fYgX2B_hDxkA"
+ },
+ "source": [
+ "class PatchGANDiscriminator(nn.Module):\n",
+ " '''\n",
+ " PatchGANDiscriminator Class\n",
+ " Implements the discriminator class for a subdiscriminator, \n",
+ " which can be used for all the different scales, just with different argument values.\n",
+ " Values:\n",
+ " in_channels: the number of channels in input, a scalar\n",
+ " base_channels: the number of channels in first convolutional layer, a scalar\n",
+ " n_layers: the number of convolutional layers, a scalar\n",
+ " '''\n",
+ "\n",
+ " def __init__(self, in_channels, base_channels=64, n_layers=3):\n",
+ " super().__init__()\n",
+ "\n",
+ " # Use nn.ModuleList so we can output intermediate values for loss.\n",
+ " self.layers = nn.ModuleList()\n",
+ "\n",
+ " # Initial convolutional layer\n",
+ " self.layers.append(\n",
+ " nn.Sequential(\n",
+ " nn.utils.spectral_norm(\n",
+ " nn.Conv2d(in_channels, base_channels, kernel_size=4, stride=2, padding=2)\n",
+ " ),\n",
+ " nn.LeakyReLU(0.2, inplace=True),\n",
+ " )\n",
+ " )\n",
+ "\n",
+ " # Downsampling convolutional layers\n",
+ " channels = base_channels\n",
+ " for _ in range(1, n_layers):\n",
+ " prev_channels = channels\n",
+ " channels = min(2 * channels, 512)\n",
+ " self.layers.append(\n",
+ " nn.Sequential(\n",
+ " nn.utils.spectral_norm(\n",
+ " nn.Conv2d(prev_channels, channels, kernel_size=4, stride=2, padding=2)\n",
+ " ),\n",
+ " nn.InstanceNorm2d(channels, affine=False),\n",
+ " nn.LeakyReLU(0.2, inplace=True),\n",
+ " )\n",
+ " )\n",
+ "\n",
+ " # Output convolutional layer\n",
+ " prev_channels = channels\n",
+ " channels = min(2 * channels, 512)\n",
+ " self.layers.append(\n",
+ " nn.Sequential(\n",
+ " nn.utils.spectral_norm(\n",
+ " nn.Conv2d(prev_channels, channels, kernel_size=4, stride=1, padding=2))\n",
+ " ,\n",
+ " nn.InstanceNorm2d(channels, affine=False),\n",
+ " nn.LeakyReLU(0.2, inplace=True),\n",
+ " nn.utils.spectral_norm(\n",
+ " nn.Conv2d(channels, 1, kernel_size=4, stride=1, padding=2)\n",
+ " ),\n",
+ " )\n",
+ " )\n",
+ "\n",
+ " def forward(self, x):\n",
+ " outputs = [] # for feature matching loss\n",
+ " for layer in self.layers:\n",
+ " x = layer(x)\n",
+ " outputs.append(x)\n",
+ "\n",
+ " return outputs"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ZchSdgY1Jrd5"
+ },
+ "source": [
+ "Now you're ready to implement the multiscale discriminator in full! This puts together the different subdiscriminator scales."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "3_kqcsh4Jwjz"
+ },
+ "source": [
+ "class Discriminator(nn.Module):\n",
+ " '''\n",
+ " Discriminator Class\n",
+ " Values:\n",
+ " in_channels: number of input channels to each discriminator, a scalar\n",
+ " base_channels: number of channels in last hidden layer, a scalar\n",
+ " n_layers: number of downsampling layers in each discriminator, a scalar\n",
+ " n_discriminators: number of discriminators at different scales, a scalar\n",
+ " '''\n",
+ "\n",
+ " def __init__(self, in_channels, base_channels=64, n_layers=3, n_discriminators=3):\n",
+ " super().__init__()\n",
+ "\n",
+ " # Initialize all discriminators\n",
+ " self.discriminators = nn.ModuleList()\n",
+ " for _ in range(n_discriminators):\n",
+ " self.discriminators.append(\n",
+ " PatchGANDiscriminator(in_channels, base_channels=base_channels, n_layers=n_layers)\n",
+ " )\n",
+ "\n",
+ " # Downsampling layer to pass inputs between discriminators at different scales\n",
+ " self.downsample = nn.AvgPool2d(3, stride=2, padding=1, count_include_pad=False)\n",
+ "\n",
+ " def forward(self, x):\n",
+ " outputs = []\n",
+ "\n",
+ " for i, discriminator in enumerate(self.discriminators):\n",
+ " # Downsample input for subsequent discriminators\n",
+ " if i != 0:\n",
+ " x = self.downsample(x)\n",
+ "\n",
+ " outputs.append(discriminator(x))\n",
+ "\n",
+ " # Return list of multiscale discriminator outputs\n",
+ " return outputs\n",
+ "\n",
+ " @property\n",
+ " def n_discriminators(self):\n",
+ " return len(self.discriminators)"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "1Vsz1XL4yjuh"
+ },
+ "source": [
+ "## GauGAN: Putting it all together\n",
+ "\n",
+ "You can now create your GauGAN model that encapsulates all the parts you've just learned about! Since the encoder outputs mean and log-variance values to sample random noise from, this implementation will use the 'reparameterization trick' to allow gradient flow to the encoder. If you're not familiar with this trick, it samples from $\\mathcal{N}(0, I)$ and applies shift and scale ($\\mu, \\sigma$) as opposed to sampling directly from $\\mathcal{N}(\\mu, \\sigma^2I)$:\n",
+ "\n",
+ "\\begin{align*}\n",
+ " z: z \\sim \\mathcal{N}(\\mu, \\sigma^2I) \\equiv \\sigma * z + \\mu: z \\sim \\mathcal{N}(0, I).\n",
+ "\\end{align*}\n",
+ "\n",
+ "Check out the optional VAE notebook for a more detailed description!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "slAXJc_wzxVT"
+ },
+ "source": [
+ "class GauGAN(nn.Module):\n",
+ " '''\n",
+ " GauGAN Class\n",
+ " Values:\n",
+ " n_classes: number of object classes in dataset, a scalar\n",
+ " spatial_size: tuple containing (height, width) of full-size image, a tuple\n",
+ " base_channels: number of channels in last generator & first discriminator layers, a scalar\n",
+ " z_dim: number of dimensions in noise vector (z), a scalar\n",
+ " n_upsample: number of downsampling (encoder) and upsampling (generator) operations, a scalar\n",
+ " n_disc_layer:: number of discriminator layers, a scalar\n",
+ " n_disc: number of discriminators (at different scales), a scalar\n",
+ " '''\n",
+ "\n",
+ " def __init__(\n",
+ " self,\n",
+ " n_classes,\n",
+ " spatial_size,\n",
+ " base_channels=64,\n",
+ " z_dim=256,\n",
+ " n_upsample=6,\n",
+ " n_disc_layers=3,\n",
+ " n_disc=3,\n",
+ " ):\n",
+ " super().__init__()\n",
+ "\n",
+ " self.encoder = Encoder(\n",
+ " spatial_size, z_dim=z_dim, n_downsample=n_upsample, base_channels=base_channels,\n",
+ " )\n",
+ " self.generator = Generator(\n",
+ " n_classes, spatial_size, z_dim=z_dim, base_channels=base_channels, n_upsample=n_upsample,\n",
+ " )\n",
+ " self.discriminator = Discriminator(\n",
+ " n_classes + 3, base_channels=base_channels, n_layers=n_disc_layers, n_discriminators=n_disc,\n",
+ " )\n",
+ "\n",
+ " def forward(self, x, seg):\n",
+ " ''' Performs a full forward pass for training. '''\n",
+ " mu, logvar = self.encode(x)\n",
+ " z = self.sample_z(mu, logvar)\n",
+ " x_fake = self.generate(z, seg)\n",
+ " pred = self.discriminate(x_fake, seg)\n",
+ " return x_fake, pred\n",
+ "\n",
+ " def encode(self, x):\n",
+ " return self.encoder(x)\n",
+ "\n",
+ " def generate(self, z, seg):\n",
+ " ''' Generates fake image from noise vector and segmentation. '''\n",
+ " return self.generator(z, seg)\n",
+ "\n",
+ " def discriminate(self, x, seg):\n",
+ " ''' Predicts whether input image is real. '''\n",
+ " return self.discriminator(torch.cat((x, seg), dim=1))\n",
+ "\n",
+ " @staticmethod\n",
+ " def sample_z(mu, logvar):\n",
+ " ''' Samples noise vector with reparameterization trick. '''\n",
+ " eps = torch.randn(mu.size(), device=mu.device).to(mu.dtype)\n",
+ " return (logvar / 2).exp() * eps + mu\n",
+ "\n",
+ " @property\n",
+ " def n_disc(self):\n",
+ " return self.discriminator.n_discriminators"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "pYlQTBpkkWkd"
+ },
+ "source": [
+ "## Loss Functions\n",
+ "\n",
+ "GauGAN reuses the composite loss functions that Pix2PixHD does, except it replaces the LSGAN loss with [Hinge loss](https://paperswithcode.com/method/gan-hinge-loss). It also imposes a soft (0.05 weight) Kullbach-Leibler divergence (KLD) loss term on the Gaussian statistics generated by the encoder.\n",
+ "\n",
+ "#### A debrief on KLD\n",
+ "\n",
+ "KLD measures how different two probability distributions are. In the case of $\\mathcal{N}(\\mu, \\sigma^2I)$ learned by the encoder, KLD loss encourages the learned distribution to be close to a standard Gaussian. For more information on implementation, check out Pytorch's [KLDivLoss](https://pytorch.org/docs/stable/generated/torch.nn.KLDivLoss.html) documentation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "QCXhrrsudbB2"
+ },
+ "source": [
+ "import torchvision.models as models\n",
+ "\n",
+ "class VGG19(nn.Module):\n",
+ " '''\n",
+ " VGG19 Class\n",
+ " Wrapper for pretrained torchvision.models.vgg19 to output intermediate feature maps\n",
+ " '''\n",
+ "\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ " vgg_features = models.vgg19(pretrained=True).features\n",
+ "\n",
+ " self.f1 = nn.Sequential(*[vgg_features[x] for x in range(2)])\n",
+ " self.f2 = nn.Sequential(*[vgg_features[x] for x in range(2, 7)])\n",
+ " self.f3 = nn.Sequential(*[vgg_features[x] for x in range(7, 12)])\n",
+ " self.f4 = nn.Sequential(*[vgg_features[x] for x in range(12, 21)])\n",
+ " self.f5 = nn.Sequential(*[vgg_features[x] for x in range(21, 30)])\n",
+ "\n",
+ " for param in self.parameters():\n",
+ " param.requires_grad = False\n",
+ "\n",
+ " def forward(self, x):\n",
+ " h1 = self.f1(x)\n",
+ " h2 = self.f2(h1)\n",
+ " h3 = self.f3(h2)\n",
+ " h4 = self.f4(h3)\n",
+ " h5 = self.f5(h4)\n",
+ " return [h1, h2, h3, h4, h5]\n",
+ "\n",
+ "class Loss(nn.Module):\n",
+ " '''\n",
+ " Loss Class\n",
+ " Implements composite loss for GauGAN\n",
+ " Values:\n",
+ " lambda1: weight for feature matching loss, a float\n",
+ " lambda2: weight for vgg perceptual loss, a float\n",
+ " lambda3: weight for KLD loss, a float\n",
+ " device: 'cuda' or 'cpu' for hardware to use\n",
+ " norm_weight_to_one: whether to normalize weights to (0, 1], a bool\n",
+ " '''\n",
+ "\n",
+ " def __init__(self, lambda1=10., lambda2=10., lambda3=0.05, device='cuda', norm_weight_to_one=True):\n",
+ " super().__init__()\n",
+ "\n",
+ " self.vgg = VGG19().to(device)\n",
+ " self.vgg_weights = [1.0/32, 1.0/16, 1.0/8, 1.0/4, 1.0]\n",
+ "\n",
+ " lambda0 = 1.0\n",
+ " # Keep ratio of composite loss, but scale down max to 1.0\n",
+ " scale = max(lambda0, lambda1, lambda2, lambda3) if norm_weight_to_one else 1.0\n",
+ "\n",
+ " self.lambda0 = lambda0 / scale\n",
+ " self.lambda1 = lambda1 / scale\n",
+ " self.lambda2 = lambda2 / scale\n",
+ " self.lambda3 = lambda3 / scale\n",
+ "\n",
+ " def kld_loss(self, mu, logvar):\n",
+ " return -0.5 * torch.sum(1 + logvar - mu ** 2 - logvar.exp())\n",
+ "\n",
+ " def g_adv_loss(self, discriminator_preds):\n",
+ " adv_loss = 0.0\n",
+ " for preds in discriminator_preds:\n",
+ " pred = preds[-1]\n",
+ " adv_loss += -pred.mean()\n",
+ " return adv_loss\n",
+ "\n",
+ " def d_adv_loss(self, discriminator_preds, is_real):\n",
+ " adv_loss = 0.0\n",
+ " for preds in discriminator_preds:\n",
+ " pred = preds[-1]\n",
+ " target = -1 + pred if is_real else -1 - pred\n",
+ " mask = target < 0\n",
+ " adv_loss += (mask * target).mean()\n",
+ " return adv_loss\n",
+ "\n",
+ " def fm_loss(self, real_preds, fake_preds):\n",
+ " fm_loss = 0.0\n",
+ " for real_features, fake_features in zip(real_preds, fake_preds):\n",
+ " for real_feature, fake_feature in zip(real_features, fake_features):\n",
+ " fm_loss += F.l1_loss(real_feature.detach(), fake_feature)\n",
+ " return fm_loss\n",
+ "\n",
+ " def vgg_loss(self, x_real, x_fake):\n",
+ " vgg_real = self.vgg(x_real)\n",
+ " vgg_fake = self.vgg(x_fake)\n",
+ "\n",
+ " vgg_loss = 0.0\n",
+ " for real, fake, weight in zip(vgg_real, vgg_fake, self.vgg_weights):\n",
+ " vgg_loss += weight * F.l1_loss(real.detach(), fake)\n",
+ " return vgg_loss\n",
+ "\n",
+ " def forward(self, x_real, label_map, gaugan):\n",
+ " '''\n",
+ " Function that computes the forward pass and total loss for GauGAN.\n",
+ " '''\n",
+ " mu, logvar = gaugan.encode(x_real)\n",
+ " z = gaugan.sample_z(mu, logvar)\n",
+ " x_fake = gaugan.generate(z, label_map)\n",
+ "\n",
+ " # Get necessary outputs for loss/backprop for both generator and discriminator\n",
+ " fake_preds_for_g = gaugan.discriminate(x_fake, label_map)\n",
+ " fake_preds_for_d = gaugan.discriminate(x_fake.detach(), label_map)\n",
+ " real_preds_for_d = gaugan.discriminate(x_real.detach(), label_map)\n",
+ "\n",
+ " g_loss = (\n",
+ " self.lambda0 * self.g_adv_loss(fake_preds_for_g) + \\\n",
+ " self.lambda1 * self.fm_loss(real_preds_for_d, fake_preds_for_g) / gaugan.n_disc + \\\n",
+ " self.lambda2 * self.vgg_loss(x_fake, x_real) + \\\n",
+ " self.lambda3 * self.kld_loss(mu, logvar)\n",
+ " )\n",
+ " d_loss = 0.5 * (\n",
+ " self.d_adv_loss(real_preds_for_d, True) + \\\n",
+ " self.d_adv_loss(fake_preds_for_d, False)\n",
+ " )\n",
+ "\n",
+ " return g_loss, d_loss, x_fake.detach()"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "EcyavR5oLmau"
+ },
+ "source": [
+ "## Training GauGAN\n",
+ "\n",
+ "You now have GauGAN implemented! All you have to do now is prepare your dataset. The authors trained GauGAN on a variety of datasets, but for simplicity, this notebook is geared towards the Cityscapes dataset (Pix2PixHD is also trained on the Cityscapes dataset). You'll have to download the dataset, unzip it, and put it in your `data` folder to initialize the dataset code below.\n",
+ "\n",
+ "Specifically, you should download the `gtFine_trainvaltest` and `leftImg8bit_trainvaltest` and specify the corresponding data splits into the dataloader.\n",
+ "\n",
+ "Below is a quick dataset class to help you load and preprocess the Cityscapes examples."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "mII5L2cZLlpO"
+ },
+ "source": [
+ "import os\n",
+ "\n",
+ "import numpy as np\n",
+ "import torchvision.transforms as transforms\n",
+ "from PIL import Image\n",
+ "\n",
+ "class CityscapesDataset(torch.utils.data.Dataset):\n",
+ " '''\n",
+ " CityscapesDataset Class\n",
+ " Values:\n",
+ " paths: (a list of) paths to construct dataset from, a list or string\n",
+ " img_size: tuple containing the (height, width) for resizing, a tuple\n",
+ " n_classes: the number of object classes, a scalar\n",
+ " '''\n",
+ "\n",
+ " def __init__(self, paths, img_size=(256, 512), n_classes=35):\n",
+ " super().__init__()\n",
+ "\n",
+ " self.n_classes = n_classes\n",
+ "\n",
+ " # Collect list of examples\n",
+ " self.examples = {}\n",
+ " if type(paths) == str:\n",
+ " self.load_examples_from_dir(paths)\n",
+ " elif type(paths) == list:\n",
+ " for path in paths:\n",
+ " self.load_examples_from_dir(path)\n",
+ " else:\n",
+ " raise ValueError('`paths` should be a single path or list of paths')\n",
+ "\n",
+ " self.examples = list(self.examples.values())\n",
+ " assert all(len(example) == 2 for example in self.examples)\n",
+ "\n",
+ " # Initialize transforms for the real color image\n",
+ " self.img_transforms = transforms.Compose([\n",
+ " transforms.Resize(img_size),\n",
+ " transforms.Lambda(lambda img: np.array(img)),\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n",
+ " ])\n",
+ "\n",
+ " # Initialize transforms for semantic label maps\n",
+ " self.map_transforms = transforms.Compose([\n",
+ " transforms.Resize(img_size),\n",
+ " transforms.Lambda(lambda img: np.array(img)),\n",
+ " transforms.ToTensor(),\n",
+ " ])\n",
+ "\n",
+ " def load_examples_from_dir(self, abs_path):\n",
+ " '''\n",
+ " Given a folder of examples, this function returns a list of paired examples.\n",
+ " '''\n",
+ " assert os.path.isdir(abs_path)\n",
+ "\n",
+ " img_suffix = '_leftImg8bit.png'\n",
+ " label_suffix = '_gtFine_labelIds.png'\n",
+ "\n",
+ " for root, _, files in os.walk(abs_path):\n",
+ " for f in files:\n",
+ " if f.endswith(img_suffix):\n",
+ " prefix = f[:-len(img_suffix)]\n",
+ " attr = 'orig_img'\n",
+ " elif f.endswith(label_suffix):\n",
+ " prefix = f[:-len(label_suffix)]\n",
+ " attr = 'label_map'\n",
+ " else:\n",
+ " continue\n",
+ "\n",
+ " if prefix not in self.examples.keys():\n",
+ " self.examples[prefix] = {}\n",
+ " self.examples[prefix][attr] = root + '/' + f\n",
+ "\n",
+ " def __getitem__(self, idx):\n",
+ " example = self.examples[idx]\n",
+ "\n",
+ " # Load image and maps\n",
+ " img = Image.open(example['orig_img']).convert('RGB') # color image: (3, h, w)\n",
+ " label = Image.open(example['label_map']) # semantic label map: (1, h, w)\n",
+ "\n",
+ " # Apply corresponding transforms\n",
+ " img = self.img_transforms(img)\n",
+ " label = self.map_transforms(label).long() * 255\n",
+ "\n",
+ " # Convert labels to one-hot vectors\n",
+ " label = F.one_hot(label, num_classes=self.n_classes)\n",
+ " label = label.squeeze(0).permute(2, 0, 1).to(img.dtype)\n",
+ "\n",
+ " return (img, label)\n",
+ "\n",
+ " def __len__(self):\n",
+ " return len(self.examples)\n",
+ "\n",
+ " @staticmethod\n",
+ " def collate_fn(batch):\n",
+ " imgs, labels = [], []\n",
+ " for (x, l) in batch:\n",
+ " imgs.append(x)\n",
+ " labels.append(l)\n",
+ " return torch.stack(imgs, dim=0), torch.stack(labels, dim=0)"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "51StN80TCpgE"
+ },
+ "source": [
+ "Now initialize everything you'll need for training. Don't be worried if there looks like a lot of random code, it's all stuff you've seen before!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "KG1ZIAI8DgJX"
+ },
+ "source": [
+ "from tqdm import tqdm\n",
+ "from torch.utils.data import DataLoader\n",
+ "\n",
+ "def lr_lambda(epoch):\n",
+ " ''' Function for scheduling learning rate '''\n",
+ " return 1. if epoch < decay_after else 1 - float(epoch - decay_after) / (epochs - decay_after)\n",
+ "\n",
+ "def weights_init(m):\n",
+ " ''' Function for initializing all model weights '''\n",
+ " if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):\n",
+ " nn.init.xavier_uniform_(m.weights_init)\n",
+ "\n",
+ "# Initialize model\n",
+ "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
+ "gaugan_config = {\n",
+ " 'n_classes': 35,\n",
+ " 'spatial_size': (128, 256), # Default (256, 512): halve size for memory\n",
+ " 'base_channels': 32, # Default 64: halve channels for memory\n",
+ " 'z_dim': 256,\n",
+ " 'n_upsample': 5, # Default 6: decrease layers for memory\n",
+ " 'n_disc_layers': 2,\n",
+ " 'n_disc': 3,\n",
+ "}\n",
+ "gaugan = GauGAN(**gaugan_config).to(device)\n",
+ "loss = Loss(device=device)\n",
+ "\n",
+ "# Initialize dataloader\n",
+ "train_dir = ['data']\n",
+ "batch_size = 16 # Default 32: decrease for memory\n",
+ "dataset = CityscapesDataset(\n",
+ " train_dir, img_size=gaugan_config['spatial_size'], n_classes=gaugan_config['n_classes'],\n",
+ ")\n",
+ "dataloader = DataLoader(\n",
+ " dataset, collate_fn=CityscapesDataset.collate_fn,\n",
+ " batch_size=batch_size, shuffle=True,\n",
+ " drop_last=False, pin_memory=True,\n",
+ ")\n",
+ "\n",
+ "# Initialize optimizers + schedulers\n",
+ "epochs = 200 # total number of train epochs\n",
+ "decay_after = 100 # number of epochs with constant lr\n",
+ "betas = (0.0, 0.999)\n",
+ "\n",
+ "g_params = list(gaugan.generator.parameters()) + list(gaugan.encoder.parameters())\n",
+ "d_params = list(gaugan.discriminator.parameters())\n",
+ "\n",
+ "g_optimizer = torch.optim.Adam(g_params, lr=1e-4, betas=betas)\n",
+ "d_optimizer = torch.optim.Adam(d_params, lr=4e-4, betas=betas)\n",
+ "g_scheduler = torch.optim.lr_scheduler.LambdaLR(g_optimizer, lr_lambda)\n",
+ "d_scheduler = torch.optim.lr_scheduler.LambdaLR(d_optimizer, lr_lambda)"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "VwyO_padKxW5"
+ },
+ "source": [
+ "And now the training loop, which is pretty much the same between the two phases:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "w-2lU4TnK5ik",
+ "outputId": "a51b2643-9efe-4141-f9c3-7cba91398cc4",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 1000
+ }
+ },
+ "source": [
+ "from torchvision.utils import make_grid\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "# Parse torch version for autocast\n",
+ "# #################################################\n",
+ "version = torch.__version__\n",
+ "version = tuple(int(n) for n in version.split('.')[:-1])\n",
+ "has_autocast = version >= (1, 6)\n",
+ "# #################################################\n",
+ "\n",
+ "def show_tensor_images(image_tensor):\n",
+ " '''\n",
+ " Function for visualizing images: Given a tensor of images, number of images, and\n",
+ " size per image, plots and prints the images in an uniform grid.\n",
+ " '''\n",
+ " image_tensor = (image_tensor + 1) / 2\n",
+ " image_unflat = image_tensor.detach().cpu()\n",
+ " image_grid = make_grid(image_unflat[:1], nrow=1)\n",
+ " plt.imshow(image_grid.permute(1, 2, 0).squeeze())\n",
+ " plt.show()\n",
+ "\n",
+ "def train(dataloader, gaugan, optimizers, schedulers, device):\n",
+ " g_optimizer, d_optimizer = optimizers\n",
+ " g_scheduler, d_scheduler = schedulers\n",
+ "\n",
+ " cur_step = 0\n",
+ " display_step = 100\n",
+ "\n",
+ " mean_g_loss = 0.0\n",
+ " mean_d_loss = 0.0\n",
+ "\n",
+ " for epoch in range(epochs):\n",
+ " # Training epoch\n",
+ " for (x_real, labels) in tqdm(dataloader, position=0):\n",
+ " x_real = x_real.to(device)\n",
+ " labels = labels.to(device)\n",
+ "\n",
+ " # Enable autocast to FP16 tensors (new feature since torch==1.6.0)\n",
+ " # If you're running older versions of torch, comment this out\n",
+ " # and use NVIDIA apex for mixed/half precision training\n",
+ " if has_autocast:\n",
+ " with torch.cuda.amp.autocast(enabled=(device=='cuda')):\n",
+ " g_loss, d_loss, x_fake = loss(x_real, labels, gaugan)\n",
+ " else:\n",
+ " g_loss, d_loss, x_fake = loss(x_real, labels, gaugan)\n",
+ "\n",
+ " g_optimizer.zero_grad()\n",
+ " g_loss.backward()\n",
+ " g_optimizer.step()\n",
+ "\n",
+ " d_optimizer.zero_grad()\n",
+ " d_loss.backward()\n",
+ " d_optimizer.step()\n",
+ "\n",
+ " mean_g_loss += g_loss.item() / display_step\n",
+ " mean_d_loss += d_loss.item() / display_step\n",
+ "\n",
+ " if cur_step % display_step == 0 and cur_step > 0:\n",
+ " print('Step {}: Generator loss: {:.5f}, Discriminator loss: {:.5f}'\n",
+ " .format(cur_step, mean_g_loss, mean_d_loss))\n",
+ " show_tensor_images(x_fake.to(x_real.dtype))\n",
+ " show_tensor_images(x_real)\n",
+ " mean_g_loss = 0.0\n",
+ " mean_d_loss = 0.0\n",
+ " cur_step += 1\n",
+ "\n",
+ " g_scheduler.step()\n",
+ " d_scheduler.step()\n",
+ "\n",
+ "train(\n",
+ " dataloader, gaugan,\n",
+ " [g_optimizer, d_optimizer],\n",
+ " [g_scheduler, d_scheduler],\n",
+ " device,\n",
+ ")"
+ ],
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "text": [
+ "100%|██████████| 11/11 [00:32<00:00, 3.00s/it]\n",
+ "100%|██████████| 11/11 [00:32<00:00, 2.97s/it]\n",
+ "100%|██████████| 11/11 [00:32<00:00, 2.96s/it]\n",
+ "100%|██████████| 11/11 [00:32<00:00, 2.98s/it]\n",
+ "100%|██████████| 11/11 [00:32<00:00, 2.98s/it]\n",
+ "100%|██████████| 11/11 [00:32<00:00, 2.99s/it]\n",
+ "100%|██████████| 11/11 [00:32<00:00, 2.97s/it]\n",
+ "100%|██████████| 11/11 [00:32<00:00, 2.95s/it]\n",
+ "100%|██████████| 11/11 [00:32<00:00, 2.97s/it]\n",
+ " 9%|▉ | 1/11 [00:03<00:30, 3.02s/it]"
+ ],
+ "name": "stderr"
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Step 100: Generator loss: 9.22943, Discriminator loss: -26.50570\n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "