Model_1st_Dataset.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "df = pd.read_csv(\"Parkinsson disease.csv\")\n",
    "\n",
    "# Data Cleaning\n",
    "df.drop('name', axis=1, inplace=True)\n",
    "\n",
    "X= df.drop('status', axis=1)\n",
    "Y= df['status']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['MDVP:Fo(Hz)', 'MDVP:Fhi(Hz)', 'MDVP:Flo(Hz)', 'MDVP:Jitter(%)',\n",
      "       'MDVP:Jitter(Abs)', 'MDVP:RAP', 'MDVP:PPQ', 'Jitter:DDP',\n",
      "       'MDVP:Shimmer', 'MDVP:Shimmer(dB)', 'Shimmer:APQ3', 'Shimmer:APQ5',\n",
      "       'MDVP:APQ', 'Shimmer:DDA', 'NHR', 'HNR', 'status', 'RPDE', 'DFA',\n",
      "       'spread1', 'spread2', 'D2', 'PPE'],\n",
      "      dtype='object')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 14/14 [00:03<00:00,  4.34it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['spread1', 'PPE', 'spread2', 'MDVP:Shimmer', 'MDVP:Fo(Hz)', 'D2', 'MDVP:Flo(Hz)', 'MDVP:APQ', 'Shimmer:APQ3', 'Shimmer:DDA', 'MDVP:Jitter(Abs)', 'Shimmer:APQ5', 'RPDE', 'MDVP:Shimmer(dB)']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from imblearn.over_sampling import SVMSMOTE\n",
    "from mrmr import mrmr_classif\n",
    "overampler = SVMSMOTE(random_state=42)\n",
    "\n",
    "# Oversampling the data\n",
    "X, Y = overampler.fit_resample(X, Y)\n",
    "#Shuffling the data\n",
    "X['status'] = Y\n",
    "X=X.sample(frac=1,random_state=0).reset_index(drop=True)\n",
    "Y=X['status']\n",
    "X=X.drop('status', axis=1)\n",
    "\n",
    "print(df.columns)\n",
    "# Select the features\n",
    "\n",
    "# model = KNeighborsClassifier()\n",
    "\n",
    "# # Define the range of K\n",
    "# K_range = range(1, 20)\n",
    "\n",
    "# # Store the cross-validation scores\n",
    "# cv_scores = []\n",
    "\n",
    "# # Loop over K_range\n",
    "# for K in K_range:\n",
    "#     # Select top K features\n",
    "#     features_check = mrmr_classif(X, Y, K=K)\n",
    "    \n",
    "#     # Train and evaluate the model\n",
    "#     score = cross_val_score(model, X[features_check], Y, cv=5).mean()\n",
    "    \n",
    "#     # Append the score\n",
    "#     cv_scores.append(score)\n",
    "\n",
    "# # Find the optimal K\n",
    "# optimal_K = K_range[cv_scores.index(max(cv_scores))]\n",
    "# print(\"Optimal K:\", optimal_K)\n",
    "\n",
    "features = mrmr_classif(X,Y, K=14)\n",
    "# Print the selected features\n",
    "print(features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['MDVP:Fo(Hz)', 'MDVP:Fhi(Hz)', 'MDVP:Flo(Hz)', 'MDVP:Jitter(%)',\n",
      "       'MDVP:Jitter(Abs)', 'MDVP:RAP', 'MDVP:PPQ', 'Jitter:DDP',\n",
      "       'MDVP:Shimmer', 'MDVP:Shimmer(dB)', 'Shimmer:APQ3', 'Shimmer:APQ5',\n",
      "       'MDVP:APQ', 'Shimmer:DDA', 'NHR', 'HNR', 'RPDE', 'DFA', 'spread1',\n",
      "       'spread2', 'D2', 'PPE'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "X_temp, X_test, Y_temp, Y_test = train_test_split(X, Y, test_size=0.2, random_state=42)\n",
    "\n",
    "X_train, X_val, Y_train, Y_val = train_test_split(X_temp, Y_temp, test_size=0.25, random_state=42)\n",
    "\n",
    "scaler=StandardScaler()\n",
    "columns=X_train.columns\n",
    "\n",
    "X_train=pd.DataFrame(scaler.fit_transform(X_train), columns=columns)\n",
    "X_val=pd.DataFrame(scaler.fit_transform(X_val), columns=columns)\n",
    "X_test=pd.DataFrame(scaler.fit_transform(X_test), columns=columns)\n",
    "print(X_train.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['Shimmer:APQ5', 'MDVP:Jitter(Abs)', 'D2', 'MDVP:Shimmer', 'MDVP:APQ',\n",
      "       'D2', 'MDVP:Jitter(Abs)', 'MDVP:Fo(Hz)', 'MDVP:Flo(Hz)', 'Shimmer:APQ3',\n",
      "       'RPDE', 'MDVP:APQ', 'MDVP:Shimmer', 'MDVP:Jitter(Abs)', 'Shimmer:APQ3',\n",
      "       'MDVP:Shimmer', 'RPDE', 'MDVP:Shimmer(dB)', 'Shimmer:APQ5', 'RPDE',\n",
      "       'MDVP:Fo(Hz)', 'MDVP:Jitter(Abs)'],\n",
      "      dtype='object')\n",
      "Index(['RPDE', 'Shimmer:DDA', 'MDVP:Flo(Hz)', 'PPE', 'MDVP:Flo(Hz)',\n",
      "       'Shimmer:APQ3', 'RPDE', 'MDVP:Shimmer(dB)', 'MDVP:Flo(Hz)', 'RPDE',\n",
      "       'MDVP:Shimmer', 'Shimmer:APQ5', 'MDVP:APQ', 'spread1',\n",
      "       'MDVP:Jitter(Abs)', 'D2', 'Shimmer:APQ5', 'Shimmer:DDA', 'spread1',\n",
      "       'MDVP:Flo(Hz)', 'RPDE', 'MDVP:Shimmer'],\n",
      "      dtype='object')\n",
      "Index(['MDVP:Fo(Hz)', 'RPDE', 'spread2', 'MDVP:APQ', 'MDVP:Shimmer',\n",
      "       'MDVP:Shimmer(dB)', 'Shimmer:APQ5', 'MDVP:Flo(Hz)', 'PPE',\n",
      "       'MDVP:Fo(Hz)', 'MDVP:APQ', 'MDVP:Shimmer(dB)', 'PPE', 'MDVP:APQ',\n",
      "       'Shimmer:DDA', 'MDVP:APQ', 'Shimmer:APQ5', 'MDVP:APQ',\n",
      "       'MDVP:Shimmer(dB)', 'Shimmer:APQ3', 'Shimmer:APQ3', 'MDVP:Flo(Hz)'],\n",
      "      dtype='object')\n",
      "Index(['Shimmer:APQ3', 'D2', 'Shimmer:APQ3', 'MDVP:Fo(Hz)', 'spread2',\n",
      "       'spread2', 'Shimmer:APQ3', 'Shimmer:DDA', 'MDVP:Flo(Hz)', 'PPE',\n",
      "       'MDVP:Jitter(Abs)', 'RPDE', 'RPDE', 'Shimmer:APQ5', 'RPDE', 'RPDE',\n",
      "       'MDVP:APQ', 'D2', 'Shimmer:DDA', 'MDVP:Shimmer', 'Shimmer:APQ5',\n",
      "       'Shimmer:APQ5'],\n",
      "      dtype='object')\n",
      "Index(['RPDE', 'Shimmer:APQ3', 'MDVP:Shimmer(dB)', 'Shimmer:APQ3',\n",
      "       'MDVP:Flo(Hz)', 'Shimmer:DDA', 'MDVP:Shimmer(dB)', 'RPDE',\n",
      "       'Shimmer:APQ5', 'PPE', 'Shimmer:APQ3', 'MDVP:Flo(Hz)', 'Shimmer:APQ3',\n",
      "       'Shimmer:APQ5', 'MDVP:Shimmer', 'MDVP:Jitter(Abs)', 'PPE',\n",
      "       'MDVP:Shimmer', 'Shimmer:APQ5', 'MDVP:Fo(Hz)', 'Shimmer:APQ5', 'PPE'],\n",
      "      dtype='object')\n",
      "Index(['spread2', 'Shimmer:DDA', 'spread1', 'Shimmer:APQ3', 'RPDE', 'MDVP:APQ',\n",
      "       'Shimmer:DDA', 'spread1', 'Shimmer:APQ3', 'Shimmer:APQ3',\n",
      "       'Shimmer:APQ3', 'D2', 'D2', 'MDVP:Shimmer(dB)', 'spread1', 'spread1',\n",
      "       'MDVP:Shimmer(dB)', 'spread2', 'PPE', 'spread2', 'Shimmer:APQ5',\n",
      "       'MDVP:Shimmer(dB)'],\n",
      "      dtype='object')\n",
      "Index(['spread1', 'D2', 'PPE', 'MDVP:Shimmer', 'MDVP:Shimmer', 'Shimmer:DDA',\n",
      "       'MDVP:Fo(Hz)', 'spread2', 'MDVP:APQ', 'spread1', 'PPE',\n",
      "       'MDVP:Shimmer(dB)', 'spread2', 'D2', 'MDVP:Jitter(Abs)', 'Shimmer:APQ5',\n",
      "       'RPDE', 'spread2', 'Shimmer:DDA', 'MDVP:Shimmer(dB)', 'spread1',\n",
      "       'Shimmer:DDA'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "k=7 #Number of bags\n",
    "\n",
    "# Randomly select 22 elements from the list, allowing duplicates\n",
    "X_train_sets=[]\n",
    "X_val_sets=[]\n",
    "X_test_sets=[]\n",
    "random.seed(0)\n",
    "for i in range(k):\n",
    "    resampled_features = random.choices(features, k=22)\n",
    "    X_train_sets.append(X_train[resampled_features])\n",
    "    X_val_sets.append(X_val[resampled_features])\n",
    "    X_test_sets.append(X_test[resampled_features])\n",
    "    print(X_train_sets[i].columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import KFold\n",
    "\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.linear_model import LogisticRegression,RidgeClassifier\n",
    "\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "models=[]\n",
    "for i in range(len(X_train_sets)):\n",
    "    models.append([SVC(), GaussianNB(), KNeighborsClassifier(),\\\n",
    "                    DecisionTreeClassifier(random_state=42), LogisticRegression(random_state=42), RidgeClassifier(random_state=42)])\n",
    "\n",
    "k_fold=KFold(n_splits=5, shuffle=True, random_state=42)\n",
    "\n",
    "for i in range(len(X_train_sets)):\n",
    "    X_train_fromsets=X_train_sets[i]\n",
    "    \n",
    "    for train_index, val_index in k_fold.split(X_train_fromsets):\n",
    "        X_train_kfold, X_val_kfold = X_train_fromsets.iloc[train_index], X_train_fromsets.iloc[val_index]\n",
    "        Y_train_kfold, Y_val_kfold = Y_train.iloc[train_index], Y_train.iloc[val_index]\n",
    "\n",
    "        for model in models[i]:\n",
    "            model.fit(X_train_kfold, Y_train_kfold)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bag 1:\n",
      "SVC :  0.7627118644067796\n",
      "GaussianNB :  0.7288135593220338\n",
      "KNeighborsClassifier :  0.864406779661017\n",
      "DecisionTreeClassifier :  0.864406779661017\n",
      "LogisticRegression :  0.7627118644067796\n",
      "RidgeClassifier :  0.6949152542372882\n",
      "Best model: KNeighborsClassifier\n",
      "\n",
      "\n",
      "Bag 2:\n",
      "SVC :  0.8135593220338984\n",
      "GaussianNB :  0.7457627118644068\n",
      "KNeighborsClassifier :  0.864406779661017\n",
      "DecisionTreeClassifier :  0.847457627118644\n",
      "LogisticRegression :  0.7457627118644068\n",
      "RidgeClassifier :  0.7796610169491526\n",
      "Best model: KNeighborsClassifier\n",
      "\n",
      "\n",
      "Bag 3:\n",
      "SVC :  0.8305084745762712\n",
      "GaussianNB :  0.7457627118644068\n",
      "KNeighborsClassifier :  0.9491525423728814\n",
      "DecisionTreeClassifier :  0.9152542372881356\n",
      "LogisticRegression :  0.7627118644067796\n",
      "RidgeClassifier :  0.7457627118644068\n",
      "Best model: KNeighborsClassifier\n",
      "\n",
      "\n",
      "Bag 4:\n",
      "SVC :  0.8135593220338984\n",
      "GaussianNB :  0.7288135593220338\n",
      "KNeighborsClassifier :  0.864406779661017\n",
      "DecisionTreeClassifier :  0.9491525423728814\n",
      "LogisticRegression :  0.7627118644067796\n",
      "RidgeClassifier :  0.7796610169491526\n",
      "Best model: DecisionTreeClassifier\n",
      "\n",
      "\n",
      "Bag 5:\n",
      "SVC :  0.8305084745762712\n",
      "GaussianNB :  0.7457627118644068\n",
      "KNeighborsClassifier :  0.9322033898305084\n",
      "DecisionTreeClassifier :  0.9491525423728814\n",
      "LogisticRegression :  0.7288135593220338\n",
      "RidgeClassifier :  0.7627118644067796\n",
      "Best model: DecisionTreeClassifier\n",
      "\n",
      "\n",
      "Bag 6:\n",
      "SVC :  0.8305084745762712\n",
      "GaussianNB :  0.7796610169491526\n",
      "KNeighborsClassifier :  0.864406779661017\n",
      "DecisionTreeClassifier :  0.847457627118644\n",
      "LogisticRegression :  0.7457627118644068\n",
      "RidgeClassifier :  0.8305084745762712\n",
      "Best model: KNeighborsClassifier\n",
      "\n",
      "\n",
      "Bag 7:\n",
      "SVC :  0.8305084745762712\n",
      "GaussianNB :  0.7796610169491526\n",
      "KNeighborsClassifier :  0.8983050847457628\n",
      "DecisionTreeClassifier :  0.864406779661017\n",
      "LogisticRegression :  0.7457627118644068\n",
      "RidgeClassifier :  0.8135593220338984\n",
      "Best model: KNeighborsClassifier\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "best_models=[]\n",
    "for i in range(len(X_val_sets)):\n",
    "    X_val_fromsets=X_val_sets[i]\n",
    "    accuracies=[]\n",
    "    print(f\"Bag {i+1}:\")\n",
    "    for model in models[i]:\n",
    "        Y_pred = model.predict(X_val_fromsets)\n",
    "        acc=accuracy_score(Y_val, Y_pred)\n",
    "        accuracies.append(acc)\n",
    "        print(f\"{type(model).__name__} : \",acc)\n",
    "    best_model=models[i][accuracies.index(max(accuracies))]\n",
    "    best_models.append(best_model)\n",
    "    print(f\"Best model: {type(best_model).__name__}\")\n",
    "        \n",
    "    print(\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "KNeighborsClassifier : "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 0.847457627118644\n",
      "\n",
      "\n",
      "KNeighborsClassifier :  0.8813559322033898\n",
      "\n",
      "\n",
      "KNeighborsClassifier :  0.9491525423728814\n",
      "\n",
      "\n",
      "DecisionTreeClassifier :  0.847457627118644\n",
      "\n",
      "\n",
      "DecisionTreeClassifier :  0.7966101694915254\n",
      "\n",
      "\n",
      "KNeighborsClassifier :  0.9152542372881356\n",
      "\n",
      "\n",
      "KNeighborsClassifier :  0.9322033898305084\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "Y_pred_sets=pd.DataFrame()\n",
    "for i in range(len(X_test_sets)):\n",
    "    X_test_fromsets=X_test_sets[i]\n",
    "    best_model=best_models[i]\n",
    "    Y_pred = best_model.predict(X_test_fromsets)\n",
    "    Y_pred_sets[f\"Y_pred_{i}\"]=Y_pred\n",
    "    acc=accuracy_score(Y_test, Y_pred)\n",
    "    print(f\"{type(best_model).__name__} : \",acc)\n",
    "    print(\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sensitivity: 0.96\n",
      "Specificity: 0.9411764705882353\n",
      "False Positive Rate: 0.058823529411764705\n",
      "Positive Predictive Value: 0.9230769230769231\n",
      "Negative Predictive Value: 0.9696969696969697\n",
      "\n",
      "Majority Voting Accuracy :  0.9491525423728814\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "Y_pred_sets['mode']=Y_pred_sets.mode(axis=1)\n",
    "# print(Y_pred_sets)K\n",
    "\n",
    "tn, fp, fn, tp = confusion_matrix(Y_test, Y_pred_sets['mode']).ravel()\n",
    "\n",
    "sensitivity = tp / (tp + fn)\n",
    "specificity = tn / (tn + fp)\n",
    "fpr = fp / (fp + tn)\n",
    "ppv = tp / (tp + fp)\n",
    "npv = tn / (tn + fn)\n",
    "accuracy = (tp + tn) / (tp + fp + tn + fn)\n",
    "\n",
    "print(f\"Sensitivity: {sensitivity}\")\n",
    "print(f\"Specificity: {specificity}\")\n",
    "print(f\"False Positive Rate: {fpr}\")\n",
    "print(f\"Positive Predictive Value: {ppv}\")\n",
    "print(f\"Negative Predictive Value: {npv}\")\n",
    "print(f\"\\nMajority Voting Accuracy : \",accuracy)\n",
    "Y_pred_sets.drop('mode', axis=1, inplace=True)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Accuracy :  0.9661016949152542\n"
     ]
    }
   ],
   "source": [
    "Y_pred_val_sets=pd.DataFrame()\n",
    "for i in range(len(X_val_sets)):\n",
    "    X_val_fromsets=X_val_sets[i]\n",
    "    best_model=best_models[i]\n",
    "    Y_pred_val = best_model.predict(X_val_fromsets)\n",
    "    Y_pred_val_sets[f\"Y_pred_{i}\"]=Y_pred_val\n",
    "    acc=accuracy_score(Y_val, Y_pred_val)\n",
    "\n",
    "model=DecisionTreeClassifier(random_state=42)\n",
    "model.fit(Y_pred_val_sets, Y_val)\n",
    "Y_pred_val = model.predict(Y_pred_val_sets)\n",
    "acc=accuracy_score(Y_val, Y_pred_val)\n",
    "print(\"Validation Accuracy : \",acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final Accuracy :  0.9661016949152542\n"
     ]
    }
   ],
   "source": [
    "final_preds=model.predict(Y_pred_sets)\n",
    "acc=accuracy_score(Y_test, final_preds)\n",
    "print(\"Final Accuracy : \",acc)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}