generate.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Architectural Style Generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "__author__ = \"Caroline Ho and Cole Thomson\"\n",
    "__version__ = \"CS230, Stanford, Autumn 2018 term\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contents\n",
    "1. [Overview](#Overview)\n",
    "2. [Set-Up](#Set-Up)\n",
    "3. [Data](#Data)\n",
    "4. [Model](#Model)\n",
    "5. [Run Model](#Run-Model)\n",
    "6. [Resources](#Resources)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overview\n",
    "\n",
    "In this notebook, we use conditional GANs to generate images of buildings with given architectural styles."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set-Up\n",
    "\n",
    "Run the following cells to import necessary libraries/functions and set global variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.autograd import Variable\n",
    "import torchvision.datasets as dsets\n",
    "import torchvision.transforms as transforms\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import imageio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parameters\n",
    "image_size = 64\n",
    "label_dim = 25\n",
    "G_input_dim = 625\n",
    "G_output_dim = 3\n",
    "D_input_dim = 3\n",
    "D_output_dim = 1\n",
    "num_filters = [1024, 512, 256, 128]\n",
    "\n",
    "learning_rate = 0.0002\n",
    "betas = (0.5, 0.999)\n",
    "batch_size = 4\n",
    "num_epochs = 20\n",
    "save_dir = 'generated_images/'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data\n",
    "\n",
    "Download [Xu et al.'s architecture dataset](https://drive.google.com/file/d/0Bwo0SFiZwl3JVGRlWGZUaW5va00/edit) and place it in the current directory.\n",
    "\n",
    "This dataset contains 4,843 images of buildings from 25 architecture style classes ranging from Achaemenid to Tudor Revival. Image dimensions/aspect ratios are not consistent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "transform = transforms.Compose([\n",
    "    transforms.Resize(image_size),\n",
    "    transforms.CenterCrop(image_size),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize(mean=(0.5, 0.5, 0.5),std=(0.5, 0.5, 0.5))\n",
    "])\n",
    "\n",
    "data = dsets.ImageFolder('arcDataset', transform=transform)\n",
    "\n",
    "data_loader = torch.utils.data.DataLoader(dataset=data,\n",
    "                                          batch_size=batch_size,\n",
    "                                          shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Helper Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_var(x):\n",
    "    if torch.cuda.is_available():\n",
    "        x = x.cuda()\n",
    "    return Variable(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# De-normalization\n",
    "def denorm(x):\n",
    "    out = (x + 1) / 2\n",
    "    return out.clamp(0, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generator model\n",
    "class Generator(torch.nn.Module):\n",
    "    def __init__(self, input_dim, label_dim, num_filters, output_dim):\n",
    "        super(Generator, self).__init__()\n",
    "\n",
    "        # Hidden layers\n",
    "        self.hidden_layer1 = torch.nn.Sequential()\n",
    "        self.hidden_layer2 = torch.nn.Sequential()\n",
    "        self.hidden_layer = torch.nn.Sequential()\n",
    "        for i in range(len(num_filters)):\n",
    "            # Deconvolutional layer\n",
    "            if i == 0:\n",
    "                # For input\n",
    "                input_deconv = torch.nn.ConvTranspose2d(input_dim, int(num_filters[i]/2), kernel_size=4, stride=1, padding=0)\n",
    "                self.hidden_layer1.add_module('input_deconv', input_deconv)\n",
    "\n",
    "                # Initializer\n",
    "                torch.nn.init.normal_(input_deconv.weight, mean=0.0, std=0.02)\n",
    "                torch.nn.init.constant_(input_deconv.bias, 0.0)\n",
    "\n",
    "                # Batch normalization\n",
    "                self.hidden_layer1.add_module('input_bn', torch.nn.BatchNorm2d(int(num_filters[i]/2)))\n",
    "\n",
    "                # Activation\n",
    "                self.hidden_layer1.add_module('input_act', torch.nn.ReLU())\n",
    "\n",
    "                # For label\n",
    "                label_deconv = torch.nn.ConvTranspose2d(label_dim, int(num_filters[i]/2), kernel_size=4, stride=1, padding=0)\n",
    "                self.hidden_layer2.add_module('label_deconv', label_deconv)\n",
    "\n",
    "                # Initializer\n",
    "                torch.nn.init.normal_(label_deconv.weight, mean=0.0, std=0.02)\n",
    "                torch.nn.init.constant_(label_deconv.bias, 0.0)\n",
    "\n",
    "                # Batch normalization\n",
    "                self.hidden_layer2.add_module('label_bn', torch.nn.BatchNorm2d(int(num_filters[i]/2)))\n",
    "\n",
    "                # Activation\n",
    "                self.hidden_layer2.add_module('label_act', torch.nn.ReLU())\n",
    "            else:\n",
    "                deconv = torch.nn.ConvTranspose2d(num_filters[i-1], num_filters[i], kernel_size=4, stride=2, padding=1)\n",
    "\n",
    "                deconv_name = 'deconv' + str(i + 1)\n",
    "                self.hidden_layer.add_module(deconv_name, deconv)\n",
    "\n",
    "                # Initializer\n",
    "                torch.nn.init.normal_(deconv.weight, mean=0.0, std=0.02)\n",
    "                torch.nn.init.constant_(deconv.bias, 0.0)\n",
    "\n",
    "                # Batch normalization\n",
    "                bn_name = 'bn' + str(i + 1)\n",
    "                self.hidden_layer.add_module(bn_name, torch.nn.BatchNorm2d(num_filters[i]))\n",
    "\n",
    "                # Activation\n",
    "                act_name = 'act' + str(i + 1)\n",
    "                self.hidden_layer.add_module(act_name, torch.nn.ReLU())\n",
    "\n",
    "        # Output layer\n",
    "        self.output_layer = torch.nn.Sequential()\n",
    "        # Deconvolutional layer\n",
    "        out = torch.nn.ConvTranspose2d(num_filters[i], output_dim, kernel_size=4, stride=2, padding=1)\n",
    "        self.output_layer.add_module('out', out)\n",
    "        # Initializer\n",
    "        torch.nn.init.normal_(out.weight, mean=0.0, std=0.02)\n",
    "        torch.nn.init.constant_(out.bias, 0.0)\n",
    "        # Activation\n",
    "        self.output_layer.add_module('act', torch.nn.Tanh())\n",
    "\n",
    "    def forward(self, z, c):\n",
    "        h1 = self.hidden_layer1(z)\n",
    "        h2 = self.hidden_layer2(c)\n",
    "        x = torch.cat([h1, h2], 1)\n",
    "        h = self.hidden_layer(x)\n",
    "        out = self.output_layer(h)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Discriminator model\n",
    "class Discriminator(torch.nn.Module):\n",
    "    def __init__(self, input_dim, label_dim, num_filters, output_dim):\n",
    "        super(Discriminator, self).__init__()\n",
    "\n",
    "        self.hidden_layer1 = torch.nn.Sequential()\n",
    "        self.hidden_layer2 = torch.nn.Sequential()\n",
    "        self.hidden_layer = torch.nn.Sequential()\n",
    "        for i in range(len(num_filters)):\n",
    "            # Convolutional layer\n",
    "            if i == 0:\n",
    "                # For input\n",
    "                input_conv = torch.nn.Conv2d(input_dim, int(num_filters[i]/2), kernel_size=4, stride=2, padding=1)\n",
    "                self.hidden_layer1.add_module('input_conv', input_conv)\n",
    "\n",
    "                # Initializer\n",
    "                torch.nn.init.normal_(input_conv.weight, mean=0.0, std=0.02)\n",
    "                torch.nn.init.constant_(input_conv.bias, 0.0)\n",
    "\n",
    "                # Activation\n",
    "                self.hidden_layer1.add_module('input_act', torch.nn.LeakyReLU(0.2))\n",
    "\n",
    "                # For label\n",
    "                label_conv = torch.nn.Conv2d(label_dim, int(num_filters[i]/2), kernel_size=4, stride=2, padding=1)\n",
    "                self.hidden_layer2.add_module('label_conv', label_conv)\n",
    "\n",
    "                # Initializer\n",
    "                torch.nn.init.normal_(label_conv.weight, mean=0.0, std=0.02)\n",
    "                torch.nn.init.constant_(label_conv.bias, 0.0)\n",
    "\n",
    "                # Activation\n",
    "                self.hidden_layer2.add_module('label_act', torch.nn.LeakyReLU(0.2))\n",
    "            else:\n",
    "                conv = torch.nn.Conv2d(num_filters[i-1], num_filters[i], kernel_size=4, stride=2, padding=1)\n",
    "\n",
    "                conv_name = 'conv' + str(i + 1)\n",
    "                self.hidden_layer.add_module(conv_name, conv)\n",
    "\n",
    "                # Initializer\n",
    "                torch.nn.init.normal_(conv.weight, mean=0.0, std=0.02)\n",
    "                torch.nn.init.constant_(conv.bias, 0.0)\n",
    "\n",
    "                # Batch normalization\n",
    "                bn_name = 'bn' + str(i + 1)\n",
    "                self.hidden_layer.add_module(bn_name, torch.nn.BatchNorm2d(num_filters[i]))\n",
    "\n",
    "                # Activation\n",
    "                act_name = 'act' + str(i + 1)\n",
    "                self.hidden_layer.add_module(act_name, torch.nn.LeakyReLU(0.2))\n",
    "\n",
    "        # Output layer\n",
    "        self.output_layer = torch.nn.Sequential()\n",
    "        # Convolutional layer\n",
    "        out = torch.nn.Conv2d(num_filters[i], output_dim, kernel_size=4, stride=1, padding=0)\n",
    "        self.output_layer.add_module('out', out)\n",
    "        # Initializer\n",
    "        torch.nn.init.normal_(out.weight, mean=0.0, std=0.02)\n",
    "        torch.nn.init.constant_(out.bias, 0.0)\n",
    "        # Activation\n",
    "        self.output_layer.add_module('act', torch.nn.Sigmoid())\n",
    "\n",
    "    def forward(self, z, c):\n",
    "        h1 = self.hidden_layer1(z)\n",
    "        h2 = self.hidden_layer2(c)\n",
    "        x = torch.cat([h1, h2], 1)\n",
    "        h = self.hidden_layer(x)\n",
    "        out = self.output_layer(h)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot losses\n",
    "def plot_loss(d_losses, g_losses, num_epoch, save=False, save_dir='generated_images/', show=False):\n",
    "    fig, ax = plt.subplots()\n",
    "    ax.set_xlim(0, num_epochs)\n",
    "    ax.set_ylim(0, max(np.max(g_losses), np.max(d_losses))*1.1)\n",
    "    plt.xlabel('Epoch {0}'.format(num_epoch + 1))\n",
    "    plt.ylabel('Loss values')\n",
    "    plt.plot(d_losses, label='Discriminator')\n",
    "    plt.plot(g_losses, label='Generator')\n",
    "    plt.legend()\n",
    "\n",
    "    # save figure\n",
    "    if save:\n",
    "        if not os.path.exists(save_dir):\n",
    "            os.mkdir(save_dir)\n",
    "        save_fn = save_dir + 'cDCGAN_losses_epoch_{:d}'.format(num_epoch + 1) + '.png'\n",
    "        plt.savefig(save_fn)\n",
    "\n",
    "    if show:\n",
    "        plt.show()\n",
    "    else:\n",
    "        plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_result(generator, noise, label, num_epoch, save=False, save_dir='generated_images/', show=False, fig_size=(100, 100)):\n",
    "    generator.eval()\n",
    "\n",
    "    noise = Variable(noise.cuda())\n",
    "    label = Variable(label.cuda())\n",
    "    gen_image = generator(noise, label)\n",
    "    gen_image = denorm(gen_image)\n",
    "\n",
    "    generator.train()\n",
    "\n",
    "    n_rows = np.sqrt(noise.size()[0]).astype(np.int32)\n",
    "    n_cols = np.sqrt(noise.size()[0]).astype(np.int32)\n",
    "    fig, axes = plt.subplots(n_rows, n_cols, figsize=fig_size)\n",
    "    for ax, img in zip(axes.flatten(), gen_image):\n",
    "        ax.axis('off')\n",
    "        ax.set_adjustable('box-forced')\n",
    "        # Scale to 0-255\n",
    "        img = (((img - img.min()) * 255) / (img.max() - img.min())).cpu().data.numpy().transpose(1, 2, 0).astype(\n",
    "            np.uint8)\n",
    "        ax.imshow(img, cmap=None, aspect='equal')\n",
    "    plt.subplots_adjust(wspace=0, hspace=0)\n",
    "    title = 'Epoch {0}'.format(num_epoch + 1)\n",
    "    fig.text(0.5, 0.04, title, ha='center')\n",
    "\n",
    "    # save figure\n",
    "    if save:\n",
    "        if not os.path.exists(save_dir):\n",
    "            os.mkdir(save_dir)\n",
    "        save_fn = save_dir + 'cDCGAN_epoch_{:d}'.format(num_epoch+1) + '.png'\n",
    "        plt.savefig(save_fn)\n",
    "\n",
    "    if show:\n",
    "        plt.show()\n",
    "    else:\n",
    "        plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run Model\n",
    "\n",
    "You can view generated images and loss plots in the 'generated_images' folder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Discriminator(\n",
       "  (hidden_layer1): Sequential(\n",
       "    (input_conv): Conv2d(3, 64, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
       "    (input_act): LeakyReLU(negative_slope=0.2)\n",
       "  )\n",
       "  (hidden_layer2): Sequential(\n",
       "    (label_conv): Conv2d(25, 64, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
       "    (label_act): LeakyReLU(negative_slope=0.2)\n",
       "  )\n",
       "  (hidden_layer): Sequential(\n",
       "    (conv2): Conv2d(128, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
       "    (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (act2): LeakyReLU(negative_slope=0.2)\n",
       "    (conv3): Conv2d(256, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
       "    (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (act3): LeakyReLU(negative_slope=0.2)\n",
       "    (conv4): Conv2d(512, 1024, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
       "    (bn4): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (act4): LeakyReLU(negative_slope=0.2)\n",
       "  )\n",
       "  (output_layer): Sequential(\n",
       "    (out): Conv2d(1024, 1, kernel_size=(4, 4), stride=(1, 1))\n",
       "    (act): Sigmoid()\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G = Generator(G_input_dim, label_dim, num_filters, G_output_dim)\n",
    "D = Discriminator(D_input_dim, label_dim, num_filters[::-1], D_output_dim)\n",
    "G.cuda()\n",
    "D.cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loss function\n",
    "criterion = torch.nn.BCELoss()\n",
    "\n",
    "# Optimizers\n",
    "G_optimizer = torch.optim.Adam(G.parameters(), lr=learning_rate, betas=betas)\n",
    "D_optimizer = torch.optim.Adam(D.parameters(), lr=learning_rate, betas=betas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Label preprocess\n",
    "onehot = torch.zeros(label_dim, label_dim)\n",
    "onehot = onehot.scatter_(1, torch.LongTensor(list(range(label_dim))).view(label_dim, 1), 1).view(label_dim, label_dim, 1, 1)\n",
    "fill = torch.zeros([label_dim, label_dim, image_size, image_size])\n",
    "for i in range(label_dim):\n",
    "    fill[i, i, :, :] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fixed noise & label for test\n",
    "temp_noise = torch.randn(label_dim, G_input_dim)\n",
    "fixed_noise = temp_noise\n",
    "fixed_c = torch.zeros(label_dim, 1)\n",
    "for i in range(label_dim - 1):\n",
    "    fixed_noise = torch.cat([fixed_noise, temp_noise], 0)\n",
    "    temp = torch.ones(label_dim, 1) + i\n",
    "    fixed_c = torch.cat([fixed_c, temp], 0)\n",
    "\n",
    "fixed_noise = fixed_noise.view(-1, G_input_dim, 1, 1)\n",
    "fixed_label = torch.zeros(G_input_dim, label_dim)\n",
    "fixed_label.scatter_(1, fixed_c.type(torch.LongTensor), 1)\n",
    "fixed_label = fixed_label.view(-1, label_dim, 1, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Training GAN\n",
    "D_avg_losses = []\n",
    "G_avg_losses = []\n",
    "\n",
    "step = 0\n",
    "for epoch in range(num_epochs):\n",
    "    D_losses = []\n",
    "    G_losses = []\n",
    "\n",
    "    if epoch == 5 or epoch == 10:\n",
    "        G_optimizer.param_groups[0]['lr'] /= label_dim\n",
    "        D_optimizer.param_groups[0]['lr'] /= label_dim\n",
    "\n",
    "    # minibatch training\n",
    "    for i, (images, labels) in enumerate(data_loader):\n",
    "\n",
    "        # image data\n",
    "        mini_batch = images.size()[0]\n",
    "        x_ = Variable(images.cuda())\n",
    "\n",
    "        # labels\n",
    "        y_real_ = Variable(torch.ones(mini_batch).cuda())\n",
    "        y_fake_ = Variable(torch.zeros(mini_batch).cuda())\n",
    "        c_fill_ = Variable(fill[labels].cuda())\n",
    "\n",
    "        # Train discriminator with real data\n",
    "        D_real_decision = D(x_, c_fill_).squeeze()\n",
    "        D_real_loss = criterion(D_real_decision, y_real_)\n",
    "\n",
    "        # Train discriminator with fake data\n",
    "        z_ = torch.randn(mini_batch, G_input_dim).view(-1, G_input_dim, 1, 1)\n",
    "        z_ = Variable(z_.cuda())\n",
    "\n",
    "        c_ = (torch.rand(mini_batch, 1) * label_dim).type(torch.LongTensor).squeeze()\n",
    "        c_onehot_ = Variable(onehot[c_].cuda())\n",
    "        gen_image = G(z_, c_onehot_)\n",
    "\n",
    "        c_fill_ = Variable(fill[c_].cuda())\n",
    "        D_fake_decision = D(gen_image, c_fill_).squeeze()\n",
    "        D_fake_loss = criterion(D_fake_decision, y_fake_)\n",
    "\n",
    "        # Back propagation\n",
    "        D_loss = D_real_loss + D_fake_loss\n",
    "        D.zero_grad()\n",
    "        D_loss.backward()\n",
    "        D_optimizer.step()\n",
    "\n",
    "        # Train generator\n",
    "        z_ = torch.randn(mini_batch, G_input_dim).view(-1, G_input_dim, 1, 1)\n",
    "        z_ = Variable(z_.cuda())\n",
    "\n",
    "        c_ = (torch.rand(mini_batch, 1) * label_dim).type(torch.LongTensor).squeeze()\n",
    "        c_onehot_ = Variable(onehot[c_].cuda())\n",
    "        gen_image = G(z_, c_onehot_)\n",
    "\n",
    "        c_fill_ = Variable(fill[c_].cuda())\n",
    "        D_fake_decision = D(gen_image, c_fill_).squeeze()\n",
    "        G_loss = criterion(D_fake_decision, y_real_)\n",
    "\n",
    "        # Back propagation\n",
    "        G.zero_grad()\n",
    "        G_loss.backward()\n",
    "        G_optimizer.step()\n",
    "\n",
    "        # Loss values\n",
    "        D_losses.append(torch.Tensor.item(D_loss.data))\n",
    "        G_losses.append(torch.Tensor.item(G_loss.data))\n",
    "\n",
    "        print('Epoch [%d/%d], Step [%d/%d], D_loss: %.4f, G_loss: %.4f'\n",
    "              % (epoch+1, num_epochs, i+1, len(data_loader), torch.Tensor.item(D_loss.data), torch.Tensor.item(G_loss.data)))\n",
    "        step += 1\n",
    "\n",
    "    D_avg_loss = torch.mean(torch.FloatTensor(D_losses))\n",
    "    G_avg_loss = torch.mean(torch.FloatTensor(G_losses))\n",
    "\n",
    "    # Avg loss values for plot\n",
    "    D_avg_losses.append(D_avg_loss)\n",
    "    G_avg_losses.append(G_avg_loss)\n",
    "\n",
    "    plot_loss(D_avg_losses, G_avg_losses, epoch, save=True, save_dir=save_dir)\n",
    "\n",
    "    # Show result for fixed noise\n",
    "    plot_result(G, fixed_noise, fixed_label, epoch, save=True, save_dir=save_dir)\n",
    "\n",
    "# Make gif\n",
    "loss_plots = []\n",
    "gen_image_plots = []\n",
    "for epoch in range(num_epochs):\n",
    "    # Plot for generating gif\n",
    "    save_fn1 = save_dir + 'cDCGAN_losses_epoch_{:d}'.format(epoch + 1) + '.png'\n",
    "    loss_plots.append(imageio.imread(save_fn1))\n",
    "\n",
    "    save_fn2 = save_dir + 'cDCGAN_epoch_{:d}'.format(epoch + 1) + '.png'\n",
    "    gen_image_plots.append(imageio.imread(save_fn2))\n",
    "\n",
    "imageio.mimsave(save_dir + 'cDCGAN_losses_epochs_{:d}'.format(num_epochs) + '.gif', loss_plots, fps=5)\n",
    "imageio.mimsave(save_dir + 'cDCGAN_epochs_{:d}'.format(num_epochs) + '.gif', gen_image_plots, fps=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resources\n",
    "\n",
    "- Much of the code in this notebook is modified from togheppi's implementation of [cDCGAN](https://github.com/togheppi/cDCGAN)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}