MNIST_GAN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import torch packages\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",
    "\n",
    "# helper packages\n",
    "import matplotlib.pyplot as plt\n",
    "import tqdm as tqdm\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate transforms to apply to the images in order to perform data augmentation\n",
    "from torchvision import transforms\n",
    "\n",
    "# Chain together scaling and cropping transformations (and convert to pytorch tensors)\n",
    "transform = transforms.Compose([transforms.RandomAffine(degrees=10,translate=(0.1,0.1),scale=(0.9,1.1),shear=10), transforms.ToTensor()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load MNIST training and test datasets using torchvision\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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create training and test dataloaders (batch size of 32)\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=32, shuffle=True)\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=32, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([32, 1, 28, 28])\n",
      "torch.Size([32])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# View MNIST image using MNIST an look at the shape of a batch\n",
    "image, label = next(iter(trainloader))\n",
    "print(image.shape)\n",
    "print(label.shape)\n",
    "\n",
    "# Plot the first image in the batch\n",
    "plt.imshow(image[0,0,:,:], cmap='gray')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build the critic network class (standard convolutional architecture)\n",
    "# The output will be a single value which scores the input image (based on how realistic it is)\n",
    "\n",
    "class Critic(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Critic,self).__init__()\n",
    "        # This takes in a 28 x 28 image and outputs a single value\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Conv2d(1, 32, kernel_size = 3, padding = 1), # 28 x 28 x 1 -> 28 x 28 x 32\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size = 2), # 28 x 28 x 32 -> 14 x 14 x 32\n",
    "            nn.Conv2d(32, 64, kernel_size = 3, padding = 1), # 14 x 14 x 32 -> 14 x 14 x 64\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size = 2), # 14 x 14 x 64 -> 7 x 7 x 64\n",
    "            nn.Conv2d(64, 8, kernel_size = 3), # 7 x 7 x 64 -> 5 x 5 x 8\n",
    "            nn.Flatten(), \n",
    "            nn.Linear(5*5*8, 1), # 5 x 5 x 8 -> 1\n",
    "            nn.Tanh()\n",
    "        )\n",
    "    # Put image through layers and return output\n",
    "    def forward(self, x):\n",
    "        return self.layers(x)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build the generator network class (standard convolutional architecture)\n",
    "# The generator takes in a random vector and outputs a 28 x 28 image\n",
    "# The random vector is a 24 dimensional Gaussian distribution with mean 0 and variance 1\n",
    "# The generator network will have a standard deconv architecture\n",
    "\n",
    "class Generator(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Generator, self).__init__()\n",
    "        # This takes in a 24 dimensional vector and outputs a 28 x 28 image\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(24, 5*5*8), \n",
    "            nn.Unflatten(1, (8, 5, 5)),\n",
    "            nn.ConvTranspose2d(8, 64, kernel_size = 3), \n",
    "            nn.ReLU(),\n",
    "            nn.ConvTranspose2d(64, 32, kernel_size = 3, padding = 1), \n",
    "            nn.ReLU(),\n",
    "            nn.Upsample(scale_factor = 2),\n",
    "            nn.ConvTranspose2d(32, 16, kernel_size = 3, padding = 1), \n",
    "            nn.ReLU(),\n",
    "            nn.Upsample(scale_factor = 2),\n",
    "            nn.ConvTranspose2d(16, 1, kernel_size = 3, padding = 1),\n",
    "            nn.Sigmoid()\n",
    "        )   \n",
    "    # Put random vector through layers and return output\n",
    "    def forward(self, x):\n",
    "        return self.layers(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instantiate the generator and critic\n",
    "generator = Generator()\n",
    "critic = Critic()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define optimisers for generator and critic\n",
    "g_optimiser = optim.Adam(generator.parameters(), lr=0.0005)\n",
    "c_optimiser = optim.Adam(critic.parameters(), lr=0.0005)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a list to store the losses for the two networks\n",
    "c_losses = []\n",
    "g_losses = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1875/1875 [09:11<00:00,  3.40it/s]\n",
      "100%|██████████| 1875/1875 [20:10<00:00,  1.55it/s]\n",
      "100%|██████████| 1875/1875 [1:10:13<00:00,  2.25s/it]     \n"
     ]
    }
   ],
   "source": [
    "# Train generator and critic networks using Wasserstein loss with l2 weight regularisation\n",
    "# Wasserstein loss for the critic network is C(G(Z)) - C(X) where Z is a random vector and X is a real image\n",
    "# This encourages the critic to score real images highly and generated images poorly\n",
    "# The generator loss is -C(G(Z)) which encourages the generator to produce images that score highly with the critic\n",
    "\n",
    "def train_one_epoch():\n",
    "    # Iterate over training data\n",
    "    for real_images, label in tqdm.tqdm(trainloader):\n",
    "        # Zero the gradients\n",
    "        c_optimiser.zero_grad()\n",
    "        # generate random vector\n",
    "        z = torch.randn(32,24)\n",
    "        # Pass random vector through generator\n",
    "        fake_image = generator(z)\n",
    "        critic_loss = critic(fake_image).mean() - critic(real_images).mean()\n",
    "        critic_loss.backward()\n",
    "        c_losses.append(critic_loss.item())\n",
    "        c_optimiser.step()\n",
    "\n",
    "        # train the generator\n",
    "        # zero gradients for the generator\n",
    "        g_optimiser.zero_grad()\n",
    "        # generate random vector\n",
    "        z = torch.randn(32,24)\n",
    "        # Pass random vector through generator\n",
    "        fake_image = generator(z)\n",
    "        generator_loss = -critic(fake_image).mean()\n",
    "        generator_loss.backward()\n",
    "        g_losses.append(generator_loss.item())\n",
    "        g_optimiser.step()\n",
    "\n",
    "for i in range(3):\n",
    "    train_one_epoch()\n",
    "    print(np.mean(g_losses), np.mean(c_losses))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the losses for the generator and critic networks\n",
    "plt.plot(c_losses, label='critic loss')\n",
    "plt.plot(g_losses, label='generator loss')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ML",
   "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
}