Analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# _**<span style=\"color:#1F618D;\"> Face Mask Image Classification</span>**_\n",
    "\n",
    "<span style=\"color:#148F77;\">Author: Blaise Appolinary</span> [@Blaise](https://blaise-appolinary.netlify.app/)\n",
    "\n",
    "******\n",
    "\n",
    "<a id=\"table-of-contents\"></a>\n",
    "# **<span style=\"color:#1F618D;\">📓 Table of Contents 📓</span>**\n",
    "- [1.😼 About author](#1)\n",
    "- [2. Background and Objective](#2)\n",
    "- [3. Convolution Block Implementation](#3)\n",
    "- [4. Classifier Implementation](#4)\n",
    "- [5. Obtaining DataLoaders](#5)\n",
    "- [6. Train Loop Implementation](#6)\n",
    "- [7. Model Evaluation on Test set](#7)\n",
    "******\n",
    "\n",
    "<a id=\"1\"></a>\n",
    "# <span style=\"color:#1F618D;\">😼 About Me</span>\n",
    "My name is Blaise Appolinary, a Mathematics and Statistics student at the University of British Columbia. I love playing with datasets to gain insights from them through machine learning, statistical analysis and data visualization.\n",
    "\n",
    "\n",
    "<a id=\"2\"></a>\n",
    "# <span style=\"color:#1F618D;\">BackGround and Objective of the project</span>\n",
    "The use of Masks have been very helpful in the fight against the rise of COVID-19 cases globally. The objective of the project is to build a Convolutional Neural Network architecture that can classify different images and detect whether the image has:\n",
    "- a fully covered face by a mask\n",
    "- a partially covered face by a mask\n",
    "- a face not covered by mask\n",
    "- No a face at all\n",
    "\n",
    "<table style='font-size:10'>\n",
    "    <tr>\n",
    "    <th>Fully covered</th>\n",
    "    <th>Partially Covered</th>\n",
    "    <th>Not covered</th>\n",
    "    <th>Not Face</th>\n",
    "    </tr>\n",
    "    </tr>\n",
    "    <tr>\n",
    "    <td> <img src=\"Images/fully_masked1.jpg\" alt=\"Fully Masked\" style=\"width: 70px;\"/> </td>\n",
    "    <td> <img src=\"Images/partially1.jpg\" alt=\"Partially Masked\" style=\"width: 70px;\"/> </td>\n",
    "    <td> <img src=\"Images/not_covered1.jpg\" alt=\"Not Masked\" style=\"width: 70px;\"/> </td>\n",
    "    <td> <img src=\"Images/not_face1.jpg\" alt= \"Not face\" style='width:70px'\"/> </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "    <td> <img src=\"Images/fully_masked2.jpg\" alt=\"Fully Masked\" style=\"width: 70px;\"/> </td>\n",
    "    <td> <img src=\"Images/partially2.jpg\" alt=\"Partially Masked\" style=\"width: 70px;\"/> </td>\n",
    "    <td> <img src=\"Images/not_covered2.jpg\" alt=\"Not Masked\" style=\"width: 70px;\"/> </td>\n",
    "    <td> <img src=\"Images/not_face2.jpg\" alt= \"Not face\" style='width:70px'\"/> </td>\n",
    "    </tr>\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## <span style=\"color:#1F618D;\">Importing Necessary Packages</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "import torch.nn as nn\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from tqdm.notebook import tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "<a id=\"3\"></a>\n",
    "## <span style=\"color:#1F618D;\">Convolution Block Implementation</span>\n",
    "\n",
    "The image below shows the design for the convolution block"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "<img src=\"Images/UML class.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "class ConvolutionBlock(nn.Module):\n",
    "    def __init__(self, in_channels: int, out_channels: int):\n",
    "        \"\"\"\n",
    "        An Implementation of the convolutional block\n",
    "        :param in_channels: Number of Channels entering the convolution layer\n",
    "        :param out_channels: Number of filter for the convolution layer\n",
    "        \"\"\"\n",
    "        super(ConvolutionBlock, self).__init__()\n",
    "\n",
    "        self.convs = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=in_channels, out_channels=out_channels,\n",
    "                      kernel_size=3, padding=0, stride=1),\n",
    "            nn.BatchNorm2d(out_channels),\n",
    "            nn.MaxPool2d(2),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "    def forward(self, X):\n",
    "        return self.convs(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "<a id=\"4\"></a>\n",
    "## <span style=\"color:#1F618D;\">Classifier class</span>\n",
    "\n",
    "The image below shows the design of the Classifier Class\n",
    "\n",
    "<img src=\"Images/Classifier.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "class Classifier(nn.Module):\n",
    "    def __init__(self, in_channels: int,  num_classes: int) -> None:\n",
    "        \"\"\"\n",
    "        :param in_channels: Number of Channels of the image\n",
    "        :param num_classes: Number of categories of images (4 in out case)\n",
    "        \"\"\"\n",
    "\n",
    "        super(Classifier, self).__init__()\n",
    "\n",
    "        conv1 = ConvolutionBlock(in_channels=in_channels, out_channels=8)\n",
    "        dropout1 = nn.Dropout2d(0.5)\n",
    "        conv2 = ConvolutionBlock(in_channels=8, out_channels=16)\n",
    "        dropout2 = nn.Dropout2d(0.5)\n",
    "        conv3 = ConvolutionBlock(in_channels=16, out_channels=32)\n",
    "\n",
    "        self.layers = nn.Sequential(conv1,dropout1, conv2,dropout2, conv3)\n",
    "\n",
    "        self.fc = nn.Sequential(\n",
    "            nn.Linear(in_features=1152, out_features=40),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(),\n",
    "            nn.Linear(in_features=40, out_features=20),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(),\n",
    "            nn.Linear(in_features=20, out_features=num_classes),\n",
    "            nn.LogSoftmax(dim=-1)\n",
    "        )\n",
    "\n",
    "    def forward(self, X):\n",
    "        X = self.layers(X)\n",
    "        X = X.view(X.shape[0], -1)\n",
    "        X = self.fc(X)\n",
    "        return X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "<a id=\"5\"></a>\n",
    "## <span style=\"color:#1F618D;\">DataLoaders Function</span>\n",
    "The `get_dataloaders` function below does the following:\n",
    "- Reads in the Image data from a given directory\n",
    "- Applies transformations to the images\n",
    "- If the images are from the train set, it applies a random horizontal flip, otherwise not\n",
    "- returns a dataloaders object of the data with a batch size of 32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def get_dataloaders(path: str, training: bool):\n",
    "    \"\"\"\n",
    "    returns a dataloader object given a path to a directory depending on whether it is a train set\n",
    "    :param training: True if it is a training directory\n",
    "    :param path: A path to a directory containing the image\n",
    "    \"\"\"\n",
    "    transforms = None\n",
    "    if training:\n",
    "        transforms = torchvision.transforms.Compose([\n",
    "            torchvision.transforms.Resize((64, 64)),\n",
    "            torchvision.transforms.ToTensor(),\n",
    "            torchvision.transforms.RandomHorizontalFlip()\n",
    "        ])\n",
    "    else:\n",
    "        transforms = torchvision.transforms.Compose([\n",
    "            torchvision.transforms.Resize((64, 64)),\n",
    "            torchvision.transforms.ToTensor()\n",
    "        ])\n",
    "\n",
    "    data = torchvision.datasets.ImageFolder(\n",
    "        path, transform=transforms)\n",
    "\n",
    "    data_loader = DataLoader(data, batch_size=32, shuffle=training)\n",
    "\n",
    "    return data_loader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def calculate_accuracy(y_true, y_pred) -> float:\n",
    "    \"\"\"\n",
    "    Calculates the accuracy of the model\n",
    "    :param y_true: True labels\n",
    "    :param y_pred: Predicted labels\n",
    "    :return: Accuracy\n",
    "    \"\"\"\n",
    "    correct = torch.eq(y_true, y_pred).sum().item()\n",
    "    accuracy = (correct/len(y_pred))*100\n",
    "    return accuracy"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "<a id=\"6\"></a>\n",
    "## <span style=\"color:#1F618D;\">Train Loop Implementation</span>"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "df87530f657b4a7db7290f2e0fb7beeb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/15 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, Loss: 1.0356364250183105, Train Accuracy: 46.666666666666664, Val Accuracy: 0.0\n",
      "Epoch: 1, Loss: 0.07953456789255142, Train Accuracy: 100.0, Val Accuracy: 14.285714285714285\n",
      "Epoch: 2, Loss: 0.1807042509317398, Train Accuracy: 93.33333333333333, Val Accuracy: 66.66666666666666\n",
      "Epoch: 3, Loss: 0.053170107305049896, Train Accuracy: 100.0, Val Accuracy: 71.42857142857143\n",
      "Epoch: 4, Loss: 0.18635313212871552, Train Accuracy: 93.33333333333333, Val Accuracy: 85.71428571428571\n",
      "Epoch: 5, Loss: 0.032802458852529526, Train Accuracy: 100.0, Val Accuracy: 80.95238095238095\n",
      "Epoch: 6, Loss: 0.1896732747554779, Train Accuracy: 93.33333333333333, Val Accuracy: 95.23809523809523\n",
      "Epoch: 7, Loss: 0.3720669150352478, Train Accuracy: 93.33333333333333, Val Accuracy: 90.47619047619048\n",
      "Epoch: 8, Loss: 0.3018714487552643, Train Accuracy: 93.33333333333333, Val Accuracy: 85.71428571428571\n",
      "Epoch: 9, Loss: 0.09767886996269226, Train Accuracy: 93.33333333333333, Val Accuracy: 90.47619047619048\n",
      "Epoch: 10, Loss: 0.008540055714547634, Train Accuracy: 100.0, Val Accuracy: 85.71428571428571\n",
      "Epoch: 11, Loss: 0.1937117725610733, Train Accuracy: 86.66666666666667, Val Accuracy: 100.0\n",
      "Epoch: 12, Loss: 0.013836058788001537, Train Accuracy: 100.0, Val Accuracy: 95.23809523809523\n",
      "Epoch: 13, Loss: 0.016918618232011795, Train Accuracy: 100.0, Val Accuracy: 100.0\n",
      "Epoch: 14, Loss: 0.06403740495443344, Train Accuracy: 93.33333333333333, Val Accuracy: 100.0\n"
     ]
    }
   ],
   "source": [
    "# def train_model(model=Classifier(in_channels=3, num_classes=4)):\n",
    "\n",
    "train_loss = []\n",
    "train_acc = []\n",
    "val_loss = []\n",
    "val_acc = []\n",
    "\n",
    "model = Classifier(in_channels=3, num_classes=4)\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(params=model.parameters(), lr=0.001)\n",
    "EPOCHS = 15\n",
    "train_loader = get_dataloaders(path='Mask_Data/train', training=True)\n",
    "valid_loader = get_dataloaders(path='Mask_Data/val', training=False)\n",
    "model.train()\n",
    "for epoch in tqdm(range(EPOCHS)):\n",
    "    # for batch_idx, (inputs, labels) in enumerate(train_loader):\n",
    "    for batch in train_loader:\n",
    "        inputs, labels = batch\n",
    "\n",
    "        # Forward pass\n",
    "        y_pred = model.forward(inputs)\n",
    "\n",
    "        # Calculating Accuracy\n",
    "        _, predicted = torch.max(y_pred, dim=1)\n",
    "        train_accuracy = calculate_accuracy(y_true = labels, y_pred = predicted)\n",
    "\n",
    "        # Calculating loss\n",
    "        loss = criterion(input=y_pred, target=labels)\n",
    "\n",
    "        # BackPropagation\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        # Zero Gradients\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "    with torch.no_grad():\n",
    "        validation_loss = 0\n",
    "        model.eval()\n",
    "        for batch in valid_loader:\n",
    "            val_input, val_labels = batch\n",
    "            preds = model.forward(val_input)\n",
    "            _, eval_preds = torch.max(preds, dim=1)\n",
    "            \n",
    "            valid_accuracy = calculate_accuracy(y_true = val_labels, y_pred = eval_preds)\n",
    "            \n",
    "            valid_loss = criterion(input=preds, target=val_labels)\n",
    "\n",
    "            validation_loss += valid_loss.item()\n",
    "    \n",
    "    train_loss.append(loss.item())\n",
    "    train_acc.append(train_accuracy)\n",
    "    val_loss.append(validation_loss)\n",
    "    val_acc.append(valid_accuracy)\n",
    "    print('Epoch: {}, Loss: {}, Train Accuracy: {}, Val Accuracy: {}'.format(\n",
    "        epoch, loss.item(), train_accuracy, valid_accuracy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(train_loss, label = 'Training Loss')\n",
    "plt.plot(val_loss, label = \"Validation Loss\")\n",
    "plt.plot(val_acc, label = 'Val Accuracy')\n",
    "plt.plot(train_acc, label = 'Train Accuracy')\n",
    "plt.grid()\n",
    "plt.legend()\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "<a id=\"7\"></a>\n",
    "## <span style=\"color:#1F618D;\">Evaluation on test set</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Set Accuracy 92.0\n"
     ]
    }
   ],
   "source": [
    "test_set = get_dataloaders(path='Mask_Data/test', training=False)\n",
    "with torch.no_grad():\n",
    "        test_loss = 0\n",
    "        model.eval()\n",
    "        for batch in test_set:\n",
    "            test_input, test_labels = batch\n",
    "            preds = model.forward(test_input)\n",
    "            _, test_preds = torch.max(preds, dim=1)\n",
    "            \n",
    "            test_accuracy = calculate_accuracy(y_true = test_labels, y_pred = test_preds)\n",
    "print(\"Test Set Accuracy\",test_accuracy)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}