Pain_Detection.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "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.7.10"
    },
    "colab": {
      "name": "Pain Detection.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Trailblazer29/Pain-Detection-From-Facial-Expressions/blob/main/Pain_Detection.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vWhxlD7E7a92"
      },
      "source": [
        "# <center> Pain Detection Through Facial Expressions - Ilham Seladji, MS. Data Analytics</center>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "TONrOKcB7a96"
      },
      "source": [
        "#Load Libraries\n",
        "import cv2\n",
        "import os\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import torch\n",
        "import torchvision\n",
        "from torchvision import datasets, transforms\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "import tkinter as tk\n",
        "import re\n",
        "from tkinter import filedialog\n",
        "from sklearn.metrics import confusion_matrix\n",
        "import seaborn as sn\n",
        "import pandas as pd\n",
        "import RegscorePy as rp"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZKvLUEGo7a98"
      },
      "source": [
        "# Load the OpenCV face cascade\n",
        "face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')\n",
        "kernel = np.ones((5,5),np.float32)/25\n",
        "def preprocess_img(img, img_size):\n",
        "    #Face Detection & Cropping\n",
        "    faces = face_cascade.detectMultiScale(img, 1.1, 4)\n",
        "    # Grayscale conversion\n",
        "    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
        "    # Histogram equalization\n",
        "    img = cv2.equalizeHist(img)\n",
        "    for (x, y, w, h) in faces: \n",
        "        img_ = img[y:y+h, x:x+w]\n",
        "    try:\n",
        "        #Resizing/Normalizing\n",
        "        img_ = cv2.resize(img_,(img_size, img_size))\n",
        "        #Mean Filtering\n",
        "        img_ = cv2.filter2D(img_,-1,kernel)\n",
        "    except Exception as e:\n",
        "        #print(\"Exception: \"+str(e))\n",
        "        return img\n",
        "    return img_"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "br4X7kWo7a99"
      },
      "source": [
        "def preprocess(class_path, img_size):\n",
        "    for filename in os.listdir(class_path):\n",
        "        #img = cv2.imread(os.path.join(class_path,filename), cv2.IMREAD_GRAYSCALE)\n",
        "        img = cv2.imread(os.path.join(class_path,filename))\n",
        "        img = preprocess_img(img, img_size)\n",
        "        cv2.imwrite(os.path.join(\"Processed \"+class_path,filename), img)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TG3ub5w57a99"
      },
      "source": [
        "# Preprocessing:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "KJ_-D7F57a99"
      },
      "source": [
        "preprocess(\"Binary Classified Pain Images/0\", 224)\n",
        "preprocess(\"Binary Classified Pain Images/1\", 224)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zRMbjowX7a9-"
      },
      "source": [
        "## Print Sample"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OdYje6u67a9-"
      },
      "source": [
        "for filename in os.listdir(\"Processed Binary Classified Pain Images/0\"):\n",
        "    #Conversion to grayscale\n",
        "    img = cv2.imread(os.path.join(\"Processed Binary Classified Pain Images/0\",filename), cv2.IMREAD_GRAYSCALE)\n",
        "    tran = transforms.ToTensor()\n",
        "    img = tran(img)\n",
        "    break"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f8D_6BOI7a9_"
      },
      "source": [
        "# Importing Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "6I01J09B7a-A"
      },
      "source": [
        "data_transform = transforms.Compose(\n",
        "    [transforms.ToTensor(),\n",
        "     transforms.Normalize((0.5,), (0.5,)),\n",
        "     transforms.Grayscale(num_output_channels=1)])\n",
        "trainset = datasets.ImageFolder(root=\"train\", transform=data_transform)\n",
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size = 10, shuffle = True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YFdM7iEd7a-A"
      },
      "source": [
        "testset = datasets.ImageFolder(root=\"test\", transform=data_transform)\n",
        "testloader = torch.utils.data.DataLoader(testset)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EdRsS8XP7a-B"
      },
      "source": [
        "# Processing:\n",
        "\n",
        "### CNN Architecture:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fLJVL1l47a-B"
      },
      "source": [
        "num_epochs = 20\n",
        "batch_size = 10\n",
        "learning_rate = 0.0001\n",
        "class NN(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(NN, self).__init__()\n",
        "        self.layer1 = nn.Sequential(\n",
        "        nn.Conv2d(1, 64, kernel_size=3, stride=1, padding=1),\n",
        "        nn.ReLU(),\n",
        "        nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1),\n",
        "        nn.ReLU(),\n",
        "        nn.MaxPool2d(kernel_size=2, stride=2))\n",
        "        self.layer2 = nn.Sequential(\n",
        "        nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),\n",
        "        nn.ReLU(),\n",
        "        nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),\n",
        "        nn.ReLU(),\n",
        "        nn.MaxPool2d(kernel_size=2, stride=2))\n",
        "        self.layer3 = nn.Sequential(\n",
        "        nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),\n",
        "        nn.ReLU(),\n",
        "        nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),\n",
        "        nn.ReLU(),\n",
        "        nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),\n",
        "        nn.ReLU(),\n",
        "        nn.MaxPool2d(kernel_size=2, stride=2))\n",
        "        self.layer4 = nn.Sequential(\n",
        "        nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),\n",
        "        nn.ReLU(),\n",
        "        nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),\n",
        "        nn.ReLU(),\n",
        "        nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),\n",
        "        nn.ReLU(),\n",
        "        nn.MaxPool2d(kernel_size=2, stride=2))\n",
        "        self.layer5 = nn.Sequential(\n",
        "        nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),\n",
        "        nn.ReLU(),\n",
        "        nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),\n",
        "        nn.ReLU(),\n",
        "        nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),\n",
        "        nn.ReLU(),\n",
        "        nn.MaxPool2d(kernel_size=2, stride=2))\n",
        "        self.drop_out = nn.Dropout()\n",
        "        self.fc1 = nn.Linear(7 * 7 * 512, 1000)\n",
        "        self.fc2 = nn.Linear(1000, 2)\n",
        "    def forward(self, x):\n",
        "        out = self.layer1(x)\n",
        "        out = self.layer2(out)\n",
        "        out = self.layer3(out)\n",
        "        out = self.layer4(out)\n",
        "        out = self.layer5(out)\n",
        "        out = out.reshape(out.size(0), -1)\n",
        "        out = self.drop_out(out)\n",
        "        out = F.relu(self.fc1(out))\n",
        "        out = self.fc2(out)\n",
        "        return out"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PtzuVPET7a-B"
      },
      "source": [
        "### Computing Loss:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ojo5VJch7a-C"
      },
      "source": [
        "model = NN()\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.Adam(model.parameters(), lr=learning_rate)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-JIDxXYb7a-D"
      },
      "source": [
        "### Train Network:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GCFPdr397a-D"
      },
      "source": [
        "total_step = len(trainloader)\n",
        "loss_list = []\n",
        "acc_list = []\n",
        "for epoch in range(num_epochs):\n",
        "    for i, (images, labels) in enumerate(trainloader):\n",
        "        outputs = model(images)\n",
        "        loss = criterion(outputs, labels)\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        total = labels.size(0)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "        correct = (predicted == labels).sum().item()\n",
        "        print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}, Accuracy: {:.2f}%'.format(epoch + 1, num_epochs, i + 1, total_step, loss.item(),(correct / total) * 100))\n",
        "        loss_list.append(loss.item())\n",
        "        acc_list.append(correct / total)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2IYTKsuc7a-E"
      },
      "source": [
        "pd.DataFrame(acc_list).to_excel('accuracies.xlsx')\n",
        "pd.DataFrame(loss_list).to_excel('losses.xlsx')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dkqrOc_d7a-E"
      },
      "source": [
        "### Save Trained Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1sl_1dWQ7a-E"
      },
      "source": [
        "torch.save(model.state_dict(), \"./pain_detection_nn.pth\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gg8n9Mn57a-E"
      },
      "source": [
        "### Test Network Performance"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ReqMDyb_7a-E",
        "outputId": "9cfa213e-e12e-4fe6-b4fc-4da7a7d9da7b"
      },
      "source": [
        "#load Model\n",
        "model = NN()\n",
        "model.load_state_dict(torch.load(\"pain_detection_nn.pth\"))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<All keys matched successfully>"
            ]
          },
          "execution_count": 16,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CDUZ0DFj7a-F",
        "outputId": "8783111b-8b7a-4a74-af9b-b7341cb5b3bb"
      },
      "source": [
        "model.eval()\n",
        "actual_outputs=[]\n",
        "predicted_outputs=[]\n",
        "with torch.no_grad():\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    for images, labels in testloader:\n",
        "        actual_outputs.append(labels.item())\n",
        "        outputs = model(images)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "        predicted_outputs.append(predicted.item())\n",
        "        total += labels.size(0)\n",
        "        correct += (predicted == labels).sum().item()\n",
        "accuracy = (correct / total) * 100\n",
        "print('The test accuracy is: {} %'.format(accuracy))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The test accuracy is: 92.25 %\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_KbqQi9W7a-F"
      },
      "source": [
        "cm = confusion_matrix(actual_outputs, predicted_outputs)\n",
        "df_cm = pd.DataFrame(cm, index = [\"No Pain\", \"Pain\"],\n",
        "                  columns = [\"No Pain\", \"Pain\"])\n",
        "plt.figure(figsize = (10,7))\n",
        "sn.heatmap(df_cm, annot=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FDjEAiXg7a-F"
      },
      "source": [
        "### Test Network with new images"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": false,
        "id": "gCOedGjA7a-F"
      },
      "source": [
        "#Open Image\n",
        "root = tk.Tk()\n",
        "root.withdraw()\n",
        "path = filedialog.askopenfilename()\n",
        "new_img = cv2.imread(path)\n",
        "processed_img = preprocess_img(new_img, 224)\n",
        "plt.imshow(cv2.cvtColor(processed_img, cv2.COLOR_BGR2RGB))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "It5KVG0w7a-G"
      },
      "source": [
        "#Preprocess Image\n",
        "tran = transforms.Compose(\n",
        "    [transforms.ToTensor(),\n",
        "     transforms.Normalize((0.5,), (0.5,))])\n",
        "processed_img = tran(processed_img)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TbTYjC6T7a-G"
      },
      "source": [
        "#Assess Pain\n",
        "output = model(processed_img[None,...])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "XVfOLQfM7a-G"
      },
      "source": [
        "value, index = torch.max(output, 1)\n",
        "if index==0:\n",
        "    print(\"No Pain\")\n",
        "else:\n",
        "    print(\"Pain\")\n"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}