Memprediksi Penyakit Jantung dengan Logistic Regression
perhatian: disini posisi saya masih belajar, jadi mungkin belum bisa memberikan penjelasan yang akurat
Halo, salam kenal semuanya. Pada kesempatan kali ini, ijinkan saya seorang programmer jarang ngoding untuk memberikan sedikit tutorial seputar machine learning. Buat yang belum tahu, machine learning adalah salah satu cabang dari artificial intelligence atau kecerdasan buatan yang membuat sistem bisa mengadaptasi kemampuan manusia untuk belajar (https://glints.com/id/lowongan/machine-learning/).
Oke biar ga terlalu banyak intro kita langsung aja praktek bagaimana pemakaiannya di dunia nyata. Disini saya mengambil kasus tentang memprediksi penyakit jantung dengan algoritma logistic regression.
teori-teori mengenai logistic regression dll akan saya skip dulu, mungkin akan dibahas pada tulisan selanjutnya
Langkah pertama yang perlu dipersiapkan sudah pasti dataset dan aplikasi untuk menjalankannya. untuk aplikasinya disini saya pakai jupyter notebook (bisa di download disini: Anaconda | Individual Edition). Kalau malas nginstall bisa pakai google colab (https://colab.research.google.com/)
Kalau sudah install, langsung klik jupyter notebook (disamping kiri powershell prompt) lalu pilih new.
selanjutnya download datasetnya disini: https://www.kaggle.com/rashikrahmanpritom/heart-attack-analysis-prediction-dataset
Simpan ke directory kalian terserah dimana.
Import Required Library
langkah awal adalah import library yang diperlukan beserta datasetnya:
#import required library
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as snsdf = pd.read_csv(‘D:/yourdirectory/heart.csv’)
df
Data Preprocessing
Langkah selanjutnya adalah kita akan melakukan data preprocessing. Intinya proses ini dilakukan untuk ngecek data kita apakah sudah ok atau belum untuk diimplementasikan algoritma machine learningnya. pada kasus ini data preprocessing yang dilakukan yaitu unique values checking, data type checking, dan missing values checking.
Unique Values Checking
Di tahap ini kita akan ngecek nilai unik yang ada di dalam dataset. Untuk scriptnya seperti ini:
#Check for the unique values
list_col=[‘age’,’sex’,’cp’,’trtbps’,’chol’,’fbs’,’restecg’,’thalachh’,’exng’,’oldpeak’,’slp’,’caa’,’thall’]for col in list_col:
print(‘{} :{} ‘ . format(col.upper(),df[col].unique()))
dan hasilnya akan seperti ini:
AGE :[63 37 41 56 57 44 52 54 48 49 64 58 50 66 43 69 59 42 61 40 71 51 65 53
46 45 39 47 62 34 35 29 55 60 67 68 74 76 70 38 77]
SEX :[1 0]
CP :[3 2 1 0]
TRTBPS :[145 130 120 140 172 150 110 135 160 105 125 142 155 104 138 128 108 134
122 115 118 100 124 94 112 102 152 101 132 148 178 129 180 136 126 106
156 170 146 117 200 165 174 192 144 123 154 114 164]
CHOL :[233 250 204 236 354 192 294 263 199 168 239 275 266 211 283 219 340 226
247 234 243 302 212 175 417 197 198 177 273 213 304 232 269 360 308 245
208 264 321 325 235 257 216 256 231 141 252 201 222 260 182 303 265 309
186 203 183 220 209 258 227 261 221 205 240 318 298 564 277 214 248 255
207 223 288 160 394 315 246 244 270 195 196 254 126 313 262 215 193 271
268 267 210 295 306 178 242 180 228 149 278 253 342 157 286 229 284 224
206 167 230 335 276 353 225 330 290 172 305 188 282 185 326 274 164 307
249 341 407 217 174 281 289 322 299 300 293 184 409 259 200 327 237 218
319 166 311 169 187 176 241 131]
FBS :[1 0]
RESTECG :[0 1 2]
THALACHH :[150 187 172 178 163 148 153 173 162 174 160 139 171 144 158 114 151 161
179 137 157 123 152 168 140 188 125 170 165 142 180 143 182 156 115 149
146 175 186 185 159 130 190 132 147 154 202 166 164 184 122 169 138 111
145 194 131 133 155 167 192 121 96 126 105 181 116 108 129 120 112 128
109 113 99 177 141 136 97 127 103 124 88 195 106 95 117 71 118 134
90]
EXNG :[0 1]
OLDPEAK :[2.3 3.5 1.4 0.8 0.6 0.4 1.3 0. 0.5 1.6 1.2 0.2 1.8 1. 2.6 1.5 3. 2.4
0.1 1.9 4.2 1.1 2. 0.7 0.3 0.9 3.6 3.1 3.2 2.5 2.2 2.8 3.4 6.2 4. 5.6
2.9 2.1 3.8 4.4]
SLP :[0 2 1]
CAA :[0 2 1 3 4]
THALL :[1 2 3 0]Bisa terlihat bahwa beberapa features memiliki nilai yang berbeda-beda. Dari hasil diatas kita bisa tarik kesimpulan bahwa features-features pada dataset ini bisa dibagi menjadi categorical features & continuous features.
Data Type Checking
Umumnya, machine learning mampu melakukan prediksi pada data-data berupa angka. Maka untuk mengantisipasi adanya data-data yang bukan angka bisa dilakukan data type checking ini. Scriptnya sebagai berikut:
#check the type of the data
df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 303 entries, 0 to 302
Data columns (total 14 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 age 303 non-null int64
1 sex 303 non-null int64
2 cp 303 non-null int64
3 trtbps 303 non-null int64
4 chol 303 non-null int64
5 fbs 303 non-null int64
6 restecg 303 non-null int64
7 thalachh 303 non-null int64
8 exng 303 non-null int64
9 oldpeak 303 non-null float64
10 slp 303 non-null int64
11 caa 303 non-null int64
12 thall 303 non-null int64
13 output 303 non-null int64
dtypes: float64(1), int64(13)
memory usage: 33.3 KBStatus dataset ini sudah aman, bisa kita lihat bahwa tipe data yang dimiliki adalah integer (int64) dan float (float64).
Missing Values Checking
data yang tidak ada isinya kadang bisa jadi mengganggu proses pembuatan model machine learning. Maka diperlukan pengecekan terhadap missing values tersebut dengan script berikut:
#check for the missing values
df.isnull().sum()
age 0
sex 0
cp 0
trtbps 0
chol 0
fbs 0
restecg 0
thalachh 0
exng 0
oldpeak 0
slp 0
caa 0
thall 0
output 0
dtype: int64Nah, bisa kita lihat tidak ada data yang kosong di dataset ini. Jadi sangat memudahkan kita untuk melakukan proses berikutnya.
Exploratory Data Analysis
Setelah kita melewati tahap data preprocessing tadi, langkah ini dilakukan untuk melihat keterkaitan setiap features terhadap target yang telah ditentukan. Oleh karena kita memiliki 2 tipe features (categorical & continuous) maka scriptnya pun ada 2. Script untuk categorical features adalah sebagai berikut:
#categorical Analysis
cat = [‘sex’, ‘cp’, ‘fbs’, ‘restecg’, ‘exng’, ‘slp’, ‘caa’, ‘thall’]
status = [‘No Heart Attack’, ‘Heart Attack’]for i in range(len(cat)):
plt.figure(figsize=(20,55))
plt.subplot(len(cat),2,1)
sns.countplot(x=cat[i] , data=df)
plt.xlabel(cat[i].capitalize(), fontsize=20)
plt.ylabel(‘Count’, fontsize=20)
if i == 0:
plt.title(‘Categorical Features’, fontsize=22)
plt.subplot(len(cat),2,2)
sns.countplot(x=cat[i], hue=’output’, data = df)
plt.xlabel(cat[i].capitalize(), fontsize=20)
plt.ylabel(‘Count’, fontsize=20)
plt.legend(title = ‘Output’, labels = status)
if i == 0:
plt.title(‘Countribution of Categorical Features for Heart Attack’, fontsize=22)
plt.show()
Pada gambar diatas, grafik kiri menggambarkan jumlah pasien berdasarkan jenis kelamin dan grafik di bagian kanan menjelaskan jumlah pasien yang terkena penyakit jantung dan tidak berdasarkan jenis kelamin.
# Continuous Features Analysis
cont = [‘age’, ‘trtbps’, ‘chol’, ‘thalachh’, ‘oldpeak’]
status = [‘No Heart Attack’, ‘Heart Attack’]for i in range(len(cont)):
plt.figure(figsize=(20,40))
plt.subplot(len(cont),2,1)
sns.histplot(x=cont[i] , data=df, kde=True)
plt.xlabel(cont[i].capitalize(), fontsize=20)
plt.ylabel(‘Count’, fontsize=20)
if i == 0:
plt.title(‘Histplot of Continuous Features’, fontsize=22)
plt.subplot(len(cont),2,2)
sns.histplot(x=cont[i], hue=’output’, data = df, palette=’magma’, kde=True)
plt.xlabel(cont[i].capitalize(), fontsize=20)
plt.ylabel(‘Count’, fontsize=20)
plt.legend(title = ‘Output’, labels = status)
if i == 0:
plt.title(‘Contribution of Continuous Features For Heart Attack’, fontsize=22)
plt.show()
Grafik di kiri menggambarkan rentang usia pasien penyakit jantung dan grafik kanan menggambarkan keterkaitan rentang usia tersebut terhadap kecenderungan terkena penyakit jantung.
Correlation Matrix
Langkah selanjutnya adalah menampilkan correlation matrix.
plt.figure(figsize = (20, 15))
sns.heatmap(df.corr(), cmap = “coolwarm”, annot=True, fmt=’.1f’, linewidths=0.1);
plt.yticks(rotation=0, size=16)
plt.xticks(size=16)
plt.title(‘Correlation Matrix’, size=26)
plt.show()
Jadi, correlation matrix ini berfungsi untuk menampilkan tingkat korelasi features-features terhadap output. pada kasus ini outputnya adalah 1 = terkena penyakit jantung, 0 = aman dari penyakit jantung. Nah, correlation matrix ini ada kaitannya dengan tahap selanjutnya yaitu features selection. Jadi pada correlation matrix ini kita dapat mengeliminasi features-features yang dianggap kurang berpengaruh terhadap output.
Untuk kasus ini saya membatasinya dengan mengambil features yang memiliki nilai diatas 0.25.
#take the features which have score above 0.25
corr = abs(df.corr()[‘output’])
corr[corr>0.25]
sex 0.280937
cp 0.433798
thalachh 0.421741
exng 0.436757
oldpeak 0.430696
slp 0.345877
caa 0.391724
thall 0.344029
output 1.000000
Name: output, dtype: float64Bisa terlihat pada gambar diatas, beberapa features telah tereliminasi karena nilainya dibawah 0.25
Langkah selanjutnya, kita berlanjut untuk merapikan dataset kita setelah dilakukan proses feature selection barusan
x = np.array([[df.sex, df.cp, df.thalachh, df.exng, df.oldpeak, df.slp, df.caa, df.thall]])
XR = x.reshape(x.shape[1:])
X = XR.transpose()
y = np.array(df[‘output’].values.tolist())print (X.shape)
print (y.shape)
(303, 8)
(303,)Logistic Regression
Akhirnya tibalah kita pada implementasi algoritmanya. Disini kita pakai library dari sklearn untuk implementasinya
import sklearn
from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(X,y, test_size = 0.2, random_state=5)
from sklearn.linear_model import LogisticRegression
classifier=LogisticRegression(max_iter=300)
classifier.fit(X_train,y_train)
y_pred=classifier.predict(X_test)from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
pred = classifier.predict(X_test)
print(classification_report(y_test, pred))
print()
print(‘Accuracy’, accuracy_score(y_test, pred))
precision recall f1-score support
0 0.93 0.93 0.93 30
1 0.94 0.94 0.94 31
accuracy 0.93 61
macro avg 0.93 0.93 0.93 61
weighted avg 0.93 0.93 0.93 61
Accuracy 0.9344262295081968Nah, setelah berhasil diimplementasi, kita bisa lihat bahwa tingkat akurasi logistic regression untuk memprediksi potensi orang terkena penyakit jantung cukup tinggi yaitu kisaran 93%.
Jangan lupa, setelah implementasi kita lakukan evaluasi terhadap algoritmanya. Disini saya pakai Mean Squared Error (MSE)
#Check for MSE
from sklearn.metrics import mean_squared_errormean_squared_error(y_test, pred)
0.06557377049180328Terlihat jelas bahwa nilai errornya sangat kecil yaitu 0.065.
Jadi Kesimpulannya Apa?
Oke jadi disini saya bisa katakan bahwa algoritma logistic regression mampu memberikan performa yang baik dalam kasus memprediksi penyakit jantung.
Oke mungkin sampai sini tutorial yang bisa saya berikan. Bingung mau jelasin apalagi soalnya masih newbie.