dcgan-pytorch-mnist.ipynb

README.MD

MNIST DCGAN using PyTorch

Based on DCGAN from this paper: https://arxiv.org/pdf/1511.06434.pdf

dcgan-pytorch-mnist.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "dcgan-pytorch-mnist.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyOfQq6gqDTOmkNaMFhhkc7Z",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/gist/SharanSMenon/887afed7d8538d35d1add819d129114a/dcgan-pytorch-mnist.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XJCXGi_VzFD7"
      },
      "source": [
        "import torch\n",
        "import torchvision\n",
        "from torchvision import datasets, transforms\n",
        "import matplotlib.pyplot as plt\n",
        "from tqdm.notebook import tqdm\n",
        "from torchsummary import summary"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nSeZoDQuzLjn",
        "outputId": "157b8673-2f66-425b-b19c-8ffaa22a84bc"
      },
      "source": [
        "transform = transforms.Compose([transforms.ToTensor(),\n",
        "                                transforms.Normalize((0.5,), (0.5,))])\n",
        "# Download and load the training data\n",
        "trainset = datasets.MNIST('MNIST_data/', download=True, train=True, transform=transform)\n",
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True)\n",
        "\n",
        "testset = datasets.MNIST('MNIST_data/', download=True, train=False, transform=transform)\n",
        "testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=True)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torchvision/datasets/mnist.py:498: UserWarning: The given NumPy array is not writeable, and PyTorch does not support non-writeable tensors. This means you can write to the underlying (supposedly non-writeable) NumPy array using the tensor. You may want to copy the array to protect its data or make it writeable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at  /pytorch/torch/csrc/utils/tensor_numpy.cpp:180.)\n",
            "  return torch.from_numpy(parsed.astype(m[2], copy=False)).view(*s)\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nd5Icq4YzNSR"
      },
      "source": [
        "from torch import nn, optim\n",
        "from torch.nn import functional as F"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sVYPkd2dNPSN"
      },
      "source": [
        "def weights_init(m):\n",
        "    classname = m.__class__.__name__\n",
        "    if classname.find('Conv') != -1:\n",
        "        nn.init.normal_(m.weight.data, 0.0, 0.02)\n",
        "    elif classname.find('BatchNorm') != -1:\n",
        "        nn.init.normal_(m.weight.data, 1.0, 0.02)\n",
        "        nn.init.constant_(m.bias.data, 0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YA45990-zRso"
      },
      "source": [
        "def conv(in_c, out_c, ks=4, stride=2, padding=1, bn = True, out_layer=False):\n",
        "    layers = [nn.Conv2d(in_c, out_c, kernel_size=ks, stride=stride, padding=padding, bias=False)]\n",
        "    if bn: layers.append(nn.BatchNorm2d(out_c))\n",
        "    layers.append(nn.Sigmoid() if out_layer else nn.LeakyReLU(0.2, inplace=True))\n",
        "    return nn.Sequential(*layers)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "IkkreOUc1A8h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2d65oG3KzThW"
      },
      "source": [
        "D = nn.Sequential(\n",
        "    conv(1, 32, bn=False),\n",
        "    conv(32, 64),\n",
        "    conv(64, 128, ks=3),\n",
        "    conv(128, 1, out_layer=True, bn=False, padding=0),\n",
        ")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tRSix8t4zvUo"
      },
      "source": [
        "class Generator(nn.Module):\n",
        "  def __init__(self):\n",
        "    super(Generator, self).__init__()\n",
        "    self.layers = nn.Sequential(*[\n",
        "                                 self.conv_block(100, 128, padding=0),\n",
        "                                 self.conv_block(128, 64, stride=2, ks=3),\n",
        "                                 self.conv_block(64, 32, stride=2),\n",
        "                                 self.conv_block(32, 1, stride=2, bn=False, out_layer=True)\n",
        "    ])\n",
        "  \n",
        "  @staticmethod\n",
        "  def conv_block(in_c, out_c, out_layer = False, ks=4, stride=1, padding=1, bias=False, bn=True):\n",
        "    l = [nn.ConvTranspose2d(in_c, out_c, ks, stride=stride, padding=padding, bias=bias)]\n",
        "    if bn: l.append(nn.BatchNorm2d(out_c))\n",
        "    if out_layer: l.append(nn.Tanh())\n",
        "    else: l.append(nn.ReLU(True))\n",
        "    return nn.Sequential(*l)\n",
        "\n",
        "  \n",
        "  def forward(self, x):\n",
        "    return self.layers(x)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2BSyhLY56XN3"
      },
      "source": [
        "G = Generator()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ksUIb1mvJRV1",
        "outputId": "9c7adc10-eb57-4a21-b600-59bea1498a89"
      },
      "source": [
        "D"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Sequential(\n",
              "  (0): Sequential(\n",
              "    (0): Conv2d(1, 32, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "    (1): LeakyReLU(negative_slope=0.2, inplace=True)\n",
              "  )\n",
              "  (1): Sequential(\n",
              "    (0): Conv2d(32, 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, track_running_stats=True)\n",
              "    (2): LeakyReLU(negative_slope=0.2, inplace=True)\n",
              "  )\n",
              "  (2): Sequential(\n",
              "    (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "    (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    (2): LeakyReLU(negative_slope=0.2, inplace=True)\n",
              "  )\n",
              "  (3): Sequential(\n",
              "    (0): Conv2d(128, 1, kernel_size=(4, 4), stride=(2, 2), bias=False)\n",
              "    (1): Sigmoid()\n",
              "  )\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5x1NQC-OJSg0",
        "outputId": "f91535ea-ff64-42bc-db50-f178c2ba0fc8"
      },
      "source": [
        "G"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Generator(\n",
              "  (layers): Sequential(\n",
              "    (0): Sequential(\n",
              "      (0): ConvTranspose2d(100, 128, kernel_size=(4, 4), stride=(1, 1), bias=False)\n",
              "      (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (2): ReLU(inplace=True)\n",
              "    )\n",
              "    (1): Sequential(\n",
              "      (0): ConvTranspose2d(128, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "      (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (2): ReLU(inplace=True)\n",
              "    )\n",
              "    (2): Sequential(\n",
              "      (0): ConvTranspose2d(64, 32, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "      (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (2): ReLU(inplace=True)\n",
              "    )\n",
              "    (3): Sequential(\n",
              "      (0): ConvTranspose2d(32, 1, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "      (1): Tanh()\n",
              "    )\n",
              "  )\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "muQFrPGsfoAI",
        "outputId": "13e9b2d2-b45c-4164-9de6-bf1c7ad42bd5"
      },
      "source": [
        "rand_noise = torch.rand((64, 100, 1, 1))\n",
        "G.apply(weights_init)\n",
        "D.apply(weights_init)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Sequential(\n",
              "  (0): Sequential(\n",
              "    (0): Conv2d(1, 32, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "    (1): LeakyReLU(negative_slope=0.2, inplace=True)\n",
              "  )\n",
              "  (1): Sequential(\n",
              "    (0): Conv2d(32, 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, track_running_stats=True)\n",
              "    (2): LeakyReLU(negative_slope=0.2, inplace=True)\n",
              "  )\n",
              "  (2): Sequential(\n",
              "    (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "    (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    (2): LeakyReLU(negative_slope=0.2, inplace=True)\n",
              "  )\n",
              "  (3): Sequential(\n",
              "    (0): Conv2d(128, 1, kernel_size=(4, 4), stride=(2, 2), bias=False)\n",
              "    (1): Sigmoid()\n",
              "  )\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eSFLWRSEG48T"
      },
      "source": [
        "criterion = nn.BCELoss()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O_DHp4iD6kOB"
      },
      "source": [
        "optim_G = torch.optim.Adam(G.parameters(), lr=0.0002, betas=(0.5, 0.999))\n",
        "optim_D = torch.optim.Adam(D.parameters(), lr=0.0002, betas=(0.5, 0.999))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AT9MXSJlG-a8"
      },
      "source": [
        "D = D.cuda()\n",
        "G = G.cuda()\n",
        "criterion = criterion.cuda()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CWMUStKTHCkx",
        "outputId": "4915513a-9e94-4634-81be-923570fcf665"
      },
      "source": [
        "for epoch in range(1, EPOCHS + 1):\n",
        "    loss_d = 0.0\n",
        "    loss_g = 0.0\n",
        "    for i, (images, labels) in enumerate(trainloader):\n",
        "        images = images.cuda() # if cuda\n",
        "        fake_labels = torch.full((images.size(0),), FAKE_LABEL).cuda()\n",
        "        real_labels = torch.full((images.size(0),), REAL_LABEL).cuda()\n",
        "\n",
        "        ### Training Discriminator ###\n",
        "        ### Maximize log(D(x)) + log(1 - D(G(z))) ###\n",
        "        D.zero_grad()\n",
        "\n",
        "        d_real = D(images).view(-1)\n",
        "        d_loss_real = criterion(d_real, real_labels)\n",
        "        d_loss_real.backward()\n",
        "\n",
        "        noise = torch.randn(images.size(0), 100, 1, 1).cuda()\n",
        "        fake_images = G(noise)\n",
        "\n",
        "        d_fake = D(fake_images.detach()).view(-1)\n",
        "        d_loss_fake = criterion(d_fake, fake_labels)\n",
        "        d_loss_fake.backward()\n",
        "\n",
        "        d_loss = d_loss_real + d_loss_fake\n",
        "        optim_D.step()\n",
        "\n",
        "        ### Training Generator ###\n",
        "        ### Maximize log(D(G(z))) ###\n",
        "        G.zero_grad()\n",
        "        d_fake = D(fake_images).view(-1)\n",
        "        g_loss = criterion(d_fake, real_labels)\n",
        "        g_loss.backward()\n",
        "        optim_G.step()\n",
        "\n",
        "        if i % 100 == 0:\n",
        "          print('Epoch [{}/{}], Batch [{}], Loss_D: {:.4f}, Loss_G: {:.4f}'.format(epoch, EPOCHS, i, d_loss, g_loss))\n",
        "    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch [1/10], Batch [0], Loss_D: 1.3001, Loss_G: 0.9725\n",
            "Epoch [1/10], Batch [100], Loss_D: 0.1149, Loss_G: 3.2734\n",
            "Epoch [1/10], Batch [200], Loss_D: 0.2295, Loss_G: 2.8770\n",
            "Epoch [1/10], Batch [300], Loss_D: 0.1363, Loss_G: 3.2608\n",
            "Epoch [1/10], Batch [400], Loss_D: 0.3577, Loss_G: 2.9370\n",
            "Epoch [2/10], Batch [0], Loss_D: 0.1583, Loss_G: 3.3581\n",
            "Epoch [2/10], Batch [100], Loss_D: 0.1059, Loss_G: 3.2018\n",
            "Epoch [2/10], Batch [200], Loss_D: 0.2606, Loss_G: 1.9497\n",
            "Epoch [2/10], Batch [300], Loss_D: 0.8414, Loss_G: 6.3635\n",
            "Epoch [2/10], Batch [400], Loss_D: 4.7866, Loss_G: 2.7104\n",
            "Epoch [3/10], Batch [0], Loss_D: 0.2102, Loss_G: 3.2500\n",
            "Epoch [3/10], Batch [100], Loss_D: 0.2284, Loss_G: 2.2332\n",
            "Epoch [3/10], Batch [200], Loss_D: 0.3167, Loss_G: 3.3116\n",
            "Epoch [3/10], Batch [300], Loss_D: 0.6720, Loss_G: 1.5293\n",
            "Epoch [3/10], Batch [400], Loss_D: 0.3406, Loss_G: 2.7290\n",
            "Epoch [4/10], Batch [0], Loss_D: 0.3795, Loss_G: 1.7760\n",
            "Epoch [4/10], Batch [100], Loss_D: 0.6796, Loss_G: 1.3558\n",
            "Epoch [4/10], Batch [200], Loss_D: 0.3258, Loss_G: 2.0844\n",
            "Epoch [4/10], Batch [300], Loss_D: 0.4009, Loss_G: 1.8775\n",
            "Epoch [4/10], Batch [400], Loss_D: 0.6390, Loss_G: 0.7374\n",
            "Epoch [5/10], Batch [0], Loss_D: 0.4041, Loss_G: 2.0121\n",
            "Epoch [5/10], Batch [100], Loss_D: 0.7286, Loss_G: 1.4428\n",
            "Epoch [5/10], Batch [200], Loss_D: 0.4127, Loss_G: 2.1184\n",
            "Epoch [5/10], Batch [300], Loss_D: 0.3977, Loss_G: 1.9220\n",
            "Epoch [5/10], Batch [400], Loss_D: 0.8514, Loss_G: 3.3121\n",
            "Epoch [6/10], Batch [0], Loss_D: 0.4392, Loss_G: 1.8065\n",
            "Epoch [6/10], Batch [100], Loss_D: 0.3999, Loss_G: 2.5173\n",
            "Epoch [6/10], Batch [200], Loss_D: 0.5214, Loss_G: 2.0764\n",
            "Epoch [6/10], Batch [300], Loss_D: 0.4661, Loss_G: 1.9234\n",
            "Epoch [6/10], Batch [400], Loss_D: 0.3233, Loss_G: 2.6000\n",
            "Epoch [7/10], Batch [0], Loss_D: 0.5749, Loss_G: 2.9116\n",
            "Epoch [7/10], Batch [100], Loss_D: 0.6353, Loss_G: 1.3683\n",
            "Epoch [7/10], Batch [200], Loss_D: 0.4414, Loss_G: 2.4010\n",
            "Epoch [7/10], Batch [300], Loss_D: 0.4377, Loss_G: 2.0088\n",
            "Epoch [7/10], Batch [400], Loss_D: 0.4001, Loss_G: 2.2673\n",
            "Epoch [8/10], Batch [0], Loss_D: 0.6286, Loss_G: 1.1083\n",
            "Epoch [8/10], Batch [100], Loss_D: 0.4817, Loss_G: 2.3583\n",
            "Epoch [8/10], Batch [200], Loss_D: 0.4991, Loss_G: 1.8483\n",
            "Epoch [8/10], Batch [300], Loss_D: 0.5276, Loss_G: 3.1109\n",
            "Epoch [8/10], Batch [400], Loss_D: 0.6079, Loss_G: 1.0218\n",
            "Epoch [9/10], Batch [0], Loss_D: 0.6138, Loss_G: 1.3414\n",
            "Epoch [9/10], Batch [100], Loss_D: 0.3914, Loss_G: 2.9822\n",
            "Epoch [9/10], Batch [200], Loss_D: 0.3207, Loss_G: 2.6911\n",
            "Epoch [9/10], Batch [300], Loss_D: 0.6223, Loss_G: 1.4501\n",
            "Epoch [9/10], Batch [400], Loss_D: 2.5708, Loss_G: 0.0518\n",
            "Epoch [10/10], Batch [0], Loss_D: 0.4674, Loss_G: 1.3918\n",
            "Epoch [10/10], Batch [100], Loss_D: 0.6588, Loss_G: 1.9986\n",
            "Epoch [10/10], Batch [200], Loss_D: 0.5989, Loss_G: 1.3750\n",
            "Epoch [10/10], Batch [300], Loss_D: 0.6104, Loss_G: 3.2338\n",
            "Epoch [10/10], Batch [400], Loss_D: 0.5074, Loss_G: 2.2687\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bCgYiCZYeLPu"
      },
      "source": [
        "import numpy as np\n",
        "import torchvision.utils as vutils"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 611
        },
        "id": "7m2rSNBWHHY2",
        "outputId": "240e6296-47bd-4e32-f21a-be788e4c3795"
      },
      "source": [
        "fig = plt.figure(figsize=(10, 10))\n",
        "rand_noise = torch.rand((64, 100, 1, 1))\n",
        "out = vutils.make_grid(G(rand_noise.cuda()).cpu().detach(), padding=5, normalize=True)\n",
        "plt.imshow(np.transpose(out.numpy(), (1, 2, 0)), cmap='gray')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f7a80f27850>"
            ]
          },
          "metadata": {},
          "execution_count": 33
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sll_xIC_kTGy"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}