Quality_Evalution_Model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8bf94f64-f8dd-4c48-acdc-3efe64e864c3",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "8bf94f64-f8dd-4c48-acdc-3efe64e864c3",
    "outputId": "d44760ac-2fd5-4e9b-d5c9-5b0dfdb906f0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defaulting to user installation because normal site-packages is not writeable\n",
      "Requirement already satisfied: nibabel in /home/lrangar/.local/lib/python3.9/site-packages (5.0.1)\n",
      "Requirement already satisfied: setuptools in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from nibabel) (61.2.0)\n",
      "Requirement already satisfied: packaging>=17 in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from nibabel) (21.3)\n",
      "Requirement already satisfied: numpy>=1.19 in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from nibabel) (1.21.5)\n",
      "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from packaging>=17->nibabel) (3.0.4)\n",
      "Defaulting to user installation because normal site-packages is not writeable\n",
      "Requirement already satisfied: torch in /home/lrangar/.local/lib/python3.9/site-packages (2.0.0)\n",
      "Requirement already satisfied: typing-extensions in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from torch) (4.1.1)\n",
      "Requirement already satisfied: jinja2 in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from torch) (2.11.3)\n",
      "Requirement already satisfied: nvidia-curand-cu11==10.2.10.91 in /home/lrangar/.local/lib/python3.9/site-packages (from torch) (10.2.10.91)\n",
      "Requirement already satisfied: filelock in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from torch) (3.6.0)\n",
      "Requirement already satisfied: nvidia-nccl-cu11==2.14.3 in /home/lrangar/.local/lib/python3.9/site-packages (from torch) (2.14.3)\n",
      "Requirement already satisfied: nvidia-cuda-nvrtc-cu11==11.7.99 in /home/lrangar/.local/lib/python3.9/site-packages (from torch) (11.7.99)\n",
      "Requirement already satisfied: nvidia-cublas-cu11==11.10.3.66 in /home/lrangar/.local/lib/python3.9/site-packages (from torch) (11.10.3.66)\n",
      "Requirement already satisfied: nvidia-cuda-runtime-cu11==11.7.99 in /home/lrangar/.local/lib/python3.9/site-packages (from torch) (11.7.99)\n",
      "Requirement already satisfied: nvidia-cuda-cupti-cu11==11.7.101 in /home/lrangar/.local/lib/python3.9/site-packages (from torch) (11.7.101)\n",
      "Requirement already satisfied: nvidia-cusolver-cu11==11.4.0.1 in /home/lrangar/.local/lib/python3.9/site-packages (from torch) (11.4.0.1)\n",
      "Requirement already satisfied: nvidia-nvtx-cu11==11.7.91 in /home/lrangar/.local/lib/python3.9/site-packages (from torch) (11.7.91)\n",
      "Requirement already satisfied: triton==2.0.0 in /home/lrangar/.local/lib/python3.9/site-packages (from torch) (2.0.0)\n",
      "Requirement already satisfied: networkx in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from torch) (2.7.1)\n",
      "Requirement already satisfied: nvidia-cudnn-cu11==8.5.0.96 in /home/lrangar/.local/lib/python3.9/site-packages (from torch) (8.5.0.96)\n",
      "Requirement already satisfied: nvidia-cusparse-cu11==11.7.4.91 in /home/lrangar/.local/lib/python3.9/site-packages (from torch) (11.7.4.91)\n",
      "Requirement already satisfied: nvidia-cufft-cu11==10.9.0.58 in /home/lrangar/.local/lib/python3.9/site-packages (from torch) (10.9.0.58)\n",
      "Requirement already satisfied: sympy in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from torch) (1.10.1)\n",
      "Requirement already satisfied: wheel in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from nvidia-cublas-cu11==11.10.3.66->torch) (0.37.1)\n",
      "Requirement already satisfied: setuptools in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from nvidia-cublas-cu11==11.10.3.66->torch) (61.2.0)\n",
      "Requirement already satisfied: lit in /home/lrangar/.local/lib/python3.9/site-packages (from triton==2.0.0->torch) (15.0.7)\n",
      "Requirement already satisfied: cmake in /home/lrangar/.local/lib/python3.9/site-packages (from triton==2.0.0->torch) (3.26.0)\n",
      "Requirement already satisfied: MarkupSafe>=0.23 in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from jinja2->torch) (2.0.1)\n",
      "Requirement already satisfied: mpmath>=0.19 in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from sympy->torch) (1.2.1)\n",
      "Defaulting to user installation because normal site-packages is not writeable\n",
      "Requirement already satisfied: torch-summary in /home/lrangar/.local/lib/python3.9/site-packages (1.4.5)\n",
      "Defaulting to user installation because normal site-packages is not writeable\n",
      "Requirement already satisfied: torchmetrics in /home/lrangar/.local/lib/python3.9/site-packages (0.11.4)\n",
      "Requirement already satisfied: numpy>=1.17.2 in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from torchmetrics) (1.21.5)\n",
      "Requirement already satisfied: packaging in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from torchmetrics) (21.3)\n",
      "Requirement already satisfied: torch>=1.8.1 in /home/lrangar/.local/lib/python3.9/site-packages (from torchmetrics) (2.0.0)\n",
      "Requirement already satisfied: nvidia-cufft-cu11==10.9.0.58 in /home/lrangar/.local/lib/python3.9/site-packages (from torch>=1.8.1->torchmetrics) (10.9.0.58)\n",
      "Requirement already satisfied: nvidia-cusolver-cu11==11.4.0.1 in /home/lrangar/.local/lib/python3.9/site-packages (from torch>=1.8.1->torchmetrics) (11.4.0.1)\n",
      "Requirement already satisfied: nvidia-cuda-cupti-cu11==11.7.101 in /home/lrangar/.local/lib/python3.9/site-packages (from torch>=1.8.1->torchmetrics) (11.7.101)\n",
      "Requirement already satisfied: typing-extensions in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from torch>=1.8.1->torchmetrics) (4.1.1)\n",
      "Requirement already satisfied: nvidia-cuda-nvrtc-cu11==11.7.99 in /home/lrangar/.local/lib/python3.9/site-packages (from torch>=1.8.1->torchmetrics) (11.7.99)\n",
      "Requirement already satisfied: triton==2.0.0 in /home/lrangar/.local/lib/python3.9/site-packages (from torch>=1.8.1->torchmetrics) (2.0.0)\n",
      "Requirement already satisfied: nvidia-cudnn-cu11==8.5.0.96 in /home/lrangar/.local/lib/python3.9/site-packages (from torch>=1.8.1->torchmetrics) (8.5.0.96)\n",
      "Requirement already satisfied: filelock in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from torch>=1.8.1->torchmetrics) (3.6.0)\n",
      "Requirement already satisfied: nvidia-nccl-cu11==2.14.3 in /home/lrangar/.local/lib/python3.9/site-packages (from torch>=1.8.1->torchmetrics) (2.14.3)\n",
      "Requirement already satisfied: nvidia-nvtx-cu11==11.7.91 in /home/lrangar/.local/lib/python3.9/site-packages (from torch>=1.8.1->torchmetrics) (11.7.91)\n",
      "Requirement already satisfied: sympy in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from torch>=1.8.1->torchmetrics) (1.10.1)\n",
      "Requirement already satisfied: nvidia-cuda-runtime-cu11==11.7.99 in /home/lrangar/.local/lib/python3.9/site-packages (from torch>=1.8.1->torchmetrics) (11.7.99)\n",
      "Requirement already satisfied: jinja2 in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from torch>=1.8.1->torchmetrics) (2.11.3)\n",
      "Requirement already satisfied: nvidia-cublas-cu11==11.10.3.66 in /home/lrangar/.local/lib/python3.9/site-packages (from torch>=1.8.1->torchmetrics) (11.10.3.66)\n",
      "Requirement already satisfied: nvidia-curand-cu11==10.2.10.91 in /home/lrangar/.local/lib/python3.9/site-packages (from torch>=1.8.1->torchmetrics) (10.2.10.91)\n",
      "Requirement already satisfied: nvidia-cusparse-cu11==11.7.4.91 in /home/lrangar/.local/lib/python3.9/site-packages (from torch>=1.8.1->torchmetrics) (11.7.4.91)\n",
      "Requirement already satisfied: networkx in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from torch>=1.8.1->torchmetrics) (2.7.1)\n",
      "Requirement already satisfied: wheel in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from nvidia-cublas-cu11==11.10.3.66->torch>=1.8.1->torchmetrics) (0.37.1)\n",
      "Requirement already satisfied: setuptools in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from nvidia-cublas-cu11==11.10.3.66->torch>=1.8.1->torchmetrics) (61.2.0)\n",
      "Requirement already satisfied: cmake in /home/lrangar/.local/lib/python3.9/site-packages (from triton==2.0.0->torch>=1.8.1->torchmetrics) (3.26.0)\n",
      "Requirement already satisfied: lit in /home/lrangar/.local/lib/python3.9/site-packages (from triton==2.0.0->torch>=1.8.1->torchmetrics) (15.0.7)\n",
      "Requirement already satisfied: MarkupSafe>=0.23 in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from jinja2->torch>=1.8.1->torchmetrics) (2.0.1)\n",
      "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from packaging->torchmetrics) (3.0.4)\n",
      "Requirement already satisfied: mpmath>=0.19 in /software/spackages/linux-rocky8-x86_64/gcc-9.5.0/anaconda3-2022.05-zyrazrj6uvrtukupqzhaslr63w7hj6in/lib/python3.9/site-packages (from sympy->torch>=1.8.1->torchmetrics) (1.2.1)\n"
     ]
    }
   ],
   "source": [
    "!pip install nibabel\n",
    "!pip install torch\n",
    "!pip install torch-summary\n",
    "!pip install torchmetrics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b894e945-6e62-4b36-a916-9a2e0c04dc93",
   "metadata": {
    "id": "b894e945-6e62-4b36-a916-9a2e0c04dc93"
   },
   "source": [
    "Importing the libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "733b49ff-caba-4eda-b4ac-d30323f75879",
   "metadata": {
    "id": "733b49ff-caba-4eda-b4ac-d30323f75879"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import math\n",
    "import nibabel as nib\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4fd974db-f8ee-49da-9c7a-ac2a76c60307",
   "metadata": {
    "id": "4fd974db-f8ee-49da-9c7a-ac2a76c60307"
   },
   "outputs": [],
   "source": [
    "data_csv = pd.read_csv(\"labels.csv\") # Total 2059 entries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b919548-984b-4f8f-9f65-3dcca535f09e",
   "metadata": {
    "id": "1b919548-984b-4f8f-9f65-3dcca535f09e"
   },
   "source": [
    "Counting images belonging to different lables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d62892ee-6782-47b4-97a8-57badd37d3b9",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "d62892ee-6782-47b4-97a8-57badd37d3b9",
    "outputId": "a7f50d0a-35b7-4148-f3d3-1361e3b2b3a6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Y-N': 713, 'Y-Y': 0, 'N-Y': 1332, 'N-N': 15}\n"
     ]
    }
   ],
   "source": [
    "count_of_diff_lables = {\"Y-N\":0, \"Y-Y\":0, \"N-Y\":0, \"N-N\":0}\n",
    "\n",
    "'''\n",
    "Y-N = Input image consists of recognizable facial features with no brain feature loss.\n",
    "Y-Y = Input image consists of recognizable facial features and brain features are lost. => Image has only facial features.\n",
    "N-Y = Input image doesn't have recognizable facial features and there are brain features loss.\n",
    "N-N = Input image doesn't have recognizable facial features and there is no brain feature loss. => perfect desired sample.\n",
    "'''\n",
    "\n",
    "data_csv_shape = data_csv.shape\n",
    "data_y_n = []\n",
    "data_y_y = []\n",
    "data_n_y = []\n",
    "data_n_n = []\n",
    "\n",
    "for row_num in range(data_csv_shape[0]):\n",
    "    if data_csv.iloc[row_num][1] == \"Yes\" and data_csv.iloc[row_num][2] == \"No\":\n",
    "        count_of_diff_lables[\"Y-N\"] = count_of_diff_lables[\"Y-N\"] + 1\n",
    "        data_y_n.append(data_csv.iloc[row_num])\n",
    "    elif data_csv.iloc[row_num][1] == \"Yes\" and data_csv.iloc[row_num][2] == \"Yes\":\n",
    "        count_of_diff_lables[\"Y-Y\"] = count_of_diff_lables[\"Y-Y\"] + 1\n",
    "        data_y_y.append(data_csv.iloc[row_num])\n",
    "    elif data_csv.iloc[row_num][1] == \"No\" and data_csv.iloc[row_num][2] == \"Yes\":\n",
    "        count_of_diff_lables[\"N-Y\"] = count_of_diff_lables[\"N-Y\"] + 1\n",
    "        data_n_y.append(data_csv.iloc[row_num])\n",
    "    elif data_csv.iloc[row_num][1] == \"No\" and data_csv.iloc[row_num][2] == \"No\":\n",
    "        count_of_diff_lables[\"N-N\"] = count_of_diff_lables[\"N-N\"] + 1\n",
    "        data_n_n.append(data_csv.iloc[row_num])\n",
    "        \n",
    "print(count_of_diff_lables) #{'Y-N': 713, 'Y-Y': 0, 'N-Y': 1332, 'N-N': 15}\n",
    "data_y_n = pd.DataFrame(data_y_n)\n",
    "data_y_y = pd.DataFrame(data_y_y)\n",
    "data_n_y = pd.DataFrame(data_n_y)\n",
    "data_n_n = pd.DataFrame(data_n_n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae8a4ed0-baaa-46bf-9362-6683699b33cd",
   "metadata": {
    "id": "ae8a4ed0-baaa-46bf-9362-6683699b33cd"
   },
   "source": [
    "Train-Validation-Test splitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c9d900cf-20ea-4291-a51b-f78893051543",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "c9d900cf-20ea-4291-a51b-f78893051543",
    "outputId": "a86632e5-8de4-4269-ca70-65dfd85e1a74"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training_y_n samples size =  (428, 3)\n",
      "validation_y_n samples size =  (142, 3)\n",
      "testing_y_n samples size =  (143, 3)\n",
      "training_y_y samples size =  (0, 0)\n",
      "validation_y_y samples size =  (0, 0)\n",
      "testing_y_y samples size =  (0, 0)\n",
      "training_n_y samples size =  (800, 3)\n",
      "validation_n_y samples size =  (266, 3)\n",
      "testing_n_y samples size =  (266, 3)\n",
      "training_n_n samples size =  (9, 3)\n",
      "validation_n_n samples size =  (3, 3)\n",
      "testing_n_n samples size =  (3, 3)\n"
     ]
    }
   ],
   "source": [
    "data_y_n_shape = data_y_n.shape\n",
    "data_y_y_shape = data_y_y.shape\n",
    "data_n_y_shape = data_n_y.shape\n",
    "data_n_n_shape = data_n_n.shape\n",
    "\n",
    "training_samples = pd.DataFrame()\n",
    "validation_samples = pd.DataFrame()\n",
    "testing_samples = pd.DataFrame()\n",
    "\n",
    "#Y-N samples\n",
    "training_split_y_n = math.ceil(0.6*data_y_n_shape[0])\n",
    "validation_split_y_n = math.floor(data_y_n_shape[0]*0.2)\n",
    "\n",
    "training_samples_y_n = pd.DataFrame(data_y_n.iloc[0:training_split_y_n])\n",
    "validation_samples_y_n = pd.DataFrame(data_y_n.iloc[training_split_y_n: training_split_y_n + validation_split_y_n])\n",
    "testing_samples_y_n = pd.DataFrame(data_y_n.iloc[(training_split_y_n + validation_split_y_n):])\n",
    "\n",
    "print(\"training_y_n samples size = \", training_samples_y_n.shape)\n",
    "print(\"validation_y_n samples size = \", validation_samples_y_n.shape)\n",
    "print(\"testing_y_n samples size = \", testing_samples_y_n.shape)\n",
    "\n",
    "#Y-Y samples\n",
    "training_split_y_y = math.ceil(0.6*data_y_y_shape[0])\n",
    "validation_split_y_y = math.floor(data_y_y_shape[0]*0.2)\n",
    "\n",
    "training_samples_y_y = pd.DataFrame(data_y_y.iloc[0:training_split_y_y])\n",
    "validation_samples_y_y = pd.DataFrame(data_y_y.iloc[training_split_y_y: training_split_y_y + validation_split_y_y])\n",
    "testing_samples_y_y = pd.DataFrame(data_y_y.iloc[(training_split_y_y + validation_split_y_y):])\n",
    "\n",
    "print(\"training_y_y samples size = \", training_samples_y_y.shape)\n",
    "print(\"validation_y_y samples size = \", validation_samples_y_y.shape)\n",
    "print(\"testing_y_y samples size = \", testing_samples_y_y.shape)\n",
    "\n",
    "#N-Y samples\n",
    "training_split_n_y = math.ceil(0.6*data_n_y_shape[0])\n",
    "validation_split_n_y = math.floor(data_n_y_shape[0]*0.2)\n",
    "\n",
    "training_samples_n_y = pd.DataFrame(data_n_y.iloc[0:training_split_n_y])\n",
    "validation_samples_n_y = pd.DataFrame(data_n_y.iloc[training_split_n_y: training_split_n_y + validation_split_n_y])\n",
    "testing_samples_n_y = pd.DataFrame(data_n_y.iloc[(training_split_n_y + validation_split_n_y):])\n",
    "\n",
    "print(\"training_n_y samples size = \", training_samples_n_y.shape)\n",
    "print(\"validation_n_y samples size = \", validation_samples_n_y.shape)\n",
    "print(\"testing_n_y samples size = \", testing_samples_n_y.shape)\n",
    "\n",
    "#N-N samples\n",
    "training_split_n_n = math.ceil(0.6*data_n_n_shape[0])\n",
    "validation_split_n_n = math.floor(data_n_n_shape[0]*0.2)\n",
    "\n",
    "training_samples_n_n = pd.DataFrame(data_n_n.iloc[0:training_split_n_n])\n",
    "validation_samples_n_n = pd.DataFrame(data_n_n.iloc[training_split_n_n: training_split_n_n + validation_split_n_n])\n",
    "testing_samples_n_n = pd.DataFrame(data_n_n.iloc[(training_split_n_n + validation_split_n_n):])\n",
    "\n",
    "print(\"training_n_n samples size = \", training_samples_n_n.shape)\n",
    "print(\"validation_n_n samples size = \", validation_samples_n_n.shape)\n",
    "print(\"testing_n_n samples size = \", testing_samples_n_n.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3639e704-06e1-4942-b4d2-baee038c6105",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "3639e704-06e1-4942-b4d2-baee038c6105",
    "outputId": "b683a3f1-36fa-49d4-80d2-6c278f1043c4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of training data =  (1237, 3)\n",
      "Size of validation data =  (411, 3)\n",
      "Size of testing data =  (412, 3)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/local_scratch/pbs.484873.pbs02/ipykernel_3937719/393655029.py:2: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  training_samples = training_samples_y_n.append(training_samples_n_y, ignore_index=True)\n",
      "/local_scratch/pbs.484873.pbs02/ipykernel_3937719/393655029.py:3: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  training_samples = training_samples.append(training_samples_n_n, ignore_index=True)\n",
      "/local_scratch/pbs.484873.pbs02/ipykernel_3937719/393655029.py:11: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  validation_samples = validation_samples_y_n.append(validation_samples_n_y, ignore_index=True)\n",
      "/local_scratch/pbs.484873.pbs02/ipykernel_3937719/393655029.py:12: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  validation_samples = validation_samples.append(validation_samples_n_n, ignore_index=True)\n",
      "/local_scratch/pbs.484873.pbs02/ipykernel_3937719/393655029.py:20: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  testing_samples = testing_samples_y_n.append(testing_samples_n_y, ignore_index=True)\n",
      "/local_scratch/pbs.484873.pbs02/ipykernel_3937719/393655029.py:21: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  testing_samples = testing_samples.append(testing_samples_n_n, ignore_index=True)\n"
     ]
    }
   ],
   "source": [
    "#Training samples\n",
    "training_samples = training_samples_y_n.append(training_samples_n_y, ignore_index=True)\n",
    "training_samples = training_samples.append(training_samples_n_n, ignore_index=True)\n",
    "#Shuffling the data set\n",
    "training_samples = training_samples.sample(n = training_samples.shape[0], axis=0)\n",
    "print(\"Size of training data = \", training_samples.shape)\n",
    "training_labels = [[1 if training_samples.iloc[row][1] == \"Yes\" else 0, \n",
    "                    1 if training_samples.iloc[row][2] == \"Yes\" else 0] for row in range(training_samples.shape[0])]\n",
    "\n",
    "#Validation samples\n",
    "validation_samples = validation_samples_y_n.append(validation_samples_n_y, ignore_index=True)\n",
    "validation_samples = validation_samples.append(validation_samples_n_n, ignore_index=True)\n",
    "#Shuffling the data set\n",
    "validation_samples = validation_samples.sample(n = validation_samples.shape[0], axis=0)\n",
    "print(\"Size of validation data = \", validation_samples.shape)\n",
    "validation_labels = [[1 if validation_samples.iloc[row][1] == \"Yes\" else 0, \n",
    "                      1 if validation_samples.iloc[row][2] == \"Yes\" else 0] for row in range(validation_samples.shape[0])]\n",
    "\n",
    "#Testing samples\n",
    "testing_samples = testing_samples_y_n.append(testing_samples_n_y, ignore_index=True)\n",
    "testing_samples = testing_samples.append(testing_samples_n_n, ignore_index=True)\n",
    "#Shuffling the data set\n",
    "testing_samples = testing_samples.sample(n = testing_samples.shape[0], axis=0)\n",
    "print(\"Size of testing data = \", testing_samples.shape)\n",
    "testing_labels = [[1 if testing_samples.iloc[row][1] == \"Yes\" else 0, \n",
    "                   1 if testing_samples.iloc[row][2] == \"Yes\" else 0] for row in range(testing_samples.shape[0])]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "cfa66386-c820-491b-b84b-421ed1c8fbd1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Are there any null values in training samples =  False\n",
      "Are there any null values in validation samples =  False\n",
      "Are there any null values in testing samples =  False\n"
     ]
    }
   ],
   "source": [
    "#Checking if the datasets contain any null values\n",
    "print(\"Are there any null values in training samples = \", training_samples.isnull().values.any())\n",
    "print(\"Are there any null values in validation samples = \", validation_samples.isnull().values.any())\n",
    "print(\"Are there any null values in testing samples = \", testing_samples.isnull().values.any())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "DuXUFVEQNoTB",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "DuXUFVEQNoTB",
    "outputId": "e1a71f09-6802-4cc4-b485-26ef0893c415"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'nibabel.nifti1.Nifti1Header'> object, endian='<'\n",
      "sizeof_hdr      : 348\n",
      "data_type       : b''\n",
      "db_name         : b''\n",
      "extents         : 16384\n",
      "session_error   : 0\n",
      "regular         : b'r'\n",
      "dim_info        : 0\n",
      "dim             : [  3 256 256 150   1   0   0   0]\n",
      "intent_p1       : 0.0\n",
      "intent_p2       : 0.0\n",
      "intent_p3       : 0.0\n",
      "intent_code     : none\n",
      "datatype        : int16\n",
      "bitpix          : 16\n",
      "slice_start     : 0\n",
      "pixdim          : [1.       0.9375   0.9375   1.200002 1.       1.       1.       1.      ]\n",
      "vox_offset      : 0.0\n",
      "scl_slope       : nan\n",
      "scl_inter       : nan\n",
      "slice_end       : 0\n",
      "slice_code      : unknown\n",
      "xyzt_units      : 2\n",
      "cal_max         : 0.0\n",
      "cal_min         : 0.0\n",
      "slice_duration  : 0.0\n",
      "toffset         : 0.0\n",
      "glmax           : 32767\n",
      "glmin           : 0\n",
      "descrip         : b'bse -n 3 -d 25 -s 0.84 -r 2 -i ixi_dataset/IXI156-Guys-0837-T1.nii.gz'\n",
      "aux_file        : b''\n",
      "qform_code      : scanner\n",
      "sform_code      : scanner\n",
      "quatern_b       : 0.4382675\n",
      "quatern_c       : 0.47557345\n",
      "quatern_d       : -0.46727434\n",
      "qoffset_x       : -97.93478\n",
      "qoffset_y       : 114.60675\n",
      "qoffset_z       : -92.444275\n",
      "srow_x          : [ 7.6416098e-02 -1.6447876e-02  1.1958237e+00 -9.7934776e+01]\n",
      "srow_y          : [-9.3438047e-01 -1.3451996e-03  9.7797610e-02  1.1460675e+02]\n",
      "srow_z          : [-4.8894847e-08  9.3735468e-01  2.1123609e-02 -9.2444275e+01]\n",
      "intent_name     : b''\n",
      "magic           : b'n+1'\n"
     ]
    }
   ],
   "source": [
    "path = \"files/\"\n",
    "extension = \".gz\"\n",
    "image = nib.load(os.path.join(path, training_samples.iloc[0][0] + extension))\n",
    "print(image.header)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "45a6e24e-ea8e-464c-b2c1-7c8f3ba9a5e8",
   "metadata": {
    "id": "45a6e24e-ea8e-464c-b2c1-7c8f3ba9a5e8"
   },
   "source": [
    "Visualizing the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "fkNQCy78VJ7C",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 239
    },
    "id": "fkNQCy78VJ7C",
    "outputId": "9bbd8fda-8b77-4989-ee8e-8d6c5cf3009e"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1440x1440 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Load the image\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "path = \"files/\"\n",
    "extension = \".gz\"\n",
    "for row in range(training_samples.shape[0]):\n",
    "    image = nib.load(os.path.join(path, training_samples.iloc[row][0] + extension))\n",
    "    image_array = image.get_fdata()\n",
    "    image_array = image_array/255\n",
    "    \n",
    "    for i in range(1,5):\n",
    "        plt.subplot(5, 5,i + 1)\n",
    "        plt.imshow(image_array[:,:,(70)])\n",
    "        plt.gcf().set_size_inches(20, 20)\n",
    "    plt.show()\n",
    "    break\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f33929c8-931b-41c4-bf7a-71d566e724fb",
   "metadata": {
    "id": "f33929c8-931b-41c4-bf7a-71d566e724fb"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.utils.data import Dataset\n",
    "import numpy as np\n",
    "\n",
    "#Creating custom dataset class\n",
    "class CustomDataset(Dataset):\n",
    "    def __init__(self, data):\n",
    "        self.data = data\n",
    "        self.path = \"files/\"\n",
    "        self.extension = \".gz\"\n",
    "        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.data.shape[0]\n",
    "\n",
    "    def __getitem__(self, idx):  \n",
    "        image = nib.load(os.path.join(self.path, self.data.iloc[idx][0] + self.extension)).get_fdata()\n",
    "        #Preprocessing - scaling image pixel values to 0-1 by performing Min-Max normalization.\n",
    "        max_pixel = np.amax(image)\n",
    "        min_pixel = np.amin(image)\n",
    "        image = (image - min_pixel) / (max_pixel - min_pixel)\n",
    "        #Extracting the first 130 channels as they have most important information. \n",
    "        image = image[:,:,0:64]\n",
    "        image = torch.tensor(image, dtype=torch.float64, device='cuda')\n",
    "        #Expanding the dimensions of the image. Converting (x,x,x) to  (x,x,x,1)\n",
    "        image = torch.unsqueeze(image, 3)\n",
    "        image = torch.reshape(image, (image.shape[3], image.shape[2], image.shape[0], image.shape[1]))\n",
    "\n",
    "        label_1 = 1 if self.data.iloc[idx][1] == \"Yes\" else 0 \n",
    "        label_1 = torch.tensor(label_1, device = self.device, dtype=torch.float64)\n",
    "        label_2 = 1 if self.data.iloc[idx][2] == \"Yes\" else 0\n",
    "        label_2 = torch.tensor(label_2, device = self.device, dtype=torch.float64)\n",
    "    \n",
    "        return image, label_1, label_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "a019d9df-6c40-44f7-b6bf-03ce500c207d",
   "metadata": {
    "id": "a019d9df-6c40-44f7-b6bf-03ce500c207d"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchsummary\n",
    "from torch import nn\n",
    "from torchsummary import summary\n",
    "\n",
    "\n",
    "#Model\n",
    "class Model(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Model, self).__init__()\n",
    "        device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Conv3d(in_channels = 1, out_channels = 5, kernel_size = (3, 3, 3), stride = 2, padding = 0, bias = True, device=device, dtype=torch.float64),\n",
    "            nn.ReLU(inplace=False),\n",
    "            nn.MaxPool3d(kernel_size = 3, stride = 2),\n",
    "            nn.BatchNorm3d(5, device=device, dtype=torch.float64),\n",
    "            \n",
    "            nn.Conv3d(in_channels = 5, out_channels = 3, kernel_size = (3, 3, 3), stride = 1, padding = 0, bias = True, device=device, dtype=torch.float64),\n",
    "            nn.ReLU(inplace=False),\n",
    "            nn.MaxPool3d(kernel_size = 3, stride = 2),\n",
    "            nn.BatchNorm3d(3, device=device, dtype=torch.float64),\n",
    "            \n",
    "            nn.Conv3d(in_channels = 3, out_channels = 2, kernel_size = (3, 3, 3), stride = 1, padding = 0, bias = True, device=device, dtype=torch.float64),\n",
    "            nn.ReLU(inplace=False),\n",
    "            nn.MaxPool3d(kernel_size = 3, stride = 2),\n",
    "            nn.BatchNorm3d(2, device=device, dtype=torch.float64),\n",
    "    \n",
    "            nn.Flatten(),\n",
    "\n",
    "            nn.Linear(in_features = 338, out_features = 9, bias = True, device = 'cuda', dtype=torch.float64),\n",
    "            # nn.Linear(in_features = 30, out_features = 9, bias = True, device = 'cuda', dtype=torch.float64),\n",
    "            nn.Linear(in_features = 9, out_features = 2, bias = True, device = 'cuda', dtype=torch.float64),\n",
    "            nn.Sigmoid()\n",
    "        )\n",
    "        \n",
    "    def forward(self, input_image):\n",
    "        return self.layers(input_image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "UioIv_TaL37N",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "UioIv_TaL37N",
    "outputId": "36488554-fd5f-426f-d998-eb9d86917ab0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==========================================================================================\n",
      "Layer (type:depth-idx)                   Output Shape              Param #\n",
      "==========================================================================================\n",
      "├─Conv3d: 1-1                            [-1, 5, 31, 127, 127]     140\n",
      "├─ReLU: 1-2                              [-1, 5, 31, 127, 127]     --\n",
      "├─MaxPool3d: 1-3                         [-1, 5, 15, 63, 63]       --\n",
      "├─BatchNorm3d: 1-4                       [-1, 5, 15, 63, 63]       10\n",
      "├─Conv3d: 1-5                            [-1, 3, 13, 61, 61]       408\n",
      "├─ReLU: 1-6                              [-1, 3, 13, 61, 61]       --\n",
      "├─MaxPool3d: 1-7                         [-1, 3, 6, 30, 30]        --\n",
      "├─BatchNorm3d: 1-8                       [-1, 3, 6, 30, 30]        6\n",
      "├─Conv3d: 1-9                            [-1, 2, 4, 28, 28]        164\n",
      "├─ReLU: 1-10                             [-1, 2, 4, 28, 28]        --\n",
      "├─MaxPool3d: 1-11                        [-1, 2, 1, 13, 13]        --\n",
      "├─BatchNorm3d: 1-12                      [-1, 2, 1, 13, 13]        4\n",
      "├─Flatten: 1-13                          [-1, 338]                 --\n",
      "├─Linear: 1-14                           [-1, 9]                   3,051\n",
      "├─Linear: 1-15                           [-1, 2]                   20\n",
      "├─Sigmoid: 1-16                          [-1, 2]                   --\n",
      "==========================================================================================\n",
      "Total params: 3,803\n",
      "Trainable params: 3,803\n",
      "Non-trainable params: 0\n",
      "Total mult-adds (M): 87.60\n",
      "==========================================================================================\n",
      "Input size (MB): 16.00\n",
      "Forward/backward pass size (MB): 22.63\n",
      "Params size (MB): 0.01\n",
      "Estimated Total Size (MB): 38.64\n",
      "==========================================================================================\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "==========================================================================================\n",
       "Layer (type:depth-idx)                   Output Shape              Param #\n",
       "==========================================================================================\n",
       "├─Conv3d: 1-1                            [-1, 5, 31, 127, 127]     140\n",
       "├─ReLU: 1-2                              [-1, 5, 31, 127, 127]     --\n",
       "├─MaxPool3d: 1-3                         [-1, 5, 15, 63, 63]       --\n",
       "├─BatchNorm3d: 1-4                       [-1, 5, 15, 63, 63]       10\n",
       "├─Conv3d: 1-5                            [-1, 3, 13, 61, 61]       408\n",
       "├─ReLU: 1-6                              [-1, 3, 13, 61, 61]       --\n",
       "├─MaxPool3d: 1-7                         [-1, 3, 6, 30, 30]        --\n",
       "├─BatchNorm3d: 1-8                       [-1, 3, 6, 30, 30]        6\n",
       "├─Conv3d: 1-9                            [-1, 2, 4, 28, 28]        164\n",
       "├─ReLU: 1-10                             [-1, 2, 4, 28, 28]        --\n",
       "├─MaxPool3d: 1-11                        [-1, 2, 1, 13, 13]        --\n",
       "├─BatchNorm3d: 1-12                      [-1, 2, 1, 13, 13]        4\n",
       "├─Flatten: 1-13                          [-1, 338]                 --\n",
       "├─Linear: 1-14                           [-1, 9]                   3,051\n",
       "├─Linear: 1-15                           [-1, 2]                   20\n",
       "├─Sigmoid: 1-16                          [-1, 2]                   --\n",
       "==========================================================================================\n",
       "Total params: 3,803\n",
       "Trainable params: 3,803\n",
       "Non-trainable params: 0\n",
       "Total mult-adds (M): 87.60\n",
       "==========================================================================================\n",
       "Input size (MB): 16.00\n",
       "Forward/backward pass size (MB): 22.63\n",
       "Params size (MB): 0.01\n",
       "Estimated Total Size (MB): 38.64\n",
       "=========================================================================================="
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "model = nn.Sequential(\n",
    "            nn.Conv3d(in_channels = 1, out_channels = 5, kernel_size = (3, 3, 3), stride = 2, padding = 0, bias = True, device=device, dtype=torch.float64),\n",
    "            nn.ReLU(inplace=False),\n",
    "            nn.MaxPool3d(kernel_size = 3, stride = 2),\n",
    "            nn.BatchNorm3d(5, device=device, dtype=torch.float64),\n",
    "            \n",
    "            nn.Conv3d(in_channels = 5, out_channels = 3, kernel_size = (3, 3, 3), stride = 1, padding = 0, bias = True, device=device, dtype=torch.float64),\n",
    "            nn.ReLU(inplace=False),\n",
    "            nn.MaxPool3d(kernel_size = 3, stride = 2),\n",
    "            nn.BatchNorm3d(3, device=device, dtype=torch.float64),\n",
    "            \n",
    "            nn.Conv3d(in_channels = 3, out_channels = 2, kernel_size = (3, 3, 3), stride = 1, padding = 0, bias = True, device=device, dtype=torch.float64),\n",
    "            nn.ReLU(inplace=False),\n",
    "            nn.MaxPool3d(kernel_size = 3, stride = 2),\n",
    "            nn.BatchNorm3d(2, device=device, dtype=torch.float64),\n",
    "    \n",
    "            # nn.Conv3d(in_channels = 3, out_channels = 2, kernel_size = (3, 3, 3), stride = 1, padding = 0, bias = True, device=device, dtype=torch.float64),\n",
    "            # nn.ReLU(inplace=False),\n",
    "            # nn.MaxPool3d(kernel_size = 3, stride = 2),\n",
    "            # nn.BatchNorm3d(2, device=device, dtype=torch.float64),\n",
    "    \n",
    "            nn.Flatten(),\n",
    "\n",
    "            nn.Linear(in_features = 338, out_features = 9, bias = True, device = 'cuda', dtype=torch.float64),\n",
    "            # nn.Linear(in_features = 30, out_features = 9, bias = True, device = 'cuda', dtype=torch.float64),\n",
    "            nn.Linear(in_features = 9, out_features = 2, bias = True, device = 'cuda', dtype=torch.float64),\n",
    "            nn.Sigmoid()\n",
    "        )\n",
    "\n",
    "summary(model, (1, 64,256,256), dtypes=[torch.float64])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "nxRzjwhWc3yH",
   "metadata": {
    "id": "nxRzjwhWc3yH"
   },
   "outputs": [],
   "source": [
    "from tabulate import tabulate\n",
    "\n",
    "def tabulate_epoch_meter(elapsed_time, acc, loss, metrics = None):\n",
    "    \"\"\" Tabulate total average value of meters every epoch.\n",
    "\n",
    "    Args:\n",
    "        eplased_time (float): The elapsed time of a epoch.\n",
    "        meter_list (list or tuple of AverageMeter): A list of meters.\n",
    "    \"\"\"\n",
    "    epoch_metric = {}\n",
    "    epoch_metric[\"Accuracy\"] = [acc]\n",
    "    epoch_metric[\"loss\"] = [loss]\n",
    "    epoch_metric[\"time\"] = [elapsed_time]\n",
    "    table = tabulate(epoch_metric, headers=\"keys\", tablefmt=\"github\", floatfmt=\".5f\")\n",
    "    table = table.split(\"\\n\")\n",
    "    table = \"\\n\".join([table[1]] + table)\n",
    "    print(table)\n",
    "    if metrics != None:\n",
    "        headers = [\"sensitivity_ff\", \"sensitivity_bl\", \"specificity_ff\", \"specificity_bl\"]\n",
    "        print(tabulate(metrics.items(), headers = headers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "DWWamRNlhM-1",
   "metadata": {
    "id": "DWWamRNlhM-1"
   },
   "outputs": [],
   "source": [
    "def cal_acc(actual, predicted):\n",
    "    if len(actual) != len(predicted):\n",
    "        print(\"[ERROR] actual and predicted doesn't have same shape\")\n",
    "        return\n",
    "    \n",
    "    correctly_predicted_recog_facial_features = [actual[row][0]==predicted[row][0] for row in range(len(actual))]\n",
    "    correctly_predicted_brain_feature_loss = [actual[row][1]==predicted[row][1] for row in range(len(actual))]\n",
    "    \n",
    "    facial_features_acc = (sum(correctly_predicted_recog_facial_features) / len(actual)) * 100\n",
    "    brain_loss_acc = (sum(correctly_predicted_brain_feature_loss) / len(actual)) * 100\n",
    "    return (facial_features_acc, brain_loss_acc) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "72d45d31-de96-41ae-8d5c-3016a84a6405",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def cal_confusion_matrices(actual, predicted):\n",
    "    if len(actual) != len(predicted):\n",
    "        print(\"[ERROR] actual and predicted doesn't have same shape\")\n",
    "        return\n",
    "    \n",
    "    confusion_matrics_ff = torch.zeros(2, 2)\n",
    "    confusion_matrics_bl = torch.zeros(2, 2)\n",
    "    \n",
    "    for row in range(len(actual)):\n",
    "        row = predicted[row][0]\n",
    "        col = actual[row][0]\n",
    "        confusion_matrics_ff[row][col] = confusion_matrics_ff[row][col] + 1\n",
    "        \n",
    "        row = predicted[row][1]\n",
    "        col = actual[row][1]\n",
    "        confusion_matrics_bl[row][col] = confusion_matrics_bl[row][col] + 1\n",
    "        \n",
    "    return {\"confusion_matrics_ff\": confusion_matrics_ff, \"confusion_matrics_bl\": confusion_matrics_bl}\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f433f999-c6e3-4e58-9c9f-1f923e1cbf9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cal_sensitivity(confusion_matrix):\n",
    "    return (confusion_matrix[0][0]) / (confusion_matrix[0][0] + confusion_matrix[0][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "ab4c8eec-ec4e-4156-9409-4f6c46251c56",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cal_specificity(confusion_matrix):\n",
    "    return (confusion_matrix[1][1]) / (confusion_matrix[1][0] + confusion_matrix[1][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "914315c3-7689-480f-8c75-3d7992ffa637",
   "metadata": {},
   "outputs": [],
   "source": [
    "def unpack_labels(label_1, label_2):\n",
    "    labels = []\n",
    "    for row in range(len(label_1)):\n",
    "        labels.append([label_1[row], label_2[row]])\n",
    "  \n",
    "    return labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "3a2a6ad9-8ea6-488f-9828-5ace9969140f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_checkpoint(state, epochs):\n",
    "    filepath = \"Model/model_after_\" + str(epochs) + \"_epochs.tar\"\n",
    "    torch.save(state, filepath)\n",
    "    print('[info] Finish saving the model')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "EZIy9UMcYuJt",
   "metadata": {
    "id": "EZIy9UMcYuJt"
   },
   "source": [
    "Training the model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "4a477109-078a-4612-89d1-b0064c910688",
   "metadata": {},
   "outputs": [],
   "source": [
    "training_accuracies = []\n",
    "validation_accuracies = []\n",
    "training_losses = []\n",
    "validation_losses = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "16828e52-9e8e-4731-8c52-7a8165461690",
   "metadata": {
    "id": "16828e52-9e8e-4731-8c52-7a8165461690"
   },
   "outputs": [],
   "source": [
    "def train(model, train_loader, optimizer) :\n",
    "    predicted_val = []\n",
    "    device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "    model.train() \n",
    "    \n",
    "    for batch_idx, batch in enumerate(train_loader):\n",
    "        image = batch[0]\n",
    "        label_1 = batch[1]\n",
    "        label_2 = batch[2]\n",
    "        labels = unpack_labels(label_1, label_2)\n",
    "        labels = torch.tensor(labels, device=device, dtype = torch.float64)\n",
    "\n",
    "        y_pred = model(image)\n",
    "        #print(\"len of y_pred = \", len(y_pred))\n",
    "        \n",
    "        binary_crossentropy_loss = nn.BCELoss()\n",
    "        loss = binary_crossentropy_loss(y_pred, labels)\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        #Check the threshold\n",
    "        for row in range(len(y_pred)):\n",
    "            pred_lables = []\n",
    "            if y_pred[row][0] >= 0.4:\n",
    "                pred_lables.append(1)\n",
    "            else:\n",
    "                pred_lables.append(0)\n",
    "            if y_pred[row][1] >= 0.4:\n",
    "                pred_lables.append(1)\n",
    "            else:\n",
    "                pred_lables.append(0)\n",
    "            predicted_val.append(pred_lables)\n",
    "\n",
    "    return predicted_val, loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "MHsGmW8Xj1BA",
   "metadata": {
    "id": "MHsGmW8Xj1BA"
   },
   "outputs": [],
   "source": [
    "def test(model, val_loader):\n",
    "    device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "\n",
    "    model.eval()\n",
    "    loss = []\n",
    "    predicted_val = []\n",
    "    start_time = time.time()\n",
    "    for batch_idx, batch in enumerate(val_loader):\n",
    "        image = batch[0]\n",
    "        label_1 = batch[1]\n",
    "        label_2 = batch[2]\n",
    "        labels = unpack_labels(label_1, label_2)\n",
    "        labels = torch.tensor(labels, device=device, dtype = torch.float64)\n",
    "    \n",
    "        with torch.no_grad():\n",
    "            y_pred = model(image)\n",
    "            binary_crossentropy_loss = nn.BCELoss()\n",
    "            loss_ = binary_crossentropy_loss(y_pred, labels)\n",
    "            loss.append(loss_)\n",
    "\n",
    "        #Check the threshold\n",
    "        for row in range(len(y_pred)):\n",
    "            pred_lables = []\n",
    "            if y_pred[row][0] >= 0.4:\n",
    "                pred_lables.append(1)\n",
    "            else:\n",
    "                pred_lables.append(0)\n",
    "            if y_pred[0][1] >= 0.4:\n",
    "                pred_lables.append(1)\n",
    "            else:\n",
    "                pred_lables.append(0)\n",
    "            predicted_val.append(pred_lables)\n",
    "\n",
    "    acc = cal_acc(validation_labels, predicted_val)\n",
    "    validation_accuracies.append(acc)\n",
    "    validation_losses.append(sum(loss)/len(loss))\n",
    "    \n",
    "    conf_matrices = cal_confusion_matrices(validation_labels, predicted_val)\n",
    "    \n",
    "    sensitivity_ff = cal_sensitivity(conf_matrices['confusion_matrics_ff'])\n",
    "    sensitivity_bl = cal_sensitivity(conf_matrices['confusion_matrics_bl'])\n",
    "    \n",
    "    specificity_ff = cal_specificity(conf_matrices['confusion_matrics_ff'])\n",
    "    specificity_bl = cal_specificity(conf_matrices['confusion_matrics_bl'])\n",
    "    \n",
    "    metrics = {'sensitivity_ff': sensitivity_ff,\n",
    "               'sensitivity_bl': sensitivity_bl,\n",
    "               'specificity_ff': specificity_ff,\n",
    "               'specificity_bl': specificity_bl}\n",
    "    \n",
    "    print(\"-----Validation accuracy and avg loss are-----\")\n",
    "    tabulate_epoch_meter(time.time() - start_time, acc, sum(loss)/len(loss), metrics)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "OSJ0vkDdghyl",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 493
    },
    "id": "OSJ0vkDdghyl",
    "outputId": "0b015942-f76a-48bc-a375-34dc224df422"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----Starting Epoch-0-----\n",
      "|---------------------------------------|---------|-----------|\n",
      "| Accuracy                              |    loss |      time |\n",
      "|---------------------------------------|---------|-----------|\n",
      "| (44.78577202910267, 64.6725949878739) | 0.55963 | 186.01925 |\n",
      "-----Starting validating the model-----\n",
      "-----Validation accuracy and avg loss are-----\n",
      "|----------------------------------------|---------|----------|\n",
      "| Accuracy                               |    loss |     time |\n",
      "|----------------------------------------|---------|----------|\n",
      "| (34.54987834549878, 64.72019464720195) | 0.67466 | 60.71592 |\n",
      "sensitivity_ff      sensitivity_bl\n",
      "----------------  ----------------\n",
      "sensitivity_ff                 nan\n",
      "sensitivity_bl                 nan\n",
      "specificity_ff                   0\n",
      "specificity_bl                   1\n",
      "-----Starting Epoch-1-----\n",
      "|---------------------------------------|---------|-----------|\n",
      "| Accuracy                              |    loss |      time |\n",
      "|---------------------------------------|---------|-----------|\n",
      "| (69.2805173807599, 65.64268391269201) | 0.45191 | 434.17328 |\n",
      "-----Starting Epoch-2-----\n",
      "|----------------------------------------|---------|-----------|\n",
      "| Accuracy                               |    loss |      time |\n",
      "|----------------------------------------|---------|-----------|\n",
      "| (89.57154405820533, 74.85852869846403) | 0.34101 | 620.21121 |\n",
      "-----Starting Epoch-3-----\n",
      "|----------------------------------------|---------|-----------|\n",
      "| Accuracy                               |    loss |      time |\n",
      "|----------------------------------------|---------|-----------|\n",
      "| (97.41309620048504, 87.63136620856912) | 0.24423 | 807.94111 |\n",
      "-----Starting Epoch-4-----\n",
      "|----------------------------------------|---------|-----------|\n",
      "| Accuracy                               |    loss |      time |\n",
      "|----------------------------------------|---------|-----------|\n",
      "| (98.54486661277284, 92.40097008892482) | 0.17438 | 995.35435 |\n",
      "-----Starting Epoch-5-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (98.86822958771221, 94.17946645109136) | 0.12596 | 1182.72641 |\n",
      "-----Starting Epoch-6-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.02991107518189, 96.44300727566694) | 0.09318 | 1370.64077 |\n",
      "-----Starting Epoch-7-----\n",
      "|---------------------------------------|---------|------------|\n",
      "| Accuracy                              |    loss |       time |\n",
      "|---------------------------------------|---------|------------|\n",
      "| (99.19159256265158, 97.8981406628941) | 0.07153 | 1558.04678 |\n",
      "-----Starting Epoch-8-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.51495553759095, 98.14066289409863) | 0.05753 | 1745.19690 |\n",
      "-----Starting Epoch-9-----\n",
      "|---------------------------------------|---------|------------|\n",
      "| Accuracy                              |    loss |       time |\n",
      "|---------------------------------------|---------|------------|\n",
      "| (99.59579628132579, 98.3023443815683) | 0.04796 | 1932.64798 |\n",
      "-----Starting Epoch-10-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.59579628132579, 98.54486661277284) | 0.04104 | 2119.93034 |\n",
      "-----Starting validating the model-----\n",
      "-----Validation accuracy and avg loss are-----\n",
      "|----------------------------------------|---------|----------|\n",
      "| Accuracy                               |    loss |     time |\n",
      "|----------------------------------------|---------|----------|\n",
      "| (93.67396593673966, 48.41849148418492) | 0.16246 | 56.01288 |\n",
      "sensitivity_ff      sensitivity_bl\n",
      "----------------  ----------------\n",
      "sensitivity_ff                   0\n",
      "sensitivity_bl                   1\n",
      "specificity_ff                   0\n",
      "specificity_bl                 nan\n",
      "-----Starting Epoch-11-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.59579628132579, 98.70654810024251) | 0.03598 | 2363.52128 |\n",
      "-----Starting Epoch-12-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.59579628132579, 98.78738884397737) | 0.03182 | 2551.10566 |\n",
      "-----Starting Epoch-13-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.59579628132579, 98.86822958771221) | 0.02855 | 2738.90562 |\n",
      "-----Starting Epoch-14-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.51495553759095, 98.94907033144705) | 0.02578 | 2922.75924 |\n",
      "-----Starting Epoch-15-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.51495553759095, 98.94907033144705) | 0.02354 | 3108.93052 |\n",
      "-----Starting Epoch-16-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.51495553759095, 98.94907033144705) | 0.02154 | 3296.56438 |\n",
      "-----Starting Epoch-17-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.59579628132579, 98.94907033144705) | 0.01996 | 3483.96445 |\n",
      "-----Starting Epoch-18-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.59579628132579, 99.02991107518189) | 0.01858 | 3667.90413 |\n",
      "-----Starting Epoch-19-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.59579628132579, 99.02991107518189) | 0.01743 | 3853.44888 |\n",
      "-----Starting Epoch-20-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.59579628132579, 99.02991107518189) | 0.01645 | 4037.62175 |\n",
      "-----Starting validating the model-----\n",
      "-----Validation accuracy and avg loss are-----\n",
      "|----------------------------------------|---------|----------|\n",
      "| Accuracy                               |    loss |     time |\n",
      "|----------------------------------------|---------|----------|\n",
      "| (93.43065693430657, 48.41849148418492) | 0.16192 | 55.14354 |\n",
      "sensitivity_ff      sensitivity_bl\n",
      "----------------  ----------------\n",
      "sensitivity_ff                   0\n",
      "sensitivity_bl                   1\n",
      "specificity_ff                   0\n",
      "specificity_bl                 nan\n",
      "-----Starting Epoch-21-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.59579628132579, 99.02991107518189) | 0.01563 | 4276.52103 |\n",
      "-----Starting Epoch-22-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.59579628132579, 99.02991107518189) | 0.01483 | 4464.69316 |\n",
      "-----Starting Epoch-23-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.59579628132579, 99.02991107518189) | 0.01417 | 4652.85835 |\n",
      "-----Starting Epoch-24-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.59579628132579, 99.02991107518189) | 0.01361 | 4839.87371 |\n",
      "-----Starting Epoch-25-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.59579628132579, 99.02991107518189) | 0.01309 | 5026.84886 |\n",
      "-----Starting Epoch-26-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.59579628132579, 99.02991107518189) | 0.01262 | 5214.80661 |\n",
      "-----Starting Epoch-27-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.59579628132579, 99.11075181891673) | 0.01221 | 5402.77045 |\n",
      "-----Starting Epoch-28-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.59579628132579, 99.11075181891673) | 0.01191 | 5591.00847 |\n",
      "-----Starting Epoch-29-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.59579628132579, 99.11075181891673) | 0.01159 | 5778.82706 |\n",
      "-----Starting Epoch-30-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.59579628132579, 99.02991107518189) | 0.01135 | 5963.39364 |\n",
      "-----Starting validating the model-----\n",
      "-----Validation accuracy and avg loss are-----\n",
      "|----------------------------------------|---------|----------|\n",
      "| Accuracy                               |    loss |     time |\n",
      "|----------------------------------------|---------|----------|\n",
      "| (94.16058394160584, 48.41849148418492) | 0.15857 | 55.28105 |\n",
      "sensitivity_ff      sensitivity_bl\n",
      "----------------  ----------------\n",
      "sensitivity_ff                   0\n",
      "sensitivity_bl                   1\n",
      "specificity_ff                   0\n",
      "specificity_bl                 nan\n",
      "-----Starting Epoch-31-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.67663702506063, 99.02991107518189) | 0.01109 | 6203.07222 |\n",
      "-----Starting Epoch-32-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.67663702506063, 99.02991107518189) | 0.01092 | 6388.09315 |\n",
      "-----Starting Epoch-33-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.67663702506063, 99.02991107518189) | 0.01076 | 6575.39350 |\n",
      "-----Starting Epoch-34-----\n",
      "|----------------------------------------|---------|------------|\n",
      "| Accuracy                               |    loss |       time |\n",
      "|----------------------------------------|---------|------------|\n",
      "| (99.67663702506063, 99.02991107518189) | 0.01055 | 6764.13022 |\n",
      "[info] Finish saving the model\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "from torchmetrics.classification import MultilabelAccuracy\n",
    "import numpy as np\n",
    "\n",
    "model = Model()\n",
    "epochs = 35\n",
    "lr = 1e-4\n",
    "batch_size = 50\n",
    "train_loader = torch.utils.data.DataLoader(CustomDataset(training_samples), batch_size = batch_size)\n",
    "val_loader = torch.utils.data.DataLoader(CustomDataset(validation_samples), batch_size = batch_size)\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr = lr)\n",
    "start_time = time.time()\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    print(\"-----Starting Epoch-{}-----\".format(epoch))\n",
    "    predicted_values, loss = train(model, train_loader, optimizer)\n",
    "    acc = cal_acc(training_labels, predicted_values)\n",
    "    training_accuracies.append(acc)\n",
    "    training_losses.append(loss)\n",
    "    \n",
    "    tabulate_epoch_meter(time.time() - start_time, acc, loss.item())\n",
    "    \n",
    "    if epoch % 10 == 0:\n",
    "        print(\"-----Starting validating the model-----\")\n",
    "        test(model, val_loader)\n",
    "        \n",
    "save_checkpoint({'epoch': epoch + 1,\n",
    "    'state_dict': model.state_dict(),\n",
    "    'optimizer': optimizer.state_dict()}, epochs)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "14e2bb5f-ec89-4250-bce5-5af6f9bf1d14",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Saving accuracies\n",
    "\n",
    "accuracies = {}\n",
    "accuracies[\"training_accuracies\"] = training_accuracies\n",
    "accuracies[\"validation_accuracies\"] = validation_accuracies\n",
    "\n",
    "losses = {}\n",
    "losses[\"training_losses\"] = training_losses\n",
    "losses[\"validation_losses\"] = validation_losses\n",
    "\n",
    "f = open(\"metrics.txt\",\"w\")\n",
    "\n",
    "# write file\n",
    "f.write(str(accuracies))\n",
    "f.write(str(losses) )\n",
    "\n",
    "# close file\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6fe344e-c61d-4d01-8b6c-ba15095935ad",
   "metadata": {},
   "source": [
    "Testing the trained model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "ead48c29-752c-4ad1-b02d-bafc7a5ecc5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----Testing accuracy and avg loss are-----\n",
      "|----------------------------------------|---------|----------|\n",
      "| Accuracy                               |    loss |     time |\n",
      "|----------------------------------------|---------|----------|\n",
      "| (88.83495145631069, 48.54368932038835) | 0.32848 | 66.94941 |\n",
      "sensitivity_ff      sensitivity_bl\n",
      "----------------  ----------------\n",
      "sensitivity_ff                   0\n",
      "sensitivity_bl                   1\n",
      "specificity_ff                   1\n",
      "specificity_bl                 nan\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "gpu = torch.cuda.current_device()\n",
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "model_for_testing = Model()\n",
    "model_for_testing.cuda(gpu)\n",
    "\n",
    "saved_model = torch.load('Model/model_after_35_epochs.tar', map_location=\"cuda:{}\".format(gpu))\n",
    "model_for_testing.load_state_dict(saved_model[\"state_dict\"])\n",
    "\n",
    "batch_size = 100\n",
    "test_loader = torch.utils.data.DataLoader(CustomDataset(testing_samples), batch_size = batch_size)\n",
    "\n",
    "model_for_testing.eval()\n",
    "loss = []\n",
    "predicted_val = []\n",
    "start_time = time.time()\n",
    "for batch_idx, batch in enumerate(test_loader):\n",
    "    image = batch[0]\n",
    "    label_1 = batch[1]\n",
    "    label_2 = batch[2]\n",
    "    labels = unpack_labels(label_1, label_2)\n",
    "    labels = torch.tensor(labels, device=device, dtype = torch.float64)\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        y_pred = model_for_testing(image)\n",
    "        binary_crossentropy_loss = nn.BCELoss()\n",
    "        loss_ = binary_crossentropy_loss(y_pred, labels)\n",
    "        loss.append(loss_)\n",
    "\n",
    "    #Check the threshold\n",
    "    for row in range(len(y_pred)):\n",
    "        pred_lables = []\n",
    "        if y_pred[row][0] >= 0.4:\n",
    "            pred_lables.append(1)\n",
    "        else:\n",
    "            pred_lables.append(0)\n",
    "        if y_pred[0][1] >= 0.4:\n",
    "            pred_lables.append(1)\n",
    "        else:\n",
    "            pred_lables.append(0)\n",
    "        predicted_val.append(pred_lables)\n",
    "        \n",
    "test_acc = cal_acc(testing_labels, predicted_val)\n",
    "conf_matrices = cal_confusion_matrices(testing_labels, predicted_val)\n",
    "    \n",
    "sensitivity_ff = cal_sensitivity(conf_matrices['confusion_matrics_ff'])\n",
    "sensitivity_bl = cal_sensitivity(conf_matrices['confusion_matrics_bl'])\n",
    "    \n",
    "specificity_ff = cal_specificity(conf_matrices['confusion_matrics_ff'])\n",
    "specificity_bl = cal_specificity(conf_matrices['confusion_matrics_bl'])\n",
    "    \n",
    "metrics = {'sensitivity_ff': sensitivity_ff,\n",
    "               'sensitivity_bl': sensitivity_bl,\n",
    "               'specificity_ff': specificity_ff,\n",
    "               'specificity_bl': specificity_bl}\n",
    "\n",
    "print(\"-----Testing accuracy and avg loss are-----\")\n",
    "tabulate_epoch_meter(time.time() - start_time, test_acc, sum(loss)/len(loss), metrics)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "e598d827-27e5-4306-9492-db0418619c09",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "f = open(\"copy_metrics.txt\",\"r\")\n",
    "accuracies = f.read()\n",
    "\n",
    "training_acc = accuracies.split(\"\\n\")[0].split(\":\")[1]\n",
    "training_accuracies = eval(training_acc)\n",
    "\n",
    "validation_acc = accuracies.split(\"\\n\")[1].split(\":\")[1]\n",
    "validation_accuracies = eval(validation_acc)\n",
    "\n",
    "training_loss = accuracies.split(\"\\n\")[2].split(\":\")[1]\n",
    "training_losses = eval(training_loss)\n",
    "\n",
    "validation_loss = accuracies.split(\"\\n\")[3].split(\":\")[1]\n",
    "validation_losses = eval(validation_loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8271abf1-33e8-48ed-bbea-91ebe6c7cc06",
   "metadata": {
    "id": "8jtz75xkivoq"
   },
   "source": [
    "Plotting training accuracy vs epochs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "31rIbTxUm59n",
   "metadata": {
    "id": "31rIbTxUm59n"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# facial_features_acc, brain_loss_acc\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "training_accuracies_ff_acc = []\n",
    "training_accuracies_bl_acc = []\n",
    "validation_accuracies_ff_acc = []\n",
    "validation_accuracies_bl_acc = []\n",
    "epochs = []\n",
    "val_counter = 0\n",
    "for row in range(len(training_accuracies)):\n",
    "    training_accuracies_ff_acc.append(training_accuracies[row][0])\n",
    "    training_accuracies_bl_acc.append(training_accuracies[row][1])\n",
    "    epochs.append(row)\n",
    "    if row % 10 == 0:\n",
    "        validation_accuracies_ff_acc.append(validation_accuracies[val_counter][0])\n",
    "        validation_accuracies_bl_acc.append(validation_accuracies[val_counter][1])\n",
    "        val_counter = val_counter + 1\n",
    "    else:\n",
    "        validation_accuracies_ff_acc.append(0)\n",
    "        validation_accuracies_bl_acc.append(0)\n",
    "\n",
    "#Facial Features\n",
    "#Training accuracies\n",
    "plt.plot(epochs, training_accuracies_ff_acc, color=\"blue\")\n",
    "\n",
    "#Validation accuracies\n",
    "plt.stackplot(epochs, validation_accuracies_ff_acc, color=\"orange\")\n",
    "\n",
    "plt.ylabel('Accuracy')\n",
    "plt.xlabel('Epochs')\n",
    "plt.title('Facial Features')\n",
    "plt.show()\n",
    "\n",
    "#Brain Features\n",
    "#Training accuracies\n",
    "plt.plot(epochs, training_accuracies_bl_acc, color=\"blue\")\n",
    "\n",
    "#Validation accuracies\n",
    "plt.stackplot(epochs, validation_accuracies_bl_acc, color=\"orange\")\n",
    "\n",
    "plt.ylabel('Accuracy')\n",
    "plt.xlabel('Epochs')\n",
    "plt.title('Brain Features')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "c2555117-3a30-4d83-851e-e517a7614394",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# facial_features_acc, brain_loss_acc\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "#Training losses\n",
    "plt.plot(epochs, training_losses, color=\"blue\")\n",
    "\n",
    "plt.ylabel('Loss')\n",
    "plt.xlabel('Epochs')\n",
    "plt.title('Training Loss')\n",
    "plt.show()\n",
    "\n",
    "#Validation Losses\n",
    "plt.plot(range(len(validation_losses)), validation_losses, color=\"blue\")\n",
    "\n",
    "plt.ylabel('Loss')\n",
    "plt.xlabel('Epochs')\n",
    "plt.title('Validation Loss')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "provenance": []
  },
  "gpuClass": "standard",
  "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.12"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}