{ "cells": [ { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "1czVdIlqnImH" }, "source": [ "# Evaluating GANs" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "1KD3ZgLs80vY" }, "source": [ "### Goals\n", "In this notebook, you're going to gain a better understanding of some of the challenges that come with evaluating GANs and a response you can take to alleviate some of them called Fréchet Inception Distance (FID).\n", "\n", "### Learning Objectives\n", "1. Understand the challenges associated with evaluating GANs.\n", "2. Write code to evaluate the Fréchet Inception Distance.\n", " \n" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "YcjvPOSMSCzL" }, "source": [ "## Challenges With Evaluating GANs\n", "\n", "#### Loss is Uninformative of Performance\n", "One aspect that makes evaluating GANs challenging is that the loss tells us little about their performance. Unlike with classifiers, where a low loss on a test set indicates superior performance, a low loss for the generator or discriminator suggests that learning has stopped. \n", "\n", "\n", "#### No Clear Non-human Metric\n", "If you define the goal of a GAN as \"generating images which look real to people\" then it's technically possible to measure this directly: [you can ask people to act as a discriminator](https://arxiv.org/abs/1904.01121). However, this takes significant time and money so ideally you can use a proxy for this. There is also no \"perfect\" discriminator that can differentiate reals from fakes - if there were, a lot of machine learning tasks would be solved ;)\n", "\n", "In this notebook, you will implement Fréchet Inception Distance, one method which aims to solve these issues. " ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "wU8DDM6l9rZb" }, "source": [ "## Getting Started\n", "For this notebook, you will again be using [CelebA](http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html). You will start by loading a pre-trained generator which has been trained on CelebA." ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "gsTReUckdFQh" }, "source": [ "Here, you will import some useful libraries and packages. You will also be provided with the generator and noise code from earlier assignments." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "colab": {}, "colab_type": "code", "id": "JfkorNJrnmNO" }, "outputs": [], "source": [ "import torch\n", "import numpy as np\n", "from torch import nn\n", "from tqdm.auto import tqdm\n", "from torchvision import transforms\n", "from torchvision.datasets import CelebA\n", "from torchvision.utils import make_grid\n", "from torch.utils.data import DataLoader\n", "import matplotlib.pyplot as plt\n", "torch.manual_seed(0) # Set for our testing purposes, please do not change!\n", "\n", "class Generator(nn.Module):\n", " '''\n", " Generator Class\n", " Values:\n", " z_dim: the dimension of the noise vector, a scalar\n", " im_chan: the number of channels in the images, fitted for the dataset used, a scalar\n", " (CelebA is rgb, so 3 is your default)\n", " hidden_dim: the inner dimension, a scalar\n", " '''\n", " def __init__(self, z_dim=10, im_chan=3, hidden_dim=64):\n", " super(Generator, self).__init__()\n", " self.z_dim = z_dim\n", " # Build the neural network\n", " self.gen = nn.Sequential(\n", " self.make_gen_block(z_dim, hidden_dim * 8),\n", " self.make_gen_block(hidden_dim * 8, hidden_dim * 4),\n", " self.make_gen_block(hidden_dim * 4, hidden_dim * 2),\n", " self.make_gen_block(hidden_dim * 2, hidden_dim),\n", " self.make_gen_block(hidden_dim, im_chan, kernel_size=4, final_layer=True),\n", " )\n", "\n", " def make_gen_block(self, input_channels, output_channels, kernel_size=3, stride=2, final_layer=False):\n", " '''\n", " Function to return a sequence of operations corresponding to a generator block of DCGAN;\n", " a transposed convolution, a batchnorm (except in the final layer), and an activation.\n", " Parameters:\n", " input_channels: how many channels the input feature representation has\n", " output_channels: how many channels the output feature representation should have\n", " kernel_size: the size of each convolutional filter, equivalent to (kernel_size, kernel_size)\n", " stride: the stride of the convolution\n", " final_layer: a boolean, true if it is the final layer and false otherwise \n", " (affects activation and batchnorm)\n", " '''\n", " if not final_layer:\n", " return nn.Sequential(\n", " nn.ConvTranspose2d(input_channels, output_channels, kernel_size, stride),\n", " nn.BatchNorm2d(output_channels),\n", " nn.ReLU(inplace=True),\n", " )\n", " else:\n", " return nn.Sequential(\n", " nn.ConvTranspose2d(input_channels, output_channels, kernel_size, stride),\n", " nn.Tanh(),\n", " )\n", "\n", " def forward(self, noise):\n", " '''\n", " Function for completing a forward pass of the generator: Given a noise tensor, \n", " returns generated images.\n", " Parameters:\n", " noise: a noise tensor with dimensions (n_samples, z_dim)\n", " '''\n", " x = noise.view(len(noise), self.z_dim, 1, 1)\n", " return self.gen(x)\n", "\n", "def get_noise(n_samples, z_dim, device='cpu'):\n", " '''\n", " Function for creating noise vectors: Given the dimensions (n_samples, z_dim)\n", " creates a tensor of that shape filled with random numbers from the 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", " device: the device type\n", " '''\n", " return torch.randn(n_samples, z_dim, device=device)" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "qRk_8azSq3tF" }, "source": [ "## Loading the Pre-trained Model\n", "\n", "Now, you can set the arguments for the model and load the dataset:\n", " * z_dim: the dimension of the noise vector\n", " * image_size: the image size of the input to Inception (more details in the following section)\n", " * device: the device type" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 426 }, "colab_type": "code", "executionInfo": { "elapsed": 5223, "status": "error", "timestamp": 1599108736989, "user": { "displayName": "Eric Zelikman", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GjA3YFIDW6U361yE3hLUnt-lzGRhMwlG-B2_mQLtQ=s64", "userId": "16768126786232632622" }, "user_tz": 240 }, "id": "UXptQZcwrBrq", "outputId": "b7ef6127-ba5d-4f7b-c437-c8d75d67a6b0" }, "outputs": [], "source": [ "z_dim = 64\n", "image_size = 299\n", "device = 'cuda'\n", "\n", "transform = transforms.Compose([\n", " transforms.Resize(image_size),\n", " transforms.CenterCrop(image_size),\n", " transforms.ToTensor(),\n", " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n", "])\n", "\n", "in_coursera = True # Set this to false if you're running this outside Coursera\n", "if in_coursera:\n", " import numpy as np\n", " data = torch.Tensor(np.load('fid_images_tensor.npz', allow_pickle=True)['arr_0'])\n", " dataset = torch.utils.data.TensorDataset(data, data)\n", "else:\n", " dataset = CelebA(\".\", download=True, transform=transform)" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "VJvvJ7GDVcyi" }, "source": [ "Then, you can load and initialize the model with weights from a pre-trained model. This allows you to use the pre-trained model as if you trained it yourself." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "colab": {}, "colab_type": "code", "id": "m5-yxnpDVSzv" }, "outputs": [], "source": [ "gen = Generator(z_dim).to(device)\n", "gen.load_state_dict(torch.load(f\"pretrained_celeba.pth\", map_location=torch.device(device))[\"gen\"])\n", "gen = gen.eval()" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "Zvis3TCd8tmI" }, "source": [ "## Inception-v3 Network\n", "Inception-V3 is a neural network trained on [ImageNet](http://www.image-net.org/) to classify objects. You may recall from the lectures that ImageNet has over 1 million images to train on. As a result, Inception-V3 does a good job detecting features and classifying images. Here, you will load Inception-V3 as `inception_model`.\n", "\n", "\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "colab": {}, "colab_type": "code", "id": "1tPRtB993v68" }, "outputs": [], "source": [ "from torchvision.models import inception_v3\n", "inception_model = inception_v3(pretrained=False)\n", "inception_model.load_state_dict(torch.load(\"inception_v3_google-1a9a5a14.pth\"))\n", "inception_model.to(device)\n", "inception_model = inception_model.eval() # Evaluation mode" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "9iYUtcRU-woT" }, "source": [ "## Fréchet Inception Distance\n", "\n", "Fréchet Inception Distance (FID) was proposed as an improvement over Inception Score and still uses the Inception-v3 network as part of its calculation. However, instead of using the classification labels of the Inception-v3 network, it uses the output from an earlier layer—the layer right before the labels. This is often called the feature layer. Research has shown that deep convolutional neural networks trained on difficult tasks, like classifying many classes, build increasingly sophisticated representations of features going deeper into the network. For example, the first few layers may learn to detect different kinds of edges and curves, while the later layers may have neurons that fire in response to human faces.\n", "\n", "To get the feature layer of a convolutional neural network, you can replace the final fully connected layer with an identity layer that simply returns whatever input it received, unchanged. This essentially removes the final classification layer and leaves you with the intermediate outputs from the layer before.\n", "\n", "
\n", "\n", "\n", "\n", "Optional hint for inception_model.fc\n", "\n", "\n", "\n", "1. You may find [torch.nn.Identity()](https://pytorch.org/docs/master/generated/torch.nn.Identity.html) helpful.\n", "\n", "
" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "colab": {}, "colab_type": "code", "id": "y2KBoaJEXH29" }, "outputs": [], "source": [ "# UNQ_C1 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n", "# GRADED CELL: inception_model.fc\n", "\n", "# You want to replace the final fully-connected (fc) layer \n", "# with an identity function layer to cut off the classification\n", "# layer and get a feature extractor\n", "#### START CODE HERE ####\n", "inception_model.fc = torch.nn.Identity() \n", "#### END CODE HERE ####" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "colab": {}, "colab_type": "code", "id": "_txoiugobfck" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Success!\n" ] } ], "source": [ "# UNIT TEST\n", "test_identity_noise = torch.randn(100, 100)\n", "assert torch.equal(test_identity_noise, inception_model.fc(test_identity_noise))\n", "print(\"Success!\")" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "BKzLLQI_XLdw" }, "source": [ "### Fréchet Distance \n", "Fréchet distance uses the values from the feature layer for two sets of images, say reals and fakes, and compares different statistical properties between them to see how different they are. Specifically, Fréchet distance finds the shortest distance needed to walk along two lines, or two curves, simultaneously. The most intuitive explanation of Fréchet distance is as the \"minimum leash distance\" between two points. Imagine yourself and your dog, both moving along two curves. If you walked on one curve and your dog, attached to a leash, walked on the other at the same pace, what is the least amount of leash that you can give your dog so that you never need to give them more slack during your walk? Using this, the Fréchet distance measures the similarity between these two curves.\n", "\n", "The basic idea is similar for calculating the Fréchet distance between two probability distributions. You'll start by seeing what this looks like in one-dimensional, also called univariate, space." ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "fb5z23wVFE3m" }, "source": [ "\n", "#### Univariate Fréchet Distance\n", "You can calculate the distance between two normal distributions $X$ and $Y$ with means $\\mu_X$ and $\\mu_Y$ and standard deviations $\\sigma_X$ and $\\sigma_Y$, as:\n", "\n", "$$d(X,Y) = (\\mu_X-\\mu_Y)^2 + (\\sigma_X-\\sigma_Y)^2 $$\n", "\n", "Pretty simple, right? Now you can see how it can be converted to be used in multi-dimensional, which is also called multivariate, space." ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "f1syunux1Jon" }, "source": [ "#### Multivariate Fréchet Distance\n", "**Covariance**\n", "\n", "To find the Fréchet distance between two multivariate normal distributions, you first need to find the covariance instead of the standard deviation. The covariance, which is the multivariate version of variance (the square of standard deviation), is represented using a square matrix where the side length is equal to the number of dimensions. Since the feature vectors you will be using have 2048 values/weights, the covariance matrix will be 2048 x 2048. But for the sake of an example, this is a covariance matrix in a two-dimensional space:\n", "\n", "$\\Sigma = \\left(\\begin{array}{cc} \n", "1 & 0\\\\ \n", "0 & 1\n", "\\end{array}\\right)\n", "$\n", "\n", "The value at location $(i, j)$ corresponds to the covariance of vector $i$ with vector $j$. Since the covariance of $i$ with $j$ and $j$ with $i$ are equivalent, the matrix will always be symmetric with respect to the diagonal. The diagonal is the covariance of that element with itself. In this example, there are zeros everywhere except the diagonal. That means that the two dimensions are independent of one another, they are completely unrelated.\n", "\n", "The following code cell will visualize this matrix." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "colab": {}, "colab_type": "code", "id": "qDLxAxYo-v0y" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "#import os\n", "#os.environ['KMP_DUPLICATE_LIB_OK']='True'\n", "\n", "from torch.distributions import MultivariateNormal\n", "import seaborn as sns # This is for visualization\n", "mean = torch.Tensor([0, 0]) # Center the mean at the origin\n", "covariance = torch.Tensor( # This matrix shows independence - there are only non-zero values on the diagonal\n", " [[1, 0],\n", " [0, 1]]\n", ")\n", "independent_dist = MultivariateNormal(mean, covariance)\n", "samples = independent_dist.sample((10000,))\n", "res = sns.jointplot(samples[:, 0], samples[:, 1], kind=\"kde\")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "HkEtuo_k2ED5" }, "source": [ "Now, here's an example of a multivariate normal distribution that has covariance:\n", "\n", "$\\Sigma = \\left(\\begin{array}{cc} \n", "2 & -1\\\\ \n", "-1 & 2\n", "\\end{array}\\right)\n", "$\n", "\n", "And see how it looks:\n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "colab": {}, "colab_type": "code", "id": "SQvjyAmw2SGl" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "mean = torch.Tensor([0, 0])\n", "covariance = torch.Tensor(\n", " [[2, -1],\n", " [-1, 2]]\n", ")\n", "covariant_dist = MultivariateNormal(mean, covariance)\n", "samples = covariant_dist.sample((10000,))\n", "res = sns.jointplot(samples[:, 0], samples[:, 1], kind=\"kde\")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "uf3kci9d2ROC" }, "source": [ "**Formula**\n", "\n", "Based on the paper, \"[The Fréchet distance between multivariate normal distributions](https://core.ac.uk/reader/82269844)\" by Dowson and Landau (1982), the Fréchet distance between two multivariate normal distributions $X$ and $Y$ is:\n", "\n", "$d(X, Y) = \\Vert\\mu_X-\\mu_Y\\Vert^2 + \\mathrm{Tr}\\left(\\Sigma_X+\\Sigma_Y - 2 \\sqrt{\\Sigma_X \\Sigma_Y}\\right)$\n", "\n", "Similar to the formula for univariate Fréchet distance, you can calculate the distance between the means and the distance between the standard deviations. However, calculating the distance between the standard deviations changes slightly here, as it includes the matrix product and matrix square root. $\\mathrm{Tr}$ refers to the trace, the sum of the diagonal elements of a matrix.\n", "\n", "Now you can implement this!\n", "\n", "
\n", "\n", "\n", "\n", "Optional hints for frechet_distance\n", "\n", "\n", "\n", "1. You want to implement the above equation in code.\n", "2. You might find the functions `torch.norm` and `torch.trace` helpful here.\n", "3. A matrix_sqrt function is defined for you above -- you need to use it instead of `torch.sqrt()` which only gets the elementwise square root instead of the matrix square root.\n", "4. You can also use the `@` symbol for matrix multiplication.\n", "
" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "colab": {}, "colab_type": "code", "id": "iOlCmNPiuuhK" }, "outputs": [], "source": [ "import scipy\n", "# This is the matrix square root function you will be using\n", "def matrix_sqrt(x):\n", " '''\n", " Function that takes in a matrix and returns the square root of that matrix.\n", " For an input matrix A, the output matrix B would be such that B @ B is the matrix A.\n", " Parameters:\n", " x: a matrix\n", " '''\n", " y = x.cpu().detach().numpy()\n", " y = scipy.linalg.sqrtm(y)\n", " return torch.Tensor(y.real, device=x.device)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "colab": {}, "colab_type": "code", "id": "_hLWk57s91it" }, "outputs": [], "source": [ "# UNQ_C2 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n", "# GRADED FUNCTION: frechet_distance\n", "def frechet_distance(mu_x, mu_y, sigma_x, sigma_y):\n", " '''\n", " Function for returning the Fréchet distance between multivariate Gaussians,\n", " parameterized by their means and covariance matrices.\n", " Parameters:\n", " mu_x: the mean of the first Gaussian, (n_features)\n", " mu_y: the mean of the second Gaussian, (n_features) \n", " sigma_x: the covariance matrix of the first Gaussian, (n_features, n_features)\n", " sigma_y: the covariance matrix of the second Gaussian, (n_features, n_features)\n", " '''\n", " #### START CODE HERE ####\n", " return (mu_x - mu_y).dot(mu_x - mu_y) + torch.trace(sigma_x) + torch.trace(sigma_y) - 2*torch.trace(matrix_sqrt(sigma_x @ sigma_y)) \n", " #### END CODE HERE ####" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "colab": {}, "colab_type": "code", "id": "Pphv97XEgPDh" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Success!\n" ] } ], "source": [ "# UNIT TEST\n", "\n", "mean1 = torch.Tensor([0, 0]) # Center the mean at the origin\n", "covariance1 = torch.Tensor( # This matrix shows independence - there are only non-zero values on the diagonal\n", " [[1, 0],\n", " [0, 1]]\n", ")\n", "dist1 = MultivariateNormal(mean1, covariance1)\n", "\n", "mean2 = torch.Tensor([0, 0]) # Center the mean at the origin\n", "covariance2 = torch.Tensor( # This matrix shows dependence \n", " [[2, -1],\n", " [-1, 2]]\n", ")\n", "dist2 = MultivariateNormal(mean2, covariance2)\n", "\n", "assert torch.isclose(\n", " frechet_distance(\n", " dist1.mean, dist2.mean,\n", " dist1.covariance_matrix, dist2.covariance_matrix\n", " ),\n", " 4 - 2 * torch.sqrt(torch.tensor(3.))\n", ")\n", "\n", "assert (frechet_distance(\n", " dist1.mean, dist1.mean,\n", " dist1.covariance_matrix, dist1.covariance_matrix\n", " ).item() == 0)\n", "\n", "print(\"Success!\")" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "r9dMgbxGCTno" }, "source": [ "## Putting it all together!\n", "Now, you can apply FID to your generator from earlier.\n", "\n", "You will start by defining a bit of helper code to preprocess the image for the Inception-v3 network:\n", "" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "colab": {}, "colab_type": "code", "id": "s2ZMTdzMCZtn" }, "outputs": [], "source": [ "def preprocess(img):\n", " img = torch.nn.functional.interpolate(img, size=(299, 299), mode='bilinear', align_corners=False)\n", " return img" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "hzXQTFv_UNjm" }, "source": [ "Then, you'll define a function to calculate the covariance of the features that returns a covariance matrix given a list of values:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "colab": {}, "colab_type": "code", "id": "4BEbwlGLiPWJ" }, "outputs": [], "source": [ "import numpy as np\n", "def get_covariance(features):\n", " return torch.Tensor(np.cov(features.detach().numpy(), rowvar=False))" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "Sw5obaXjVv_v" }, "source": [ "Finally, you can use the pre-trained Inception-v3 model to compute features of the real and fake images. With these features, you can then get the covariance and means of these features across many samples. \n", "\n", "First, you get the features of the real and fake images using the Inception-v3 model:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "colab": {}, "colab_type": "code", "id": "qQwHSAhrf0hX" }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c88275f4126c482da748bfc03a84dcb7", "version_major": 2, "version_minor": 0 }, "text/plain": [ "HBox(children=(FloatProgress(value=0.0, max=128.0), HTML(value='')))" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fake_features_list = []\n", "real_features_list = []\n", "\n", "gen.eval()\n", "n_samples = 512 # The total number of samples\n", "batch_size = 4 # Samples per iteration\n", "\n", "dataloader = DataLoader(\n", " dataset,\n", " batch_size=batch_size,\n", " shuffle=True)\n", "\n", "cur_samples = 0\n", "with torch.no_grad(): # You don't need to calculate gradients here, so you do this to save memory\n", " try:\n", " for real_example, _ in tqdm(dataloader, total=n_samples // batch_size): # Go by batch\n", " real_samples = real_example\n", " real_features = inception_model(real_samples.to(device)).detach().to('cpu') # Move features to CPU\n", " real_features_list.append(real_features)\n", "\n", " fake_samples = get_noise(len(real_example), z_dim).to(device)\n", " fake_samples = preprocess(gen(fake_samples))\n", " fake_features = inception_model(fake_samples.to(device)).detach().to('cpu')\n", " fake_features_list.append(fake_features)\n", " cur_samples += len(real_samples)\n", " if cur_samples >= n_samples:\n", " break\n", " except:\n", " print(\"Error in loop\")" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "LUrJ_ZEZXkvu" }, "source": [ "Then, you can combine all of the values that you collected for the reals and fakes into large tensors:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "colab": {}, "colab_type": "code", "id": "UmiOuDulqDTC" }, "outputs": [], "source": [ "# UNQ_C3 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n", "# UNIT TEST COMMENT: Needed as is for autograding\n", "fake_features_all = torch.cat(fake_features_list)\n", "real_features_all = torch.cat(real_features_list)" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "41XEEZRoXxN1" }, "source": [ "And calculate the covariance and means of these real and fake features:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "colab": {}, "colab_type": "code", "id": "quNhtmwaNhpT" }, "outputs": [], "source": [ "# UNQ_C4 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n", "# GRADED CELL\n", "\n", "# Calculate the covariance matrix for the fake and real features\n", "# and also calculate the means of the feature over the batch (for each feature dimension mean)\n", "#### START CODE HERE ####\n", "mu_fake = fake_features_all.mean(0)\n", "mu_real = real_features_all.mean(0)\n", "sigma_fake = get_covariance(fake_features_all)\n", "sigma_real = get_covariance(real_features_all)\n", "#### END CODE HERE ####" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "colab": {}, "colab_type": "code", "id": "zC1spPHPxkOQ" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Success!\n" ] } ], "source": [ "assert tuple(sigma_fake.shape) == (fake_features_all.shape[1], fake_features_all.shape[1])\n", "assert torch.abs(sigma_fake[0, 0] - 2.5e-2) < 1e-2 and torch.abs(sigma_fake[-1, -1] - 5e-2) < 1e-2\n", "assert tuple(sigma_real.shape) == (real_features_all.shape[1], real_features_all.shape[1])\n", "assert torch.abs(sigma_real[0, 0] - 3.5768e-2) < 1e-4 and torch.abs(sigma_real[0, 1] + 5.3236e-4) < 1e-4\n", "assert tuple(mu_fake.shape) == (fake_features_all.shape[1],)\n", "assert tuple(mu_real.shape) == (real_features_all.shape[1],)\n", "assert torch.abs(mu_real[0] - 0.3099) < 0.01 and torch.abs(mu_real[1] - 0.2721) < 0.01\n", "assert torch.abs(mu_fake[0] - 0.37) < 0.05 and torch.abs(mu_real[1] - 0.27) < 0.05\n", "print(\"Success!\")" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "gyHx-bBqo5MU" }, "source": [ "At this point, you can also visualize what the pairwise multivariate distributions of the inception features look like!" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "colab": {}, "colab_type": "code", "id": "fBOp8wfNkce1" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "indices = [2, 4, 5]\n", "fake_dist = MultivariateNormal(mu_fake[indices], sigma_fake[indices][:, indices])\n", "fake_samples = fake_dist.sample((5000,))\n", "real_dist = MultivariateNormal(mu_real[indices], sigma_real[indices][:, indices])\n", "real_samples = real_dist.sample((5000,))\n", "\n", "import pandas as pd\n", "df_fake = pd.DataFrame(fake_samples.numpy(), columns=indices)\n", "df_real = pd.DataFrame(real_samples.numpy(), columns=indices)\n", "df_fake[\"is_real\"] = \"no\"\n", "df_real[\"is_real\"] = \"yes\"\n", "df = pd.concat([df_fake, df_real])\n", "sns.pairplot(df, plot_kws={'alpha': 0.1}, hue='is_real')" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "Ja7DQ9SSX0u2" }, "source": [ "Lastly, you can use your earlier `frechet_distance` function to calculate the FID and evaluate your GAN. You can see how similar/different the features of the generated images are to the features of the real images. The next cell might take five minutes or so to run in Coursera." ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "colab": {}, "colab_type": "code", "id": "qS8kklILkmyg" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "136.65989685058594\n" ] } ], "source": [ "with torch.no_grad():\n", " print(frechet_distance(mu_real, mu_fake, sigma_real, sigma_fake).item())" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "Rnt8jEP6Fh70" }, "source": [ "You'll notice this model gets a pretty high FID, likely over 30. Since lower is better, and the best models on CelebA get scores in the single-digits, there's clearly a ways to go with this model. You can use FID to compare different models, as well as different stages of training of the same model. " ] } ], "metadata": { "colab": { "collapsed_sections": [], "machine_shape": "hm", "name": "C2W1_3: FID (Student).ipynb", "provenance": [ { "file_id": "1PHyStVU9tpRZ3cdJmfVfrSJ8ftCoaRVB", "timestamp": 1596210108151 }, { "file_id": "1dfp-3gGaFasdR4XB4cNkxb7vm4VHr2tR", "timestamp": 1595718206414 }, { "file_id": "1Tj1PwWp73iGwYsQrKq8CgMe8xfXeyn8s", "timestamp": 1592457596256 } ] }, "coursera": { "schema_names": [ "GANSC2-1A" ] }, "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.6.9" } }, "nbformat": 4, "nbformat_minor": 1 }