bvae_classifier_quickdraw.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "bvae_classifier_quickdraw.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "6wEqGHMZtJl-"
      },
      "source": [
        "import os\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "import torch \n",
        "from torch import tensor, Tensor\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",
        "from torch.utils.data import Dataset, DataLoader, TensorDataset \n",
        "from torchvision import transforms\n",
        "import torchvision"
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iDHyAlu4trKZ"
      },
      "source": [
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pV9vimYctv9v",
        "outputId": "3f5f4742-5f81-4276-8849-560b33ed4a66"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive')"
      ],
      "execution_count": 3,
      "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 CS7643 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",
        "    # 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.c4 = nn.Conv2d(64, 64, kernel_size = 3, stride = 1, padding = 1)\n",
        "    self.b4 = 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",
        "\n",
        "    self.d0 = nn.ConvTranspose2d(64, 64, kernel_size = 3, stride = 1, padding = 1)\n",
        "    self.db0 = nn.BatchNorm2d(64)\n",
        "\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",
        "    out = F.relu(self.b4(self.c4(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.db0(self.d0(out)))\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": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MOnzZq0Nxaqn"
      },
      "source": [
        "pretrained_vae = bVAE(30).eval().to(device)\n",
        "pretrained_vae.load_state_dict(torch.load('bVAE_Quickdraw.pt'))\n",
        "\n",
        "for param in pretrained_vae.parameters():\n",
        "  param.requires_grad_(False)"
      ],
      "execution_count": 7,
      "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(30, 50)\n",
        "    self.bn1 = nn.BatchNorm1d(50)\n",
        "    self.fc2 = nn.Linear(50, 40)\n",
        "    self.bn2 = nn.BatchNorm1d(40)\n",
        "    self.fc3 = nn.Linear(40, 30)\n",
        "    self.bn3 = nn.BatchNorm1d(30)\n",
        "    self.fc4 = nn.Linear(30, 20)\n",
        "    self.bn4 = nn.BatchNorm1d(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.bn1(self.fc1(z)))\n",
        "    out = F.selu(self.bn2(self.fc2(out)))\n",
        "    out = F.selu(self.bn3(self.fc3(out)))\n",
        "    out = F.selu(self.bn4(self.fc4(out)))\n",
        "    out = self.fc5(out)\n",
        "    return out"
      ],
      "execution_count": 106,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ahjR_IKy6Chh"
      },
      "source": [
        "def evaluate_model(model, dataloader, dtype = 'Test', 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",
        "    if dtype != 'Train':\n",
        "      print(f'\\n{dtype} loss: {loss / n: .2f} | {dtype} accuracy: {correct / total : .2f}')\n",
        "    return loss / n, 100 * correct / total"
      ],
      "execution_count": 49,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dy-oejfZ35iR"
      },
      "source": [
        "def load_data(batch_size = 128):\n",
        "    \"\"\"\n",
        "    Returns a list of PyTorch DataLoaders in order of train, validation, and test loaders\n",
        "    \"\"\"\n",
        "    dirnames = ['Train/', 'Validation/', 'Test/']\n",
        "    loaders = []\n",
        "\n",
        "    for dirname in dirnames:\n",
        "        dataname = os.listdir(dirname)[0]\n",
        "        xs = np.load(dirname + dataname)['data'].reshape(-1, 1, 28, 28)\n",
        "        ys = np.load(dirname + dataname)['target']\n",
        "\n",
        "        xs = Tensor(xs).to(device)\n",
        "        ys = tensor(ys, dtype = torch.long).to(device)\n",
        "\n",
        "        xs /= 255\n",
        "        mu = torch.mean(xs, dim = (0, 2, 3))\n",
        "        std = torch.std(xs, dim = (0, 2, 3))\n",
        "\n",
        "        transform = transforms.Compose([transforms.Normalize((mu,), (std,))])\n",
        "        xs = transform(xs)\n",
        "\n",
        "        print(f'Loading {dataname} into Pytorch Dataloader ... Xs shape: {xs.shape}, Ys shape: {ys.shape}')\n",
        "        loaders.append(DataLoader(TensorDataset(xs, ys), batch_size = batch_size, shuffle=True))\n",
        "    \n",
        "    return loaders"
      ],
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NSueF7Ei36J9"
      },
      "source": [
        "classes = ['tree.npy', 't-shirt.npy', 'ice cream.npy', 'fish.npy', 'face.npy', 'car.npy', 'bowtie.npy', 'apple.npy', 'flamingo.npy', 'sheep.npy']"
      ],
      "execution_count": 33,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w7uwln3qtTip"
      },
      "source": [
        "batch_size = 128"
      ],
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_hM56eKy38u8",
        "outputId": "b370ae81-2e83-4eca-9221-315cd0fbbf64"
      },
      "source": [
        "train_data_loader, valid_data_loader, test_data_loader = load_data(batch_size)"
      ],
      "execution_count": 107,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Loading Train.npz into Pytorch Dataloader ... Xs shape: torch.Size([84000, 1, 28, 28]), Ys shape: torch.Size([84000])\n",
            "Loading Validation.npz into Pytorch Dataloader ... Xs shape: torch.Size([36000, 1, 28, 28]), Ys shape: torch.Size([36000])\n",
            "Loading Test.npz into Pytorch Dataloader ... Xs shape: torch.Size([30000, 1, 28, 28]), Ys shape: torch.Size([30000])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": 108,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "334Pk98r3Rjw"
      },
      "source": [
        "losses, acc = [], []\n",
        "valid_losses, valid_acc = [], []\n",
        "test_losses, test_acc = [], []\n",
        "epochs = 40\n",
        "best_loss = float('inf')"
      ],
      "execution_count": 110,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LyCXxlFH1HYm",
        "outputId": "caca204c-b861-48ad-9159-a0042ad9988f"
      },
      "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",
        "  \n",
        "  _, train_accuracy = evaluate_model(classifier, train_data_loader, 'Train')\n",
        "  valid_loss, valid_accuracy = evaluate_model(classifier, valid_data_loader, 'Validation')\n",
        "  test_loss, test_accuracy = evaluate_model(classifier, test_data_loader, 'Test')\n",
        "  \n",
        "  # save the model that performs best on the test set\n",
        "  if test_loss < best_loss:\n",
        "    best_loss = test_loss\n",
        "    torch.save(classifier.state_dict(), 'bvae_classifier_quickdraw.pt')\n",
        "  \n",
        "  # put model back in train mode after putting it in eval mode\n",
        "  classifier.train()\n",
        "  \n",
        "  test_losses.append(test_loss)\n",
        "  acc.append(train_accuracy)\n",
        "  test_acc.append(test_accuracy)\n",
        "  valid_losses.append(valid_loss)\n",
        "  valid_acc.append(valid_accuracy)\n",
        "  \n",
        "  print('Epoch: {}, Avg Loss: {:.4f}, Avg Accuracy: {:.2f}'.format(epoch, total / n, train_accuracy))"
      ],
      "execution_count": 111,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Validation loss:  0.42 | Validation accuracy:  0.88\n",
            "\n",
            "Test loss:  0.40 | Test accuracy:  0.88\n",
            "Epoch: 1, Avg Loss: 0.6150, Avg Accuracy: 88.62\n",
            "\n",
            "Validation loss:  0.38 | Validation accuracy:  0.89\n",
            "\n",
            "Test loss:  0.37 | Test accuracy:  0.89\n",
            "Epoch: 2, Avg Loss: 0.3958, Avg Accuracy: 89.46\n",
            "\n",
            "Validation loss:  0.36 | Validation accuracy:  0.89\n",
            "\n",
            "Test loss:  0.35 | Test accuracy:  0.90\n",
            "Epoch: 3, Avg Loss: 0.3645, Avg Accuracy: 89.97\n",
            "\n",
            "Validation loss:  0.35 | Validation accuracy:  0.89\n",
            "\n",
            "Test loss:  0.34 | Test accuracy:  0.90\n",
            "Epoch: 4, Avg Loss: 0.3491, Avg Accuracy: 90.20\n",
            "\n",
            "Validation loss:  0.34 | Validation accuracy:  0.90\n",
            "\n",
            "Test loss:  0.33 | Test accuracy:  0.90\n",
            "Epoch: 5, Avg Loss: 0.3388, Avg Accuracy: 90.68\n",
            "\n",
            "Validation loss:  0.34 | Validation accuracy:  0.90\n",
            "\n",
            "Test loss:  0.33 | Test accuracy:  0.90\n",
            "Epoch: 6, Avg Loss: 0.3292, Avg Accuracy: 90.75\n",
            "\n",
            "Validation loss:  0.33 | Validation accuracy:  0.90\n",
            "\n",
            "Test loss:  0.32 | Test accuracy:  0.90\n",
            "Epoch: 7, Avg Loss: 0.3249, Avg Accuracy: 91.10\n",
            "\n",
            "Validation loss:  0.33 | Validation accuracy:  0.90\n",
            "\n",
            "Test loss:  0.31 | Test accuracy:  0.90\n",
            "Epoch: 8, Avg Loss: 0.3218, Avg Accuracy: 90.93\n",
            "\n",
            "Validation loss:  0.32 | Validation accuracy:  0.90\n",
            "\n",
            "Test loss:  0.31 | Test accuracy:  0.91\n",
            "Epoch: 9, Avg Loss: 0.3167, Avg Accuracy: 91.29\n",
            "\n",
            "Validation loss:  0.32 | Validation accuracy:  0.90\n",
            "\n",
            "Test loss:  0.31 | Test accuracy:  0.91\n",
            "Epoch: 10, Avg Loss: 0.3113, Avg Accuracy: 91.37\n",
            "\n",
            "Validation loss:  0.33 | Validation accuracy:  0.90\n",
            "\n",
            "Test loss:  0.31 | Test accuracy:  0.90\n",
            "Epoch: 11, Avg Loss: 0.3105, Avg Accuracy: 91.27\n",
            "\n",
            "Validation loss:  0.32 | Validation accuracy:  0.90\n",
            "\n",
            "Test loss:  0.30 | Test accuracy:  0.91\n",
            "Epoch: 12, Avg Loss: 0.3062, Avg Accuracy: 91.40\n",
            "\n",
            "Validation loss:  0.32 | Validation accuracy:  0.90\n",
            "\n",
            "Test loss:  0.30 | Test accuracy:  0.91\n",
            "Epoch: 13, Avg Loss: 0.3027, Avg Accuracy: 91.55\n",
            "\n",
            "Validation loss:  0.32 | Validation accuracy:  0.90\n",
            "\n",
            "Test loss:  0.30 | Test accuracy:  0.91\n",
            "Epoch: 14, Avg Loss: 0.3035, Avg Accuracy: 91.37\n",
            "\n",
            "Validation loss:  0.32 | Validation accuracy:  0.90\n",
            "\n",
            "Test loss:  0.30 | Test accuracy:  0.91\n",
            "Epoch: 15, Avg Loss: 0.3003, Avg Accuracy: 91.47\n",
            "\n",
            "Validation loss:  0.31 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.30 | Test accuracy:  0.91\n",
            "Epoch: 16, Avg Loss: 0.2985, Avg Accuracy: 91.67\n",
            "\n",
            "Validation loss:  0.31 | Validation accuracy:  0.90\n",
            "\n",
            "Test loss:  0.30 | Test accuracy:  0.91\n",
            "Epoch: 17, Avg Loss: 0.2985, Avg Accuracy: 91.69\n",
            "\n",
            "Validation loss:  0.32 | Validation accuracy:  0.90\n",
            "\n",
            "Test loss:  0.30 | Test accuracy:  0.91\n",
            "Epoch: 18, Avg Loss: 0.2956, Avg Accuracy: 91.65\n",
            "\n",
            "Validation loss:  0.31 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.30 | Test accuracy:  0.91\n",
            "Epoch: 19, Avg Loss: 0.2949, Avg Accuracy: 91.64\n",
            "\n",
            "Validation loss:  0.31 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.29 | Test accuracy:  0.91\n",
            "Epoch: 20, Avg Loss: 0.2914, Avg Accuracy: 91.84\n",
            "\n",
            "Validation loss:  0.31 | Validation accuracy:  0.90\n",
            "\n",
            "Test loss:  0.30 | Test accuracy:  0.91\n",
            "Epoch: 21, Avg Loss: 0.2891, Avg Accuracy: 91.62\n",
            "\n",
            "Validation loss:  0.31 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.29 | Test accuracy:  0.91\n",
            "Epoch: 22, Avg Loss: 0.2904, Avg Accuracy: 91.88\n",
            "\n",
            "Validation loss:  0.31 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.30 | Test accuracy:  0.91\n",
            "Epoch: 23, Avg Loss: 0.2874, Avg Accuracy: 91.87\n",
            "\n",
            "Validation loss:  0.31 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.29 | Test accuracy:  0.91\n",
            "Epoch: 24, Avg Loss: 0.2865, Avg Accuracy: 92.02\n",
            "\n",
            "Validation loss:  0.31 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.29 | Test accuracy:  0.91\n",
            "Epoch: 25, Avg Loss: 0.2859, Avg Accuracy: 91.91\n",
            "\n",
            "Validation loss:  0.30 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.29 | Test accuracy:  0.91\n",
            "Epoch: 26, Avg Loss: 0.2854, Avg Accuracy: 92.07\n",
            "\n",
            "Validation loss:  0.31 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.29 | Test accuracy:  0.91\n",
            "Epoch: 27, Avg Loss: 0.2835, Avg Accuracy: 92.03\n",
            "\n",
            "Validation loss:  0.30 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.29 | Test accuracy:  0.91\n",
            "Epoch: 28, Avg Loss: 0.2841, Avg Accuracy: 92.02\n",
            "\n",
            "Validation loss:  0.30 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.29 | Test accuracy:  0.91\n",
            "Epoch: 29, Avg Loss: 0.2807, Avg Accuracy: 92.08\n",
            "\n",
            "Validation loss:  0.30 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.29 | Test accuracy:  0.91\n",
            "Epoch: 30, Avg Loss: 0.2821, Avg Accuracy: 92.05\n",
            "\n",
            "Validation loss:  0.30 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.28 | Test accuracy:  0.91\n",
            "Epoch: 31, Avg Loss: 0.2785, Avg Accuracy: 92.12\n",
            "\n",
            "Validation loss:  0.30 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.29 | Test accuracy:  0.91\n",
            "Epoch: 32, Avg Loss: 0.2791, Avg Accuracy: 92.19\n",
            "\n",
            "Validation loss:  0.30 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.29 | Test accuracy:  0.91\n",
            "Epoch: 33, Avg Loss: 0.2799, Avg Accuracy: 92.07\n",
            "\n",
            "Validation loss:  0.30 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.29 | Test accuracy:  0.91\n",
            "Epoch: 34, Avg Loss: 0.2785, Avg Accuracy: 92.25\n",
            "\n",
            "Validation loss:  0.30 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.28 | Test accuracy:  0.91\n",
            "Epoch: 35, Avg Loss: 0.2779, Avg Accuracy: 92.16\n",
            "\n",
            "Validation loss:  0.30 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.29 | Test accuracy:  0.91\n",
            "Epoch: 36, Avg Loss: 0.2763, Avg Accuracy: 92.20\n",
            "\n",
            "Validation loss:  0.30 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.28 | Test accuracy:  0.91\n",
            "Epoch: 37, Avg Loss: 0.2752, Avg Accuracy: 92.31\n",
            "\n",
            "Validation loss:  0.30 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.29 | Test accuracy:  0.91\n",
            "Epoch: 38, Avg Loss: 0.2741, Avg Accuracy: 92.20\n",
            "\n",
            "Validation loss:  0.30 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.29 | Test accuracy:  0.91\n",
            "Epoch: 39, Avg Loss: 0.2752, Avg Accuracy: 92.25\n",
            "\n",
            "Validation loss:  0.30 | Validation accuracy:  0.91\n",
            "\n",
            "Test loss:  0.28 | Test accuracy:  0.91\n",
            "Epoch: 40, Avg Loss: 0.2744, Avg Accuracy: 92.20\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 482
        },
        "id": "gaVk2hIx4iqx",
        "outputId": "1e004e37-154d-43a5-b2ba-b86083e6f95f"
      },
      "source": [
        "plt.rcParams['figure.figsize'] = [8, 6]\n",
        "plt.rcParams['figure.dpi'] = 90\n",
        "\n",
        "plt.plot(list(range(1, epochs + 1)), losses, color='royalblue')\n",
        "plt.plot(list(range(1, epochs + 1)), test_losses, color = 'red')\n",
        "plt.plot(list(range(1, epochs + 1)), valid_losses, color='teal')\n",
        "\n",
        "plt.legend(['Train Loss', 'Test Loss', 'Validation Loss'], loc='upper right')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Cross Entropy Loss')\n",
        "plt.show()"
      ],
      "execution_count": 112,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x540 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 482
        },
        "id": "dz7Tu4LW6xh0",
        "outputId": "029e4ec8-8961-41b3-a261-f676e54493bb"
      },
      "source": [
        "plt.rcParams['figure.figsize'] = [8, 6]\n",
        "plt.rcParams['figure.dpi'] = 90 \n",
        "\n",
        "plt.plot(list(range(1, epochs + 1)), acc, color='royalblue')\n",
        "plt.plot(list(range(1, epochs + 1)), test_acc, color = 'red')\n",
        "plt.plot(list(range(1, epochs + 1)), valid_acc, color='teal')\n",
        "\n",
        "plt.legend(['Train Accuracy', 'Test Accuracy', 'Validation Accuracy'], loc='upper left')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.show()"
      ],
      "execution_count": 113,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x540 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "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 = ['tree', 't-shirt', 'ice cream', 'fish', 'face', 'car', 'bowtie', 'apple', 'flamingo', 'sheep']\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",
        "  plt.colorbar()\n",
        "  plt.show()"
      ],
      "execution_count": 114,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 646
        },
        "id": "J6yKjpJCGrJS",
        "outputId": "7f9480a8-a4b1-4d98-f2bf-2f42a3955a26"
      },
      "source": [
        "plt.rcParams['figure.figsize'] = [9, 9]\n",
        "plt.rcParams['figure.dpi'] = 90 \n",
        "plot_confusion_matrix_mnist(classifier, test_data_loader)"
      ],
      "execution_count": 115,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 810x810 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}