Course 2/Week 3/Week 3 Components of StyleGAN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kz7GMf9fruXG"
   },
   "source": [
    "# Components of StyleGAN\n",
    "\n",
    "### Goals\n",
    "In this notebook, you're going to implement various components of StyleGAN, including the truncation trick, the mapping layer, noise injection, adaptive instance normalization (AdaIN), and progressive growing. \n",
    "\n",
    "### Learning Objectives\n",
    "\n",
    "1.   Understand the components of StyleGAN that differ from the traditional GAN.\n",
    "2.   Implement the components of StyleGAN.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "oI3mxAyzsexw"
   },
   "source": [
    "## Getting Started\n",
    "You will begin by importing some packages from PyTorch and defining a visualization function which will be useful later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "L1vT-DFVn252"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "def show_tensor_images(image_tensor, num_images=16, size=(3, 64, 64), nrow=3):\n",
    "    '''\n",
    "    Function for visualizing images: Given a tensor of images, number of images,\n",
    "    size per image, and images per row, plots and prints the images in an uniform grid.\n",
    "    '''\n",
    "    image_tensor = (image_tensor + 1) / 2\n",
    "    image_unflat = image_tensor.detach().cpu().clamp_(0, 1)\n",
    "    image_grid = make_grid(image_unflat[:num_images], nrow=nrow, padding=0)\n",
    "    plt.imshow(image_grid.permute(1, 2, 0).squeeze())\n",
    "    plt.axis('off')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "k7VE8l7dyo0A"
   },
   "source": [
    "## Truncation Trick\n",
    "The first component you will implement is the truncation trick. Remember that this is done after the model is trained and when you are sampling beautiful outputs. The truncation trick resamples the noise vector $z$ from a truncated normal distribution which allows you to tune the generator's fidelity/diversity. The truncation value is at least 0, where 1 means there is little truncation (high diversity) and 0 means the distribution is all truncated except for the mean (high quality/fidelity). This trick is not exclusive to StyleGAN. In fact, you may recall playing with it in an earlier GAN notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "dPpIAAOjykrQ"
   },
   "outputs": [],
   "source": [
    "# UNQ_C1 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
    "# GRADED CELL: get_truncated_noise\n",
    "\n",
    "from scipy.stats import truncnorm\n",
    "def get_truncated_noise(n_samples, z_dim, truncation):\n",
    "    '''\n",
    "    Function for creating truncated noise vectors: Given the dimensions (n_samples, z_dim)\n",
    "    and truncation value, creates a tensor of that shape filled with random\n",
    "    numbers from the truncated normal distribution.\n",
    "    Parameters:\n",
    "        n_samples: the number of samples to generate, a scalar\n",
    "        z_dim: the dimension of the noise vector, a scalar\n",
    "        truncation: the truncation value, a non-negative scalar\n",
    "    '''\n",
    "    #### START CODE HERE ####\n",
    "    truncated_noise = truncnorm.rvs(-truncation, truncation, size=(n_samples, z_dim))\n",
    "    #### END CODE HERE ####\n",
    "    return torch.Tensor(truncated_noise)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PpdtW2cxp-z7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success!\n"
     ]
    }
   ],
   "source": [
    "# Test the truncation sample\n",
    "assert tuple(get_truncated_noise(n_samples=10, z_dim=5, truncation=0.7).shape) == (10, 5)\n",
    "simple_noise = get_truncated_noise(n_samples=1000, z_dim=10, truncation=0.2)\n",
    "assert simple_noise.max() > 0.199 and simple_noise.max() < 2\n",
    "assert simple_noise.min() < -0.199 and simple_noise.min() > -0.2\n",
    "assert simple_noise.std() > 0.113 and simple_noise.std() < 0.117\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "uAtedvsisf1j"
   },
   "source": [
    "## Mapping $z$ → $w$\n",
    "\n",
    "The next component you need to implement is the mapping network. It takes the noise vector, $z$, and maps it to an intermediate noise vector, $w$. This makes it so $z$ can be represented in a more disentangled space which makes the features easier to control later.\n",
    "\n",
    "The mapping network in StyleGAN is composed of 8 layers, but for your implementation, you will use a neural network with 3 layers. This is to save time training later.\n",
    "\n",
    "<details>\n",
    "<summary>\n",
    "<font size=\"3\" color=\"green\">\n",
    "<b>Optional hints for <code><font size=\"4\">MappingLayers</font></code></b>\n",
    "</font>\n",
    "</summary>\n",
    "\n",
    "1.   This code should be five lines.\n",
    "2.   You need 3 linear layers and should use ReLU activations.\n",
    "3.   Your linear layers should be input -> hidden_dim -> hidden_dim -> output.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "C2XBgopFrsne"
   },
   "outputs": [],
   "source": [
    "# UNQ_C2 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
    "# GRADED CELL: MappingLayers\n",
    "\n",
    "class MappingLayers(nn.Module):\n",
    "    '''\n",
    "    Mapping Layers Class\n",
    "    Values:\n",
    "        z_dim: the dimension of the noise vector, a scalar\n",
    "        hidden_dim: the inner dimension, a scalar\n",
    "        w_dim: the dimension of the intermediate noise vector, a scalar\n",
    "    '''\n",
    " \n",
    "    def __init__(self, z_dim, hidden_dim, w_dim):\n",
    "        super().__init__()\n",
    "        self.mapping = nn.Sequential(\n",
    "            # Please write a neural network which takes in tensors of \n",
    "            # shape (n_samples, z_dim) and outputs (n_samples, w_dim)\n",
    "            # with a hidden layer with hidden_dim neurons\n",
    "            #### START CODE HERE ####\n",
    "            nn.Linear(z_dim, hidden_dim),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(hidden_dim, hidden_dim),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(hidden_dim, w_dim)\n",
    "            #### END CODE HERE ####\n",
    "        )\n",
    "\n",
    "    def forward(self, noise):\n",
    "        '''\n",
    "        Function for completing a forward pass of MappingLayers: \n",
    "        Given an initial noise tensor, returns the intermediate noise tensor.\n",
    "        Parameters:\n",
    "            noise: a noise tensor with dimensions (n_samples, z_dim)\n",
    "        '''\n",
    "        return self.mapping(noise)\n",
    "    \n",
    "    #UNIT TEST COMMENT: Required for grading\n",
    "    def get_mapping(self):\n",
    "        return self.mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "68W1aD-P0_vP"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success!\n"
     ]
    }
   ],
   "source": [
    "# Test the mapping function\n",
    "map_fn = MappingLayers(10,20,30)\n",
    "assert tuple(map_fn(torch.randn(2, 10)).shape) == (2, 30)\n",
    "assert len(map_fn.mapping) > 4\n",
    "outputs = map_fn(torch.randn(1000, 10))\n",
    "assert outputs.std() > 0.05 and outputs.std() < 0.3\n",
    "assert outputs.min() > -2 and outputs.min() < 0\n",
    "assert outputs.max() < 2 and outputs.max() > 0\n",
    "layers = [str(x).replace(' ', '').replace('inplace=True', '') for x in map_fn.get_mapping()]\n",
    "assert layers == ['Linear(in_features=10,out_features=20,bias=True)', \n",
    "                  'ReLU()', \n",
    "                  'Linear(in_features=20,out_features=20,bias=True)', \n",
    "                  'ReLU()', \n",
    "                  'Linear(in_features=20,out_features=30,bias=True)']\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nfMvkudy1y9O"
   },
   "source": [
    "## Random Noise Injection\n",
    "Next, you will implement the random noise injection that occurs before every AdaIN block. To do this, you need to create a noise tensor that is the same size as the current feature map (image).\n",
    "\n",
    "The noise tensor is not entirely random; it is initialized as one random channel that is then multiplied by learned weights for each channel in the image. For example, imagine an image has 512 channels and its height and width are (4 x 4). You would first create a random (4 x 4) noise matrix with one channel. Then, your model would create 512 values—one for each channel. Next, you multiply the (4 x 4) matrix by each one of these values. This creates a \"random\" tensor of 512 channels and (4 x 4) pixels, the same dimensions as the image. Finally, you add this noise tensor to the image. This introduces uncorrelated noise and is meant to increase the diversity in the image.\n",
    "\n",
    "New starting weights are generated for every new layer, or generator, where this class is used. Within a layer, every following time the noise injection is called, you take another step with the optimizer and the weights that you use for each channel are optimized (i.e. learned).\n",
    "\n",
    "<details>\n",
    "\n",
    "<summary>\n",
    "<font size=\"3\" color=\"green\">\n",
    "<b>Optional hint for <code><font size=\"4\">InjectNoise</font></code></b>\n",
    "</font>\n",
    "</summary>\n",
    "\n",
    "1.   The weight should have the shape (1, channels, 1, 1).\n",
    "</details>\n",
    "\n",
    "<!-- <details>\n",
    "\n",
    "<summary>\n",
    "<font size=\"3\" color=\"green\">\n",
    "<b>Optional hint for <code><font size=\"4\">InjectNoise</font></code></b>\n",
    "</font>\n",
    "</summary>\n",
    "\n",
    "1.   Remember that you only make the noise for one channel (it is then multiplied by random values to create ones for the other channels).\n",
    "</details> -->\n",
    "\n",
    "<!-- (not sure how??) You'll find the get_noise function from before helpful here -->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "biLJxq3P11qY"
   },
   "outputs": [],
   "source": [
    "# UNQ_C3 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
    "# GRADED CELL: InjectNoise\n",
    "\n",
    "class InjectNoise(nn.Module):\n",
    "    '''\n",
    "    Inject Noise Class\n",
    "    Values:\n",
    "        channels: the number of channels the image has, a scalar\n",
    "    '''\n",
    "    def __init__(self, channels):\n",
    "        super().__init__()\n",
    "        self.weight = nn.Parameter( # You use nn.Parameter so that these weights can be optimized\n",
    "            # Initiate the weights for the channels from a random normal distribution\n",
    "            #### START CODE HERE ####\n",
    "            torch.randn(1, channels, 1, 1)\n",
    "            #### END CODE HERE ####\n",
    "        )\n",
    "\n",
    "    def forward(self, image):\n",
    "        '''\n",
    "        Function for completing a forward pass of InjectNoise: Given an image, \n",
    "        returns the image with random noise added.\n",
    "        Parameters:\n",
    "            image: the feature map of shape (n_samples, channels, width, height)\n",
    "        '''\n",
    "        # Set the appropriate shape for the noise!\n",
    "        \n",
    "        #### START CODE HERE ####\n",
    "        noise_shape = (image.shape[0], 1, image.shape[2], image.shape[3])\n",
    "        #### END CODE HERE ####\n",
    "        \n",
    "        noise = torch.randn(noise_shape, device=image.device) # Creates the random noise\n",
    "        return image + self.weight * noise # Applies to image after multiplying by the weight for each channel\n",
    "    \n",
    "    #UNIT TEST COMMENT: Required for grading\n",
    "    def get_weight(self):\n",
    "        return self.weight\n",
    "    \n",
    "    #UNIT TEST COMMENT: Required for grading\n",
    "    def get_self(self):\n",
    "        return self\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zO1v6hos_Od0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success!\n"
     ]
    }
   ],
   "source": [
    "# UNIT TEST\n",
    "test_noise_channels = 3000\n",
    "test_noise_samples = 20\n",
    "fake_images = torch.randn(test_noise_samples, test_noise_channels, 10, 10)\n",
    "inject_noise = InjectNoise(test_noise_channels)\n",
    "assert torch.abs(inject_noise.weight.std() - 1) < 0.1\n",
    "assert torch.abs(inject_noise.weight.mean()) < 0.1\n",
    "assert type(inject_noise.get_weight()) == torch.nn.parameter.Parameter\n",
    "\n",
    "assert tuple(inject_noise.weight.shape) == (1, test_noise_channels, 1, 1)\n",
    "inject_noise.weight = nn.Parameter(torch.ones_like(inject_noise.weight))\n",
    "# Check that something changed\n",
    "assert torch.abs((inject_noise(fake_images) - fake_images)).mean() > 0.1\n",
    "# Check that the change is per-channel\n",
    "assert torch.abs((inject_noise(fake_images) - fake_images).std(0)).mean() > 1e-4\n",
    "assert torch.abs((inject_noise(fake_images) - fake_images).std(1)).mean() < 1e-4\n",
    "assert torch.abs((inject_noise(fake_images) - fake_images).std(2)).mean() > 1e-4\n",
    "assert torch.abs((inject_noise(fake_images) - fake_images).std(3)).mean() > 1e-4\n",
    "# Check that the per-channel change is roughly normal\n",
    "per_channel_change = (inject_noise(fake_images) - fake_images).mean(1).std()\n",
    "assert per_channel_change > 0.9 and per_channel_change < 1.1\n",
    "# Make sure that the weights are being used at all\n",
    "inject_noise.weight = nn.Parameter(torch.zeros_like(inject_noise.weight))\n",
    "assert torch.abs((inject_noise(fake_images) - fake_images)).mean() < 1e-4\n",
    "assert len(inject_noise.weight.shape) == 4\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xTGkpHwrsqay"
   },
   "source": [
    "## Adaptive Instance Normalization (AdaIN)\n",
    "The next component you will implement is AdaIN. To increase control over the image, you inject $w$ — the intermediate noise vector — multiple times throughout StyleGAN. This is done by transforming it into a set of style parameters and introducing the style to the image through AdaIN. Given an image ($x_i$) and the intermediate vector ($w$), AdaIN takes the instance normalization of the image and multiplies it by the style scale ($y_s$) and adds the style bias ($y_b$). You need to calculate the learnable style scale and bias by using linear mappings from $w$.\n",
    "\n",
    "# $ \\text{AdaIN}(\\boldsymbol{\\mathrm{x}}_i, \\boldsymbol{\\mathrm{y}}) = \\boldsymbol{\\mathrm{y}}_{s,i} \\frac{\\boldsymbol{\\mathrm{x}}_i - \\mu(\\boldsymbol{\\mathrm{x}}_i)}{\\sigma(\\boldsymbol{\\mathrm{x}}_i)} + \\boldsymbol{\\mathrm{y}}_{b,i} $\n",
    "\n",
    "<details>\n",
    "\n",
    "<summary>\n",
    "<font size=\"3\" color=\"green\">\n",
    "<b>Optional hints for <code><font size=\"4\">forward</font></code></b>\n",
    "</font>\n",
    "</summary>\n",
    "\n",
    "1.   Remember the equation for AdaIN.\n",
    "2.   The instance normalized image, style scale, and style shift have already been calculated for you.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "aDyqXHUvsp1G"
   },
   "outputs": [],
   "source": [
    "# UNQ_C4 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
    "# GRADED CELL: AdaIN\n",
    "\n",
    "class AdaIN(nn.Module):\n",
    "    '''\n",
    "    AdaIN Class\n",
    "    Values:\n",
    "        channels: the number of channels the image has, a scalar\n",
    "        w_dim: the dimension of the intermediate noise vector, a scalar\n",
    "    '''\n",
    "\n",
    "    def __init__(self, channels, w_dim):\n",
    "        super().__init__()\n",
    "\n",
    "        # Normalize the input per-dimension\n",
    "        self.instance_norm = nn.InstanceNorm2d(channels)\n",
    "\n",
    "        # You want to map w to a set of style weights per channel.\n",
    "        # Replace the Nones with the correct dimensions - keep in mind that \n",
    "        # both linear maps transform a w vector into style weights \n",
    "        # corresponding to the number of image channels.\n",
    "        #### START CODE HERE ####\n",
    "        self.style_scale_transform = nn.Linear(w_dim, channels)\n",
    "        self.style_shift_transform = nn.Linear(w_dim, channels)\n",
    "        #### END CODE HERE ####\n",
    "\n",
    "    def forward(self, image, w):\n",
    "        '''\n",
    "        Function for completing a forward pass of AdaIN: Given an image and intermediate noise vector w, \n",
    "        returns the normalized image that has been scaled and shifted by the style.\n",
    "        Parameters:\n",
    "            image: the feature map of shape (n_samples, channels, width, height)\n",
    "            w: the intermediate noise vector\n",
    "        '''\n",
    "        normalized_image = self.instance_norm(image)\n",
    "        style_scale = self.style_scale_transform(w)[:, :, None, None]\n",
    "        style_shift = self.style_shift_transform(w)[:, :, None, None]\n",
    "        \n",
    "        # Calculate the transformed image\n",
    "        #### START CODE HERE ####\n",
    "        transformed_image = style_scale * normalized_image + style_shift\n",
    "        #### END CODE HERE ####\n",
    "        return transformed_image\n",
    "    \n",
    "    #UNIT TEST COMMENT: Required for grading\n",
    "    def get_style_scale_transform(self):\n",
    "        return self.style_scale_transform\n",
    "    \n",
    "    #UNIT TEST COMMENT: Required for grading\n",
    "    def get_style_shift_transform(self):\n",
    "        return self.style_shift_transform\n",
    "    \n",
    "    #UNIT TEST COMMENT: Required for grading\n",
    "    def get_self(self):\n",
    "        return self \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ljePdqZq4m3p"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success!\n"
     ]
    }
   ],
   "source": [
    "w_channels = 50\n",
    "image_channels = 20\n",
    "image_size = 30\n",
    "n_test = 10\n",
    "adain = AdaIN(image_channels, w_channels)\n",
    "test_w = torch.randn(n_test, w_channels)\n",
    "assert adain.style_scale_transform(test_w).shape == adain.style_shift_transform(test_w).shape\n",
    "assert adain.style_scale_transform(test_w).shape[-1] == image_channels\n",
    "assert tuple(adain(torch.randn(n_test, image_channels, image_size, image_size), test_w).shape) == (n_test, image_channels, image_size, image_size)\n",
    "\n",
    "w_channels = 3\n",
    "image_channels = 2\n",
    "image_size = 3\n",
    "n_test = 1\n",
    "adain = AdaIN(image_channels, w_channels)\n",
    "\n",
    "adain.style_scale_transform.weight.data = torch.ones_like(adain.style_scale_transform.weight.data) / 4\n",
    "adain.style_scale_transform.bias.data = torch.zeros_like(adain.style_scale_transform.bias.data)\n",
    "adain.style_shift_transform.weight.data = torch.ones_like(adain.style_shift_transform.weight.data) / 5\n",
    "adain.style_shift_transform.bias.data = torch.zeros_like(adain.style_shift_transform.bias.data)\n",
    "test_input = torch.ones(n_test, image_channels, image_size, image_size)\n",
    "test_input[:, :, 0] = 0\n",
    "test_w = torch.ones(n_test, w_channels)\n",
    "test_output = adain(test_input, test_w)\n",
    "assert(torch.abs(test_output[0, 0, 0, 0] - 3 / 5 + torch.sqrt(torch.tensor(9 / 8))) < 1e-4)\n",
    "assert(torch.abs(test_output[0, 0, 1, 0] - 3 / 5 - torch.sqrt(torch.tensor(9 / 32))) < 1e-4)\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_KnN184yI4AB"
   },
   "source": [
    "## Progressive Growing in StyleGAN\n",
    "The final StyleGAN component that you will create is progressive growing. This helps StyleGAN to create high resolution images by gradually doubling the image's size until the desired size.\n",
    "\n",
    "You will start by creating a block for the StyleGAN generator. This is comprised of an upsampling layer, a convolutional layer, random noise injection, an AdaIN layer, and an activation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "xnFh67WVrr2G"
   },
   "outputs": [],
   "source": [
    "# UNQ_C5 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
    "# GRADED CELL: MicroStyleGANGeneratorBlock\n",
    "\n",
    "class MicroStyleGANGeneratorBlock(nn.Module):\n",
    "    '''\n",
    "    Micro StyleGAN Generator Block Class\n",
    "    Values:\n",
    "        in_chan: the number of channels in the input, a scalar\n",
    "        out_chan: the number of channels wanted in the output, a scalar\n",
    "        w_dim: the dimension of the intermediate noise vector, a scalar\n",
    "        kernel_size: the size of the convolving kernel\n",
    "        starting_size: the size of the starting image\n",
    "    '''\n",
    "\n",
    "    def __init__(self, in_chan, out_chan, w_dim, kernel_size, starting_size, use_upsample=True):\n",
    "        super().__init__()\n",
    "        self.use_upsample = use_upsample\n",
    "        # Replace the Nones in order to:\n",
    "        # 1. Upsample to the starting_size, bilinearly (https://pytorch.org/docs/master/generated/torch.nn.Upsample.html)\n",
    "        # 2. Create a kernel_size convolution which takes in \n",
    "        #    an image with in_chan and outputs one with out_chan (https://pytorch.org/docs/stable/generated/torch.nn.Conv2d.html)\n",
    "        # 3. Create an object to inject noise\n",
    "        # 4. Create an AdaIN object\n",
    "        # 5. Create a LeakyReLU activation with slope 0.2\n",
    "        \n",
    "        #### START CODE HERE ####\n",
    "        if self.use_upsample:\n",
    "            self.upsample = nn.Upsample((starting_size, starting_size), mode=\"bilinear\")\n",
    "        self.conv = nn.Conv2d(in_chan, out_chan, kernel_size, padding=1) # Padding is used to maintain the image size\n",
    "        self.inject_noise = InjectNoise(out_chan)\n",
    "        self.adain = AdaIN(out_chan, w_dim)\n",
    "        self.activation = nn.LeakyReLU(0.2)\n",
    "        #### END CODE HERE ####\n",
    "\n",
    "    def forward(self, x, w):\n",
    "        '''\n",
    "        Function for completing a forward pass of MicroStyleGANGeneratorBlock: Given an x and w, \n",
    "        computes a StyleGAN generator block.\n",
    "        Parameters:\n",
    "            x: the input into the generator, feature map of shape (n_samples, channels, width, height)\n",
    "            w: the intermediate noise vector\n",
    "        '''\n",
    "        if self.use_upsample:\n",
    "            x = self.upsample(x)\n",
    "        x = self.conv(x)\n",
    "        x = self.inject_noise(x)\n",
    "        x = self.activation(x)\n",
    "        x = self.adain(x, w)\n",
    "        return x\n",
    "    \n",
    "    #UNIT TEST COMMENT: Required for grading\n",
    "    def get_self(self):\n",
    "        return self;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-cP1FDPz_C9K"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success!\n"
     ]
    }
   ],
   "source": [
    "test_stylegan_block = MicroStyleGANGeneratorBlock(in_chan=128, out_chan=64, w_dim=256, kernel_size=3, starting_size=8)\n",
    "test_x = torch.ones(1, 128, 4, 4)\n",
    "test_x[:, :, 1:3, 1:3] = 0\n",
    "test_w = torch.ones(1, 256)\n",
    "test_x = test_stylegan_block.upsample(test_x)\n",
    "assert tuple(test_x.shape) == (1, 128, 8, 8)\n",
    "assert torch.abs(test_x.mean() - 0.75) < 1e-4\n",
    "test_x = test_stylegan_block.conv(test_x)\n",
    "assert tuple(test_x.shape) == (1, 64, 8, 8)\n",
    "test_x = test_stylegan_block.inject_noise(test_x)\n",
    "test_x = test_stylegan_block.activation(test_x)\n",
    "assert test_x.min() < 0\n",
    "assert -test_x.min() / test_x.max() < 0.4\n",
    "test_x = test_stylegan_block.adain(test_x, test_w) \n",
    "foo = test_stylegan_block(torch.ones(10, 128, 4, 4), torch.ones(10, 256))\n",
    "\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FxgtRyMWrqTA"
   },
   "source": [
    "Now, you can implement progressive growing. \n",
    "\n",
    "StyleGAN starts with a constant 4 x 4 (x 512 channel) tensor which is put through an iteration of the generator without upsampling. The output is some noise that can then be transformed into a blurry 4 x 4 image. This is where the progressive growing process begins. The 4 x 4 noise can be further passed through a generator block with upsampling to produce an 8 x 8 output. However, this will be done gradually.\n",
    "\n",
    "You will simulate progressive growing from an 8 x 8 image to a 16 x 16 image. Instead of simply passing it to the generator block with upsampling, StyleGAN gradually trains the generator to the new size by mixing in an image that was only upsampled. By mixing an upsampled 8 x 8 image (which is 16 x 16) with increasingly more of the 16 x 16 generator output, the generator is more stable as it progressively trains. As such, you will do two separate operations with the 8 x 8 noise:\n",
    "\n",
    "1.   Pass it into the next generator block to create an output noise, that you will then transform to an image.\n",
    "2.   Transform it into an image and then upsample it to be 16 x 16.\n",
    "\n",
    "You will now have two images that are both double the resolution of the 8 x 8 noise. Then, using an alpha ($\\alpha$) term, you combine the higher resolution images obtained from (1) and (2). You would then pass this into the discriminator and use the feedback to update the weights of your generator. The key here is that the $\\alpha$ term is gradually increased until eventually, only the image from (1), the generator, is used. That is your final image or you could continue this process to make a 32 x 32 image or 64 x 64, 128 x 128, etc. \n",
    "\n",
    "This micro model you will implement will visualize what the model outputs at a particular stage of training, for a specific value of $\\alpha$. However to reiterate, in practice, StyleGAN will slowly phase out the upsampled image by increasing the $\\alpha$ parameter over many training steps, doing this process repeatedly with larger and larger alpha values until it is 1—at this point, the combined image is solely comprised of the image from the generator block. This method of gradually training the generator increases the stability and fidelity of the model.\n",
    "\n",
    "<!-- by passing a random noise vector in $z$ through the mapping function you wrote to get $w$. $w$ is then passed through the first block of the generator to create your first output noise. -->\n",
    "\n",
    "<details>\n",
    "\n",
    "<summary>\n",
    "<font size=\"3\" color=\"green\">\n",
    "<b>Optional hint for <code><font size=\"4\">forward</font></code></b>\n",
    "</font>\n",
    "</summary>\n",
    "\n",
    "1.    You may find [torch.lerp](https://pytorch.org/docs/stable/generated/torch.lerp.html) helpful.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "M9RTS6nTI2kf"
   },
   "outputs": [],
   "source": [
    "# UNQ_C6 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
    "# GRADED CELL: MicroStyleGANGenerator\n",
    "\n",
    "class MicroStyleGANGenerator(nn.Module):\n",
    "    '''\n",
    "    Micro StyleGAN Generator Class\n",
    "    Values:\n",
    "        z_dim: the dimension of the noise vector, a scalar\n",
    "        map_hidden_dim: the mapping inner dimension, a scalar\n",
    "        w_dim: the dimension of the intermediate noise vector, a scalar\n",
    "        in_chan: the dimension of the constant input, usually w_dim, a scalar\n",
    "        out_chan: the number of channels wanted in the output, a scalar\n",
    "        kernel_size: the size of the convolving kernel\n",
    "        hidden_chan: the inner dimension, a scalar\n",
    "    '''\n",
    "\n",
    "    def __init__(self, \n",
    "                 z_dim, \n",
    "                 map_hidden_dim,\n",
    "                 w_dim,\n",
    "                 in_chan,\n",
    "                 out_chan, \n",
    "                 kernel_size, \n",
    "                 hidden_chan):\n",
    "        super().__init__()\n",
    "        self.map = MappingLayers(z_dim, map_hidden_dim, w_dim)\n",
    "        # Typically this constant is initiated to all ones, but you will initiate to a\n",
    "        # Gaussian to better visualize the network's effect\n",
    "        self.starting_constant = nn.Parameter(torch.randn(1, in_chan, 4, 4))\n",
    "        self.block0 = MicroStyleGANGeneratorBlock(in_chan, hidden_chan, w_dim, kernel_size, 4, use_upsample=False)\n",
    "        self.block1 = MicroStyleGANGeneratorBlock(hidden_chan, hidden_chan, w_dim, kernel_size, 8)\n",
    "        self.block2 = MicroStyleGANGeneratorBlock(hidden_chan, hidden_chan, w_dim, kernel_size, 16)\n",
    "        # You need to have a way of mapping from the output noise to an image, \n",
    "        # so you learn a 1x1 convolution to transform the e.g. 512 channels into 3 channels\n",
    "        # (Note that this is simplified, with clipping used in the real StyleGAN)\n",
    "        self.block1_to_image = nn.Conv2d(hidden_chan, out_chan, kernel_size=1)\n",
    "        self.block2_to_image = nn.Conv2d(hidden_chan, out_chan, kernel_size=1)\n",
    "        self.alpha = 0.2\n",
    "\n",
    "    def upsample_to_match_size(self, smaller_image, bigger_image):\n",
    "        '''\n",
    "        Function for upsampling an image to the size of another: Given a two images (smaller and bigger), \n",
    "        upsamples the first to have the same dimensions as the second.\n",
    "        Parameters:\n",
    "            smaller_image: the smaller image to upsample\n",
    "            bigger_image: the bigger image whose dimensions will be upsampled to\n",
    "        '''\n",
    "        return F.interpolate(smaller_image, size=bigger_image.shape[-2:], mode='bilinear')\n",
    "\n",
    "    def forward(self, noise, return_intermediate=False):\n",
    "        '''\n",
    "        Function for completing a forward pass of MicroStyleGANGenerator: Given noise, \n",
    "        computes a StyleGAN iteration.\n",
    "        Parameters:\n",
    "            noise: a noise tensor with dimensions (n_samples, z_dim)\n",
    "            return_intermediate: a boolean, true to return the images as well (for testing) and false otherwise\n",
    "        '''\n",
    "        x = self.starting_constant\n",
    "        w = self.map(noise)\n",
    "        x = self.block0(x, w)\n",
    "        x_small = self.block1(x, w) # First generator run output\n",
    "        x_small_image = self.block1_to_image(x_small)\n",
    "        x_big = self.block2(x_small, w) # Second generator run output \n",
    "        x_big_image = self.block2_to_image(x_big)\n",
    "        x_small_upsample = self.upsample_to_match_size(x_small_image, x_big_image) # Upsample first generator run output to be same size as second generator run output \n",
    "        # Interpolate between the upsampled image and the image from the generator using alpha\n",
    "        \n",
    "        #### START CODE HERE ####\n",
    "        interpolation = self.alpha * (x_big_image) + (1-self.alpha) * (x_small_upsample)\n",
    "        #### END CODE HERE #### \n",
    "        \n",
    "        if return_intermediate:\n",
    "            return interpolation, x_small_upsample, x_big_image\n",
    "        return interpolation\n",
    "    \n",
    "    #UNIT TEST COMMENT: Required for grading\n",
    "    def get_self(self):\n",
    "        return self;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "bWHCOPJWkYm2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success!\n"
     ]
    }
   ],
   "source": [
    "z_dim = 128\n",
    "out_chan = 3\n",
    "truncation = 0.7\n",
    "\n",
    "mu_stylegan = MicroStyleGANGenerator(\n",
    "    z_dim=z_dim, \n",
    "    map_hidden_dim=1024,\n",
    "    w_dim=496,\n",
    "    in_chan=512,\n",
    "    out_chan=out_chan, \n",
    "    kernel_size=3, \n",
    "    hidden_chan=256\n",
    ")\n",
    "\n",
    "test_samples = 10\n",
    "test_result = mu_stylegan(get_truncated_noise(test_samples, z_dim, truncation))\n",
    "\n",
    "# Check if the block works\n",
    "assert tuple(test_result.shape) == (test_samples, out_chan, 16, 16)\n",
    "\n",
    "# Check that the interpolation is correct\n",
    "mu_stylegan.alpha = 1.\n",
    "test_result, _, test_big =  mu_stylegan(\n",
    "    get_truncated_noise(test_samples, z_dim, truncation), \n",
    "    return_intermediate=True)\n",
    "assert torch.abs(test_result - test_big).mean() < 0.001\n",
    "mu_stylegan.alpha = 0.\n",
    "test_result, test_small, _ =  mu_stylegan(\n",
    "    get_truncated_noise(test_samples, z_dim, truncation), \n",
    "    return_intermediate=True)\n",
    "assert torch.abs(test_result - test_small).mean() < 0.001\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nXXdZdOAkavj"
   },
   "source": [
    "## Running StyleGAN\n",
    "Finally, you can put all the components together to run an iteration of your micro StyleGAN!\n",
    "\n",
    "You can also visualize what this randomly initiated generator can produce. The code will automatically interpolate between different values of alpha so that you can intuitively see what it means to mix the low-resolution and high-resolution images using different values of alpha. In the generated image, the samples start from low alpha values and go to high alpha values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "xmfdB47xNWvf"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from torchvision.utils import make_grid\n",
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams['figure.figsize'] = [15, 15]\n",
    "\n",
    "viz_samples = 10\n",
    "# The noise is exaggerated for visual effect\n",
    "viz_noise = get_truncated_noise(viz_samples, z_dim, truncation) * 10\n",
    "\n",
    "mu_stylegan.eval()\n",
    "images = []\n",
    "for alpha in np.linspace(0, 1, num=5):\n",
    "    mu_stylegan.alpha = alpha\n",
    "    viz_result, _, _ =  mu_stylegan(\n",
    "        viz_noise, \n",
    "        return_intermediate=True)\n",
    "    images += [tensor for tensor in viz_result]\n",
    "show_tensor_images(torch.stack(images), nrow=viz_samples, num_images=len(images))\n",
    "mu_stylegan = mu_stylegan.train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "C2W3: Components of StyleGAN (Student).ipynb",
   "provenance": []
  },
  "coursera": {
   "schema_names": [
    "GANSC2-3A"
   ]
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}