ResNet_Cover_Classifier.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "ResNet Cover Classifier.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "mount_file_id": "1GR02cWca7f_3AeVlXfwQ3E3vjbp9hShn",
      "authorship_tag": "ABX9TyME6UoD/NZc/rqh25kKXh+V",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/SeaOfFrost/BookCoverClassifier/blob/master/ResNet_Cover_Classifier.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gkEqxbl8iZTE",
        "colab_type": "text"
      },
      "source": [
        "# Load Required Folder and check for GPU"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "raJdcWAF1Iog",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "3476b32a-beed-4724-8875-46a2042e1c41"
      },
      "source": [
        "ls"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[0m\u001b[01;34mdrive\u001b[0m/  \u001b[01;34msample_data\u001b[0m/\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hd8hM1vu1Ofg",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "be5bb329-8ef9-44c9-b351-adc36b6cc423"
      },
      "source": [
        "cd drive/My Drive/Book Classifier/book-dataset/Task1/"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/content/drive/My Drive/Book Classifier/book-dataset/Task1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iQtnzx5xCuJk",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 380
        },
        "outputId": "59726c55-a63a-46f5-ba9b-3df39fa6d274"
      },
      "source": [
        "!nvidia-smi"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Tue Jul 28 10:24:31 2020       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 450.51.05    Driver Version: 418.67       CUDA Version: 10.1     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla T4            Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   76C    P0    33W /  70W |   1871MiB / 15079MiB |      0%      Default |\n",
            "|                               |                      |                 ERR! |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "|  No running processes found                                                 |\n",
            "+-----------------------------------------------------------------------------+\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TW-LTmetifIg",
        "colab_type": "text"
      },
      "source": [
        "# Import Dependencies"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4wtGCLTDCHbc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.optim import lr_scheduler\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import torchvision\n",
        "from torchvision import datasets, models, transforms\n",
        "import matplotlib.pyplot as plt\n",
        "import time\n",
        "import os\n",
        "import copy\n",
        "plt.ion()   # interactive mode"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Uq4D4u2biiEA",
        "colab_type": "text"
      },
      "source": [
        "# Load Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B6cOvbjhCIgM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "data_transforms = {\n",
        "    'train': transforms.Compose([\n",
        "        transforms.RandomResizedCrop(224),\n",
        "        transforms.RandomHorizontalFlip(),\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
        "    ]),\n",
        "    'val': transforms.Compose([\n",
        "        transforms.Resize(256),\n",
        "        transforms.CenterCrop(224),\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
        "    ]),\n",
        "    'test': transforms.Compose([\n",
        "        transforms.Resize(224),\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
        "    ])\n",
        "}\n",
        "\n",
        "data_dir = './images'\n",
        "image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x),\n",
        "                                          data_transforms[x])\n",
        "                  for x in ['train', 'val', 'test']}\n",
        "dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=32,\n",
        "                                             shuffle=True, num_workers=8)\n",
        "              for x in ['train', 'val', 'test']}\n",
        "dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val', 'test']}\n",
        "class_names = image_datasets['train'].classes\n",
        "\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BFcvCTj_ikHQ",
        "colab_type": "text"
      },
      "source": [
        "# Train Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "binfooGnCKbo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def train_model(model, criterion, optimizer, num_epochs=25):\n",
        "    since = time.time()\n",
        "\n",
        "    best_model_wts = copy.deepcopy(model.state_dict())\n",
        "    best_acc = 0.0\n",
        "\n",
        "    for epoch in range(num_epochs):\n",
        "        print('Epoch {}/{}'.format(epoch + 1, num_epochs))\n",
        "        print('-' * 10)\n",
        "\n",
        "        # Each epoch has a training and validation phase\n",
        "        for phase in ['train', 'val']:\n",
        "            if phase == 'train':\n",
        "                model.train()  # Set model to training mode\n",
        "            else:\n",
        "                model.eval()   # Set model to evaluate mode\n",
        "\n",
        "            running_loss = 0.0\n",
        "            running_corrects = 0\n",
        "\n",
        "            # Iterate over data.\n",
        "            for inputs, labels in dataloaders[phase]:\n",
        "                inputs = inputs.to(device)\n",
        "                labels = labels.to(device)\n",
        "\n",
        "                # zero the parameter gradients\n",
        "                optimizer.zero_grad()\n",
        "\n",
        "                # forward\n",
        "                # track history if only in train\n",
        "                with torch.set_grad_enabled(phase == 'train'):\n",
        "                    outputs = model(inputs)\n",
        "                    _, preds = torch.max(outputs, 1)\n",
        "                    loss = criterion(outputs, labels)\n",
        "\n",
        "                    # backward + optimize only if in training phase\n",
        "                    if phase == 'train':\n",
        "                        loss.backward()\n",
        "                        optimizer.step()\n",
        "\n",
        "                # statistics\n",
        "                running_loss += loss.item() * inputs.size(0)\n",
        "                running_corrects += torch.sum(preds == labels.data)\n",
        "#             if phase == 'train':\n",
        "#                 scheduler.step()\n",
        "\n",
        "            epoch_loss = running_loss / dataset_sizes[phase]\n",
        "            epoch_acc = running_corrects.double() / dataset_sizes[phase]\n",
        "\n",
        "            print('{} Loss: {:.4f} Acc: {:.4f}'.format(\n",
        "                phase, epoch_loss, epoch_acc))\n",
        "\n",
        "            # deep copy the model\n",
        "            if phase == 'val' and epoch_acc > best_acc:\n",
        "                best_acc = epoch_acc\n",
        "                best_model_wts = copy.deepcopy(model.state_dict())\n",
        "\n",
        "        print()\n",
        "\n",
        "    time_elapsed = time.time() - since\n",
        "    print('Training complete in {:.0f}m {:.0f}s'.format(\n",
        "        time_elapsed // 60, time_elapsed % 60))\n",
        "    print('Best val Acc: {:4f}'.format(best_acc))\n",
        "\n",
        "    # load best model weights\n",
        "    model.load_state_dict(best_model_wts)\n",
        "    return model"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4nW7opK5CNrc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model = models.resnet50(pretrained=True)\n",
        "for param in model.parameters():\n",
        "  param.requires_grad = False\n",
        "model.fc = nn.Sequential(nn.Linear(2048, 512),\n",
        "                         nn.ReLU(),\n",
        "                         nn.Dropout(0.2),\n",
        "                         nn.Linear(512, 10),\n",
        "                         nn.LogSoftmax(dim=1))\n",
        "model = model.to(device)\n",
        "criterion = nn.NLLLoss()\n",
        "optimizer = optim.Adam(model.parameters(), lr = 0.001)"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EB1UajAliqzY",
        "colab_type": "text"
      },
      "source": [
        "Train model and save weights after completion"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eT-uhFj8CPoc",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "07725d76-4db7-48d9-f1dc-adce65abc41c"
      },
      "source": [
        "model_ft = train_model(model, criterion, optimizer, num_epochs=25)\n",
        "torch.save(model_ft.state_dict(), 'Weights.pt')"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/25\n",
            "----------\n",
            "train Loss: 1.7561 Acc: 0.3805\n",
            "val Loss: 1.6226 Acc: 0.4417\n",
            "\n",
            "Epoch 2/25\n",
            "----------\n",
            "train Loss: 1.7384 Acc: 0.3860\n",
            "val Loss: 1.6124 Acc: 0.4393\n",
            "\n",
            "Epoch 3/25\n",
            "----------\n",
            "train Loss: 1.7187 Acc: 0.4016\n",
            "val Loss: 1.6007 Acc: 0.4446\n",
            "\n",
            "Epoch 4/25\n",
            "----------\n",
            "train Loss: 1.7047 Acc: 0.4032\n",
            "val Loss: 1.5810 Acc: 0.4405\n",
            "\n",
            "Epoch 5/25\n",
            "----------\n",
            "train Loss: 1.6838 Acc: 0.4151\n",
            "val Loss: 1.5724 Acc: 0.4498\n",
            "\n",
            "Epoch 6/25\n",
            "----------\n",
            "train Loss: 1.6935 Acc: 0.4114\n",
            "val Loss: 1.5883 Acc: 0.4457\n",
            "\n",
            "Epoch 7/25\n",
            "----------\n",
            "train Loss: 1.6757 Acc: 0.4179\n",
            "val Loss: 1.5650 Acc: 0.4527\n",
            "\n",
            "Epoch 8/25\n",
            "----------\n",
            "train Loss: 1.6599 Acc: 0.4233\n",
            "val Loss: 1.5588 Acc: 0.4673\n",
            "\n",
            "Epoch 9/25\n",
            "----------\n",
            "train Loss: 1.6613 Acc: 0.4227\n",
            "val Loss: 1.5589 Acc: 0.4562\n",
            "\n",
            "Epoch 10/25\n",
            "----------\n",
            "train Loss: 1.6608 Acc: 0.4144\n",
            "val Loss: 1.5673 Acc: 0.4492\n",
            "\n",
            "Epoch 11/25\n",
            "----------\n",
            "train Loss: 1.6425 Acc: 0.4218\n",
            "val Loss: 1.5467 Acc: 0.4446\n",
            "\n",
            "Epoch 12/25\n",
            "----------\n",
            "train Loss: 1.6528 Acc: 0.4269\n",
            "val Loss: 1.5587 Acc: 0.4516\n",
            "\n",
            "Epoch 13/25\n",
            "----------\n",
            "train Loss: 1.6349 Acc: 0.4314\n",
            "val Loss: 1.5874 Acc: 0.4545\n",
            "\n",
            "Epoch 14/25\n",
            "----------\n",
            "train Loss: 1.6345 Acc: 0.4284\n",
            "val Loss: 1.5765 Acc: 0.4376\n",
            "\n",
            "Epoch 15/25\n",
            "----------\n",
            "train Loss: 1.6362 Acc: 0.4292\n",
            "val Loss: 1.5401 Acc: 0.4621\n",
            "\n",
            "Epoch 16/25\n",
            "----------\n",
            "train Loss: 1.6389 Acc: 0.4284\n",
            "val Loss: 1.5844 Acc: 0.4504\n",
            "\n",
            "Epoch 17/25\n",
            "----------\n",
            "train Loss: 1.6132 Acc: 0.4386\n",
            "val Loss: 1.5432 Acc: 0.4656\n",
            "\n",
            "Epoch 18/25\n",
            "----------\n",
            "train Loss: 1.6239 Acc: 0.4308\n",
            "val Loss: 1.5802 Acc: 0.4527\n",
            "\n",
            "Epoch 19/25\n",
            "----------\n",
            "train Loss: 1.6187 Acc: 0.4342\n",
            "val Loss: 1.5798 Acc: 0.4574\n",
            "\n",
            "Epoch 20/25\n",
            "----------\n",
            "train Loss: 1.6195 Acc: 0.4373\n",
            "val Loss: 1.5309 Acc: 0.4597\n",
            "\n",
            "Epoch 21/25\n",
            "----------\n",
            "train Loss: 1.6021 Acc: 0.4422\n",
            "val Loss: 1.5732 Acc: 0.4533\n",
            "\n",
            "Epoch 22/25\n",
            "----------\n",
            "train Loss: 1.6082 Acc: 0.4375\n",
            "val Loss: 1.5675 Acc: 0.4510\n",
            "\n",
            "Epoch 23/25\n",
            "----------\n",
            "train Loss: 1.6132 Acc: 0.4355\n",
            "val Loss: 1.5401 Acc: 0.4592\n",
            "\n",
            "Epoch 24/25\n",
            "----------\n",
            "train Loss: 1.5854 Acc: 0.4514\n",
            "val Loss: 1.5356 Acc: 0.4592\n",
            "\n",
            "Epoch 25/25\n",
            "----------\n",
            "train Loss: 1.5988 Acc: 0.4440\n",
            "val Loss: 1.5311 Acc: 0.4615\n",
            "\n",
            "Training complete in 28m 0s\n",
            "Best val Acc: 0.467328\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dfrnkQk7ixUk",
        "colab_type": "text"
      },
      "source": [
        "# Test Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_-Sv_aZCSRRE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def test_model(model, criterion):\n",
        "    \n",
        "    path = 'Weights.pt'\n",
        "    since = time.time()\n",
        "    model.load_state_dict(torch.load(path))\n",
        "    model = model.to(device)\n",
        "    \n",
        "    best_acc = 0.0\n",
        "    model.eval()   # Set model to evaluate mode\n",
        "\n",
        "    running_loss = 0.0\n",
        "    running_corrects = 0\n",
        "    total_preds = []\n",
        "    total_labels = []\n",
        "\n",
        "    # Iterate over data.\n",
        "    for inputs, labels in dataloaders['test']:\n",
        "        total_labels.append(labels)\n",
        "        inputs = inputs.to(device)\n",
        "        labels = labels.to(device)\n",
        "\n",
        "        # forward\n",
        "        # track history if only in train\n",
        "        with torch.no_grad():\n",
        "            outputs = model(inputs)\n",
        "            # print(outputs.shape)\n",
        "            total_preds.append(outputs.detach().cpu())\n",
        "            _, preds = torch.max(outputs, 1)\n",
        "            loss = criterion(outputs, labels)\n",
        "        # statistics\n",
        "        running_loss += loss.item() * inputs.size(0)\n",
        "        running_corrects += torch.sum(preds == labels.data)\n",
        "\n",
        "    loss = running_loss / dataset_sizes['test']\n",
        "    acc = running_corrects.double() / dataset_sizes['test']\n",
        "\n",
        "    print('Loss: {:.4f} Acc: {:.4f}'.format(loss, acc))\n",
        "\n",
        "    time_elapsed = time.time() - since\n",
        "    print('Training complete in {:.0f}m {:.0f}s'.format(\n",
        "        time_elapsed // 60, time_elapsed % 60))\n",
        "    \n",
        "    return total_preds, total_labels"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3VrXb-lkU5oE",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "outputId": "714e6883-3a89-4d1e-c3ba-805eec173b9c"
      },
      "source": [
        "preds, labels = test_model(model, criterion)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Loss: 1.6499 Acc: 0.4142\n",
            "Training complete in 2m 7s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hMHbd8kCZ9YY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from torch import topk\n",
        "\n",
        "def accuracy(output, target, topk=(1,)):\n",
        "    \"\"\"Computes the precision@k for the specified values of k\"\"\"\n",
        "    maxk = max(topk)\n",
        "    batch_size = target.size(0)\n",
        "\n",
        "    _, pred = output.topk(maxk, 1, True, True)\n",
        "    pred = pred.t()\n",
        "    correct = pred.eq(target.view(1, -1).expand_as(pred))\n",
        "\n",
        "    res = []\n",
        "    for k in topk:\n",
        "        correct_k = correct[:k].view(-1).float().sum(0)\n",
        "        res.append(correct_k.mul_(100.0 / batch_size))\n",
        "    return res"
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E8F3AkcsaWEE",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        },
        "outputId": "b7fe78f5-af1c-4cb4-87c2-9e59be6d198a"
      },
      "source": [
        "total_top1 = 0\n",
        "total_top3 = 0\n",
        "total_top5 = 0\n",
        "for i in range(len(preds)):\n",
        "  top1, top3, top5 = accuracy(preds[i], labels[i], topk = (1, 3, 5))\n",
        "  total_top1 += top1\n",
        "  total_top3 += top3\n",
        "  total_top5 += top5\n",
        "print(f\"Top 1 Accuracy is: {total_top1/len(preds)}\")\n",
        "print(f\"Top 3 Accuracy is: {total_top3/len(preds)}\")\n",
        "print(f\"Top 5 Accuracy is: {total_top5/len(preds)}\")"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Top 1 Accuracy is: 41.42361068725586\n",
            "Top 3 Accuracy is: 71.61458587646484\n",
            "Top 5 Accuracy is: 87.1875\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}