Copmputer_Intelligence_project.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/MehrnazSadeghieh/Computational-Intelligence-ThirdProject/blob/main/Copmputer_Intelligence_project.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Copmputer Intelligence project"
      ],
      "metadata": {
        "id": "ly2VwUlTYN_G"
      },
      "id": "ly2VwUlTYN_G"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Faridreza Momtaz Zandi 9812762601\n",
        "### Mehrnaz Sadeghieh 9812762167\n"
      ],
      "metadata": {
        "id": "m_9-EuVgYqzr"
      },
      "id": "m_9-EuVgYqzr"
    },
    {
      "cell_type": "markdown",
      "source": [
        "After dealing with feature engineering in the previous phases and getting to know classifiers and clustering methods we are now finally reached the stage to use all our knowledge and get to use what we learned on a real-life dataset and try to find the solution to a well-known problem. Up till now we had a pretty neat dataset and didn't need to do anything about it to make it ready but in this project, one of our main objectives is to load and tidy our data so we can extract features and use it to train and predict a CNN model. We finish our work by analysing how our model works on our data and try to improve it by using various ways to make our model more accurate."
      ],
      "metadata": {
        "id": "ePnd08i1Y-qw"
      },
      "id": "ePnd08i1Y-qw"
    },
    {
      "cell_type": "markdown",
      "source": [
        "We simply start by linking our drive to our notebook so we don't need to upload every time we need to use our dataset."
      ],
      "metadata": {
        "id": "CGuyoUxibKMU"
      },
      "id": "CGuyoUxibKMU"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "M-TSDlc5rL0j",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5ae1a0c2-d1ed-475a-a2f9-37dff913535d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "id": "M-TSDlc5rL0j"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E1-zDjt5MQgw",
        "outputId": "95ebfb70-9dc5-43b7-80f9-94c4dbe05e5a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting pyEDFlib\n",
            "  Downloading pyEDFlib-0.1.30-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.4 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.4/2.4 MB\u001b[0m \u001b[31m29.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: numpy>=1.9.1 in /usr/local/lib/python3.8/dist-packages (from pyEDFlib) (1.21.6)\n",
            "Installing collected packages: pyEDFlib\n",
            "Successfully installed pyEDFlib-0.1.30\n"
          ]
        }
      ],
      "source": [
        "pip install pyEDFlib"
      ],
      "id": "E1-zDjt5MQgw"
    },
    {
      "cell_type": "markdown",
      "source": [
        "Like always we import all the needed libraries which we're gonna use."
      ],
      "metadata": {
        "id": "s8bNqF8oblK4"
      },
      "id": "s8bNqF8oblK4"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ced6fd94"
      },
      "outputs": [],
      "source": [
        "import pyedflib\n",
        "import numpy as np\n",
        "from scipy.signal import butter, lfilter\n",
        "import tensorflow as tf\n",
        "import scipy.stats as sp\n",
        "from tensorflow.keras import datasets, layers, models, Input\n",
        "import random\n",
        "import os\n",
        "from sklearn.model_selection import train_test_split\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.metrics import RocCurveDisplay, accuracy_score, confusion_matrix, recall_score, precision_score"
      ],
      "id": "ced6fd94"
    },
    {
      "cell_type": "markdown",
      "source": [
        "As we did in previous phases we need to give the seed to our environment."
      ],
      "metadata": {
        "id": "tVl-Mngab8bx"
      },
      "id": "tVl-Mngab8bx"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1fvgdlppWuAJ"
      },
      "outputs": [],
      "source": [
        "seed = 57\n",
        "random.seed(seed)\n",
        "os.environ['PYTHONHASHSEED'] = str(seed)\n",
        "np.random.seed(seed)"
      ],
      "id": "1fvgdlppWuAJ"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Part 1: loading data and making it ready\n",
        "In this part, we're gonna use 11 signals and only 10 of them are containing 1 seizure part. We got these data set from \"physionet.org/content/chbmit/1.0.0\" and use its summary text file to find seizure parts. We try to use a 10-second window on these signals and use overlapped windows to get 10 times more samples! Out of 3000 samples, 600 of them contain a seizure part and 2400 are normals and 25% of our normals are from signals that had seizure parts."
      ],
      "metadata": {
        "id": "lfs0Ak26ceKy"
      },
      "id": "lfs0Ak26ceKy"
    },
    {
      "cell_type": "code",
      "source": [
        "seizurs = []\n",
        "normals = []\n",
        "pred_test = []"
      ],
      "metadata": {
        "id": "7MXKFzr6WJuW"
      },
      "id": "7MXKFzr6WJuW",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7693b673"
      },
      "outputs": [],
      "source": [
        "file_name = \"/content/drive/MyDrive/dataset/chb01_03.edf\"\n",
        "f = pyedflib.EdfReader(file_name)\n",
        "n = f.signals_in_file\n",
        "signal_labels = f.getSignalLabels()\n",
        "sigbufs = np.zeros((n, f.getNSamples()[0]))\n",
        "for i in np.arange(n):\n",
        "        sigbufs[i, :] = f.readSignal(i)\n",
        "new_sigbufs = sigbufs[16:18, :]\n",
        "for i in range (0,40):\n",
        "      seizurs.append(new_sigbufs[:, (i+2995)*256:(i+2995)*256 + 2560])\n",
        "\n",
        "for i in range (0,60):\n",
        "    normals.append(new_sigbufs[:, (i+360)*256:(i+360)*256 + 2560])"
      ],
      "id": "7693b673"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "11ef1e34"
      },
      "outputs": [],
      "source": [
        "file_name = \"/content/drive/MyDrive/dataset/chb01_04.edf\"\n",
        "f = pyedflib.EdfReader(file_name)\n",
        "n = f.signals_in_file\n",
        "signal_labels = f.getSignalLabels()\n",
        "sigbufs = np.zeros((n, f.getNSamples()[0]))\n",
        "for i in np.arange(n):\n",
        "        sigbufs[i, :] = f.readSignal(i)\n",
        "new_sigbufs = sigbufs[16:18, :]\n",
        "for i in range (0,20):\n",
        "      seizurs.append(new_sigbufs[:, (i+1466)*256:(i+1466)*256 + 2560])\n",
        "\n",
        "for i in range (0,60):\n",
        "    normals.append(new_sigbufs[:, (i+360)*256:(i+360)*256 + 2560])"
      ],
      "id": "11ef1e34"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2c19cfb0"
      },
      "outputs": [],
      "source": [
        "file_name = \"/content/drive/MyDrive/dataset/chb01_15.edf\"\n",
        "f = pyedflib.EdfReader(file_name)\n",
        "n = f.signals_in_file\n",
        "signal_labels = f.getSignalLabels()\n",
        "sigbufs = np.zeros((n, f.getNSamples()[0]))\n",
        "for i in np.arange(n):\n",
        "        sigbufs[i, :] = f.readSignal(i)\n",
        "new_sigbufs = sigbufs[16:18, :]\n",
        "for i in range (0,40):\n",
        "      seizurs.append(new_sigbufs[:, (i+1731)*256:(i+1731)*256 + 2560])\n",
        "\n",
        "for i in range (0,60):\n",
        "    normals.append(new_sigbufs[:, (i+360)*256:(i+360)*256 + 2560])"
      ],
      "id": "2c19cfb0"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "a5d724bd"
      },
      "outputs": [],
      "source": [
        "file_name = \"/content/drive/MyDrive/dataset/chb01_16.edf\"\n",
        "f = pyedflib.EdfReader(file_name)\n",
        "n = f.signals_in_file\n",
        "signal_labels = f.getSignalLabels()\n",
        "sigbufs = np.zeros((n, f.getNSamples()[0]))\n",
        "for i in np.arange(n):\n",
        "        sigbufs[i, :] = f.readSignal(i)\n",
        "new_sigbufs = sigbufs[16:18, :]\n",
        "for i in range (0,50):\n",
        "      seizurs.append(new_sigbufs[:, (i+1014)*256:(i+1014)*256 + 2560])\n",
        "\n",
        "for i in range (0,60):\n",
        "    normals.append(new_sigbufs[:, (i+360)*256:(i+360)*256 + 2560])"
      ],
      "id": "a5d724bd"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "d1e8ad6e"
      },
      "outputs": [],
      "source": [
        "file_name = \"/content/drive/MyDrive/dataset/chb01_18.edf\"\n",
        "f = pyedflib.EdfReader(file_name)\n",
        "n = f.signals_in_file\n",
        "signal_labels = f.getSignalLabels()\n",
        "sigbufs = np.zeros((n, f.getNSamples()[0]))\n",
        "for i in np.arange(n):\n",
        "        sigbufs[i, :] = f.readSignal(i)\n",
        "new_sigbufs = sigbufs[16:18, :]\n",
        "for i in range (0,90):\n",
        "      seizurs.append(new_sigbufs[:, (i+1719)*256:(i+1719)*256 + 2560])\n",
        "\n",
        "for i in range (0,60):\n",
        "    normals.append(new_sigbufs[:, (i+360)*256:(i+360)*256 + 2560])"
      ],
      "id": "d1e8ad6e"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "85358372"
      },
      "outputs": [],
      "source": [
        "file_name = \"/content/drive/MyDrive/dataset/chb01_21.edf\"\n",
        "f = pyedflib.EdfReader(file_name)\n",
        "n = f.signals_in_file\n",
        "signal_labels = f.getSignalLabels()\n",
        "sigbufs = np.zeros((n, f.getNSamples()[0]))\n",
        "for i in np.arange(n):\n",
        "        sigbufs[i, :] = f.readSignal(i)\n",
        "new_sigbufs = sigbufs[16:18, :]\n",
        "for i in range (0,90):\n",
        "      seizurs.append(new_sigbufs[:, (i+326)*256:(i+326)*256 + 2560])\n",
        "\n",
        "for i in range (0,60):\n",
        "    normals.append(new_sigbufs[:, (i+420)*256:(i+420)*256 + 2560])"
      ],
      "id": "85358372"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5aba86c1"
      },
      "outputs": [],
      "source": [
        "file_name = \"/content/drive/MyDrive/dataset/chb01_26.edf\"\n",
        "f = pyedflib.EdfReader(file_name)\n",
        "n = f.signals_in_file\n",
        "signal_labels = f.getSignalLabels()\n",
        "sigbufs = np.zeros((n, f.getNSamples()[0]))\n",
        "for i in np.arange(n):\n",
        "        sigbufs[i, :] = f.readSignal(i)\n",
        "new_sigbufs = sigbufs[16:18, :]\n",
        "for i in range (0,100):\n",
        "      seizurs.append(new_sigbufs[:, (i+1861)*256:(i+1861)*256 + 2560])\n",
        "\n",
        "for i in range (0,60):\n",
        "    normals.append(new_sigbufs[:, (i+360)*256:(i+360)*256 + 2560])"
      ],
      "id": "5aba86c1"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bf7fa9f4"
      },
      "outputs": [],
      "source": [
        "file_name = \"/content/drive/MyDrive/dataset/chb02_16.edf\"\n",
        "f = pyedflib.EdfReader(file_name)\n",
        "n = f.signals_in_file\n",
        "signal_labels = f.getSignalLabels()\n",
        "sigbufs = np.zeros((n, f.getNSamples()[0]))\n",
        "for i in np.arange(n):\n",
        "        sigbufs[i, :] = f.readSignal(i)\n",
        "new_sigbufs = sigbufs[16:18, :]\n",
        "for i in range (0,80):\n",
        "      seizurs.append(new_sigbufs[:, (i+129)*256:(i+129)*256 + 2560])\n",
        "\n",
        "for i in range (0,60):\n",
        "    normals.append(new_sigbufs[:, (i+360)*256:(i+360)*256 + 2560])"
      ],
      "id": "bf7fa9f4"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ddd58efd"
      },
      "outputs": [],
      "source": [
        "file_name = \"/content/drive/MyDrive/dataset/chb02_16+.edf\"\n",
        "f = pyedflib.EdfReader(file_name)\n",
        "n = f.signals_in_file\n",
        "signal_labels = f.getSignalLabels()\n",
        "sigbufs = np.zeros((n, f.getNSamples()[0]))\n",
        "for i in np.arange(n):\n",
        "        sigbufs[i, :] = f.readSignal(i)\n",
        "new_sigbufs = sigbufs[16:18, :]\n",
        "for i in range (0,80):\n",
        "      seizurs.append(new_sigbufs[:, (i+2971)*256:(i+2971)*256 + 2560])\n",
        "\n",
        "for i in range (0,60):\n",
        "    normals.append(new_sigbufs[:, (i+360)*256:(i+360)*256 + 2560])"
      ],
      "id": "ddd58efd"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "d9bb23f7"
      },
      "outputs": [],
      "source": [
        "file_name = \"/content/drive/MyDrive/dataset/chb02_19.edf\"\n",
        "f = pyedflib.EdfReader(file_name)\n",
        "n = f.signals_in_file\n",
        "signal_labels = f.getSignalLabels()\n",
        "sigbufs = np.zeros((n, f.getNSamples()[0]))\n",
        "for i in np.arange(n):\n",
        "        sigbufs[i, :] = f.readSignal(i)\n",
        "new_sigbufs = sigbufs[16:18, :]\n",
        "for i in range (0,10):\n",
        "      seizurs.append(new_sigbufs[:, (i+3368)*256:(i+3368)*256 + 2560])\n",
        "\n",
        "for i in range (0,60):\n",
        "    normals.append(new_sigbufs[:, (i+360)*256:(i+360)*256 + 2560])"
      ],
      "id": "d9bb23f7"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fef071b6"
      },
      "outputs": [],
      "source": [
        "file_name = \"/content/drive/MyDrive/dataset/chb01_01.edf\"\n",
        "f = pyedflib.EdfReader(file_name)\n",
        "n = f.signals_in_file\n",
        "signal_labels = f.getSignalLabels()\n",
        "sigbufs = np.zeros((n, f.getNSamples()[0]))\n",
        "for i in np.arange(n):\n",
        "        sigbufs[i, :] = f.readSignal(i)\n",
        "new_sigbufs = sigbufs[16:18, :]\n",
        "for i in range (0,1800):\n",
        "    normals.append(new_sigbufs[:, (i+360)*256:(i+360)*256 + 2560])\n",
        "\n",
        "for i in range (0,600):\n",
        "    pred_test.append(new_sigbufs[:, (i+2160)*256:(i+2160)*256 + 2560])"
      ],
      "id": "fef071b6"
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's check if we choose the right amount of samples:"
      ],
      "metadata": {
        "id": "STWj_Lb3eQ_F"
      },
      "id": "STWj_Lb3eQ_F"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "970826ad",
        "outputId": "f506918e-c467-4ebc-d7ef-69cd8b366e4b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "600\n",
            "2400\n"
          ]
        }
      ],
      "source": [
        "print(len(seizurs))\n",
        "print(len(normals))"
      ],
      "id": "970826ad"
    },
    {
      "cell_type": "markdown",
      "source": [
        "The last objective of this part is to filter our gained samples by the sampling frequency we got from our source."
      ],
      "metadata": {
        "id": "CZBpjKu4ehh9"
      },
      "id": "CZBpjKu4ehh9"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2914c1fe"
      },
      "outputs": [],
      "source": [
        "x_normal = np.asarray(normals)\n",
        "x_seizure = np.asarray(seizurs)\n",
        "\n",
        "sampling_freq = 256\n",
        "\n",
        "b, a = butter(3, [0.5,40], btype='bandpass',fs=sampling_freq)\n",
        "\n",
        "\n",
        "x_normal_filtered = np.array([lfilter(b,a,x_normal[ind,:]) for ind in range(x_normal.shape[0])])\n",
        "x_seizure_filtered = np.array([lfilter(b,a,x_seizure[ind,:]) for ind in range(x_seizure.shape[0])])\n",
        "\n",
        "x_normal = x_normal_filtered\n",
        "x_seizure = x_seizure_filtered"
      ],
      "id": "2914c1fe"
    },
    {
      "cell_type": "markdown",
      "source": [
        "We Finish this part by concatenating our filtered normals and seizures and also make a numpy array with the same size and value of 0 for normals and 1 for seizures so we can use it as a label array."
      ],
      "metadata": {
        "id": "AIeLlohqevj2"
      },
      "id": "AIeLlohqevj2"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "82362f7a"
      },
      "outputs": [],
      "source": [
        "x = np.concatenate((x_normal,x_seizure))\n",
        "y = np.concatenate((np.zeros((2400,1)), np.full((600,1), 1)))"
      ],
      "id": "82362f7a"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Part2: Classification\n",
        "we need to use our achieved dataset to train and test our structured CNN model. We also need to get the features we found are most useful in phase2 and give them to our network as the second input. We start this part by getting our selected features."
      ],
      "metadata": {
        "id": "UHQ3tzzTfMtv"
      },
      "id": "UHQ3tzzTfMtv"
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's have a normalize function so we can call it to normalize each of our features."
      ],
      "metadata": {
        "id": "VgfON5RVgZ44"
      },
      "id": "VgfON5RVgZ44"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ad4c2f49"
      },
      "outputs": [],
      "source": [
        "def normalize (x):\n",
        "    normalizedData = (x-np.min(x))/(np.max(x)-np.min(x))\n",
        "    return normalizedData"
      ],
      "id": "ad4c2f49"
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now we can get all of the selected features and we need to be careful because our data has 2 channels and we need to get the features for both of them."
      ],
      "metadata": {
        "id": "KbvrGYEKgqvy"
      },
      "id": "KbvrGYEKgqvy"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "c92c4fa6"
      },
      "outputs": [],
      "source": [
        "margin_factor_values = np.zeros((3000,2,1))\n",
        "B_factor_values = np.zeros((3000,2,1))\n",
        "kurtosis_values = np.zeros((3000,2,1))\n",
        "mean_values = np.zeros((3000,2,1))\n",
        "median_values = np.zeros((3000,2,1))\n",
        "\n",
        "abs_max_values = np.zeros((3000,2,1))\n",
        "variance_values = np.zeros((3000,2,1))\n",
        "crest_factor_margin_values = np.zeros((3000,2,1))\n",
        "standard_deviation_values = np.zeros((3000,2,1))\n",
        "RMS_values = np.zeros((3000,2,1))\n",
        "\n",
        "for i in range(0 , 3000):\n",
        "    abs_max_values[i][0][0] = max(x[i][0])\n",
        "    abs_max_values[i][1][0] = max(x[i][1])\n",
        "    mean_values[i][0][0] = np.mean(x[i][0])\n",
        "    mean_values[i][1][0] = np.mean(x[i][1])\n",
        "    median_values[i][0][0] = np.median(x[i][0])\n",
        "    median_values[i][1][0] = np.median(x[i][1])\n",
        "    variance_values[i][0][0] = np.var(x[i][0])\n",
        "    variance_values[i][1][0] = np.var(x[i][1])\n",
        "    standard_deviation_values[i][0][0] = np.std(x[i][0])\n",
        "    standard_deviation_values[i][1][0] = np.std(x[i][0])\n",
        "    kurtosis_values[i][0][0] = sp.kurtosis(x[i][0])\n",
        "    kurtosis_values[i][1][0] = sp.kurtosis(x[i][1])\n",
        "    RMS_values[i][0][0] = np.sqrt(np.mean(x[i][0] ** 2))\n",
        "    RMS_values[i][1][0] = np.sqrt(np.mean(x[i][1] ** 2))\n",
        "\n",
        "for i in range (0, 3000):\n",
        "    crest_factor_margin_values[i][0][0] = abs_max_values[i][0][0] / RMS_values[i][0][0]\n",
        "    crest_factor_margin_values[i][1][0] = abs_max_values[i][1][0] / RMS_values[i][1][0]\n",
        "    margin_factor_values[i][0][0] = abs_max_values[i][0][0] / variance_values[i][0][0]\n",
        "    margin_factor_values[i][1][0] = abs_max_values[i][1][0] / variance_values[i][1][0]\n",
        "    B_factor_values[i][0][0] = (kurtosis_values[i][0][0] * crest_factor_margin_values[i][0][0]) / standard_deviation_values[i][0][0]\n",
        "    B_factor_values[i][1][0] = (kurtosis_values[i][1][0] * crest_factor_margin_values[i][1][0]) / standard_deviation_values[i][1][0]\n",
        "\n",
        "abs_max_values = normalize(abs_max_values)\n",
        "mean_values = normalize(mean_values)\n",
        "median_values = normalize(median_values)\n",
        "variance_values = normalize(variance_values)\n",
        "standard_deviation_values = normalize(standard_deviation_values)\n",
        "kurtosis_values = normalize(kurtosis_values)\n",
        "RMS_values = normalize(RMS_values)\n",
        "crest_factor_margin_values = normalize(crest_factor_margin_values)\n",
        "margin_factor_values = normalize(margin_factor_values)\n",
        "B_factor_values = normalize(B_factor_values)"
      ],
      "id": "c92c4fa6"
    },
    {
      "cell_type": "markdown",
      "source": [
        "Our desired features are now concatenated to make our features array."
      ],
      "metadata": {
        "id": "oRbWDQ20hKCh"
      },
      "id": "oRbWDQ20hKCh"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "a81ce245"
      },
      "outputs": [],
      "source": [
        "x_features = np.concatenate((margin_factor_values, kurtosis_values, median_values, B_factor_values, abs_max_values), 1)"
      ],
      "id": "a81ce245"
    },
    {
      "cell_type": "markdown",
      "source": [
        "We reached the most complicated part of this project which is designing the best CNN model with no other changes that can't make the result better! First of all, we need to specify that we have two inputs with different shapes one of them is our signals and it goes through 3 convolution layers and 1 pooling, our second input is features that go through a size 1 pooling layer so we get it as tensors and after modeling both inputs we concatenate both layers and give it to a 2 node fully connected layer with softmax as activation."
      ],
      "metadata": {
        "id": "ijtxvV4lhaf8"
      },
      "id": "ijtxvV4lhaf8"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_UcopvxoqSVw"
      },
      "outputs": [],
      "source": [
        "inputA = Input(shape=(2,2560))\n",
        "inputB = Input(shape=(1,10))\n",
        "\n",
        "x1 = layers.Conv1D(64, 1, activation='relu')(inputA)\n",
        "x1 = layers.MaxPooling1D(pool_size=2)(x1)\n",
        "x1 = layers.Conv1D(128, 1, activation='relu')(x1)\n",
        "x1 = layers.Conv1D(128, 1, activation='relu')(x1)\n",
        "x1 = layers.Dense(10, activation='relu')(x1)\n",
        "x1 = tf.keras.Model(inputs=inputA, outputs=x1)\n",
        "\n",
        "y1 = layers.MaxPooling1D(pool_size=1)(inputB)\n",
        "y1 = tf.keras.Model(inputs=inputB, outputs=y1)\n",
        "\n",
        "combined = tf.keras.layers.concatenate([x1.output, y1.output])\n",
        "\n",
        "z = layers.Dense(2,activation = tf.keras.activations.softmax)(combined)\n",
        "\n",
        "model = tf.keras.Model(inputs=[x1.input, y1.input], outputs=z)"
      ],
      "id": "_UcopvxoqSVw"
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's get a summary of our model so we can see how each layer affect our input."
      ],
      "metadata": {
        "id": "mZOpcDR7jlTu"
      },
      "id": "mZOpcDR7jlTu"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W5E9lI7GrkMP",
        "outputId": "12b89e11-e663-45e5-b448-a29ba8b19cab"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model_2\"\n",
            "__________________________________________________________________________________________________\n",
            " Layer (type)                   Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            " input_1 (InputLayer)           [(None, 2, 2560)]    0           []                               \n",
            "                                                                                                  \n",
            " conv1d (Conv1D)                (None, 2, 64)        163904      ['input_1[0][0]']                \n",
            "                                                                                                  \n",
            " max_pooling1d (MaxPooling1D)   (None, 1, 64)        0           ['conv1d[0][0]']                 \n",
            "                                                                                                  \n",
            " conv1d_1 (Conv1D)              (None, 1, 128)       8320        ['max_pooling1d[0][0]']          \n",
            "                                                                                                  \n",
            " conv1d_2 (Conv1D)              (None, 1, 128)       16512       ['conv1d_1[0][0]']               \n",
            "                                                                                                  \n",
            " input_2 (InputLayer)           [(None, 1, 10)]      0           []                               \n",
            "                                                                                                  \n",
            " dense (Dense)                  (None, 1, 10)        1290        ['conv1d_2[0][0]']               \n",
            "                                                                                                  \n",
            " max_pooling1d_1 (MaxPooling1D)  (None, 1, 10)       0           ['input_2[0][0]']                \n",
            "                                                                                                  \n",
            " concatenate (Concatenate)      (None, 1, 20)        0           ['dense[0][0]',                  \n",
            "                                                                  'max_pooling1d_1[0][0]']        \n",
            "                                                                                                  \n",
            " dense_1 (Dense)                (None, 1, 2)         42          ['concatenate[0][0]']            \n",
            "                                                                                                  \n",
            "==================================================================================================\n",
            "Total params: 190,068\n",
            "Trainable params: 190,068\n",
            "Non-trainable params: 0\n",
            "__________________________________________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "model.summary()"
      ],
      "id": "W5E9lI7GrkMP"
    },
    {
      "cell_type": "markdown",
      "source": [
        "We also need to compile this model before we can fit or predict with it!"
      ],
      "metadata": {
        "id": "MlrnGZuqjy9n"
      },
      "id": "MlrnGZuqjy9n"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ne6QCQS6Ut-g"
      },
      "outputs": [],
      "source": [
        "model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),metrics=['accuracy'])"
      ],
      "id": "ne6QCQS6Ut-g"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f8Ns3LXN7njV"
      },
      "outputs": [],
      "source": [
        "x_features = np.transpose(x_features, (0, 2, 1))"
      ],
      "id": "f8Ns3LXN7njV"
    },
    {
      "cell_type": "markdown",
      "source": [
        "We finally reached the point to give our data to our model so we need to call train test split so it can give us a totally random train and test data. we use this method on our x, y and x_features arrays and get their equivelant test and train arrays and give it to our model fit function."
      ],
      "metadata": {
        "id": "IwPC4eWMj7M0"
      },
      "id": "IwPC4eWMj7M0"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qa11GQ5MVL4H",
        "outputId": "ae855517-d4a2-4533-8279-f7ec1257f51e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/20\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.8/dist-packages/keras/backend.py:5585: UserWarning: \"`sparse_categorical_crossentropy` received `from_logits=True`, but the `output` argument was produced by a Softmax activation and thus does not represent logits. Was this intended?\n",
            "  output, from_logits = _get_logits(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 2s 2s/step - loss: 13.5568 - accuracy: 0.7329 - val_loss: 14.5320 - val_accuracy: 0.3100\n",
            "Epoch 2/20\n",
            "1/1 [==============================] - 0s 185ms/step - loss: 12.9387 - accuracy: 0.3162 - val_loss: 9.8320 - val_accuracy: 0.3783\n",
            "Epoch 3/20\n",
            "1/1 [==============================] - 0s 218ms/step - loss: 6.2783 - accuracy: 0.4625 - val_loss: 7.0175 - val_accuracy: 0.6067\n",
            "Epoch 4/20\n",
            "1/1 [==============================] - 0s 252ms/step - loss: 2.0162 - accuracy: 0.7604 - val_loss: 9.3364 - val_accuracy: 0.7367\n",
            "Epoch 5/20\n",
            "1/1 [==============================] - 0s 189ms/step - loss: 2.6023 - accuracy: 0.8492 - val_loss: 9.8911 - val_accuracy: 0.7533\n",
            "Epoch 6/20\n",
            "1/1 [==============================] - 0s 195ms/step - loss: 2.2000 - accuracy: 0.8621 - val_loss: 8.4222 - val_accuracy: 0.7350\n",
            "Epoch 7/20\n",
            "1/1 [==============================] - 0s 189ms/step - loss: 0.9243 - accuracy: 0.9108 - val_loss: 6.9613 - val_accuracy: 0.7133\n",
            "Epoch 8/20\n",
            "1/1 [==============================] - 0s 194ms/step - loss: 0.4243 - accuracy: 0.9275 - val_loss: 6.0824 - val_accuracy: 0.6633\n",
            "Epoch 9/20\n",
            "1/1 [==============================] - 0s 218ms/step - loss: 0.3619 - accuracy: 0.9117 - val_loss: 5.4995 - val_accuracy: 0.6400\n",
            "Epoch 10/20\n",
            "1/1 [==============================] - 0s 193ms/step - loss: 0.3797 - accuracy: 0.8963 - val_loss: 5.1637 - val_accuracy: 0.6300\n",
            "Epoch 11/20\n",
            "1/1 [==============================] - 0s 188ms/step - loss: 0.3658 - accuracy: 0.8908 - val_loss: 5.0374 - val_accuracy: 0.6383\n",
            "Epoch 12/20\n",
            "1/1 [==============================] - 0s 199ms/step - loss: 0.2790 - accuracy: 0.9062 - val_loss: 5.0177 - val_accuracy: 0.6500\n",
            "Epoch 13/20\n",
            "1/1 [==============================] - 0s 189ms/step - loss: 0.1856 - accuracy: 0.9346 - val_loss: 5.0675 - val_accuracy: 0.6700\n",
            "Epoch 14/20\n",
            "1/1 [==============================] - 0s 200ms/step - loss: 0.1185 - accuracy: 0.9596 - val_loss: 5.1573 - val_accuracy: 0.6833\n",
            "Epoch 15/20\n",
            "1/1 [==============================] - 0s 192ms/step - loss: 0.0753 - accuracy: 0.9737 - val_loss: 5.3210 - val_accuracy: 0.7017\n",
            "Epoch 16/20\n",
            "1/1 [==============================] - 0s 181ms/step - loss: 0.0494 - accuracy: 0.9833 - val_loss: 5.4972 - val_accuracy: 0.7233\n",
            "Epoch 17/20\n",
            "1/1 [==============================] - 0s 196ms/step - loss: 0.0319 - accuracy: 0.9929 - val_loss: 5.6730 - val_accuracy: 0.7267\n",
            "Epoch 18/20\n",
            "1/1 [==============================] - 0s 198ms/step - loss: 0.0261 - accuracy: 0.9929 - val_loss: 5.8161 - val_accuracy: 0.7267\n",
            "Epoch 19/20\n",
            "1/1 [==============================] - 0s 163ms/step - loss: 0.0201 - accuracy: 0.9950 - val_loss: 5.9249 - val_accuracy: 0.7317\n",
            "Epoch 20/20\n",
            "1/1 [==============================] - 0s 177ms/step - loss: 0.0139 - accuracy: 0.9987 - val_loss: 6.0080 - val_accuracy: 0.7383\n"
          ]
        }
      ],
      "source": [
        "x_train, x_test, y_train, y_test,x_features_train,x_features_test = train_test_split(x,y,x_features,random_state=seed,test_size=0.2)\n",
        "\n",
        "history = model.fit([x_train, x_features_train],y_train, batch_size=2400, epochs=20, validation_data=([x_test, x_features_test], y_test))"
      ],
      "id": "qa11GQ5MVL4H"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Part3: Presenting Results\n",
        "Now that we have our model and used our samples to train it we can use accuracy and validation accuracy to plot both of them and check to see if our model is overfitted or not which we see it's not. We can also use the model evaluates function to get test_loss and test_acc attributes."
      ],
      "metadata": {
        "id": "o7vKO0qsk6Ez"
      },
      "id": "o7vKO0qsk6Ez"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "U8ny2L7VD3KA",
        "outputId": "f441681e-c40f-4de3-c2d7-8c61298d16c0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "19/19 - 0s - loss: 6.0080 - accuracy: 0.7383 - 73ms/epoch - 4ms/step\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "plt.plot(history.history['accuracy'], label='accuracy')\n",
        "plt.plot(history.history['val_accuracy'], label = 'val_accuracy')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.ylim([0.5, 1])\n",
        "plt.legend(loc='lower right')\n",
        "\n",
        "test_loss, test_acc = model.evaluate([x_test, x_features_test],  y_test, verbose=2)\n"
      ],
      "id": "U8ny2L7VD3KA"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sWZMC1-iESuH",
        "outputId": "425b5a86-f673-49c9-a6ed-9e8a1473de81"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.7383333444595337"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ],
      "source": [
        "test_acc"
      ],
      "id": "sWZMC1-iESuH"
    },
    {
      "cell_type": "markdown",
      "source": [
        "We need to get the prediction of our model on our test data as the code below does."
      ],
      "metadata": {
        "id": "PfiSFlz2mDMJ"
      },
      "id": "PfiSFlz2mDMJ"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XUenfAPHXcPt",
        "outputId": "1b82accb-1da1-4d86-c3a8-a49c3a1fb94a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "19/19 [==============================] - 0s 2ms/step\n"
          ]
        }
      ],
      "source": [
        "y_pred = model.predict([x_test, x_features_test])"
      ],
      "id": "XUenfAPHXcPt"
    },
    {
      "cell_type": "markdown",
      "source": [
        "As We have a categorical cross-entropy classifier,first we need to convert it to a binary classifier, then we calculate some numerical metrics such as accuracy_score,confusion_matrix,recall_score and precision_score and ROC graph\n",
        "As mentioned in the class, to have better accuracy we try to look into our samples 5 by 5 so we calculate the number of seizures in larger scope and make the label equal to the most number of types.\n"
      ],
      "metadata": {
        "id": "nn_XwBAomXGh"
      },
      "id": "nn_XwBAomXGh"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 366
        },
        "id": "inMCUSNmxXkM",
        "outputId": "fc4c4c02-e611-4757-d073-452e55dcd777"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.7383333333333333\n",
            "[[415  59]\n",
            " [ 98  28]]\n",
            "0.2222222222222222\n",
            "0.3218390804597701\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "y_pred_1 = np.zeros((600,1))\n",
        "\n",
        "for i in range(0,600):\n",
        "  if(y_pred[i][0][0] > y_pred[i][0][1]):\n",
        "    y_pred_1[i][0] = 0\n",
        "  else:\n",
        "    y_pred_1[i][0] = 1\n",
        "\n",
        "print(accuracy_score(y_test,y_pred_1))\n",
        "print(confusion_matrix(y_test, y_pred_1))\n",
        "print(recall_score(y_test,y_pred_1))\n",
        "print(precision_score(y_test,y_pred_1))\n",
        "\n",
        "RocCurveDisplay.from_predictions(y_test, y_pred_1, color= \"darkorange\")\n",
        "plt.show()\n",
        "\n",
        "for i in range(0,600,5):\n",
        "  count = 0\n",
        "  for j in range(0,5):\n",
        "    if(y_pred_1[i+j][0] == 1):\n",
        "      count = count+1\n",
        "\n",
        "  for j in range(0,5):\n",
        "    if(count >= 3):\n",
        "      y_pred_1[i+j][0] = 1\n",
        "    else:\n",
        "      y_pred_1[i+j][0] = 0"
      ],
      "id": "inMCUSNmxXkM"
    },
    {
      "cell_type": "markdown",
      "source": [
        "we can see that we have a better accuracy after the changed we just made!"
      ],
      "metadata": {
        "id": "au-XhfFHqDH2"
      },
      "id": "au-XhfFHqDH2"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 366
        },
        "id": "4otW1YmZxngd",
        "outputId": "c833acbe-d1cc-4b2f-9b12-98540a1832d0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.7816666666666666\n",
            "[[459  15]\n",
            " [116  10]]\n",
            "0.07936507936507936\n",
            "0.4\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "print(accuracy_score(y_test,y_pred_1))\n",
        "print(confusion_matrix(y_test, y_pred_1))\n",
        "print(recall_score(y_test,y_pred_1))\n",
        "print(precision_score(y_test,y_pred_1))\n",
        "RocCurveDisplay.from_predictions(y_test, y_pred_1, color= \"darkorange\")\n",
        "plt.show()"
      ],
      "id": "4otW1YmZxngd"
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this part, we are gonna get the features for our pred_test list which we got by only getting samples from signals without any seizures."
      ],
      "metadata": {
        "id": "GZQ3VJGBqQg0"
      },
      "id": "GZQ3VJGBqQg0"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Kt_xzksJxXR0"
      },
      "outputs": [],
      "source": [
        "margin_factor_values = np.zeros((600,2,1))\n",
        "B_factor_values = np.zeros((600,2,1))\n",
        "kurtosis_values = np.zeros((600,2,1))\n",
        "mean_values = np.zeros((600,2,1))\n",
        "median_values = np.zeros((600,2,1))\n",
        "\n",
        "abs_max_values = np.zeros((600,2,1))\n",
        "variance_values = np.zeros((600,2,1))\n",
        "crest_factor_margin_values = np.zeros((600,2,1))\n",
        "standard_deviation_values = np.zeros((600,2,1))\n",
        "RMS_values = np.zeros((600,2,1))\n",
        "\n",
        "for i in range(0 , 600):\n",
        "    abs_max_values[i][0][0] = max(pred_test[i][0])\n",
        "    abs_max_values[i][1][0] = max(pred_test[i][1])\n",
        "    mean_values[i][0][0] = np.mean(pred_test[i][0])\n",
        "    mean_values[i][1][0] = np.mean(pred_test[i][1])\n",
        "    median_values[i][0][0] = np.median(pred_test[i][0])\n",
        "    median_values[i][1][0] = np.median(pred_test[i][1])\n",
        "    variance_values[i][0][0] = np.var(pred_test[i][0])\n",
        "    variance_values[i][1][0] = np.var(pred_test[i][1])\n",
        "    standard_deviation_values[i][0][0] = np.std(pred_test[i][0])\n",
        "    standard_deviation_values[i][1][0] = np.std(pred_test[i][0])\n",
        "    kurtosis_values[i][0][0] = sp.kurtosis(pred_test[i][0])\n",
        "    kurtosis_values[i][1][0] = sp.kurtosis(pred_test[i][1])\n",
        "    RMS_values[i][0][0] = np.sqrt(np.mean(pred_test[i][0] ** 2))\n",
        "    RMS_values[i][1][0] = np.sqrt(np.mean(pred_test[i][1] ** 2))\n",
        "\n",
        "for i in range (0, 600):\n",
        "    crest_factor_margin_values[i][0][0] = abs_max_values[i][0][0] / RMS_values[i][0][0]\n",
        "    crest_factor_margin_values[i][1][0] = abs_max_values[i][1][0] / RMS_values[i][1][0]\n",
        "    margin_factor_values[i][0][0] = abs_max_values[i][0][0] / variance_values[i][0][0]\n",
        "    margin_factor_values[i][1][0] = abs_max_values[i][1][0] / variance_values[i][1][0]\n",
        "    B_factor_values[i][0][0] = (kurtosis_values[i][0][0] * crest_factor_margin_values[i][0][0]) / standard_deviation_values[i][0][0]\n",
        "    B_factor_values[i][1][0] = (kurtosis_values[i][1][0] * crest_factor_margin_values[i][1][0]) / standard_deviation_values[i][1][0]\n",
        "\n",
        "abs_max_values = normalize(abs_max_values)\n",
        "mean_values = normalize(mean_values)\n",
        "median_values = normalize(median_values)\n",
        "variance_values = normalize(variance_values)\n",
        "standard_deviation_values = normalize(standard_deviation_values)\n",
        "kurtosis_values = normalize(kurtosis_values)\n",
        "RMS_values = normalize(RMS_values)\n",
        "crest_factor_margin_values = normalize(crest_factor_margin_values)\n",
        "margin_factor_values = normalize(margin_factor_values)\n",
        "B_factor_values = normalize(B_factor_values)"
      ],
      "id": "Kt_xzksJxXR0"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nTTwJlI9xx8g"
      },
      "outputs": [],
      "source": [
        "x_features_pred = np.concatenate((margin_factor_values, kurtosis_values, median_values, B_factor_values, abs_max_values), 1)"
      ],
      "id": "nTTwJlI9xx8g"
    },
    {
      "cell_type": "code",
      "source": [
        "pred_test = np.asarray(pred_test)\n",
        "x_features_pred = np.asarray(x_features_pred)\n",
        "x_features_pred = np.transpose(x_features_pred, (0, 2, 1))"
      ],
      "metadata": {
        "id": "1caOWY8s7MCi"
      },
      "id": "1caOWY8s7MCi",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We get a model prediction by giving our model full normal data to see how it works by getting false alarms."
      ],
      "metadata": {
        "id": "RmzPZgaKr5GR"
      },
      "id": "RmzPZgaKr5GR"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rb9BaHCD2zXR",
        "outputId": "b331f373-1e13-453a-99d1-776d465549ff"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "19/19 [==============================] - 0s 2ms/step\n",
            "(600, 1, 2)\n"
          ]
        }
      ],
      "source": [
        "prediction = model.predict([pred_test,x_features_pred])\n",
        "print(prediction.shape)"
      ],
      "id": "rb9BaHCD2zXR"
    },
    {
      "cell_type": "code",
      "source": [
        "prediction_1 = np.zeros((600,1))\n",
        "for i in range(0,600):\n",
        "  if(prediction[i][0][0] > prediction[i][0][1]):\n",
        "    prediction_1[i][0] = 0\n",
        "  else:\n",
        "    prediction_1[i][0] = 1\n",
        "\n",
        "y_test_pred = np.zeros((600,1))\n",
        "print(accuracy_score(y_test_pred,prediction_1))"
      ],
      "metadata": {
        "id": "-zhKIOiq8IW7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "35c72e56-9e84-4ded-d433-67e186cb9217"
      },
      "id": "-zhKIOiq8IW7",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.8716666666666667\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The function below let us find the number of times and duration that our prediction gave us a seizure although it only had normals! we use this method and draw its histogram to get a better grasp of it."
      ],
      "metadata": {
        "id": "z87AAYcasgnK"
      },
      "id": "z87AAYcasgnK"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IsxdPaA4KYFO"
      },
      "outputs": [],
      "source": [
        "def find_false_alarm():\n",
        "  false_alarms = 0\n",
        "  for i in range(0,600):\n",
        "    if(0 != prediction_1[i][0]):\n",
        "      false_alarms = false_alarms + 1\n",
        "\n",
        "  print(\"false_alarm count:\",false_alarms)\n",
        "  fls_alm = []\n",
        "  i = 0\n",
        "  while(i < 600):\n",
        "    false_duration = 0\n",
        "    if(0 != prediction_1[i][0]):\n",
        "      while(0 != prediction_1[i][0]):\n",
        "        false_duration = false_duration + 1\n",
        "        i = i+1\n",
        "      i = i-1\n",
        "    if(false_duration > 0):\n",
        "      fls_alm.append(false_duration * 10)\n",
        "    i = i+1\n",
        "\n",
        "  plt.hist(fls_alm,edgecolor = 'black',rwidth = 0.9)\n",
        "  plt.show()"
      ],
      "id": "IsxdPaA4KYFO"
    },
    {
      "cell_type": "code",
      "source": [
        "find_false_alarm()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 283
        },
        "id": "mXlU25AH9LTd",
        "outputId": "47cc4bf7-995a-4a36-b359-bb33ef5e400c"
      },
      "id": "mXlU25AH9LTd",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "false_alarm count: 77\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAD5CAYAAAA+0W6bAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAOaElEQVR4nO3dXYxdV3nG8f9TOykU2iYhU8uKCU5LBIpQcappGgSqaFKqCCLiSlEEoshqXbmVoAoqLTHctFStRC5K4KJCchOILygkCh+2ItQ2MkFQqQqMiYEkBiWkiWLLH0NJBPQCZHh7cbbJMJ7xHM/36/x/0tHZe+19Zr/Ly368Z529z0lVIUnq55fWugBJ0uIY4JLUlAEuSU0Z4JLUlAEuSU0Z4JLU1MZxdkpyEXAn8BqggD8DvgPcA2wFngJuqapnz/ZzLr300tq6deviq5WkF6CDBw9+r6omZrdnnOvAk+wFvlJVdya5EPgV4APA96vqQ0l2AxdX1W1n+zmTk5M1NTW1uB5I0gtUkoNVNTm7fcEplCS/Dvw+cBdAVf2kqp4DbgL2DrvtBbYvX7mSpIWMMwd+BTANfCLJw0nuTPISYFNVHRv2OQ5sWqkiJUlnGifANwK/A3ysqq4G/g/YPXOHGs3DzDkXk2RXkqkkU9PT00utV5I0GCfAjwBHquqhYf0+RoF+IslmgOH55Fwvrqo9VTVZVZMTE2fMwUuSFmnBAK+q48AzSV41NF0PPAbsB3YMbTuAfStSoSRpTmNdRgj8FfDJ4QqUJ4E/ZRT+9ybZCTwN3LIyJUqS5jJWgFfVIeCMS1gYnY1LktaAd2JKUlMGuCQ11SbAN2+5nCSr9ti85fK17rIkndW4b2KuueNHn+EVt92/asd7+vYbV+1YkrQYbc7AJUm/yACXpKYMcElqygCXpKYMcElqygCXpKYMcElqygCXpKYMcElqygCXpKYMcElqygCXpKYMcElqygCXpKYMcElqygCXpKYMcElqygCXpKYMcElqygCXpKYMcElqygCXpKYMcElqauM4OyV5Cvgh8FPgVFVNJrkEuAfYCjwF3FJVz65MmZKk2c7lDPwPqmpbVU0O67uBA1V1JXBgWJckrZKlTKHcBOwdlvcC25dejiRpXOMGeAH/meRgkl1D26aqOjYsHwc2zfXCJLuSTCWZmp6eXmK5kqTTxpoDB95QVUeT/AbwQJJvz9xYVZWk5nphVe0B9gBMTk7OuY8k6dyNdQZeVUeH55PA54BrgBNJNgMMzydXqkhJ0pkWDPAkL0nyq6eXgT8CHgH2AzuG3XYA+1aqSEnSmcaZQtkEfC7J6f3/rar+PcnXgHuT7ASeBm5ZuTIlSbMtGOBV9STw2jna/xe4fiWKkiQtzDsxJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJampsQM8yYYkDye5f1i/IslDSZ5Ick+SC1euTEnSbOdyBn4rcHjG+u3AHVX1SuBZYOdyFiZJOruxAjzJFuAtwJ3DeoDrgPuGXfYC21eiQEnS3MY9A/8I8D7gZ8P6y4DnqurUsH4EuGyuFybZlWQqydT09PSSipUkPW/BAE9yI3Cyqg4u5gBVtaeqJqtqcmJiYjE/QpI0h41j7PN64K1J3gy8CPg14KPARUk2DmfhW4CjK1emJGm2Bc/Aq+r9VbWlqrYCbwO+WFXvAB4Ebh522wHsW7EqJUlnWMp14LcBf53kCUZz4nctT0mSpHGMM4Xyc1X1JeBLw/KTwDXLX5IkaRzeiSlJTRngktSUAS5JTRngktSUAS5JTRngktSUAS5JTRngktSUAS5JTRngktSUAS5JTRngktSUAS5JTRngktSUAS5JTRngktSUAS5JTRngktSUAS5JTRngktSUAS5JTRngktSUAS5JTRngktSUAS5JTRngktTUggGe5EVJvprkG0keTfLBof2KJA8leSLJPUkuXPlyJUmnjXMG/mPguqp6LbANuCHJtcDtwB1V9UrgWWDnypUpSZptwQCvkR8NqxcMjwKuA+4b2vcC21ekQknSnMaaA0+yIckh4CTwAPBd4LmqOjXscgS4bGVKlCTNZawAr6qfVtU2YAtwDfDqcQ+QZFeSqSRT09PTiyxTkjTbOV2FUlXPAQ8CrwMuSrJx2LQFODrPa/ZU1WRVTU5MTCypWEnS88a5CmUiyUXD8ouBNwGHGQX5zcNuO4B9K1WkJOlMGxfehc3A3iQbGAX+vVV1f5LHgE8n+UfgYeCuFaxTkjTLggFeVd8Erp6j/UlG8+GSpDXgnZiS1JQBLklNGeCS1JQBLklNGeCS1JQBLklNGeCS1JQBLklNGeCS1JQBLklNGeCS1JQBLklNGeCS1JQBLklNGeCS1JQBLklNGeCS1JQBLklNGeCS1JQBLklNGeCS1JQBLklNGeCS1JQBLklNGeCS1JQBLklNGeCS1NSCAZ7k5UkeTPJYkkeT3Dq0X5LkgSSPD88Xr3y5kqTTxjkDPwW8t6quAq4F3pXkKmA3cKCqrgQODOuSpFWyYIBX1bGq+vqw/EPgMHAZcBOwd9htL7B9pYqUJJ3pnObAk2wFrgYeAjZV1bFh03Fg0zyv2ZVkKsnU9PT0EkqVJM00doAneSnwGeA9VfWDmduqqoCa63VVtaeqJqtqcmJiYknFSpKeN1aAJ7mAUXh/sqo+OzSfSLJ52L4ZOLkyJUqS5jLOVSgB7gIOV9WHZ2zaD+wYlncA+5a/PEnSfDaOsc/rgXcC30pyaGj7APAh4N4kO4GngVtWpkRJ0lwWDPCq+i8g82y+fnnLkSSNyzsxJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJakpA1ySmjLAJampBQM8yceTnEzyyIy2S5I8kOTx4fnilS1TkjTbOGfgdwM3zGrbDRyoqiuBA8O6JGkVLRjgVfVl4Puzmm8C9g7Le4Hty1yXJGkBi50D31RVx4bl48Cm+XZMsivJVJKp6enpRR5OkjTbkt/ErKoC6izb91TVZFVNTkxMLPVwkqTBYgP8RJLNAMPzyeUrSZI0jsUG+H5gx7C8A9i3POVIksY1zmWEnwL+G3hVkiNJdgIfAt6U5HHgD4d1SdIq2rjQDlX19nk2Xb/MtUiSzoF3YkpSUwa4JDVlgEtSUwa4JDVlgEtSUwa4JDVlgEtSUwa4JDVlgGtOm7dcTpJVe2zecvlad1lqZ8E7MfXCdPzoM7zitvtX7XhP337jqh1LOl94Bi5JTRngktSUAS5JTRngktSUAS5JTRngktSUAS5JTRngktSUAS5JTRngktSUAS5JTRngktSUAS5JTRngktSUAS5JTRngktTUkgI8yQ1JvpPkiSS7l6so6YVoNb8FyW9AOj/+vBf9jTxJNgD/ArwJOAJ8Lcn+qnpsuYqTXkhW81uQ/Aak8+PPeyln4NcAT1TVk1X1E+DTwE3LU5YkaSFLCfDLgGdmrB8Z2iRJqyBVtbgXJjcDN1TVnw/r7wR+r6rePWu/XcCuYfVVwHcWcbhLge8tqtD1x76sT/Zl/Tqf+rPYvryiqiZmNy7lW+mPAi+fsb5laPsFVbUH2LOE45Bkqqoml/Iz1gv7sj7Zl/XrfOrPcvdlKVMoXwOuTHJFkguBtwH7l6csSdJCFn0GXlWnkrwb+A9gA/Dxqnp02SqTJJ3VUqZQqKovAF9YplrOZklTMOuMfVmf7Mv6dT71Z1n7sug3MSVJa8tb6SWpqXUV4Ek+nuRkkkdmtF2S5IEkjw/PF69ljeOapy9/n+RokkPD481rWeO4krw8yYNJHkvyaJJbh/auYzNff9qNT5IXJflqkm8Mffng0H5FkoeGj7m4Z7jQYF07S1/uTvI/M8Zl21rXOq4kG5I8nOT+YX1Zx2VdBThwN3DDrLbdwIGquhI4MKx3cDdn9gXgjqraNjxW4/2D5XAKeG9VXQVcC7wryVX0HZv5+gP9xufHwHVV9VpgG3BDkmuB2xn15ZXAs8DONaxxXPP1BeBvZ4zLobUr8ZzdChyesb6s47KuAryqvgx8f1bzTcDeYXkvsH1Vi1qkefrSUlUdq6qvD8s/ZPQX8jL6js18/WmnRn40rF4wPAq4DrhvaG8xNmfpS0tJtgBvAe4c1sMyj8u6CvB5bKqqY8PycWDTWhazDN6d5JvDFEuLKYeZkmwFrgYe4jwYm1n9gYbjM/yafgg4CTwAfBd4rqpODbu0+ZiL2X2pqtPj8k/DuNyR5JfXsMRz8RHgfcDPhvWXsczj0iHAf65Gl8y0/R8Z+BjwW4x+PTwG/PPalnNukrwU+Azwnqr6wcxtHcdmjv60HJ+q+mlVbWN0N/Q1wKvXuKRFm92XJK8B3s+oT78LXALctoYljiXJjcDJqjq4ksfpEOAnkmwGGJ5PrnE9i1ZVJ4a/oD8D/pXRP7YWklzAKOw+WVWfHZrbjs1c/ek8PgBV9RzwIPA64KIkp+/zmPNjLtazGX25YZjyqqr6MfAJeozL64G3JnmK0Se1Xgd8lGUelw4Bvh/YMSzvAPatYS1LcjrsBn8MPDLfvuvJMHd3F3C4qj48Y1PLsZmvPx3HJ8lEkouG5Rcz+nz+w4zC7+ZhtxZjM09fvj3jJCGM5ozX/bhU1furaktVbWX0MSNfrKp3sMzjsq5u5EnyKeCNjD6x6wTwd8DngXuBy4GngVuqat2/OThPX97I6NfzAp4C/mLGHPK6leQNwFeAb/H8fN4HGM0bdxyb+frzdpqNT5LfZvRm2AZGJ2T3VtU/JPlNRmd+lwAPA38ynMGuW2fpyxeBCSDAIeAvZ7zZue4leSPwN1V143KPy7oKcEnS+DpMoUiS5mCAS1JTBrgkNWWAS1JTBrgkNWWAS1JTBrgkNWWAS1JT/w/4ljrvdxlcAwAAAABJRU5ErkJggg==\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## A comprehensive solution for building a seizure detection system\n",
        "One of the main flaws of CNN models is that if our data isn't enough and doesn't have the desired variety it won't be general enough to use on different Patients so one way to fix this is to get samples of many patients as possible so we get many different ways a seizure might occur!"
      ],
      "metadata": {
        "id": "_ekO2VzNs849"
      },
      "id": "_ekO2VzNs849"
    },
    {
      "cell_type": "markdown",
      "source": [
        "Our structured model which we just achieved and used all our knowledge and any ways we could have thought about on it finally got to 0.87 accuracy and by having enough input samples we won't be needing any other classifiers to mix it with our model, we just need to make our CNN model as precise as we can."
      ],
      "metadata": {
        "id": "ZJz_JDZuu5u5"
      },
      "id": "ZJz_JDZuu5u5"
    },
    {
      "cell_type": "markdown",
      "source": [
        "By looking into what we did in this project and what we achieved we can give a piece of professional advice on how to program the implant on the patient, we think the best way to plan it is to have it send the last 20-second signal every 20 seconds, this gives us enough testing time to give to our trained and ready model also it's enough time to inject medicene to our patient if needed."
      ],
      "metadata": {
        "id": "rMGwOnh3wh8V"
      },
      "id": "rMGwOnh3wh8V"
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "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.5"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}