CIFAR_10_Basic_DC_Gan.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "CIFAR 10 Basic DC Gan.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "Mm964yyI4AiK",
        "QfUqmsxmTPsu",
        "ltEqQsIpK1Us"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "dPrgnGl9ZR_E",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive/',force_remount=True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G81dSJ3Uquzz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import torch \n",
        "import torchvision\n",
        "from torch import nn, optim\n",
        "from torch.autograd.variable import Variable\n",
        "from torchvision import transforms, datasets\n",
        "import os\n",
        "from PIL import Image\n",
        "import glob\n",
        "import PIL\n",
        "from PIL import ImageFont\n",
        "from PIL import Image\n",
        "from PIL import ImageDraw\n",
        "import matplotlib.pyplot as plt\n",
        "import random\n",
        "from bokeh.io import curdoc, show, output_notebook\n",
        "from bokeh.layouts import column\n",
        "from bokeh.models import ColumnDataSource\n",
        "from bokeh.plotting import figure\n",
        "from functools import partial\n",
        "from threading import Thread\n",
        "from tornado import gen\n",
        "import time\n",
        "import pickle\n",
        "from tqdm import tqdm\n",
        "import torchvision.utils as vutils\n",
        "\n",
        "\n",
        "#root folder\n",
        "root_dir=\"/content/drive/My Drive/Fall 2019/Deep Learning CSE 676/Projects/1/DC Gans/\"\n",
        "\n",
        "#data directories\n",
        "#output images\n",
        "output_dir=root_dir+\"output/epoch/\"\n",
        "#input images\n",
        "input_dir=root_dir+\"data/augmented/\"\n",
        "\n",
        "#log dir\n",
        "log_dir=root_dir+\"logs/\"\n",
        "\n",
        "#models\n",
        "model_dir=root_dir+\"model/\"\n",
        "#other resources\n",
        "res_dir=root_dir+\"res/\"\n",
        "#report and logging\n",
        "report_dir=root_dir+\"report/\"\n",
        "\n",
        "\n",
        "#parameters\n",
        "batch_size=100\n",
        "train_split=0.8\n",
        "train_epoch=50\n",
        "\n",
        "#input\n",
        "data_dir=\"data\"\n",
        "inp_width=32\n",
        "inp_height=32\n",
        "inp_channels=3\n",
        "nc=3\n",
        "nz=200\n",
        "\n",
        "#generator\n",
        "ngf=64\n",
        "ndf=64\n",
        "\n",
        "#discriminator\n",
        "ndf=2"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D_7FLsJSq_NS",
        "colab_type": "text"
      },
      "source": [
        "Importing logger to keep a track of training progress "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mm964yyI4AiK",
        "colab_type": "text"
      },
      "source": [
        "##utils"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m6pzQjPG4B2S",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "import itertools, imageio, torch\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from torchvision import datasets\n",
        "#from scipy.misc import imresize\n",
        "#import PIL\n",
        "#import pilutil\n",
        "\n",
        "\n",
        "def ones_target(size):\n",
        "  #returning tensor variable containing ones, with shape =size\n",
        "  data=Variable(torch.ones(size,1))\n",
        "  return data\n",
        "\n",
        "def zeros_target(size):\n",
        "  data=Variable(torch.zeros(size,1))\n",
        "  return data\n",
        "\n",
        "def images_to_vectors(images):\n",
        "  return images.view(images.size(0),3072) #parameters: (size to flatten(28 here, row size), no. of images to be flattened)\n",
        "\n",
        "def vectors_to_images(vectors):\n",
        "  return vectors.view(vectors.size(0),3,32,32) # to convert each row of vectors to 28x28 pixels images \n",
        "# parameteres: (initial flattened dim, no. of sub vectors to be converted to 2d, 2d dimensions of output )\n",
        "\n",
        "def show_result(G, x_, num_epoch, show = False, save = False, path = 'result.png'):\n",
        "    # G.eval()\n",
        "    y_ = G(x_)\n",
        "    y_=y_[:4]\n",
        "    y_ = y_.cpu()\n",
        "\n",
        "    size_figure_grid = 3\n",
        "    fig, ax = plt.subplots(x_.size()[0], size_figure_grid, figsize=(5, 5))\n",
        "    for i, j in itertools.product(range(x_.size()[0]), range(size_figure_grid)):\n",
        "        ax[i, j].get_xaxis().set_visible(False)\n",
        "        ax[i, j].get_yaxis().set_visible(False)\n",
        "\n",
        "    for i in range(y_.size()[0],2):\n",
        "\n",
        "        ax[i, 0].cla()\n",
        "        ax[i, 0].imshow((y_[i].numpy().transpose(1, 2, 0) + 1) / 2)\n",
        "        ax[i, 1].cla()\n",
        "        ax[i, 1].imshow((y_[i+1].numpy().transpose(1, 2, 0) + 1) / 2)\n",
        "\n",
        "    label = 'Epoch {0}'.format(num_epoch)\n",
        "    fig.text(0.5, 0.04, label, ha='center')\n",
        "\n",
        "    if save:\n",
        "        plt.savefig(path)\n",
        "\n",
        "    if show:\n",
        "        plt.show()\n",
        "    else:\n",
        "        plt.close()\n",
        "\n",
        "def show_train_hist(hist, show = False, save = False, path = 'Train_hist.png'):\n",
        "    x = range(len(hist['D_losses']))\n",
        "\n",
        "    y1 = hist['D_losses']\n",
        "    y2 = hist['G_losses']\n",
        "\n",
        "    plt.plot(x, y1, label='D_loss')\n",
        "    plt.plot(x, y2, label='G_loss')\n",
        "\n",
        "    plt.xlabel('Iter')\n",
        "    plt.ylabel('Loss')\n",
        "\n",
        "    plt.legend(loc=4)\n",
        "    plt.grid(True)\n",
        "    plt.tight_layout()\n",
        "\n",
        "    if save:\n",
        "        plt.savefig(path)\n",
        "\n",
        "    if show:\n",
        "        plt.show()\n",
        "    else:\n",
        "        plt.close()\n",
        "\n",
        "def generate_animation(root, model, opt):\n",
        "    images = []\n",
        "    for e in range(opt.train_epoch):\n",
        "        img_name = root + 'Fixed_results/' + model + str(e + 1) + '.png'\n",
        "        images.append(imageio.imread(img_name))\n",
        "    imageio.mimsave(root + model + 'generate_animation.gif', images, fps=5)\n",
        "\n",
        "def data_load(path, subfolder, transform, batch_size, shuffle=True):\n",
        "    dset = datasets.ImageFolder(path, transform)\n",
        "    ind = dset.class_to_idx[subfolder]\n",
        "\n",
        "    n = 0\n",
        "    for i in range(dset.__len__()):\n",
        "        if ind != dset.imgs[n][1]:\n",
        "            del dset.imgs[n]\n",
        "            n -= 1\n",
        "\n",
        "        n += 1\n",
        "\n",
        "    return torch.utils.data.DataLoader(dset, batch_size=batch_size, shuffle=shuffle)\n",
        "\n",
        "def imgs_resize(imgs, resize_scale = 286):\n",
        "    outputs = torch.FloatTensor(imgs.size()[0], imgs.size()[1], resize_scale, resize_scale)\n",
        "    for i in range(imgs.size()[0]):\n",
        "        img = imresize(imgs[i].numpy(), [resize_scale, resize_scale])\n",
        "        outputs[i] = torch.FloatTensor((img.transpose(2, 0, 1).astype(np.float32).reshape(-1, imgs.size()[1], resize_scale, resize_scale) - 127.5) / 127.5)\n",
        "\n",
        "    return outputs\n",
        "\n",
        "def random_crop(imgs1, imgs2, crop_size = 256):\n",
        "    outputs1 = torch.FloatTensor(imgs1.size()[0], imgs1.size()[1], crop_size, crop_size)\n",
        "    outputs2 = torch.FloatTensor(imgs2.size()[0], imgs2.size()[1], crop_size, crop_size)\n",
        "    for i in range(imgs1.size()[0]):\n",
        "        img1 = imgs1[i]\n",
        "        img2 = imgs2[i]\n",
        "        rand1 = np.random.randint(0, imgs1.size()[2] - crop_size)\n",
        "        rand2 = np.random.randint(0, imgs2.size()[2] - crop_size)\n",
        "        outputs1[i] = img1[:, rand1: crop_size + rand1, rand2: crop_size + rand2]\n",
        "        outputs2[i] = img2[:, rand1: crop_size + rand1, rand2: crop_size + rand2]\n",
        "\n",
        "    return outputs1, outputs2\n",
        "\n",
        "def random_fliplr(imgs1, imgs2):\n",
        "    outputs1 = torch.FloatTensor(imgs1.size())\n",
        "    outputs2 = torch.FloatTensor(imgs2.size())\n",
        "    for i in range(imgs1.size()[0]):\n",
        "        if torch.rand(1)[0] < 0.5:\n",
        "            img1 = torch.FloatTensor(\n",
        "                (np.fliplr(imgs1[i].numpy().transpose(1, 2, 0)).transpose(2, 0, 1).reshape(-1, imgs1.size()[1], imgs1.size()[2], imgs1.size()[3]) + 1) / 2)\n",
        "            outputs1[i] = (img1 - 0.5) / 0.5\n",
        "            img2 = torch.FloatTensor(\n",
        "                (np.fliplr(imgs2[i].numpy().transpose(1, 2, 0)).transpose(2, 0, 1).reshape(-1, imgs2.size()[1], imgs2.size()[2], imgs2.size()[3]) + 1) / 2)\n",
        "            outputs2[i] = (img2 - 0.5) / 0.5\n",
        "        else:\n",
        "            outputs1[i] = imgs1[i]\n",
        "            outputs2[i] = imgs2[i]\n",
        "\n",
        "    return outputs1, outputs2\n",
        "\n",
        "def imshow(img):\n",
        "    img = img / 2 + 0.5     # unnormalize\n",
        "    npimg = img.numpy()\n",
        "    plt.imshow(np.transpose(npimg, (1, 2, 0)))\n",
        "    plt.show()\n",
        "    \n",
        "def noise(size):\n",
        "  n=Variable(torch.randn(size,200))\n",
        "  return n\n",
        " \n",
        "def weights_init(m):\n",
        "    classname = m.__class__.__name__\n",
        "    if classname.find('Conv') != -1:\n",
        "        m.weight.data.normal_(0.0, 0.02)\n",
        "    elif classname.find('BatchNorm') != -1:\n",
        "        m.weight.data.normal_(1.0, 0.02)\n",
        "        m.bias.data.fill_(0)\n",
        "        \n",
        "def log_tboard(numerical_info, image_info,step):\n",
        "\n",
        "  for tag, value in numerical_info.items():\n",
        "      logger.scalar_summary(tag, value, step+1)\n",
        "\n",
        "  #for tag, images in image_info.items():\n",
        "   #   logger.image_summary(tag, images, step+1)\n",
        "     \n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y8xtngMv2yDK",
        "colab_type": "text"
      },
      "source": [
        "##Loading the CIFAR Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ahwUvnwh20hC",
        "colab_type": "code",
        "outputId": "a708ccc5-ebbe-462a-a8dc-e55558b1d47f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 425
        }
      },
      "source": [
        "transform = transforms.Compose(\n",
        "    [transforms.ToTensor(),\n",
        "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
        "\n",
        "dataset = torchvision.datasets.CIFAR10(root='./data', train=True,\n",
        "                                        download=True, transform=transform)\n",
        "\n",
        "train_size=int(train_split*len(dataset))\n",
        "val_size=len(dataset)-train_size\n",
        "trainset, valset=torch.utils.data.random_split(dataset,[train_size,val_size])\n",
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n",
        "                                          shuffle=True, num_workers=2)\n",
        "valloader = torch.utils.data.DataLoader(valset, batch_size=batch_size,\n",
        "                                          shuffle=True, num_workers=2)\n",
        "\n",
        "testset = torchvision.datasets.CIFAR10(root='./data', train=False,\n",
        "                                       download=True, transform=transform)\n",
        "testloader = torch.utils.data.DataLoader(testset, batch_size=4,\n",
        "                                         shuffle=False, num_workers=2)\n",
        "\n",
        "classes = ('plane', 'car', 'bird', 'cat',\n",
        "           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n",
        "\n",
        "print(\"Size of train set\",len(trainloader))\n",
        "print(\"Size of val set\",len(valloader))\n",
        "print(\"Size of test set\",len(testloader))\n",
        "\n",
        "\n",
        "\n",
        "# get some random training images\n",
        "dataiter = iter(trainloader)\n",
        "images, labels = dataiter.next()\n",
        "\n",
        "# show images\n",
        "imshow(torchvision.utils.make_grid(images))\n",
        "# print labels\n",
        "print(' '.join('%5s' % classes[labels[j]] for j in range(batch_size)))\n",
        "print(\"Size of images\",images.size())\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\r0it [00:00, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            " 98%|█████████▊| 167911424/170498071 [00:12<00:00, 16952978.87it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Extracting ./data/cifar-10-python.tar.gz to ./data\n",
            "Files already downloaded and verified\n",
            "Size of train set 400\n",
            "Size of val set 100\n",
            "Size of test set 2500\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAALIAAAD8CAYAAADT2P50AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRK5CYII=\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            " bird  deer   dog   cat plane  frog   dog plane  bird truck   cat   car   cat horse   dog truck horse truck   dog  ship   car  ship  deer   cat plane plane horse  deer  frog   cat   dog  frog  bird   cat  frog  bird   car  bird horse  ship   dog   cat truck  deer  ship  ship plane   car   dog  ship   car  deer plane  ship   cat   car   car  ship   car   cat  ship  deer  ship  bird   cat   car  bird  ship   car  frog plane  ship   car   cat   dog   cat  bird horse  bird horse  bird  ship  frog  deer   cat plane   dog   dog plane  deer  ship   car   car   dog truck  deer   car plane   cat   dog\n",
            "Size of images torch.Size([100, 3, 32, 32])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "to1Jq4QK1fzh",
        "colab_type": "text"
      },
      "source": [
        "Adding funcionality to flatten an image and vice versa. \n",
        "Flattening means to convert a multidimensional matrix to one dimensional"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QfUqmsxmTPsu",
        "colab_type": "text"
      },
      "source": [
        "##model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EMAU28spIIyx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Generator(nn.Module):\n",
        "    def __init__(self, ngpu=64):\n",
        "        super(Generator, self).__init__()\n",
        "        self.ngpu = ngpu\n",
        "        self.main = nn.Sequential(\n",
        "            # input is Z, going into a convolution\n",
        "\n",
        "            # state size. (ngf*8) x 4 x 4\n",
        "            nn.ConvTranspose2d(200, ngf * 4, 4, 1, 0, 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,      3, 4, 2, 1, bias=False),\n",
        "            nn.Tanh()\n",
        "            # state size. (nc) x 64 x 64\n",
        "        )\n",
        "\n",
        "            \n",
        "    def forward(self, input):\n",
        "#         if input.is_cuda and self.ngpu > 1:\n",
        "#             output = nn.parallel.data_parallel(self.main, input, range(self.ngpu))\n",
        "#         else:\n",
        "#             output = self.main(input)\n",
        "        output = self.main(input)\n",
        "        return output\n",
        "\n",
        "class Discriminator(nn.Module):\n",
        "    def __init__(self, ngpu=64):\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(3, 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.BatchNorm2d(ndf * 2),\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.BatchNorm2d(ndf * 4),\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.BatchNorm2d(ndf * 8),\n",
        "            nn.LeakyReLU(0.2, inplace=True),\n",
        "            # state size. (ndf*8) x 4 x 4\n",
        "            nn.Conv2d(ndf * 8, 1, 1, 1, 0, bias=False),\n",
        "            nn.Sigmoid()\n",
        "        )\n",
        "\n",
        "    def forward(self, input):\n",
        "#         if input.is_cuda and self.ngpu > 1:\n",
        "#             output = nn.parallel.data_parallel(self.main, input, range(self.ngpu))\n",
        "#         else:\n",
        "#             output = self.main(input)\n",
        "        output = self.main(input)\n",
        "        return output.view(-1, 1).squeeze(1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5WpEN-sGKBOn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "num_test_samples=16\n",
        "#generating test samples\n",
        "test_noise=noise(num_test_samples)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ltEqQsIpK1Us",
        "colab_type": "text"
      },
      "source": [
        "##Training the Gan"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OUHXgR9MOwdS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from PIL import Image\n",
        "def register_extension(id, extension): Image.EXTENSION[extension.lower()] = id.upper()\n",
        "Image.register_extension = register_extension\n",
        "def register_extensions(id, extensions): \n",
        "  for extension in extensions: register_extension(id, extension)\n",
        "Image.register_extensions = register_extensions"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EfTDecmxK_Mc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from PIL import Image\n",
        "#creating logger instance\n",
        "num_epochs=50\n",
        "num_batches = len(trainloader)\n",
        "for epoch in range(num_epochs):\n",
        "  for n_batch,(real_batch,_) in enumerate(trainloader):\n",
        "    N=real_batch.size(0)\n",
        "    \n",
        "    #Train discriminator\n",
        "    real_data=Variable(images_to_vectors(real_batch))\n",
        "    #generate fake data and detach to avoid further calculation of gradients\n",
        "    fake_data=generator(noise(N)).detach()\n",
        "    \n",
        "    #train\n",
        "    d_error,d_pred_real,d_pred_fake=train_discriminator(d_optimizer, real_data, fake_data)\n",
        "    \n",
        "    #Train Generator\n",
        "    #generate fake data\n",
        "    fake_data=generator(noise(N))\n",
        "    #train \n",
        "    g_error=train_generator(g_optimizer, fake_data)\n",
        "    #Log batch error\n",
        "    \n",
        "    if(n_batch)%100==0: #??\n",
        "      test_images=vectors_to_images(generator(test_noise))\n",
        "      test_images=test_images.data\n",
        "            \n",
        "      #display status logs\n",
        "      import matplotlib.pyplot as plt\n",
        "      f, axarr = plt.subplots(2, 2)\n",
        "      axarr[0, 0].imshow(test_images[0,0])\n",
        "      axarr[0,1].imshow(test_images[1,0])\n",
        "      axarr[1, 0].imshow(test_images[2,0])\n",
        "      axarr[1, 1].imshow(test_images[3,0])\n",
        "      # Fine-tune figure; make subplots farther from each other.\n",
        "      f.subplots_adjust(hspace=0.3)\n",
        "\n",
        "      plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zIS_HptgayEW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "f, axarr = plt.subplots(2, 2)\n",
        "axarr[0, 0].imshow(test_images[0,0])\n",
        "axarr[0,1].imshow(test_images[1,0])\n",
        "axarr[1, 0].imshow(test_images[2,0])\n",
        "axarr[1, 1].imshow(test_images[3,0])\n",
        "# Fine-tune figure; make subplots farther from each other.\n",
        "f.subplots_adjust(hspace=0.3)\n",
        "\n",
        "plt.show()\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GiM3SlQkAVt0",
        "colab_type": "text"
      },
      "source": [
        "https://medium.com/ai-society/gans-from-scratch-1-a-deep-introduction-with-code-in-pytorch-and-tensorflow-cb03cdcdba0f"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qkHirAiOOJ05",
        "colab_type": "code",
        "outputId": "096299d6-574e-41f6-d851-51e5a9e146f0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 122
        }
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive/',force_remount=True)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Go to this URL in a browser: https://accounts.google.com/o/oauth2/auth?client_id=947318989803-6bn6qk8qdgf4n4g3pfee6491hc0brc4i.apps.googleusercontent.com&redirect_uri=urn%3Aietf%3Awg%3Aoauth%3A2.0%3Aoob&scope=email%20https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fdocs.test%20https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fdrive%20https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fdrive.photos.readonly%20https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fpeopleapi.readonly&response_type=code\n",
            "\n",
            "Enter your authorization code:\n",
            "··········\n",
            "Mounted at /content/drive/\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xqwXkFWBfrXd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from torch.utils import tensorboard"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mHL5-Ns5zg1O",
        "colab_type": "text"
      },
      "source": [
        "##From pix2pix model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GjeSuVBhQVUO",
        "colab_type": "code",
        "outputId": "1a134739-8fb9-4a37-8847-9d062ed36a0b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 646
        }
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive/',force_remount=True)\n",
        "print(len(dataset))\n",
        "train_size=int(train_split*len(dataset))\n",
        "val_size=len(dataset)-train_size\n",
        "train_dataset, val_dataset=torch.utils.data.random_split(dataset,[train_size,val_size])\n",
        "train_dataloader=torch.utils.data.DataLoader(dataset=train_dataset, \n",
        "                                              batch_size=batch_size,\n",
        "                                             shuffle=True,\n",
        "                                          num_workers=4)\n",
        "num_batches=len(train_dataloader)\n",
        "val_dataloader=torch.utils.data.DataLoader(dataset=val_dataset,\n",
        "                                             batch_size=batch_size,\n",
        "                                             shuffle=True,\n",
        "                                          num_workers=4)\n",
        "\n",
        "\n",
        "#from model import generator, discriminator\n",
        "#import utils\n",
        "\n",
        "#parameters\n",
        "lrG=0.02\n",
        "lrD=0.02\n",
        "beta1=0.5\n",
        "beta2=0.999\n",
        "L1_lambda=1.5\n",
        "\n",
        "\n",
        "\n",
        "start_time=time.time()\n",
        "epoch_start=0\n",
        "epoch_end=epoch_start+train_epoch\n",
        "\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "G = Generator(ngf)\n",
        "D = Discriminator(ndf)\n",
        "G_optimizer=optim.Adam(G.parameters(),lr=lrG,betas=(beta1,beta2))\n",
        "D_optimizer=optim.Adam(D.parameters(),lr=lrD,betas=(beta1,beta2))\n",
        "#loss\n",
        "\n",
        "BCE_loss=nn.BCELoss().to(device)\n",
        "L1_loss=nn.L1Loss().to(device)\n",
        "fid_model=FID(\"./\",device)\n",
        "#fid_model.compute_fid(real_image,G_result) #todo add fid score\n",
        "\n",
        "logger=Logger(log_dir)\n",
        "#Loading the model if previously exists\n",
        "if(os.path.isfile(model_dir+'generator_param.pkl') and os.path.isfile(model_dir+'discriminator_param.pkl')):\n",
        "\n",
        "  G_checkpoint=torch.load(model_dir+'generator_param.pkl',map_location=device)\n",
        "  D_checkpoint=torch.load(model_dir+'discriminator_param.pkl',map_location=device)\n",
        "  G.load_state_dict(G_checkpoint['model_state_dict'])\n",
        "  D.load_state_dict(D_checkpoint['model_state_dict'])\n",
        "  G.to(device)\n",
        "  D.to(device)\n",
        "  G.train()\n",
        "  D.train()\n",
        "  #D.eval()\n",
        "\n",
        "  G_optimizer.load_state_dict(G_checkpoint['optimizer_state_dict'])\n",
        "  D_optimizer.load_state_dict(D_checkpoint['optimizer_state_dict'])\n",
        "\n",
        "  train_hist=G_checkpoint['train_hist']\n",
        "  epoch_start=G_checkpoint['epoch']\n",
        "  epoch_end=epoch_start+train_epoch\n",
        "#Esle creating new model\n",
        "else:  \n",
        "  print(\"Previous model not found. Restarting train process...\")\n",
        "  G.apply(weights_init)\n",
        "  D.apply(weights_init)\n",
        "  G.to(device)\n",
        "  D.to(device)\n",
        "  G.train()\n",
        "  D.train()\n",
        "\n",
        "\n",
        "  G_optimizer=optim.Adam(G.parameters(),lr=lrG,betas=(beta1,beta2))\n",
        "  D_optimizer=optim.Adam(D.parameters(),lr=lrD,betas=(beta1,beta2))\n",
        "\n",
        "  train_hist={}\n",
        "  train_hist['D_losses']=[]\n",
        "  train_hist['G_losses']=[]\n",
        "  train_hist['per_epoch_ptimes']=[]\n",
        "  train_hist['total_ptime']=[]\n",
        "  epoch_start=0\n",
        "  epoch_end=epoch_start+train_epoch\n",
        "\n",
        "#training\n",
        "for epoch in range(epoch_start,epoch_end):\n",
        "  D_losses=[]\n",
        "  G_losses=[]\n",
        "  epoch_start_time=time.time()\n",
        "  num_iter=0\n",
        "  for (real_image, _) in train_dataloader:\n",
        "    inp_noise=torch.randn(batch_size, nz, 1, 1, device=device)\n",
        "    inp_noise,real_image=Variable(inp_noise.to(device)),Variable(real_image.to(device))\n",
        "    D.zero_grad()\n",
        "\n",
        "    D_result=D(real_image).squeeze()\n",
        "    \n",
        "    D_real_loss=BCE_loss(D_result,Variable(torch.ones(D_result.size()).to(device)))\n",
        "    \n",
        "    G_result=G(inp_noise)\n",
        "    G_result=G_result.detach()\n",
        "    D_result=D(G_result).squeeze()\n",
        "    D_fake_loss=BCE_loss(D_result,Variable(torch.zeros(D_result.size()).to(device)))\n",
        "    \n",
        "    D_train_loss=(D_real_loss +D_fake_loss)*0.5\n",
        "    D_train_loss.backward()\n",
        "    D_optimizer.step()\n",
        "    train_hist['D_losses'].append(float(D_train_loss))\n",
        "\n",
        "    D_losses.append(float(D_train_loss))\n",
        "    D_losses.append(float(0))\n",
        "\n",
        "    #training generator\n",
        "    G.zero_grad()\n",
        "\n",
        "    G_result=G(inp_noise)\n",
        "    G_result=G_result.detach()\n",
        "    D_result=D(G_result).squeeze()\n",
        "    G_train_loss=BCE_loss(D_result, Variable(torch.ones(D_result.size()).to(device))) + L1_lambda*L1_loss(G_result,real_image)\n",
        "    G_train_loss.backward()\n",
        "    G_optimizer.step()\n",
        "\n",
        "    train_hist['G_losses'].append(float(G_train_loss))\n",
        "    G_losses.append(float(G_train_loss))\n",
        "    \n",
        "    num_iter+=1\n",
        "\n",
        "  torch.save({\n",
        "            'epoch': epoch,\n",
        "            'model_state_dict': G.state_dict(),\n",
        "            'optimizer_state_dict': G_optimizer.state_dict(),\n",
        "            'train_hist': train_hist\n",
        "            }, model_dir+'generator_param.pkl')\n",
        "\n",
        "  torch.save({\n",
        "            'model_state_dict': D.state_dict(),\n",
        "            'optimizer_state_dict': D_optimizer.state_dict(),\n",
        "            },model_dir+'discriminator_param.pkl')\n",
        "\n",
        "  epoch_end_time=time.time()\n",
        "  per_epoch_ptime=epoch_end_time-epoch_start_time\n",
        "  print('[%d/%d] - ptime: %.2f, loss_d: %.3f, loss_g: %.3f' % ((epoch + 1), train_epoch, per_epoch_ptime, torch.mean(torch.FloatTensor(D_losses)),\n",
        "                                                              torch.mean(torch.FloatTensor(G_losses))))\n",
        "  fixed_p =  output_dir  + str(epoch + 1) + '.png'\n",
        "  save_noise=torch.randn(1, nz, 1, 1, device=device)\n",
        "  #show_result(G, Variable(inp_noise.to(device), volatile=True), real_image.cpu(), (epoch+1), save=True, path=fixed_p)\n",
        "  vutils.save_image(G(save_noise).detach(),\n",
        "                    fixed_p,\n",
        "                    normalize=True)\n",
        "  num_info = { 'Discriminator loss': torch.mean(torch.FloatTensor(D_losses)), 'Generator loss': torch.mean(torch.FloatTensor(G_losses)) }  \n",
        "  fake_to_show=G(save_noise).detach()\n",
        "  print(fake_to_show[0].size())\n",
        "  image_info = { 'images': fake_to_show.cpu().numpy()}\n",
        "  log_tboard(num_info,image_info,epoch)\n",
        "  train_hist['per_epoch_ptimes'].append(per_epoch_ptime)\n",
        "  \n",
        "  \n",
        "\n",
        "end_time=time.time()\n",
        "total_ptime=end_time-start_time\n",
        "train_hist['total_ptime'].append(total_ptime)\n",
        "print(\"Avg one epoch ptime: %.2f, total %d epochs ptime: %.2f\" % (torch.mean(torch.FloatTensor(train_hist['per_epoch_ptimes'])), train_epoch, total_ptime))\n",
        "\n",
        "\n",
        "with open(report_dir+'train_hist.pkl', 'wb') as f:\n",
        "    pickle.dump(train_hist, f)\n",
        "\n",
        "show_train_hist(train_hist, save=True, path=report_dir + 'train_hist.png')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive/\n",
            "50000\n",
            "[53/50] - ptime: 17.22, loss_d: 1.727, loss_g: 21.382\n",
            "torch.Size([3, 32, 32])\n",
            "[54/50] - ptime: 17.12, loss_d: 1.727, loss_g: 21.356\n",
            "torch.Size([3, 32, 32])\n",
            "[55/50] - ptime: 17.29, loss_d: 1.727, loss_g: 21.306\n",
            "torch.Size([3, 32, 32])\n",
            "[56/50] - ptime: 17.14, loss_d: 1.727, loss_g: 21.258\n",
            "torch.Size([3, 32, 32])\n",
            "[57/50] - ptime: 17.10, loss_d: 1.727, loss_g: 21.249\n",
            "torch.Size([3, 32, 32])\n",
            "[58/50] - ptime: 17.14, loss_d: 1.727, loss_g: 21.245\n",
            "torch.Size([3, 32, 32])\n",
            "[59/50] - ptime: 17.29, loss_d: 1.727, loss_g: 21.221\n",
            "torch.Size([3, 32, 32])\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-38-6b2594e5a8e0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m    117\u001b[0m     \u001b[0mG\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzero_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    118\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 119\u001b[0;31m     \u001b[0mG_result\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mG\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minp_noise\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    120\u001b[0m     \u001b[0mG_result\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mG_result\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdetach\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    121\u001b[0m     \u001b[0mD_result\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mD\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mG_result\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqueeze\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m    539\u001b[0m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    540\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 541\u001b[0;31m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    542\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mhook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    543\u001b[0m             \u001b[0mhook_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-6-3dccd6af9ca5>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m     30\u001b[0m \u001b[0;31m#         else:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     31\u001b[0m \u001b[0;31m#             output = self.main(input)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 32\u001b[0;31m         \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     33\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0moutput\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     34\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m    539\u001b[0m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    540\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 541\u001b[0;31m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    542\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mhook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    543\u001b[0m             \u001b[0mhook_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torch/nn/modules/container.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m     90\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     91\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mmodule\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_modules\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 92\u001b[0;31m             \u001b[0minput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodule\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     93\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m    539\u001b[0m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    540\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 541\u001b[0;31m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    542\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mhook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    543\u001b[0m             \u001b[0mhook_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torch/nn/modules/conv.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input, output_size)\u001b[0m\n\u001b[1;32m    776\u001b[0m         return F.conv_transpose2d(\n\u001b[1;32m    777\u001b[0m             \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbias\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstride\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpadding\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 778\u001b[0;31m             output_padding, self.groups, self.dilation)\n\u001b[0m\u001b[1;32m    779\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    780\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SJAt9zCjwABR",
        "colab_type": "code",
        "outputId": "a1c9ccef-9c8b-4462-aa73-99880cc12f7b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 63
        }
      },
      "source": [
        "!tensorboard --logdir=log_dir --port=6007"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "TensorBoard 1.15.0 at http://683152f1a078:6007/ (Press CTRL+C to quit)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yCIn6w9dnx90",
        "colab_type": "text"
      },
      "source": [
        "##logger"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X_EthbVdnw-4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Code referenced from https://gist.github.com/gyglim/1f8dfb1b5c82627ae3efcfbbadb9f514\n",
        "import tensorflow as tf\n",
        "import numpy as np\n",
        "import scipy.misc \n",
        "from PIL import Image\n",
        "try:\n",
        "    from StringIO import StringIO  # Python 2.7\n",
        "except ImportError:\n",
        "    from io import BytesIO         # Python 3.x\n",
        "\n",
        "\n",
        "class Logger(object):\n",
        "    \n",
        "    def __init__(self, log_dir):\n",
        "        \"\"\"Create a summary writer logging to log_dir.\"\"\"\n",
        "        self.writer = tf.summary.FileWriter(log_dir)\n",
        "\n",
        "    def scalar_summary(self, tag, value, step):\n",
        "        \"\"\"Log a scalar variable.\"\"\"\n",
        "        summary = tf.Summary(value=[tf.Summary.Value(tag=tag, simple_value=value)])\n",
        "        self.writer.add_summary(summary, step)\n",
        "\n",
        "    def image_summary(self, tag, images, step):\n",
        "        \"\"\"Log a list of images.\"\"\"\n",
        "\n",
        "        img_summaries = []\n",
        "        for i, img in enumerate(images):\n",
        "            # Write the image to a string\n",
        "            try:\n",
        "                s = StringIO()\n",
        "            except:\n",
        "                s = BytesIO()\n",
        "            print(img.size)\n",
        "            Image.fromarray(img).save(s, format=\"png\")\n",
        "\n",
        "            # Create an Image object\n",
        "            img_sum = tf.Summary.Image(encoded_image_string=s.getvalue(),\n",
        "                                       height=img.shape[0],\n",
        "                                       width=img.shape[1])\n",
        "            # Create a Summary value\n",
        "            img_summaries.append(tf.Summary.Value(tag='%s/%d' % (tag, i), image=img_sum))\n",
        "\n",
        "        # Create and write Summary\n",
        "        summary = tf.Summary(value=img_summaries)\n",
        "        self.writer.add_summary(summary, step)\n",
        "        \n",
        "    def histo_summary(self, tag, values, step, bins=1000):\n",
        "        \"\"\"Log a histogram of the tensor of values.\"\"\"\n",
        "\n",
        "        # Create a histogram using numpy\n",
        "        counts, bin_edges = np.histogram(values, bins=bins)\n",
        "\n",
        "        # Fill the fields of the histogram proto\n",
        "        hist = tf.HistogramProto()\n",
        "        hist.min = float(np.min(values))\n",
        "        hist.max = float(np.max(values))\n",
        "        hist.num = int(np.prod(values.shape))\n",
        "        hist.sum = float(np.sum(values))\n",
        "        hist.sum_squares = float(np.sum(values**2))\n",
        "\n",
        "        # Drop the start of the first bin\n",
        "        bin_edges = bin_edges[1:]\n",
        "\n",
        "        # Add bin edges and counts\n",
        "        for edge in bin_edges:\n",
        "            hist.bucket_limit.append(edge)\n",
        "        for c in counts:\n",
        "            hist.bucket.append(c)\n",
        "\n",
        "        # Create and write Summary\n",
        "        summary = tf.Summary(value=[tf.Summary.Value(tag=tag, histo=hist)])\n",
        "        self.writer.add_summary(summary, step)\n",
        "        self.writer.flush()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YGjr8iSrn2fv",
        "colab_type": "text"
      },
      "source": [
        "##fid score "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VQRNhSDgb0e8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import math\n",
        "import os\n",
        "import warnings\n",
        "import numpy as np\n",
        "from scipy import linalg\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.autograd as autograd\n",
        "import torch.optim as optim\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "import torchvision.models as models\n",
        "from tqdm import tqdm_notebook as tqdm\n",
        "\n",
        "class FID():\n",
        "    def __init__(self, cache_dir, device='cpu', transform_input=True):\n",
        "        #cuda:0\n",
        "        os.environ[\"TORCH_HOME\"] = \"./Cache\"\n",
        "        self.device=device\n",
        "        self.transform_input = transform_input\n",
        "        self.InceptionV3 = models.inception_v3(pretrained=True, transform_input=False, aux_logits=False).to(device=self.device)\n",
        "        self.InceptionV3.eval()\n",
        "    \n",
        "    def build_maps(self, x):\n",
        "        # Resize to Fit InceptionV3\n",
        "        if list(x.shape[-2:]) != [299,299]:\n",
        "            with warnings.catch_warnings():\n",
        "                warnings.simplefilter(\"ignore\")\n",
        "                x = F.interpolate(x, size=[299,299], mode='bilinear')\n",
        "        # Transform Input to InceptionV3 Standards\n",
        "        if self.transform_input:\n",
        "            x_ch0 = torch.unsqueeze(x[:, 0], 1) * (0.229 / 0.5) + (0.485 - 0.5) / 0.5\n",
        "            x_ch1 = torch.unsqueeze(x[:, 1], 1) * (0.224 / 0.5) + (0.456 - 0.5) / 0.5\n",
        "            x_ch2 = torch.unsqueeze(x[:, 2], 1) * (0.225 / 0.5) + (0.406 - 0.5) / 0.5\n",
        "            x = torch.cat((x_ch0, x_ch1, x_ch2), 1)\n",
        "        # Run Through Partial InceptionV3 Model\n",
        "        with torch.no_grad():\n",
        "            # N x 3 x 299 x 299\n",
        "            x = self.InceptionV3.Conv2d_1a_3x3(x)\n",
        "            # N x 32 x 149 x 149\n",
        "            x = self.InceptionV3.Conv2d_2a_3x3(x)\n",
        "            # N x 32 x 147 x 147\n",
        "            x = self.InceptionV3.Conv2d_2b_3x3(x)\n",
        "            # N x 64 x 147 x 147\n",
        "            x = F.max_pool2d(x, kernel_size=3, stride=2)\n",
        "            # N x 64 x 73 x 73\n",
        "            x = self.InceptionV3.Conv2d_3b_1x1(x)\n",
        "            # N x 80 x 73 x 73\n",
        "            x = self.InceptionV3.Conv2d_4a_3x3(x)\n",
        "            # N x 192 x 71 x 71\n",
        "            x = F.max_pool2d(x, kernel_size=3, stride=2)\n",
        "            # N x 192 x 35 x 35\n",
        "            x = self.InceptionV3.Mixed_5b(x)\n",
        "            # N x 256 x 35 x 35\n",
        "            x = self.InceptionV3.Mixed_5c(x)\n",
        "            # N x 288 x 35 x 35\n",
        "            x = self.InceptionV3.Mixed_5d(x)\n",
        "            # N x 288 x 35 x 35\n",
        "            x = self.InceptionV3.Mixed_6a(x)\n",
        "            # N x 768 x 17 x 17\n",
        "            x = self.InceptionV3.Mixed_6b(x)\n",
        "            # N x 768 x 17 x 17\n",
        "            x = self.InceptionV3.Mixed_6c(x)\n",
        "            # N x 768 x 17 x 17\n",
        "            x = self.InceptionV3.Mixed_6d(x)\n",
        "            # N x 768 x 17 x 17\n",
        "            x = self.InceptionV3.Mixed_6e(x)\n",
        "            # N x 768 x 17 x 17\n",
        "            x = self.InceptionV3.Mixed_7a(x)\n",
        "            # N x 1280 x 8 x 8\n",
        "            x = self.InceptionV3.Mixed_7b(x)\n",
        "            # N x 2048 x 8 x 8\n",
        "            x = self.InceptionV3.Mixed_7c(x)\n",
        "            # N x 2048 x 8 x 8\n",
        "            # Adaptive average pooling\n",
        "            x = F.adaptive_avg_pool2d(x, (1, 1))\n",
        "            # N x 2048 x 1 x 1\n",
        "            return x\n",
        "    \n",
        "    def compute_fid(self, real_images, generated_images, batch_size=64):\n",
        "        # Ensure Set Sizes are the Same\n",
        "        assert(real_images.shape[0] == generated_images.shape[0])\n",
        "        # Build Random Sampling Orders\n",
        "        real_images = real_images[np.random.permutation(real_images.shape[0])]\n",
        "        generated_images = generated_images[np.random.permutation(generated_images.shape[0])]\n",
        "        # Lists of Maps per Batch\n",
        "        real_maps = []\n",
        "        generated_maps = []\n",
        "        # Build Maps\n",
        "        for s in tqdm(range(math.ceil(real_images.shape[0]/batch_size)), desc='Evaluation', leave=False):\n",
        "            sidx = np.arange(batch_size*s, min(batch_size*(s+1), real_images.shape[0]))\n",
        "            real_maps.append(self.build_maps(real_images[sidx].to(device=self.device)).detach().to(device='cpu'))\n",
        "            generated_maps.append(self.build_maps(generated_images[sidx].to(device=self.device)).detach().to(device='cpu'))\n",
        "        # Concatenate Maps\n",
        "        real_maps = np.squeeze(torch.cat(real_maps).numpy())\n",
        "        generated_maps = np.squeeze(torch.cat(generated_maps).numpy())\n",
        "        # Calculate FID\n",
        "        # Activation Statistics\n",
        "        mu_g = np.mean(generated_maps, axis=0)\n",
        "        mu_x = np.mean(real_maps, axis=0)\n",
        "        sigma_g = np.cov(generated_maps, rowvar=False)\n",
        "        sigma_x = np.cov(real_maps, rowvar=False)\n",
        "        # Sum of Squared Differences\n",
        "        ssd = np.sum((mu_g - mu_x)**2)\n",
        "        # Square Root of Product of Covariances\n",
        "        covmean = linalg.sqrtm(sigma_g.dot(sigma_x), disp=False)[0]\n",
        "        if np.iscomplexobj(covmean):\n",
        "            covmean = covmean.real\n",
        "        # Final FID Computation\n",
        "        return ssd + np.trace(sigma_g + sigma_x - 2*covmean)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "98Ub7h6rdXPY",
        "colab_type": "code",
        "outputId": "5b401ba8-87dc-407b-fcd9-f7d6414e0676",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 666
        }
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading: \"https://download.pytorch.org/models/inception_v3_google-1a9a5a14.pth\" to ./Cache/checkpoints/inception_v3_google-1a9a5a14.pth\n",
            "\n",
            "  0%|          | 0.00/104M [00:00<?, ?B/s]\u001b[A\n",
            "  0%|          | 112k/104M [00:00<01:38, 1.10MB/s]\u001b[A\n",
            "  1%|          | 560k/104M [00:00<01:16, 1.42MB/s]\u001b[A\n",
            "  2%|▏         | 2.45M/104M [00:00<00:53, 1.97MB/s]\u001b[A\n",
            "  8%|▊         | 8.10M/104M [00:00<00:36, 2.78MB/s]\u001b[A\n",
            " 14%|█▎        | 14.1M/104M [00:00<00:24, 3.90MB/s]\u001b[A\n",
            " 19%|█▉        | 20.0M/104M [00:00<00:16, 5.42MB/s]\u001b[A\n",
            " 25%|██▌       | 26.1M/104M [00:00<00:10, 7.46MB/s]\u001b[A\n",
            " 31%|███       | 32.2M/104M [00:00<00:07, 10.2MB/s]\u001b[A\n",
            " 37%|███▋      | 38.4M/104M [00:00<00:05, 13.6MB/s]\u001b[A\n",
            " 43%|████▎     | 44.5M/104M [00:01<00:03, 17.8MB/s]\u001b[A\n",
            " 49%|████▉     | 50.6M/104M [00:01<00:02, 22.7MB/s]\u001b[A\n",
            " 55%|█████▍    | 56.7M/104M [00:01<00:01, 28.1MB/s]\u001b[A\n",
            " 61%|██████    | 62.8M/104M [00:01<00:01, 33.8MB/s]\u001b[A\n",
            " 66%|██████▋   | 68.9M/104M [00:01<00:00, 39.4MB/s]\u001b[A\n",
            " 72%|███████▏  | 75.1M/104M [00:01<00:00, 44.6MB/s]\u001b[A\n",
            " 78%|███████▊  | 81.1M/104M [00:01<00:00, 48.9MB/s]\u001b[A\n",
            " 84%|████████▍ | 87.1M/104M [00:01<00:00, 52.4MB/s]\u001b[A\n",
            " 90%|████████▉ | 93.1M/104M [00:01<00:00, 55.0MB/s]\u001b[A\n",
            " 96%|█████████▌| 99.1M/104M [00:01<00:00, 57.1MB/s]\u001b[A\n",
            "100%|██████████| 104M/104M [00:01<00:00, 54.6MB/s] \u001b[A"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "torch.Size([100, 3, 32, 32]) torch.Size([100, 3, 32, 32])\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "fd1a8c7eadb049958a73225cebc93943",
              "version_minor": 0,
              "version_major": 2
            },
            "text/plain": [
              "HBox(children=(IntProgress(value=0, description='Evaluation', max=2, style=ProgressStyle(description_width='in…"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Exception ignored in: <bound method tqdm.__del__ of 170500096it [08:45, 16952978.87it/s]>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.6/dist-packages/tqdm/_tqdm.py\", line 931, in __del__\n",
            "    self.close()\n",
            "  File \"/usr/local/lib/python3.6/dist-packages/tqdm/_tqdm.py\", line 1133, in close\n",
            "    self._decr_instances(self)\n",
            "  File \"/usr/local/lib/python3.6/dist-packages/tqdm/_tqdm.py\", line 496, in _decr_instances\n",
            "    cls.monitor.exit()\n",
            "  File \"/usr/local/lib/python3.6/dist-packages/tqdm/_monitor.py\", line 52, in exit\n",
            "    self.join()\n",
            "  File \"/usr/lib/python3.6/threading.py\", line 1053, in join\n",
            "    raise RuntimeError(\"cannot join current thread\")\n",
            "RuntimeError: cannot join current thread\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\r"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "429.42303295797626"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UQ2N_xo549TJ",
        "colab_type": "text"
      },
      "source": [
        "## W GAN"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FEdPsLJnBCax",
        "colab_type": "code",
        "outputId": "f67004db-21b2-49c8-e6e6-81447ac6b1d3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 384
        }
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive/',force_remount=True)\n",
        "print(len(dataset))\n",
        "train_size=int(train_split*len(dataset))\n",
        "val_size=len(dataset)-train_size\n",
        "train_dataset, val_dataset=torch.utils.data.random_split(dataset,[train_size,val_size])\n",
        "train_dataloader=torch.utils.data.DataLoader(dataset=train_dataset, \n",
        "                                              batch_size=batch_size,\n",
        "                                             shuffle=True,\n",
        "                                          num_workers=4)\n",
        "num_batches=len(train_dataloader)\n",
        "val_dataloader=torch.utils.data.DataLoader(dataset=val_dataset,\n",
        "                                             batch_size=batch_size,\n",
        "                                             shuffle=True,\n",
        "                                          num_workers=4)\n",
        "\n",
        "\n",
        "#from model import generator, discriminator\n",
        "#import utils\n",
        "\n",
        "#parameters\n",
        "lrG=0.02\n",
        "lrD=0.02\n",
        "beta1=0.5\n",
        "beta2=0.999\n",
        "L1_lambda=1.5\n",
        "\n",
        "\n",
        "\n",
        "start_time=time.time()\n",
        "epoch_start=0\n",
        "epoch_end=epoch_start+train_epoch\n",
        "\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "G = Generator(ngf)\n",
        "D = Discriminator(ndf)\n",
        "G_optimizer=torch.optim.RMSprop(G.parameters(), lr=0.0001)\n",
        "D_optimizer=torch.optim.RMSprop(D.parameters(), lr=0.0001)\n",
        "\n",
        "BCE_loss=nn.BCELoss().to(device)\n",
        "L1_loss=nn.L1Loss().to(device)\n",
        "\n",
        "#Loading the model if previously exists\n",
        "if(os.path.isfile(model_dir+'generator_param.pkl') and os.path.isfile(model_dir+'discriminator_param.pkl')):\n",
        "\n",
        "  G_checkpoint=torch.load(model_dir+'generator_param.pkl',map_location=device)\n",
        "  D_checkpoint=torch.load(model_dir+'discriminator_param.pkl',map_location=device)\n",
        "  G.load_state_dict(G_checkpoint['model_state_dict'])\n",
        "  D.load_state_dict(D_checkpoint['model_state_dict'])\n",
        "  G.to(device)\n",
        "  D.to(device)\n",
        "  G.train()\n",
        "  D.train()\n",
        "  #D.eval()\n",
        "\n",
        "  G_optimizer.load_state_dict(G_checkpoint['optimizer_state_dict'])\n",
        "  D_optimizer.load_state_dict(D_checkpoint['optimizer_state_dict'])\n",
        "\n",
        "  train_hist=G_checkpoint['train_hist']\n",
        "  epoch_start=G_checkpoint['epoch']\n",
        "  epoch_end=epoch_start+train_epoch\n",
        "#Esle creating new model\n",
        "else:  \n",
        "  print(\"Previous model not found. Restarting train process...\")\n",
        "  G.apply(weights_init)\n",
        "  D.apply(weights_init)\n",
        "  G.to(device)\n",
        "  D.to(device)\n",
        "  G.train()\n",
        "  D.train()\n",
        "\n",
        "\n",
        "  G_optimizer=optim.Adam(G.parameters(),lr=lrG,betas=(beta1,beta2))\n",
        "  D_optimizer=optim.Adam(D.parameters(),lr=lrD,betas=(beta1,beta2))\n",
        "\n",
        "  train_hist={}\n",
        "  train_hist['D_losses']=[]\n",
        "  train_hist['G_losses']=[]\n",
        "  train_hist['per_epoch_ptimes']=[]\n",
        "  train_hist['total_ptime']=[]\n",
        "  epoch_start=0\n",
        "  epoch_end=epoch_start+train_epoch\n",
        "\n",
        "#training\n",
        "for epoch in range(epoch_start,epoch_end):\n",
        "  D_losses=[]\n",
        "  G_losses=[]\n",
        "  epoch_start_time=time.time()\n",
        "  num_iter=0\n",
        "  for (real_image, _) in train_dataloader:\n",
        "    inp_noise=torch.randn(batch_size, nz, 1, 1, device=device)\n",
        "    inp_noise,real_image=Variable(inp_noise.to(device)),Variable(real_image.to(device))\n",
        "    D.zero_grad()\n",
        "\n",
        "    D_real=D(real_image).squeeze()\n",
        "\n",
        "    \n",
        "    G_result=G(inp_noise)\n",
        "    G_result=G_result.detach()\n",
        "    D_fake=D(G_result).squeeze()\n",
        "\n",
        "    D_train_loss=-torch.mean(D_real) + torch.mean(D_fake)\n",
        "    D_train_loss.backward()\n",
        "    D_optimizer.step()\n",
        "    \n",
        "    for p in D.parameters():\n",
        "      p.data.clamp_(-0.01, 0.01)\n",
        "    \n",
        "    train_hist['D_losses'].append(float(D_train_loss))\n",
        "\n",
        "    D_losses.append(float(D_train_loss))\n",
        "    D_losses.append(float(0))\n",
        "    for _ in range(5):\n",
        "      #training generator\n",
        "      G.zero_grad()\n",
        "\n",
        "      G_result=G(inp_noise)\n",
        "      G_result=G_result.detach()\n",
        "      D_result=D(G_result).squeeze()\n",
        "      G_train_loss = -torch.mean(D_result)\n",
        "      G_train_loss.backward()\n",
        "      G_optimizer.step()\n",
        "\n",
        "    train_hist['G_losses'].append(float(G_train_loss))\n",
        "    G_losses.append(float(G_train_loss))\n",
        "    num_iter+=1\n",
        "\n",
        "  torch.save({\n",
        "            'epoch': epoch,\n",
        "            'model_state_dict': G.state_dict(),\n",
        "            'optimizer_state_dict': G_optimizer.state_dict(),\n",
        "            'train_hist': train_hist\n",
        "            }, model_dir+'generator_param.pkl')\n",
        "\n",
        "  torch.save({\n",
        "            'model_state_dict': D.state_dict(),\n",
        "            'optimizer_state_dict': D_optimizer.state_dict(),\n",
        "            },model_dir+'discriminator_param.pkl')\n",
        "\n",
        "  epoch_end_time=time.time()\n",
        "  per_epoch_ptime=epoch_end_time-epoch_start_time\n",
        "  print('[%d/%d] - ptime: %.2f, loss_d: %.3f, loss_g: %.3f' % ((epoch + 1), train_epoch, per_epoch_ptime, torch.mean(torch.FloatTensor(D_losses)),\n",
        "                                                              torch.mean(torch.FloatTensor(G_losses))))\n",
        "  fixed_p =  output_dir  + str(epoch + 1) + '.png'\n",
        "  save_noise=torch.randn(1, nz, 1, 1, device=device)\n",
        "  #show_result(G, Variable(inp_noise.to(device), volatile=True), real_image.cpu(), (epoch+1), save=True, path=fixed_p)\n",
        "  vutils.save_image(G(save_noise).detach(),\n",
        "                    fixed_p,\n",
        "                    normalize=True)\n",
        "  train_hist['per_epoch_ptimes'].append(per_epoch_ptime)\n",
        "\n",
        "end_time=time.time()\n",
        "total_ptime=end_time-start_time\n",
        "train_hist['total_ptime'].append(total_ptime)\n",
        "print(\"Avg one epoch ptime: %.2f, total %d epochs ptime: %.2f\" % (torch.mean(torch.FloatTensor(train_hist['per_epoch_ptimes'])), train_epoch, total_ptime))\n",
        "\n",
        "\n",
        "with open(report_dir+'train_hist.pkl', 'wb') as f:\n",
        "    pickle.dump(train_hist, f)\n",
        "\n",
        "show_train_hist(train_hist, save=True, path=report_dir + 'train_hist.png')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive/\n",
            "50000\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "KeyError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-47-7d456cb1b2d6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m    102\u001b[0m     \u001b[0mD_train_loss\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mD_real\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mD_fake\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    103\u001b[0m     \u001b[0mD_train_loss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 104\u001b[0;31m     \u001b[0mD_optimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    105\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    106\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mp\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mD\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparameters\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torch/optim/rmsprop.py\u001b[0m in \u001b[0;36mstep\u001b[0;34m(self, closure)\u001b[0m\n\u001b[1;32m     76\u001b[0m                         \u001b[0mstate\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'grad_avg'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros_like\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     77\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 78\u001b[0;31m                 \u001b[0msquare_avg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstate\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'square_avg'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     79\u001b[0m                 \u001b[0malpha\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgroup\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'alpha'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     80\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyError\u001b[0m: 'square_avg'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_-r-Wk7i4_aH",
        "colab_type": "text"
      },
      "source": [
        "##FID Score\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wRMIiBZF5jth",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "from torchvision import models\n",
        "\n",
        "try:\n",
        "    from torchvision.models.utils import load_state_dict_from_url\n",
        "except ImportError:\n",
        "    from torch.utils.model_zoo import load_url as load_state_dict_from_url\n",
        "\n",
        "# Inception weights ported to Pytorch from\n",
        "# http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz\n",
        "FID_WEIGHTS_URL = 'https://github.com/mseitzer/pytorch-fid/releases/download/fid_weights/pt_inception-2015-12-05-6726825d.pth'\n",
        "\n",
        "\n",
        "class InceptionV3(nn.Module):\n",
        "    \"\"\"Pretrained InceptionV3 network returning feature maps\"\"\"\n",
        "\n",
        "    # Index of default block of inception to return,\n",
        "    # corresponds to output of final average pooling\n",
        "    DEFAULT_BLOCK_INDEX = 3\n",
        "\n",
        "    # Maps feature dimensionality to their output blocks indices\n",
        "    BLOCK_INDEX_BY_DIM = {\n",
        "        64: 0,   # First max pooling features\n",
        "        192: 1,  # Second max pooling featurs\n",
        "        768: 2,  # Pre-aux classifier features\n",
        "        2048: 3  # Final average pooling features\n",
        "    }\n",
        "\n",
        "    def __init__(self,\n",
        "                 output_blocks=[DEFAULT_BLOCK_INDEX],\n",
        "                 resize_input=True,\n",
        "                 normalize_input=True,\n",
        "                 requires_grad=False,\n",
        "                 use_fid_inception=True):\n",
        "        \"\"\"Build pretrained InceptionV3\n",
        "        Parameters\n",
        "        ----------\n",
        "        output_blocks : list of int\n",
        "            Indices of blocks to return features of. Possible values are:\n",
        "                - 0: corresponds to output of first max pooling\n",
        "                - 1: corresponds to output of second max pooling\n",
        "                - 2: corresponds to output which is fed to aux classifier\n",
        "                - 3: corresponds to output of final average pooling\n",
        "        resize_input : bool\n",
        "            If true, bilinearly resizes input to width and height 299 before\n",
        "            feeding input to model. As the network without fully connected\n",
        "            layers is fully convolutional, it should be able to handle inputs\n",
        "            of arbitrary size, so resizing might not be strictly needed\n",
        "        normalize_input : bool\n",
        "            If true, scales the input from range (0, 1) to the range the\n",
        "            pretrained Inception network expects, namely (-1, 1)\n",
        "        requires_grad : bool\n",
        "            If true, parameters of the model require gradients. Possibly useful\n",
        "            for finetuning the network\n",
        "        use_fid_inception : bool\n",
        "            If true, uses the pretrained Inception model used in Tensorflow's\n",
        "            FID implementation. If false, uses the pretrained Inception model\n",
        "            available in torchvision. The FID Inception model has different\n",
        "            weights and a slightly different structure from torchvision's\n",
        "            Inception model. If you want to compute FID scores, you are\n",
        "            strongly advised to set this parameter to true to get comparable\n",
        "            results.\n",
        "        \"\"\"\n",
        "        super(InceptionV3, self).__init__()\n",
        "\n",
        "        self.resize_input = resize_input\n",
        "        self.normalize_input = normalize_input\n",
        "        self.output_blocks = sorted(output_blocks)\n",
        "        self.last_needed_block = max(output_blocks)\n",
        "\n",
        "        assert self.last_needed_block <= 3, \\\n",
        "            'Last possible output block index is 3'\n",
        "\n",
        "        self.blocks = nn.ModuleList()\n",
        "\n",
        "        if use_fid_inception:\n",
        "            inception = fid_inception_v3()\n",
        "        else:\n",
        "            inception = models.inception_v3(pretrained=True)\n",
        "\n",
        "        # Block 0: input to maxpool1\n",
        "        block0 = [\n",
        "            inception.Conv2d_1a_3x3,\n",
        "            inception.Conv2d_2a_3x3,\n",
        "            inception.Conv2d_2b_3x3,\n",
        "            nn.MaxPool2d(kernel_size=3, stride=2)\n",
        "        ]\n",
        "        self.blocks.append(nn.Sequential(*block0))\n",
        "\n",
        "        # Block 1: maxpool1 to maxpool2\n",
        "        if self.last_needed_block >= 1:\n",
        "            block1 = [\n",
        "                inception.Conv2d_3b_1x1,\n",
        "                inception.Conv2d_4a_3x3,\n",
        "                nn.MaxPool2d(kernel_size=3, stride=2)\n",
        "            ]\n",
        "            self.blocks.append(nn.Sequential(*block1))\n",
        "\n",
        "        # Block 2: maxpool2 to aux classifier\n",
        "        if self.last_needed_block >= 2:\n",
        "            block2 = [\n",
        "                inception.Mixed_5b,\n",
        "                inception.Mixed_5c,\n",
        "                inception.Mixed_5d,\n",
        "                inception.Mixed_6a,\n",
        "                inception.Mixed_6b,\n",
        "                inception.Mixed_6c,\n",
        "                inception.Mixed_6d,\n",
        "                inception.Mixed_6e,\n",
        "            ]\n",
        "            self.blocks.append(nn.Sequential(*block2))\n",
        "\n",
        "        # Block 3: aux classifier to final avgpool\n",
        "        if self.last_needed_block >= 3:\n",
        "            block3 = [\n",
        "                inception.Mixed_7a,\n",
        "                inception.Mixed_7b,\n",
        "                inception.Mixed_7c,\n",
        "                nn.AdaptiveAvgPool2d(output_size=(1, 1))\n",
        "            ]\n",
        "            self.blocks.append(nn.Sequential(*block3))\n",
        "\n",
        "        for param in self.parameters():\n",
        "            param.requires_grad = requires_grad\n",
        "\n",
        "    def forward(self, inp):\n",
        "        \"\"\"Get Inception feature maps\n",
        "        Parameters\n",
        "        ----------\n",
        "        inp : torch.autograd.Variable\n",
        "            Input tensor of shape Bx3xHxW. Values are expected to be in\n",
        "            range (0, 1)\n",
        "        Returns\n",
        "        -------\n",
        "        List of torch.autograd.Variable, corresponding to the selected output\n",
        "        block, sorted ascending by index\n",
        "        \"\"\"\n",
        "        outp = []\n",
        "        x = inp\n",
        "\n",
        "        if self.resize_input:\n",
        "            x = F.interpolate(x,\n",
        "                              size=(299, 299),\n",
        "                              mode='bilinear',\n",
        "                              align_corners=False)\n",
        "\n",
        "        if self.normalize_input:\n",
        "            x = 2 * x - 1  # Scale from range (0, 1) to range (-1, 1)\n",
        "\n",
        "        for idx, block in enumerate(self.blocks):\n",
        "            x = block(x)\n",
        "            if idx in self.output_blocks:\n",
        "                outp.append(x)\n",
        "\n",
        "            if idx == self.last_needed_block:\n",
        "                break\n",
        "\n",
        "        return outp\n",
        "\n",
        "\n",
        "def fid_inception_v3():\n",
        "    \"\"\"Build pretrained Inception model for FID computation\n",
        "    The Inception model for FID computation uses a different set of weights\n",
        "    and has a slightly different structure than torchvision's Inception.\n",
        "    This method first constructs torchvision's Inception and then patches the\n",
        "    necessary parts that are different in the FID Inception model.\n",
        "    \"\"\"\n",
        "    inception = models.inception_v3(num_classes=1008,\n",
        "                                    aux_logits=False,\n",
        "                                    pretrained=False)\n",
        "    inception.Mixed_5b = FIDInceptionA(192, pool_features=32)\n",
        "    inception.Mixed_5c = FIDInceptionA(256, pool_features=64)\n",
        "    inception.Mixed_5d = FIDInceptionA(288, pool_features=64)\n",
        "    inception.Mixed_6b = FIDInceptionC(768, channels_7x7=128)\n",
        "    inception.Mixed_6c = FIDInceptionC(768, channels_7x7=160)\n",
        "    inception.Mixed_6d = FIDInceptionC(768, channels_7x7=160)\n",
        "    inception.Mixed_6e = FIDInceptionC(768, channels_7x7=192)\n",
        "    inception.Mixed_7b = FIDInceptionE_1(1280)\n",
        "    inception.Mixed_7c = FIDInceptionE_2(2048)\n",
        "\n",
        "    state_dict = load_state_dict_from_url(FID_WEIGHTS_URL, progress=True)\n",
        "    inception.load_state_dict(state_dict)\n",
        "    return inception\n",
        "\n",
        "\n",
        "class FIDInceptionA(models.inception.InceptionA):\n",
        "    \"\"\"InceptionA block patched for FID computation\"\"\"\n",
        "    def __init__(self, in_channels, pool_features):\n",
        "        super(FIDInceptionA, self).__init__(in_channels, pool_features)\n",
        "\n",
        "    def forward(self, x):\n",
        "        branch1x1 = self.branch1x1(x)\n",
        "\n",
        "        branch5x5 = self.branch5x5_1(x)\n",
        "        branch5x5 = self.branch5x5_2(branch5x5)\n",
        "\n",
        "        branch3x3dbl = self.branch3x3dbl_1(x)\n",
        "        branch3x3dbl = self.branch3x3dbl_2(branch3x3dbl)\n",
        "        branch3x3dbl = self.branch3x3dbl_3(branch3x3dbl)\n",
        "\n",
        "        # Patch: Tensorflow's average pool does not use the padded zero's in\n",
        "        # its average calculation\n",
        "        branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1,\n",
        "                                   count_include_pad=False)\n",
        "        branch_pool = self.branch_pool(branch_pool)\n",
        "\n",
        "        outputs = [branch1x1, branch5x5, branch3x3dbl, branch_pool]\n",
        "        return torch.cat(outputs, 1)\n",
        "\n",
        "\n",
        "class FIDInceptionC(models.inception.InceptionC):\n",
        "    \"\"\"InceptionC block patched for FID computation\"\"\"\n",
        "    def __init__(self, in_channels, channels_7x7):\n",
        "        super(FIDInceptionC, self).__init__(in_channels, channels_7x7)\n",
        "\n",
        "    def forward(self, x):\n",
        "        branch1x1 = self.branch1x1(x)\n",
        "\n",
        "        branch7x7 = self.branch7x7_1(x)\n",
        "        branch7x7 = self.branch7x7_2(branch7x7)\n",
        "        branch7x7 = self.branch7x7_3(branch7x7)\n",
        "\n",
        "        branch7x7dbl = self.branch7x7dbl_1(x)\n",
        "        branch7x7dbl = self.branch7x7dbl_2(branch7x7dbl)\n",
        "        branch7x7dbl = self.branch7x7dbl_3(branch7x7dbl)\n",
        "        branch7x7dbl = self.branch7x7dbl_4(branch7x7dbl)\n",
        "        branch7x7dbl = self.branch7x7dbl_5(branch7x7dbl)\n",
        "\n",
        "        # Patch: Tensorflow's average pool does not use the padded zero's in\n",
        "        # its average calculation\n",
        "        branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1,\n",
        "                                   count_include_pad=False)\n",
        "        branch_pool = self.branch_pool(branch_pool)\n",
        "\n",
        "        outputs = [branch1x1, branch7x7, branch7x7dbl, branch_pool]\n",
        "        return torch.cat(outputs, 1)\n",
        "\n",
        "\n",
        "class FIDInceptionE_1(models.inception.InceptionE):\n",
        "    \"\"\"First InceptionE block patched for FID computation\"\"\"\n",
        "    def __init__(self, in_channels):\n",
        "        super(FIDInceptionE_1, self).__init__(in_channels)\n",
        "\n",
        "    def forward(self, x):\n",
        "        branch1x1 = self.branch1x1(x)\n",
        "\n",
        "        branch3x3 = self.branch3x3_1(x)\n",
        "        branch3x3 = [\n",
        "            self.branch3x3_2a(branch3x3),\n",
        "            self.branch3x3_2b(branch3x3),\n",
        "        ]\n",
        "        branch3x3 = torch.cat(branch3x3, 1)\n",
        "\n",
        "        branch3x3dbl = self.branch3x3dbl_1(x)\n",
        "        branch3x3dbl = self.branch3x3dbl_2(branch3x3dbl)\n",
        "        branch3x3dbl = [\n",
        "            self.branch3x3dbl_3a(branch3x3dbl),\n",
        "            self.branch3x3dbl_3b(branch3x3dbl),\n",
        "        ]\n",
        "        branch3x3dbl = torch.cat(branch3x3dbl, 1)\n",
        "\n",
        "        # Patch: Tensorflow's average pool does not use the padded zero's in\n",
        "        # its average calculation\n",
        "        branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1,\n",
        "                                   count_include_pad=False)\n",
        "        branch_pool = self.branch_pool(branch_pool)\n",
        "\n",
        "        outputs = [branch1x1, branch3x3, branch3x3dbl, branch_pool]\n",
        "        return torch.cat(outputs, 1)\n",
        "\n",
        "\n",
        "class FIDInceptionE_2(models.inception.InceptionE):\n",
        "    \"\"\"Second InceptionE block patched for FID computation\"\"\"\n",
        "    def __init__(self, in_channels):\n",
        "        super(FIDInceptionE_2, self).__init__(in_channels)\n",
        "\n",
        "    def forward(self, x):\n",
        "        branch1x1 = self.branch1x1(x)\n",
        "\n",
        "        branch3x3 = self.branch3x3_1(x)\n",
        "        branch3x3 = [\n",
        "            self.branch3x3_2a(branch3x3),\n",
        "            self.branch3x3_2b(branch3x3),\n",
        "        ]\n",
        "        branch3x3 = torch.cat(branch3x3, 1)\n",
        "\n",
        "        branch3x3dbl = self.branch3x3dbl_1(x)\n",
        "        branch3x3dbl = self.branch3x3dbl_2(branch3x3dbl)\n",
        "        branch3x3dbl = [\n",
        "            self.branch3x3dbl_3a(branch3x3dbl),\n",
        "            self.branch3x3dbl_3b(branch3x3dbl),\n",
        "        ]\n",
        "        branch3x3dbl = torch.cat(branch3x3dbl, 1)\n",
        "\n",
        "        # Patch: The FID Inception model uses max pooling instead of average\n",
        "        # pooling. This is likely an error in this specific Inception\n",
        "        # implementation, as other Inception models use average pooling here\n",
        "        # (which matches the description in the paper).\n",
        "        branch_pool = F.max_pool2d(x, kernel_size=3, stride=1, padding=1)\n",
        "        branch_pool = self.branch_pool(branch_pool)\n",
        "\n",
        "        outputs = [branch1x1, branch3x3, branch3x3dbl, branch_pool]\n",
        "        return torch.cat(outputs, 1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bpXgYycu5CeH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "  \n",
        "#!/usr/bin/env python3\n",
        "\n",
        "import os\n",
        "import pathlib\n",
        "from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter\n",
        "\n",
        "import numpy as np\n",
        "import torch\n",
        "from scipy import linalg\n",
        "from scipy.misc import imread\n",
        "from torch.nn.functional import adaptive_avg_pool2d\n",
        "\n",
        "try:\n",
        "    from tqdm import tqdm\n",
        "except ImportError:\n",
        "    # If not tqdm is not available, provide a mock version of it\n",
        "    def tqdm(x): return x\n",
        "\n",
        "#from inception import InceptionV3\n",
        "'''\n",
        "parser = ArgumentParser(formatter_class=ArgumentDefaultsHelpFormatter)\n",
        "parser.add_argument('path', type=str, nargs=2,\n",
        "                    help=('Path to the generated images or '\n",
        "                          'to .npz statistic files'))\n",
        "parser.add_argument('--batch-size', type=int, default=50,\n",
        "                    help='Batch size to use')\n",
        "parser.add_argument('--dims', type=int, default=2048,\n",
        "                    choices=list(InceptionV3.BLOCK_INDEX_BY_DIM),\n",
        "                    help=('Dimensionality of Inception features to use. '\n",
        "                          'By default, uses pool3 features'))\n",
        "parser.add_argument('-c', '--gpu', default='', type=str,\n",
        "                    help='GPU to use (leave blank for CPU only)')\n",
        "\n",
        "'''\n",
        "def get_activations(files, model, batch_size=50, dims=2048,\n",
        "                    cuda=False, verbose=False):\n",
        "    \"\"\"Calculates the activations of the pool_3 layer for all images.\n",
        "    Params:\n",
        "    -- files       : List of image files paths\n",
        "    -- model       : Instance of inception model\n",
        "    -- batch_size  : Batch size of images for the model to process at once.\n",
        "                     Make sure that the number of samples is a multiple of\n",
        "                     the batch size, otherwise some samples are ignored. This\n",
        "                     behavior is retained to match the original FID score\n",
        "                     implementation.\n",
        "    -- dims        : Dimensionality of features returned by Inception\n",
        "    -- cuda        : If set to True, use GPU\n",
        "    -- verbose     : If set to True and parameter out_step is given, the number\n",
        "                     of calculated batches is reported.\n",
        "    Returns:\n",
        "    -- A numpy array of dimension (num images, dims) that contains the\n",
        "       activations of the given tensor when feeding inception with the\n",
        "       query tensor.\n",
        "    \"\"\"\n",
        "    model.eval()\n",
        "\n",
        "    if len(files) % batch_size != 0:\n",
        "        print(('Warning: number of images is not a multiple of the '\n",
        "               'batch size. Some samples are going to be ignored.'))\n",
        "    if batch_size > len(files):\n",
        "        print(('Warning: batch size is bigger than the data size. '\n",
        "               'Setting batch size to data size'))\n",
        "        batch_size = len(files)\n",
        "\n",
        "    n_batches = len(files) // batch_size\n",
        "    n_used_imgs = n_batches * batch_size\n",
        "\n",
        "    pred_arr = np.empty((n_used_imgs, dims))\n",
        "\n",
        "    for i in tqdm(range(n_batches)):\n",
        "        if verbose:\n",
        "            print('\\rPropagating batch %d/%d' % (i + 1, n_batches),\n",
        "                  end='', flush=True)\n",
        "        start = i * batch_size\n",
        "        end = start + batch_size\n",
        "\n",
        "        images = np.array([imread(str(f)).astype(np.float32)\n",
        "                           for f in files[start:end]])\n",
        "\n",
        "        # Reshape to (n_images, 3, height, width)\n",
        "        images = images.transpose((0, 3, 1, 2))\n",
        "        images /= 255\n",
        "\n",
        "        batch = torch.from_numpy(images).type(torch.FloatTensor)\n",
        "        if cuda:\n",
        "            batch = batch.cuda()\n",
        "\n",
        "        pred = model(batch)[0]\n",
        "\n",
        "        # If model output is not scalar, apply global spatial average pooling.\n",
        "        # This happens if you choose a dimensionality not equal 2048.\n",
        "        if pred.shape[2] != 1 or pred.shape[3] != 1:\n",
        "            pred = adaptive_avg_pool2d(pred, output_size=(1, 1))\n",
        "\n",
        "        pred_arr[start:end] = pred.cpu().data.numpy().reshape(batch_size, -1)\n",
        "\n",
        "    if verbose:\n",
        "        print(' done')\n",
        "\n",
        "    return pred_arr\n",
        "\n",
        "\n",
        "def calculate_frechet_distance(mu1, sigma1, mu2, sigma2, eps=1e-6):\n",
        "    \"\"\"Numpy implementation of the Frechet Distance.\n",
        "    The Frechet distance between two multivariate Gaussians X_1 ~ N(mu_1, C_1)\n",
        "    and X_2 ~ N(mu_2, C_2) is\n",
        "            d^2 = ||mu_1 - mu_2||^2 + Tr(C_1 + C_2 - 2*sqrt(C_1*C_2)).\n",
        "    Stable version by Dougal J. Sutherland.\n",
        "    Params:\n",
        "    -- mu1   : Numpy array containing the activations of a layer of the\n",
        "               inception net (like returned by the function 'get_predictions')\n",
        "               for generated samples.\n",
        "    -- mu2   : The sample mean over activations, precalculated on an\n",
        "               representative data set.\n",
        "    -- sigma1: The covariance matrix over activations for generated samples.\n",
        "    -- sigma2: The covariance matrix over activations, precalculated on an\n",
        "               representative data set.\n",
        "    Returns:\n",
        "    --   : The Frechet Distance.\n",
        "    \"\"\"\n",
        "\n",
        "    mu1 = np.atleast_1d(mu1)\n",
        "    mu2 = np.atleast_1d(mu2)\n",
        "\n",
        "    sigma1 = np.atleast_2d(sigma1)\n",
        "    sigma2 = np.atleast_2d(sigma2)\n",
        "\n",
        "    assert mu1.shape == mu2.shape, \\\n",
        "        'Training and test mean vectors have different lengths'\n",
        "    assert sigma1.shape == sigma2.shape, \\\n",
        "        'Training and test covariances have different dimensions'\n",
        "\n",
        "    diff = mu1 - mu2\n",
        "\n",
        "    # Product might be almost singular\n",
        "    covmean, _ = linalg.sqrtm(sigma1.dot(sigma2), disp=False)\n",
        "    if not np.isfinite(covmean).all():\n",
        "        msg = ('fid calculation produces singular product; '\n",
        "               'adding %s to diagonal of cov estimates') % eps\n",
        "        print(msg)\n",
        "        offset = np.eye(sigma1.shape[0]) * eps\n",
        "        covmean = linalg.sqrtm((sigma1 + offset).dot(sigma2 + offset))\n",
        "\n",
        "    # Numerical error might give slight imaginary component\n",
        "    if np.iscomplexobj(covmean):\n",
        "        if not np.allclose(np.diagonal(covmean).imag, 0, atol=1e-3):\n",
        "            m = np.max(np.abs(covmean.imag))\n",
        "            raise ValueError('Imaginary component {}'.format(m))\n",
        "        covmean = covmean.real\n",
        "\n",
        "    tr_covmean = np.trace(covmean)\n",
        "\n",
        "    return (diff.dot(diff) + np.trace(sigma1) +\n",
        "            np.trace(sigma2) - 2 * tr_covmean)\n",
        "\n",
        "\n",
        "def calculate_activation_statistics(files, model, batch_size=50,\n",
        "                                    dims=2048, cuda=False, verbose=False):\n",
        "    \"\"\"Calculation of the statistics used by the FID.\n",
        "    Params:\n",
        "    -- files       : List of image files paths\n",
        "    -- model       : Instance of inception model\n",
        "    -- batch_size  : The images numpy array is split into batches with\n",
        "                     batch size batch_size. A reasonable batch size\n",
        "                     depends on the hardware.\n",
        "    -- dims        : Dimensionality of features returned by Inception\n",
        "    -- cuda        : If set to True, use GPU\n",
        "    -- verbose     : If set to True and parameter out_step is given, the\n",
        "                     number of calculated batches is reported.\n",
        "    Returns:\n",
        "    -- mu    : The mean over samples of the activations of the pool_3 layer of\n",
        "               the inception model.\n",
        "    -- sigma : The covariance matrix of the activations of the pool_3 layer of\n",
        "               the inception model.\n",
        "    \"\"\"\n",
        "    act = get_activations(files, model, batch_size, dims, cuda, verbose)\n",
        "    mu = np.mean(act, axis=0)\n",
        "    sigma = np.cov(act, rowvar=False)\n",
        "    return mu, sigma\n",
        "\n",
        "\n",
        "def _compute_statistics_of_path(path, model, batch_size, dims, cuda):\n",
        "    if path.endswith('.npz'):\n",
        "        f = np.load(path)\n",
        "        m, s = f['mu'][:], f['sigma'][:]\n",
        "        f.close()\n",
        "    else:\n",
        "        path = pathlib.Path(path)\n",
        "        files = list(path.glob('*.jpg')) + list(path.glob('*.png'))\n",
        "        m, s = calculate_activation_statistics(files, model, batch_size,\n",
        "                                               dims, cuda)\n",
        "\n",
        "    return m, s\n",
        "\n",
        "\n",
        "def calculate_fid_given_paths(paths, batch_size, cuda, dims):\n",
        "    \"\"\"Calculates the FID of two paths\"\"\"\n",
        "    for p in paths:\n",
        "        if not os.path.exists(p):\n",
        "            raise RuntimeError('Invalid path: %s' % p)\n",
        "\n",
        "    block_idx = InceptionV3.BLOCK_INDEX_BY_DIM[dims]\n",
        "\n",
        "    model = InceptionV3([block_idx])\n",
        "    if cuda:\n",
        "        model.cuda()\n",
        "\n",
        "    m1, s1 = _compute_statistics_of_path(paths[0], model, batch_size,\n",
        "                                         dims, cuda)\n",
        "    m2, s2 = _compute_statistics_of_path(paths[1], model, batch_size,\n",
        "                                         dims, cuda)\n",
        "    fid_value = calculate_frechet_distance(m1, s1, m2, s2)\n",
        "\n",
        "    return fid_value\n",
        "\n",
        "\n",
        "if __name__ == '__main__':\n",
        "\n",
        "    os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu\n",
        "\n",
        "    fid_value = calculate_fid_given_paths(args.path,\n",
        "                                          args.batch_size,\n",
        "                                          args.gpu != '',\n",
        "                                          args.dims)\n",
        "    print('FID: ', fid_value)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}