Variational Autoencoder.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "74KEu1L8OnLq"
   },
   "source": [
    "# Variational Autoencoder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "r94_BRA-OnLr"
   },
   "source": [
    "In this assignment, we will build Variational Autoencoder, train it on MNIST dataset, and play with its architecture and hyperparameters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GmV9OxiIOnL7"
   },
   "source": [
    "Variational Autoencoder is a probabilistic model of data based on a continuous mixture of distributions. Here we will apply VAE to binary MNIST images (each pixel is either black or white). To better model binary data we will use a continuous mixture of binomial distributions: $p(x \\mid w) = \\int p(x \\mid t, w) p(t) dt$, where the prior distribution on the latent code $t$ is standard normal $p(t) = \\mathcal{N}(0, I)$, but probability that $(i, j)$-th pixel is black equals to $(i, j)$-th output of the decoder neural detwork: $p(x_{ij} \\mid t, w) = \\text{decoder}(t, w)_{ij}$.\n",
    "\n",
    "To train this model we would like to the maximize marginal log-likelihood of our dataset $\\max_w \\log p(X \\mid w)$, which is very hard to do computationally. Instead, we try to use EM to maximize the Variational Lower Bound w.r.t. both the original parameters $w$ and variational distribution $q$ which is defined as an encoder neural network with weights $\\phi$ taking an input image $x$ and outputs the parameters of the gaussian distribution for $q$. Given $q(t \\mid x, \\phi)$ we will try to maximize Variational Lower Bound $ \\mathcal{L}(w, \\phi)$ w.r.t. ${w, \\phi}$. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{align*}\n",
    "\\text{max}_{w, \\phi}\\mathcal{L}(w, \\phi) =&\\\\\n",
    "=& \\sum_i \\mathbb{E}_{q_i} \\log \\frac{p(x_i\\mid t_i, w, \\phi)p(t_i)}{q_i(t_i)}\\\\\n",
    "=& \\sum_i \\mathbb{E}_{q_i} \\log p(x_i\\mid t_i, w, \\phi) + \n",
    "\\mathbb{E}_{q_i}\\log \\frac{p(t_i)}{q_i(t_i)}\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second term is $-\\mathcal{KL}(q_i(t_i)\\mid\\mid p(t_i))$ which acts as reqularizer. Also, $q_i(t_i)$ is an approximate of the true posterior of the latent variable $p(t_i| x_i, w)$. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\mathcal{KL}(q_i(t_i)\\mid\\mid p(t_i))$ can be analytically calculated, and is equal to: \n",
    "$$\\sum_j\\Big(-\\log \\sigma_j(t_i) + \\frac{\\sigma_j^2(t_i) + \\mu_j^2(t_i) - 1}{2}\\Big)$$\n",
    "where $\\mu(t_i)=(\\mu_j(t_i))$ and $\\sigma(t_i)=(\\sigma_j(t_i))$ are the mean and variance vector for the ditribution of latent variable $t_i$.\n",
    "They are provided by the encoder and therefore, dependent on $\\phi$. However, their gradient is easily hangled by a differentiable programming platform such as TensorFlow. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at the gradient of first term which depends on $w$ and $\\phi$. With respect to $w$, we have \n",
    "\\begin{align*}\n",
    "\\bigtriangledown_w\\;\\mathbb{E}_{q_i} \\log p(x_i\\mid t_i, w) \\\\\n",
    "= &\\int q(t_i|x_i, \\phi)\\bigtriangledown_w\\log p(x_i\\mid t_i, w)dt_i\\\\\n",
    "= \\,& \\mathbb{E}_{q_i}\\bigtriangledown_w\\log p(x_i\\mid t_i, w)\\\\\n",
    "\\approx& \\bigtriangledown_w\\log p(x_i\\mid \\hat t_i, w)\n",
    "\\end{align*}\n",
    "where $\\hat t_i$ should be sampled from the posterior distribution $q(t_i|x_i, \\phi)$. Note that $\\bigtriangledown_w\\log p(x_i\\mid \\hat t_i, w)$ is an unbiased approximation of the exact expression. Therefore, the gradient w.r.t. $w$ will be applied on $\\log p(x_i\\mid t_i, w)$ where $t_i$ is sampled."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The gradient with respect to $\\phi$ is more complicated but using a reparametrization, it would flow nicely:\n",
    "\\begin{align*}\n",
    "\\bigtriangledown_\\phi\\;\\mathbb{E}_{q_i} \\log p(x_i\\mid t_i, w)\n",
    "= & \\bigtriangledown_\\phi\\ \\int q(t_i|x_i, \\phi)\\log p(x_i\\mid t_i, w)dt_i\\\\\n",
    "\\end{align*}\n",
    "But now both terms inside the integral depend on $\\phi$ especially, in a more comlicated way in the case of $\\log p(x_i\\mid t_i, w)$ because of $t_i$. The trick to simplfy gradient calulations is to consider $t_i = \\varepsilon_i\\odot s_i + m_i = g(\\varepsilon_i, x_i, \\phi)$ where $\\varepsilon_i \\sim  \\mathcal{N}(0, I)$ while $\\mathcal{N}(m_i, \\text{diag}(s^2_i))$ was distribution of $t_i$. Given that, we get\n",
    "\\begin{align*}\n",
    "\\bigtriangledown_\\phi\\;\\mathbb{E}_{q_i} \\log p(x_i\\mid t_i, w)\n",
    "= & \\bigtriangledown_\\phi\\;\\mathbb{E}_{p(\\varepsilon_i)} \\log p(x_i\\mid g(\\varepsilon_i, x_i, \\phi), w)\n",
    "\\end{align*}\n",
    "which is again reduced to the derivative of $\\log p(x_i\\mid g(\\varepsilon_i, x_i, \\phi), w)$ with $\\varepsilon_i$ sampled from the standard normal distribution. This is necessary to understand how to implement our loss function for training the model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So overall our model looks as follows: encoder takes an image $x$, produces a distribution over latent codes $q(t \\mid x)$ which should approximate the posterior distribution $p(t \\mid x)$ (at least after training), samples a point from this distribution $\\widehat{t} \\sim q(t \\mid x, \\phi)$, and finally feeds it into a decoder that outputs a distribution over images.\n",
    "\n",
    "![](https://github.com/hse-aml/bayesian-methods-for-ml/blob/master/week5/VAE.png?raw=1)\n",
    "\n",
    "In the lecture, we also discussed that variational lower bound has an expected value inside which we are going to approximate with sampling. But it is not trivial since we need to differentiate through this approximation. However, we learned about _reparametrization trick_ which suggests instead of sampling from distribution $\\widehat{t} \\sim q(t \\mid x, \\phi)$ sample from a distribution which doesn't depend on any parameters, e.g. standard normal, and then deterministically transform this sample to the desired one: $\\varepsilon \\sim \\mathcal{N}(0, I); ~~\\widehat{t} = m(x, \\phi) + \\varepsilon \\sigma(x, \\phi)$. This way we don't have to worry about our stochastic gradient being biased and can straightforwardly differentiate our loss w.r.t. all the parameters while treating the current sample $\\varepsilon$ as constant.\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So let's get started to implement VAE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "H-hJ6_wBOnLz"
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.keras import layers\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loss "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Expectation-Maximization, Variational Lower Bound VLB which is typically a negative number has to be maximized. For convenience, we will **minimize** the **negated** of VLB (which will be a positive number) instead of maximizing VLB itself. \n",
    "\n",
    "To do that, we need a stochastic estimate of VLB: \n",
    "$$\\text{VLB} = \\sum_{i=1}^N \\text{VLB}_i \\approx \\frac{N}{M}\\sum_{i_s}^M \\text{VLB}_{i_s}$$\n",
    "where $N$ is the dataset size, $\\text{VLB}_i$ is the term of VLB corresponding to the $i$-th object, and $M$ is the mini-batch size. But instead of this stochastic estimate of the full VLB we will use an estimate of the negated VLB normalized by the dataset size, i.e. the function below returns the average across the mini-batch $-\\frac{1}{M}\\sum_{i_s}^M \\text{VLB}_{i_s}$. People usually optimize the normalized version of VLB since it doesn't depend on the dataset - we can write VLB function once and use it for different datasets - the dataset size won't affect the learning rate too much. We define it based in our calculations above. This is our loss function used to train our model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vlb_binomial(model, x):\n",
    "    \"\"\"Returns the value of negative Variational Lower Bound\n",
    "       x: (batch_size x number_of_pixels) matrix with one image per row with zeros and ones\n",
    "    Returns:\n",
    "        A scalar tf.Tensor (averaged across the batch), - VLB\n",
    "    \"\"\"\n",
    "    t_mean, t_log_var = model.encoder(x)\n",
    "    x_decoded_mean = model(x)\n",
    "        \n",
    "    vlb = tf.reduce_mean(tf.reduce_sum(x * tf.math.log(x_decoded_mean + 1e-6) +\\\n",
    "            (1-x)*tf.math.log(1-x_decoded_mean + 1e-6), axis=1) +\\\n",
    "            tf.reduce_sum(0.5 * (t_log_var - tf.exp(t_log_var) - tf.math.pow(t_mean, 2.0) + 1.0 ), axis=1))\n",
    "    \n",
    "    return -vlb\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JIajOY9bOnMK"
   },
   "source": [
    "# Encoder - Decoder Net"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to built our encoder-decoder network. To do this we use the Functional API in TensorFlow, Keras, to implement the layer combined with obeject oriented aproach to wrap the parts into a final model. We choose this approach as we will need to use the structure agian but with minimal modification. I tried my best to do that but there could be an even better way to do this. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's begin with making a Keras layer from our *sampling* function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Sampling(layers.Layer):\n",
    "  \"\"\"Uses (t_mean, t_log_var) to sample t.\"\"\"\n",
    "\n",
    "  def call(self, inputs):\n",
    "    t_mean, t_log_var = inputs\n",
    "    eps = tf.random.normal(shape=tf.shape(t_mean), mean=0.0, stddev=1.0, \n",
    "                       dtype=tf.float32, seed=None, name=\"eps\")\n",
    "    t = t_mean + eps * tf.exp(t_log_var * 0.5)\n",
    "    return t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now create our encoder and decoder model using Functional API defind as functions so we can reuse them later easily."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 100\n",
    "original_dim = 784\n",
    "intermediate_dim = 256\n",
    "latent_dim = 10\n",
    "\n",
    "\n",
    "def create_encoder(input_dim):\n",
    "    \"\"\"Create encoder model\"\"\"\n",
    "    \n",
    "    original_inputs = layers.Input(shape=(input_dim,), name='encoder_input')\n",
    "    x = layers.Dense(intermediate_dim, activation='relu')(original_inputs)\n",
    "    t_mean = layers.Dense(latent_dim, name='t_mean')(x)\n",
    "    t_log_var = layers.Dense(latent_dim, name='t_log_var')(x)\n",
    "    encoder = tf.keras.Model(inputs=original_inputs, \n",
    "                             outputs=[t_mean, t_log_var], \n",
    "                             name='encoder')\n",
    "    return encoder\n",
    "\n",
    "encoder = create_encoder(original_dim)\n",
    "\n",
    "# Define decoder model.\n",
    "def create_decoder(input_dim):\n",
    "    latent_inputs = layers.Input(shape=(input_dim,), name='decoder_input')\n",
    "    x = layers.Dense(intermediate_dim, activation='relu')(latent_inputs)\n",
    "    outputs = layers.Dense(original_dim, activation='sigmoid')(x)\n",
    "    decoder = tf.keras.Model(inputs=latent_inputs, outputs=outputs, name='decoder')\n",
    "    return decoder\n",
    "\n",
    "decoder = create_decoder(latent_dim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now wrap around our encoder and decoder into the final model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class VAE(tf.keras.Model):\n",
    "    \"\"\"Combines the encoder and decoder into an end-to-end model for training.\"\"\"\n",
    "\n",
    "    def __init__(self, name='autoencoder', **kwargs):\n",
    "        super(VAE, self).__init__(name=name, **kwargs)\n",
    "        self.encoder = encoder\n",
    "        self.decoder = decoder\n",
    "\n",
    "    def call(self, inputs):\n",
    "        t = self.encoder(inputs)\n",
    "        t = Sampling()(t)\n",
    "        x_decoded_mean = self.decoder(t) \n",
    "        return x_decoded_mean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create an instance of the model to be trained:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "vae = VAE()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nktDqnapOnMS"
   },
   "source": [
    "## Training the model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we pass the loss function defined above to GradientTape() API for its gradient to be calculated: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "OwynsmjaOnL-"
   },
   "outputs": [],
   "source": [
    "optimizer = tf.keras.optimizers.RMSprop(\n",
    "    learning_rate=0.001, name='RMSprop')\n",
    "\n",
    "def compute_apply_gradients(model, x, optimizer):\n",
    "    with tf.GradientTape() as tape:\n",
    "        loss = vlb_binomial(model, x)\n",
    "    gradients = tape.gradient(loss, model.trainable_variables)\n",
    "    optimizer.apply_gradients(zip(gradients, model.trainable_variables))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SVJQG9l4OnMY"
   },
   "source": [
    "#### Load and prepare the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's load the MNIST data. Each MNIST image is originally a vector of 784 integers, each of which is between 0-255 and represents the intensity of a pixel. We normalized the data to be between 0-1. We categorize the labels in one-hot encoding format which will be use later for the second model. We do not need it for VAE model as we are beuilding a generative model. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()\n",
    "\n",
    "# One hot encoding.\n",
    "y_train = tf.keras.utils.to_categorical(y_train)\n",
    "y_test = tf.keras.utils.to_categorical(y_test)\n",
    "\n",
    "\n",
    "x_train = x_train.astype('float32') / 255.\n",
    "x_test = x_test.astype('float32') / 255.\n",
    "x_train = tf.reshape(x_train, (len(x_train), np.prod(x_train.shape[1:])))\n",
    "x_test = tf.reshape(x_test, (len(x_test), np.prod(x_test.shape[1:])))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "EnWfL2xrOnMb"
   },
   "source": [
    "#### Train the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/50: \n",
      "\t loss:175.447388  - test_loss:177.718811\n",
      "Epoch 2/50: \n",
      "\t loss:152.781494  - test_loss:155.871414\n",
      "Epoch 3/50: \n",
      "\t loss:141.218445  - test_loss:144.824203\n",
      "Epoch 4/50: \n",
      "\t loss:136.864166  - test_loss:140.452255\n",
      "Epoch 5/50: \n",
      "\t loss:132.582336  - test_loss:136.134689\n",
      "Epoch 6/50: \n",
      "\t loss:130.714478  - test_loss:133.520386\n",
      "Epoch 7/50: \n",
      "\t loss:127.365471  - test_loss:131.078354\n",
      "Epoch 8/50: \n",
      "\t loss:124.928581  - test_loss:128.928650\n",
      "Epoch 9/50: \n",
      "\t loss:123.565338  - test_loss:128.057953\n",
      "Epoch 10/50: \n",
      "\t loss:122.736526  - test_loss:126.555359\n",
      "Epoch 11/50: \n",
      "\t loss:121.068565  - test_loss:125.580147\n",
      "Epoch 12/50: \n",
      "\t loss:119.724541  - test_loss:125.034653\n",
      "Epoch 13/50: \n",
      "\t loss:119.270515  - test_loss:124.073685\n",
      "Epoch 14/50: \n",
      "\t loss:119.398224  - test_loss:123.345177\n",
      "Epoch 15/50: \n",
      "\t loss:117.495422  - test_loss:122.260048\n",
      "Epoch 16/50: \n",
      "\t loss:116.974617  - test_loss:121.729927\n",
      "Epoch 17/50: \n",
      "\t loss:115.241547  - test_loss:121.238647\n",
      "Epoch 18/50: \n",
      "\t loss:115.650627  - test_loss:121.164726\n",
      "Epoch 19/50: \n",
      "\t loss:115.997429  - test_loss:120.992538\n",
      "Epoch 20/50: \n",
      "\t loss:115.135536  - test_loss:120.777802\n",
      "Epoch 21/50: \n",
      "\t loss:115.072685  - test_loss:120.254372\n",
      "Epoch 22/50: \n",
      "\t loss:114.602089  - test_loss:119.729950\n",
      "Epoch 23/50: \n",
      "\t loss:112.914177  - test_loss:119.075974\n",
      "Epoch 24/50: \n",
      "\t loss:113.750351  - test_loss:119.396576\n",
      "Epoch 25/50: \n",
      "\t loss:112.950783  - test_loss:118.848465\n",
      "Epoch 26/50: \n",
      "\t loss:113.329071  - test_loss:118.693810\n",
      "Epoch 27/50: \n",
      "\t loss:113.134315  - test_loss:118.681763\n",
      "Epoch 28/50: \n",
      "\t loss:111.975143  - test_loss:118.122803\n",
      "Epoch 29/50: \n",
      "\t loss:111.913254  - test_loss:118.313477\n",
      "Epoch 30/50: \n",
      "\t loss:112.312889  - test_loss:117.969116\n",
      "Epoch 31/50: \n",
      "\t loss:111.180763  - test_loss:117.685440\n",
      "Epoch 32/50: \n",
      "\t loss:110.596741  - test_loss:117.377861\n",
      "Epoch 33/50: \n",
      "\t loss:110.908890  - test_loss:117.343140\n",
      "Epoch 34/50: \n",
      "\t loss:110.853142  - test_loss:117.518898\n",
      "Epoch 35/50: \n",
      "\t loss:111.005402  - test_loss:117.270226\n",
      "Epoch 36/50: \n",
      "\t loss:110.694931  - test_loss:117.316200\n",
      "Epoch 37/50: \n",
      "\t loss:110.729774  - test_loss:117.390373\n",
      "Epoch 38/50: \n",
      "\t loss:110.527267  - test_loss:117.091286\n",
      "Epoch 39/50: \n",
      "\t loss:110.663643  - test_loss:117.175728\n",
      "Epoch 40/50: \n",
      "\t loss:109.581406  - test_loss:116.698074\n",
      "Epoch 41/50: \n",
      "\t loss:109.586823  - test_loss:116.673149\n",
      "Epoch 42/50: \n",
      "\t loss:109.024040  - test_loss:116.502113\n",
      "Epoch 43/50: \n",
      "\t loss:109.192917  - test_loss:116.575127\n",
      "Epoch 44/50: \n",
      "\t loss:109.499619  - test_loss:116.324547\n",
      "Epoch 45/50: \n",
      "\t loss:109.118408  - test_loss:116.190750\n",
      "Epoch 46/50: \n",
      "\t loss:109.043839  - test_loss:116.161972\n",
      "Epoch 47/50: \n",
      "\t loss:109.985916  - test_loss:116.906876\n",
      "Epoch 48/50: \n",
      "\t loss:108.134079  - test_loss:116.083054\n",
      "Epoch 49/50: \n",
      "\t loss:108.341141  - test_loss:116.032822\n",
      "Epoch 50/50: \n",
      "\t loss:109.236237  - test_loss:116.673523\n"
     ]
    }
   ],
   "source": [
    "epochs = 50\n",
    "\n",
    "for epoch in range(1, epochs + 1):\n",
    "    for i in range(1, batch_size + 1):\n",
    "        X_batch = x_train[(i-1)*batch_size:i*batch_size]\n",
    "        compute_apply_gradients(vae, X_batch, optimizer)\n",
    "    print('Epoch %d/%d: \\n\\t loss:%f  - test_loss:%f'%(epoch, epochs,\n",
    "                                          tf.keras.backend.eval(vlb_binomial(vae, X_batch)),\n",
    "                                          tf.keras.backend.eval(vlb_binomial(vae, x_test))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "vae.save_weights('./checkpoints/my_checkpoint')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FdjnEbpkOnMf"
   },
   "source": [
    "### Visualize reconstructions for train and validation data\n",
    "In the picture below the reconstruction ability of the network is shown on training and validation data. In each of the two images, the left column is MNIST images and the right column is the corresponding image after passing through autoencoder (or more precisely the mean of the binomial distribution over the output images).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(10, 10))\n",
    "for fid_idx, (data, title) in enumerate(\n",
    "            zip([x_train, x_test], ['Train', 'Validation'])):\n",
    "    n = 10  # figure with 10 x 2 digits\n",
    "    digit_size = 28\n",
    "    figure = np.zeros((digit_size * n, digit_size * 2))\n",
    "    decoded = tf.keras.backend.eval(vae(data[:batch_size, :]))\n",
    "    for i in range(10):\n",
    "        figure[i * digit_size: (i + 1) * digit_size,\n",
    "               :digit_size] = tf.keras.backend.eval(tf.reshape(data[i, :], (digit_size, digit_size)))\n",
    "        figure[i * digit_size: (i + 1) * digit_size,\n",
    "               digit_size:] = decoded[i, :].reshape(digit_size, digit_size)\n",
    "    ax = fig.add_subplot(1, 2, fid_idx + 1)\n",
    "    ax.imshow(figure, cmap='Greys_r')\n",
    "    ax.set_title(title)\n",
    "    ax.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WEclzA3WOnMk"
   },
   "source": [
    "## Hallucinating new data\n",
    "In the following cell, new sample images are generated from your trained VAE. To do that we sample from the prior distribution $p(t)$ (standard normal) and then from the likelihood $p(x \\mid t)$, which is the output of the decoder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jGLqzZD4OnMm"
   },
   "outputs": [],
   "source": [
    "n_samples = 10 \n",
    "\n",
    "t_sample = tf.keras.backend.random_normal([n_samples,latent_dim],mean=0.0,stddev=1.0,dtype=tf.float32,seed=12)\n",
    "\n",
    "sampled_im_mean = tf.keras.backend.eval(vae.decoder(t_sample))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "for i in range(n_samples):\n",
    "    ax = plt.subplot(n_samples // 5 + 1, 5, i + 1)\n",
    "    plt.imshow(tf.reshape(sampled_im_mean[i, :], [28, 28]), cmap='gray')\n",
    "    ax.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VMuhWEYBOnMt"
   },
   "source": [
    "# Conditional VAE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ly1YYFktOnMu"
   },
   "source": [
    "We can easily modify the above code to obtain Conditional Variational Autoencoder [1]. The idea is very simple: we can pass more information about the samples to the model that makes it easier for the model to generate more accurate samples. To do this, we condition all the distributions on some additional information. In our case, this additional information could be the class label (the digit on the image, from 0 to 9).\n",
    "\n",
    "![](https://github.com/hse-aml/bayesian-methods-for-ml/blob/master/week5/CVAE.png?raw=1)\n",
    "\n",
    "So now both the likelihood and the variational distributions are conditioned on the class label: $p(x \\mid t, \\text{label}, w)$, $q(t \\mid x, \\text{label}, \\phi)$.\n",
    "\n",
    "The only thing we need to do in your code is to concatenate input image $x$ with (one-hot) label of this image to pass into the encoder $q$ and to concatenate latent code $t$ with the same label to pass into the decoder $p$. This is slightly harder to do with convolutional encoder/decoder model.\n",
    "\n",
    "This change would definitely imporove the model as we are giving more information about the type of a sample to the model. \n",
    "\n",
    "[1] Sohn, Kihyuk, Honglak Lee, and Xinchen Yan. “Learning Structured Output Representation using Deep Conditional Generative Models.” Advances in Neural Information Processing Systems. 2015."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can easily reuse the code for encoder-decoder but need a slight mod for the model to take the concatenation of the images and their labels as input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoder = create_encoder(original_dim + 10)\n",
    "decoder = create_decoder(latent_dim + 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And, the conditional variational autoencoder model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CVAE(tf.keras.Model):\n",
    "    \"\"\"Combines the encoder and decoder into an end-to-end model for training.\"\"\"\n",
    "\n",
    "    def __init__(self, name='autoencoder', **kwargs):\n",
    "        super(CVAE, self).__init__(name=name, **kwargs)\n",
    "        self.encoder = encoder\n",
    "        self.decoder = decoder\n",
    "\n",
    "    def call(self, inputs):\n",
    "        x, labels = inputs\n",
    "        t = layers.concatenate([x, labels], axis=1)\n",
    "        t = self.encoder(t)\n",
    "        t = Sampling()(t)\n",
    "        t = layers.concatenate([t, labels], axis=1)\n",
    "        x_decoded_mean = self.decoder(t)\n",
    "        return x_decoded_mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "cvae = CVAE()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We add a one-line code to the loss function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cvlb_binomial(model, x):\n",
    "    \n",
    "    y = tf.keras.backend.concatenate(x, axis=1)\n",
    "    t_mean, t_log_var = model.encoder(y)\n",
    "    x_decoded_mean = model(x)\n",
    "        \n",
    "    vlb = tf.reduce_mean(tf.reduce_sum(x[0] * tf.math.log(x_decoded_mean + 1e-6) +\\\n",
    "            (1-x[0])*tf.math.log(1-x_decoded_mean + 1e-6), axis=1) +\\\n",
    "            tf.reduce_sum(0.5 * (t_log_var - tf.exp(t_log_var) - tf.math.pow(t_mean, 2.0) + 1.0 ), axis=1))\n",
    "    \n",
    "    return -vlb\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_apply_gradients(model, x, optimizer):\n",
    "    with tf.GradientTape() as tape:\n",
    "        loss = cvlb_binomial(model, x)\n",
    "    gradients = tape.gradient(loss, model.trainable_variables)\n",
    "    optimizer.apply_gradients(zip(gradients, model.trainable_variables))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/50: \n",
      "\t loss:133.675583  - test_loss:136.307495\n",
      "Epoch 2/50: \n",
      "\t loss:127.877884  - test_loss:132.039337\n",
      "Epoch 3/50: \n",
      "\t loss:125.633469  - test_loss:129.899368\n",
      "Epoch 4/50: \n",
      "\t loss:122.403328  - test_loss:127.043228\n",
      "Epoch 5/50: \n",
      "\t loss:121.324707  - test_loss:125.626816\n",
      "Epoch 6/50: \n",
      "\t loss:119.545937  - test_loss:125.114059\n",
      "Epoch 7/50: \n",
      "\t loss:118.103584  - test_loss:122.498489\n",
      "Epoch 8/50: \n",
      "\t loss:116.838661  - test_loss:121.197075\n",
      "Epoch 9/50: \n",
      "\t loss:116.612625  - test_loss:121.929649\n",
      "Epoch 10/50: \n",
      "\t loss:116.329895  - test_loss:120.733948\n",
      "Epoch 11/50: \n",
      "\t loss:114.462463  - test_loss:119.896912\n",
      "Epoch 12/50: \n",
      "\t loss:114.239326  - test_loss:118.669472\n",
      "Epoch 13/50: \n",
      "\t loss:112.326385  - test_loss:118.256363\n",
      "Epoch 14/50: \n",
      "\t loss:112.066261  - test_loss:117.546761\n",
      "Epoch 15/50: \n",
      "\t loss:111.633415  - test_loss:116.976372\n",
      "Epoch 16/50: \n",
      "\t loss:111.464806  - test_loss:116.348213\n",
      "Epoch 17/50: \n",
      "\t loss:110.365829  - test_loss:116.336975\n",
      "Epoch 18/50: \n",
      "\t loss:110.012962  - test_loss:115.358528\n",
      "Epoch 19/50: \n",
      "\t loss:110.392570  - test_loss:115.319252\n",
      "Epoch 20/50: \n",
      "\t loss:109.659317  - test_loss:115.098778\n",
      "Epoch 21/50: \n",
      "\t loss:108.807693  - test_loss:114.112686\n",
      "Epoch 22/50: \n",
      "\t loss:109.499657  - test_loss:115.007225\n",
      "Epoch 23/50: \n",
      "\t loss:108.168831  - test_loss:114.264175\n",
      "Epoch 24/50: \n",
      "\t loss:108.123680  - test_loss:114.259773\n",
      "Epoch 25/50: \n",
      "\t loss:108.802467  - test_loss:113.759300\n",
      "Epoch 26/50: \n",
      "\t loss:107.525780  - test_loss:113.595154\n",
      "Epoch 27/50: \n",
      "\t loss:106.514717  - test_loss:112.768112\n",
      "Epoch 28/50: \n",
      "\t loss:106.357513  - test_loss:112.736664\n",
      "Epoch 29/50: \n",
      "\t loss:105.967087  - test_loss:112.474297\n",
      "Epoch 30/50: \n",
      "\t loss:105.170517  - test_loss:112.293503\n",
      "Epoch 31/50: \n",
      "\t loss:105.460548  - test_loss:112.468575\n",
      "Epoch 32/50: \n",
      "\t loss:107.120087  - test_loss:113.254372\n",
      "Epoch 33/50: \n",
      "\t loss:105.744675  - test_loss:112.334290\n",
      "Epoch 34/50: \n",
      "\t loss:104.838348  - test_loss:111.893997\n",
      "Epoch 35/50: \n",
      "\t loss:104.748047  - test_loss:111.362564\n",
      "Epoch 36/50: \n",
      "\t loss:104.255539  - test_loss:111.454887\n",
      "Epoch 37/50: \n",
      "\t loss:104.968681  - test_loss:111.438164\n",
      "Epoch 38/50: \n",
      "\t loss:103.943703  - test_loss:111.386078\n",
      "Epoch 39/50: \n",
      "\t loss:104.579704  - test_loss:111.416603\n",
      "Epoch 40/50: \n",
      "\t loss:104.478378  - test_loss:111.300323\n",
      "Epoch 41/50: \n",
      "\t loss:105.019844  - test_loss:111.420197\n",
      "Epoch 42/50: \n",
      "\t loss:104.106133  - test_loss:110.985161\n",
      "Epoch 43/50: \n",
      "\t loss:103.135323  - test_loss:110.769928\n",
      "Epoch 44/50: \n",
      "\t loss:103.782097  - test_loss:111.720825\n",
      "Epoch 45/50: \n",
      "\t loss:103.711037  - test_loss:111.030540\n",
      "Epoch 46/50: \n",
      "\t loss:103.405411  - test_loss:110.622223\n",
      "Epoch 47/50: \n",
      "\t loss:103.614738  - test_loss:110.473251\n",
      "Epoch 48/50: \n",
      "\t loss:103.116699  - test_loss:110.299065\n",
      "Epoch 49/50: \n",
      "\t loss:103.746033  - test_loss:110.891014\n",
      "Epoch 50/50: \n",
      "\t loss:102.809807  - test_loss:110.149284\n"
     ]
    }
   ],
   "source": [
    "epochs = 50\n",
    "\n",
    "for epoch in range(1, epochs + 1):\n",
    "    for i in range(1, batch_size + 1):\n",
    "        X_batch = x_train[(i-1)*batch_size:i*batch_size]\n",
    "        y_batch = y_train[(i-1)*batch_size:i*batch_size]\n",
    "        compute_apply_gradients(cvae, [X_batch, y_batch], optimizer)\n",
    "    print('Epoch %d/%d: \\n\\t loss:%f  - test_loss:%f'%(epoch, epochs,\n",
    "          tf.keras.backend.eval(cvlb_binomial(cvae,[X_batch, y_batch])),\n",
    "          tf.keras.backend.eval(cvlb_binomial(cvae,[x_test, y_test]))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(10, 10))\n",
    "for fid_idx, (x_data, y_data, title) in enumerate(\n",
    "            zip([x_train, x_test], [y_train, y_test], ['Train', 'Validation'])):\n",
    "    n = 10  # figure with 10 x 2 digits\n",
    "    digit_size = 28\n",
    "    figure = np.zeros((digit_size * n, digit_size * 2))\n",
    "    decoded = tf.keras.backend.eval(cvae([x_data[:batch_size, :], \n",
    "                                     y_data[:batch_size, :]]))\n",
    "    \n",
    "    for i in range(10):\n",
    "        figure[i * digit_size: (i + 1) * digit_size,\n",
    "               :digit_size] = tf.keras.backend.eval(tf.reshape(x_data[i, :],(digit_size, digit_size)))\n",
    "        figure[i * digit_size: (i + 1) * digit_size,\n",
    "               digit_size:] = decoded[i, :].reshape(digit_size, digit_size)\n",
    "    ax = fig.add_subplot(1, 2, fid_idx + 1)\n",
    "    ax.imshow(figure, cmap='Greys_r')\n",
    "    ax.set_title(title)\n",
    "    ax.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Prepare one hot labels of form\n",
    "#   0 0 0 0 0 1 1 1 1 1 2 2 2 2 2 ...\n",
    "# to sample five zeros, five ones, etc\n",
    "curr_labels = np.eye(10)\n",
    "curr_labels = np.repeat(curr_labels, 5, axis=0)  # Its shape is 50 x 10.\n",
    "\n",
    "curr_labels = tf.convert_to_tensor(curr_labels, dtype=tf.float32)\n",
    "\n",
    "t_sample = tf.keras.backend.random_normal([50,latent_dim], mean=0.0, stddev=1.0, dtype=tf.float32, seed=12)\n",
    "t = layers.concatenate([t_sample, curr_labels], axis=1)\n",
    "\n",
    "cond_sampled_im_mean = tf.keras.backend.eval(cvae.decoder(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 50 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Show the sampled images.\n",
    "plt.figure(figsize=(10, 10))\n",
    "global_idx = 0\n",
    "for digit in range(10):\n",
    "    for _ in range(5):\n",
    "        ax = plt.subplot(10, 5, global_idx + 1)\n",
    "        plt.imshow(cond_sampled_im_mean[global_idx, :].reshape(28, 28), cmap='gray')\n",
    "        ax.axis('off')\n",
    "        global_idx += 1\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way of extension for this work is to modify the code such that it works with the mixture of Gaussian distributions (in contrast to the mixture of Binomial distributions). This allows us to mimic the above experience for full color natural images with more diverse structures such as the ones in CIFAR-10 dataset.\n",
    "Finally, there are better generative model such as GAN for images but the significance of variational autoencoder is not limited to its generative model for images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "celltoolbar": "Raw Cell Format",
  "colab": {
   "collapsed_sections": [],
   "name": "Vae_assignment.ipynb",
   "provenance": [],
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}