Pengumpulan Data
Menelaah Data
import pandas as pd
import re
import numpy as np
import itertools
with open('hungarian.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()
Validasi Data
df.replace(-9.0, np.nan, inplace=True)
Menentukan Object 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()
columns_to_drop = ['ca', 'slope', 'thal']
df_selected = df_selected.drop(columns_to_drop, axis=1)
df_selected.isnull().sum()
meanTBPS = round(df_selected['trestbps'].dropna().astype(float).mean())
meanChol = round(df_selected['chol'].dropna().astype(float).mean())
meanFbs = round(df_selected['fbs'].dropna().astype(float).mean())
meanRestEcg = round(df_selected['restecg'].dropna().astype(float).mean())
meanThalach = round(df_selected['thalach'].dropna().astype(float).mean())
meanExang = round(df_selected['exang'].dropna().astype(float).mean())
fill_values = {
'trestbps': meanTBPS,
'chol': meanChol,
'fbs': meanFbs,
'thalach': meanThalach,
'exang': meanExang,
'restecg': meanRestEcg
}
df_clean = df_selected.fillna(value=fill_values)
df_clean.info()
df_clean.isnull().sum()
duplicate_rows = df_clean.duplicated()
df_clean[duplicate_rows]
df_clean = df_clean.drop_duplicates()
df_clean[df_clean.duplicated(keep=False)]
df_clean.corr()
import seaborn as sns
import matplotlib.pyplot as plt
corr_mat = df_clean.corr()
fig, ax = plt.subplots(figsize=(15, 10))
sns.heatmap(corr_mat, annot=True, linewidths=0.5, fmt=".3f")
Konstruksi Data
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)
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.2, random_state=42, stratify=y_smote_resampled)
Modelling
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)
})
Oversampling
KNN
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier
from xgboost import XGBClassifier
from sklearn.metrics import accuracy_score, classification_report
knn_model = KNeighborsClassifier(n_neighbors=3)
knn_model.fit(X_train, y_train)
y_pred_knn = knn_model.predict(X_test)
print("KNN Model:")
accuracy_knn_smote = round(accuracy_score(y_test, y_pred_knn), 3)
print("Accuracy: ", accuracy_knn_smote)
print("Classification Report: ")
print(classification_report(y_test, y_pred_knn))
evaluation(y_test, y_pred_knn)
cm = confusion_matrix(y_test, y_pred_knn)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title("Confussion Matrix")
plt.xlabel('True')
plt.ylabel('Predict')
plt.show()
Random Forest
rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
rf_model.fit(X_train, y_train)
y_pred_rf = rf_model.predict(X_test)
print("Random Forest Model:")
accuracy_rf_smote = round(accuracy_score(y_test, y_pred_rf), 3)
print("Accuracy: ", accuracy_rf_smote)
print("Classification Report: ")
print(classification_report(y_test, y_pred_rf))
evaluation(y_test, y_pred_rf)
cm = confusion_matrix(y_test, y_pred_rf)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title("Confussion Matrix")
plt.xlabel('True')
plt.ylabel('Predict')
plt.show()
XGBoost
xgb_model = XGBClassifier(learning_rate=0.1, n_estimators=100, random_state=42)
xgb_model.fit(X_train, y_train)
y_pred_xgb = xgb_model.predict(X_test)
print("XGBoost Model:")
accuracy_xgb_smote = round(accuracy_score(y_test, y_pred_xgb), 3)
print("Accuracy: ", accuracy_xgb_smote)
print("Classification Report: ")
print(classification_report(y_test, y_pred_xgb))
evaluation(y_test, y_pred_xgb)
cm = confusion_matrix(y_test, y_pred_xgb)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title("Confussion Matrix")
plt.xlabel('True')
plt.ylabel('Predict')
plt.show()
Oversampling + Normalisasi
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier
from xgboost import XGBClassifier
from sklearn.metrics import accuracy_score, classification_report
KNN
knn_model = KNeighborsClassifier(n_neighbors=3)
knn_model.fit(X_train_normal, y_train_normal)
y_pred_knn = knn_model.predict(X_test_normal)
print("KNN Model:")
accuracy_knn_smote_normal = round(accuracy_score(y_test_normal, y_pred_knn), 3)
print("Accuracy: ", accuracy_knn_smote_normal)
print("Classification Report: ")
print(classification_report(y_test_normal, y_pred_knn))
evaluation(y_test_normal, y_pred_knn)
cm = confusion_matrix(y_test_normal, y_pred_knn)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title("Confussion Matrix")
plt.xlabel('True')
plt.ylabel('Predict')
plt.show()
Random Forest
rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
rf_model.fit(X_train_normal, y_train_normal)
y_pred_rf = rf_model.predict(X_test_normal)
print("Random Forest Model:")
accuracy_rf_smote_normal = round(accuracy_score(y_test_normal, y_pred_rf), 3)
print("Accuracy: ", accuracy_rf_smote_normal)
print("Classification Report: ")
print(classification_report(y_test_normal, y_pred_rf))
evaluation(y_test_normal, y_pred_rf)
cm = confusion_matrix(y_test_normal, y_pred_rf)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title("Confussion Matrix")
plt.xlabel('True')
plt.ylabel('Predict')
plt.show()
XGBoost
xgb_model = XGBClassifier(learning_rate=0.1, n_estimators=100, random_state=42)
xgb_model.fit(X_train_normal, y_train_normal)
y_pred_xgb = xgb_model.predict(X_test_normal)
print("XGBoost Model:")
accuracy_xgb_smote_normal = round(accuracy_score(y_test_normal, y_pred_xgb), 3)
print("Accuracy: ", accuracy_xgb_smote_normal)
print("Classification Report: ")
print(classification_report(y_test, y_pred_xgb))
evaluation(y_test_normal, y_pred_xgb)
cm = confusion_matrix(y_test_normal, y_pred_xgb)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title("Confussion Matrix")
plt.xlabel('True')
plt.ylabel('Predict')
plt.show()
Oversampling + Normalisasi + Tunning
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier
from xgboost import XGBClassifier
from sklearn.metrics import accuracy_score, classification_report
from sklearn.model_selection import RandomizedSearchCV
KNN
knn_model = KNeighborsClassifier()
param_grid = {
"n_neighbors": range(3, 21),
"metric": ["euclidean", "manhattan", "chebyshev"],
"weights": ["uniform", "distance"],
"algorithm": ["auto", "ball_tree", "kd_tree"],
"leaf_size": range(10, 61),
}
knn_model = RandomizedSearchCV(estimator=knn_model, param_distributions=param_grid, n_iter=100, scoring="accuracy", cv=5)
knn_model.fit(X_train_normal, y_train_normal)
best_params = knn_model.best_params_
print(f"Best Parameters: {best_params}")
y_pred_knn = knn_model.predict(X_test_normal)
print("KNN Model:")
accuracy_knn_smote_normal_tunning = round(accuracy_score(y_test_normal, y_pred_knn), 3)
print("Accuracy: ", accuracy_knn_smote_normal_tunning)
print("Classification Report: ")
print(classification_report(y_test_normal, y_pred_knn))
evaluation(y_test_normal, y_pred_knn)
cm = confusion_matrix(y_test_normal, y_pred_knn)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title("Confussion Matrix")
plt.xlabel('True')
plt.ylabel('Predict')
plt.show()
Random Forest
rf_model = RandomForestClassifier()
param_grid = {
"n_estimators": [100, 200],
"max_depth": [10, 15],
"min_samples_leaf": [1, 2],
"min_samples_split": [2, 5],
"max_features": ["sqrt", "log2"],
}
rf_model = RandomizedSearchCV(rf_model, param_grid, n_iter=100, cv=5, n_jobs=-1)
rf_model.fit(X_train_normal, y_train_normal)
best_params = rf_model.best_params_
print(f"Best Parameters: {best_params})")
y_pred_rf = rf_model.predict(X_test_normal)
print("Random Forest Model:")
accuracy_rf_smote_normal_tunning = round(accuracy_score(y_test_normal, y_pred_rf), 3)
print("Accuracy: ", accuracy_rf_smote_normal_tunning)
print("Classification Report: ")
print(classification_report(y_test_normal, y_pred_rf))
evaluation(y_test_normal, y_pred_rf)
cm = confusion_matrix(y_test_normal, y_pred_rf)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title("Confussion Matrix")
plt.xlabel('True')
plt.ylabel('Predict')
plt.show()
XGBoost
xgb_model = XGBClassifier()
param_grid = {
"max_depth": [3, 5, 7],
"learning_rate": [0.01, 0.1],
"n_estimators": [100, 200],
"gamma": [0, 0.1],
"colsample_bytree": [0.7, 0.8],
}
xgb_model = RandomizedSearchCV(xgb_model, param_grid, n_iter=10, cv=5, n_jobs=-1)
xgb_model.fit(X_train_normal, y_train_normal)
best_params = xgb_model.best_params_
print(f"Best Parameters: {best_params})")
y_pred_xgb = xgb_model.predict(X_test_normal)
print("XGBoost Model:")
accuracy_xgb_smote_normal_tunning = round(accuracy_score(y_test_normal, y_pred_xgb), 3)
print("Accuracy: ", accuracy_xgb_smote_normal_tunning)
print("Classification Report: ")
print(classification_report(y_test, y_pred_xgb))
evaluation(y_test_normal, y_pred_xgb)
cm = confusion_matrix(y_test_normal, y_pred_xgb)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title("Confussion Matrix")
plt.xlabel('True')
plt.ylabel('Predict')
plt.show()
Evaluasi
import matplotlib.pyplot as plt
model_comp1 = pd.DataFrame({
'Model': [
'KNN',
'Random Forest',
'XGBoost'
],
'Accuracy': [
accuracy_knn_smote*100,
accuracy_rf_smote*100,
accuracy_xgb_smote*100
]
})
model_comp1.head()
fig, ax = plt.subplots()
bars = plt.bar(model_comp1['Model'], model_comp1['Accuracy'], color=['orange', 'green', 'red'])
plt.title("Oversampling")
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': [
'KNN',
'Random Forest',
'XGBoost'
],
'Accuracy': [
accuracy_knn_smote_normal*100,
accuracy_rf_smote_normal*100,
accuracy_xgb_smote_normal*100
]
})
model_comp2.head()
fig, ax = plt.subplots()
bars = plt.bar(model_comp2['Model'], model_comp2['Accuracy'], color=['orange', 'green', 'red'])
plt.title("Oversampling + 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': [
'KNN',
'Random Forest',
'XGBoost'
],
'Accuracy': [
accuracy_knn_smote_normal_tunning*100,
accuracy_rf_smote_normal_tunning*100,
accuracy_xgb_smote_normal_tunning*100
]
})
model_comp3.head()
fig, ax = plt.subplots()
bars = plt.bar(model_comp3['Model'], model_comp3['Accuracy'], color=['orange', 'green', 'red'])
plt.title("Oversampling + 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': [
'KNN (Oversampling + Normalisasi + Tunning)',
'Random Forest (Oversampling)',
'XGBoost (Oversampling + Normalisasi)'
],
'Accuracy': [
accuracy_knn_smote_normal_tunning*100,
accuracy_rf_smote*100,
accuracy_xgb_smote_normal*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()
Deployment
import joblib
joblib.dump(knn_model, 'knn.joblib')
Result: https://hhd.hiskia.app
Kesimpulan
Dari penelitian yang dilakukan, telah dilaksanakan pemodelan menggunakan algoritma KNN (K-Nearest Neighbors), Random Forest, dan XGBoost. Beberapa metode penanganan data diterapkan, termasuk penggunaan Random Over Sampling SMOTE untuk mengatasi data yang tidak seimbang, RandomSearchCV untuk optimasi parameter, dan Normalisasi data. Hasilnya, model KNN dengan Random Over Sampling SMOTE mencapai akurasi 75%, sementara Random Forest mencapai 92% dan XGBoost mencapai 90.4%.
Ketika model KNN menggunakan data yang telah dinormalisasi dan diproses dengan Random Over Sampling SMOTE, akurasinya meningkat menjadi 86%. Untuk Random Forest, akurasinya tetap 92%, sedangkan XGBoost mencapai 90%. Lebih lanjut, ketika dilakukan penyesuaian parameter dengan RandomSearchCV, normalisasi, dan Random Over Sampling SMOTE, akurasi model KNN meningkat menjadi 93%, sementara Random Forest turun menjadi 89%, dan XGBoost meningkat menjadi 91%.
Dari hasil ini, dapat disimpulkan bahwa penanganan data yang optimal untuk mengatasi ketidakseimbangan data adalah dengan menggabungkan metode Random Over Sampling SMOTE, tuning menggunakan RandomSearchCV, dan normalisasi data. Pendekatan ini secara signifikan meningkatkan akurasi model klasifikasi, khususnya untuk model KNN dan XGBoost. Namun, untuk model Random Forest, pendekatan ini justru menurunkan akurasinya. Secara keseluruhan, penanganan ketidakseimbangan data dengan tuning parameter, normalisasi, dan oversampling berdampak signifikan terhadap peningkatan performa model klasifikasi. Memilih model dan parameter yang tepat dapat meningkatkan akurasi dan kinerja model secara keseluruhan.