Denoising_Autoencoder_MNIST.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Denoising Autoencoder\n",
    "\n",
    "Sticking with the MNIST dataset, let's add noise to our data and see if we can define and train an autoencoder to _de_-noise the images.\n",
    "\n",
    "<img src='notebook_ims/autoencoder_denoise.png' width=70%/>\n",
    "\n",
    "Let's get started by importing our libraries and getting the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to data\\MNIST\\raw\\train-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100.1%"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting data\\MNIST\\raw\\train-images-idx3-ubyte.gz to data\\MNIST\\raw\n",
      "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to data\\MNIST\\raw\\train-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "113.5%"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting data\\MNIST\\raw\\train-labels-idx1-ubyte.gz to data\\MNIST\\raw\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to data\\MNIST\\raw\\t10k-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100.4%"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting data\\MNIST\\raw\\t10k-images-idx3-ubyte.gz to data\\MNIST\\raw\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to data\\MNIST\\raw\\t10k-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "180.4%"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting data\\MNIST\\raw\\t10k-labels-idx1-ubyte.gz to data\\MNIST\\raw\n",
      "Processing...\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "from torchvision import datasets\n",
    "import torchvision.transforms as transforms\n",
    "\n",
    "# convert data to torch.FloatTensor\n",
    "transform = transforms.ToTensor()\n",
    "\n",
    "# load the training and test datasets\n",
    "train_data = datasets.MNIST(root='data', train=True,\n",
    "                                   download=True, transform=transform)\n",
    "test_data = datasets.MNIST(root='data', train=False,\n",
    "                                  download=True, transform=transform)\n",
    "\n",
    "# Create training and test dataloaders\n",
    "num_workers = 0\n",
    "# how many samples per batch to load\n",
    "batch_size = 20\n",
    "\n",
    "# prepare data loaders\n",
    "train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, num_workers=num_workers)\n",
    "test_loader = torch.utils.data.DataLoader(test_data, batch_size=batch_size, num_workers=num_workers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize the Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x2d9841f2488>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "    \n",
    "# obtain one batch of training images\n",
    "dataiter = iter(train_loader)\n",
    "images, labels = dataiter.next()\n",
    "images = images.numpy()\n",
    "\n",
    "# get one image from the batch\n",
    "img = np.squeeze(images[0])\n",
    "\n",
    "fig = plt.figure(figsize = (5,5)) \n",
    "ax = fig.add_subplot(111)\n",
    "ax.imshow(img, cmap='gray')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Denoising\n",
    "\n",
    "As I've mentioned before, autoencoders like the ones you've built so far aren't too useful in practive. However, they can be used to denoise images quite successfully just by training the network on noisy images. We can create the noisy images ourselves by adding Gaussian noise to the training images, then clipping the values to be between 0 and 1.\n",
    "\n",
    ">**We'll use noisy images as input and the original, clean images as targets.** \n",
    "\n",
    "Below is an example of some of the noisy images I generated and the associated, denoised images.\n",
    "\n",
    "<img src='notebook_ims/denoising.png' />\n",
    "\n",
    "\n",
    "Since this is a harder problem for the network, we'll want to use _deeper_ convolutional layers here; layers with more feature maps. You might also consider adding additional layers. I suggest starting with a depth of 32 for the convolutional layers in the encoder, and the same depths going backward through the decoder.\n",
    "\n",
    "#### TODO: Build the network for the denoising autoencoder. Add deeper and/or additional layers compared to the model above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ConvDenoiser(\n",
      "  (conv1): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (conv2): Conv2d(32, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (conv3): Conv2d(16, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (conv4): Conv2d(8, 4, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  (t_conv1): ConvTranspose2d(4, 8, kernel_size=(2, 2), stride=(2, 2))\n",
      "  (t_conv2): ConvTranspose2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (t_conv3): ConvTranspose2d(16, 32, kernel_size=(2, 2), stride=(2, 2))\n",
      "  (t_conv4): ConvTranspose2d(32, 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "# define the NN architecture\n",
    "class ConvDenoiser(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(ConvDenoiser, self).__init__()\n",
    "        ## encoder layers ##\n",
    "        # 1 grayscale to 32 filters\n",
    "        self.conv1 = nn.Conv2d(1,32, 3, padding=1)\n",
    "        self.conv2 = nn.Conv2d(32,16, 3, padding=1)\n",
    "        self.conv3 = nn.Conv2d(16,8, 3, padding=1)\n",
    "        self.conv4 = nn.Conv2d(8,4, 3, padding=1)\n",
    "        \n",
    "        self.pool = nn.MaxPool2d(2,2)\n",
    "        \n",
    "        ## decoder layers ##\n",
    "        ## a kernel of 2 and a stride of 2 will increase the spatial dims by 2\n",
    "        self.t_conv1 = nn.ConvTranspose2d(4, 8, 2, stride=2)\n",
    "        self.t_conv2 = nn.ConvTranspose2d(8, 16, 3, stride=1, padding=1)\n",
    "        self.t_conv3 = nn.ConvTranspose2d(16, 32, 2, stride=2)\n",
    "        self.t_conv4 = nn.ConvTranspose2d(32, 1, 3, stride=1, padding=1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        ## encode ##\n",
    "        x = F.relu(self.conv1(x))\n",
    "        x = F.relu(self.conv2(x))\n",
    "        x = self.pool(x)\n",
    "        x = F.relu(self.conv3(x))\n",
    "        x = F.relu(self.conv4(x))\n",
    "        x = self.pool(x)\n",
    "        \n",
    "        ## decode ##\n",
    "        x = F.relu(self.t_conv1(x))\n",
    "        x = F.relu(self.t_conv2(x))\n",
    "        x = F.relu(self.t_conv3(x))\n",
    "        x = F.sigmoid(self.t_conv4(x))\n",
    "        \n",
    "        return x\n",
    "\n",
    "# initialize the NN\n",
    "model = ConvDenoiser()\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Training\n",
    "\n",
    "We are only concerned with the training images, which we can get from the `train_loader`.\n",
    "\n",
    ">In this case, we are actually **adding some noise** to these images and we'll feed these `noisy_imgs` to our model. The model will produce reconstructed images based on the noisy input. But, we want it to produce _normal_ un-noisy images, and so, when we calculate the loss, we will still compare the reconstructed outputs to the original images!\n",
    "\n",
    "Because we're comparing pixel values in input and output images, it will be best to use a loss that is meant for a regression task. Regression is all about comparing quantities rather than probabilistic values. So, in this case, I'll use `MSELoss`. And compare output images and input images as follows:\n",
    "```\n",
    "loss = criterion(outputs, images)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# specify loss function\n",
    "criterion = nn.MSELoss()\n",
    "\n",
    "# specify loss function\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\di.wei.tan\\AppData\\Local\\Continuum\\anaconda3\\envs\\deep-learning\\lib\\site-packages\\torch\\nn\\functional.py:1351: UserWarning: nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\n",
      "  warnings.warn(\"nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\")\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1 \tTraining Loss: 0.517085\n",
      "Epoch: 2 \tTraining Loss: 0.340247\n",
      "Epoch: 3 \tTraining Loss: 0.320893\n",
      "Epoch: 4 \tTraining Loss: 0.310022\n",
      "Epoch: 5 \tTraining Loss: 0.300308\n",
      "Epoch: 6 \tTraining Loss: 0.291802\n",
      "Epoch: 7 \tTraining Loss: 0.280810\n",
      "Epoch: 8 \tTraining Loss: 0.271716\n",
      "Epoch: 9 \tTraining Loss: 0.265536\n",
      "Epoch: 10 \tTraining Loss: 0.261158\n"
     ]
    }
   ],
   "source": [
    "# number of epochs to train the model\n",
    "n_epochs = 10\n",
    "\n",
    "# for adding noise to images\n",
    "noise_factor=0.5\n",
    "\n",
    "for epoch in range(1, n_epochs+1):\n",
    "    # monitor training loss\n",
    "    train_loss = 0.0\n",
    "    \n",
    "    ###################\n",
    "    # train the model #\n",
    "    ###################\n",
    "    for data in train_loader:\n",
    "        # _ stands in for labels, here\n",
    "        # no need to flatten images\n",
    "        images, _ = data\n",
    "        \n",
    "        ## add random noise to the input images\n",
    "        noisy_imgs = images + noise_factor * torch.randn(*images.shape)\n",
    "        # Clip the images to be between 0 and 1\n",
    "        noisy_imgs = np.clip(noisy_imgs, 0., 1.)\n",
    "                \n",
    "        # clear the gradients of all optimized variables\n",
    "        optimizer.zero_grad()\n",
    "        ## forward pass: compute predicted outputs by passing *noisy* images to the model\n",
    "        outputs = model(noisy_imgs)\n",
    "        # calculate the loss\n",
    "        # the \"target\" is still the original, not-noisy images\n",
    "        loss = criterion(outputs, images)\n",
    "        # backward pass: compute gradient of the loss with respect to model parameters\n",
    "        loss.backward()\n",
    "        # perform a single optimization step (parameter update)\n",
    "        optimizer.step()\n",
    "        # update running training loss\n",
    "        train_loss += loss.item()*images.size(0)\n",
    "            \n",
    "    # print avg training statistics \n",
    "    train_loss = train_loss/len(train_loader)\n",
    "    print('Epoch: {} \\tTraining Loss: {:.6f}'.format(\n",
    "        epoch, \n",
    "        train_loss\n",
    "        ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Checking out the results\n",
    "\n",
    "Here I'm adding noise to the test images and passing them through the autoencoder. It does a suprising great job of removing the noise, even though it's sometimes difficult to tell what the original number is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1800x288 with 20 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# obtain one batch of test images\n",
    "dataiter = iter(test_loader)\n",
    "images, labels = dataiter.next()\n",
    "\n",
    "# add noise to the test images\n",
    "noisy_imgs = images + noise_factor * torch.randn(*images.shape)\n",
    "noisy_imgs = np.clip(noisy_imgs, 0., 1.)\n",
    "\n",
    "# get sample outputs\n",
    "output = model(noisy_imgs)\n",
    "# prep images for display\n",
    "noisy_imgs = noisy_imgs.numpy()\n",
    "\n",
    "# output is resized into a batch of iages\n",
    "output = output.view(batch_size, 1, 28, 28)\n",
    "# use detach when it's an output that requires_grad\n",
    "output = output.detach().numpy()\n",
    "\n",
    "# plot the first ten input images and then reconstructed images\n",
    "fig, axes = plt.subplots(nrows=2, ncols=10, sharex=True, sharey=True, figsize=(25,4))\n",
    "\n",
    "# input images on top row, reconstructions on bottom\n",
    "for noisy_imgs, row in zip([noisy_imgs, output], axes):\n",
    "    for img, ax in zip(noisy_imgs, row):\n",
    "        ax.imshow(np.squeeze(img), cmap='gray')\n",
    "        ax.get_xaxis().set_visible(False)\n",
    "        ax.get_yaxis().set_visible(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}