10. Reconsturcting Inputs using Autoencoders/10.07 Denoising images using Denoising Autoencoder.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Denoising images using Denoising Autoencoder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section, we will learn how to denoise the images using  Denoising Autoencoder (DAE). We use convolutional autoencoders for denoising the images. The code for DAE is just the same as CAE except that here we use noisy images in the input."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import the libraries\n",
    "\n",
    "\n",
    "First, let us import the necessary libraries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "#modelling\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Input, Dense, Conv2D, MaxPooling2D, UpSampling2D\n",
    "from tensorflow.keras import backend as K\n",
    "\n",
    "import tensorflow as tf\n",
    "tf.logging.set_verbosity(tf.logging.ERROR)\n",
    "\n",
    "#plotting\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "#dataset\n",
    "from keras.datasets import mnist\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare the Dataset\n",
    "\n",
    "Let us load the MNIST dataset. We don't need the labels for autoencoder. Since we are reconstructing the given input we don't need the labels. So, we just load x_train for training and x_test for testing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "(x_train, _), (x_test, _) = mnist.load_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Normalize the data by dividing with max pixel value which is 255:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x_train = x_train.astype('float32') / 255.\n",
    "x_test = x_test.astype('float32') / 255."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reshape the images:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x_train = np.reshape(x_train, (len(x_train), 28, 28, 1))  \n",
    "x_test = np.reshape(x_test, (len(x_test), 28, 28, 1))  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, the shape of data would become:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((60000, 28, 28, 1), (10000, 28, 28, 1))\n"
     ]
    }
   ],
   "source": [
    "print(x_train.shape, x_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set the noise factor:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "noise_factor = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add noise to the train and test images:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x_train_noisy = x_train + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_train.shape) \n",
    "x_test_noisy = x_test + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Clip the train and test set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x_train_noisy = np.clip(x_train_noisy, 0., 1.)\n",
    "x_test_noisy = np.clip(x_test_noisy, 0., 1.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us define the shape of our input image:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "input_image = Input(shape=(28, 28, 1))  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define the Encoder\n",
    "\n",
    "Now let us define our encoder. Unlike vanilla autoencoders where we use feedforward networks, here we use convolutional network so our encoder comprises of three convolutional layer followed by a max pooling layer with relu activations.\n",
    "\n",
    "Define the first convolutional layer followed by a pooling operation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = Conv2D(16, (3, 3), activation='relu', padding='same')(input_image)\n",
    "x = MaxPooling2D((2, 2), padding='same')(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Second convolutional layer with a max pooling layer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = Conv2D(8, (3, 3), activation='relu', padding='same')(x)\n",
    "x = MaxPooling2D((2, 2), padding='same')(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Final convolutional layer with max pooling operation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = Conv2D(8, (3, 3), activation='relu', padding='same')(x)\n",
    "encoder = MaxPooling2D((2, 2), padding='same')(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define the decoder\n",
    "\n",
    "Now we define our decoder, in the decoder, we perform the deconvolution operation with three layers i.e we upsample the encodings create by the encoder and get the original image,\n",
    "\n",
    "Define the first convolutional layer followed by upsampling:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = Conv2D(8, (3, 3), activation='relu', padding='same')(encoder)\n",
    "x = UpSampling2D((2, 2))(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Second convolutional layer with upsampling:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = Conv2D(8, (3, 3), activation='relu', padding='same')(x)\n",
    "x = UpSampling2D((2, 2))(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the final layer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = Conv2D(16, (3, 3), activation='relu')(x)\n",
    "x = UpSampling2D((2, 2))(x)\n",
    "decoded = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build the model\n",
    "\n",
    "Define the model which takes an input image and returns the images generated by the decoder which is reconstructed images:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "model = Model(input_image, decoded)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Let us compile our with loss as binary cross entropy and adadelta as our optimizer:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "model.compile(optimizer='adadelta', loss='binary_crossentropy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train the model. Since, we want the model to learn to remove noise in the image, Input to the model is the noisy images, that is, x_train_noisy and output is the denoised images, that is, x_train:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 60000 samples, validate on 10000 samples\n",
      "Epoch 1/10\n",
      "60000/60000 [==============================] - 39s 644us/sample - loss: 33.8206 - val_loss: 29.2978\n",
      "Epoch 2/10\n",
      "60000/60000 [==============================] - 38s 633us/sample - loss: 28.1641 - val_loss: 26.4556\n",
      "Epoch 3/10\n",
      "60000/60000 [==============================] - 38s 640us/sample - loss: 26.2510 - val_loss: 25.2689\n",
      "Epoch 4/10\n",
      "60000/60000 [==============================] - 39s 649us/sample - loss: 25.3953 - val_loss: 24.7228\n",
      "Epoch 5/10\n",
      "60000/60000 [==============================] - 39s 652us/sample - loss: 24.8777 - val_loss: 24.3716\n",
      "Epoch 6/10\n",
      "60000/60000 [==============================] - 50s 828us/sample - loss: 24.5304 - val_loss: 24.1560\n",
      "Epoch 7/10\n",
      "60000/60000 [==============================] - 39s 655us/sample - loss: 24.2728 - val_loss: 23.8624\n",
      "Epoch 8/10\n",
      "60000/60000 [==============================] - 39s 646us/sample - loss: 24.0702 - val_loss: 23.6791\n",
      "Epoch 9/10\n",
      "60000/60000 [==============================] - 39s 650us/sample - loss: 23.8961 - val_loss: 23.4635\n",
      "Epoch 10/10\n",
      "60000/60000 [==============================] - 38s 634us/sample - loss: 23.7661 - val_loss: 23.2458\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7f4ef6803190>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(x_train_noisy, x_train, epochs=10,batch_size=128, shuffle=True, validation_data=(x_test_noisy, x_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reconstruct the images\n",
    "\n",
    "Reconstruct images using our trained model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "reconstructed_images = model.predict(x_test_noisy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the actual images:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x288 with 7 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n = 7\n",
    "plt.figure(figsize=(20, 4))\n",
    "for i in range(n):\n",
    " \n",
    "    ax = plt.subplot(1, n, i+1)\n",
    "    plt.imshow(x_test_noisy[i].reshape(28, 28))\n",
    "    plt.gray()\n",
    "    ax.get_xaxis().set_visible(False)\n",
    "    ax.get_yaxis().set_visible(False)\n",
    "plt.show()   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the reconstructed images:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x288 with 7 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n = 7\n",
    "plt.figure(figsize=(20, 4))\n",
    "for i in range(n):\n",
    "    ax = plt.subplot(2, n, i + n + 1)\n",
    "    plt.imshow(reconstructed_images[i].reshape(28, 28))\n",
    "    plt.gray()\n",
    "    ax.get_xaxis().set_visible(False)\n",
    "    ax.get_yaxis().set_visible(False)\n",
    "\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you may notice the above reconstructed images, DAE has learned to remove the noise in the image. In that next section we will learn about another interesting type of autoencoders called sparse autoencoder. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}