Covid19_Classification_VGG_Arjun.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "epGd8bfZQO1l"
   },
   "source": [
    "**Import Python module**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "bQMJ3R2PvEou"
   },
   "outputs": [],
   "source": [
    "from google.colab import drive\n",
    "drive.mount('/gdrive')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vLgNmD86woYH"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import zipfile\n",
    "import random\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import torchvision\n",
    "import torchvision.datasets as datasets\n",
    "import torchvision.transforms as transforms\n",
    "import torchvision.models as models\n",
    "from torch.autograd import Variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "yOhMJSUNdlut"
   },
   "outputs": [],
   "source": [
    "#Load data to Google Colab\n",
    "local_zip = '/gdrive/MyDrive/DLH_Project_Data/DLH_Project_Data/archive.zip'\n",
    "zip_ref = zipfile.ZipFile(local_zip, 'r')\n",
    "zip_ref.extractall('/content')\n",
    "zip_ref.close()\n",
    "DATA_PATH = \"Data\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "APPiNun0QqIv"
   },
   "source": [
    "**Data pre-processing(Augmentation + DataLoader)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dWSAGy5SxxiB"
   },
   "outputs": [],
   "source": [
    "def get_count_metrics(folder, data_path=DATA_PATH):\n",
    "\n",
    "    train_dir = os.path.join(data_path, folder)\n",
    "    list_p = os.listdir(os.path.join(train_dir,'PNEUMONIA')) # dir is your directory path\n",
    "    num_p = len(list_p)\n",
    "    list_n = os.listdir(os.path.join(train_dir,'NORMAL')) # dir is your directory path\n",
    "    num_n = len(list_n)\n",
    "    list_c = os.listdir(os.path.join(train_dir,'COVID19')) # dir is your directory path\n",
    "    num_c = len(list_c)\n",
    "    count_tuple = (int(num_n), int(num_p), int(num_c))\n",
    "\n",
    "    return count_tuple\n",
    "\n",
    "def load_data(data_path=DATA_PATH):\n",
    "    \n",
    "    transform_dict = {\n",
    "        'train': transforms.Compose(\n",
    "        [transforms.Resize(224),\n",
    "         transforms.RandomResizedCrop(224),\n",
    "         transforms.RandomHorizontalFlip(p=0.5),\n",
    "         transforms.RandomRotation(degrees=(-10, 10)),\n",
    "         transforms.RandomVerticalFlip(p=0.5),\n",
    "         transforms.GaussianBlur(kernel_size= (5,5),sigma=(0.1, 2.0)),\n",
    "         transforms.ToTensor(),\n",
    "         ]),\n",
    "        'test': transforms.Compose(\n",
    "        [transforms.Resize(224),\n",
    "         transforms.CenterCrop(224),\n",
    "         transforms.RandomHorizontalFlip(p=0.5),\n",
    "         transforms.RandomRotation(degrees=(-10, 10)),\n",
    "         transforms.RandomVerticalFlip(p=0.5),\n",
    "         transforms.GaussianBlur(kernel_size= (5,5),sigma=(0.1, 2.0)),\n",
    "         transforms.ToTensor(),\n",
    "         ])}\n",
    "    \n",
    "    train_data = datasets.ImageFolder(root=data_path + '/train', transform=transform_dict['train'])\n",
    "    train_loader = torch.utils.data.DataLoader(train_data, batch_size=32, shuffle=True)\n",
    "\n",
    "    print('train_loader - len', len(train_loader))\n",
    "    print('train_loader - type', type(train_loader))\n",
    "    \n",
    "    test_data = datasets.ImageFolder(root=data_path + '/test', transform=transform_dict['test'])\n",
    "    test_loader = torch.utils.data.DataLoader(test_data, batch_size=32, shuffle=False)\n",
    "\n",
    "    print('test_loader - len', len(test_loader))\n",
    "    print('test_loader - type', type(test_loader))\n",
    "\n",
    "    return train_loader, test_loader\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "CLsrVnBBymY0"
   },
   "outputs": [],
   "source": [
    "assert type(get_count_metrics('train')) is tuple\n",
    "assert type(get_count_metrics('test')) is tuple\n",
    "print(get_count_metrics('train'))\n",
    "print(get_count_metrics('test'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "62I6_RUjg11Z"
   },
   "outputs": [],
   "source": [
    "train_loader, val_loader = load_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oAcobmr8Q6Za"
   },
   "source": [
    "**Explore processed image**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "yT8aSK9H3uSs"
   },
   "outputs": [],
   "source": [
    "import torchvision\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "def show_batch_images(dataloader):\n",
    "    images, labels = next(iter(dataloader))\n",
    "    grid = torchvision.utils.make_grid(images, padding=20)\n",
    "    npgrid = grid.cpu().numpy()\n",
    "    plt.figure(figsize=(30, 15))\n",
    "    plt.imshow(np.transpose(npgrid, (1, 2, 0)), interpolation='nearest')\n",
    "    print(labels)\n",
    "    plt.title(label=[\"COVID19\" if x==0 else \"non-COVID19\" for x in labels])\n",
    "    plt.show()\n",
    "\n",
    " \n",
    "for i in range(1):\n",
    "    show_batch_images(train_loader)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BQ-_ISZeFpq2"
   },
   "source": [
    "**VGG16 Model Creation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UUsv5nz-CX2a"
   },
   "outputs": [],
   "source": [
    "num_classes = 3\n",
    "vgg16 = models.vgg16_bn()\n",
    "#vgg16.load_state_dict(torch.load(\"../input/vgg16bn/vgg16_bn.pth\"))\n",
    "print(vgg16.classifier[6].out_features)\n",
    "\n",
    "for param in vgg16.features.parameters():\n",
    "  param.requires_grad = False\n",
    "\n",
    "num_features = vgg16.classifier[6].in_features\n",
    "features = list(vgg16.classifier.children())[:-1] # Remove last layer\n",
    "features.extend([nn.Linear(num_features, num_classes)]) # Add our layer with 4 outputs\n",
    "vgg16.classifier = nn.Sequential(*features) # Replace the model classifier\n",
    "print(vgg16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ShK23VJ8F4h6"
   },
   "outputs": [],
   "source": [
    "#Load vgg model and train on multiple epochs\n",
    "\n",
    "n_epochs = 40\n",
    "vgg16.cuda()\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.SGD(vgg16.parameters(), lr= 1e-4) \n",
    "\n",
    "def train_model(model, train_dataloader, n_epoch=n_epochs, optimizer=optimizer, criterion=criterion):\n",
    "    import torch.optim as optim\n",
    "\n",
    "    model.train() # prep model for training\n",
    "    _START_RUNTIME = time.time()\n",
    "    \n",
    "    for epoch in range(n_epoch):\n",
    "        print(f\"Epoch {epoch} starts\")\n",
    "        curr_epoch_loss = []\n",
    "        for data, target in train_dataloader:\n",
    "            if use_gpu:\n",
    "                data, target = Variable(data.cuda()), Variable(target.cuda())\n",
    "            \n",
    "            outputs = model(data)\n",
    "            loss = criterion(outputs, target)\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            curr_epoch_loss.append(loss.cpu().data.numpy())\n",
    "        print(\"Total train time = {:.2f} seconds\".format(time.time() - _START_RUNTIME))    \n",
    "        print(f\"Epoch {epoch}: curr_epoch_loss={np.mean(curr_epoch_loss)}\")\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Yvkl7U8n7WjX"
   },
   "outputs": [],
   "source": [
    "import time\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hhl4DrPgZ0Vd"
   },
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "6VsoDvFzZ8O6"
   },
   "outputs": [],
   "source": [
    "use_gpu = torch.cuda.is_available()\n",
    "if use_gpu:\n",
    "    print(\"Using CUDA\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "TmPa3kNKFS1B"
   },
   "outputs": [],
   "source": [
    "#print(model)\n",
    "seed = 24\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)\n",
    "model = train_model(vgg16, train_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "podC8UVHLXmw"
   },
   "outputs": [],
   "source": [
    "model.eval()\n",
    "Y_pred = []\n",
    "Y_test = []\n",
    "predictions, actuals = list(), list()\n",
    "for data, target in val_loader:\n",
    "    if use_gpu:\n",
    "      data, target = Variable(data.cuda()), Variable(target.cuda())\n",
    "\n",
    "    Y_pred_orig = model(data)\n",
    "    _, Y_pred_tag = torch.max(Y_pred_orig, dim = 1)\n",
    "    Y_pred_tag = Y_pred_tag.cpu().detach().numpy()\n",
    "    Y_pred_tag = Y_pred_tag.reshape(len(Y_pred_tag), 1)\n",
    "\n",
    "    Y_test = target.cpu().numpy()\n",
    "    Y_test = Y_test.reshape(len(Y_test), 1)\n",
    "\n",
    "    predictions.append(Y_pred_tag)\n",
    "    actuals.append(Y_test)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "bkkQm2z7LtLt"
   },
   "outputs": [],
   "source": [
    "Y_pred = np.concatenate(predictions, axis=0)\n",
    "Y_test = np.concatenate(actuals, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "P3DqeOYfLz-S"
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "acc = accuracy_score(Y_test, Y_pred)\n",
    "print((\"Validation Accuracy of Simple Vgg: \" + str(acc)))"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "machine_shape": "hm",
   "name": "Copy of Covid19_Classification_VGG  Arjun.ipynb",
   "private_outputs": true,
   "provenance": []
  },
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}