Heart Disease Prediction Using Machine Learning

Cardiovascular diseases represent a significant worldwide health issue, causing a substantial number of deaths. Prompt identification and preventive measures are vital for mitigating their effects. Recently, a class of innovative computational methods known as machine learning has proven highly effective in prognosticating and diagnosing diverse medical ailments, and heart disease is one of them. By harnessing extensive datasets and cutting-edge algorithms, these models can accurately pinpoint individuals susceptible to heart disease and facilitate timely interventions. This article explores the domain of heart disease prediction through machine learning, shedding light on its promise, hurdles, and implications within the healthcare sector.

Various ailments, including coronary artery disease, heart failure, and irregular heart rhythms, fall under the umbrella term "heart disease." Detecting individuals at an early stage who are susceptible to these conditions can substantially enhance the well-being of patients through prompt interventions and adjustments to their way of life.

Now we try to predict whether a patient has heart disease or not under a given clinical parameter.

Data is abstracted from https://archive.ics.uci.edu/ml/datasets/heart+Disease

Features

Below are the details and descriptions of the data features.

age - age in years
sex - (1 = male; 0 = female)
cp - chest pain type
- 0: Typical angina: chest pain related decrease blood supply to the heart
- 1: Atypical angina: chest pain not related to heart
- 2: Non-anginal pain: typically esophageal spasms (non-heart related)
- 3: Asymptomatic: chest pain not showing signs of disease
trestbps - resting blood pressure (in mm Hg on admission to the hospital); anything above 130-140 typically causes concern
chol - serum cholesterol in mg/dl
- serum = LDL + HDL + .2 * triglycerides
- above 200 is cause for concern
fbs - (fasting blood sugar > 120 mg/dl) (1 = true; 0 = false)
- '>126' mg/dL signals diabetes
restecg - resting electrocardiographic results
- 0: Nothing to note
- 1: ST-T Wave abnormality
  - can range from mild symptoms to severe problems
  - signals non-normal heartbeat
- 2: Possible or definite left ventricular hypertrophy
  - Enlarged heart's main pumping chamber
thalach - maximum heart rate achieved
exang - exercise-induced angina (1 = yes; 0 = no)
oldpeak - ST depression induced by exercise relative to rest looks at the stress of the heart during unhealthy exercise heart will stress more
slope - the slope of the peak exercise ST segment
- 0: Upsloping: better heart rate with exercise (uncommon)
- 1: Flatsloping: minimal change (typical healthy heart)
- 2: Downslopins: signs of an unhealthy heart
ca - number of major vessels (0-3) colored by fluoroscopy
- colored vessel means the doctor can see the blood passing through
- the more blood movement, the better (no clots)
thal - thalium stress result
- 1,3: Normal
- 6: fixed defect: used to be a defect but ok now
- 7: reversible defect: no proper blood movement when exercising
target - have disease or not (1=yes, 0=no) (= the predicted attribute)

Code:

Importing Libraries

#!pip install sklearn
#Import all libraries

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

#Inline matplotlib to view inside this notebook directly
%matplotlib inline

#Models
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier

#Evaluation
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.model_selection import RandomizedSearchCV, GridSearchCV
from sklearn.metrics import confusion_matrix, classification_report
from sklearn.metrics import precision_score, recall_score, f1_score
from sklearn.metrics import plot_roc_curve

Loading Dataset

dataframe = pd.read_csv("../input/hear2csv/heart (2).csv")
dataframe.shape

Output:

EDA(Exploratory Data Analysis)

EDA plays a vital role in comprehending the dataset and extracting valuable insights. EDA encompasses a range of techniques aimed at thoroughly examining and visually representing the data, with the objective of unveiling underlying patterns, relationships, and possible anomalies that may exist within the dataset.

Output:

#how many classes of one feature or target
dataframe["target"].value_counts()

Output:

#bar chart
dataframe["target"].value_counts().plot(kind='bar', color=["salmon","lightblue"])

Output:

In this bar chart, we can see that more data samples show heart disease.

Output:

#check missing values of all features
>dataframe.isna().sum()

Output:

Heart Disease Frequency according to sex

Output:

#Compare target and sex column
pd.crosstab(df.target, df.sex)

Output:

#Create a plot of crosstab
pd.crosstab(dataframe.target, dataframe.sex).plot(kind="bar",figsize=(10,6),color=["salmon","lightblue"])
plt.title("Heart Disease Frerquency for Sex")
plt.xlabel("0 = No Disease, 1=Disease")
plt.ylabel("Amount")
plt.legend(["Female","Male"]);
plt.xticks(rotation=0);

Output:

From the bar chart above, the frequency of females getting heart disease is higher in this dataset compared to males.

Age vs. Max Heart Rate for Heart Disease

#Create a new figure
plt.figure(figsize=(10,6))

#Scatter with positive examples
plt.scatter(dataframe.age[dataframe.target==1],
           dataframe.thalach[dataframe.target==1],
           c="salmon")

#Scatter with negative examples
plt.scatter(dataframe.age[dataframe.target==0],
           dataframe.thalach[dataframe.target==0],
           c="lightblue");

#Add some helpful info
plt.title("Heart Disease in function of Age and Max Heart Rate")
plt.xlabel("Age")
plt.ylabel("Max Heart Rate")
plt.legend(["Disease", "No Disease"])

Output:

The chances of getting a maximum heart rate are higher for heart disease patients.

#Check the distribution of the age column with a histogram
#May check for outliers of the data
dataframe.age.plot.hist()

Output:

In this histogram, we can see that approximately half of the sample's age is between 55 to 65 years old. The rest are from the 40s to 70s. There are also a few samples for 30-40 and 70 above.

Heart Disease Frequency per Chest Pain Type

cp - chest pain type

0: Typical angina: chest pain related decrease blood supply to the heart
1: Atypical angina: chest pain not related to heart
2: Non-anginal pain: typically esophageal spasms (non-heart related)
3: Asymptomatic: chest pain not showing signs of disease

Output:

# Make crosstab visualise
pd.crosstab(dataframe.cp,dataframe.target).plot(kind="bar",figsize=(10,6),color=["salmon","lightblue"])

plt.title("Heart Disease Frequency Per Chest Pain Type")
plt.xlabel("CHest Pain Type")
plt.ylabel("Amount")
plt.legend(["No Disease","Disease"])
plt.xticks(rotation=0)

Output:

Most heart disease patients suffer from the third chest pain type, which is non-anginal pain, and some of those suffering from the first chest pain type, typical angina, and atypical angina. Although the second and third chest pain type is non-related to the heart, the data shows patients will suffer from those chest pain types. To make a conclusion, we might need to approach some healthcare professionals to ask for their opinions.

Correlation

#Make a correlation matrix
dataframe.corr()

Output:

#Visualise correlation
corr_matrix = dataframe.corr()
fig,ax = plt.subplots(figsize=(15,10))
ax=sns.heatmap(corr_matrix,annot=True,linewidths=0.5,fmt=".2f",cmap="YlGnBu");
bottom, top = ax.get_ylim()
ax.set_ylim(bottom + 0.5, top-0.5)

Output:

1. Positive correlation, both variables increase or decrease in the same direction

2. Negative correlation, one variable increase and one variable decrease vice versa

Result 1: Chest pain and target have a positive correlation -> Higher chest pain level, and more targets may get heart disease.

Modeling

#Split data into X and y for training features and the target variable
X=dataframe.drop("target",axis=1)
y=dataframe["target"]


#Split data into train and test sets
np.random.seed(42)
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2)

Train Base Models

Here we will employ the following machine-learning models:

Logistic Regression
K-Nearest Neighbors Classifiers
Random Forest Classifiers

#Put models in a dictionary

models = {"Logistic Regression": LogisticRegression(),
         "KNN": KNeighborsClassifier(),
         "Random Forest": RandomForestClassifier()}

#Create a function to fit and score models
def fit_and_score(models, X_train, X_test, y_train, y_test):
    """
    Fits and evaluates given machine learning models.
    models: a dict of different Scikit-Learn machine learning models
    X_train: training data (no labels)
    X_test: testing data (no labels)
    y_train: training labels
    y_test: test labels
    """
    #set a random seed
    np. random.seed(42)
    #dictionary to keep model scores
    model_scores = {}
    #loop thru models
    for name, model in models.items():
        #fit model
        model.fit(X_train, y_train)
        #evaluate model and append score
        model_scores[name]=model.score(X_test, y_test)
    return model_scores


model_scores = fit_and_score(models=models, X_train=X_train, X_test=X_test, y_train=y_train, y_test=y_test)
model_scores

Output:

Base Model Comparison

model_compare = pd.DataFrame(model_scores, index=["accuracy"])
model_compare.T.plot.bar()

Output:

For the base model, Logistic Regression and Random Forest work way better than KNN.

Hyperparameter Tuning

We will employ the following ways of Hyperparameter Tuning:

by hand
RandomizedSearchCV
GridSearchCV

Tune By Hand

#Tune knn
train_scores = []
test_scores = []

#list for different values of n-neighbors
neighbors = range(1,21)

#set up knn instance
knn = KNeighborsClassifier()

#loop through a list
for i in neighbors:
    knn.set_params(n_neighbors=i)
    
    #fit the model
    knn.fit(X_train, y_train)
    
    # Update the training scores list
    train_scores.append(knn.score(X_train, y_train))
    
    # Update the test scores list
    test_scores.append(knn.score(X_test, y_test))
    


test_scores

Output:

plt.plot(neighbors, train_scores, label="Train score")
plt.plot(neighbors, test_scores, label="Test score")
plt.xticks(np.arange(1, 21, 1))
plt.xlabel("Number of neighbors")
plt.ylabel("Model score")
plt.legend()

print(f"Maximum KNN score on the test data: {max(test_scores)*100:.2f}%")

Output:

Maximum KNN score on the test data: 75.41%

After tuning the parameter for k value, the KNN classifier has improved, but the performance is still lower than Logistic Regression and Random Forest.

Hyperparameter tuning with RandomizedSearchCV

#Create a hyperparameter grid for LR
log_reg_grid = {"C": np.logspace(-4,4,20),
                "solver": ["liblinear"]}

#Create a hyperparameter grid for RF
rf_grid = {"n_estimators": np.arange(10,1000,50),
          "max_depth": [None,3,5,10],
          "min_samples_split": np.arange(2,20,2),
          "min_samples_leaf": np.arange(1,20,2)}


# Tune LogisticRegression

np.random.seed(42)

# Setup random hyperparameter search for LogisticRegression
rs_log_reg = RandomizedSearchCV(LogisticRegression(),
                                param_distributions=log_reg_grid,
                                cv=5,
                                n_iter=20,
                                verbose=True)

# Fit random hyperparameter search model for LogisticRegression
rs_log_reg.fit(X_train, y_train)

Output:

rs_lr_score = rs_log_reg.score(X_test,y_test)

#Tune RF

#Set random parameter search for RF
np.random.seed(42)
rs_rf = RandomizedSearchCV(RandomForestClassifier(),
                            param_distributions=rf_grid,
                                cv=5,
                                n_iter=20,
                                verbose=True)
#Fit random hyperparameter search model for RF
rs_rf.fit(X_train,y_train)

Output:

#Find the best hyperparameter
rs_rf.best_params_

Output:

#Evaluate the randomized search RF model
rs_rf_score =rs_rf.score(X_test, y_test)
#default model scores
model_scores

Output:

By using RandomizedSearchCV, the performance of random forest models has improved. But the logistic regression model's performance is still higher.

Hyperparameter Tuning with GridSearchCV

#Different hyperparameters for the LR model
log_reg_grid = {"C": np.logspace(-4,4,30),
               "solver": ["liblinear"]}

#Setup grid hyperparameter for LR
gs_log_reg = GridSearchCV(LogisticRegression(),
                         param_grid=log_reg_grid,
                         cv=5,
                         verbose=True)

#Fit into model
gs_log_reg.fit(X_train,y_train)

Output:

#check best hyperparameters
gs_log_reg.best_params_

Output:

#Evaluate grid search LR model
gs_lr_score = gs_log_reg.score(X_test,y_test)


model_scores.update( [('RandomizedS LR',rs_lr_score),('RandomizedS RF',rs_rf_score),('GridS LR',gs_lr_score)] )
model_compare2 = pd.DataFrame(model_scores, index=["accuracy"])
model_compare2.T.plot.bar(legend=False)

Output:

Logistic Regression has the same scores for all of the different hyperparameter tuning models.

Out of three different classifiers, Logistic Regression has the best performance score during the training stage.

Evaluating tuned machine learning classifier beyond accuracy

We will be using the following metrics for evaluation:

ROC curve and AUC score
Confusion matrix
Classification report
Precision
Recall
F1-score

#Make predictions with a tuned model
y_preds = gs_log_reg.predict(X_test)
y_preds

Output:

#Plot the ROC curve and calculate the AUC metric
plot_roc_curve(gs_log_reg, X_test, y_test)

Output:

#Confusion matrix
print(confusion_matrix(y_test, y_preds))

Output:

sns.set(font_scale=1.5)

def plot_conf_mat(y_test,y_preds):
    """
    Plot a nice-looking confusion matrix using Seaborn's heatmap.
    """
    fig,ax = plt.subplots(figsize=(3,3))
    ax=sns.heatmap(confusion_matrix(y_test,y_preds),
                  annot=True,
                  cbar=False)
    plt.xlabel("Predicted label")
    plt.ylabel("True label")
    
    bottom, top = ax.get_ylim()
    ax.set_ylim(bottom + 0.5, top - 0.5)
    
plot_conf_mat(y_test, y_preds)

Output:

Classification Report

#Using only one split
print(classification_report(y_test,y_preds))

Output:

Calculate evaluation metrics using cross-validation using cross_val_score()

#Check best hyperparameters
gs_log_reg.best_params_ 

Output:

#Create a new classifier with the best parameters
clf = LogisticRegression(C=0.20433597178569418,
                        solver="liblinear")


# Cross-validated accuracy
cv_acc= cross_val_score(clf,
                       X,
                       y,
                       cv=5,
                       scoring="accuracy")
cv_acc

Output:

cv_acc = np.mean(cv_acc)
cv_acc

Output:

#Cross-validated precision
cv_precision= cross_val_score(clf,
                       X,
                       y,
                       cv=5,
                       scoring="precision")
cv_precision = np.mean(cv_precision)
cv_precision

Output:

#Cross-validated recall
cv_recall= cross_val_score(clf,
                       X,
                       y,
                       cv=5,
                       scoring="recall")
cv_recall = np.mean(cv_recall)
cv_recall

Output:

#Cross-validated f1
cv_f1= cross_val_score(clf,
                       X,
                       y,
                       cv=5,
                       scoring="f1")
cv_f1 = np.mean(cv_f1)
cv_f1

Output:

#Visualise cross-validated metrics
cv_metrics = pd.DataFrame({"Accuracy": cv_acc,
                          "Precision": cv_precision,
                          "Recall": cv_recall,
                          "F1": cv_f1},
                          index=[0])

cv_metrics.T.plot.bar(title="Cross-validated classification metrics",
                      legend=False);

Output:

Feature Importance

Feature importance is another as asking, "which features contributed most to the outcome of the model and how did they contribute?"

Finding feature importance is different for each machine learning model.

We may refer to feature importance for future collecting data.

#Fit an instance of LR
clf = LogisticRegression(C=0.20433597178569418,
                        solver="liblinear")

clf.fit(X_train,y_train);
#Check coef_
clf.coef_

Output:

#Match coef to columns
feature_dict = dict(zip(dataframe.columns, list(clf.coef_[0])))
feature_dict

Output:

#Visualise feature importance
feature_df = pd.DataFrame(feature_dict,index=[0])
feature_df.T.plot.bar(title="Feature Importance",legend=False)

Output:

Based on the visualization,

chest pain type(cp)
resting electrocardiographic results(restecg)
the slope of the peak exercise ST segment(slope)

have strong feature importance.

On the other hand, sex has the least importance.

Incorporating machine learning techniques for heart disease prediction presents a set of hurdles to overcome. These challenges encompass the necessity for extensive, varied, and carefully curated datasets, the possibility of biases within data acquisition, and the interpretability of the models themselves. Resolving these obstacles necessitates a cooperative effort among healthcare experts, data scientists, and regulatory entities to guarantee the ethical and efficient application of machine learning algorithms.

Conclusion

Heart disease prognosis utilizing machine learning stands as a notable stride forward in healthcare. Capitalizing on sophisticated algorithms and extensive data analysis, we are able to embrace forward-thinking and tailored methodologies in combating heart disease. As research and technological progress march on, it becomes imperative for stakeholders to unite, guaranteeing judicious execution, confronting obstacles, and maximizing the advantages of this revolutionary technology. By means of early identification and preventive measures, we endeavor to shape a future where global cardiovascular well-being experiences marked enhancement.

Next TopicOCR with Machine Learning

← prev next →