Epileptic Seizure - Recognition Using EEG.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "aa17c9e1",
   "metadata": {},
   "source": [
    "# Epileptic Seizure Recognition "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28e516c5",
   "metadata": {},
   "source": [
    "# Project 1: Machine Learning Algorithms for Epileptic Seizures"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "489b0b13",
   "metadata": {},
   "source": [
    "**Dataset**\n",
    "https://www.kaggle.com/harunshimanto/epileptic-seizure-recognition\n",
    "    \n",
    "**Dataset name**\n",
    "Epileptic Seizure Recognition epileptic seizure detection\n",
    "\n",
    "**Dataset file **\n",
    "Epileptic Seizure Recognition.csv\n",
    "\n",
    "**number means in dataset of FX (Y)**\n",
    "• 5 - eyes open, means when they were recording the EEG signal of the brain the patient had their eyes open\n",
    "• 4 - eyes closed, means when they were recording the EEG signal the patient had their eyes closed\n",
    "• 3 - Yes they identify where the region of the tumor was in the brain and recording the EEG activity from the healthy brain area\n",
    "• 2 - They recorder the EEG from the area where the tumor was located\n",
    "• 1 - Recording of seizure activity\n",
    "\n",
    "All subjects falling in classes 2, 3, 4, and 5 are subjects who did not have epileptic seizure. Only subjects in class 1 have epileptic seizure.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89b9ed5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "import matplotlib.pyplot as plt \n",
    "import pandas as pd \n",
    "import seaborn as sn \n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "ESR = pd.read_csv('Epileptic Seizure Recognition.csv')\n",
    "print (ESR. head ( ))\n",
    "cols = ESR. columns\n",
    "tgt = ESR.y\n",
    "tgt [tgt>1]=0\n",
    "ax = sn. countplot (tgt, label=\"Count\")\n",
    "plt.show ()\n",
    "non_seizure, seizure = tgt. value_counts ()\n",
    "print('The number of trials for the non-seizure class is:', non_seizure)\n",
    "print ('The number of trials for the seizure class is:', seizure)\n",
    "print (ESR.isnull().sum())\n",
    "print (ESR.info())\n",
    "X = ESR.iloc [:,1:179].values\n",
    "print (X.shape)\n",
    "\n",
    "plt. subplot (511)\n",
    "plt.plot (X[1,:])\n",
    "pit.title('Classes')\n",
    "plt.ylabel('uV')\n",
    "pit.subplot (512)\n",
    "plt.plot (X[7, :])\n",
    "plt.subplot(513)\n",
    "plt.plot (X[12,:])\n",
    "plt.subplot (514)\n",
    "plt.plot(X[0, : ])\n",
    "plt.subplot(515)\n",
    "plt.plot (X[2,:])\n",
    "plt.xlabel ('Samples')\n",
    "plt.show ()\n",
    "\n",
    "y = ESR. iloc[:, 179]. values\n",
    "print (y)\n",
    "У[у>1]=0\n",
    "print(y)\n",
    "\n",
    "from sklearn. model_selection import train_test_split, cross_val_score\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2)\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "sc = StandardScaler ( )\n",
    "X_train = sc.fit_transform(X_train)\n",
    "X test = sc.transform(X test)\n",
    "#- -\n",
    "from sklearn. linear_model import LogisticRegression\n",
    "c1f = LogisticRegression ()\n",
    "clf.fit (X_train, y_train)\n",
    "y_pred_log_reg = clf.predict (X_test)\n",
    "acc_log_reg = round(clf.score(X_test, y_test) * 100, 2)\n",
    "print (str(acc_log_reg) + ' %')\n",
    "\n",
    "#--\n",
    "from sklearn.svm import SVC\n",
    "clf = SVC ()\n",
    "clf.fit(X_train, y_train)\n",
    "y_pred_svc = clf.predict (X_test)\n",
    "acc_svc = round(clf.score (X_test, y_test) * 100, 2)\n",
    "print (str(acc_svc) + '%')\n",
    "#--\n",
    "from sklearn. svm import sC, Linearsvc\n",
    "clf = LinearSVC()\n",
    "clf.fit(X_train, y_train)\n",
    "y_pred_linear_svc = clf.predict (X_test)\n",
    "acc_linear_svc = round(clf.score(X_test, y_test) * 100, 2)\n",
    "print (str (acc_linear_svc) + '%*)\n",
    "\n",
    "\n",
    " -\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "clf = KNeighborsClassifier ()\n",
    "clf.fit(X_train, y_train)\n",
    "y_pred_knn = clf.predict(X_test)\n",
    "acc_knn = round(clf.score(X_test, y_test) * 100,\n",
    "print (str (acc_knn)+'%*)\n",
    "#-\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "clf = GaussianNB\n",
    "c1f.fit(X_train, y_train)\n",
    "y_pred_gnb = clf.predict(X_test)\n",
    "acc_gnb = round (clf.score(X_test, y_test) * 100, 2)\n",
    "print (str (acc_gnb) + '%')\n",
    "#-\n",
    "from sklearn.decomposition import PCA\n",
    "pca = PCA()\n",
    "X_train_pca = pca.fit_transform(X_train)\n",
    "X_test_pca = pa.transform(X_test)\n",
    "acc_PCA = round(pa.score (X_test, y_test).)\n",
    "print (str(acc_PCA) + '%')\n",
    "\n",
    "#Importing keras Libraries and packages import keras\n",
    "from keras.models import Sequential from keras.layers import Dense\n",
    "classifier = Sequential ()\n",
    "classifier.add(Dense(output_dim = 80, init = 'uniform', activation = 'relu', input_dim = 178))\n",
    "classifier.add(Dense(output_dim = 80, init = 'uniform', activation = 'relu'))\n",
    "classifier.add (Dense (output_dim = 1, init = 'uniform', activation = 'sigmoid'))\n",
    "classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])\n",
    "#Fitting the ANN to the training set\n",
    "history=classifier.fit(X_train, y_train, batch_size = 10, b_epoch = 100)\n",
    "# Predicting the Test set results\n",
    "print(\"Evaluation: \")\n",
    "mse, acc_ANN = classifier.evaluate (X_test, y_test)\n",
    "acc ANN = acc ANN * 100\n",
    "print (str(acc ANN) + '%\")\n",
    "\n",
    "\n",
    "-models = pd.DataFrame ( {\n",
    "'Model': ['Logistic Regression', 'Support Vector Machines', 'ANN'\n",
    "'KNN' .\n",
    "'Naive Bayes'\n",
    "'Principal Component Analysis'],\n",
    "'Score': [acc_log_reg, acc_svc, acc_ANN, acc_knn, acc_gnb, acc_PCA]\n",
    "})\n",
    "print (models.sort_values (by='Score', ascending=False))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eedf13ac",
   "metadata": {},
   "source": [
    "# Project 2 : Deep Learning with Python: Epileptic Seizure Detection on EEG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3352677",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dataset\n",
    "https://archive.ics.uci.edu/ml/datasets/Epileptic+Seizure+Recognition\n",
    "Machine Learning Repository\n",
    "Epileptic Seizure Recognition Data Set\n",
    "data = \"data.csv\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c20a1281",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv(data, header=0, index_col=0)\n",
    "print (df. head())\n",
    "print (df.info())\n",
    "\n",
    "dfr\"seizure\" = 0\n",
    "for i in range (11500):\n",
    "    if df[\"y\" ][i] == 1:\n",
    "        df[\"seizure\"][i]=1\n",
    "    else:\n",
    "        df[\"seizure\"][i] = 0\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "# plotting an epileptic wave form\n",
    "plt.plot (range (178), df.iloc [11496, 0:178])\n",
    "plt.show()\n",
    "plt.plot (range (178), df.iloc[0,0:178])\n",
    "plt.show()\n",
    "\n",
    "\n",
    "# create df1 which only contains the waveform data points\n",
    "df1 = df. drop ([\"seizure\", \"y\"], axis=1)\n",
    "# 1. parse the data\n",
    "import numpy as np\n",
    "wave = np. zeros ((11500, 178))\n",
    "_index =0\n",
    "for index, row in df1.iterrows ():\n",
    "    wave [_ index,:] = row\n",
    "    _index+=1\n",
    "# print the wave. shape to make sure we parsed the data correctly\n",
    "print (wave.shape)\n",
    "# 2. standardize the data such that it has mean of 0 and standard deviation of\n",
    "mean = wave. mean (axis=0)\n",
    "wave -= mean\n",
    "std = wave.std (axis=0)\n",
    "wave /= std\n",
    "# 3. create the target numpy array\n",
    "target = df [\"seizure\"].values\n",
    "\n",
    "\n",
    "from sklearn.metrics import roc_curve, auc\n",
    "Y_pred = model.predict (×_test).ravel ()\n",
    "fpr_keras, tpr_keras, thresholds_keras = roc_curve (y_test, y_pred)\n",
    "AUC = auc (fpr_keras, tpr_keras)\n",
    "pit.plot (fpr_keras, tpr_keras, label='Keras Model(area = {:.3f})'.format (AUC))\n",
    "plt.xlabel ('False positive Rate')\n",
    "pit.ylabel ('True positive Rate')\n",
    "pit.title('ROC curve')\n",
    "plt.legend(loc='best')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "acc = history.history['acc' ]\n",
    "val_acc = history.history[ 'val_acc']\n",
    "loss = history.history['loss']\n",
    "val_loss = historg.history[ 'val_loss']\n",
    "epochs = range(len (acc))\n",
    "pit.plot (epochs, acc, 'b', label='Training acc') \n",
    "plt.plot(epochs, val_acc, 'p', label='Validation acc')\n",
    "plt. title('Training and validation accuracy') \n",
    "plt.legend()\n",
    "plt.figure()\n",
    "plt.plot(epochs, loss, 'b', label='Training loss') \n",
    "plt.plot(epochs, val_loss,'r', label='Validation loss')\n",
    "plt.title('Training and validation loss')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86e8d931",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-09T04:31:01.644162Z",
     "start_time": "2023-04-09T04:31:01.636182Z"
    }
   },
   "source": [
    "# Resources:\n",
    "\n",
    "https://www.kaggle.com/harunshimanto/machine-learning-algorithms-for-epileptic-seizures\n",
    "\n",
    "https://medium.com/@steven827/deep-learning-with-python-epileptic-seizure-detection-on-eeg-41dcb6a0b64c\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f5807721",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}