Mnist_VAE_TensorFlow_CNN.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Variational Auto Encoder with TensorFlow(CNN)\n",
        "\n",
        "VAE trained on MNIST dataset. The encoder is a CNN with three convolution layer and 3 maxpools and decoder is a fully-connected NNs."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "6MOW9wUD2Xpd"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import tensorflow as tf\n",
        "import tensorflow_probability as tfp\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Download and load the dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "3-vdOfKY2Xpe"
      },
      "outputs": [],
      "source": [
        "(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Preprocess the input. The images will be rescaled so all the pixels have a value between 0 and 1. This enables the decoder to learn a Bernoulli distribution over the pixel space."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "fJb4WQzU2Xpe"
      },
      "outputs": [],
      "source": [
        "def pre_process_imgs(img):\n",
        "    img = tf.cast(img, tf.float32)\n",
        "    img = img / 255.0\n",
        "    return img"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "create the dataset object and batch the data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "q8BWMTox2Xpf"
      },
      "outputs": [],
      "source": [
        "MNIST_dataset = tf.data.Dataset.from_tensor_slices(x_train)\n",
        "MNIST_dataset = MNIST_dataset.map(pre_process_imgs).batch(128)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Encoder\n",
        "A simple CNN with three convolution layers and three maxpools for downsampling. The mean and variance($log(\\sigma^2)$) of the latent normal distributions each have a dense layer head. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "RT4Ya4Nw2Xpf"
      },
      "outputs": [],
      "source": [
        "class MnistEncoder(tf.keras.layers.Layer):\n",
        "    def __init__(self, filters, latent_dim):\n",
        "        super(MnistEncoder, self).__init__()\n",
        "        self.latent_dim = latent_dim\n",
        "        self.conv1 = tf.keras.layers.Conv2D(filters=filters[0], kernel_size=3, strides=1, padding='same', activation='tanh')\n",
        "        self.maxpool1 = tf.keras.layers.MaxPool2D(pool_size=2, strides=2)\n",
        "        self.conv2 = tf.keras.layers.Conv2D(filters=filters[1], kernel_size=3, strides=1, padding='same', activation='tanh')\n",
        "        self.maxpool2 = tf.keras.layers.MaxPool2D(pool_size=2, strides=2)\n",
        "        self.conv3 = tf.keras.layers.Conv2D(filters=filters[2], kernel_size=3, strides=1, padding='same', activation='tanh')\n",
        "        self.maxpool3 = tf.keras.layers.MaxPool2D(pool_size=2, strides=2)\n",
        "        self.flatten = tf.keras.layers.Flatten()\n",
        "        self.dense_mu = tf.keras.layers.Dense(self.latent_dim, activation=None)\n",
        "        self.dense_logsig2 = tf.keras.layers.Dense(self.latent_dim, activation=None)\n",
        "\n",
        "    def call(self, x):\n",
        "        x = tf.reshape(x, [-1, 28, 28, 1])\n",
        "        x = self.conv1(x)\n",
        "        x = self.maxpool1(x)\n",
        "        x = self.conv2(x)\n",
        "        x = self.maxpool2(x)\n",
        "        x = self.conv3(x)\n",
        "        x = self.maxpool3(x)\n",
        "        x = self.flatten(x)\n",
        "        mu = self.dense_mu(x)\n",
        "        logsig2 = self.dense_logsig2(x)\n",
        "        return mu, tf.exp(logsig2)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Decoder\n",
        "Simple NN with a single hidden layer. Same number of units as the encoder's hidden layer."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "snFTNOeQ2Xpf"
      },
      "outputs": [],
      "source": [
        "class MnistDecoder(tf.keras.layers.Layer):\n",
        "    def __init__(self, hidden_dim, output_dim):\n",
        "        super(MnistDecoder, self).__init__()\n",
        "        self.dense1 = tf.keras.layers.Dense(hidden_dim, activation='tanh')\n",
        "        self.dense2 = tf.keras.layers.Dense(output_dim, activation='sigmoid')\n",
        "\n",
        "    def call(self, x):\n",
        "        x = self.dense1(x)\n",
        "        x = self.dense2(x)\n",
        "        return x"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Complete VAE\n",
        "\n",
        "The VAE minimizes negative of ELBO loss:\n",
        "\n",
        "$$ \\text{ELBO} = \\mathbb{E}_{q_\\phi(z|x)} [\\log p_\\theta(x|z) + \\log p(z) - \\log(q_\\phi(z|x)]. $$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "u1Nu8bmr2Xpg"
      },
      "outputs": [],
      "source": [
        "class MnistVAE(tf.keras.Model):\n",
        "    def __init__(self, filters, hidden_dim, latent_dim, output_dim):\n",
        "        super(MnistVAE, self).__init__()\n",
        "        self.latent_dim = latent_dim\n",
        "        self.encoder = MnistEncoder(filters, latent_dim)\n",
        "        self.decoder = MnistDecoder(hidden_dim, output_dim)\n",
        "\n",
        "    def encode(self, x):\n",
        "        mu, sig2 = self.encoder(x)\n",
        "        return mu, sig2\n",
        "\n",
        "    def sample_latent(self, mu, sig2):\n",
        "        z = tf.random.normal(shape=mu.shape)\n",
        "        return z * tf.sqrt(sig2) + mu\n",
        "\n",
        "    def decode(self, z):\n",
        "        return self.decoder(z)\n",
        "\n",
        "    def call(self, x):\n",
        "        mu, sig2 = self.encode(x)\n",
        "        z = self.sample_latent(mu, sig2)\n",
        "        return self.decode(z)\n",
        "\n",
        "    def elbo_loss(self, x, z, p, mu, sig2):\n",
        "        \"\"\"calculates ELBO loss\n",
        "\n",
        "        Args:\n",
        "            x : input iamges\n",
        "            z : samples from latent space\n",
        "            p : output from decoder\n",
        "            mu : learned means\n",
        "            sig2 : learned variances\n",
        "        \"\"\"\n",
        "\n",
        "        # log_q(z|x) logprobability of z under approximate posterior N(mu, sig)\n",
        "        log_q = tfp.distributions.Normal(loc=mu, scale=tf.sqrt(sig2)).log_prob(z)\n",
        "        log_q = tf.reduce_sum(log_q, axis=1)\n",
        "\n",
        "        # log_p_z(z) log probability of z under prior\n",
        "        log_p_z = tfp.distributions.Normal(loc=tf.constant(0., shape=(x.shape[0], self.latent_dim)), scale=tf.constant(1., shape=(x.shape[0], self.latent_dim))).log_prob(z)\n",
        "        log_p_z = tf.reduce_sum(log_p_z, axis=1)\n",
        "\n",
        "        # log_p(x|z) - conditional probability of data given latents.\n",
        "        log_p = tfp.distributions.Bernoulli(probs=p).log_prob(tf.reshape(x, shape=(x.shape[0], -1)))\n",
        "        log_p = tf.reduce_sum(log_p, axis=1)\n",
        "        \n",
        "        # log_p_z(z) + log_p(x|z) - log_q(z|x)\n",
        "        return tf.reduce_mean(log_p_z + log_p - log_q)\n",
        "\n",
        "\n",
        "    def train_step(self, x, optimizer):\n",
        "        with tf.GradientTape() as tape:\n",
        "            mu, sig2 = self.encode(x)\n",
        "            z = self.sample_latent(mu, sig2)\n",
        "            p = self.decode(z)\n",
        "            loss = -1 * self.elbo_loss(x, z, p, mu, sig2)\n",
        "        grads = tape.gradient(loss, self.trainable_variables)\n",
        "        optimizer.apply_gradients(zip(grads, self.trainable_variables))\n",
        "        return loss\n",
        "\n",
        "    def train(self, dataset, epochs):\n",
        "        optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)\n",
        "        for epoch in range(epochs):\n",
        "            for batch in dataset:\n",
        "                loss = self.train_step(batch, optimizer)\n",
        "            print(\"Epoch: {}, Loss: {}\".format(epoch, loss))\n",
        "\n",
        "    def visualize_data_space(self, img):\n",
        "        mu, sigma_square = self.encoder(img)\n",
        "        # TODO: Sample 10 z from prior \n",
        "        z = self.sample_latent(mu, sigma_square)\n",
        "\n",
        "        # TODO: For each z, plot p(x|z)\n",
        "        p = self.decoder(z)\n",
        "        x_sample = tfp.distributions.Bernoulli(probs=p).sample()\n",
        "\n",
        "        fig, axs = plt.subplots(1, 2, figsize=(5, 10), dpi=100)\n",
        "\n",
        "        axs[0].imshow(tf.reshape(p, shape=(28, 28)))\n",
        "        axs[1].imshow(tf.reshape(x_sample, shape=(28, 28)))\n",
        "        axs[0].axis('off')\n",
        "        axs[1].axis('off')\n",
        "        plt.tight_layout()\n",
        "        plt.show()\n",
        "\n",
        "    def visualize_latent_space(self, dataset, labels):\n",
        "        \n",
        "        # TODO: Encode the training data self.train_images\n",
        "        mu, _ = self.encoder(dataset)\n",
        "        colors = ['red', 'blue', 'yellow', 'green', 'orange', 'purple', 'cyan', 'magenta', 'black', 'brown']\n",
        "        fig, ax = plt.subplots(1, 1, figsize = (5, 5), dpi = 100)\n",
        "        point_sets = []\n",
        "        for i in range(len(colors)):\n",
        "            inner_list = []\n",
        "            for _ in range(mu.shape[1]):\n",
        "                inner_list.append([])\n",
        "            point_sets.append(inner_list)\n",
        "\n",
        "        for i in range(mu.shape[0]):\n",
        "            label = labels[i]\n",
        "            point_sets[label][0].append(mu[i, 0])\n",
        "            point_sets[label][1].append(mu[i, 1])\n",
        "        \n",
        "        for i in range(len(point_sets)):\n",
        "            ax.scatter(point_sets[i][0], point_sets[i][1], color=colors[i], label=i)\n",
        "        plt.legend()\n",
        "        ax.set_xlabel(r\"$\\mu_1$\")\n",
        "        ax.set_ylabel(r\"$\\mu_2$\")\n",
        "        plt.show()\n",
        "\n",
        "    def interpolate_mu(self, mua, mub, alpha = 0.5):\n",
        "        return alpha*mua + (1-alpha)*mub\n",
        "\n",
        "    def visualize_inter_class_interpolation(self, imgs, labels):\n",
        "        N_data = imgs.shape[0]\n",
        "        fig, axs = plt.subplots(1, 10, figsize=(20, 5), dpi=100)\n",
        "\n",
        "        id_1 = np.random.randint(0, N_data, (1,))[0]\n",
        "        sample_1 = imgs[id_1, ...]\n",
        "        label_1 = labels[id_1]\n",
        "        while True:\n",
        "            id_2 = np.random.randint(0, N_data, (1,))[0]\n",
        "            sample_2 = imgs[id_2, :]\n",
        "            label_2 = labels[id_2]\n",
        "            if label_1 != label_2:\n",
        "                break\n",
        "\n",
        "        mu1, sigma1 = self.encoder(tf.reshape(sample_1, shape=(1, 28, 28)))\n",
        "        mu2, sigma2 = self.encoder(tf.reshape(sample_2, shape=(1, 28, 28)))\n",
        "\n",
        "        for i in range(10):\n",
        "            z = self.interpolate_mu(mu1, mu2, i*0.1)\n",
        "            p = self.decoder(z)\n",
        "            img = tf.reshape(p, shape=(28, 28))\n",
        "            axs[i].imshow(img)\n",
        "            axs[i].set_title(r\"$\\alpha$ = %.1f\" % (0.1*i))\n",
        "            axs[i].axis('off')\n",
        "\n",
        "        plt.tight_layout()\n",
        "        plt.show()\n",
        "\n",
        "    "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Instantiate a `MnistVAE` object to train"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "hQSqoeqv2Xph"
      },
      "outputs": [],
      "source": [
        "test = MnistVAE(filters=[64, 256, 512], hidden_dim=1024, latent_dim=2, output_dim=784)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "training for 200 epochs"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sCiMS31x2Xph",
        "outputId": "69579413-8712-4381-b11a-9b1e092b031e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch: 0, Loss: 198.2141571044922\n",
            "Epoch: 1, Loss: 190.51829528808594\n",
            "Epoch: 2, Loss: 190.26048278808594\n",
            "Epoch: 3, Loss: 186.3338165283203\n",
            "Epoch: 4, Loss: 182.3324737548828\n",
            "Epoch: 5, Loss: 179.7847137451172\n",
            "Epoch: 6, Loss: 176.457275390625\n",
            "Epoch: 7, Loss: 174.16847229003906\n",
            "Epoch: 8, Loss: 171.4991912841797\n",
            "Epoch: 9, Loss: 170.65040588378906\n",
            "Epoch: 10, Loss: 168.95791625976562\n",
            "Epoch: 11, Loss: 168.51351928710938\n",
            "Epoch: 12, Loss: 167.4862823486328\n",
            "Epoch: 13, Loss: 165.5391845703125\n",
            "Epoch: 14, Loss: 165.03282165527344\n",
            "Epoch: 15, Loss: 164.07485961914062\n",
            "Epoch: 16, Loss: 162.97479248046875\n",
            "Epoch: 17, Loss: 162.09031677246094\n",
            "Epoch: 18, Loss: 162.9320526123047\n",
            "Epoch: 19, Loss: 162.1335906982422\n",
            "Epoch: 20, Loss: 160.6643829345703\n",
            "Epoch: 21, Loss: 159.77261352539062\n",
            "Epoch: 22, Loss: 159.29275512695312\n",
            "Epoch: 23, Loss: 158.99510192871094\n",
            "Epoch: 24, Loss: 161.15655517578125\n",
            "Epoch: 25, Loss: 158.08377075195312\n",
            "Epoch: 26, Loss: 157.28065490722656\n",
            "Epoch: 27, Loss: 157.9495086669922\n",
            "Epoch: 28, Loss: 158.64881896972656\n",
            "Epoch: 29, Loss: 157.29150390625\n",
            "Epoch: 30, Loss: 157.57057189941406\n",
            "Epoch: 31, Loss: 157.6591796875\n",
            "Epoch: 32, Loss: 157.02566528320312\n",
            "Epoch: 33, Loss: 157.04254150390625\n",
            "Epoch: 34, Loss: 157.02947998046875\n",
            "Epoch: 35, Loss: 156.9530792236328\n",
            "Epoch: 36, Loss: 156.0481414794922\n",
            "Epoch: 37, Loss: 156.02735900878906\n",
            "Epoch: 38, Loss: 155.54017639160156\n",
            "Epoch: 39, Loss: 155.7105712890625\n",
            "Epoch: 40, Loss: 155.3821258544922\n",
            "Epoch: 41, Loss: 155.63551330566406\n",
            "Epoch: 42, Loss: 155.7854766845703\n",
            "Epoch: 43, Loss: 156.71148681640625\n",
            "Epoch: 44, Loss: 156.62818908691406\n",
            "Epoch: 45, Loss: 154.89566040039062\n",
            "Epoch: 46, Loss: 157.2422332763672\n",
            "Epoch: 47, Loss: 156.2478485107422\n",
            "Epoch: 48, Loss: 155.99208068847656\n",
            "Epoch: 49, Loss: 157.9053497314453\n",
            "Epoch: 50, Loss: 155.18763732910156\n",
            "Epoch: 51, Loss: 153.45091247558594\n",
            "Epoch: 52, Loss: 153.75599670410156\n",
            "Epoch: 53, Loss: 153.8787078857422\n",
            "Epoch: 54, Loss: 155.3721466064453\n",
            "Epoch: 55, Loss: 152.60482788085938\n",
            "Epoch: 56, Loss: 154.03269958496094\n",
            "Epoch: 57, Loss: 152.7007293701172\n",
            "Epoch: 58, Loss: 152.9571533203125\n",
            "Epoch: 59, Loss: 152.5957794189453\n",
            "Epoch: 60, Loss: 152.2290496826172\n",
            "Epoch: 61, Loss: 151.9329833984375\n",
            "Epoch: 62, Loss: 152.9063262939453\n",
            "Epoch: 63, Loss: 152.69496154785156\n",
            "Epoch: 64, Loss: 151.9177703857422\n",
            "Epoch: 65, Loss: 152.29229736328125\n",
            "Epoch: 66, Loss: 151.9596405029297\n",
            "Epoch: 67, Loss: 152.3834686279297\n",
            "Epoch: 68, Loss: 151.54107666015625\n",
            "Epoch: 69, Loss: 151.11988830566406\n",
            "Epoch: 70, Loss: 151.63006591796875\n",
            "Epoch: 71, Loss: 150.9228973388672\n",
            "Epoch: 72, Loss: 151.15228271484375\n",
            "Epoch: 73, Loss: 152.5963134765625\n",
            "Epoch: 74, Loss: 151.3697967529297\n",
            "Epoch: 75, Loss: 150.37489318847656\n",
            "Epoch: 76, Loss: 150.66705322265625\n",
            "Epoch: 77, Loss: 150.7266082763672\n",
            "Epoch: 78, Loss: 152.67930603027344\n",
            "Epoch: 79, Loss: 151.5439910888672\n",
            "Epoch: 80, Loss: 152.92787170410156\n",
            "Epoch: 81, Loss: 150.90089416503906\n",
            "Epoch: 82, Loss: 149.7755889892578\n",
            "Epoch: 83, Loss: 150.67681884765625\n",
            "Epoch: 84, Loss: 150.66567993164062\n",
            "Epoch: 85, Loss: 149.7667694091797\n",
            "Epoch: 86, Loss: 150.15159606933594\n",
            "Epoch: 87, Loss: 149.97055053710938\n",
            "Epoch: 88, Loss: 149.36195373535156\n",
            "Epoch: 89, Loss: 148.84629821777344\n",
            "Epoch: 90, Loss: 150.2608184814453\n",
            "Epoch: 91, Loss: 149.91494750976562\n",
            "Epoch: 92, Loss: 148.63829040527344\n",
            "Epoch: 93, Loss: 148.86529541015625\n",
            "Epoch: 94, Loss: 148.87220764160156\n",
            "Epoch: 95, Loss: 148.9695587158203\n",
            "Epoch: 96, Loss: 149.0105438232422\n",
            "Epoch: 97, Loss: 148.39476013183594\n",
            "Epoch: 98, Loss: 148.09046936035156\n",
            "Epoch: 99, Loss: 148.21336364746094\n",
            "Epoch: 100, Loss: 148.31167602539062\n",
            "Epoch: 101, Loss: 149.1148681640625\n",
            "Epoch: 102, Loss: 148.78880310058594\n",
            "Epoch: 103, Loss: 148.08404541015625\n",
            "Epoch: 104, Loss: 148.31585693359375\n",
            "Epoch: 105, Loss: 147.6730194091797\n",
            "Epoch: 106, Loss: 148.3595733642578\n",
            "Epoch: 107, Loss: 147.7429962158203\n",
            "Epoch: 108, Loss: 148.2195587158203\n",
            "Epoch: 109, Loss: 147.8477325439453\n",
            "Epoch: 110, Loss: 148.80154418945312\n",
            "Epoch: 111, Loss: 147.51072692871094\n",
            "Epoch: 112, Loss: 150.39877319335938\n",
            "Epoch: 113, Loss: 147.0448455810547\n",
            "Epoch: 114, Loss: 147.04830932617188\n",
            "Epoch: 115, Loss: 148.28916931152344\n",
            "Epoch: 116, Loss: 148.2159881591797\n",
            "Epoch: 117, Loss: 147.1190643310547\n",
            "Epoch: 118, Loss: 147.9783477783203\n",
            "Epoch: 119, Loss: 148.16964721679688\n",
            "Epoch: 120, Loss: 147.39056396484375\n",
            "Epoch: 121, Loss: 147.2841033935547\n",
            "Epoch: 122, Loss: 148.8771209716797\n",
            "Epoch: 123, Loss: 148.79452514648438\n",
            "Epoch: 124, Loss: 150.388671875\n",
            "Epoch: 125, Loss: 146.9683380126953\n",
            "Epoch: 126, Loss: 147.09564208984375\n",
            "Epoch: 127, Loss: 146.78436279296875\n",
            "Epoch: 128, Loss: 147.05189514160156\n",
            "Epoch: 129, Loss: 147.16929626464844\n",
            "Epoch: 130, Loss: 146.6986846923828\n",
            "Epoch: 131, Loss: 149.31202697753906\n",
            "Epoch: 132, Loss: 146.7483673095703\n",
            "Epoch: 133, Loss: 147.3944549560547\n",
            "Epoch: 134, Loss: 146.53123474121094\n",
            "Epoch: 135, Loss: 146.41285705566406\n",
            "Epoch: 136, Loss: 146.247802734375\n",
            "Epoch: 137, Loss: 146.5490264892578\n",
            "Epoch: 138, Loss: 147.51295471191406\n",
            "Epoch: 139, Loss: 147.24134826660156\n",
            "Epoch: 140, Loss: 146.76121520996094\n",
            "Epoch: 141, Loss: 146.9093780517578\n",
            "Epoch: 142, Loss: 147.39617919921875\n",
            "Epoch: 143, Loss: 146.38282775878906\n",
            "Epoch: 144, Loss: 145.4785614013672\n",
            "Epoch: 145, Loss: 145.6385955810547\n",
            "Epoch: 146, Loss: 146.5802001953125\n",
            "Epoch: 147, Loss: 145.82997131347656\n",
            "Epoch: 148, Loss: 145.9649200439453\n",
            "Epoch: 149, Loss: 145.2128448486328\n",
            "Epoch: 150, Loss: 145.4602508544922\n",
            "Epoch: 151, Loss: 145.70359802246094\n",
            "Epoch: 152, Loss: 146.67401123046875\n",
            "Epoch: 153, Loss: 146.4893341064453\n",
            "Epoch: 154, Loss: 145.82643127441406\n",
            "Epoch: 155, Loss: 146.4113311767578\n",
            "Epoch: 156, Loss: 145.28082275390625\n",
            "Epoch: 157, Loss: 145.9829559326172\n",
            "Epoch: 158, Loss: 145.19056701660156\n",
            "Epoch: 159, Loss: 146.2156982421875\n",
            "Epoch: 160, Loss: 145.7769012451172\n",
            "Epoch: 161, Loss: 145.6619110107422\n",
            "Epoch: 162, Loss: 145.34706115722656\n",
            "Epoch: 163, Loss: 146.6004638671875\n",
            "Epoch: 164, Loss: 146.6047821044922\n",
            "Epoch: 165, Loss: 145.5055694580078\n",
            "Epoch: 166, Loss: 146.49139404296875\n",
            "Epoch: 167, Loss: 145.02488708496094\n",
            "Epoch: 168, Loss: 146.33279418945312\n",
            "Epoch: 169, Loss: 144.9325408935547\n",
            "Epoch: 170, Loss: 145.27720642089844\n",
            "Epoch: 171, Loss: 144.76914978027344\n",
            "Epoch: 172, Loss: 145.8961944580078\n",
            "Epoch: 173, Loss: 145.3577423095703\n",
            "Epoch: 174, Loss: 145.02061462402344\n",
            "Epoch: 175, Loss: 145.25721740722656\n",
            "Epoch: 176, Loss: 145.24642944335938\n",
            "Epoch: 177, Loss: 145.13182067871094\n",
            "Epoch: 178, Loss: 146.3741912841797\n",
            "Epoch: 179, Loss: 145.28977966308594\n",
            "Epoch: 180, Loss: 145.82073974609375\n",
            "Epoch: 181, Loss: 145.9654998779297\n",
            "Epoch: 182, Loss: 145.3348846435547\n",
            "Epoch: 183, Loss: 145.937255859375\n",
            "Epoch: 184, Loss: 144.47032165527344\n",
            "Epoch: 185, Loss: 144.11338806152344\n",
            "Epoch: 186, Loss: 144.62295532226562\n",
            "Epoch: 187, Loss: 144.7813262939453\n",
            "Epoch: 188, Loss: 144.15008544921875\n",
            "Epoch: 189, Loss: 145.1722412109375\n",
            "Epoch: 190, Loss: 145.26490783691406\n",
            "Epoch: 191, Loss: 146.1428985595703\n",
            "Epoch: 192, Loss: 145.79005432128906\n",
            "Epoch: 193, Loss: 146.3190155029297\n",
            "Epoch: 194, Loss: 145.61891174316406\n",
            "Epoch: 195, Loss: 149.1328582763672\n",
            "Epoch: 196, Loss: 148.2197723388672\n",
            "Epoch: 197, Loss: 144.93223571777344\n",
            "Epoch: 198, Loss: 144.6786651611328\n",
            "Epoch: 199, Loss: 144.65687561035156\n"
          ]
        }
      ],
      "source": [
        "test.train(MNIST_dataset, 200)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Sample from the latent space\n",
        "Left figure shows the probabity distribution (Bernoulli) learned and the right figure shows a sample from this distribution."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 264
        },
        "id": "YFihWRj62Xpi",
        "outputId": "f3b3386e-ba5c-4ca8-8d62-2dca251e264b"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 500x1000 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "test_img = next(iter(MNIST_dataset))[0]\n",
        "test_img = tf.reshape(test_img, shape=(1, 28, 28))\n",
        "test.visualize_data_space(test_img)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Latent space plot\n",
        "A plot of the two dimnesions of the latent space (only the means) and their correspoding labels (numbers)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 458
        },
        "id": "kx0jrIzs2Xpi",
        "outputId": "3059d774-4773-4361-a258-a602c70c33c3"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 500x500 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "imgs = tf.concat([x for x in MNIST_dataset], axis=0) # get all the data back from the batches\n",
        "test.visualize_latent_space(imgs[:10000, ...], y_train)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Interpolation plot\n",
        "Linear interpolation of $\\mu$ values of two different numbers shows how moving across the latent space generates different outputs."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 242
        },
        "id": "CcUXGi0o2Xpi",
        "outputId": "c333af3b-47f5-4705-e3e1-ff75e66a4d68"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 2000x500 with 10 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "test.visualize_inter_class_interpolation(imgs, y_train)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "wMBF7eme2Xpi"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [],
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3.10.6 ('tensorflow')",
      "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.10.6"
    },
    "orig_nbformat": 4,
    "vscode": {
      "interpreter": {
        "hash": "b3e2e258fdf5e2bb186dcc83b9b19b3eff941715d1664da7433e1539ab25aa65"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}