celeba_stylegan2_tpu.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "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.6"
    },
    "colab": {
      "name": "dcgan_faces_tutorial.ipynb",
      "provenance": [],
      "private_outputs": true,
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/gist/GetsEclectic/add2a89b1add49483c07e84f91400bcc/dcgan_faces_tutorial.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xJ9h-C3iE90L",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%matplotlib inline"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B4vme_GlE90P",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "DCGAN Tutorial\n",
        "==============\n",
        "\n",
        "**Author**: `Nathan Inkawhich <https://github.com/inkawhich>`__\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KRKNdbcmE90R",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from __future__ import print_function\n",
        "#%matplotlib inline\n",
        "import argparse\n",
        "import os\n",
        "import random\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.parallel\n",
        "import torch.backends.cudnn as cudnn\n",
        "import torch.optim as optim\n",
        "import torch.utils.data\n",
        "import torchvision.datasets as dset\n",
        "import torchvision.transforms as transforms\n",
        "import torchvision.utils as vutils\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.animation as animation\n",
        "from IPython.display import HTML\n",
        "\n",
        "# Set random seem for reproducibility\n",
        "manualSeed = 999\n",
        "#manualSeed = random.randint(1, 10000) # use if you want new results\n",
        "print(\"Random Seed: \", manualSeed)\n",
        "random.seed(manualSeed)\n",
        "torch.manual_seed(manualSeed)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "63NvtMygE90V",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Root directory for dataset\n",
        "dataroot = \"/content/imgs\"\n",
        "model_file_path = '/content/drive/My Drive/gans/dcgan_models_and_optimizers.tar'\n",
        "\n",
        "# Number of workers for dataloader\n",
        "workers = 4\n",
        "\n",
        "# Batch size during training\n",
        "batch_size = 128\n",
        "\n",
        "# Spatial size of training images. All images will be resized to this\n",
        "#   size using a transformer.\n",
        "image_size = 64\n",
        "\n",
        "# Number of channels in the training images. For color images this is 3\n",
        "nc = 3\n",
        "\n",
        "# Size of z latent vector (i.e. size of generator input)\n",
        "nz = 100\n",
        "\n",
        "# Size of feature maps in generator\n",
        "ngf = 64\n",
        "\n",
        "# Size of feature maps in discriminator\n",
        "ndf = 64\n",
        "\n",
        "# Number of training epochs\n",
        "num_epochs = 5\n",
        "\n",
        "# Learning rate for optimizers\n",
        "lr = 1e-4\n",
        "betas = (.9, .99)\n",
        "\n",
        "# Number of GPUs available. Use 0 for CPU mode.\n",
        "ngpu = 1\n",
        "\n",
        "# number of critic updates per generator update\n",
        "num_critic_updates = 5\n",
        "\n",
        "# Gradient penalty lambda hyperparameter\n",
        "LAMBDA = 10"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tICYdg68F-mi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# get the data\n",
        "from google.colab import drive\n",
        "\n",
        "if not os.path.isdir(dataroot):\n",
        "  drive.mount('/content/drive')\n",
        "  !bash -c 'cp /content/drive/My\\ Drive/gans/img_align_celeba.zip /content/sample_data'\n",
        "  !unzip /content/sample_data/img_align_celeba.zip -d /content/imgs/\n",
        "\n",
        "# load checkpoint data if it exists\n",
        "have_checkpoint = False\n",
        "checkpoint = None\n",
        "if os.path.exists(model_file_path):\n",
        "  checkpoint = torch.load(model_file_path)\n",
        "  have_checkpoint = True"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ayFbpLj1E90Z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# We can use an image folder dataset the way we have it setup.\n",
        "# Create the dataset\n",
        "dataset = dset.ImageFolder(root=dataroot,\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",
        "# Create the dataloader\n",
        "dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size,\n",
        "                                         shuffle=True, num_workers=workers)\n",
        "\n",
        "# Decide which device we want to run on\n",
        "device = torch.device(\"cuda:0\" if (torch.cuda.is_available() and ngpu > 0) else \"cpu\")\n",
        "\n",
        "# Plot some training images\n",
        "real_batch = next(iter(dataloader))\n",
        "plt.figure(figsize=(8,8))\n",
        "plt.axis(\"off\")\n",
        "plt.title(\"Training Images\")\n",
        "plt.imshow(np.transpose(vutils.make_grid(real_batch[0].to(device)[:64], padding=2, normalize=True).cpu(),(1,2,0)))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BatxsavEE90d",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# custom weights initialization called on netG and netD\n",
        "def weights_init(m):\n",
        "    classname = m.__class__.__name__\n",
        "    if classname.find('Conv') != -1:\n",
        "        nn.init.normal_(m.weight.data, 0.0, 0.02)\n",
        "    elif classname.find('BatchNorm') != -1:\n",
        "        nn.init.normal_(m.weight.data, 1.0, 0.02)\n",
        "        nn.init.constant_(m.bias.data, 0)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XpueL3UDE90h",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Generator Code\n",
        "\n",
        "class Generator(nn.Module):\n",
        "    def __init__(self, ngpu):\n",
        "        super(Generator, self).__init__()\n",
        "        self.ngpu = ngpu\n",
        "        self.main = nn.Sequential(\n",
        "            # input is Z, going into a convolution\n",
        "            nn.ConvTranspose2d( nz, ngf * 8, 4, 1, 0, bias=False),\n",
        "            nn.BatchNorm2d(ngf * 8),\n",
        "            nn.ReLU(True),\n",
        "            # state size. (ngf*8) x 4 x 4\n",
        "            nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),\n",
        "            nn.BatchNorm2d(ngf * 4),\n",
        "            nn.ReLU(True),\n",
        "            # state size. (ngf*4) x 8 x 8\n",
        "            nn.ConvTranspose2d( ngf * 4, ngf * 2, 4, 2, 1, bias=False),\n",
        "            nn.BatchNorm2d(ngf * 2),\n",
        "            nn.ReLU(True),\n",
        "            # state size. (ngf*2) x 16 x 16\n",
        "            nn.ConvTranspose2d( ngf * 2, ngf, 4, 2, 1, bias=False),\n",
        "            nn.BatchNorm2d(ngf),\n",
        "            nn.ReLU(True),\n",
        "            # state size. (ngf) x 32 x 32\n",
        "            nn.ConvTranspose2d( ngf, nc, 4, 2, 1, bias=False),\n",
        "            nn.Tanh()\n",
        "            # state size. (nc) x 64 x 64\n",
        "        )\n",
        "\n",
        "    def forward(self, input):\n",
        "        return self.main(input)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y7zSNkBkE90m",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Create the generator\n",
        "netG = Generator(ngpu).to(device)\n",
        "\n",
        "# Handle multi-gpu if desired\n",
        "if (device.type == 'cuda') and (ngpu > 1):\n",
        "    netG = nn.DataParallel(netG, list(range(ngpu)))\n",
        "\n",
        "if not have_checkpoint:      \n",
        "  # Apply the weights_init function to randomly initialize all weights\n",
        "  #  to mean=0, stdev=0.2.\n",
        "  netG.apply(weights_init)\n",
        "else:\n",
        "  netG.load_state_dict(checkpoint['netG_state_dict'])\n",
        "\n",
        "# Print the model\n",
        "print(netG)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZUlsY7HgE90q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Discriminator(nn.Module):\n",
        "    def __init__(self, ngpu):\n",
        "        super(Discriminator, self).__init__()\n",
        "        self.ngpu = ngpu\n",
        "        self.main = nn.Sequential(\n",
        "            # input is (nc) x 64 x 64\n",
        "            nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),\n",
        "            nn.LeakyReLU(0.2, inplace=True),\n",
        "            # state size. (ndf) x 32 x 32\n",
        "            nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),\n",
        "            nn.LeakyReLU(0.2, inplace=True),\n",
        "            # state size. (ndf*2) x 16 x 16\n",
        "            nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),\n",
        "            nn.LeakyReLU(0.2, inplace=True),\n",
        "            # state size. (ndf*4) x 8 x 8\n",
        "            nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),\n",
        "            nn.LeakyReLU(0.2, inplace=True),\n",
        "            # state size. (ndf*8) x 4 x 4\n",
        "            nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),\n",
        "        )\n",
        "\n",
        "    def forward(self, input):\n",
        "        return self.main(input)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x9HEb0a4E90v",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Create the Discriminator\n",
        "netD = Discriminator(ngpu).to(device)\n",
        "\n",
        "# Handle multi-gpu if desired\n",
        "if (device.type == 'cuda') and (ngpu > 1):\n",
        "  netD = nn.DataParallel(netD, list(range(ngpu)))\n",
        "\n",
        "if not have_checkpoint:      \n",
        "  # Apply the weights_init function to randomly initialize all weights\n",
        "  #  to mean=0, stdev=0.2.\n",
        "  netD.apply(weights_init)\n",
        "else:\n",
        "  netD.load_state_dict(checkpoint['netD_state_dict'])\n",
        "\n",
        "# Print the model\n",
        "print(netD)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Uk04ng_tE900",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Create batch of latent vectors that we will use to visualize\n",
        "#  the progression of the generator\n",
        "fixed_noise = torch.randn(64, nz, 1, 1, device=device)\n",
        "\n",
        "# Establish convention for real and fake labels during training\n",
        "real_label = 1\n",
        "fake_label = -1\n",
        "\n",
        "# Setup Adam optimizers for both G and D\n",
        "optimizerD = optim.Adam(netD.parameters(), lr=lr, betas=betas)\n",
        "optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=betas)\n",
        "\n",
        "if have_checkpoint:\n",
        "  optimizerD.load_state_dict(checkpoint['optimizerD_state_dict'])\n",
        "  optimizerG.load_state_dict(checkpoint['optimizerG_state_dict'])\n",
        "\n",
        "from torch import autograd\n",
        "\n",
        "def calc_gradient_penalty(netD, real_data, fake_data):\n",
        "    data_size = real_data.size()[0]\n",
        "    fake_data = fake_data[0:data_size]\n",
        "    \n",
        "    alpha = torch.rand(data_size, 1, 1, 1)\n",
        "    alpha = alpha.expand_as(real_data)\n",
        "    alpha = alpha.cuda()\n",
        "\n",
        "    interpolates = alpha * real_data + ((1 - alpha) * fake_data)\n",
        "    interpolates = interpolates.cuda()\n",
        "    interpolates = autograd.Variable(interpolates, requires_grad=True)\n",
        "\n",
        "    disc_interpolates = netD(interpolates)\n",
        "\n",
        "    gradients = autograd.grad(outputs=disc_interpolates, inputs=interpolates,\n",
        "                              grad_outputs=torch.ones(disc_interpolates.size()).cuda(),\n",
        "                              create_graph=True, retain_graph=True, only_inputs=True)[0]\n",
        "    gradients = gradients.view(gradients.size(0), -1)\n",
        "\n",
        "    gradient_penalty = ((gradients.norm(2, dim=1) - 1) ** 2).mean() * LAMBDA\n",
        "    return gradient_penalty"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uPFCTuKaE903",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Training Loop\n",
        "\n",
        "# Lists to keep track of progress\n",
        "img_list = []\n",
        "G_losses = []\n",
        "D_losses = []\n",
        "iters = 0\n",
        "\n",
        "# generate fake images before beginning training, in case we just want to look at a sample without training\n",
        "with torch.no_grad():\n",
        "    fake = netG(fixed_noise).detach().cpu()\n",
        "    img_list.append(vutils.make_grid(fake, padding=2, normalize=True))\n",
        "\n",
        "print(\"Starting Training Loop...\")\n",
        "# For each epoch\n",
        "for epoch in range(num_epochs):\n",
        "    # For each batch in the dataloader\n",
        "    for i, data in enumerate(dataloader, 0):\n",
        "        for j in range(num_critic_updates):\n",
        "            ############################\n",
        "            # (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))\n",
        "            ###########################\n",
        "            ## Train with all-real batch\n",
        "            netD.zero_grad()\n",
        "            # Format batch\n",
        "            real_cpu = data[0].to(device)\n",
        "            # Forward pass real batch through D\n",
        "            output = netD(real_cpu).view(-1)\n",
        "            # Calculate loss on all-real batch\n",
        "            errD_real = output.mean()\n",
        "            D_x = output.mean().item()\n",
        "\n",
        "            ## Train with all-fake batch\n",
        "            # Generate batch of latent vectors\n",
        "            noise = torch.randn(batch_size, nz, 1, 1, device=device)\n",
        "            # Generate fake image batch with G\n",
        "            fake = netG(noise)\n",
        "            # Classify all fake batch with D\n",
        "            output = netD(fake.detach()).view(-1)\n",
        "            # Calculate D's loss on the all-fake batch\n",
        "            errD_fake = output.mean()\n",
        "            D_G_z1 = output.mean().item()\n",
        "            \n",
        "            # Add the gradients from the all-real and all-fake batches\n",
        "            gradient_penalty = calc_gradient_penalty(netD, real_cpu.data, fake.data)\n",
        "\n",
        "            errD = errD_fake - errD_real + gradient_penalty\n",
        "            errD.backward()\n",
        "            # Update D\n",
        "            optimizerD.step()\n",
        "\n",
        "        ############################\n",
        "        # (2) Update G network: maximize log(D(G(z)))\n",
        "        ###########################\n",
        "        netG.zero_grad()\n",
        "        # Since we just updated D, perform another forward pass of all-fake batch through D\n",
        "        output = netD(fake).view(-1)\n",
        "        # Calculate G's loss based on this output\n",
        "        errG = - output.mean()\n",
        "        # Calculate gradients for G\n",
        "        errG.backward()\n",
        "        D_G_z2 = output.mean().item()\n",
        "        # Update G\n",
        "        optimizerG.step()\n",
        "        \n",
        "        # Output training stats\n",
        "        if i % 50 == 0:\n",
        "            print('[%d/%d][%d/%d]\\tLoss_D: %.4f\\tLoss_G: %.4f\\tD(x): %.4f\\tD(G(z)): %.4f / %.4f'\n",
        "                  % (epoch, num_epochs, i, len(dataloader),\n",
        "                     errD.item(), errG.item(), D_x, D_G_z1, D_G_z2))\n",
        "        \n",
        "        # Save Losses for plotting later\n",
        "        G_losses.append(errG.item())\n",
        "        D_losses.append(errD.item())\n",
        "        \n",
        "        # Check how the generator is doing by saving G's output on fixed_noise\n",
        "        if (iters % 500 == 0) or ((epoch == num_epochs-1) and (i == len(dataloader)-1)):\n",
        "            with torch.no_grad():\n",
        "                fake = netG(fixed_noise).detach().cpu()\n",
        "            img_list.append(vutils.make_grid(fake, padding=2, normalize=True))\n",
        "            \n",
        "        iters += 1\n",
        "\n",
        "    # save models and optimizers\n",
        "    torch.save({\n",
        "                'netG_state_dict': netG.state_dict(),\n",
        "                'netD_state_dict': netD.state_dict(),\n",
        "                'optimizerG_state_dict': optimizerG.state_dict(),\n",
        "                'optimizerD_state_dict': optimizerD.state_dict()\n",
        "                }, model_file_path)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8NODnTqSE906",
        "colab_type": "text"
      },
      "source": [
        "Results\n",
        "-------\n",
        "\n",
        "Finally, lets check out how we did. Here, we will look at three\n",
        "different results. First, we will see how D and G’s losses changed\n",
        "during training. Second, we will visualize G’s output on the fixed_noise\n",
        "batch for every epoch. And third, we will look at a batch of real data\n",
        "next to a batch of fake data from G.\n",
        "\n",
        "**Loss versus training iteration**\n",
        "\n",
        "Below is a plot of D & G’s losses versus training iterations.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZyrdNTyhE906",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "plt.figure(figsize=(10,5))\n",
        "plt.title(\"Generator and Discriminator Loss During Training\")\n",
        "plt.plot(G_losses,label=\"G\")\n",
        "plt.plot(D_losses,label=\"D\")\n",
        "plt.xlabel(\"iterations\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0p7sqxjZE909",
        "colab_type": "text"
      },
      "source": [
        "**Visualization of G’s progression**\n",
        "\n",
        "Remember how we saved the generator’s output on the fixed_noise batch\n",
        "after every epoch of training. Now, we can visualize the training\n",
        "progression of G with an animation. Press the play button to start the\n",
        "animation.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fi7V7rwRE90-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#%%capture\n",
        "fig = plt.figure(figsize=(8,8))\n",
        "plt.axis(\"off\")\n",
        "ims = [[plt.imshow(np.transpose(i,(1,2,0)), animated=True)] for i in img_list]\n",
        "ani = animation.ArtistAnimation(fig, ims, interval=1000, repeat_delay=1000, blit=True)\n",
        "\n",
        "HTML(ani.to_jshtml())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6Vq1Nwi1E91A",
        "colab_type": "text"
      },
      "source": [
        "**Real Images vs. Fake Images**\n",
        "\n",
        "Finally, lets take a look at some real images and fake images side by\n",
        "side.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MofRFv_JE91B",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Grab a batch of real images from the dataloader\n",
        "real_batch = next(iter(dataloader))\n",
        "\n",
        "# Plot the real images\n",
        "plt.figure(figsize=(15,15))\n",
        "plt.subplot(1,2,1)\n",
        "plt.axis(\"off\")\n",
        "plt.title(\"Real Images\")\n",
        "plt.imshow(np.transpose(vutils.make_grid(real_batch[0].to(device)[:64], padding=5, normalize=True).cpu(),(1,2,0)))\n",
        "\n",
        "# Plot the fake images from the last epoch\n",
        "plt.subplot(1,2,2)\n",
        "plt.axis(\"off\")\n",
        "plt.title(\"Fake Images\")\n",
        "plt.imshow(np.transpose(img_list[-1],(1,2,0)))\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7NdkwndjVkN1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# calculate frechet inception distance\n",
        "\n",
        "from torchvision.utils import save_image\n",
        "import glob\n",
        "num_batches = 100\n",
        "real_images_for_fid_dir = \"./fid_images/real/\"\n",
        "fake_images_for_fid_dir = \"./fid_images/fake/\"\n",
        "\n",
        "if not os.path.isdir(\"fid\"):\n",
        "    ! git clone https://github.com/mseitzer/pytorch-fid.git\n",
        "    ! mv pytorch-fid fid\n",
        "    os.makedirs(real_images_for_fid_dir)\n",
        "    os.makedirs(fake_images_for_fid_dir)\n",
        "\n",
        "for f in glob.glob(real_images_for_fid_dir + \"*\"):\n",
        "    os.remove(f)\n",
        "\n",
        "for f in glob.glob(fake_images_for_fid_dir + \"*\"):\n",
        "    os.remove(f)\n",
        "\n",
        "real_images = torch.cat([x[0] for _, x in zip(range(num_batches), iter(dataloader))])\n",
        "\n",
        "generator_inputs = torch.randn(batch_size * num_batches, nz, 1, 1, device=device)\n",
        "with torch.no_grad():\n",
        "    fake_images = netG(generator_inputs).detach().cpu()\n",
        "\n",
        "for i in range(real_images.size(0)):\n",
        "    save_image(real_images[i, :, :, :], real_images_for_fid_dir + '{}.png'.format(i))\n",
        "\n",
        "for i in range(fake_images.size(0)):\n",
        "    save_image(fake_images[i, :, :, :], fake_images_for_fid_dir + '{}.png'.format(i))\n",
        "\n",
        "! fid/fid_score.py --batch-size 128 --gpu 0 ./fid_images/real/ ./fid_images/fake/"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}