diff --git a/ML Algorithms/Parkinson Disease Detection using SVM.ipynb b/ML Algorithms/Parkinson Disease Detection using SVM.ipynb new file mode 100644 index 000000000..046f52e7c --- /dev/null +++ b/ML Algorithms/Parkinson Disease Detection using SVM.ipynb @@ -0,0 +1,1678 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Parkinson's Disease Detection using SVMs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Building a system that can detect Parkinson's disease in a patient depending upon certain medical procedures" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Parkinson's disease- \n", + "It is a progressive nervous system disorder that affects movement leading to shaking, stiffness, and difficulty with walking, balance, and coordination. Parkinson's symptoms usually begin gradually and get worse over time" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Workflow-\n", + " Parkinson's Data ----> Data pre processing ----> Train Test and Split ----> Support Vector Machine Classifier\n", + " \n", + " New Data ----> Trained SVM classifier ----> Prediction of disease" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Importing the Dependencies" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np \n", + "import pandas as pd \n", + "import matplotlib.pyplot as plt \n", + "import seaborn as sns\n", + "from sklearn.model_selection import train_test_split, GridSearchCV\n", + "from sklearn.preprocessing import StandardScaler #stand data in common fram\n", + "from sklearn import svm #model\n", + "from sklearn.metrics import accuracy_score #For evaluation\n", + "from sklearn.metrics import classification_report, confusion_matrix" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### About Dataset used-\n", + " I have used Parkinson's dataset that is given on kaggle.com site and freely available.\n", + " \n", + " About dataset-\n", + " This dataset is composed of a range of biomedical voice measurements from 31 people, 23 with Parkinson's disease (PD). \n", + " Each column in the table is a particular voice measure, and each row corresponds one of 195 voice recording from \n", + " these individuals (\"name\" column). The main aim of the data is to discriminate healthy people from those with PD, \n", + " according to \"status\" column which is set to 0 for healthy and 1 for PD.\n", + " \n", + " Attribute Information:\n", + "\n", + " Matrix column entries (attributes):\n", + " name - ASCII subject name and recording number\n", + " MDVP:Fo(Hz) - Average vocal fundamental frequency\n", + " MDVP:Fhi(Hz) - Maximum vocal fundamental frequency\n", + " MDVP:Flo(Hz) - Minimum vocal fundamental frequency\n", + " MDVP:Jitter(%),MDVP:Jitter(Abs),MDVP:RAP,MDVP:PPQ,Jitter:DDP - Several\n", + " measures of variation in fundamental frequency\n", + " MDVP:Shimmer,MDVP:Shimmer(dB),Shimmer:APQ3,Shimmer:APQ5,MDVP:APQ,Shimmer:DDA - Several measures of variation in amplitude\n", + " NHR,HNR - Two measures of ratio of noise to tonal components in the voice\n", + " status - Health status of the subject (one) - Parkinson's, (zero) - healthy\n", + " RPDE,D2 - Two nonlinear dynamical complexity measures\n", + " DFA - Signal fractal scaling exponent\n", + " spread1,spread2,PPE - Three nonlinear measures of fundamental frequency variation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Data Collection and Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "#Loading our dataset\n", + "parkinsons_data = pd.read_csv('parkinsons.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nameMDVP:Fo(Hz)MDVP:Fhi(Hz)MDVP:Flo(Hz)MDVP:Jitter(%)MDVP:Jitter(Abs)MDVP:RAPMDVP:PPQJitter:DDPMDVP:Shimmer...Shimmer:DDANHRHNRstatusRPDEDFAspread1spread2D2PPE
0phon_R01_S01_1119.992157.30274.9970.007840.000070.003700.005540.011090.04374...0.065450.0221121.03310.4147830.815285-4.8130310.2664822.3014420.284654
1phon_R01_S01_2122.400148.650113.8190.009680.000080.004650.006960.013940.06134...0.094030.0192919.08510.4583590.819521-4.0751920.3355902.4868550.368674
2phon_R01_S01_3116.682131.111111.5550.010500.000090.005440.007810.016330.05233...0.082700.0130920.65110.4298950.825288-4.4431790.3111732.3422590.332634
3phon_R01_S01_4116.676137.871111.3660.009970.000090.005020.006980.015050.05492...0.087710.0135320.64410.4349690.819235-4.1175010.3341472.4055540.368975
4phon_R01_S01_5116.014141.781110.6550.012840.000110.006550.009080.019660.06425...0.104700.0176719.64910.4173560.823484-3.7477870.2345132.3321800.410335
\n", + "

5 rows × 24 columns

\n", + "
" + ], + "text/plain": [ + " name MDVP:Fo(Hz) MDVP:Fhi(Hz) MDVP:Flo(Hz) MDVP:Jitter(%) \\\n", + "0 phon_R01_S01_1 119.992 157.302 74.997 0.00784 \n", + "1 phon_R01_S01_2 122.400 148.650 113.819 0.00968 \n", + "2 phon_R01_S01_3 116.682 131.111 111.555 0.01050 \n", + "3 phon_R01_S01_4 116.676 137.871 111.366 0.00997 \n", + "4 phon_R01_S01_5 116.014 141.781 110.655 0.01284 \n", + "\n", + " MDVP:Jitter(Abs) MDVP:RAP MDVP:PPQ Jitter:DDP MDVP:Shimmer ... \\\n", + "0 0.00007 0.00370 0.00554 0.01109 0.04374 ... \n", + "1 0.00008 0.00465 0.00696 0.01394 0.06134 ... \n", + "2 0.00009 0.00544 0.00781 0.01633 0.05233 ... \n", + "3 0.00009 0.00502 0.00698 0.01505 0.05492 ... \n", + "4 0.00011 0.00655 0.00908 0.01966 0.06425 ... \n", + "\n", + " Shimmer:DDA NHR HNR status RPDE DFA spread1 \\\n", + "0 0.06545 0.02211 21.033 1 0.414783 0.815285 -4.813031 \n", + "1 0.09403 0.01929 19.085 1 0.458359 0.819521 -4.075192 \n", + "2 0.08270 0.01309 20.651 1 0.429895 0.825288 -4.443179 \n", + "3 0.08771 0.01353 20.644 1 0.434969 0.819235 -4.117501 \n", + "4 0.10470 0.01767 19.649 1 0.417356 0.823484 -3.747787 \n", + "\n", + " spread2 D2 PPE \n", + "0 0.266482 2.301442 0.284654 \n", + "1 0.335590 2.486855 0.368674 \n", + "2 0.311173 2.342259 0.332634 \n", + "3 0.334147 2.405554 0.368975 \n", + "4 0.234513 2.332180 0.410335 \n", + "\n", + "[5 rows x 24 columns]" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#printing first 5 rows of our dataset\n", + "parkinsons_data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(195, 24)" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#number of rows and columns in our dataframe\n", + "parkinsons_data.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 195 entries, 0 to 194\n", + "Data columns (total 24 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 name 195 non-null object \n", + " 1 MDVP:Fo(Hz) 195 non-null float64\n", + " 2 MDVP:Fhi(Hz) 195 non-null float64\n", + " 3 MDVP:Flo(Hz) 195 non-null float64\n", + " 4 MDVP:Jitter(%) 195 non-null float64\n", + " 5 MDVP:Jitter(Abs) 195 non-null float64\n", + " 6 MDVP:RAP 195 non-null float64\n", + " 7 MDVP:PPQ 195 non-null float64\n", + " 8 Jitter:DDP 195 non-null float64\n", + " 9 MDVP:Shimmer 195 non-null float64\n", + " 10 MDVP:Shimmer(dB) 195 non-null float64\n", + " 11 Shimmer:APQ3 195 non-null float64\n", + " 12 Shimmer:APQ5 195 non-null float64\n", + " 13 MDVP:APQ 195 non-null float64\n", + " 14 Shimmer:DDA 195 non-null float64\n", + " 15 NHR 195 non-null float64\n", + " 16 HNR 195 non-null float64\n", + " 17 status 195 non-null int64 \n", + " 18 RPDE 195 non-null float64\n", + " 19 DFA 195 non-null float64\n", + " 20 spread1 195 non-null float64\n", + " 21 spread2 195 non-null float64\n", + " 22 D2 195 non-null float64\n", + " 23 PPE 195 non-null float64\n", + "dtypes: float64(22), int64(1), object(1)\n", + "memory usage: 36.7+ KB\n" + ] + } + ], + "source": [ + "# getting more informatiton about the dataset\n", + "parkinsons_data.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "name 0\n", + "MDVP:Fo(Hz) 0\n", + "MDVP:Fhi(Hz) 0\n", + "MDVP:Flo(Hz) 0\n", + "MDVP:Jitter(%) 0\n", + "MDVP:Jitter(Abs) 0\n", + "MDVP:RAP 0\n", + "MDVP:PPQ 0\n", + "Jitter:DDP 0\n", + "MDVP:Shimmer 0\n", + "MDVP:Shimmer(dB) 0\n", + "Shimmer:APQ3 0\n", + "Shimmer:APQ5 0\n", + "MDVP:APQ 0\n", + "Shimmer:DDA 0\n", + "NHR 0\n", + "HNR 0\n", + "status 0\n", + "RPDE 0\n", + "DFA 0\n", + "spread1 0\n", + "spread2 0\n", + "D2 0\n", + "PPE 0\n", + "dtype: int64" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# checking for missing values in each columns\n", + "parkinsons_data.isnull().sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### After this step it is very clear that our dataset didn't contain any missing values that means it is already processed" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
MDVP:Fo(Hz)MDVP:Fhi(Hz)MDVP:Flo(Hz)MDVP:Jitter(%)MDVP:Jitter(Abs)MDVP:RAPMDVP:PPQJitter:DDPMDVP:ShimmerMDVP:Shimmer(dB)...Shimmer:DDANHRHNRstatusRPDEDFAspread1spread2D2PPE
count195.000000195.000000195.000000195.000000195.000000195.000000195.000000195.000000195.000000195.000000...195.000000195.000000195.000000195.000000195.000000195.000000195.000000195.000000195.000000195.000000
mean154.228641197.104918116.3246310.0062200.0000440.0033060.0034460.0099200.0297090.282251...0.0469930.02484721.8859740.7538460.4985360.718099-5.6843970.2265102.3818260.206552
std41.39006591.49154843.5214130.0048480.0000350.0029680.0027590.0089030.0188570.194877...0.0304590.0404184.4257640.4318780.1039420.0553361.0902080.0834060.3827990.090119
min88.333000102.14500065.4760000.0016800.0000070.0006800.0009200.0020400.0095400.085000...0.0136400.0006508.4410000.0000000.2565700.574282-7.9649840.0062741.4232870.044539
25%117.572000134.86250084.2910000.0034600.0000200.0016600.0018600.0049850.0165050.148500...0.0247350.00592519.1980001.0000000.4213060.674758-6.4500960.1743512.0991250.137451
50%148.790000175.829000104.3150000.0049400.0000300.0025000.0026900.0074900.0229700.221000...0.0383600.01166022.0850001.0000000.4959540.722254-5.7208680.2188852.3615320.194052
75%182.769000224.205500140.0185000.0073650.0000600.0038350.0039550.0115050.0378850.350000...0.0607950.02564025.0755001.0000000.5875620.761881-5.0461920.2792342.6364560.252980
max260.105000592.030000239.1700000.0331600.0002600.0214400.0195800.0643300.1190801.302000...0.1694200.31482033.0470001.0000000.6851510.825288-2.4340310.4504933.6711550.527367
\n", + "

8 rows × 23 columns

\n", + "
" + ], + "text/plain": [ + " MDVP:Fo(Hz) MDVP:Fhi(Hz) MDVP:Flo(Hz) MDVP:Jitter(%) \\\n", + "count 195.000000 195.000000 195.000000 195.000000 \n", + "mean 154.228641 197.104918 116.324631 0.006220 \n", + "std 41.390065 91.491548 43.521413 0.004848 \n", + "min 88.333000 102.145000 65.476000 0.001680 \n", + "25% 117.572000 134.862500 84.291000 0.003460 \n", + "50% 148.790000 175.829000 104.315000 0.004940 \n", + "75% 182.769000 224.205500 140.018500 0.007365 \n", + "max 260.105000 592.030000 239.170000 0.033160 \n", + "\n", + " MDVP:Jitter(Abs) MDVP:RAP MDVP:PPQ Jitter:DDP MDVP:Shimmer \\\n", + "count 195.000000 195.000000 195.000000 195.000000 195.000000 \n", + "mean 0.000044 0.003306 0.003446 0.009920 0.029709 \n", + "std 0.000035 0.002968 0.002759 0.008903 0.018857 \n", + "min 0.000007 0.000680 0.000920 0.002040 0.009540 \n", + "25% 0.000020 0.001660 0.001860 0.004985 0.016505 \n", + "50% 0.000030 0.002500 0.002690 0.007490 0.022970 \n", + "75% 0.000060 0.003835 0.003955 0.011505 0.037885 \n", + "max 0.000260 0.021440 0.019580 0.064330 0.119080 \n", + "\n", + " MDVP:Shimmer(dB) ... Shimmer:DDA NHR HNR status \\\n", + "count 195.000000 ... 195.000000 195.000000 195.000000 195.000000 \n", + "mean 0.282251 ... 0.046993 0.024847 21.885974 0.753846 \n", + "std 0.194877 ... 0.030459 0.040418 4.425764 0.431878 \n", + "min 0.085000 ... 0.013640 0.000650 8.441000 0.000000 \n", + "25% 0.148500 ... 0.024735 0.005925 19.198000 1.000000 \n", + "50% 0.221000 ... 0.038360 0.011660 22.085000 1.000000 \n", + "75% 0.350000 ... 0.060795 0.025640 25.075500 1.000000 \n", + "max 1.302000 ... 0.169420 0.314820 33.047000 1.000000 \n", + "\n", + " RPDE DFA spread1 spread2 D2 PPE \n", + "count 195.000000 195.000000 195.000000 195.000000 195.000000 195.000000 \n", + "mean 0.498536 0.718099 -5.684397 0.226510 2.381826 0.206552 \n", + "std 0.103942 0.055336 1.090208 0.083406 0.382799 0.090119 \n", + "min 0.256570 0.574282 -7.964984 0.006274 1.423287 0.044539 \n", + "25% 0.421306 0.674758 -6.450096 0.174351 2.099125 0.137451 \n", + "50% 0.495954 0.722254 -5.720868 0.218885 2.361532 0.194052 \n", + "75% 0.587562 0.761881 -5.046192 0.279234 2.636456 0.252980 \n", + "max 0.685151 0.825288 -2.434031 0.450493 3.671155 0.527367 \n", + "\n", + "[8 rows x 23 columns]" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Getting some statistical measures about the data\n", + "parkinsons_data.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1 147\n", + "0 48\n", + "Name: status, dtype: int64" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Distribution of Target i.e status of a person\n", + "parkinsons_data['status'].value_counts()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Status=1 -> Parkinson's Positive\n", + "#### Status=0 -> Healthy" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
MDVP:Fo(Hz)MDVP:Fhi(Hz)MDVP:Flo(Hz)MDVP:Jitter(%)MDVP:Jitter(Abs)MDVP:RAPMDVP:PPQJitter:DDPMDVP:ShimmerMDVP:Shimmer(dB)...MDVP:APQShimmer:DDANHRHNRRPDEDFAspread1spread2D2PPE
status
0181.937771223.636750145.2072920.0038660.0000230.0019250.0020560.0057760.0176150.162958...0.0133050.0285110.01148324.6787500.4425520.695716-6.7592640.1602922.1544910.123017
1145.180762188.441463106.8935580.0069890.0000510.0037570.0039000.0112730.0336580.321204...0.0276000.0530270.02921120.9740480.5168160.725408-5.3334200.2481332.4560580.233828
\n", + "

2 rows × 22 columns

\n", + "
" + ], + "text/plain": [ + " MDVP:Fo(Hz) MDVP:Fhi(Hz) MDVP:Flo(Hz) MDVP:Jitter(%) \\\n", + "status \n", + "0 181.937771 223.636750 145.207292 0.003866 \n", + "1 145.180762 188.441463 106.893558 0.006989 \n", + "\n", + " MDVP:Jitter(Abs) MDVP:RAP MDVP:PPQ Jitter:DDP MDVP:Shimmer \\\n", + "status \n", + "0 0.000023 0.001925 0.002056 0.005776 0.017615 \n", + "1 0.000051 0.003757 0.003900 0.011273 0.033658 \n", + "\n", + " MDVP:Shimmer(dB) ... MDVP:APQ Shimmer:DDA NHR HNR \\\n", + "status ... \n", + "0 0.162958 ... 0.013305 0.028511 0.011483 24.678750 \n", + "1 0.321204 ... 0.027600 0.053027 0.029211 20.974048 \n", + "\n", + " RPDE DFA spread1 spread2 D2 PPE \n", + "status \n", + "0 0.442552 0.695716 -6.759264 0.160292 2.154491 0.123017 \n", + "1 0.516816 0.725408 -5.333420 0.248133 2.456058 0.233828 \n", + "\n", + "[2 rows x 22 columns]" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Grouping the data based on the target variable\n", + "parkinsons_data.groupby('status').mean()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### By naive eyes we can easily see that for ex- if MDVP:Fo(Hz) value is above 180 that means person is very less likely to be Parkinson positive and if this value is below 150 than person is more likely to be Parkinson positive. Further we will try to make it show using our SVM model " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exploratory data analysis\n", + " We will use heatmap for our purpose.\n", + " To represent more common values or higher activitiesBrighter colors basically reddish colors are used and to represent \n", + " less common or activity values, darker colors are preferred. " + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df= parkinsons_data\n", + "sns.heatmap(data=df.drop(columns=['name', 'status']))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Data Pre-Processing" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "#Seperating the features and target\n", + "X = parkinsons_data.drop(columns=['name', 'status'], axis=1) #axis=1 because we are dropping column, for dropping row axis=0\n", + "Y = parkinsons_data['status']" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " MDVP:Fo(Hz) MDVP:Fhi(Hz) MDVP:Flo(Hz) MDVP:Jitter(%) \\\n", + "0 119.992 157.302 74.997 0.00784 \n", + "1 122.400 148.650 113.819 0.00968 \n", + "2 116.682 131.111 111.555 0.01050 \n", + "3 116.676 137.871 111.366 0.00997 \n", + "4 116.014 141.781 110.655 0.01284 \n", + ".. ... ... ... ... \n", + "190 174.188 230.978 94.261 0.00459 \n", + "191 209.516 253.017 89.488 0.00564 \n", + "192 174.688 240.005 74.287 0.01360 \n", + "193 198.764 396.961 74.904 0.00740 \n", + "194 214.289 260.277 77.973 0.00567 \n", + "\n", + " MDVP:Jitter(Abs) MDVP:RAP MDVP:PPQ Jitter:DDP MDVP:Shimmer \\\n", + "0 0.00007 0.00370 0.00554 0.01109 0.04374 \n", + "1 0.00008 0.00465 0.00696 0.01394 0.06134 \n", + "2 0.00009 0.00544 0.00781 0.01633 0.05233 \n", + "3 0.00009 0.00502 0.00698 0.01505 0.05492 \n", + "4 0.00011 0.00655 0.00908 0.01966 0.06425 \n", + ".. ... ... ... ... ... \n", + "190 0.00003 0.00263 0.00259 0.00790 0.04087 \n", + "191 0.00003 0.00331 0.00292 0.00994 0.02751 \n", + "192 0.00008 0.00624 0.00564 0.01873 0.02308 \n", + "193 0.00004 0.00370 0.00390 0.01109 0.02296 \n", + "194 0.00003 0.00295 0.00317 0.00885 0.01884 \n", + "\n", + " MDVP:Shimmer(dB) ... MDVP:APQ Shimmer:DDA NHR HNR RPDE \\\n", + "0 0.426 ... 0.02971 0.06545 0.02211 21.033 0.414783 \n", + "1 0.626 ... 0.04368 0.09403 0.01929 19.085 0.458359 \n", + "2 0.482 ... 0.03590 0.08270 0.01309 20.651 0.429895 \n", + "3 0.517 ... 0.03772 0.08771 0.01353 20.644 0.434969 \n", + "4 0.584 ... 0.04465 0.10470 0.01767 19.649 0.417356 \n", + ".. ... ... ... ... ... ... ... \n", + "190 0.405 ... 0.02745 0.07008 0.02764 19.517 0.448439 \n", + "191 0.263 ... 0.01879 0.04812 0.01810 19.147 0.431674 \n", + "192 0.256 ... 0.01667 0.03804 0.10715 17.883 0.407567 \n", + "193 0.241 ... 0.01588 0.03794 0.07223 19.020 0.451221 \n", + "194 0.190 ... 0.01373 0.03078 0.04398 21.209 0.462803 \n", + "\n", + " DFA spread1 spread2 D2 PPE \n", + "0 0.815285 -4.813031 0.266482 2.301442 0.284654 \n", + "1 0.819521 -4.075192 0.335590 2.486855 0.368674 \n", + "2 0.825288 -4.443179 0.311173 2.342259 0.332634 \n", + "3 0.819235 -4.117501 0.334147 2.405554 0.368975 \n", + "4 0.823484 -3.747787 0.234513 2.332180 0.410335 \n", + ".. ... ... ... ... ... \n", + "190 0.657899 -6.538586 0.121952 2.657476 0.133050 \n", + "191 0.683244 -6.195325 0.129303 2.784312 0.168895 \n", + "192 0.655683 -6.787197 0.158453 2.679772 0.131728 \n", + "193 0.643956 -6.744577 0.207454 2.138608 0.123306 \n", + "194 0.664357 -5.724056 0.190667 2.555477 0.148569 \n", + "\n", + "[195 rows x 22 columns]\n" + ] + } + ], + "source": [ + "print(X)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 1\n", + "1 1\n", + "2 1\n", + "3 1\n", + "4 1\n", + " ..\n", + "190 0\n", + "191 0\n", + "192 0\n", + "193 0\n", + "194 0\n", + "Name: status, Length: 195, dtype: int64\n" + ] + } + ], + "source": [ + "print(Y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Splitting the data to Training data and Test data" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "# Taking 20% of data as test data and rest 80% as training data\n", + "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(195, 22) (156, 22) (39, 22)\n" + ] + } + ], + "source": [ + "print(X.shape, X_train.shape, X_test.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Data Standardization\n", + " It is always advisable to bring all features to same scale for applying distance based algorithms " + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "scaler= StandardScaler()" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StandardScaler()" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scaler.fit(X_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "#tranform function to convert our data on new same scale\n", + "X_train = scaler.transform(X_train)\n", + "X_test = scaler.transform(X_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0.63239631 -0.02731081 -0.87985049 ... -0.97586547 -0.55160318\n", + " 0.07769494]\n", + " [-1.05512719 -0.83337041 -0.9284778 ... 0.3981808 -0.61014073\n", + " 0.39291782]\n", + " [ 0.02996187 -0.29531068 -1.12211107 ... -0.43937044 -0.62849605\n", + " -0.50948408]\n", + " ...\n", + " [-0.9096785 -0.6637302 -0.160638 ... 1.22001022 -0.47404629\n", + " -0.2159482 ]\n", + " [-0.35977689 0.19731822 -0.79063679 ... -0.17896029 -0.47272835\n", + " 0.28181221]\n", + " [ 1.01957066 0.19922317 -0.61914972 ... -0.716232 1.23632066\n", + " -0.05829386]]\n" + ] + } + ], + "source": [ + "print(X_train)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Model Training" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Support Vector Machine Model\n", + " SVM models can be used for both classification and regression problems, but in our case we are using it for\n", + " classification of whether a person is PD positive or negative" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "model = svm.SVC()" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "SVC()" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Training the SVM model with training data\n", + "model.fit(X_train, Y_train)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Model Evaluation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Accuracy Score" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "# Accuracy score of training data\n", + "X_train_prediction = model.predict(X_train)\n", + "training_data_accuracy = accuracy_score(Y_train, X_train_prediction)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy Score of Training Data : 0.9166666666666666\n" + ] + } + ], + "source": [ + "print('Accuracy Score of Training Data : ', training_data_accuracy)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "# Accuracy score of testing data\n", + "X_test_prediction = model.predict(X_test)\n", + "test_data_accuracy = accuracy_score(Y_test, X_test_prediction)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy Score of Test Data : 0.8974358974358975\n" + ] + } + ], + "source": [ + "print('Accuracy Score of Test Data : ', test_data_accuracy)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Note:\n", + " Since the accuracy score of both testing and training data are approximately similar that means our model is working fine and not overfitted" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Confusion Matrix : \n", + "\n", + "[[ 4 4]\n", + " [ 0 31]]\n", + "\n", + "Classification Report : \n", + "\n", + " precision recall f1-score support\n", + "\n", + " 0 1.00 0.50 0.67 8\n", + " 1 0.89 1.00 0.94 31\n", + "\n", + " accuracy 0.90 39\n", + " macro avg 0.94 0.75 0.80 39\n", + "weighted avg 0.91 0.90 0.88 39\n", + "\n" + ] + } + ], + "source": [ + "#Printing the results using Classification_report and Confusion_matrix for more clearity\n", + "print(\"Confusion Matrix : \")\n", + "print()\n", + "print(confusion_matrix(Y_test, X_test_prediction))\n", + "print()\n", + "print(\"Classification Report : \")\n", + "print()\n", + "print(classification_report(Y_test, X_test_prediction))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Printing Results using Grid Search CV- (Optional)\n", + " It is used to select most appropiate hyperparameter for our SVC() model, ehich could give most better results with \n", + " highest accuracy.\n", + " Finding right parameters (like what C or gamma values to use) is a difficult task (if hit and trial one by one).\n", + " Therfore we use the idea of creating a grid of parameters and this idea of just trying all possible combinations is \n", + " called Grid Search\n" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 5 folds for each of 16 candidates, totalling 80 fits\n", + "[CV] C=0.1, gamma=1 ..................................................\n", + "[CV] ................................... C=0.1, gamma=1, total= 0.0s\n", + "[CV] C=0.1, gamma=1 ..................................................\n", + "[CV] ................................... C=0.1, gamma=1, total= 0.0s\n", + "[CV] C=0.1, gamma=1 ..................................................\n", + "[CV] ................................... C=0.1, gamma=1, total= 0.0s\n", + "[CV] C=0.1, gamma=1 ..................................................\n", + "[CV] ................................... C=0.1, gamma=1, total= 0.0s\n", + "[CV] C=0.1, gamma=1 ..................................................\n", + "[CV] ................................... C=0.1, gamma=1, total= 0.0s\n", + "[CV] C=0.1, gamma=0.1 ................................................\n", + "[CV] ................................. C=0.1, gamma=0.1, total= 0.0s\n", + "[CV] C=0.1, gamma=0.1 ................................................\n", + "[CV] ................................. C=0.1, gamma=0.1, total= 0.0s\n", + "[CV] C=0.1, gamma=0.1 ................................................\n", + "[CV] ................................. C=0.1, gamma=0.1, total= 0.0s\n", + "[CV] C=0.1, gamma=0.1 ................................................\n", + "[CV] ................................. C=0.1, gamma=0.1, total= 0.0s\n", + "[CV] C=0.1, gamma=0.1 ................................................\n", + "[CV] ................................. C=0.1, gamma=0.1, total= 0.0s\n", + "[CV] C=0.1, gamma=0.01 ...............................................\n", + "[CV] ................................ C=0.1, gamma=0.01, total= 0.0s\n", + "[CV] C=0.1, gamma=0.01 ...............................................\n", + "[CV] ................................ C=0.1, gamma=0.01, total= 0.0s\n", + "[CV] C=0.1, gamma=0.01 ...............................................\n", + "[CV] ................................ C=0.1, gamma=0.01, total= 0.0s\n", + "[CV] C=0.1, gamma=0.01 ...............................................\n", + "[CV] ................................ C=0.1, gamma=0.01, total= 0.0s\n", + "[CV] C=0.1, gamma=0.01 ...............................................\n", + "[CV] ................................ C=0.1, gamma=0.01, total= 0.0s\n", + "[CV] C=0.1, gamma=0.001 ..............................................\n", + "[CV] ............................... C=0.1, gamma=0.001, total= 0.0s\n", + "[CV] C=0.1, gamma=0.001 ..............................................\n", + "[CV] ............................... C=0.1, gamma=0.001, total= 0.0s\n", + "[CV] C=0.1, gamma=0.001 ..............................................\n", + "[CV] ............................... C=0.1, gamma=0.001, total= 0.0s\n", + "[CV] C=0.1, gamma=0.001 ..............................................\n", + "[CV] ............................... C=0.1, gamma=0.001, total= 0.0s\n", + "[CV] C=0.1, gamma=0.001 ..............................................\n", + "[CV] ............................... C=0.1, gamma=0.001, total= 0.0s\n", + "[CV] C=1, gamma=1 ....................................................\n", + "[CV] ..................................... C=1, gamma=1, total= 0.0s\n", + "[CV] C=1, gamma=1 ....................................................\n", + "[CV] ..................................... C=1, gamma=1, total= 0.0s\n", + "[CV] C=1, gamma=1 ....................................................\n", + "[CV] ..................................... C=1, gamma=1, total= 0.0s\n", + "[CV] C=1, gamma=1 ....................................................\n", + "[CV] ..................................... C=1, gamma=1, total= 0.0s\n", + "[CV] C=1, gamma=1 ....................................................\n", + "[CV] ..................................... C=1, gamma=1, total= 0.0s\n", + "[CV] C=1, gamma=0.1 ..................................................\n", + "[CV] ................................... C=1, gamma=0.1, total= 0.0s\n", + "[CV] C=1, gamma=0.1 ..................................................\n", + "[CV] ................................... C=1, gamma=0.1, total= 0.0s\n", + "[CV] C=1, gamma=0.1 ..................................................\n", + "[CV] ................................... C=1, gamma=0.1, total= 0.0s\n", + "[CV] C=1, gamma=0.1 ..................................................\n", + "[CV] ................................... C=1, gamma=0.1, total= 0.0s\n", + "[CV] C=1, gamma=0.1 ..................................................\n", + "[CV] ................................... C=1, gamma=0.1, total= 0.0s\n", + "[CV] C=1, gamma=0.01 .................................................\n", + "[CV] .................................. C=1, gamma=0.01, total= 0.0s\n", + "[CV] C=1, gamma=0.01 .................................................\n", + "[CV] .................................. C=1, gamma=0.01, total= 0.0s\n", + "[CV] C=1, gamma=0.01 .................................................\n", + "[CV] .................................. C=1, gamma=0.01, total= 0.0s\n", + "[CV] C=1, gamma=0.01 .................................................\n", + "[CV] .................................. C=1, gamma=0.01, total= 0.0s\n", + "[CV] C=1, gamma=0.01 .................................................\n", + "[CV] .................................. C=1, gamma=0.01, total= 0.0s\n", + "[CV] C=1, gamma=0.001 ................................................\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n", + "[Parallel(n_jobs=1)]: Done 1 out of 1 | elapsed: 0.0s remaining: 0.0s\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[CV] ................................. C=1, gamma=0.001, total= 0.0s\n", + "[CV] C=1, gamma=0.001 ................................................\n", + "[CV] ................................. C=1, gamma=0.001, total= 0.0s\n", + "[CV] C=1, gamma=0.001 ................................................\n", + "[CV] ................................. C=1, gamma=0.001, total= 0.0s\n", + "[CV] C=1, gamma=0.001 ................................................\n", + "[CV] ................................. C=1, gamma=0.001, total= 0.0s\n", + "[CV] C=1, gamma=0.001 ................................................\n", + "[CV] ................................. C=1, gamma=0.001, total= 0.0s\n", + "[CV] C=10, gamma=1 ...................................................\n", + "[CV] .................................... C=10, gamma=1, total= 0.0s\n", + "[CV] C=10, gamma=1 ...................................................\n", + "[CV] .................................... C=10, gamma=1, total= 0.0s\n", + "[CV] C=10, gamma=1 ...................................................\n", + "[CV] .................................... C=10, gamma=1, total= 0.0s\n", + "[CV] C=10, gamma=1 ...................................................\n", + "[CV] .................................... C=10, gamma=1, total= 0.0s\n", + "[CV] C=10, gamma=1 ...................................................\n", + "[CV] .................................... C=10, gamma=1, total= 0.0s\n", + "[CV] C=10, gamma=0.1 .................................................\n", + "[CV] .................................. C=10, gamma=0.1, total= 0.0s\n", + "[CV] C=10, gamma=0.1 .................................................\n", + "[CV] .................................. C=10, gamma=0.1, total= 0.0s\n", + "[CV] C=10, gamma=0.1 .................................................\n", + "[CV] .................................. C=10, gamma=0.1, total= 0.0s\n", + "[CV] C=10, gamma=0.1 .................................................\n", + "[CV] .................................. C=10, gamma=0.1, total= 0.0s\n", + "[CV] C=10, gamma=0.1 .................................................\n", + "[CV] .................................. C=10, gamma=0.1, total= 0.0s\n", + "[CV] C=10, gamma=0.01 ................................................\n", + "[CV] ................................. C=10, gamma=0.01, total= 0.0s\n", + "[CV] C=10, gamma=0.01 ................................................\n", + "[CV] ................................. C=10, gamma=0.01, total= 0.0s\n", + "[CV] C=10, gamma=0.01 ................................................\n", + "[CV] ................................. C=10, gamma=0.01, total= 0.0s\n", + "[CV] C=10, gamma=0.01 ................................................\n", + "[CV] ................................. C=10, gamma=0.01, total= 0.0s\n", + "[CV] C=10, gamma=0.01 ................................................\n", + "[CV] ................................. C=10, gamma=0.01, total= 0.0s\n", + "[CV] C=10, gamma=0.001 ...............................................\n", + "[CV] ................................ C=10, gamma=0.001, total= 0.0s\n", + "[CV] C=10, gamma=0.001 ...............................................\n", + "[CV] ................................ C=10, gamma=0.001, total= 0.0s\n", + "[CV] C=10, gamma=0.001 ...............................................\n", + "[CV] ................................ C=10, gamma=0.001, total= 0.0s\n", + "[CV] C=10, gamma=0.001 ...............................................\n", + "[CV] ................................ C=10, gamma=0.001, total= 0.0s\n", + "[CV] C=10, gamma=0.001 ...............................................\n", + "[CV] ................................ C=10, gamma=0.001, total= 0.0s\n", + "[CV] C=100, gamma=1 ..................................................\n", + "[CV] ................................... C=100, gamma=1, total= 0.0s\n", + "[CV] C=100, gamma=1 ..................................................\n", + "[CV] ................................... C=100, gamma=1, total= 0.0s\n", + "[CV] C=100, gamma=1 ..................................................\n", + "[CV] ................................... C=100, gamma=1, total= 0.0s\n", + "[CV] C=100, gamma=1 ..................................................\n", + "[CV] ................................... C=100, gamma=1, total= 0.0s\n", + "[CV] C=100, gamma=1 ..................................................\n", + "[CV] ................................... C=100, gamma=1, total= 0.0s\n", + "[CV] C=100, gamma=0.1 ................................................\n", + "[CV] ................................. C=100, gamma=0.1, total= 0.0s\n", + "[CV] C=100, gamma=0.1 ................................................\n", + "[CV] ................................. C=100, gamma=0.1, total= 0.0s\n", + "[CV] C=100, gamma=0.1 ................................................\n", + "[CV] ................................. C=100, gamma=0.1, total= 0.0s\n", + "[CV] C=100, gamma=0.1 ................................................\n", + "[CV] ................................. C=100, gamma=0.1, total= 0.0s\n", + "[CV] C=100, gamma=0.1 ................................................\n", + "[CV] ................................. C=100, gamma=0.1, total= 0.0s\n", + "[CV] C=100, gamma=0.01 ...............................................\n", + "[CV] ................................ C=100, gamma=0.01, total= 0.0s\n", + "[CV] C=100, gamma=0.01 ...............................................\n", + "[CV] ................................ C=100, gamma=0.01, total= 0.0s\n", + "[CV] C=100, gamma=0.01 ...............................................\n", + "[CV] ................................ C=100, gamma=0.01, total= 0.0s\n", + "[CV] C=100, gamma=0.01 ...............................................\n", + "[CV] ................................ C=100, gamma=0.01, total= 0.0s\n", + "[CV] C=100, gamma=0.01 ...............................................\n", + "[CV] ................................ C=100, gamma=0.01, total= 0.0s\n", + "[CV] C=100, gamma=0.001 ..............................................\n", + "[CV] ............................... C=100, gamma=0.001, total= 0.0s\n", + "[CV] C=100, gamma=0.001 ..............................................\n", + "[CV] ............................... C=100, gamma=0.001, total= 0.0s\n", + "[CV] C=100, gamma=0.001 ..............................................\n", + "[CV] ............................... C=100, gamma=0.001, total= 0.0s\n", + "[CV] C=100, gamma=0.001 ..............................................\n", + "[CV] ............................... C=100, gamma=0.001, total= 0.0s\n", + "[CV] C=100, gamma=0.001 ..............................................\n", + "[CV] ............................... C=100, gamma=0.001, total= 0.0s\n", + "[[ 8 0]\n", + " [ 3 28]]\n", + " precision recall f1-score support\n", + "\n", + " 0 0.73 1.00 0.84 8\n", + " 1 1.00 0.90 0.95 31\n", + "\n", + " accuracy 0.92 39\n", + " macro avg 0.86 0.95 0.90 39\n", + "weighted avg 0.94 0.92 0.93 39\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=1)]: Done 80 out of 80 | elapsed: 0.3s finished\n" + ] + } + ], + "source": [ + "param_grid={\"C\": [0.1,1,10,100], \"gamma\": [1, 0.1, 0.01, 0.001]}\n", + "grid = GridSearchCV(svm.SVC(), param_grid, verbose=2)\n", + "grid.fit(X_train, Y_train)\n", + "grid.best_params_\n", + "grid.best_estimator_\n", + "grid_predictions = grid.predict(X_test)\n", + "print(confusion_matrix(Y_test, grid_predictions))\n", + "print(classification_report(Y_test, grid_predictions))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Building a Predictive System" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1]\n", + "The Person is suffering from Parkinsons Disease\n" + ] + } + ], + "source": [ + "#Defining a tuple input_data to check and determine whether a person is Parkinson positive or negative according to our model\n", + "\n", + "#Input_data does not contains the status value from dataset, because we need to determine it using our model\n", + "input_data = (95.05600,120.10300,91.22600,0.00532,0.00006,0.00268,0.00332,0.00803,0.02838,0.25500,0.01441,0.01725,0.02444,0.04324,0.01022,21.86200,0.547037,0.798463,-5.011879,0.325996,2.432792,0.271362)\n", + "#input_data =(237.22600,247.32600,225.22700,0.00298,0.00001,0.00169,0.00182,0.00507,0.01752,0.16400,0.01035,0.01024,0.01133,0.03104,0.00740,22.73600,0.305062,0.654172,-7.310550,0.098648,2.416838,0.095032)\n", + "#(Here in first case the person is suffering from Parkinson as per our dataset and for 2nd case it is not PD positive, Similarly we can check for other input data too. Our model is also predicting same thing that means it is working fine)\n", + "\n", + "#Changing input data into numpy array for further processing using np.asarray() function\n", + "input_data_as_numpy_array = np.asarray(input_data)\n", + "\n", + "#Reshape the numpy array to tell our model that we are just predicting for one data point\n", + "input_data_reshaped = input_data_as_numpy_array.reshape(1,-1)\n", + "\n", + "#Standardize the data\n", + "std_data = scaler.transform(input_data_reshaped)\n", + "\n", + "prediction = model.predict(std_data)\n", + "print(prediction)\n", + "\n", + "if (prediction[0]==0):\n", + " print(\"The Person does not have Parkinsons Disease\")\n", + "else:\n", + " print(\"The Person is suffering from Parkinsons Disease\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# *******THANK YOU*******" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}