bvae_classifier_mnist_v4.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "bvae_classifier_mnist_v4.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "6wEqGHMZtJl-"
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "import torch \n",
        "from torch.autograd import Variable\n",
        "import torch.nn as nn\n",
        "from torch.nn import Conv2d, InstanceNorm2d, ConvTranspose2d\n",
        "from torch import optim \n",
        "import torch.nn.functional as F \n",
        "import torchvision"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iDHyAlu4trKZ"
      },
      "source": [
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pV9vimYctv9v",
        "outputId": "b9884ecb-2e7c-4828-d501-c16cc02fbb42"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/gdrive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dYMHmtg8twjR"
      },
      "source": [
        "# this won't work if the drive is shared with you\n",
        "# solution: right click on the shared folder and select 'add shortcut to my drive'\n",
        "%cd gdrive/My\\ Drive/CS7643_Final_Project"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KQ0CXfbzxBPb"
      },
      "source": [
        "# same definition as defined in beta-vae.ipynb\n",
        "class bVAE(nn.Module):\n",
        "  def __init__(self, latent_dim):\n",
        "    super(bVAE, self).__init__()\n",
        "    self.latent_dim = latent_dim\n",
        "    # Encoder\n",
        "    self.c1 = nn.Conv2d(1, 32, kernel_size = 4, stride = 2, padding = 1)\n",
        "    self.b1 = nn.BatchNorm2d(32)\n",
        "    self.c2 = nn.Conv2d(32, 64, kernel_size = 4, stride = 2, padding = 1)\n",
        "    self.b2 = nn.BatchNorm2d(64)\n",
        "    self.c3 = nn.Conv2d(64, 64, kernel_size = 4, stride = 1, padding = 1)\n",
        "    self.b3 = nn.BatchNorm2d(64)\n",
        "\n",
        "    self.fc1 = nn.Linear(64 * 6 * 6, latent_dim)\n",
        "    self.fc2 = nn.Linear(64 * 6 * 6, latent_dim)\n",
        "\n",
        "    # Decoder\n",
        "    self.fc3 = nn.Linear(latent_dim, 64 * 6 * 6)\n",
        "    self.d1 = nn.ConvTranspose2d(64, 64, kernel_size = 4, stride = 1, padding = 1)\n",
        "    self.db1 = nn.BatchNorm2d(64)\n",
        "    self.d2 = nn.ConvTranspose2d(64, 32, kernel_size = 4, stride = 2, padding = 1)\n",
        "    self.db2 = nn.BatchNorm2d(32)\n",
        "    self.d3 = nn.ConvTranspose2d(32, 1, kernel_size = 4, stride = 2, padding = 1)\n",
        "    self.db3 = nn.BatchNorm2d(1)\n",
        "    self.sigmoid = nn.Sigmoid()\n",
        "  \n",
        "  def encode(self, x):\n",
        "    out = F.relu(self.b1(self.c1(x)))\n",
        "    out = F.relu(self.b2(self.c2(out)))\n",
        "    out = F.relu(self.b3(self.c3(out)))\n",
        "    # Resize from (batch_size, num_classes, w, h) to (batch_size,num_classes*w*h)\n",
        "    out = out.view(out.shape[0], -1)\n",
        "    mu, logvar = F.relu(self.fc1(out)), F.relu(self.fc2(out))\n",
        "    return mu, logvar\n",
        "  \n",
        "  def decode(self, z):\n",
        "    out = F.relu(self.fc3(z))\n",
        "    out = out.view(-1, 64, 6, 6)\n",
        "    out = F.relu(self.db1(self.d1(out)))\n",
        "    out = F.relu(self.db2(self.d2(out)))\n",
        "    return self.sigmoid(self.db3(self.d3(out)))\n",
        "  \n",
        "  def reparameterize(self, mu, logvar):\n",
        "    std = torch.exp(0.5*logvar)\n",
        "    eps = torch.randn_like(std)\n",
        "    return mu + eps*std\n",
        "\n",
        "  def forward(self, x):\n",
        "    mu, logvar = self.encode(x)\n",
        "    z = self.reparameterize(mu, logvar)\n",
        "    return self.decode(z), mu, logvar"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MOnzZq0Nxaqn"
      },
      "source": [
        "pretrained_vae = bVAE(20).eval().to(device)\n",
        "pretrained_vae.load_state_dict(torch.load('bVAE.pt'))\n",
        "\n",
        "for param in pretrained_vae.parameters():\n",
        "  param.requires_grad_(False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mqG9RaDIvpV9"
      },
      "source": [
        "class Decoder_classifier(nn.Module):\n",
        "  def __init__(self):\n",
        "    super(Decoder_classifier, self).__init__()\n",
        "    self.fc1 = nn.Linear(20, 15)\n",
        "    self.fc2 = nn.Linear(15, 10)\n",
        "\n",
        "  \n",
        "  def forward(self, x):\n",
        "    mu, logvar = pretrained_vae.encode(x)\n",
        "    z = pretrained_vae.reparameterize(mu,logvar)\n",
        "    out = F.selu(self.fc1(z))\n",
        "    out = self.fc2(out)\n",
        "    return out"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ahjR_IKy6Chh"
      },
      "source": [
        "def evaluate_model(model, dataloader, criterion = nn.CrossEntropyLoss()):\n",
        "    \"\"\"\n",
        "    Calculates the average loss and accuracy of the model on a dataset\n",
        "    \"\"\"\n",
        "    model.eval() # Notify all layers we're in eval mode instead of training mode\n",
        "    loss, total, correct = 0, 0, 0\n",
        "    n = 0\n",
        "    with torch.no_grad():\n",
        "      for xs, ys in dataloader:\n",
        "          output = model(xs.to(device))\n",
        "          loss += criterion(output, ys.to(device)).item()\n",
        "          _, predictions = torch.max(output.data, 1)\n",
        "          total += ys.size(0)\n",
        "          correct += (predictions == ys.to(device)).sum().item()\n",
        "          n += 1\n",
        "    \n",
        "    print(f'\\nTest loss: {loss / n: .2f} | Test accuracy: {correct / total : .2f}')\n",
        "    return loss / n, 100 * correct / total"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w7uwln3qtTip"
      },
      "source": [
        "batch_size = 128"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qT2yN-Z3vTfy"
      },
      "source": [
        "train_data_loader = torch.utils.data.DataLoader(\n",
        "  torchvision.datasets.MNIST('/files/', train=True, download=True,\n",
        "                             transform=torchvision.transforms.Compose([\n",
        "                               torchvision.transforms.ToTensor(),\n",
        "                               torchvision.transforms.Normalize(\n",
        "                                 (0.1307,), (0.3081,))\n",
        "                             ])),\n",
        "  batch_size=batch_size, shuffle=True)\n",
        "\n",
        "test_data_loader = torch.utils.data.DataLoader(\n",
        "  torchvision.datasets.MNIST('/files/', train=False, download=True,\n",
        "                             transform=torchvision.transforms.Compose([\n",
        "                               torchvision.transforms.ToTensor(),\n",
        "                               torchvision.transforms.Normalize(\n",
        "                                 (0.1307,), (0.3081,))\n",
        "                             ])),\n",
        "  batch_size=batch_size, shuffle=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jclyOocJ1xCS"
      },
      "source": [
        "log_epoch = 10"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "68cCAxge0fP_"
      },
      "source": [
        "classifier = Decoder_classifier().to(device)\n",
        "optimizer = optim.Adam(params = classifier.parameters())\n",
        "criterion = nn.CrossEntropyLoss()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "334Pk98r3Rjw"
      },
      "source": [
        "losses = []\n",
        "test_losses = []\n",
        "epochs = 20"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LyCXxlFH1HYm",
        "outputId": "88527385-4517-4786-86af-41bbdea5b2d2"
      },
      "source": [
        "for epoch in range(1, epochs + 1):\n",
        "  total = 0\n",
        "  n = 0\n",
        "  for x, y in train_data_loader:\n",
        "\n",
        "    optimizer.zero_grad()\n",
        "    \n",
        "    out = classifier(x.to(device))\n",
        "    loss = criterion(out, y.to(device))\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "\n",
        "    total += loss.item()\n",
        "    n += 1\n",
        "  \n",
        "  losses.append(total / n)\n",
        "  test_loss, test_accuracy = evaluate_model(classifier, test_data_loader)\n",
        "  # put model back in train mode after putting it in eval mode\n",
        "  classifier.train()\n",
        "  test_losses.append(test_loss)\n",
        "  \n",
        "  print('Epoch: {}, Avg Loss: {:.4f}'.format(epoch, total / n))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Test loss:  0.30 | Test accuracy:  0.92\n",
            "Epoch: 1, Avg Loss: 1.1552\n",
            "\n",
            "Test loss:  0.20 | Test accuracy:  0.94\n",
            "Epoch: 2, Avg Loss: 0.2421\n",
            "\n",
            "Test loss:  0.18 | Test accuracy:  0.95\n",
            "Epoch: 3, Avg Loss: 0.1983\n",
            "\n",
            "Test loss:  0.17 | Test accuracy:  0.95\n",
            "Epoch: 4, Avg Loss: 0.1834\n",
            "\n",
            "Test loss:  0.16 | Test accuracy:  0.95\n",
            "Epoch: 5, Avg Loss: 0.1737\n",
            "\n",
            "Test loss:  0.15 | Test accuracy:  0.96\n",
            "Epoch: 6, Avg Loss: 0.1650\n",
            "\n",
            "Test loss:  0.15 | Test accuracy:  0.96\n",
            "Epoch: 7, Avg Loss: 0.1584\n",
            "\n",
            "Test loss:  0.14 | Test accuracy:  0.96\n",
            "Epoch: 8, Avg Loss: 0.1535\n",
            "\n",
            "Test loss:  0.14 | Test accuracy:  0.96\n",
            "Epoch: 9, Avg Loss: 0.1493\n",
            "\n",
            "Test loss:  0.14 | Test accuracy:  0.96\n",
            "Epoch: 10, Avg Loss: 0.1455\n",
            "\n",
            "Test loss:  0.14 | Test accuracy:  0.96\n",
            "Epoch: 11, Avg Loss: 0.1422\n",
            "\n",
            "Test loss:  0.13 | Test accuracy:  0.96\n",
            "Epoch: 12, Avg Loss: 0.1398\n",
            "\n",
            "Test loss:  0.13 | Test accuracy:  0.96\n",
            "Epoch: 13, Avg Loss: 0.1379\n",
            "\n",
            "Test loss:  0.13 | Test accuracy:  0.96\n",
            "Epoch: 14, Avg Loss: 0.1351\n",
            "\n",
            "Test loss:  0.12 | Test accuracy:  0.96\n",
            "Epoch: 15, Avg Loss: 0.1340\n",
            "\n",
            "Test loss:  0.13 | Test accuracy:  0.96\n",
            "Epoch: 16, Avg Loss: 0.1320\n",
            "\n",
            "Test loss:  0.12 | Test accuracy:  0.96\n",
            "Epoch: 17, Avg Loss: 0.1304\n",
            "\n",
            "Test loss:  0.13 | Test accuracy:  0.96\n",
            "Epoch: 18, Avg Loss: 0.1278\n",
            "\n",
            "Test loss:  0.13 | Test accuracy:  0.96\n",
            "Epoch: 19, Avg Loss: 0.1279\n",
            "\n",
            "Test loss:  0.12 | Test accuracy:  0.96\n",
            "Epoch: 20, Avg Loss: 0.1269\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 620
        },
        "id": "gaVk2hIx4iqx",
        "outputId": "5660bf16-ac81-4717-f090-5ed50d801cb4"
      },
      "source": [
        "plt.rcParams['figure.figsize'] = [10, 8]\n",
        "plt.rcParams['figure.dpi'] = 90 \n",
        "\n",
        "plt.plot(list(range(1, epochs + 1)), losses, color='blue')\n",
        "plt.plot(list(range(1, epochs + 1)), test_losses, color = 'red')\n",
        "plt.legend(['Train Loss', 'Test Loss'], loc='upper right')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Cross Entropy Loss')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 900x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hrQuLMxX77_T",
        "outputId": "caeb968a-5566-43fe-b313-70ac81f8c86e"
      },
      "source": [
        "evaluate_model(classifier, test_data_loader)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Test loss:  0.12 | Test accuracy:  0.97\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.12124431024812445, 96.63)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xKRzl243_tPD"
      },
      "source": [
        "torch.save(classifier.state_dict(), 'bvae_classifier_mnist_v4.pt')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rWX26N4nAevH"
      },
      "source": [
        "from sklearn.metrics import confusion_matrix\n",
        "\n",
        "def plot_confusion_matrix_mnist(model, dataloader):\n",
        "  preds, labels = torch.Tensor([]).to(device), torch.Tensor([]).to(device)\n",
        "  \n",
        "  with torch.no_grad():\n",
        "    for x_batch, y_batch in dataloader:\n",
        "      out = model(x_batch.to(device))\n",
        "      preds = torch.cat((preds, out), dim = 0)\n",
        "      labels = torch.cat((labels, y_batch.to(device)), dim = 0)\n",
        "  \n",
        "  preds = torch.argmax(preds, dim = 1)\n",
        "\n",
        "  count_matrix = torch.zeros((10, 10)).to(device)\n",
        "  \n",
        "  for pred, label in zip(preds, labels):\n",
        "    count_matrix[int(pred)][int(label)] += 1\n",
        "  \n",
        "  count_matrix = count_matrix / count_matrix.sum(axis = 1)\n",
        "\n",
        "  plt.imshow(count_matrix.cpu(), interpolation='nearest', cmap=plt.cm.Blues)\n",
        "  plt.title('Confusion matrix')\n",
        "  marks = list(range(10))\n",
        "  class_names = [str(x) for x in range(1, 11)]\n",
        "  plt.xlabel('Prediction')\n",
        "  plt.ylabel('Label')\n",
        "  plt.xticks(marks, class_names)\n",
        "  plt.yticks(marks, class_names)\n",
        "\n",
        "  threshold = count_matrix.max() / 2\n",
        "  # label each grid with its count\n",
        "  for i in range(10):\n",
        "    for j in range(10):\n",
        "      plt.text(j, i, format(count_matrix[i][j], '.2f'), ha=\"center\", va=\"center\",\n",
        "                    color=\"white\" if count_matrix[i][j] > threshold else \"black\")\n",
        "\n",
        "  \n",
        "  plt.colorbar()\n",
        "  plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 637
        },
        "id": "J6yKjpJCGrJS",
        "outputId": "57259350-68ce-4b30-88ce-f041163f6b48"
      },
      "source": [
        "plot_confusion_matrix_mnist(classifier, test_data_loader)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 900x720 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}