bvae_classifier_fashionMNIST.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "bvae_classifier_fashionMNIST.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\n",
        "import time"
      ],
      "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": "7952aeaa-8c7f-49f9-e1d5-094d7aa3aaab"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/gdrive; to attempt to forcibly remount, call drive.mount(\"/content/gdrive\", force_remount=True).\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 project 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": [
        "class bVAE(nn.Module):\n",
        "  def __init__(self, latent_dim):\n",
        "    super(bVAE, self).__init__()\n",
        "    self.latent_dim = latent_dim\n",
        "    self.hwdim=6\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 * self.hwdim * self.hwdim, latent_dim)\n",
        "    self.fc2 = nn.Linear(64 * self.hwdim * self.hwdim, latent_dim)\n",
        "\n",
        "    # Decoder\n",
        "    self.fc3 = nn.Linear(latent_dim, 64 * self.hwdim * self.hwdim)\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",
        "    # print(out.shape)\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, self.hwdim, self.hwdim)\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_FashionMNIST.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, 40)\n",
        "    self.fc2 = nn.Linear(40, 40)\n",
        "    self.fc3 = nn.Linear(40, 30)\n",
        "    self.fc4 = nn.Linear(30, 20)\n",
        "    self.fc5 = nn.Linear(20, 10)\n",
        "\n",
        "    self.dropout = nn.Dropout(0.25)\n",
        "  \n",
        "  def forward(self, x):\n",
        "    mu, logvar = pretrained_vae.encode(x)\n",
        "    z = pretrained_vae.reparameterize(mu,logvar)\n",
        "    \n",
        "    out = F.selu(self.fc1(z))\n",
        "    out = F.selu(self.fc2(out))\n",
        "    out = F.selu(self.fc3(out))\n",
        "    out = F.selu(self.fc4(out))\n",
        "    out = self.fc5(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.FashionMNIST('/files/', train=True, download=True,\n",
        "                             transform=torchvision.transforms.Compose([\n",
        "                               torchvision.transforms.Grayscale(num_output_channels=1),\n",
        "                               torchvision.transforms.ToTensor(),\n",
        "                               torchvision.transforms.Normalize(\n",
        "                                 (0.1307,), (0.3081,))\n",
        "                             ])),\n",
        "  batch_size=128, shuffle=True)\n",
        "\n",
        "test_data_loader = torch.utils.data.DataLoader(\n",
        "  torchvision.datasets.FashionMNIST('/files/', train=False, download=True,\n",
        "                             transform=torchvision.transforms.Compose([\n",
        "                               torchvision.transforms.Grayscale(num_output_channels=1),\n",
        "                               torchvision.transforms.ToTensor(),\n",
        "                               torchvision.transforms.Normalize(\n",
        "                                 (0.1307,), (0.3081,))\n",
        "                             ])),\n",
        "  batch_size=128, 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": "5f926dc7-99d6-4c4f-b3f4-17e016c8763f"
      },
      "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.53 | Test accuracy:  0.80\n",
            "Epoch: 1, Avg Loss: 0.6204\n",
            "\n",
            "Test loss:  0.49 | Test accuracy:  0.82\n",
            "Epoch: 2, Avg Loss: 0.4852\n",
            "\n",
            "Test loss:  0.48 | Test accuracy:  0.82\n",
            "Epoch: 3, Avg Loss: 0.4624\n",
            "\n",
            "Test loss:  0.48 | Test accuracy:  0.82\n",
            "Epoch: 4, Avg Loss: 0.4459\n",
            "\n",
            "Test loss:  0.46 | Test accuracy:  0.83\n",
            "Epoch: 5, Avg Loss: 0.4393\n",
            "\n",
            "Test loss:  0.46 | Test accuracy:  0.83\n",
            "Epoch: 6, Avg Loss: 0.4350\n",
            "\n",
            "Test loss:  0.46 | Test accuracy:  0.83\n",
            "Epoch: 7, Avg Loss: 0.4279\n",
            "\n",
            "Test loss:  0.46 | Test accuracy:  0.83\n",
            "Epoch: 8, Avg Loss: 0.4255\n",
            "\n",
            "Test loss:  0.46 | Test accuracy:  0.83\n",
            "Epoch: 9, Avg Loss: 0.4228\n",
            "\n",
            "Test loss:  0.47 | Test accuracy:  0.83\n",
            "Epoch: 10, Avg Loss: 0.4202\n",
            "\n",
            "Test loss:  0.46 | Test accuracy:  0.82\n",
            "Epoch: 11, Avg Loss: 0.4157\n",
            "\n",
            "Test loss:  0.45 | Test accuracy:  0.83\n",
            "Epoch: 12, Avg Loss: 0.4146\n",
            "\n",
            "Test loss:  0.46 | Test accuracy:  0.83\n",
            "Epoch: 13, Avg Loss: 0.4127\n",
            "\n",
            "Test loss:  0.45 | Test accuracy:  0.83\n",
            "Epoch: 14, Avg Loss: 0.4110\n",
            "\n",
            "Test loss:  0.45 | Test accuracy:  0.83\n",
            "Epoch: 15, Avg Loss: 0.4096\n",
            "\n",
            "Test loss:  0.45 | Test accuracy:  0.83\n",
            "Epoch: 16, Avg Loss: 0.4096\n",
            "\n",
            "Test loss:  0.45 | Test accuracy:  0.83\n",
            "Epoch: 17, Avg Loss: 0.4098\n",
            "\n",
            "Test loss:  0.44 | Test accuracy:  0.84\n",
            "Epoch: 18, Avg Loss: 0.4076\n",
            "\n",
            "Test loss:  0.45 | Test accuracy:  0.83\n",
            "Epoch: 19, Avg Loss: 0.4056\n",
            "\n",
            "Test loss:  0.45 | Test accuracy:  0.83\n",
            "Epoch: 20, Avg Loss: 0.4034\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 521
        },
        "id": "gaVk2hIx4iqx",
        "outputId": "1a317d2d-dab8-4a7d-95db-d76b08cc68f3"
      },
      "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": "1cad7875-89d0-417c-9b64-1957c85bb024"
      },
      "source": [
        "evaluate_model(classifier, test_data_loader)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Test loss:  0.45 | Test accuracy:  0.83\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.4472171781828609, 83.4)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xKRzl243_tPD"
      },
      "source": [
        "torch.save(classifier.state_dict(), 'bvae_classifier_fashion.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": "c0f04ac0-d86a-4414-fa34-e1d62417a486"
      },
      "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"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m4EdIWPnZZgW",
        "outputId": "f0803800-4262-4096-836e-ca361c38124d"
      },
      "source": [
        "epochs= 10\n",
        "start=time.time()\n",
        "\n",
        "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))\n",
        "\n",
        "end=time.time()\n",
        "print()\n",
        "print(\"training time: \"+str(end-start))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Test loss:  0.45 | Test accuracy:  0.83\n",
            "Epoch: 1, Avg Loss: 0.4041\n",
            "\n",
            "Test loss:  0.45 | Test accuracy:  0.83\n",
            "Epoch: 2, Avg Loss: 0.4016\n",
            "\n",
            "Test loss:  0.44 | Test accuracy:  0.84\n",
            "Epoch: 3, Avg Loss: 0.4007\n",
            "\n",
            "Test loss:  0.44 | Test accuracy:  0.83\n",
            "Epoch: 4, Avg Loss: 0.4003\n",
            "\n",
            "Test loss:  0.45 | Test accuracy:  0.83\n",
            "Epoch: 5, Avg Loss: 0.3987\n",
            "\n",
            "Test loss:  0.45 | Test accuracy:  0.83\n",
            "Epoch: 6, Avg Loss: 0.3992\n",
            "\n",
            "Test loss:  0.44 | Test accuracy:  0.83\n",
            "Epoch: 7, Avg Loss: 0.3980\n",
            "\n",
            "Test loss:  0.44 | Test accuracy:  0.83\n",
            "Epoch: 8, Avg Loss: 0.3966\n",
            "\n",
            "Test loss:  0.45 | Test accuracy:  0.83\n",
            "Epoch: 9, Avg Loss: 0.3952\n",
            "\n",
            "Test loss:  0.44 | Test accuracy:  0.83\n",
            "Epoch: 10, Avg Loss: 0.3960\n",
            "\n",
            "training time: 195.06922364234924\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}