09a_auto_encoders.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GTY-Msjal7zU"
   },
   "source": [
    "# Generative models - auto-encoders\n",
    "\n",
    "### Author: Philippe Esling (esling@ircam.fr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Z3M5ezRyrjA3"
   },
   "source": [
    "In this course we will cover\n",
    "1. A brief introduction to [generative models](#generative)\n",
    "2. A formal presentation of [Auto-Encoders](#ae) (AEs)\n",
    "3. An explanation of how to [implement AEs](#implement)\n",
    "4. An [application](#application) of AEs for modeling images\n",
    "4. An practical exemple of [convolutional denoising AEs](#denoising) for image data **(exercise)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"generative\"></a>\n",
    "\n",
    "## Generative models\n",
    "\n",
    "### Supervised refresher\n",
    "\n",
    "Until now, we have mostly discussed models that are developed for _supervised_ and _discriminative_ tasks. To formalize this problem, we have a set of data $\\{\\mathbf{x}_{i}, \\mathbf{y}_{i}\\}_{i\\in[1,n]}$, where the $\\mathbf{x}_{i}$ and $\\mathbf{y}_{i}$ are linked. Therefore, we want to approximate this relation through\n",
    "\\begin{equation}\n",
    "    \\mathbf{\\hat{y}} = \\mathcal{F}_\\mathbf{\\theta}(\\mathbf{x})  \n",
    "\\end{equation}\n",
    "where we train the parameters $\\mathbf{\\theta}$ so that $\\mathbf{\\hat{y}}\\approx\\mathbf{y}$. The existence of a label $\\mathbf{y}$ (\"correct answer\") defines a _supervised_ problem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Going unsupervised\n",
    "\n",
    "In some cases, we might only have a set of data $\\{\\mathbf{x}_{i}\\}_{i\\in[1,n]}$, and still be interested in learning some underlying properties or structure of this set. In that case, the problem is _unsupervised_ as we have to learn without a given answer. \n",
    "\n",
    "Here, we can turn to _generative_ models [[1](#reference1)], which allows to create new data instances based on the observation of existing examples. Although these models are more naturally defined in a _probabilistic way_, we will assume that we have some simple _code_ $\\mathbf{z}$, which allows to control the properties of the generation, and need to learn\n",
    "\\begin{equation}\n",
    "    \\mathbf{\\hat{x}} = \\mathcal{F}_\\mathbf{\\theta}(\\mathbf{z})  \n",
    "\\end{equation}\n",
    "where we still need to learn $\\mathbf{\\theta}$, so that $\\mathbf{\\hat{x}}$ have similar properties to that of the examples in $\\{\\mathbf{x}_{i}\\}_{i\\in[1,n]}$.\n",
    "\n",
    "Now the problem to solve is how we can learn directly from a set of data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Kg83oWxMm92f"
   },
   "source": [
    "<a id=\"ae\"></a>\n",
    "\n",
    "## Auto-encoders\n",
    "\n",
    "One way to understand a set of data is to try to _compress_, or _simplify_ the corresponding dataset. So the idea is to learn simultaneously how to _encode_ our unlabeled input $\\{\\mathbf{x}_{i}\\}_{i\\in[1,n]}$ and to _decode_ the corresponding representation. This idea give rise to the notion of **auto-encoder**. \n",
    "\n",
    "### Architecture \n",
    "\n",
    "The auto-encoder is an unsupervised architecture originally proposed to perform _dimensionality reduction_ [[3](#reference3)]. As its name indicates, we will try to train this model to learn an efficient _encoding_ $\\mathbf{z}$ of unlabeled input data $\\mathbf{x}$. The only way to learn efficient parameters is to also learn a _decoding_ function to _reconstruct_ $\\mathbf{x}$ from $\\mathbf{z}$.\n",
    "\n",
    "<img src=\"images/auto_encoder.png\"/>\n",
    "\n",
    "As shown here, a first model $\\mathcal{E}_\\phi$ _encodes_ the input into a _latent code_ $\\mathbf{z}$ in order to provide a low-dimensional representation of the data. A second model $\\mathcal{D}_\\theta$ designated as the _decoder_ aims to generate outputs from $\\mathbf{z}$ that are as close to the original inputs as possible."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Formal definition\n",
    "\n",
    "The latent code $\\mathbf{z}$ can be seen as a compressed abstract representation, and may be used as an intermediate space for analysis or generation. This helps to govern the distribution of the data through a simpler and higher-level representation, while enhancing the _expressiveness_ of the generative model.\n",
    "The behaviour of an auto-encoder can be formalized as:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "\\mathbf{z} &= \\mathcal{E}_\\phi(\\mathbf{x}) \\\\\n",
    "\\mathbf{\\hat{x}} &= \\mathcal{D}_\\theta(\\mathbf{z})  \n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "with the _encoder_ $\\mathcal{E}_\\phi$ and _decoder_ $\\mathcal{D}_\\theta$ functions parameterized respectively by $\\phi$ and $\\theta$. As we can see this defines the reconstruction relationship\n",
    "$$\n",
    "    \\mathbf{\\hat{x}} = \\mathcal{D}_\\theta(\\mathcal{E}_\\phi(\\mathbf{x}))  \n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training\n",
    "\n",
    "The training of an auto-encoder consists in finding the optimal functions of encoding $\\mathcal{E}^*$ and decoding $\\mathcal{D}^*$ by evaluating the \\textit{reconstruction error} $\\mathcal{L}$ between $\\mathbf{x}$ and $\\mathbf{\\hat{x}}$, such that\n",
    "\\begin{equation}\n",
    "    \\mathcal{E}^*, \\mathcal{D}^* = arg\\,min_{ \\phi, \\theta}{\\mathcal{L}}(\\mathbf{x}, \\mathcal{D}_\\theta(\\mathcal{E}_\\phi(\\mathbf{x})))\n",
    "\\end{equation}\n",
    "\n",
    "As the latent space usually has a smaller dimensionality than the input, it acts as an incentive for the network to find the main attributes of variations in the dataset (and also explains its use for _dimensionality reduction_)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variants and discussion\n",
    "\n",
    "There are several variants of auto-encoders, such as denoising auto-encoders or variational auto-encoders. Each address some downside of the basic AE model. For instance, the deterministic nature of the basic auto-encoder implies a point-wise mapping of the latent space, meaning that not all the latent positions can be leveraged to produce relevant reconstructions. Because of this reason, there is no way to ensure that the latent space could allow a robust generalization and that any random $\\mathbf{z}$ would generate a meaningful output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cAxMjUCBUa43"
   },
   "source": [
    "<a id=\"implement\"> </a>\n",
    "\n",
    "## Implementation\n",
    "\n",
    "Here, we discuss how we can implement and train a simple auto-encoder network in Pytorch. As discussed earlier, an AE is composed of two parts, an **encoder** and a **decoder**. The goal of the encoder is to \"compress\" the dataset, representing its principal features with a very small code, while the goal of the decoder is to learn how to reproduce the initial input from this code. Hence, we will first need to use some basic imports and definition to setup our problem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "e1_Y75QXJS6h"
   },
   "source": [
    "### Import Pytorch and other libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "YfIk2es3hJEd"
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchvision\n",
    "from helper_plot import hdr_plot_style\n",
    "hdr_plot_style();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iYn4MdZnKCey"
   },
   "source": [
    "### Load the dataset\n",
    "\n",
    "To start with a pragmatic and simple to understand example, we  will try to train the basic AE using the Fashion MNIST dataset. This dataset contains images of size 28x28 pixels, with different pieces of clothing. The following code allows to load (and eventually download) the dataset, by using the `torchvision.datasets` module. We also plot some randomly selected test examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "YZm503-I_tji"
   },
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "dataset_dir = './data'\n",
    "# Going to use 80%/20% split for train/valid\n",
    "valid_ratio = 0.2\n",
    "# Load the dataset for the training/validation sets\n",
    "train_valid_dataset = torchvision.datasets.FashionMNIST(root=dataset_dir, train=True, transform=torchvision.transforms.ToTensor(), download=True)\n",
    "# Split it into training and validation sets\n",
    "nb_train = int((1.0 - valid_ratio) * len(train_valid_dataset))\n",
    "nb_valid =  int(valid_ratio * len(train_valid_dataset))\n",
    "train_dataset, valid_dataset = torch.utils.data.dataset.random_split(train_valid_dataset, [nb_train, nb_valid])\n",
    "# Load the test set\n",
    "test_dataset = torchvision.datasets.FashionMNIST(root=dataset_dir, transform=torchvision.transforms.ToTensor(),train=False)\n",
    "# Prepare \n",
    "num_threads = 4     # Loading the dataset is using 4 CPU threads\n",
    "batch_size  = 128   # Using minibatches of 128 samples\n",
    "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, num_workers=num_threads)\n",
    "valid_loader = torch.utils.data.DataLoader(dataset=valid_dataset, batch_size=batch_size, shuffle=False, num_workers=num_threads)\n",
    "test_loader = torch.utils.data.DataLoader(dataset=test_dataset,batch_size=batch_size,shuffle=False,num_workers=num_threads)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we are going to check the properties of our different sets and also plot some random examples, in order to better understand what type of data we will be working with."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The train set contains 48000 images, in 375 batches\n",
      "The validation set contains 12000 images, in 94 batches\n",
      "The test set contains 10000 images, in 79 batches\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "dark"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"The train set contains {} images, in {} batches\".format(len(train_loader.dataset), len(train_loader)))\n",
    "print(\"The validation set contains {} images, in {} batches\".format(len(valid_loader.dataset), len(valid_loader)))\n",
    "print(\"The test set contains {} images, in {} batches\".format(len(test_loader.dataset), len(test_loader)))\n",
    "nsamples = 10\n",
    "classes_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal','Shirt', 'Sneaker', 'Bag', 'Ankle boot']\n",
    "imgs_test, labels = next(iter(train_loader))\n",
    "fig = plt.figure(figsize=(20,5))\n",
    "for i in range(nsamples):\n",
    "    ax = plt.subplot(1,nsamples, i+1)\n",
    "    plt.imshow(imgs_test[i, 0, :, :], vmin=0, vmax=1.0, cmap=matplotlib.cm.gray)\n",
    "    ax.set_title(\"{}\".format(classes_names[labels[i]]), fontsize=15)\n",
    "    ax.get_xaxis().set_visible(False)\n",
    "    ax.get_yaxis().set_visible(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VEdCXSwCoKok"
   },
   "source": [
    "## Basic auto-encoder\n",
    "\n",
    "We recall here that in order to define an autoencoder, we will need an `encoder`, which compresses the images into a small latent vector, and a `decoder`, that reconstructs the original image from this code. Here, we will start very basic and define the encoder and decoder as simple `Dense` layers. To define the model simply, we will use the [Keras API](https://www.tensorflow.org/guide/keras/custom_layers_and_models) defined in the `tensorflow.keras` module (Note that we pre-loaded the `layers` submodule"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AE(nn.Module):\n",
    "    def __init__(self, encoding_dim):\n",
    "        super(AE, self).__init__()\n",
    "        self.latent_dim = encoding_dim\n",
    "        self.hidden_dim = 256\n",
    "        self.encoder = nn.Sequential(\n",
    "          nn.Linear(28 * 28, self.hidden_dim), nn.ReLU(),\n",
    "          nn.Linear(self.hidden_dim, self.hidden_dim), nn.ReLU(),\n",
    "          nn.Linear(self.hidden_dim, self.latent_dim), nn.Sigmoid()\n",
    "        )\n",
    "        self.decoder = nn.Sequential(\n",
    "          nn.Linear(self.latent_dim, self.hidden_dim), nn.ReLU(),\n",
    "          nn.Linear(self.hidden_dim, self.hidden_dim), nn.ReLU(),\n",
    "          nn.Linear(self.hidden_dim, 28 * 28), nn.Sigmoid()\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        encoded = self.encoder(x.reshape(-1, 28 * 28))\n",
    "        decoded = self.decoder(encoded)\n",
    "        return decoded.reshape(-1, 1, 28, 28)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we can see that the model depends on a given `encoding_dim` variable, which defines the size of the latent code. Therefore, we can instantiate our model arbitrarliy with `64` dimensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "0MUxidpyChjX"
   },
   "outputs": [],
   "source": [
    "latent_dim = 64   \n",
    "model = AE(latent_dim) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The only remaining part that we did not discuss yet is what type of _loss_ (defined as $\\mathcal{L}$) we can use to train our model. First, we will simply rely on the _Mean Squared Error_ (MSE) loss, which is defined as\n",
    "\\begin{equation}\n",
    "    \\mathcal{L}_{MSE}(\\hat{\\mathbf{x}}, \\mathbf{x}) = \\mid \\hat{\\mathbf{x}}, \\mathbf{x} \\mid^{2}\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "9I1JlqEIDCI4"
   },
   "outputs": [],
   "source": [
    "# Loss function that we will use\n",
    "loss_fn = torch.nn.MSELoss(reduction='sum')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7oJSeMTroABs"
   },
   "source": [
    "<a id=\"application\"> </a>\n",
    "\n",
    "### Training the model\n",
    "\n",
    "Train the model using `x_train` as both the input and the target. The `encoder` will learn to compress the dataset from 784 dimensions to the latent space, and the `decoder` will learn to reconstruct the original images.\n",
    "."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "h1RI9OfHDBsK"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(5817.4189, grad_fn=<MseLossBackward>)\n",
      "tensor(4374.0566, grad_fn=<MseLossBackward>)\n",
      "tensor(4219.4839, grad_fn=<MseLossBackward>)\n",
      "tensor(4174.4062, grad_fn=<MseLossBackward>)\n",
      "tensor(3791.4062, grad_fn=<MseLossBackward>)\n",
      "tensor(3565.2781, grad_fn=<MseLossBackward>)\n",
      "tensor(3286.8918, grad_fn=<MseLossBackward>)\n",
      "tensor(3004.1448, grad_fn=<MseLossBackward>)\n",
      "tensor(2834.7437, grad_fn=<MseLossBackward>)\n",
      "tensor(2691.8218, grad_fn=<MseLossBackward>)\n",
      "tensor(2746.5903, grad_fn=<MseLossBackward>)\n",
      "tensor(2284.3418, grad_fn=<MseLossBackward>)\n",
      "tensor(2400.9062, grad_fn=<MseLossBackward>)\n",
      "tensor(2347.1150, grad_fn=<MseLossBackward>)\n",
      "tensor(2389.3455, grad_fn=<MseLossBackward>)\n",
      "tensor(2055.0049, grad_fn=<MseLossBackward>)\n",
      "tensor(2046.2859, grad_fn=<MseLossBackward>)\n",
      "tensor(2127.6699, grad_fn=<MseLossBackward>)\n",
      "tensor(2059.9185, grad_fn=<MseLossBackward>)\n",
      "tensor(1946.4250, grad_fn=<MseLossBackward>)\n"
     ]
    }
   ],
   "source": [
    "# Learning rate\n",
    "learning_rate = 1e-4\n",
    "# Optimizer to fit the weights of the network\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
    "for t in range(20):\n",
    "    full_loss = torch.Tensor([0])\n",
    "    # Forward pass: compute predicted y by passing x to the model.\n",
    "    for i, (x, _) in enumerate(train_loader):\n",
    "        y_pred = model(x)\n",
    "        # Compute the loss.\n",
    "        loss = loss_fn(y_pred, x)\n",
    "        # Before the backward pass, zero all of the network gradients\n",
    "        optimizer.zero_grad()\n",
    "        # Backward pass: compute gradient of the loss with respect to parameters\n",
    "        loss.backward()\n",
    "        # Calling the step function to update the parameters\n",
    "        optimizer.step()\n",
    "    print(loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wAM1QBhtoC-n"
   },
   "source": [
    "Now that the model is trained, we can test it by encoding and decoding images from the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "Pbr5WCj7FQUi"
   },
   "outputs": [],
   "source": [
    "encoded_imgs = model.encoder(imgs_test.reshape(-1,28*28))\n",
    "decoded_imgs = model.decoder(encoded_imgs).reshape(-1,28,28).detach().numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By plotting the images, we can see that the model is able to perform an adequate (yet somewhat blurry) reconstruction of the input images. The interesting point is that this reconstruction comes from a code of only `64` dimensions, whereas the original images have `784` dimensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "s4LlDOS6FUA1"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x288 with 20 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "dark"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n = 10\n",
    "plt.figure(figsize=(20, 4))\n",
    "for i in range(n):\n",
    "    # display original\n",
    "    ax = plt.subplot(2, n, i + 1)\n",
    "    plt.imshow(imgs_test[i, 0])\n",
    "    plt.title(\"original\"); plt.gray()\n",
    "    ax.get_xaxis().set_visible(False)\n",
    "    ax.get_yaxis().set_visible(False)\n",
    "    # display reconstruction\n",
    "    ax = plt.subplot(2, n, i + 1 + n)\n",
    "    plt.imshow(decoded_imgs[i])\n",
    "    plt.title(\"reconstructed\"); plt.gray()\n",
    "    ax.get_xaxis().set_visible(False)\n",
    "    ax.get_yaxis().set_visible(False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Improvements\n",
    "\n",
    "Even though this very basic example seems to work, several improvements can be made over the original model. First, we can see that the overall framework does not depend on the exact nature of the `encoder` and `decoder`. \n",
    "\n",
    "***\n",
    "1. We rewrite the original class to accept any type of architecture for these (see code below). \n",
    "2. Fill the missing code to have a new AE model\n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AE(nn.Module):\n",
    "    def __init__(self, encoder, decoder, encoding_dim):\n",
    "        super(AE, self).__init__()\n",
    "        self.latent_dim = encoding_dim\n",
    "        self.encoder = encoder\n",
    "        self.decoder = decoder\n",
    "\n",
    "    def forward(self, x):\n",
    "        encoded = self.encoder(x)\n",
    "        decoded = self.decoder(encoded)\n",
    "        return decoded\n",
    "\n",
    "######################\n",
    "# YOUR CODE GOES HERE\n",
    "######################\n",
    "\n",
    "encoder = ...\n",
    "decoder = ...\n",
    "model = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Second, we only used the train dataset, whereas the use of a validation and test sets allows to ensure that we do not overfit our model.\n",
    "\n",
    "***\n",
    "1. Write a separate train function, that can be called on different sets\n",
    "2. Re-write the training loop to test overfitting\n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "######################\n",
    "# YOUR CODE GOES HERE\n",
    "######################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r4gv6G8PoRQE"
   },
   "source": [
    "## Exercise: Denoising AE\n",
    "\n",
    "Imagine (for the sake of argument), that we choose an encoding dimension which is of same dimensionality as the input one. Then, one huge problem is that nothing prevents the AE from simply learning the _identity_ function (try to imagine why). An autoencoder can also be trained to remove noise from images. This type of _regularization_ prevents the model from learning this degenerate situation.\n",
    "\n",
    "In this exercise, you will need to create your own denoising AE, by relying on a noisy version of the Fashion MNIST dataset (adding random Gaussian noise to each image). You will then train an autoencoder using the noisy image as input, and the original image as the target.\n",
    "\n",
    "Let's reimport the dataset to omit the modifications made earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "uJZ-TcaqDBr5"
   },
   "outputs": [],
   "source": [
    "class GaussianNoise(object):\n",
    "    def __init__(self, mean=0., std=1.):\n",
    "        self.std = std\n",
    "        self.mean = mean\n",
    "        \n",
    "    def __call__(self, tensor):\n",
    "        return tensor + torch.randn(tensor.size()) * self.std + self.mean\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return self.__class__.__name__ + '(mean={0}, std={1})'.format(self.mean, self.std)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aPZl_6P65_8R"
   },
   "source": [
    "Here, we create two new train and test sets by adding random noise to the images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "axSMyxC354fc"
   },
   "outputs": [],
   "source": [
    "# Load the datasets and use our Gaussian noise transform\n",
    "train_valid_dataset = torchvision.datasets.FashionMNIST(root=dataset_dir, train=True, transform=torchvision.transforms.Compose([torchvision.transforms.ToTensor(), GaussianNoise(0., 0.1)]), download=True)\n",
    "train_dataset, valid_dataset = torch.utils.data.dataset.random_split(train_valid_dataset, [nb_train, nb_valid])\n",
    "test_dataset = torchvision.datasets.FashionMNIST(root=dataset_dir, transform=torchvision.transforms.Compose([torchvision.transforms.ToTensor(), GaussianNoise(0., 0.1)]),train=False)\n",
    "# Create loaders\n",
    "train_loader_noisy = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, num_workers=num_threads)\n",
    "valid_loader_noisy = torch.utils.data.DataLoader(dataset=valid_dataset, batch_size=batch_size, shuffle=False, num_workers=num_threads)\n",
    "test_loader_noisy = torch.utils.data.DataLoader(dataset=test_dataset,batch_size=batch_size,shuffle=False,num_workers=num_threads)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wRxHe4XXltNd"
   },
   "source": [
    "Plot the noisy images.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "thKUmbVVCQpt"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x288 with 20 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "dark"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x_test, labels = next(iter(test_loader))\n",
    "x_test_noisy, labels = next(iter(test_loader_noisy))\n",
    "n = 10\n",
    "plt.figure(figsize=(20, 4))\n",
    "for i in range(n):\n",
    "    ax = plt.subplot(2, n, i + 1)\n",
    "    plt.title(\"original\")\n",
    "    plt.imshow(x_test[i].squeeze())\n",
    "    ax.get_xaxis().set_visible(False)\n",
    "    ax.get_yaxis().set_visible(False)\n",
    "    plt.gray()\n",
    "    ax = plt.subplot(2, n, i + 1 + n)\n",
    "    plt.title(\"original + noise\")\n",
    "    plt.imshow(x_test_noisy[i].squeeze())\n",
    "    ax.get_xaxis().set_visible(False)\n",
    "    ax.get_yaxis().set_visible(False)\n",
    "    plt.gray()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Sy9SY8jGl5aP"
   },
   "source": [
    "### Define a convolutional autoencoder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vT_BhZngWMwp"
   },
   "source": [
    "In this example, you will train a convolutional autoencoder using  [Conv2D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Conv2D) layers in the `encoder`, and [Conv2DTranspose](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Conv2DTranspose) layers in the `decoder`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "R5KjoIlYCQko"
   },
   "outputs": [],
   "source": [
    "######################\n",
    "# YOUR CODE GOES HERE\n",
    "######################\n",
    "\n",
    "class DenoisingAE(AE):\n",
    "    def __init__(self):\n",
    "        super(DenoisingAE, self).__init__()\n",
    "        self.encoder = ...    \n",
    "        self.decoder = ...\n",
    "    \n",
    "    def forward(self, x):\n",
    "        encoded = ...\n",
    "        decoded = ...\n",
    "        return decoded\n",
    "\n",
    "autoencoder = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write down the full optimization loop to optimize your denoising auto-encoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "QYKbiDFYCQfj"
   },
   "outputs": [],
   "source": [
    "######################\n",
    "# YOUR CODE GOES HERE\n",
    "######################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "A7-VAuEy_N6M"
   },
   "source": [
    "Plot both the noisy images and the denoised images produced by the autoencoder to check that your implementation is correct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "id": "sfxr9NdBCP_x"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1440x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "######################\n",
    "# YOUR CODE GOES HERE\n",
    "######################\n",
    "encoded_imgs = ...\n",
    "decoded_imgs = ...\n",
    "plt.figure(figsize=(20, 4))\n",
    "for i in range(n):\n",
    "    ...\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### References\n",
    "\n",
    "<a id=\"reference1\"></a>\n",
    "[1] Rezende, Danilo Jimenez, and Shakir Mohamed. \"Variational inference with normalizing flows.\" _arXiv preprint arXiv:1505.05770_ (2015). [link](http://arxiv.org/pdf/1505.05770)\n",
    "\n",
    "[2] Kingma, Diederik P., Tim Salimans, and Max Welling. \"Improving Variational Inference with Inverse Autoregressive Flow.\" _arXiv preprint arXiv:1606.04934_ (2016). [link](https://arxiv.org/abs/1606.04934)\n",
    "\n",
    "[3] Kingma, D. P., & Welling, M. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114. (2013). [link](https://arxiv.org/pdf/1312.6114)\n",
    "\n",
    "[4] Rezende, D. J., Mohamed, S., & Wierstra, D. Stochastic backpropagation and approximate inference in deep generative models. arXiv preprint arXiv:1401.4082. (2014). [link](https://arxiv.org/pdf/1401.4082)\n",
    "\n",
    "[5] Gulrajani, I., Kumar, K., Ahmed, F., Taiga, A. A., Visin, F., Vazquez, D., & Courville, A. (2016). Pixelvae: A latent variable model for natural images. arXiv preprint arXiv:1611.05013. [link](https://arxiv.org/pdf/1611.05013)\n",
    "\n",
    "[6] Van den Oord, A., & Vinyals, O. (2017). Neural discrete representation learning. In NIPS 2017 (pp. 6306-6315). [link](http://papers.nips.cc/paper/7210-neural-discrete-representation-learning.pdf)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "TensorFlow_3_Autoencoder_Dimensionality_Reduction.ipynb",
   "provenance": [],
   "toc_visible": true,
   "version": "0.3.2"
  },
  "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.6"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}