diff --git a/C3W2_Pix2PixHD_(Optional).ipynb b/C3W2_Pix2PixHD_(Optional).ipynb
new file mode 100644
index 0000000..ab56994
--- /dev/null
+++ b/C3W2_Pix2PixHD_(Optional).ipynb
@@ -0,0 +1,1273 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "C3W2: Pix2PixHD (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": [
+ "# Pix2PixHD\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",
+ " - Residual blocks, from [Deep Residual Learning for Image Recognition](https://arxiv.org/abs/1512.03385) (He et al. 2015)\n",
+ " - Perceptual loss, from [Perceptual Losses for Real-Time Style Transfer and Super-Resolution](https://arxiv.org/abs/1603.08155) (Johnson et al. 2016)\n",
+ " - VGG architecture, from [Very Deep Convolutional Networks for Large-Scale Image Recognition](https://arxiv.org/abs/1409.1556) (Simonyan et al. 2015)\n",
+ " - Instance normalization (which you should know from StyleGAN), from [Instance Normalization: The Missing Ingredient for Fast Stylization](https://arxiv.org/abs/1607.08022) (Ulyanov et al. 2017)\n",
+ " - Reflection padding, which Pytorch has implemented in [torch.nn.ReflectionPad2d](https://pytorch.org/docs/stable/generated/torch.nn.ReflectionPad2d.html)\n",
+ "\n",
+ "**Goals**\n",
+ "\n",
+ "In this notebook, you will learn about Pix2PixHD, which synthesizes high-resolution images from semantic label maps. Proposed in [High-Resolution Image Synthesis and Semantic Manipulation with Conditional GANs](https://arxiv.org/abs/1711.11585) (Wang et al. 2018), Pix2PixHD improves upon Pix2Pix via multiscale architecture, improved adversarial loss, and instance maps."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "fB1Vq8ps7Bfd"
+ },
+ "source": [
+ "## Residual Blocks\n",
+ "\n",
+ "The residual block, which is relevant in many state-of-the-art computer vision models, is used in all parts of Pix2PixHD. If you're not familiar with residual blocks, please take a look [here](https://paperswithcode.com/method/residual-block). Now, you'll start by first implementing a basic residual block."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "GHD_wif07f4b"
+ },
+ "source": [
+ "import torch\n",
+ "import torch.nn as nn\n",
+ "import torch.nn.functional as F\n",
+ "\n",
+ "class ResidualBlock(nn.Module):\n",
+ " '''\n",
+ " ResidualBlock Class\n",
+ " Values\n",
+ " channels: the number of channels throughout the residual block, a scalar\n",
+ " '''\n",
+ "\n",
+ " def __init__(self, channels):\n",
+ " super().__init__()\n",
+ "\n",
+ " self.layers = nn.Sequential(\n",
+ " nn.ReflectionPad2d(1),\n",
+ " nn.Conv2d(channels, channels, kernel_size=3, padding=0),\n",
+ " nn.InstanceNorm2d(channels, affine=False),\n",
+ "\n",
+ " nn.ReLU(inplace=True),\n",
+ "\n",
+ " nn.ReflectionPad2d(1),\n",
+ " nn.Conv2d(channels, channels, kernel_size=3, padding=0),\n",
+ " nn.InstanceNorm2d(channels, affine=False),\n",
+ " )\n",
+ "\n",
+ " def forward(self, x):\n",
+ " return x + self.layers(x)"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Sqet5X_Sf-KZ"
+ },
+ "source": [
+ "## Multiscale Generator: Generating at multiple scales (resolutions)\n",
+ "\n",
+ "The Pix2PixHD generator is comprised of two separate subcomponent generators: $G_1$ is called the global generator and operates at low resolution (1024 x 512) to transfer styles. $G_2$ is the local enhancer and operates at high resolution (2048 x 1024) to deal with higher resolution.\n",
+ "\n",
+ "The architecture for each network is adapted from [Perceptual Losses for Real-Time Style Transfer and Super-Resolution](https://arxiv.org/abs/1603.08155) (Johnson et al. 2016) and is comprised of\n",
+ "\n",
+ "\\begin{align*}\n",
+ " G = \\left[G^{(F)}, G^{(R)}, G^{(B)}\\right],\n",
+ "\\end{align*}\n",
+ "\n",
+ "where $G^{(F)}$ is a frontend of convolutional blocks (downsampling), $G^{(R)}$ is a set of residual blocks, and $G^{(B)}$ is a backend of transposed convolutional blocks (upsampling). This is just a type of encoder-decoder generator that you learned about with Pix2Pix!\n",
+ "\n",
+ "$G_1$ is trained first on low-resolution images. Then, $G_2$ is added to the pre-trained $G_1$ and both are trained jointly on high-resolution images. Specifically, $G_2^{(F)}$ encodes a high-resolution image, $G_1$ encodes a downsampled, low-resolution image, and the outputs from both are summed and passed sequentially to $G_2^{(R)}$ and $G_2^{(B)}$. This pre-training and fine-tuning scheme works well because the model is able to learn accurate coarser representations before using them to touch up its refined representations, since learning high-fidelity representations is generally a pretty hard task.\n",
+ "\n",
+ "> ![Pix2PixHD Generator](https://drive.google.com/uc?export=view&id=1HDGPKupDxD52JSgnuH9pANV7hhHF3BDm)\n",
+ "*Pix2PixHD Generator, taken from Figure 3 of [High-Resolution Image Synthesis and Semantic Manipulation with Conditional GANs](https://arxiv.org/abs/1711.11585) (Wang et al. 2018). Following our notation, $G = \\left[G_2^{(F)}, G_1^{(F)}, G_1^{(R)}, G_1^{(B)}, G_2^{(R)}, G_2^{(B)}\\right]$ from left to right.*"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "9QzAlLDpuhZ5"
+ },
+ "source": [
+ "### Global Subgenerator ($G_1$)\n",
+ "\n",
+ "Let's first start by building the global generator ($G_1$). Even though the global generator is nested inside the local enhancer, you'll still need a separate module for training $G_1$ on its own first."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "rarPcc8xutN5"
+ },
+ "source": [
+ "class GlobalGenerator(nn.Module):\n",
+ " '''\n",
+ " GlobalGenerator Class:\n",
+ " Implements the global subgenerator (G1) for transferring styles at lower resolutions.\n",
+ " Values:\n",
+ " in_channels: the number of input channels, a scalar\n",
+ " out_channels: the number of output channels, a scalar\n",
+ " base_channels: the number of channels in first convolutional layer, a scalar\n",
+ " fb_blocks: the number of frontend / backend blocks, a scalar\n",
+ " res_blocks: the number of residual blocks, a scalar\n",
+ " '''\n",
+ "\n",
+ " def __init__(self, in_channels, out_channels,\n",
+ " base_channels=64, fb_blocks=3, res_blocks=9):\n",
+ " super().__init__()\n",
+ "\n",
+ " # Initial convolutional layer\n",
+ " g1 = [\n",
+ " nn.ReflectionPad2d(3),\n",
+ " nn.Conv2d(in_channels, base_channels, kernel_size=7, padding=0),\n",
+ " nn.InstanceNorm2d(base_channels, affine=False),\n",
+ " nn.ReLU(inplace=True),\n",
+ " ]\n",
+ "\n",
+ " channels = base_channels\n",
+ " # Frontend blocks\n",
+ " for _ in range(fb_blocks):\n",
+ " g1 += [\n",
+ " nn.Conv2d(channels, 2 * channels, kernel_size=3, stride=2, padding=1),\n",
+ " nn.InstanceNorm2d(2 * channels, affine=False),\n",
+ " nn.ReLU(inplace=True),\n",
+ " ]\n",
+ " channels *= 2\n",
+ "\n",
+ " # Residual blocks\n",
+ " for _ in range(res_blocks):\n",
+ " g1 += [ResidualBlock(channels)]\n",
+ "\n",
+ " # Backend blocks\n",
+ " for _ in range(fb_blocks):\n",
+ " g1 += [\n",
+ " nn.ConvTranspose2d(channels, channels // 2, kernel_size=3, stride=2, padding=1, output_padding=1),\n",
+ " nn.InstanceNorm2d(channels // 2, affine=False),\n",
+ " nn.ReLU(inplace=True),\n",
+ " ]\n",
+ " channels //= 2\n",
+ "\n",
+ " # Output convolutional layer as its own nn.Sequential since it will be omitted in second training phase\n",
+ " self.out_layers = nn.Sequential(\n",
+ " nn.ReflectionPad2d(3),\n",
+ " nn.Conv2d(base_channels, out_channels, kernel_size=7, padding=0),\n",
+ " nn.Tanh(),\n",
+ " )\n",
+ "\n",
+ " self.g1 = nn.Sequential(*g1)\n",
+ "\n",
+ " def forward(self, x):\n",
+ " x = self.g1(x)\n",
+ " x = self.out_layers(x)\n",
+ " return x"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "esIlNlgE7s3h"
+ },
+ "source": [
+ "### Local Enhancer Subgenerator ($G_2$)\n",
+ "\n",
+ "And now onto the local enhancer ($G_2$)! Recall that the local enhancer uses (a pretrained) $G_1$ as part of its architecture. Following our earlier notation, recall that the residual connections from the last layers of $G_2^{(F)}$ and $G_1^{(B)}$ are added together and passed through $G_2^{(R)}$ and $G_2^{(B)}$ to synthesize a high-resolution image. Because of this, you should reuse the $G_1$ implementation so that the weights are consistent for the second training phase."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "lLkFsvt28T9Z"
+ },
+ "source": [
+ "class LocalEnhancer(nn.Module):\n",
+ " '''\n",
+ " LocalEnhancer Class: \n",
+ " Implements the local enhancer subgenerator (G2) for handling larger scale images.\n",
+ " Values:\n",
+ " in_channels: the number of input channels, a scalar\n",
+ " out_channels: the number of output channels, a scalar\n",
+ " base_channels: the number of channels in first convolutional layer, a scalar\n",
+ " global_fb_blocks: the number of global generator frontend / backend blocks, a scalar\n",
+ " global_res_blocks: the number of global generator residual blocks, a scalar\n",
+ " local_res_blocks: the number of local enhancer residual blocks, a scalar\n",
+ " '''\n",
+ "\n",
+ " def __init__(self, in_channels, out_channels, base_channels=32, global_fb_blocks=3, global_res_blocks=9, local_res_blocks=3):\n",
+ " super().__init__()\n",
+ "\n",
+ " global_base_channels = 2 * base_channels\n",
+ "\n",
+ " # Downsampling layer for high-res -> low-res input to g1\n",
+ " self.downsample = nn.AvgPool2d(3, stride=2, padding=1, count_include_pad=False)\n",
+ "\n",
+ " # Initialize global generator without its output layers\n",
+ " self.g1 = GlobalGenerator(\n",
+ " in_channels, out_channels, base_channels=global_base_channels, fb_blocks=global_fb_blocks, res_blocks=global_res_blocks,\n",
+ " ).g1\n",
+ "\n",
+ " self.g2 = nn.ModuleList()\n",
+ "\n",
+ " # Initialize local frontend block\n",
+ " self.g2.append(\n",
+ " nn.Sequential(\n",
+ " # Initial convolutional layer\n",
+ " nn.ReflectionPad2d(3),\n",
+ " nn.Conv2d(in_channels, base_channels, kernel_size=7, padding=0), \n",
+ " nn.InstanceNorm2d(base_channels, affine=False),\n",
+ " nn.ReLU(inplace=True),\n",
+ "\n",
+ " # Frontend block\n",
+ " nn.Conv2d(base_channels, 2 * base_channels, kernel_size=3, stride=2, padding=1), \n",
+ " nn.InstanceNorm2d(2 * base_channels, affine=False),\n",
+ " nn.ReLU(inplace=True),\n",
+ " )\n",
+ " )\n",
+ "\n",
+ " # Initialize local residual and backend blocks\n",
+ " self.g2.append(\n",
+ " nn.Sequential(\n",
+ " # Residual blocks\n",
+ " *[ResidualBlock(2 * base_channels) for _ in range(local_res_blocks)],\n",
+ "\n",
+ " # Backend blocks\n",
+ " nn.ConvTranspose2d(2 * base_channels, base_channels, kernel_size=3, stride=2, padding=1, output_padding=1), \n",
+ " nn.InstanceNorm2d(base_channels, affine=False),\n",
+ " nn.ReLU(inplace=True),\n",
+ "\n",
+ " # Output convolutional layer\n",
+ " nn.ReflectionPad2d(3),\n",
+ " nn.Conv2d(base_channels, out_channels, kernel_size=7, padding=0),\n",
+ " nn.Tanh(),\n",
+ " )\n",
+ " )\n",
+ "\n",
+ " def forward(self, x):\n",
+ " # Get output from g1_B\n",
+ " x_g1 = self.downsample(x)\n",
+ " x_g1 = self.g1(x_g1)\n",
+ "\n",
+ " # Get output from g2_F\n",
+ " x_g2 = self.g2[0](x)\n",
+ "\n",
+ " # Get final output from g2_B\n",
+ " return self.g2[1](x_g1 + x_g2)"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "r6g5OLPHB-e0"
+ },
+ "source": [
+ "And voilà! You now have modules for both the global subgenerator and local enhancer subgenerator!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "8HoyIbXajoMC"
+ },
+ "source": [
+ "## Multiscale Discriminator: Discriminating at different scales too!\n",
+ "\n",
+ "Pix2PixHD uses 3 separate subcomponents (subdiscriminators $D_1$, $D_2$, and $D_3$) to generate predictions. They all have the same architectures but $D_2$ and $D_3$ operate on inputs downsampled by 2x and 4x, respectively. The GAN objective is now modified as\n",
+ "\n",
+ "\\begin{align*}\n",
+ " \\min_G \\max_{D_1,D_2,D_3}\\sum_{k=1,2,3}\\mathcal{L}_{\\text{GAN}}(G, D_k)\n",
+ "\\end{align*}\n",
+ "\n",
+ "Each subdiscriminator is a PatchGAN, which you should be familiar with from Pix2Pix!\n",
+ "\n",
+ "Let's first implement a single PatchGAN - this implementation will be slightly different than the one you saw in Pix2Pix since the intermediate feature maps will be needed for computing loss."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "fYgX2B_hDxkA"
+ },
+ "source": [
+ "class Discriminator(nn.Module):\n",
+ " '''\n",
+ " Discriminator 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.Conv2d(in_channels, base_channels, kernel_size=4, stride=2, padding=2),\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.Conv2d(prev_channels, channels, kernel_size=4, stride=2, padding=2),\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.Conv2d(prev_channels, channels, kernel_size=4, stride=1, padding=2),\n",
+ " nn.InstanceNorm2d(channels, affine=False),\n",
+ " nn.LeakyReLU(0.2, inplace=True),\n",
+ " nn.Conv2d(channels, 1, kernel_size=4, stride=1, padding=2),\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 MultiscaleDiscriminator(nn.Module):\n",
+ " '''\n",
+ " MultiscaleDiscriminator Class\n",
+ " Values:\n",
+ " in_channels: number of input channels to each discriminator, a scalar\n",
+ " base_channels: number of channels in first convolutional 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",
+ " Discriminator(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": "oSFpoKLlLdpb"
+ },
+ "source": [
+ "## Instance Boundary Map: Learning boundaries between instances\n",
+ "\n",
+ "Here's a new method that adds additional information as conditional input!\n",
+ "\n",
+ "The authors observed that previous approaches have typically taken in a label map (aka. segmentation map) that labels all the pixels to be of a certain class (i.e. car) but doesn't differentiate between two instances of the same class (i.e. two cars in the image). This is the difference between *semantic label maps*, which have class labels but not instance labels, and *instance label maps*, which represent unique instances with unique numbers.\n",
+ "\n",
+ "The authors found that the most important information in the instance lelab map is actually the boundaries between instances (i.e. the outline of each car). You can create boundary maps by mapping each pixel maps to a 1 if it's a different instance from its 4 neighbors, and 0 otherwise.\n",
+ "\n",
+ "To include this information, the authors concatenate the boundary map with the semantic label map as input. From the figure below, you can see that including both as input results in much sharper generated images (right) than only inputting the semantic label map (left).\n",
+ "\n",
+ "> ![Semantic label map input vs instance boundary map input](https://drive.google.com/uc?export=view&id=18J9HN-_TJMYRHPWhygAbc7EVgxpgrl8H)\n",
+ "![Semantic label map vs instance boundary map](https://drive.google.com/uc?export=view&id=13_lT1DPUxEwWWyjf-aXGzom_D4BFze2E)\n",
+ "*Semantic label map input (top left) and its blurry output between instances (bottom left) vs. instance boundary map (top right) and the much clearer output between instances from inputting both the semantic label map and the instance boundary map (bottom right). Taken from Figures 4 and 5 of [High-Resolution Image Synthesis and Semantic Manipulation with Conditional GANs](https://arxiv.org/abs/1711.11585) (Wang et al. 2018).*"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "JzRC73GwEjY-"
+ },
+ "source": [
+ "## Instance-level Feature Encoder: Adding controllable diversity\n",
+ "\n",
+ "As you already know, the task of generation has more than one possible realistic output. For example, an object of class `road` could be concrete, cobblestone, dirt, etc. To learn this diversity, the authors introduce an encoder $E$, which takes the original image as input and outputs a feature map (like the feature extractor from Course 2, Week 1). They apply *instance-wise averaging*, averaging the feature vectors across all occurrences of each instance (so that every pixel corresponding to the same instance has the same feature vector). They then concatenate this instance-level feature embedding with the semantic label and instance boundary maps as input to the generator.\n",
+ "\n",
+ "What's cool is that the encoder $E$ is trained jointly with $G_1$. One huge backprop! When training $G_2$, $E$ is fed a downsampled image and the corresponding output is upsampled to pass into $G_2$.\n",
+ "\n",
+ "To allow for control over different features (e.g. concrete, cobblestone, and dirt) for inference, the authors first use K-means clustering to cluster all the feature vectors for each object class in the training set. You can think of this as a dictionary, mapping each class label to a set of feature vectors (so $K$ centroids, each representing different clusters of features). Now during inference, you can perform a random lookup from this dictionary for each class (e.g. road) in the semantic label map to generate one type of feature (e.g. dirt). To provide greater control, you can select among different feature types for each class to generate diverse feature types and, as a result, multi-modal outputs from the same input. \n",
+ "\n",
+ "Higher values of $K$ increase diversity and potentially decrease fidelity. You've seen this tradeoff between diversity and fidelity before with the truncation trick, and this is just another way to trade-off between them.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "dtxfYI8zR5MF"
+ },
+ "source": [
+ "class Encoder(nn.Module):\n",
+ " '''\n",
+ " Encoder Class\n",
+ " Values:\n",
+ " in_channels: number of input channels to each discriminator, a scalar\n",
+ " out_channels: number of channels in output feature map, a scalar\n",
+ " base_channels: number of channels in first convolutional layer, a scalar\n",
+ " n_layers: number of downsampling layers, a scalar\n",
+ " '''\n",
+ "\n",
+ " def __init__(self, in_channels, out_channels, base_channels=16, n_layers=4):\n",
+ " super().__init__()\n",
+ "\n",
+ " self.out_channels = out_channels\n",
+ " channels = base_channels\n",
+ "\n",
+ " layers = [\n",
+ " nn.ReflectionPad2d(3),\n",
+ " nn.Conv2d(in_channels, base_channels, kernel_size=7, padding=0), \n",
+ " nn.InstanceNorm2d(base_channels),\n",
+ " nn.ReLU(inplace=True),\n",
+ " ]\n",
+ "\n",
+ " # Downsampling layers\n",
+ " for i in range(n_layers):\n",
+ " layers += [\n",
+ " nn.Conv2d(channels, 2 * channels, kernel_size=3, stride=2, padding=1),\n",
+ " nn.InstanceNorm2d(2 * channels),\n",
+ " nn.ReLU(inplace=True),\n",
+ " ]\n",
+ " channels *= 2\n",
+ " \n",
+ " # Upsampling layers\n",
+ " for i in range(n_layers):\n",
+ " layers += [\n",
+ " nn.ConvTranspose2d(channels, channels // 2, kernel_size=3, stride=2, padding=1, output_padding=1),\n",
+ " nn.InstanceNorm2d(channels // 2),\n",
+ " nn.ReLU(inplace=True),\n",
+ " ]\n",
+ " channels //= 2\n",
+ "\n",
+ " layers += [\n",
+ " nn.ReflectionPad2d(3),\n",
+ " nn.Conv2d(base_channels, out_channels, kernel_size=7, padding=0),\n",
+ " nn.Tanh(),\n",
+ " ]\n",
+ "\n",
+ " self.layers = nn.Sequential(*layers)\n",
+ "\n",
+ " def instancewise_average_pooling(self, x, inst):\n",
+ " '''\n",
+ " Applies instance-wise average pooling.\n",
+ "\n",
+ " Given a feature map of size (b, c, h, w), the mean is computed for each b, c\n",
+ " across all h, w of the same instance\n",
+ " '''\n",
+ " x_mean = torch.zeros_like(x)\n",
+ " classes = torch.unique(inst, return_inverse=False, return_counts=False) # gather all unique classes present\n",
+ "\n",
+ " for i in classes:\n",
+ " for b in range(x.size(0)):\n",
+ " indices = torch.nonzero(inst[b:b+1] == i, as_tuple=False) # get indices of all positions equal to class i\n",
+ " for j in range(self.out_channels):\n",
+ " x_ins = x[indices[:, 0] + b, indices[:, 1] + j, indices[:, 2], indices[:, 3]]\n",
+ " mean_feat = torch.mean(x_ins).expand_as(x_ins)\n",
+ " x_mean[indices[:, 0] + b, indices[:, 1] + j, indices[:, 2], indices[:, 3]] = mean_feat\n",
+ "\n",
+ " return x_mean\n",
+ "\n",
+ " def forward(self, x, inst):\n",
+ " x = self.layers(x)\n",
+ " x = self.instancewise_average_pooling(x, inst)\n",
+ " return x"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "eQHD_S0pYx7Z"
+ },
+ "source": [
+ "## Additional Loss Functions\n",
+ "\n",
+ "In addition to the architectural and feature-map enhancements, the authors also incorporate a feature matching loss based on the discriminator. Essentially, they output intermediate feature maps at different resolutions from the discriminator and try to minimize the difference between the real and fake image features.\n",
+ "\n",
+ "The authors found this to stabilize training. In this case, this forces the generator to produce natural statistics at multiple scales. This feature-matching loss is similar to StyleGAN's perceptual loss. For some semantic label map $s$ and corresponding image $x$,\n",
+ "\n",
+ "\\begin{align*}\n",
+ " \\mathcal{L}_{\\text{FM}} = \\mathbb{E}_{s,x}\\left[\\sum_{i=1}^T\\dfrac{1}{N_i}\\left|\\left|D^{(i)}_k(s, x) - D^{(i)}_k(s, G(s))\\right|\\right|_1\\right]\n",
+ "\\end{align*}\n",
+ "\n",
+ "where $T$ is the total number of layers, $N_i$ is the number of elements at layer $i$, and $D^{(i)}_k$ denotes the $i$th layer in discriminator $k$.\n",
+ "\n",
+ "The authors also report minor improvements in performance when adding perceptual loss, formulated as\n",
+ "\n",
+ "\\begin{align*}\n",
+ " \\mathcal{L}_{\\text{VGG}} = \\mathbb{E}_{s,x}\\left[\\sum_{i=1}^N\\dfrac{1}{M_i}\\left|\\left|F^i(x) - F^i(G(s))\\right|\\right|_1\\right]\n",
+ "\\end{align*}\n",
+ "\n",
+ "where $F^i$ denotes the $i$th layer with $M_i$ elements of the VGG19 network. `torchvision` provides a pretrained VGG19 network, so you'll just need a simple wrapper for it to get the intermediate outputs.\n",
+ "\n",
+ "The overall loss looks like this:\n",
+ "\n",
+ "\\begin{align*}\n",
+ " \\mathcal{L} = \\mathcal{L}_{\\text{GAN}} + \\lambda_1\\mathcal{L}_{\\text{FM}} + \\lambda_2\\mathcal{L}_{\\text{VGG}}\n",
+ "\\end{align*}\n",
+ "\n",
+ "where $\\lambda_1 = \\lambda_2 = 10$."
+ ]
+ },
+ {
+ "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",
+ " 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., device='cuda', norm_weight_to_one=True):\n",
+ " super().__init__()\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) 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",
+ "\n",
+ " def adv_loss(self, discriminator_preds, is_real):\n",
+ " '''\n",
+ " Computes adversarial loss from nested list of fakes outputs from discriminator.\n",
+ " '''\n",
+ " target = torch.ones_like if is_real else torch.zeros_like\n",
+ "\n",
+ " adv_loss = 0.0\n",
+ " for preds in discriminator_preds:\n",
+ " pred = preds[-1]\n",
+ " adv_loss += F.mse_loss(pred, target(pred))\n",
+ " return adv_loss\n",
+ "\n",
+ " def fm_loss(self, real_preds, fake_preds):\n",
+ " '''\n",
+ " Computes feature matching loss from nested lists of fake and real outputs from discriminator.\n",
+ " '''\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",
+ " '''\n",
+ " Computes perceptual loss with VGG network from real and fake images.\n",
+ " '''\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, instance_map, boundary_map, encoder, generator, discriminator):\n",
+ " '''\n",
+ " Function that computes the forward pass and total loss for generator and discriminator.\n",
+ " '''\n",
+ " feature_map = encoder(x_real, instance_map)\n",
+ " x_fake = generator(torch.cat((label_map, boundary_map, feature_map), dim=1))\n",
+ "\n",
+ " # Get necessary outputs for loss/backprop for both generator and discriminator\n",
+ " fake_preds_for_g = discriminator(torch.cat((label_map, boundary_map, x_fake), dim=1))\n",
+ " fake_preds_for_d = discriminator(torch.cat((label_map, boundary_map, x_fake.detach()), dim=1))\n",
+ " real_preds_for_d = discriminator(torch.cat((label_map, boundary_map, x_real.detach()), dim=1))\n",
+ "\n",
+ " g_loss = (\n",
+ " self.lambda0 * self.adv_loss(fake_preds_for_g, False) + \\\n",
+ " self.lambda1 * self.fm_loss(real_preds_for_d, fake_preds_for_g) / discriminator.n_discriminators + \\\n",
+ " self.lambda2 * self.vgg_loss(x_fake, x_real)\n",
+ " )\n",
+ " d_loss = 0.5 * (\n",
+ " self.adv_loss(real_preds_for_d, True) + \\\n",
+ " self.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 Pix2PixHD\n",
+ "\n",
+ "You now have the Pix2PixHD model coded up! All you have to do now is prepare your dataset. Pix2PixHD is trained on the Cityscapes dataset, which unfortunately requires registration. You'll have to download the dataset 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."
+ ]
+ },
+ {
+ "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",
+ "def scale_width(img, target_width, method):\n",
+ " '''\n",
+ " Function that scales an image to target_width while retaining aspect ratio.\n",
+ " '''\n",
+ " w, h = img.size\n",
+ " if w == target_width: return img\n",
+ " target_height = target_width * h // w\n",
+ " return img.resize((target_width, target_height), method)\n",
+ "\n",
+ "class CityscapesDataset(torch.utils.data.Dataset):\n",
+ " '''\n",
+ " CityscapesDataset Class\n",
+ " Values:\n",
+ " paths: (a list of) paths to load examples from, a list or string\n",
+ " target_width: the size of image widths for resizing, a scalar\n",
+ " n_classes: the number of object classes, a scalar\n",
+ " '''\n",
+ "\n",
+ " def __init__(self, paths, target_width=1024, 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) == 3 for example in self.examples)\n",
+ "\n",
+ " # Initialize transforms for the real color image\n",
+ " self.img_transforms = transforms.Compose([\n",
+ " transforms.Lambda(lambda img: scale_width(img, target_width, Image.BICUBIC)),\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 and instance maps\n",
+ " self.map_transforms = transforms.Compose([\n",
+ " transforms.Lambda(lambda img: scale_width(img, target_width, Image.NEAREST)),\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",
+ " inst_suffix = '_gtFine_instanceIds.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",
+ " elif f.endswith(inst_suffix):\n",
+ " prefix = f[:-len(inst_suffix)]\n",
+ " attr = 'inst_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, 512, 1024)\n",
+ " inst = Image.open(example['inst_map']) # instance map: (512, 1024)\n",
+ " label = Image.open(example['label_map']) # semantic label map: (512, 1024)\n",
+ "\n",
+ " # Apply corresponding transforms\n",
+ " img = self.img_transforms(img)\n",
+ " inst = self.map_transforms(inst)\n",
+ " label = self.map_transforms(label).long() * 255\n",
+ "\n",
+ " # Convert labels to one-hot vectors\n",
+ " label = torch.zeros(self.n_classes, img.shape[1], img.shape[2]).scatter_(0, label, 1.0).to(img.dtype)\n",
+ "\n",
+ " # Convert instance map to instance boundary map\n",
+ " bound = torch.ByteTensor(inst.shape).zero_()\n",
+ " bound[:, :, 1:] = bound[:, :, 1:] | (inst[:, :, 1:] != inst[:, :, :-1])\n",
+ " bound[:, :, :-1] = bound[:, :, :-1] | (inst[:, :, 1:] != inst[:, :, :-1])\n",
+ " bound[:, 1:, :] = bound[:, 1:, :] | (inst[:, 1:, :] != inst[:, :-1, :])\n",
+ " bound[:, :-1, :] = bound[:, :-1, :] | (inst[:, 1:, :] != inst[:, :-1, :])\n",
+ " bound = bound.to(img.dtype)\n",
+ "\n",
+ " return (img, label, inst, bound)\n",
+ "\n",
+ " def __len__(self):\n",
+ " return len(self.examples)\n",
+ "\n",
+ " @staticmethod\n",
+ " def collate_fn(batch):\n",
+ " imgs, labels, insts, bounds = [], [], [], []\n",
+ " for (x, l, i, b) in batch:\n",
+ " imgs.append(x)\n",
+ " labels.append(l)\n",
+ " insts.append(i)\n",
+ " bounds.append(b)\n",
+ " return (\n",
+ " torch.stack(imgs, dim=0),\n",
+ " torch.stack(labels, dim=0),\n",
+ " torch.stack(insts, dim=0),\n",
+ " torch.stack(bounds, dim=0),\n",
+ " )"
+ ],
+ "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",
+ "n_classes = 35 # total number of object classes\n",
+ "rgb_channels = n_features = 3\n",
+ "device = 'cuda'\n",
+ "train_dir = ['data']\n",
+ "epochs = 200 # total number of train epochs\n",
+ "decay_after = 100 # number of epochs with constant lr\n",
+ "lr = 0.0002\n",
+ "betas = (0.5, 0.999)\n",
+ "\n",
+ "def lr_lambda(epoch):\n",
+ " ''' Function for scheduling learning '''\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.ConvTranspose2d):\n",
+ " nn.init.normal_(m.weight, 0., 0.02)\n",
+ "\n",
+ "loss_fn = Loss(device=device)\n",
+ "\n",
+ "## Phase 1: Low Resolution (1024 x 512)\n",
+ "dataloader1 = DataLoader(\n",
+ " CityscapesDataset(train_dir, target_width=1024, n_classes=n_classes),\n",
+ " collate_fn=CityscapesDataset.collate_fn, batch_size=1, shuffle=True, drop_last=False, pin_memory=True,\n",
+ ")\n",
+ "encoder = Encoder(rgb_channels, n_features).to(device).apply(weights_init)\n",
+ "generator1 = GlobalGenerator(n_classes + n_features + 1, rgb_channels).to(device).apply(weights_init)\n",
+ "discriminator1 = MultiscaleDiscriminator(n_classes + 1 + rgb_channels, n_discriminators=2).to(device).apply(weights_init)\n",
+ "\n",
+ "g1_optimizer = torch.optim.Adam(list(generator1.parameters()) + list(encoder.parameters()), lr=lr, betas=betas)\n",
+ "d1_optimizer = torch.optim.Adam(list(discriminator1.parameters()), lr=lr, betas=betas)\n",
+ "g1_scheduler = torch.optim.lr_scheduler.LambdaLR(g1_optimizer, lr_lambda)\n",
+ "d1_scheduler = torch.optim.lr_scheduler.LambdaLR(d1_optimizer, lr_lambda)\n",
+ "\n",
+ "\n",
+ "## Phase 2: High Resolution (2048 x 1024)\n",
+ "dataloader2 = DataLoader(\n",
+ " CityscapesDataset(train_dir, target_width=2048, n_classes=n_classes),\n",
+ " collate_fn=CityscapesDataset.collate_fn, batch_size=1, shuffle=True, drop_last=False, pin_memory=True,\n",
+ ")\n",
+ "generator2 = LocalEnhancer(n_classes + n_features + 1, rgb_channels).to(device).apply(weights_init)\n",
+ "discriminator2 = MultiscaleDiscriminator(n_classes + 1 + rgb_channels).to(device).apply(weights_init)\n",
+ "\n",
+ "g2_optimizer = torch.optim.Adam(list(generator2.parameters()) + list(encoder.parameters()), lr=lr, betas=betas)\n",
+ "d2_optimizer = torch.optim.Adam(list(discriminator2.parameters()), lr=lr, betas=betas)\n",
+ "g2_scheduler = torch.optim.lr_scheduler.LambdaLR(g2_optimizer, lr_lambda)\n",
+ "d2_scheduler = torch.optim.lr_scheduler.LambdaLR(d2_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"
+ },
+ "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, models, optimizers, schedulers, device):\n",
+ " encoder, generator, discriminator = models\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, insts, bounds) in tqdm(dataloader, position=0):\n",
+ " x_real = x_real.to(device)\n",
+ " labels = labels.to(device)\n",
+ " insts = insts.to(device)\n",
+ " bounds = bounds.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_fn(\n",
+ " x_real, labels, insts, bounds, encoder, generator, discriminator\n",
+ " )\n",
+ " else:\n",
+ " g_loss, d_loss, x_fake = loss_fn(\n",
+ " x_real, labels, insts, bounds, encoder, generator, discriminator\n",
+ " )\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()"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "wCcV0ttk6_Mv"
+ },
+ "source": [
+ "And now you can train your models! Remember to set the local enhancer subgenerator to the global subgenerator that you train in the first phase.\n",
+ "\n",
+ "In their official repository, the authors don't continue to train the encoder. Instead, they precompute all feature maps upsample them, and concatenate this to the input to the local enhancer subgenerator. (They also leave a re-train option for it). For simplicity, the script below will just downsample and upsample high-resolution inputs."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "1-41crv17Pcn"
+ },
+ "source": [
+ "# Phase 1: Low Resolution\n",
+ "#######################################################################\n",
+ "train(\n",
+ " dataloader1,\n",
+ " [encoder, generator1, discriminator1],\n",
+ " [g1_optimizer, d1_optimizer],\n",
+ " [g1_scheduler, d1_scheduler],\n",
+ " device,\n",
+ ")\n",
+ "\n",
+ "\n",
+ "# Phase 2: High Resolution\n",
+ "#######################################################################\n",
+ "# Update global generator in local enhancer with trained\n",
+ "generator2.g1 = generator1.g1\n",
+ "\n",
+ "# Freeze encoder and wrap to support high-resolution inputs/outputs\n",
+ "def freeze(encoder):\n",
+ " encoder.eval()\n",
+ " for p in encoder.parameters():\n",
+ " p.requires_grad = False\n",
+ "\n",
+ " @torch.jit.script\n",
+ " def forward(x, inst):\n",
+ " x = F.interpolate(x, scale_factor=0.5, recompute_scale_factor=True)\n",
+ " inst = F.interpolate(inst.float(), scale_factor=0.5, recompute_scale_factor=True)\n",
+ " feat = encoder(x, inst.int())\n",
+ " return F.interpolate(feat, scale_factor=2.0, recompute_scale_factor=True)\n",
+ " return forward\n",
+ "\n",
+ "train(\n",
+ " dataloader2,\n",
+ " [freeze(encoder), generator2, discriminator2],\n",
+ " [g2_optimizer, d2_optimizer],\n",
+ " [g2_scheduler, d2_scheduler],\n",
+ " device,\n",
+ ")"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "37egKCs2YqEO"
+ },
+ "source": [
+ "## Inference with Pix2PixHD\n",
+ "\n",
+ "Recall that in inference time, the encoder feature maps from training are saved and clustered with K-means by object class. Again, you'll have to download the Cityscapes dataset into your `data` folder and then run these functions."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "69wfl6vre_cM",
+ "outputId": "cb08aea5-a28a-421b-e5dd-6441d8ee04c7",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 147
+ }
+ },
+ "source": [
+ "from sklearn.cluster import KMeans\n",
+ "\n",
+ "# Encode features by class label\n",
+ "features = {}\n",
+ "for (x, _, inst, _) in tqdm(dataloader2):\n",
+ " x = x.to(device)\n",
+ " inst = inst.to(device)\n",
+ " area = inst.size(2) * inst.size(3)\n",
+ "\n",
+ " # Get pooled feature map\n",
+ " with torch.no_grad():\n",
+ " feature_map = encoder(x, inst)\n",
+ "\n",
+ " for i in torch.unique(inst):\n",
+ " label = i if i < 1000 else i // 1000\n",
+ " label = int(label.flatten(0).item())\n",
+ "\n",
+ " # All indices should have same feature per class from pooling\n",
+ " idx = torch.nonzero(inst == i, as_tuple=False)\n",
+ " n_inst = idx.size(0)\n",
+ " idx = idx[0, :]\n",
+ "\n",
+ " # Retrieve corresponding encoded feature\n",
+ " feature = feature_map[idx[0], :, idx[2], idx[3]].unsqueeze(0)\n",
+ "\n",
+ " # Compute rate of feature appearance (in official code, they compute per block)\n",
+ " block_size = 32\n",
+ " rate_per_block = 32 * n_inst / area\n",
+ " rate = torch.ones((1, 1), device=device).to(feature.dtype) * rate_per_block\n",
+ "\n",
+ " feature = torch.cat((feature, rate), dim=1)\n",
+ " if label in features.keys():\n",
+ " features[label] = torch.cat((features[label], feature), dim=0)\n",
+ " else:\n",
+ " features[label] = feature\n",
+ "\n",
+ "\n",
+ "# Cluster features by class label\n",
+ "k = 10\n",
+ "centroids = {}\n",
+ "for label in range(n_classes):\n",
+ " if label not in features.keys():\n",
+ " continue\n",
+ " feature = features[label]\n",
+ "\n",
+ " # Thresholding by 0.5 isn't mentioned in the paper, but is present in the\n",
+ " # official code repository, probably so that only frequent features are clustered\n",
+ " feature = feature[feature[:, -1] > 0.5, :-1].cpu().numpy()\n",
+ "\n",
+ " if feature.shape[0]:\n",
+ " n_clusters = min(feature.shape[0], k)\n",
+ " kmeans = KMeans(n_clusters=n_clusters).fit(feature)\n",
+ " centroids[label] = kmeans.cluster_centers_"
+ ],
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "text": [
+ "100%|██████████| 174/174 [02:07<00:00, 1.36it/s]\n"
+ ],
+ "name": "stderr"
+ },
+ {
+ "output_type": "error",
+ "ename": "SyntaxError",
+ "evalue": "ignored",
+ "traceback": [
+ "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m54\u001b[0m\n\u001b[0;31m return centroids\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m 'return' outside function\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "f1LVqMkTjn06"
+ },
+ "source": [
+ "After getting the encoded feature centroids per class, you can now run inference! Remember that the generator is trained to take in a concatenation of the semantic label map, instance boundary map, and encoded feature map.\n",
+ "\n",
+ "Congrats on making it to the end of this complex notebook! Have fun with this powerful model and be responsible of course ;)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "3BpqE3ngk_3s",
+ "outputId": "939172eb-c90f-4050-90d4-22175fa5073a",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 421
+ }
+ },
+ "source": [
+ "def infer(label_map, instance_map, boundary_map):\n",
+ " # Sample feature vector centroids\n",
+ " b, _, h, w = label_map.shape\n",
+ " feature_map = torch.zeros((b, n_features, h, w), device=device).to(label_map.dtype)\n",
+ "\n",
+ " for i in torch.unique(instance_map):\n",
+ " label = i if i < 1000 else i // 1000\n",
+ " label = int(label.flatten(0).item())\n",
+ "\n",
+ " if label in centroids.keys():\n",
+ " centroid_idx = random.randint(0, centroids[label].shape[0] - 1)\n",
+ " idx = torch.nonzero(instance_map == int(i), as_tuple=False)\n",
+ "\n",
+ " feature = torch.from_numpy(centroids[label][centroid_idx, :]).to(device)\n",
+ " feature_map[idx[:, 0], :, idx[:, 2], idx[:, 3]] = feature\n",
+ "\n",
+ " with torch.no_grad():\n",
+ " x_fake = generator2(torch.cat((label_map, boundary_map, feature_map), dim=1))\n",
+ " return x_fake\n",
+ "\n",
+ "for x, labels, insts, bounds in dataloader2:\n",
+ " x_fake = infer(labels.to(device), insts.to(device), bounds.to(device))\n",
+ " show_tensor_images(x_fake.to(x.dtype))\n",
+ " show_tensor_images(x)\n",
+ " break"
+ ],
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "