sc_dcgan.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.autograd import Variable\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import torchvision.datasets as dsets\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"2\"\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def load_dataset(batchSize, imgSize):\n",
    "    transform=transforms.Compose([\n",
    "                        transforms.Scale(imgSize),\n",
    "#                         transforms.Resize(imgSize),\n",
    "#                         transforms.RandomRotation(degrees=(90, 180, 270)), #ignore; manually resized\n",
    "                        transforms.ToTensor(),\n",
    "                        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n",
    "                        ])\n",
    "    path = './TilesetInput/dataset'\n",
    "    dataset = dsets.ImageFolder(root=path, transform=transform)\n",
    "\n",
    "    dataloader = torch.utils.data.DataLoader(dataset, batch_size=batchSize, shuffle=True, num_workers=0, drop_last=True)\n",
    "    \n",
    "    return dataloader\n",
    "\n",
    "\n",
    "def noise(noiseSize):\n",
    "    def _noise(batchSize):\n",
    "        return torch.randn(batchSize, noiseSize, 1, 1).cuda()\n",
    "    return _noise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Displaying random training images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAB3CAYAAAANSYv6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n08H5/9+WBsqkydfzAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fcc2098b048>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plotBatchSize = 4\n",
    "plotImgSize = 128\n",
    "\n",
    "# functions to show an image\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",
    "\n",
    "# get some random training images\n",
    "dataiter = iter(load_dataset(plotBatchSize, plotImgSize))\n",
    "images, labels = dataiter.next()\n",
    "\n",
    "# show images\n",
    "imshow(torchvision.utils.make_grid(images))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "nz  = 100 # Number of dimensions for latent Z vector\n",
    "ngf = 64  # Number of generator filters\n",
    "ndf = 64  # Number of discriminator filters\n",
    "nc  = 3   # Number of channels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generator_ (\n",
      "  (main): Sequential (\n",
      "    (0): ConvTranspose2d(100, 512, kernel_size=(4, 4), stride=(2, 2))\n",
      "    (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)\n",
      "    (2): ReLU (inplace)\n",
      "    (3): ConvTranspose2d(512, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
      "    (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
      "    (5): ReLU (inplace)\n",
      "    (6): ConvTranspose2d(256, 128, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
      "    (7): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)\n",
      "    (8): ReLU (inplace)\n",
      "    (9): ConvTranspose2d(128, 64, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
      "    (10): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)\n",
      "    (11): ReLU (inplace)\n",
      "    (12): ConvTranspose2d(64, 3, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
      "    (13): Tanh ()\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "class Generator_(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Generator_, self).__init__()\n",
    "        self.main = nn.Sequential(\n",
    "            nn.ConvTranspose2d( in_channels=nz, out_channels=ngf * 8, kernel_size=4, stride=2, padding=0),\n",
    "            nn.BatchNorm2d(num_features=ngf * 8),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.ConvTranspose2d( in_channels=ngf * 8, out_channels=ngf * 4, kernel_size=4, stride=2, padding=1),\n",
    "            nn.BatchNorm2d(num_features=ngf * 4),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.ConvTranspose2d( in_channels=ngf * 4, out_channels=ngf * 2, kernel_size=4, stride=2, padding=1),\n",
    "            nn.BatchNorm2d(num_features=ngf * 2),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.ConvTranspose2d(in_channels=ngf * 2, out_channels=ngf, kernel_size=4, stride=2, padding=1),\n",
    "            nn.BatchNorm2d(num_features=ngf),\n",
    "            nn.ReLU(inplace=True),            \n",
    "            nn.ConvTranspose2d(in_channels=ngf, out_channels=nc, kernel_size=4, stride=2, padding=1),\n",
    "            nn.Tanh()\n",
    "        )\n",
    "    \n",
    "    def forward(self, input):\n",
    "#         print(input)\n",
    "        output = self.main(input)\n",
    "#         print(output)\n",
    "        return output\n",
    "\n",
    "gnet = Generator_()\n",
    "gnet = gnet.cuda()\n",
    "print(gnet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Discriminator_ (\n",
      "  (main): Sequential (\n",
      "    (0): Conv2d(3, 64, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
      "    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)\n",
      "    (2): LeakyReLU (0.2, inplace)\n",
      "    (3): Conv2d(64, 128, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
      "    (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)\n",
      "    (5): LeakyReLU (0.2, inplace)\n",
      "    (6): Conv2d(128, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
      "    (7): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
      "    (8): LeakyReLU (0.2, inplace)\n",
      "    (9): Conv2d(256, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
      "    (10): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)\n",
      "    (11): LeakyReLU (0.2, inplace)\n",
      "    (12): Conv2d(512, 1, kernel_size=(4, 4), stride=(1, 1), bias=False)\n",
      "    (13): Sigmoid ()\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "class Discriminator_(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Discriminator_, self).__init__()\n",
    "        self.main = nn.Sequential(\n",
    "            nn.Conv2d(nc, ndf, kernel_size=4, stride=2, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(ndf),\n",
    "            nn.LeakyReLU(0.2, inplace=True),\n",
    "            nn.Conv2d(ndf, ndf * 2, kernel_size=4, stride=2, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(ndf * 2),\n",
    "            nn.LeakyReLU(0.2, inplace=True),\n",
    "            nn.Conv2d(ndf * 2, ndf * 4, kernel_size=4, stride=2, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(ndf * 4),\n",
    "            nn.LeakyReLU(0.2, inplace=True),\n",
    "            nn.Conv2d(ndf * 4, ndf * 8, kernel_size=4, stride=2, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(ndf * 8),\n",
    "            nn.LeakyReLU(0.2, inplace=True),\n",
    "            nn.Conv2d(ndf * 8, 1, kernel_size=4, stride=1, bias=False), \n",
    "            nn.Sigmoid()\n",
    "        )\n",
    "    \n",
    "    def forward(self, input):\n",
    "        output = self.main(input)        \n",
    "        output = output.view(-1,1).squeeze(1)\n",
    "        return output\n",
    "\n",
    "dnet = Discriminator_()\n",
    "dnet = dnet.cuda()\n",
    "print(dnet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "criterion = nn.BCELoss().cuda()\n",
    "optimizer_g = optim.Adam(gnet.parameters(), lr=0.0005, betas=(0.5, 0.999))\n",
    "optimizer_d = optim.Adam(dnet.parameters(), lr=0.0005, betas=(0.5, 0.999))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Hidden layer calculation \n",
    "batch_size = 64\n",
    "\n",
    "import math as ma\n",
    "ma.floor(ma.log(batch_size // 4, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weights loaded successfully.\n"
     ]
    }
   ],
   "source": [
    "# Optional: To load saved weights\n",
    "folder = 'sc_dcgan-1_out'\n",
    "\n",
    "dnet.load_state_dict(torch.load('./{}/dnet_dict.pth'.format(folder)))\n",
    "gnet.load_state_dict(torch.load('./{}/gnet_dict.pth'.format(folder)))\n",
    "print(\"Weights loaded successfully.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Started Training\n",
      "Iteration 0\n"
     ]
    }
   ],
   "source": [
    "input_size = 100\n",
    "batch_size = 64\n",
    "img_size = 64\n",
    "iterations = 10000\n",
    "noise_z = Variable(torch.rand(batch_size, input_size, 1, 1).cuda())\n",
    "folder = 'sc_dcgan-3_out'\n",
    "dataloader = load_dataset(batch_size, img_size)\n",
    "\n",
    "# Generating a log file for the status printed below\n",
    "import logging\n",
    "logging.basicConfig(filename='./{}/sc_dcgan-3.log'.format(folder), level=logging.INFO)\n",
    "print('Started Training')\n",
    "logging.info('Started Training')\n",
    "\n",
    "\n",
    "# Training Loop\n",
    "for epoch in range(10001):\n",
    "    for i, data in enumerate(dataloader, 0):\n",
    "\n",
    "        # Discriminator Training\n",
    "        #\n",
    "        dnet.zero_grad()\n",
    "        # real training\n",
    "        inputs_d, _ = data\n",
    "        inputs_d = Variable(inputs_d.cuda())\n",
    "        # print(inputs_d.data.shape)\n",
    "        \n",
    "        outputs_d = dnet(inputs_d)\n",
    "        # print(outputs_d.data.shape)\n",
    "        loss_d_real = criterion(outputs_d, Variable(torch.ones(batch_size).cuda()))\n",
    "        loss_d_real.backward()\n",
    "\n",
    "        # fake training\n",
    "        inputs_g = noise_z\n",
    "        # print(inputs_g.data.shape)\n",
    "        outputs_g = gnet(inputs_g)\n",
    "        # detach() is used to detach the variable from its graph\n",
    "        outputs_dg = dnet(outputs_g.detach())\n",
    "\n",
    "        loss_d_fake = criterion(outputs_dg, Variable(torch.zeros(batch_size).cuda()))\n",
    "        loss_d_fake.backward()\n",
    "        loss_d = loss_d_real + loss_d_fake\n",
    "        optimizer_d.step()\n",
    "\n",
    "        # Generator Training\n",
    "        #\n",
    "        gnet.zero_grad()\n",
    "        outputs_dg = dnet(outputs_g)\n",
    "        loss_g = criterion(outputs_dg, Variable(torch.ones(batch_size).cuda()))\n",
    "        loss_g.backward()\n",
    "        optimizer_g.step()\n",
    "        \n",
    "# Print statistics            \n",
    "    if epoch % (iterations/100) == 0:\n",
    "        print(\"Iteration {}\".format(epoch))\n",
    "        logging.info(\"Iteration {}\".format(epoch))\n",
    "        torchvision.utils.save_image(inputs_d.data,\n",
    "                './{}/real_samples_epoch_{:05d}.png'.format(folder, epoch),\n",
    "                normalize=True)\n",
    "        torchvision.utils.save_image(outputs_g.data,\n",
    "                './{}/fake_samples_epoch_{:05d}.png'.format(folder, epoch),\n",
    "                normalize=True)\n",
    "\n",
    "# Save checkpoints for weights\n",
    "    if epoch % (iterations/10) == 0:\n",
    "        torch.save(dnet.state_dict(), './{}/dnet_dict_ep{:05d}.pth'.format(folder, epoch))\n",
    "        torch.save(gnet.state_dict(), './{}/gnet_dict_ep{:05d}.pth'.format(folder, epoch))\n",
    "        \n",
    "print('Finished Training')\n",
    "logging.info('Finished Training')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "torch.save(dnet.state_dict(), './{}/dnet_dict.pth'.format(folder))\n",
    "torch.save(gnet.state_dict(), './{}/gnet_dict.pth'.format(folder))\n",
    "print(\"Weights saved successfully.\")"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "random_noise = torch.rand(batch_size,100, 1, 1).cuda()\n",
    "fixed_noise = Variable(random_noise.cuda())\n",
    "outputs_img = gnet(Variable(random_noise.cuda()))\n",
    "outputs_img = gnet(fixed_noise)\n",
    "outputs_dg = dnet(outputs_img)\n",
    "\n",
    "plt.imshow(np.rollaxis(outputs_img.data.cpu().numpy(), 1, 4)[0])\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}