Mengumpulkan Data
cleveland.data
Menelaah Data
import pandas as pd
import re
import numpy as np
import itertools
with open('cleveland.data', encoding='Latin1') as file:
lines = [line.strip() for line in file]
lines[0:10]
data = itertools.takewhile(
lambda x: len(x) == 76,
(' '.join(lines[i:(i+10)]).split() for i in range(0, len(lines), 10))
)
df = pd.DataFrame(data)
df.head(10)
df.info()
df = df.iloc[:,:-1]
df = df.drop(df.columns[0], axis=1)
df = df.astype(float)
df.info()
Memvalidasi Data
df.replace(-9.0, np.nan, inplace=True)
Menentukan Objek Data
df_selected = df.iloc[:, [1, 2, 7, 8, 10, 14, 17, 30, 36, 38, 39, 42, 49, 56]]
df_selected.head()
column_mapping = {
2: 'age',
3: 'sex',
8: 'cp',
9: 'trestbps',
11: 'chol',
15: 'fbs',
18: 'restecg',
31: 'thalach',
37: 'exang',
39: 'oldpeak',
40: 'slope',
43: 'ca',
50: 'thal',
57: 'target'
}
df_selected.rename(columns=column_mapping, inplace=True)
df_selected.info()
df_selected.value_counts()
Membersihkan Data
df_selected.isnull().sum()
meanCa = round(df_selected['ca'].dropna().astype(float).mean())
meanThal = round(df_selected['thal'].dropna().astype(float).mean())
fill_values = {
'ca': meanCa,
'thal': meanThal,
}
df_clean = df_selected.fillna(value=fill_values)
df_clean.info()
df_clean.isnull().sum()
df_clean = df_clean.drop_duplicates()
df_clean[df_clean.duplicated(keep=False)]
df_clean.corr()
Mengonstruksi Data
import matplotlib.pyplot as plt
import seaborn as sns
X = df_clean.drop("target", axis=1).values
y = df_clean.iloc[:, -1]
df_clean['target'].value_counts().plot(kind='bar', figsize=(10,6), color=['purple', 'blue'])
plt.title("Count target")
plt.xticks(rotation=0)
from imblearn.over_sampling import SMOTE
smote = SMOTE(random_state=42)
X_smote_resampled, y_smote_resampled = smote.fit_resample(X, y)
new_df1 = pd.DataFrame(data=y)
new_df2 = pd.DataFrame(data=y_smote_resampled)
new_df2['target'].value_counts().plot(kind='bar', figsize=(10,6), color=['purple', 'blue'])
plt.title("Count target")
plt.xticks(rotation=0)
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X_smote_resampled_normal = scaler.fit_transform(X_smote_resampled)
df_check1 = pd.DataFrame(X_smote_resampled_normal)
df_check1.describe()
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X_smote_resampled, y_smote_resampled, test_size=0.2, random_state=42, stratify=y_smote_resampled)
X_train_normal, X_test_normal, y_train_normal, y_test_normal = train_test_split(X_smote_resampled_normal, y_smote_resampled, test_size=0.25, random_state=42, stratify=y_smote_resampled)
Membangun Model
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, classification_report
from sklearn.metrics import accuracy_score, recall_score, f1_score, precision_score, roc_auc_score, confusion_matrix, precision_score
def evaluation(y_test, y_pred):
return print({
'accuracy': round(accuracy_score(y_test, y_pred), 3),
'recall': round(recall_score(y_test, y_pred, average='weighted'), 3),
'f1_score': round(f1_score(y_test, y_pred, average='weighted'), 3),
'precision_score': round(precision_score(y_test, y_pred, average='weighted'), 3)
})
Raw
Decision Tree
dt_model = DecisionTreeClassifier()
dt_model.fit(X_train, y_train)
y_pred_dt = dt_model.predict(X_test)
print("Decision Tree Model:")
accuracy_dt = round(accuracy_score(y_test, y_pred_dt), 3)
print("Accuracy: ", accuracy_dt)
Naive Bayes
nb_model = GaussianNB()
nb_model.fit(X_train, y_train)
y_pred_nb = nb_model.predict(X_test)
print("Naive Bayes Model:")
accuracy_nb = round(accuracy_score(y_test, y_pred_nb), 3)
print("Accuracy: ", accuracy_nb)
Support Vector Machine
svm_model = SVC(kernel='linear')
svm_model.fit(X_train, y_train)
y_pred_svm = svm_model.predict(X_test)
print("Support Vector Machine Model:")
accuracy_svm = round(accuracy_score(y_test, y_pred_svm), 3)
print("Accuracy: ", accuracy_svm)
Over Sampling
Decision Tree
dt1_model = DecisionTreeClassifier()
dt1_model.fit(X_train, y_train)
y_pred_dt1 = dt1_model.predict(X_test)
print("Decision Tree Model:")
accuracy_dt1 = round(accuracy_score(y_test, y_pred_dt1), 3)
print("Accuracy: ", accuracy_dt1)
evaluation(y_test, y_pred_dt1)
Naive Bayes
nb1_model = GaussianNB()
nb1_model.fit(X_train, y_train)
y_pred_nb1 = nb1_model.predict(X_test)
print("Naive Bayes Model:")
accuracy_nb1 = round(accuracy_score(y_test, y_pred_nb1), 3)
print("Accuracy: ", accuracy_nb1)
evaluation(y_test, y_pred_nb1)
Support Vector Machine
svm1_model = SVC(kernel='linear')
svm1_model.fit(X_train, y_train)
y_pred_svm1 = svm1_model.predict(X_test)
print("Support Vector Machine Model:")
accuracy_svm1 = round(accuracy_score(y_test, y_pred_svm1), 3)
print("Accuracy: ", accuracy_svm1)
evaluation(y_test, y_pred_svm1)
Over Sampling + Normalisasi
Decision Tree
dt2_model = DecisionTreeClassifier()
dt2_model.fit(X_train_normal, y_train_normal)
y_pred_dt2 = dt2_model.predict(X_test_normal)
print("Decision Tree Model:")
accuracy_dt2 = round(accuracy_score(y_test_normal, y_pred_dt2), 3)
print("Accuracy: ", accuracy_dt2)
evaluation(y_test_normal, y_pred_dt2)
Naive Bayes
nb2_model = GaussianNB()
nb2_model.fit(X_train_normal, y_train_normal)
y_pred_nb2 = nb2_model.predict(X_test_normal)
print("Naive Bayes Model:")
accuracy_nb2 = round(accuracy_score(y_test_normal, y_pred_nb2), 3)
print("Accuracy: ", accuracy_nb2)
evaluation(y_test_normal, y_pred_nb2)
Support Vector Machine
svm2_model = DecisionTreeClassifier()
svm2_model.fit(X_train_normal, y_train_normal)
y_pred_svm2 = svm2_model.predict(X_test_normal)
print("Support Vector Machine Model:")
accuracy_svm2 = round(accuracy_score(y_test_normal, y_pred_svm2), 3)
print("Accuracy: ", accuracy_svm2)
evaluation(y_test_normal, y_pred_svm2)
Over Sampling + Normalisasi + Tunning
from sklearn.model_selection import RandomizedSearchCV
Decision Tree
dt3_model = DecisionTreeClassifier()
param_grid = {
'max_depth': [None, 10, 20, 30, 40, 50],
'min_samples_split': [2, 5, 10, 20],
'min_samples_leaf': [1, 2, 4, 10],
'criterion': ['gini', 'entropy']
}
dt3_model = RandomizedSearchCV(dt3_model, param_distributions=param_grid, n_iter=100, cv=5, verbose=2, random_state=42, n_jobs=-1)
dt3_model.fit(X_train_normal, y_train_normal)
best_params = dt3_model.best_params_
print(f"Best Parameters: {best_params}")
y_pred_dt3 = dt3_model.predict(X_test_normal)
print("Decision Tree Model:")
accuracy_dt3 = round(accuracy_score(y_test_normal, y_pred_dt3), 3)
print("Accuracy: ", accuracy_dt3)
evaluation(y_test_normal, y_pred_dt3)
Naive Bayes
nb3_model = GaussianNB()
param_grid = {'var_smoothing': np.logspace(0,-9, num=100)}
nb3_model = RandomizedSearchCV(nb3_model, param_distributions=param_grid, n_iter=100, cv=5, verbose=2, random_state=42, n_jobs=-1)
nb3_model.fit(X_train_normal, y_train_normal)
best_params = nb3_model.best_params_
print(f"Best Parameters: {best_params})")
y_pred_nb3 = nb3_model.predict(X_test_normal)
print("Naive Bayes Model:")
accuracy_nb3 = round(accuracy_score(y_test_normal, y_pred_nb3), 3)
print("Accuracy: ", accuracy_nb3)
evaluation(y_test_normal, y_pred_nb3)
Support Vector Machine
from scipy.stats import expon, reciprocal
svm3_model = SVC()
param_grid = {
'C': reciprocal(0.001, 1000),
'gamma': expon(scale=1.0),
'kernel': ['rbf', 'linear']
}
svm3_model = RandomizedSearchCV(svm3_model, param_distributions=param_grid, n_iter=25, cv=5, verbose=2, random_state=42, n_jobs=-1)
svm3_model.fit(X_train_normal, y_train_normal)
best_params = svm3_model.best_params_
print(f"Best Parameters: {best_params})")
y_pred_svm3 = svm3_model.predict(X_test_normal)
print("Support Vector Machine Model:")
accuracy_svm3 = round(accuracy_score(y_test_normal, y_pred_svm3), 3)
print("Accuracy: ", accuracy_svm3)
Mengevaluasi Hasil Pemodelan
model_comp = pd.DataFrame({
'Model': [
'Decision Tree',
'Naive Bayes',
'Support Vector Machine'
],
'Accuracy': [
accuracy_dt*100,
accuracy_nb*100,
accuracy_svm*100
]
})
model_comp.head()
fig, ax = plt.subplots()
bars = plt.bar(model_comp['Model'], model_comp['Accuracy'], color=['purple', 'gray', 'brown'])
plt.title("Raw")
plt.xlabel('Model')
plt.ylabel('Accuracy (%)')
plt.xticks(rotation=45, ha='right')
for bar in bars:
yval = bar.get_height()
plt.text(bar.get_x() + bar.get_width()/2, yval, round(yval, 2), ha='center', va='bottom')
plt.show()
model_comp1 = pd.DataFrame({
'Model': [
'Decision Tree',
'Naive Bayes',
'Support Vector Machine'
],
'Accuracy': [
accuracy_dt1*100,
accuracy_nb1*100,
accuracy_svm1*100
]
})
model_comp1.head()
fig, ax = plt.subplots()
bars = plt.bar(model_comp1['Model'], model_comp1['Accuracy'], color=['purple', 'gray', 'brown'])
plt.title("Over Sampling")
plt.xlabel('Model')
plt.ylabel('Accuracy (%)')
plt.xticks(rotation=45, ha='right')
for bar in bars:
yval = bar.get_height()
plt.text(bar.get_x() + bar.get_width()/2, yval, round(yval, 2), ha='center', va='bottom')
plt.show()
model_comp2 = pd.DataFrame({
'Model': [
'Decision Tree',
'Naive Bayes',
'Support Vector Machine'
],
'Accuracy': [
accuracy_dt2*100,
accuracy_nb2*100,
accuracy_svm2*100
]
})
model_comp2.head()
fig, ax = plt.subplots()
bars = plt.bar(model_comp2['Model'], model_comp2['Accuracy'], color=['purple', 'gray', 'brown'])
plt.title("Over Sampling + Normalisasi")
plt.xlabel('Model')
plt.ylabel('Accuracy (%)')
plt.xticks(rotation=45, ha='right')
for bar in bars:
yval = bar.get_height()
plt.text(bar.get_x() + bar.get_width()/2, yval, round(yval, 2), ha='center', va='bottom')
plt.show()
model_comp3 = pd.DataFrame({
'Model': [
'Decision Tree',
'Naive Bayes',
'Support Vector Machine'
],
'Accuracy': [
accuracy_dt3*100,
accuracy_nb3*100,
accuracy_svm3*100
]
})
model_comp3.head()
fig, ax = plt.subplots()
bars = plt.bar(model_comp3['Model'], model_comp3['Accuracy'], color=['purple', 'gray', 'brown'])
plt.title("Over Sampling + Normalisasi + Tunning")
plt.xlabel('Model')
plt.ylabel('Accuracy (%)')
plt.xticks(rotation=45, ha='right')
for bar in bars:
yval = bar.get_height()
plt.text(bar.get_x() + bar.get_width()/2, yval, round(yval, 2), ha='center', va='bottom')
plt.show()
model_comp_best = pd.DataFrame({
'Model': [
'Decision Tree (Over Sampling)',
'Naive Bayes (Over Sampling)',
'Support Vector Machine (Over Sampling + Normalisasi + Tunning)'
],
'Accuracy': [
accuracy_dt1*100,
accuracy_nb1*100,
accuracy_svm3*100
]
})
model_comp_best.head()
fig, ax = plt.subplots()
bars = plt.bar(model_comp_best['Model'], model_comp_best['Accuracy'], color=['orange', 'green', 'red'])
plt.title("Best Model Comparison")
plt.xlabel('Model')
plt.ylabel('Accuracy (%)')
plt.xticks(rotation=45, ha='right')
for bar in bars:
yval = bar.get_height()
plt.text(bar.get_x() + bar.get_width()/2, yval, round(yval, 2), ha='center', va='bottom')
plt.show()
Dalam penelitian ini yang bertujuan membangun model untuk heart disease, peneliti menilai efek dari berbagai teknik pemrosesan data pada performa tiga model klasifikasi: Decision Tree, Naive Bayes, dan SVM (Support Vector Machine). Empat skenario yang berbeda diuji: penggunaan data mentah (Raw), Over Sampling, Over Sampling bersama dengan Normalisasi, dan kombinasi Over Sampling, Normalisasi, serta Tunning.
Pertama, dengan data mentah, model Decision Tree mencapai akurasi 70.7%, Naive Bayes 61.1%, dan SVM 69.4%. Ini memberikan baseline untuk membandingkan efek dari teknik pemrosesan data selanjutnya.
Ketika Over Sampling diterapkan, akurasi Decision Tree meningkat menjadi 74.5%, menunjukkan peningkatan yang signifikan. Namun, tidak ada perubahan pada akurasi Naive Bayes (61.1%) dan SVM (69.4%), menunjukkan bahwa Over Sampling tidak mempengaruhi model ini dalam konteks heart disease.
Selanjutnya, ketika Normalisasi ditambahkan ke Over Sampling, semua model mengalami penurunan akurasi. Decision Tree turun menjadi 67%, Naive Bayes turun lebih lanjut menjadi 54.8%, dan SVM turun menjadi 66%. Hal ini menunjukkan bahwa kombinasi Over Sampling dan Normalisasi tidak selalu memberikan manfaat terhadap model-model ini dalam konteks heart disease.
Terakhir, ketika Tunning parameter diperkenalkan bersamaan dengan Over Sampling dan Normalisasi, terjadi perubahan yang dramatis pada model SVM, dengan peningkatan akurasi yang sangat signifikan menjadi 89.8%. Sementara itu, Decision Tree menurun ke 66.0%, dan Naive Bayes turun ke 53.3%.
Dari analisis ini, peneliti menyimpulkan bahwa Tunning parameter, ketika dikombinasikan dengan Over Sampling dan Normalisasi, sangat efektif dalam meningkatkan performa SVM untuk heart disease, tetapi tidak untuk Decision Tree dan Naive Bayes. Temuan ini menyoroti pentingnya pemilihan dan adaptasi teknik pemrosesan data yang sesuai dengan kebutuhan spesifik model dan konteks aplikasi, dalam hal ini heart disease.