top of page

# PARKINSON DISEASE PREDICTION

Neurodegenerative disease

When nerve cells in the brain or peripheral nervous system begin to lose their functionality over time and eventually die, this is known as a neurodegenerative illness.

Although some neurodegenerative disease symptoms can be alleviated with particular medications, there is presently no cure and just a slowing of the disease's progression.

Alzheimer’s disease and Parkinson’s disease are the most common neurodegenerative diseases.

Scientists are aware that a person's chance of getting a neurodegenerative disease is influenced by both their genes and environment.

For instance, even if a person has a genotype that predisposes them to Parkinson's disease, their exposure to the environment can still influence whether, when, and how severely they are impacted.

The dataset for this model was obtained from UCI ML Parkinson's dataset.

The dataset is composed of a range of biomedical voice measurements.

195 observations were made and each feature is a particular voice measure.

The aim of the data is to discriminate healthy people from those with Parkinson's disease.

Modules used

```import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn import svm
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix ```

Preprocessing

```

`parkinson_data.describe()`

As seen above, 50% of respondents have an average vocal fundamental frequency greater than 148.79.

these and other statistical information helps in other analysis and also building a predictive model

`parkinson_data.info()`

This dataset does not have any missing values, which is a good thing.

we notice also that, the features are of float data type which is friendly for algorithms to learn.

To further gain insight from this data, we can ask some questions.

1. How different is a PD patient's voice from that of a healthy person?

2. How do the HNR and NHR of a respondent with Parkinson's disease relate to one another?

3. Does an increase in Signal fractal scaling exponent affect average vocal fundamental frequency?

we need to separate the dataset in terms of the status column

```PD_patient = parkinson_data[parkinson_data['status'] == 1]
healthy_patient = parkinson_data[parkinson_data['status'] == 0]```
`PD_patient.describe()`

`healthy_patient.describe()`

from the above images, there's a wide difference between the average vocal fundamental frequency of a Parkinson's patient as compared to a healthy. This indicates the difference in the quality of voices.

The first sign of Parkinson's disease is a change in the quality of voice, a reduced volume, a monotone pitch, etc.

Question 2;

How do the HNR and NHR of a respondent with Parkinson's disease relate to one another?

HNR and NHR are the ratios of noise to tonal components in the voice of a patient

we will visualize these two features and find out about the correlation between them.

```sns.scatterplot(x=PD_patient['NHR'], y=PD_patient['HNR'])
plt.show()```

from the above graph, NHR (noise/harmonic ratio) and HNR (harmonic/noise ratio) measures are inversely proportional values.

They assess the presence of noise in a voice signal;

and they are directly related to voice quality.

A lower NHR and a higher HNR indicate superior voice quality.

```PD_patient['NHR'].corr(PD_patient['HNR'])
# -0.7279896930040246```

Question 3;

Does an increase in Signal fractal scaling exponent affect average vocal fundamental frequency?

Another way we can frame this question is;

Is there a relationship between the signal fractal scaling exponent and average vocal fundamental frequency?

```sns.scatterplot(x=parkinson_data['DFA'], y=parkinson_data['MDVP:Fo(Hz)'])
plt.show() ```

```parkinson_data['DFA'].corr(parkinson_data['MDVP:Fo(Hz)'])
# -0.4460132918988155```

The plot above shows there's a strong negative relationship between the two variables with a correlations coefficient of -0.44

These are the analysis that was performed on the dataset.

Preparing the data for model training

When we printed the first five rows of the dataset previously, we saw that there was a name column in the dataset.

This name column is unique for each observation hence it's not relevant for model training.

we will drop this column, and make our feature matrix along with our target column

```X = parkinson_data.drop(columns=['name', 'status'])
y = parkinson_data['status']```

we also need to split our data into train and test sets.

`X_train, X_test, y_train , y_test = train_test_split(X, y, test_size=0.2, random_state=133, stratify = y)`

the random state is for reproducibility and the argument stratify is to ensure that we have the same proportions of class labels as the input dataset.

Also, the dataset has to be scaled.

```scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test) ```

We only need to fit and transform the train dataset whiles the test set need to be transformed only.

Model training and evaluation

A support vector machine algorithm is used in this predictive model.

```model = svm.SVC(kernel='poly', C= 8)
model.fit(X_train, y_train)

# train accuracy
y_train_pred = model.predict(X_train)
accuracy = accuracy_score(y_train, y_train_pred)
print(f"Train accuracy: {accuracy}")

#test accuracy
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Test accuracy: {accuracy}")

#output
Train accuracy: 0.8974358974358975
Test accuracy: 0.8717948717948718```

we instantiate a support vector classifier with a nonlinear kernel, the classifier is then fit to the training data set and evaluated.

We observe that the model did not overfit as the test and train accuracies are close.

Let's plot a confusion matrix to better understand the performance of the model.

```cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(8,6))
sns.heatmap(cm , annot=True)
plt.xlabel("Predicted")
plt.ylabel("Truth")
plt.show()```

The confusion matrix tells us how well the model performed.

For class 1, the model was able to predict as 1 (True positive)

29 times and it predicted a class of 0 as 1 five times

Overall, the model performed well.

Making a predictive system

In the last part of this article, we will learn about how to use our model to make predictions of other data.

we will create a function that will take in a dataset and use the model to produce predictions.

```def make_prediction(data):
"""
Funtion to produce predictions based on input data
Args:
data - input data
Return:
None
"""
data = np.asarray(input_data)
data = data.reshape(1, -1)
data = scaler.transform(data)

prediction = model.predict(data)

if prediction[0] == 1:
print("Patient has parkinson")
else:
print("Patient is healthy")```

The reshape argument is used to transform the data into one observation for the model to understand and make predictions on it.

Test

`input_data = (120.552, 131.162, 113.787, 0.00968, 0.00008, 0.00463, 0.0075, 0.01388, 0.04701, 0.456, 0.02328, 0.03526, 0.03243, 0.06985, 0.01222, 21.378, 0.415564, 0.825069, -4.242867, 0.299111, 2.18756, 0.357775)`
```make_prediction(input_data)

# Patient has parkinson```

Thank you !