VIKRAM RAJKUMAR — Published On February 20, 2022 and Last Modified On March 22nd, 2022

This article was published as a part of the Data Science Blogathon.

## Overview

Machine Learning is one of the most widely used concepts around the world. It will be essential in the healthcare sectors which will be useful for doctors to fasten the diagnosis. In this article, we will be dealing with the Heart disease dataset and will analyze, predict the result whether the patient has heart disease or normal, i.e. Heart disease prediction using Machine Learning. This prediction will make it faster and more efficient in healthcare sectors which will be a time-consuming process.

## Takeaways from the Article

1. Data Analysis: This process involves data cleaning, data statistics, getting insights from the dataset.

2. Algorithm Implementation: This involves four machine learning algorithms which will result in performance metrics of the model.

3. Model Implementation: The well-doing algorithm is implemented in the model and checking results with the real-time data.

## Importing Libraries

```import NumPy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
from sklearn.model_selection import KFold, StratifiedKFold, cross_val_score
from sklearn import linear_model, tree, ensemble```

## Reading the Data from CSV file

In this section, we will load and view the CSV file and its contents.

Filename: heart.csv

This dataset is sourced from the online repository of UCI.

Contents:

We have 14 attributes/features including target which will be age, gender, cholesterol level, exacting, chest pain, old peak, thalach, FBS, slope, thal, etc.

```dataframe=pd.read_csv("/content/heart.csv")

Output: Inference: From the dataset, we have three types of data such as continuous, ordinal, and binary data.

## Data Analysis

Let, we get some basic information about the dataset.

`dataframe.info()`

Output:

Now, let us look at whether the dataset has null values or not.

`dataframe.isna().sum()`

Output:

Inference: From this output, our data does not contain null values and duplicates. So, the data is good which will be further analyzed.

## Correlation Matrix

Visulaizing the data features to find the correlation between them which will infer the important features.

```plt.figure(figsize=(15,10))
sns.heatmap(dataframe.corr(),linewidth=.01,annot=True,cmap="winter")
plt.show()
plt.savefig('correlationfigure')```

Output:

Inference:

From the above heatmap, we can understand that Chest pain(cp) and target have a positive correlation. It means that whose has a large risk of chest pain results in a greater chance to have heart disease. In addition to chest pain, thalach, slope, and resting have a positive correlation with the target.

Then, exercise-induced angina(exang) and the target have a negative correlation which means when we exercise, the heart requires more blood, but narrowed arteries slow down the blood flow. In addition to ca, old peak, thal have a negative correlation with the target.

Let us see the relation between each features distribution with the help of histogram.

```dataframe.hist(figsize=(12,12))
plt.savefig('featuresplot')```

Output:

## Train-Test Split

`X_train, X_test,y_train, y_test=train_test_split(X,y,test_size=0.25,random_state=40)`

We split the whole dataset into trainset and testset which contains 75% train and 25% test.

We can include this train set into classifiers to train our model and the test set is useful for predicting the performance of the model by different classifiers.

## Algorithm Implementation

#### 1 Logistic Regression

```from sklearn.model_selection import cross_val_score, GridSearchCV
from sklearn.linear_model import LogisticRegression
lr=LogisticRegression(C=1.0, class_weight='balanced', dual=False,
fit_intercept=True, intercept_scaling=1, l1_ratio=None,
max_iter=100, multi_class='auto', n_jobs=None, penalty='l2',
random_state=1234, solver='lbfgs', tol=0.0001, verbose=0,
warm_start=False)
model1=lr.fit(X_train,y_train)
prediction1=model1.predict(X_test)
from sklearn.metrics import confusion_matrix
cm=confusion_matrix(y_test,prediction1)
cm
sns.heatmap(cm, annot=True,cmap='winter',linewidths=0.3, linecolor='black',annot_kws={"size": 20})
TP=cm
TN=cm
FN=cm
FP=cm

print('Testing Accuracy for Logistic Regression:',(TP+TN)/(TP+TN+FN+FP))
print('Testing Sensitivity for Logistic Regression:',(TP/(TP+FN)))
print('Testing Specificity for Logistic Regression:',(TN/(TN+FP)))
print('Testing Precision for Logistic Regression:',(TP/(TP+FP)))```

Output:

```from sklearn.metrics import classification_report
print(classification_report(y_test, prediction1))```

Inference: From the above report, we get the accuracy of the Logistic Regression classifier is about 80%.

#### 2 Decision Tree

```from sklearn.model_selection import RandomizedSearchCV
from sklearn.tree import DecisionTreeClassifier

tree_model = DecisionTreeClassifier(max_depth=5,criterion='entropy')
cv_scores = cross_val_score(tree_model, X, y, cv=10, scoring='accuracy')
m=tree_model.fit(X, y)
prediction=m.predict(X_test)
cm= confusion_matrix(y_test,prediction)
sns.heatmap(cm, annot=True,cmap='winter',linewidths=0.3, linecolor='black',annot_kws={"size": 20})
print(classification_report(y_test, prediction))

TP=cm
TN=cm
FN=cm
FP=cm
print('Testing Accuracy for Decision Tree:',(TP+TN)/(TP+TN+FN+FP))
print('Testing Sensitivity for Decision Tree:',(TP/(TP+FN)))
print('Testing Specificity for Decision Tree:',(TN/(TN+FP)))
print('Testing Precision for Decision Tree:',(TP/(TP+FP)))```

Output:

Inference: From the above report, we get the accuracy of the Decision Tree classifier is about 92%.

#### 3 Random Forest Classifier

```from sklearn.ensemble import RandomForestClassifier
rfc=RandomForestClassifier(n_estimators=500,criterion='entropy',max_depth=8,min_samples_split=5)
model3 = rfc.fit(X_train, y_train)
prediction3 = model3.predict(X_test)
cm3=confusion_matrix(y_test, prediction3)
sns.heatmap(cm3, annot=True,cmap='winter',linewidths=0.3, linecolor='black',annot_kws={"size": 20})
TP=cm3
TN=cm3
FN=cm3
FP=cm3
print(round(accuracy_score(prediction3,y_test)*100,2))
print('Testing Accuracy for Random Forest:',(TP+TN)/(TP+TN+FN+FP))
print('Testing Sensitivity for Random Forest:',(TP/(TP+FN)))
print('Testing Specificity for Random Forest:',(TN/(TN+FP)))
print('Testing Precision for Random Forest:',(TP/(TP+FP)))```

Output:

Let us see the classification report for Random Forest Classifier:

`print(classification_report(y_test, prediction3))`

Output:

Inference: From the above report, we can get the accuracy of the Random Forest classifier is about 80%.

#### 4 Support Vector Machines(SVM)

```  from sklearn.svm import SVC
svm=SVC(C=12,kernel='linear')
model4=svm.fit(X_train,y_train)
prediction4=model4.predict(X_test)
cm4= confusion_matrix(y_test,prediction4)
sns.heatmap(cm4, annot=True,cmap='winter',linewidths=0.3, linecolor='black',annot_kws={"size": 20})
TP=cm4
TN=cm4
FN=cm4
FP=cm4

print('Testing Accuracy for SVM:',(TP+TN)/(TP+TN+FN+FP))
print('Testing Sensitivity for Random Forest:',(TP/(TP+FN)))
print('Testing Specificity for Random Forest:',(TN/(TN+FP)))
print('Testing Precision for Random Forest:',(TP/(TP+FP)))```

Output:

Let us see the classification report of SVM:

`print(classification_report(y_test, prediction4))`

Output:

Inference: From the above report, we get the accuracy of the Support Vector Machine classifier is about 82%.

From the results that we got, as four machine learning algorithms like Logistic Regression, Random Forest, Support Vector Machines and Decision Trees. From the final results, we got Logistic Regression as 80%, Random Forest as 80%, Support Vector Machines as 82%, and Decision Trees as 92%. We can conclude that the Decision Tree algorithm is the best algorithm for our model with the highest accuracy around 92 percent.

## Final Model Implementation

Now, we can apply the best working algorithm (i.e., Decision Tree Classifier) into our model and check whether our model will result in the correct output or not with the help of available data.

#### CASE 1 – For Heart Disease data

```input=(63,3,145,233,150,2.3,0)
input_as_numpy=np.asarray(input)
input_reshaped=input_as_numpy.reshape(1,-1)
pre1=tree_model.predict(input_reshaped)
if(pre1==1):
print("The patient seems to be have heart disease:(")
else:
print("The patient seems to be Normal:)")```

Output:

#### CASE 2 – For Normal Data

```input=(72,1,125,200,150,1.3,1)
input_as_numpy=np.asarray(input)
input_reshaped=input_as_numpy.reshape(1,-1)
pre1=tree_model.predict(input_reshaped)
if(pre1==1):
print("The patient seems to be have heart disease:(")
else:
print("The patient seems to be Normal:)")```

Output:

## Conclusion

Finally, we can conclude that real-time predictors will be essential in the healthcare sector nowadays. From this project, we will be able to predict real-time heart disease using the patient’s data from the model using the Decision Tree Algorithm, thereby making accurate heart disease prediction using machine learning. I hope that you are all excited about the blog. Let us know your thoughts in the comments!

Vikram Rajkumar – I am currently pursuing my Bachelor of Engineering (B.E.) in Electronics and Communication Engineering from Sri Krishna College of Engineering and Technology, Coimbatore. I have done projects and internships in the domain of data science and business analytics and am also interested in machine learning, data analysis, data visualizations. • 