image_gen_variational_autoencoder.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vuI9LoVmpJME"
      },
      "source": [
        "#   Image generatation using variational auto encoder\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SNX3Cp9kpJMJ"
      },
      "outputs": [],
      "source": [
        "%matplotlib inline\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch.utils.data import DataLoader\n",
        "from torchvision.datasets import MNIST\n",
        "import torchvision.transforms as transforms\n",
        "import torchvision.utils\n",
        "import matplotlib.pyplot as plt\n",
        "from tqdm import tqdm\n",
        "import numpy as np\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6sZahnOIVQp6"
      },
      "source": [
        "1) Download the dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cLzeH9QypJMS"
      },
      "outputs": [],
      "source": [
        "\n",
        "\n",
        "train = MNIST(root='./data/MNIST', download=True, train=True, transform=transforms.Compose([\n",
        "    transforms.ToTensor()\n",
        "]))\n",
        "train_loader = DataLoader(train, batch_size=128, shuffle=True)\n",
        "\n",
        "test = MNIST(root='./data/MNIST', download=True, train=False, transform=transforms.Compose([\n",
        "    transforms.ToTensor()\n",
        "]))\n",
        "test_loader = DataLoader(test, batch_size=128, shuffle=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dDdZ3VOFVQp-"
      },
      "source": [
        "2) Define the model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vRGQfF06pJMV"
      },
      "outputs": [],
      "source": [
        "class Encoder(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Encoder, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=4, stride=2, padding=1)\n",
        "        self.conv2 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=4, stride=2, padding=1)\n",
        "        self.conv3 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=4, stride=2, padding=1)\n",
        "        self.fc_mu = nn.Linear(in_features=256*3*3, out_features=2)\n",
        "        self.fc_logvar = nn.Linear(in_features=256*3*3, out_features=2)\n",
        "        self.relu = nn.ReLU()\n",
        "\n",
        "    def forward(self, x):\n",
        "        x =self.relu(self.conv1(x))\n",
        "        x =self.relu(self.conv2(x))\n",
        "        x =self.relu(self.conv3(x))\n",
        "        x =x.view(x.size(0), -1)\n",
        "        x_mu = self.fc_mu(x)\n",
        "        x_logvar = self.fc_logvar(x)\n",
        "        return x_mu, x_logvar\n",
        "\n",
        "class Decoder(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Decoder, self).__init__()\n",
        "        self.fc = nn.Linear(in_features=2, out_features=256*4*4)\n",
        "        self.conv3 = nn.ConvTranspose2d(in_channels=256, out_channels=64*2, kernel_size=4, stride=2, padding=1)\n",
        "        self.conv2 = nn.ConvTranspose2d(in_channels=64*2, out_channels=64, kernel_size=4, stride=2, padding=1)\n",
        "        self.conv1 = nn.ConvTranspose2d(in_channels=64, out_channels=1, kernel_size=4, stride=2, padding=3)\n",
        "        self.relu = nn.ReLU()\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.fc(x)\n",
        "        x = x.view(x.size(0), 256, 4,4)\n",
        "        x = self.relu(self.conv3(x))\n",
        "        x = self.relu(self.conv2(x))\n",
        "        x = torch.sigmoid(self.conv1(x))\n",
        "        return x\n",
        "\n",
        "class VariationalAutoencoder(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(VariationalAutoencoder, self).__init__()\n",
        "        self.encoder = Encoder()\n",
        "        self.decoder = Decoder()\n",
        "\n",
        "    def forward(self, x):\n",
        "        latent_mean, latent_log_variance = self.encoder(x)\n",
        "        latent_representation = self.sample_latent_representation(latent_mean, latent_log_variance)\n",
        "        reconstructed_image = self.decoder(latent_representation)\n",
        "        return reconstructed_image, latent_mean, latent_log_variance\n",
        "\n",
        "    def sample_latent_representation(self, latent_mean, latent_log_variance):\n",
        "        if self.training:\n",
        "            # reparameterization trick\n",
        "            latent_standard_deviation = torch.exp(torch.mul(.5,latent_log_variance))\n",
        "            sample_from_normal_distr = torch.empty_like(latent_standard_deviation).normal_()\n",
        "            return torch.add(torch.mul(sample_from_normal_distr,latent_standard_deviation) , latent_mean)\n",
        "        else:\n",
        "            return latent_mean\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y0Ll9kyCVQqC"
      },
      "source": [
        "3) Define loss for variation auto encoder"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_V2mzKslVQqE"
      },
      "outputs": [],
      "source": [
        "variational_beta = 1\n",
        "def vae_loss(image , reconstructed_image, latent_mean, latent_log_variance):\n",
        "    recontruction_loss = torch.nn.functional.binary_cross_entropy(reconstructed_image.view(-1, 784), image.view(-1, 784), reduction='sum')\n",
        "    kl_divergence_with_normal = torch.mul(-.5, torch.sum(1 + latent_log_variance - torch.pow(latent_mean,2) - torch.exp(latent_log_variance)))\n",
        "    return recontruction_loss + variational_beta * kl_divergence_with_normal\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dG2PmZbwVQqF"
      },
      "source": [
        "4) Create the objects"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "vae = VariationalAutoencoder()\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "vae = vae.to(device)\n",
        "optimizer = torch.optim.Adam(params=vae.parameters(), lr=1e-3 , weight_decay=1e-5)"
      ],
      "metadata": {
        "id": "bxy8DjMTVpFg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "thWTIiChVQqJ"
      },
      "source": [
        "5) Train the Model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 296
        },
        "id": "O5rtCUiTpJMZ",
        "outputId": "ecdde949-0aa0-47b4-bb27-24abd8421e82",
        "scrolled": true
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 10/10 [01:42<00:00, 10.24s/it]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "vae.train()\n",
        "training_loss = []\n",
        "for _ in tqdm(range(10)):\n",
        "    epoch_loss = 0\n",
        "    num_batches = 0\n",
        "    for X, _ in train_loader:\n",
        "        X = X.to(device)\n",
        "        X_reconstructed, X_latent_mean, X_latent_log_variance = vae(X)\n",
        "        loss = vae_loss(X,X_reconstructed , X_latent_mean, X_latent_log_variance)\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        epoch_loss += loss.item()\n",
        "        num_batches += 1\n",
        "    training_loss.append(epoch_loss / num_batches)\n",
        "plt.ion()\n",
        "fig = plt.figure()\n",
        "plt.plot(training_loss)\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4YYgInAjVQqL"
      },
      "source": [
        "6) Validate the model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xJUqHru2pJMf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "46b4189f-8f55-42d0-9cac-a9ed69acbded"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Testing Loss: 18318.383020\n"
          ]
        }
      ],
      "source": [
        "vae.eval()\n",
        "\n",
        "test_loss_avg, num_batches = 0, 0\n",
        "for X, _ in test_loader:\n",
        "    with torch.no_grad():\n",
        "        X = X.to(device)\n",
        "        X_reconstructed, X_latent_mean, X_latent_log_variance = vae(X)\n",
        "        loss = vae_loss( X,X_reconstructed, X_latent_mean, X_latent_log_variance)\n",
        "        test_loss_avg += loss.item()\n",
        "        num_batches += 1\n",
        "\n",
        "test_loss_avg /= num_batches\n",
        "print('Testing Loss: %f' % (test_loss_avg))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QoJ72sezVQqO"
      },
      "source": [
        "7) Sample random image"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Tx_sA6bBpJMk",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 114
        },
        "outputId": "e84d79b7-0908-4b5f-9886-0487212a693c"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x1440 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "vae.eval()\n",
        "plt.ion()\n",
        "\n",
        "def plot(img):\n",
        "    img = img.clamp(0, 1).numpy()\n",
        "    plt.imshow(np.transpose(img, (1, 2, 0)))\n",
        "\n",
        "with torch.no_grad():\n",
        "    random_noise_input = torch.randn(10, 2, device=device)\n",
        "    image_generated_by_decoder = vae.decoder(random_noise_input)\n",
        "    image_generated_by_decoder = image_generated_by_decoder.cpu()\n",
        "    fig, ax = plt.subplots(figsize=(10, 20))\n",
        "    plot(torchvision.utils.make_grid(image_generated_by_decoder.data,10,5))\n",
        "    plt.show()"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": []
    },
    "gpuClass": "standard",
    "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": 0
}