models/GANs/notebooks/cGAN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional Generative Adversarial Network (GAN)\n",
    "```\n",
    "Conditional GANs (cGANs) are a type of GAN that learn a generative model from input images with labels. It allows to generate images of user-specified classes.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# necessary imports\n",
    "# add ../src to sys.path\n",
    "import sys\n",
    "sys.path.append('../src')\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "from tqdm import tqdm, trange\n",
    "\n",
    "import cGAN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load MNIST data\n",
    "transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])\n",
    "\n",
    "# datasets\n",
    "trainset = torchvision.datasets.MNIST(root='../../data', train=True, download=True, transform=transform)\n",
    "testset = torchvision.datasets.MNIST(root='../../data', train=False, download=True, transform=transform)\n",
    "\n",
    "\n",
    "# data loaders\n",
    "batch_size = 128\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True)\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# visualize some data\n",
    "def visualize_data(data, labels):\n",
    "    fig, axs = plt.subplots(2,2, figsize=(5,5))\n",
    "    axs = axs.flatten()\n",
    "    for i in range(4):\n",
    "        axs[i].imshow(data[i].squeeze(), cmap='gray')\n",
    "        axs[i].set_title(labels[i].item())\n",
    "        axs[i].axis('off')\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "# visualize some data\n",
    "imgs, labels = next(iter(trainloader))\n",
    "visualize_data(imgs, labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max:  tensor(1.)\n",
      "min:  tensor(-1.)\n"
     ]
    }
   ],
   "source": [
    "# max and min values of the data\n",
    "print('max: ', torch.max(imgs))\n",
    "print('min: ', torch.min(imgs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "# device\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# image dim\n",
    "img_dim = imgs[0].shape[1]**2 # 28*28 = 784\n",
    "\n",
    "# noise dim\n",
    "noise_dim = 100\n",
    "\n",
    "# number of classes\n",
    "num_classes = np.unique(labels).shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create generator and discriminator models\n",
    "generator = cGAN.Generator(noise_dim, img_dim, num_classes).to(device)\n",
    "discriminator = cGAN.Discriminator(img_dim, num_classes).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([32, 784])\n",
      "torch.Size([32, 1])\n"
     ]
    }
   ],
   "source": [
    "# test generator\n",
    "noise = torch.randn(32, noise_dim).to(device)\n",
    "labels = torch.randint(0, num_classes, (32,)).to(device)\n",
    "fake_imgs = generator(noise, labels)\n",
    "print(fake_imgs.shape)\n",
    "\n",
    "# test discriminator\n",
    "preds = discriminator(fake_imgs, labels)\n",
    "print(preds.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# optimizers\n",
    "lr = 0.0002\n",
    "beta1 = 0.5\n",
    "beta2 = 0.999\n",
    "optimizer_G = optim.Adam(generator.parameters(), lr=lr, betas=(beta1, beta2))\n",
    "optimizer_D = optim.Adam(discriminator.parameters(), lr=lr, betas=(beta1, beta2))\n",
    "\n",
    "# loss function\n",
    "criterion = nn.BCELoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 1/200 [00:06<23:05,  6.96s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  0 loss_D:  0.9329308271408081 loss_G:  1.5613901615142822\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|█         | 21/200 [02:21<20:00,  6.71s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  20 loss_D:  0.884189784526825 loss_G:  1.6130173206329346\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|██        | 41/200 [04:34<17:41,  6.68s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  40 loss_D:  1.069244623184204 loss_G:  1.2251434326171875\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|███       | 61/200 [06:51<16:15,  7.02s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  60 loss_D:  0.9764268398284912 loss_G:  1.8513691425323486\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████      | 81/200 [09:09<13:41,  6.90s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  80 loss_D:  0.9614948630332947 loss_G:  1.3880962133407593\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|█████     | 101/200 [11:28<11:47,  7.14s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  100 loss_D:  1.0341129302978516 loss_G:  1.5384790897369385\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|██████    | 121/200 [13:49<09:08,  6.94s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  120 loss_D:  0.9636611938476562 loss_G:  1.4057629108428955\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|███████   | 141/200 [16:08<06:50,  6.95s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  140 loss_D:  1.0506128072738647 loss_G:  1.6723313331604004\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████  | 161/200 [18:27<04:28,  6.89s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  160 loss_D:  1.0738555192947388 loss_G:  1.7336674928665161\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|█████████ | 181/200 [20:46<02:13,  7.03s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  180 loss_D:  1.0916941165924072 loss_G:  1.1017669439315796\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 200/200 [22:58<00:00,  6.89s/it]\n"
     ]
    }
   ],
   "source": [
    "# training loop\n",
    "epochs = 200\n",
    "for epoch in trange(epochs):\n",
    "    for i, (real_imgs, real_labels) in enumerate(trainloader):\n",
    "        \n",
    "        real_imgs = real_imgs.view(-1, img_dim).to(device)\n",
    "        real_labels = real_labels.to(device)\n",
    "\n",
    "        # train discriminator\n",
    "        optimizer_D.zero_grad()\n",
    "        # real data\n",
    "        real_preds = discriminator(real_imgs, real_labels)\n",
    "        real_loss = criterion(real_preds, torch.ones_like(real_preds))\n",
    "        # fake data\n",
    "        noise = torch.randn(batch_size, noise_dim).to(device)\n",
    "        fake_labels = torch.randint(0, num_classes, (batch_size,)).to(device)\n",
    "        fake_imgs = generator(noise, fake_labels)\n",
    "        fake_preds = discriminator(fake_imgs, fake_labels)\n",
    "        fake_loss = criterion(fake_preds, torch.zeros_like(fake_preds))\n",
    "        # total loss\n",
    "        loss_D = real_loss + fake_loss\n",
    "        loss_D.backward()\n",
    "        optimizer_D.step()\n",
    "\n",
    "        # train generator\n",
    "        optimizer_G.zero_grad()\n",
    "        noise = torch.randn(batch_size, noise_dim).to(device)\n",
    "        fake_labels = torch.randint(0, num_classes, (batch_size,)).to(device)\n",
    "        fake_imgs = generator(noise, fake_labels)\n",
    "        fake_preds = discriminator(fake_imgs, fake_labels)\n",
    "        loss_G = criterion(fake_preds, torch.ones_like(fake_preds))\n",
    "        loss_G.backward()\n",
    "        optimizer_G.step()\n",
    "\n",
    "    # print losses\n",
    "    if epoch % 20 == 0:\n",
    "        print('epoch: ', epoch, 'loss_D: ', loss_D.item(), 'loss_G: ', loss_G.item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate some data\n",
    "noise = torch.randn(32, noise_dim).to(device)\n",
    "labels = torch.randint(0, num_classes, (32,)).to(device)\n",
    "fake_imgs = generator(noise, labels).detach().cpu().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# visualize some generated data, 3x3 grid\n",
    "fig, axs = plt.subplots(3,3, figsize=(5,5))\n",
    "axs = axs.flatten()\n",
    "for i in range(9):\n",
    "    axs[i].imshow(fake_imgs[i].reshape(28,28), cmap='gray')\n",
    "    axs[i].set_title(labels[i].item())\n",
    "    axs[i].axis('off')\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "Seems like it's working. A longer training time would probably improve the results. We used a simple network architecture, but a complex one, e.g. Convolutional Neural Network (CNN), would probably improve the results as well.\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "torch",
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}